Add fastapi code

main.py

@@ -0,0 +1,84 @@
+from email.quoprimime import body_check
+from http.client import HTTPException
+from turtle import title
+from typing import Optional
+from fastapi import FastAPI, Response, status, HTTPException
+from fastapi.params import Body
+from pydantic import BaseModel
+from random import randrange
+import os
+import subprocess
+
+app = FastAPI()
+
+class Post(BaseModel):
+    title: str
+    content: str
+    published: bool = True
+    rating: Optional[int] = None
+
+    
+my_posts= [{"title": "title of post 1", "content": "contents of post 1", "id": 1},{"title": "title of post 2", "content": "contents of post 2", "id": 2}]
+
+def find_post(id):
+    for p in my_posts:
+        if p["id"] == id:
+            return p
+ 
+def find_index_post(id):
+    for i, p in enumerate(my_posts):
+        if p['id'] == id:
+            return i
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to my api!!"}
+
+@app.get("/posts")
+async def get_posts():
+    return {"data": my_posts}
+
+@app.post("/posts", status_code=status.HTTP_201_CREATED)
+async def create_posts(post: Post):
+    post_dict = post.dict()
+    post_dict['id'] = randrange(0, 1000000)
+    my_posts.append(post_dict)
+    return {"data": post_dict} 
+
+@app.get("/posts/{id}")
+async def get_post(id: int):
+    post = find_post(id)
+    if not post:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Post id {id} not found")
+    return {"post_detail": post}
+
+@app.delete("/posts/{id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_post(id: int):
+    index = find_index_post(id)
+    if index == None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Post id {id} not found")
+    my_posts.pop(index)
+    
+    return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+@app.put("/posts/{id}")
+async def update_post(id: int, post: Post):
+    index = find_index_post(id)
+    if index == None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Post id {id} not found")
+    post_dict = post.dict()
+    post_dict['id'] = id
+    my_posts[index] = post_dict
+    return {"data": post_dict}
+
+@app.get("/list")
+async def ping_host():
+    # send one packet of data to the host 
+    # this is specified by '-c 1' in the argument list 
+    outputlist = []
+    # Iterate over all the servers in the list and ping each server
+           # get the output as a string
+    # output = str(os.system(cmd))
+    output = subprocess.run(["/bin/ls", "-l"],stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    # store the output in the list
+    output2 = (f"{output.stdout}")

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"

venv/bin/activate

@@ -0,0 +1,69 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+deactivate () {
+    # reset old environment variables
+    if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then
+        PATH="${_OLD_VIRTUAL_PATH:-}"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then
+        PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # This should detect bash and zsh, which have a hash command that must
+    # be called to get it to forget past commands.  Without forgetting
+    # past commands the $PATH changes we made may not be respected
+    if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+        hash -r 2> /dev/null
+    fi
+
+    if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then
+        PS1="${_OLD_VIRTUAL_PS1:-}"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1:-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV="/home/toverhag/Documents/gitrepos/fastapi_test/venv"
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/bin:$PATH"
+export PATH
+
+# unset PYTHONHOME if set
+# this will fail if PYTHONHOME is set to the empty string (which is bad anyway)
+# could use `if (set -u; : $PYTHONHOME) ;` in bash
+if [ -n "${PYTHONHOME:-}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1:-}"
+    PS1="(venv) ${PS1:-}"
+    export PS1
+    VIRTUAL_ENV_PROMPT="(venv) "
+    export VIRTUAL_ENV_PROMPT
+fi
+
+# This should detect bash and zsh, which have a hash command that must
+# be called to get it to forget past commands.  Without forgetting
+# past commands the $PATH changes we made may not be respected
+if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    hash -r 2> /dev/null
+fi

venv/bin/activate.csh

@@ -0,0 +1,26 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+# Ported to Python 3.3 venv by Andrew Svetlov <andrew.svetlov@gmail.com>
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV "/home/toverhag/Documents/gitrepos/fastapi_test/venv"
+
+set _OLD_VIRTUAL_PATH="$PATH"
+setenv PATH "$VIRTUAL_ENV/bin:$PATH"
+
+
+set _OLD_VIRTUAL_PROMPT="$prompt"
+
+if (! "$?VIRTUAL_ENV_DISABLE_PROMPT") then
+    set prompt = "(venv) $prompt"
+    setenv VIRTUAL_ENV_PROMPT "(venv) "
+endif
+
+alias pydoc python -m pydoc
+
+rehash

venv/bin/activate.fish

@@ -0,0 +1,66 @@
+# This file must be used with "source <venv>/bin/activate.fish" *from fish*
+# (https://fishshell.com/); you cannot run it directly.
+
+function deactivate  -d "Exit virtual environment and return to normal shell environment"
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        set -gx PATH $_OLD_VIRTUAL_PATH
+        set -e _OLD_VIRTUAL_PATH
+    end
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME $_OLD_VIRTUAL_PYTHONHOME
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+        functions -e fish_prompt
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+        functions -c _old_fish_prompt fish_prompt
+        functions -e _old_fish_prompt
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+    if test "$argv[1]" != "nondestructive"
+        # Self-destruct!
+        functions -e deactivate
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV "/home/toverhag/Documents/gitrepos/fastapi_test/venv"
+
+set -gx _OLD_VIRTUAL_PATH $PATH
+set -gx PATH "$VIRTUAL_ENV/bin" $PATH
+
+# Unset PYTHONHOME if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # fish uses a function instead of an env var to generate the prompt.
+
+    # Save the current fish_prompt function as the function _old_fish_prompt.
+    functions -c fish_prompt _old_fish_prompt
+
+    # With the original prompt function renamed, we can override with our own.
+    function fish_prompt
+        # Save the return status of the last command.
+        set -l old_status $status
+
+        # Output the venv prompt; color taken from the blue of the Python logo.
+        printf "%s%s%s" (set_color 4B8BBE) "(venv) " (set_color normal)
+
+        # Restore the return status of the previous command.
+        echo "exit $old_status" | .
+        # Output the original/"old" prompt.
+        _old_fish_prompt
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+    set -gx VIRTUAL_ENV_PROMPT "(venv) "
+end

venv/bin/dotenv

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

venv/bin/email_validator

@@ -0,0 +1,8 @@
+#!/home/toverhag/Documents/gitrepos/fastapi_test/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from email_validator import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/httpx

@@ -0,0 +1,8 @@
+#!/home/toverhag/Documents/gitrepos/fastapi_test/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from httpx import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pip

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

venv/bin/pip3

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

venv/bin/pip3.10

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

venv/bin/pip3.11

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

venv/bin/python

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

venv/bin/python3

@@ -0,0 +1 @@
+python

venv/bin/python3.11

@@ -0,0 +1 @@
+python

venv/bin/uvicorn

@@ -0,0 +1,8 @@
+#!/home/toverhag/Documents/gitrepos/fastapi_test/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from uvicorn.main import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/watchfiles

@@ -0,0 +1,8 @@
+#!/home/toverhag/Documents/gitrepos/fastapi_test/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from watchfiles.cli import cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cli())

venv/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/INSTALLER

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

venv/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/LICENSE.rst

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

venv/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/METADATA

@@ -0,0 +1,113 @@
+Metadata-Version: 2.1
+Name: Jinja2
+Version: 3.1.2
+Summary: A very fast and expressive template engine.
+Home-page: https://palletsprojects.com/p/jinja/
+Author: Armin Ronacher
+Author-email: armin.ronacher@active-4.com
+Maintainer: Pallets
+Maintainer-email: contact@palletsprojects.com
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://jinja.palletsprojects.com/
+Project-URL: Changes, https://jinja.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/jinja/
+Project-URL: Issue Tracker, https://github.com/pallets/jinja/issues/
+Project-URL: Twitter, https://twitter.com/PalletsTeam
+Project-URL: Chat, https://discord.gg/pallets
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: MarkupSafe (>=2.0)
+Provides-Extra: i18n
+Requires-Dist: Babel (>=2.7) ; extra == 'i18n'
+
+Jinja
+=====
+
+Jinja is a fast, expressive, extensible templating engine. Special
+placeholders in the template allow writing code similar to Python
+syntax. Then the template is passed data to render the final document.
+
+It includes:
+
+-   Template inheritance and inclusion.
+-   Define and import macros within templates.
+-   HTML templates can use autoescaping to prevent XSS from untrusted
+    user input.
+-   A sandboxed environment can safely render untrusted templates.
+-   AsyncIO support for generating templates and calling async
+    functions.
+-   I18N support with Babel.
+-   Templates are compiled to optimized Python code just-in-time and
+    cached, or can be compiled ahead-of-time.
+-   Exceptions point to the correct line in templates to make debugging
+    easier.
+-   Extensible filters, tests, functions, and even syntax.
+
+Jinja's philosophy is that while application logic belongs in Python if
+possible, it shouldn't make the template designer's job difficult by
+restricting functionality too much.
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    $ pip install -U Jinja2
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+In A Nutshell
+-------------
+
+.. code-block:: jinja
+
+    {% extends "base.html" %}
+    {% block title %}Members{% endblock %}
+    {% block content %}
+      <ul>
+      {% for user in users %}
+        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
+      {% endfor %}
+      </ul>
+    {% endblock %}
+
+
+Donate
+------
+
+The Pallets organization develops and supports Jinja and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, `please
+donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://jinja.palletsprojects.com/
+-   Changes: https://jinja.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/Jinja2/
+-   Source Code: https://github.com/pallets/jinja/
+-   Issue Tracker: https://github.com/pallets/jinja/issues/
+-   Website: https://palletsprojects.com/p/jinja/
+-   Twitter: https://twitter.com/PalletsTeam
+-   Chat: https://discord.gg/pallets
+
+

venv/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/RECORD

@@ -0,0 +1,58 @@
+Jinja2-3.1.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+Jinja2-3.1.2.dist-info/LICENSE.rst,sha256=O0nc7kEF6ze6wQ-vG-JgQI_oXSUrjp3y4JefweCUQ3s,1475
+Jinja2-3.1.2.dist-info/METADATA,sha256=PZ6v2SIidMNixR7MRUX9f7ZWsPwtXanknqiZUmRbh4U,3539
+Jinja2-3.1.2.dist-info/RECORD,,
+Jinja2-3.1.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+Jinja2-3.1.2.dist-info/entry_points.txt,sha256=zRd62fbqIyfUpsRtU7EVIFyiu1tPwfgO7EvPErnxgTE,59
+Jinja2-3.1.2.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7
+jinja2/__init__.py,sha256=8vGduD8ytwgD6GDSqpYc2m3aU-T7PKOAddvVXgGr_Fs,1927
+jinja2/__pycache__/__init__.cpython-311.pyc,,
+jinja2/__pycache__/_identifier.cpython-311.pyc,,
+jinja2/__pycache__/async_utils.cpython-311.pyc,,
+jinja2/__pycache__/bccache.cpython-311.pyc,,
+jinja2/__pycache__/compiler.cpython-311.pyc,,
+jinja2/__pycache__/constants.cpython-311.pyc,,
+jinja2/__pycache__/debug.cpython-311.pyc,,
+jinja2/__pycache__/defaults.cpython-311.pyc,,
+jinja2/__pycache__/environment.cpython-311.pyc,,
+jinja2/__pycache__/exceptions.cpython-311.pyc,,
+jinja2/__pycache__/ext.cpython-311.pyc,,
+jinja2/__pycache__/filters.cpython-311.pyc,,
+jinja2/__pycache__/idtracking.cpython-311.pyc,,
+jinja2/__pycache__/lexer.cpython-311.pyc,,
+jinja2/__pycache__/loaders.cpython-311.pyc,,
+jinja2/__pycache__/meta.cpython-311.pyc,,
+jinja2/__pycache__/nativetypes.cpython-311.pyc,,
+jinja2/__pycache__/nodes.cpython-311.pyc,,
+jinja2/__pycache__/optimizer.cpython-311.pyc,,
+jinja2/__pycache__/parser.cpython-311.pyc,,
+jinja2/__pycache__/runtime.cpython-311.pyc,,
+jinja2/__pycache__/sandbox.cpython-311.pyc,,
+jinja2/__pycache__/tests.cpython-311.pyc,,
+jinja2/__pycache__/utils.cpython-311.pyc,,
+jinja2/__pycache__/visitor.cpython-311.pyc,,
+jinja2/_identifier.py,sha256=_zYctNKzRqlk_murTNlzrju1FFJL7Va_Ijqqd7ii2lU,1958
+jinja2/async_utils.py,sha256=dHlbTeaxFPtAOQEYOGYh_PHcDT0rsDaUJAFDl_0XtTg,2472
+jinja2/bccache.py,sha256=mhz5xtLxCcHRAa56azOhphIAe19u1we0ojifNMClDio,14061
+jinja2/compiler.py,sha256=Gs-N8ThJ7OWK4-reKoO8Wh1ZXz95MVphBKNVf75qBr8,72172
+jinja2/constants.py,sha256=GMoFydBF_kdpaRKPoM5cl5MviquVRLVyZtfp5-16jg0,1433
+jinja2/debug.py,sha256=iWJ432RadxJNnaMOPrjIDInz50UEgni3_HKuFXi2vuQ,6299
+jinja2/defaults.py,sha256=boBcSw78h-lp20YbaXSJsqkAI2uN_mD_TtCydpeq5wU,1267
+jinja2/environment.py,sha256=6uHIcc7ZblqOMdx_uYNKqRnnwAF0_nzbyeMP9FFtuh4,61349
+jinja2/exceptions.py,sha256=ioHeHrWwCWNaXX1inHmHVblvc4haO7AXsjCp3GfWvx0,5071
+jinja2/ext.py,sha256=ivr3P7LKbddiXDVez20EflcO3q2aHQwz9P_PgWGHVqE,31502
+jinja2/filters.py,sha256=9js1V-h2RlyW90IhLiBGLM2U-k6SCy2F4BUUMgB3K9Q,53509
+jinja2/idtracking.py,sha256=GfNmadir4oDALVxzn3DL9YInhJDr69ebXeA2ygfuCGA,10704
+jinja2/lexer.py,sha256=DW2nX9zk-6MWp65YR2bqqj0xqCvLtD-u9NWT8AnFRxQ,29726
+jinja2/loaders.py,sha256=BfptfvTVpClUd-leMkHczdyPNYFzp_n7PKOJ98iyHOg,23207
+jinja2/meta.py,sha256=GNPEvifmSaU3CMxlbheBOZjeZ277HThOPUTf1RkppKQ,4396
+jinja2/nativetypes.py,sha256=DXgORDPRmVWgy034H0xL8eF7qYoK3DrMxs-935d0Fzk,4226
+jinja2/nodes.py,sha256=i34GPRAZexXMT6bwuf5SEyvdmS-bRCy9KMjwN5O6pjk,34550
+jinja2/optimizer.py,sha256=tHkMwXxfZkbfA1KmLcqmBMSaz7RLIvvItrJcPoXTyD8,1650
+jinja2/parser.py,sha256=nHd-DFHbiygvfaPtm9rcQXJChZG7DPsWfiEsqfwKerY,39595
+jinja2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jinja2/runtime.py,sha256=5CmD5BjbEJxSiDNTFBeKCaq8qU4aYD2v6q2EluyExms,33476
+jinja2/sandbox.py,sha256=Y0xZeXQnH6EX5VjaV2YixESxoepnRbW_3UeQosaBU3M,14584
+jinja2/tests.py,sha256=Am5Z6Lmfr2XaH_npIfJJ8MdXtWsbLjMULZJulTAj30E,5905
+jinja2/utils.py,sha256=u9jXESxGn8ATZNVolwmkjUVu4SA-tLgV0W7PcSfPfdQ,23965
+jinja2/visitor.py,sha256=MH14C6yq24G_KVtWzjwaI7Wg14PCJIYlWW1kpkxYak0,3568

venv/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/WHEEL

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

venv/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[babel.extractors]
+jinja2 = jinja2.ext:babel_extract[i18n]

venv/lib/python3.11/site-packages/Jinja2-3.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+jinja2

venv/lib/python3.11/site-packages/MarkupSafe-2.1.1-py3.11.egg-info/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.1
+Name: MarkupSafe
+Version: 2.1.1
+Summary: Safely add untrusted strings to HTML/XML markup.
+Home-page: https://palletsprojects.com/p/markupsafe/
+Author: Armin Ronacher
+Author-email: armin.ronacher@active-4.com
+Maintainer: Pallets
+Maintainer-email: contact@palletsprojects.com
+License: BSD-3-Clause
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://markupsafe.palletsprojects.com/
+Project-URL: Changes, https://markupsafe.palletsprojects.com/changes/
+Project-URL: Source Code, https://github.com/pallets/markupsafe/
+Project-URL: Issue Tracker, https://github.com/pallets/markupsafe/issues/
+Project-URL: Twitter, https://twitter.com/PalletsTeam
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+
+MarkupSafe
+==========
+
+MarkupSafe implements a text object that escapes characters so it is
+safe to use in HTML and XML. Characters that have special meanings are
+replaced so that they display as the actual characters. This mitigates
+injection attacks, meaning untrusted user input can safely be displayed
+on a page.
+
+
+Installing
+----------
+
+Install and update using `pip`_:
+
+.. code-block:: text
+
+    pip install -U MarkupSafe
+
+.. _pip: https://pip.pypa.io/en/stable/getting-started/
+
+
+Examples
+--------
+
+.. code-block:: pycon
+
+    >>> from markupsafe import Markup, escape
+
+    >>> # escape replaces special characters and wraps in Markup
+    >>> escape("<script>alert(document.cookie);</script>")
+    Markup('&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
+
+    >>> # wrap in Markup to mark text "safe" and prevent escaping
+    >>> Markup("<strong>Hello</strong>")
+    Markup('<strong>hello</strong>')
+
+    >>> escape(Markup("<strong>Hello</strong>"))
+    Markup('<strong>hello</strong>')
+
+    >>> # Markup is a str subclass
+    >>> # methods and operators escape their arguments
+    >>> template = Markup("Hello <em>{name}</em>")
+    >>> template.format(name='"World"')
+    Markup('Hello <em>&#34;World&#34;</em>')
+
+
+Donate
+------
+
+The Pallets organization develops and supports MarkupSafe and other
+popular packages. In order to grow the community of contributors and
+users, and allow the maintainers to devote more time to the projects,
+`please donate today`_.
+
+.. _please donate today: https://palletsprojects.com/donate
+
+
+Links
+-----
+
+-   Documentation: https://markupsafe.palletsprojects.com/
+-   Changes: https://markupsafe.palletsprojects.com/changes/
+-   PyPI Releases: https://pypi.org/project/MarkupSafe/
+-   Source Code: https://github.com/pallets/markupsafe/
+-   Issue Tracker: https://github.com/pallets/markupsafe/issues/
+-   Website: https://palletsprojects.com/p/markupsafe/
+-   Twitter: https://twitter.com/PalletsTeam
+-   Chat: https://discord.gg/pallets

venv/lib/python3.11/site-packages/MarkupSafe-2.1.1-py3.11.egg-info/SOURCES.txt

@@ -0,0 +1,34 @@
+CHANGES.rst
+LICENSE.rst
+MANIFEST.in
+README.rst
+setup.cfg
+setup.py
+tox.ini
+docs/Makefile
+docs/changes.rst
+docs/conf.py
+docs/escaping.rst
+docs/formatting.rst
+docs/html.rst
+docs/index.rst
+docs/license.rst
+docs/make.bat
+requirements/dev.txt
+requirements/docs.txt
+requirements/tests.txt
+requirements/typing.txt
+src/MarkupSafe.egg-info/PKG-INFO
+src/MarkupSafe.egg-info/SOURCES.txt
+src/MarkupSafe.egg-info/dependency_links.txt
+src/MarkupSafe.egg-info/top_level.txt
+src/markupsafe/__init__.py
+src/markupsafe/_native.py
+src/markupsafe/_speedups.c
+src/markupsafe/_speedups.pyi
+src/markupsafe/py.typed
+tests/conftest.py
+tests/test_escape.py
+tests/test_exception_custom_html.py
+tests/test_leak.py
+tests/test_markupsafe.py

venv/lib/python3.11/site-packages/MarkupSafe-2.1.1-py3.11.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

venv/lib/python3.11/site-packages/MarkupSafe-2.1.1-py3.11.egg-info/installed-files.txt

@@ -0,0 +1,12 @@
+../markupsafe/__init__.py
+../markupsafe/__pycache__/__init__.cpython-311.pyc
+../markupsafe/__pycache__/_native.cpython-311.pyc
+../markupsafe/_native.py
+../markupsafe/_speedups.c
+../markupsafe/_speedups.cpython-311-x86_64-linux-gnu.so
+../markupsafe/_speedups.pyi
+../markupsafe/py.typed
+PKG-INFO
+SOURCES.txt
+dependency_links.txt
+top_level.txt

venv/lib/python3.11/site-packages/MarkupSafe-2.1.1-py3.11.egg-info/top_level.txt

@@ -0,0 +1 @@
+markupsafe

venv/lib/python3.11/site-packages/PyYAML-6.0.dist-info/INSTALLER

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

venv/lib/python3.11/site-packages/PyYAML-6.0.dist-info/LICENSE

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

venv/lib/python3.11/site-packages/PyYAML-6.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.1
+Name: PyYAML
+Version: 6.0
+Summary: YAML parser and emitter for Python
+Home-page: https://pyyaml.org/
+Download-URL: https://pypi.org/project/PyYAML/
+Author: Kirill Simonov
+Author-email: xi@resolvent.net
+License: MIT
+Project-URL: Bug Tracker, https://github.com/yaml/pyyaml/issues
+Project-URL: CI, https://github.com/yaml/pyyaml/actions
+Project-URL: Documentation, https://pyyaml.org/wiki/PyYAMLDocumentation
+Project-URL: Mailing lists, http://lists.sourceforge.net/lists/listinfo/yaml-core
+Project-URL: Source Code, https://github.com/yaml/pyyaml
+Platform: Any
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Cython
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing :: Markup
+Requires-Python: >=3.6
+License-File: LICENSE
+
+YAML is a data serialization format designed for human readability
+and interaction with scripting languages.  PyYAML is a YAML parser
+and emitter for Python.
+
+PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
+support, capable extension API, and sensible error messages.  PyYAML
+supports standard YAML tags and provides Python-specific tags that
+allow to represent an arbitrary Python object.
+
+PyYAML is applicable for a broad range of tasks from complex
+configuration files to object serialization and persistence.

venv/lib/python3.11/site-packages/PyYAML-6.0.dist-info/RECORD

@@ -0,0 +1,43 @@
+PyYAML-6.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyYAML-6.0.dist-info/LICENSE,sha256=jTko-dxEkP1jVwfLiOsmvXZBAqcoKVQwfT5RZ6V36KQ,1101
+PyYAML-6.0.dist-info/METADATA,sha256=2SKnLeliGx_ihH8L6t35ImKgvwm6PojvuQ71XL14YL4,2056
+PyYAML-6.0.dist-info/RECORD,,
+PyYAML-6.0.dist-info/WHEEL,sha256=MXkSmZj-ucMvJEZe-5F9uGaWQfgqj_gRjwLyMfC10Vs,152
+PyYAML-6.0.dist-info/top_level.txt,sha256=rpj0IVMTisAjh_1vG3Ccf9v5jpCQwAz6cD1IVU5ZdhQ,11
+_yaml/__init__.py,sha256=04Ae_5osxahpJHa3XBZUAf4wi6XX32gR8D6X6p64GEA,1402
+_yaml/__pycache__/__init__.cpython-311.pyc,,
+yaml/__init__.py,sha256=NDS7S8XgA72-hY6LRmGzUWTPvzGzjWVrWk-OGA-77AA,12309
+yaml/__pycache__/__init__.cpython-311.pyc,,
+yaml/__pycache__/composer.cpython-311.pyc,,
+yaml/__pycache__/constructor.cpython-311.pyc,,
+yaml/__pycache__/cyaml.cpython-311.pyc,,
+yaml/__pycache__/dumper.cpython-311.pyc,,
+yaml/__pycache__/emitter.cpython-311.pyc,,
+yaml/__pycache__/error.cpython-311.pyc,,
+yaml/__pycache__/events.cpython-311.pyc,,
+yaml/__pycache__/loader.cpython-311.pyc,,
+yaml/__pycache__/nodes.cpython-311.pyc,,
+yaml/__pycache__/parser.cpython-311.pyc,,
+yaml/__pycache__/reader.cpython-311.pyc,,
+yaml/__pycache__/representer.cpython-311.pyc,,
+yaml/__pycache__/resolver.cpython-311.pyc,,
+yaml/__pycache__/scanner.cpython-311.pyc,,
+yaml/__pycache__/serializer.cpython-311.pyc,,
+yaml/__pycache__/tokens.cpython-311.pyc,,
+yaml/_yaml.cpython-311-x86_64-linux-gnu.so,sha256=f3kteIqrZS8TXy2O-PcBs9UHQGj-_m4RURnRDaRAoE0,2504000
+yaml/composer.py,sha256=_Ko30Wr6eDWUeUpauUGT3Lcg9QPBnOPVlTnIMRGJ9FM,4883
+yaml/constructor.py,sha256=kNgkfaeLUkwQYY_Q6Ff1Tz2XVw_pG1xVE9Ak7z-viLA,28639
+yaml/cyaml.py,sha256=6ZrAG9fAYvdVe2FK_w0hmXoG7ZYsoYUwapG8CiC72H0,3851
+yaml/dumper.py,sha256=PLctZlYwZLp7XmeUdwRuv4nYOZ2UBnDIUy8-lKfLF-o,2837
+yaml/emitter.py,sha256=jghtaU7eFwg31bG0B7RZea_29Adi9CKmXq_QjgQpCkQ,43006
+yaml/error.py,sha256=Ah9z-toHJUbE9j-M8YpxgSRM5CgLCcwVzJgLLRF2Fxo,2533
+yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445
+yaml/loader.py,sha256=UVa-zIqmkFSCIYq_PgSGm4NSJttHY2Rf_zQ4_b1fHN0,2061
+yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440
+yaml/parser.py,sha256=ilWp5vvgoHFGzvOZDItFoGjD6D42nhlZrZyjAwa0oJo,25495
+yaml/reader.py,sha256=0dmzirOiDG4Xo41RnuQS7K9rkY3xjHiVasfDMNTqCNw,6794
+yaml/representer.py,sha256=IuWP-cAW9sHKEnS0gCqSa894k1Bg4cgTxaDwIcbRQ-Y,14190
+yaml/resolver.py,sha256=9L-VYfm4mWHxUD1Vg4X7rjDRK_7VZd6b92wzq7Y2IKY,9004
+yaml/scanner.py,sha256=YEM3iLZSaQwXcQRg2l2R4MdT0zGP2F9eHkKGKnHyWQY,51279
+yaml/serializer.py,sha256=ChuFgmhU01hj4xgI8GaKv6vfM2Bujwa9i7d2FAHj7cA,4165
+yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573

venv/lib/python3.11/site-packages/PyYAML-6.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_17_x86_64
+Tag: cp311-cp311-manylinux2014_x86_64
+

venv/lib/python3.11/site-packages/PyYAML-6.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_yaml
+yaml

venv/lib/python3.11/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,222 @@
+# don't import any costly modules
+import sys
+import os
+
+
+is_pypy = '__pypy__' in sys.builtin_module_names
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    if is_pypy and sys.version_info < (3, 7):
+        # PyPy for 3.6 unconditionally imports distutils, so bypass the warning
+        # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns):
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self):
+        insert_shim()
+
+    def __exit__(self, exc, value, tb):
+        remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass

venv/lib/python3.11/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

venv/lib/python3.11/site-packages/_yaml/__init__.py

@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''

venv/lib/python3.11/site-packages/anyio-3.6.2.dist-info/INSTALLER

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

venv/lib/python3.11/site-packages/anyio-3.6.2.dist-info/LICENSE

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

venv/lib/python3.11/site-packages/anyio-3.6.2.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.1
+Name: anyio
+Version: 3.6.2
+Summary: High level compatibility layer for multiple asynchronous event loop implementations
+Author: Alex Grönholm
+Author-email: alex.gronholm@nextday.fi
+License: MIT
+Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/
+Project-URL: Source code, https://github.com/agronholm/anyio
+Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Framework :: AnyIO
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.6.2
+License-File: LICENSE
+Requires-Dist: idna (>=2.8)
+Requires-Dist: sniffio (>=1.1)
+Requires-Dist: contextvars ; python_version < "3.7"
+Requires-Dist: dataclasses ; python_version < "3.7"
+Requires-Dist: typing-extensions ; python_version < "3.8"
+Provides-Extra: doc
+Requires-Dist: packaging ; extra == 'doc'
+Requires-Dist: sphinx-rtd-theme ; extra == 'doc'
+Requires-Dist: sphinx-autodoc-typehints (>=1.2.0) ; extra == 'doc'
+Provides-Extra: test
+Requires-Dist: coverage[toml] (>=4.5) ; extra == 'test'
+Requires-Dist: hypothesis (>=4.0) ; extra == 'test'
+Requires-Dist: pytest (>=7.0) ; extra == 'test'
+Requires-Dist: pytest-mock (>=3.6.1) ; extra == 'test'
+Requires-Dist: trustme ; extra == 'test'
+Requires-Dist: contextlib2 ; (python_version < "3.7") and extra == 'test'
+Requires-Dist: uvloop (<0.15) ; (python_version < "3.7" and (platform_python_implementation == "CPython" and platform_system != "Windows")) and extra == 'test'
+Requires-Dist: mock (>=4) ; (python_version < "3.8") and extra == 'test'
+Requires-Dist: uvloop (>=0.15) ; (python_version >= "3.7" and (platform_python_implementation == "CPython" and platform_system != "Windows")) and extra == 'test'
+Provides-Extra: trio
+Requires-Dist: trio (<0.22,>=0.16) ; extra == 'trio'
+
+.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
+  :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
+  :alt: Build Status
+.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master
+  :target: https://coveralls.io/github/agronholm/anyio?branch=master
+  :alt: Code Coverage
+.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest
+  :target: https://anyio.readthedocs.io/en/latest/?badge=latest
+  :alt: Documentation
+.. image:: https://badges.gitter.im/gitterHQ/gitter.svg
+  :target: https://gitter.im/python-trio/AnyIO
+  :alt: Gitter chat
+
+AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or
+trio_. It implements trio-like `structured concurrency`_ (SC) on top of asyncio, and works in harmony
+with the native SC of trio itself.
+
+Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or
+trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full
+refactoring necessary. It will blend in with native libraries of your chosen backend.
+
+Documentation
+-------------
+
+View full documentation at: https://anyio.readthedocs.io/
+
+Features
+--------
+
+AnyIO offers the following functionality:
+
+* Task groups (nurseries_ in trio terminology)
+* High level networking (TCP, UDP and UNIX sockets)
+
+  * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python
+    3.8)
+  * async/await style UDP sockets (unlike asyncio where you still have to use Transports and
+    Protocols)
+
+* A versatile API for byte streams and object streams
+* Inter-task synchronization and communication (locks, conditions, events, semaphores, object
+  streams)
+* Worker threads
+* Subprocesses
+* Asynchronous file I/O (using worker threads)
+* Signal handling
+
+AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures.
+It even works with the popular Hypothesis_ library.
+
+.. _asyncio: https://docs.python.org/3/library/asyncio.html
+.. _trio: https://github.com/python-trio/trio
+.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency
+.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning
+.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs
+.. _pytest: https://docs.pytest.org/en/latest/
+.. _Hypothesis: https://hypothesis.works/

venv/lib/python3.11/site-packages/anyio-3.6.2.dist-info/RECORD

@@ -0,0 +1,82 @@
+anyio-3.6.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+anyio-3.6.2.dist-info/LICENSE,sha256=U2GsncWPLvX9LpsJxoKXwX8ElQkJu8gCO9uC6s8iwrA,1081
+anyio-3.6.2.dist-info/METADATA,sha256=30LcHBTF6U8AO5jpASPwKp9dqHL3t0MuCADwSLWMFrc,4660
+anyio-3.6.2.dist-info/RECORD,,
+anyio-3.6.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+anyio-3.6.2.dist-info/entry_points.txt,sha256=_d6Yu6uiaZmNe0CydowirE9Cmg7zUL2g08tQpoS3Qvc,39
+anyio-3.6.2.dist-info/top_level.txt,sha256=QglSMiWX8_5dpoVAEIHdEYzvqFMdSYWmCj6tYw2ITkQ,6
+anyio/__init__.py,sha256=M2R8dk6L5gL5lXHArzpSfEn2oH5jMyUKhzyrkRiv2AM,4037
+anyio/__pycache__/__init__.cpython-311.pyc,,
+anyio/__pycache__/from_thread.cpython-311.pyc,,
+anyio/__pycache__/lowlevel.cpython-311.pyc,,
+anyio/__pycache__/pytest_plugin.cpython-311.pyc,,
+anyio/__pycache__/to_process.cpython-311.pyc,,
+anyio/__pycache__/to_thread.cpython-311.pyc,,
+anyio/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_backends/__pycache__/__init__.cpython-311.pyc,,
+anyio/_backends/__pycache__/_asyncio.cpython-311.pyc,,
+anyio/_backends/__pycache__/_trio.cpython-311.pyc,,
+anyio/_backends/_asyncio.py,sha256=ZJDvRwfS4wv9WWcqWledNJyl8hx8A8-m9-gSKAJ6nBM,69238
+anyio/_backends/_trio.py,sha256=CebCaqr8Szi6uCnUzwtBRLfUitR5OnDT_wfH-KiqvBQ,29696
+anyio/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_core/__pycache__/__init__.cpython-311.pyc,,
+anyio/_core/__pycache__/_compat.cpython-311.pyc,,
+anyio/_core/__pycache__/_eventloop.cpython-311.pyc,,
+anyio/_core/__pycache__/_exceptions.cpython-311.pyc,,
+anyio/_core/__pycache__/_fileio.cpython-311.pyc,,
+anyio/_core/__pycache__/_resources.cpython-311.pyc,,
+anyio/_core/__pycache__/_signals.cpython-311.pyc,,
+anyio/_core/__pycache__/_sockets.cpython-311.pyc,,
+anyio/_core/__pycache__/_streams.cpython-311.pyc,,
+anyio/_core/__pycache__/_subprocesses.cpython-311.pyc,,
+anyio/_core/__pycache__/_synchronization.cpython-311.pyc,,
+anyio/_core/__pycache__/_tasks.cpython-311.pyc,,
+anyio/_core/__pycache__/_testing.cpython-311.pyc,,
+anyio/_core/__pycache__/_typedattr.cpython-311.pyc,,
+anyio/_core/_compat.py,sha256=X99W70r-O-JLdkKNtbddcIY5H2Nyg3Nk34oUYE9WZRs,5790
+anyio/_core/_eventloop.py,sha256=DRn_hy679LtsJFsPX7dXjDv72bLtSFkTnWY9WVVfgCQ,4108
+anyio/_core/_exceptions.py,sha256=1wqraNldZroYkoyB0HZStAruz_7yDCBaW-4zYwsKj8s,2904
+anyio/_core/_fileio.py,sha256=au82uZXZX4fia8EoZq_E-JDwZFKe6ZtI0J6IkxK8FmQ,18298
+anyio/_core/_resources.py,sha256=M_uN-90N8eSsWuvo-0xluWU_OG2BTyccAgsQ7XtHxzs,399
+anyio/_core/_signals.py,sha256=D4btJN527tAADspKBeNKaCds-ZcEZJP8LWM_MjVuQRA,827
+anyio/_core/_sockets.py,sha256=fW_Cbg6kfw4xgYuVuWbcWrAYspOcDSEjwxVATMzf2fo,19820
+anyio/_core/_streams.py,sha256=gjT5xChJ1OoV8nNinljSv1yW4nqUS-QzZzIydQz3exQ,1494
+anyio/_core/_subprocesses.py,sha256=pcchMI2OII0QSjiVxRiTEz4M0B7TlQPzGurfCuka-xc,5049
+anyio/_core/_synchronization.py,sha256=xOOG4hF9783N6E2IcD3YKiukguA5bPrj6BodDsKNaJY,16822
+anyio/_core/_tasks.py,sha256=ebGLjHvwL6I9aGyPwvCig1drebSVYFzvY3pnN3TsB4o,5273
+anyio/_core/_testing.py,sha256=VZka_yebIhJ6mJ6Vo_ilO3Nbz53ieqg0WBijwciMwdY,2196
+anyio/_core/_typedattr.py,sha256=k5-wBvMlDlKHIpn18INVnXAlGwI3CrAvPmWoceHjnOQ,2534
+anyio/abc/__init__.py,sha256=hMa47CMs5O1twC2bBcSbzwX-3Q08BAgAPTRekQobb3E,2123
+anyio/abc/__pycache__/__init__.cpython-311.pyc,,
+anyio/abc/__pycache__/_resources.cpython-311.pyc,,
+anyio/abc/__pycache__/_sockets.cpython-311.pyc,,
+anyio/abc/__pycache__/_streams.cpython-311.pyc,,
+anyio/abc/__pycache__/_subprocesses.cpython-311.pyc,,
+anyio/abc/__pycache__/_tasks.cpython-311.pyc,,
+anyio/abc/__pycache__/_testing.cpython-311.pyc,,
+anyio/abc/_resources.py,sha256=js737mWPG6IW0fH8W4Tz9eNWLztse7dKxEC61z934Vk,752
+anyio/abc/_sockets.py,sha256=i1VdcJTLAuRlYeZoL6s5RBSWbX62Cu6ln5YZBL2YrWk,5754
+anyio/abc/_streams.py,sha256=0g70fhKAzbnK0KKmWwRgwmKdApBwduAcVj4TpjSzjzU,6501
+anyio/abc/_subprocesses.py,sha256=iREP_YQ91it88lDU4XIcI3HZ9HUvV5UmjQk_sSPonrw,2071
+anyio/abc/_tasks.py,sha256=mQQd1DANqpySKyehVVPdMfi_UEG49zZUJpt5blunOjg,3119
+anyio/abc/_testing.py,sha256=ifKCUPzcQdHAEGO-weu2GQvzjMQPPIWO24mQ0z6zkdU,1928
+anyio/from_thread.py,sha256=nSq6mafYMqwxKmzdJyISg8cp-AyBj9rxZPMt_b7klSM,16497
+anyio/lowlevel.py,sha256=W4ydshns7f86YuSESFc2igTf46AWMXnGPQGsY_Esl2E,4679
+anyio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/pytest_plugin.py,sha256=kWj2B8BJehePJd1sztRBmJBRh8O4hk1oGSYQRlX5Gr8,5134
+anyio/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/streams/__pycache__/__init__.cpython-311.pyc,,
+anyio/streams/__pycache__/buffered.cpython-311.pyc,,
+anyio/streams/__pycache__/file.cpython-311.pyc,,
+anyio/streams/__pycache__/memory.cpython-311.pyc,,
+anyio/streams/__pycache__/stapled.cpython-311.pyc,,
+anyio/streams/__pycache__/text.cpython-311.pyc,,
+anyio/streams/__pycache__/tls.cpython-311.pyc,,
+anyio/streams/buffered.py,sha256=FegOSO4Xcxa5SaDfU1A3ZkTTxaPrv6G435Y_giZ8k44,4437
+anyio/streams/file.py,sha256=pujJ-m6BX-gOLnVoZwkE5kh-YDs5Vx9eJFVkvliQ0S4,4353
+anyio/streams/memory.py,sha256=3RGeZoevoGIgBWfD2_X1cqxIPOz-BqQkRf6lUcOnBYc,9209
+anyio/streams/stapled.py,sha256=0E0V15v8M5GVelpHe5RT0S33tQ9hGe4ZCXo_KJEjtt4,4258
+anyio/streams/text.py,sha256=WRFyjsRpBjQKdCmR4ZuzYTEAJqGx2s5oTJmGI1C6Ng0,5014
+anyio/streams/tls.py,sha256=-WXGsMV14XHXAxc38WpBvGusjuY7e449g4UCEHIlnWw,12040
+anyio/to_process.py,sha256=hu0ES3HJC-VEjcdPJMzAzjyTaekaCNToO3coj3jvnus,9247
+anyio/to_thread.py,sha256=VeMQoo8Va2zz0WFk2p123QikDpqk2wYZGw20COC3wqw,2124

venv/lib/python3.11/site-packages/anyio-3.6.2.dist-info/WHEEL

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

venv/lib/python3.11/site-packages/anyio-3.6.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+anyio = anyio.pytest_plugin

venv/lib/python3.11/site-packages/anyio-3.6.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+anyio

venv/lib/python3.11/site-packages/anyio/__init__.py

@@ -0,0 +1,167 @@
+__all__ = (
+    "maybe_async",
+    "maybe_async_cm",
+    "run",
+    "sleep",
+    "sleep_forever",
+    "sleep_until",
+    "current_time",
+    "get_all_backends",
+    "get_cancelled_exc_class",
+    "BrokenResourceError",
+    "BrokenWorkerProcess",
+    "BusyResourceError",
+    "ClosedResourceError",
+    "DelimiterNotFound",
+    "EndOfStream",
+    "ExceptionGroup",
+    "IncompleteRead",
+    "TypedAttributeLookupError",
+    "WouldBlock",
+    "AsyncFile",
+    "Path",
+    "open_file",
+    "wrap_file",
+    "aclose_forcefully",
+    "open_signal_receiver",
+    "connect_tcp",
+    "connect_unix",
+    "create_tcp_listener",
+    "create_unix_listener",
+    "create_udp_socket",
+    "create_connected_udp_socket",
+    "getaddrinfo",
+    "getnameinfo",
+    "wait_socket_readable",
+    "wait_socket_writable",
+    "create_memory_object_stream",
+    "run_process",
+    "open_process",
+    "create_lock",
+    "CapacityLimiter",
+    "CapacityLimiterStatistics",
+    "Condition",
+    "ConditionStatistics",
+    "Event",
+    "EventStatistics",
+    "Lock",
+    "LockStatistics",
+    "Semaphore",
+    "SemaphoreStatistics",
+    "create_condition",
+    "create_event",
+    "create_semaphore",
+    "create_capacity_limiter",
+    "open_cancel_scope",
+    "fail_after",
+    "move_on_after",
+    "current_effective_deadline",
+    "TASK_STATUS_IGNORED",
+    "CancelScope",
+    "create_task_group",
+    "TaskInfo",
+    "get_current_task",
+    "get_running_tasks",
+    "wait_all_tasks_blocked",
+    "run_sync_in_worker_thread",
+    "run_async_from_thread",
+    "run_sync_from_thread",
+    "current_default_worker_thread_limiter",
+    "create_blocking_portal",
+    "start_blocking_portal",
+    "typed_attribute",
+    "TypedAttributeSet",
+    "TypedAttributeProvider",
+)
+
+from typing import Any
+
+from ._core._compat import maybe_async, maybe_async_cm
+from ._core._eventloop import (
+    current_time,
+    get_all_backends,
+    get_cancelled_exc_class,
+    run,
+    sleep,
+    sleep_forever,
+    sleep_until,
+)
+from ._core._exceptions import (
+    BrokenResourceError,
+    BrokenWorkerProcess,
+    BusyResourceError,
+    ClosedResourceError,
+    DelimiterNotFound,
+    EndOfStream,
+    ExceptionGroup,
+    IncompleteRead,
+    TypedAttributeLookupError,
+    WouldBlock,
+)
+from ._core._fileio import AsyncFile, Path, open_file, wrap_file
+from ._core._resources import aclose_forcefully
+from ._core._signals import open_signal_receiver
+from ._core._sockets import (
+    connect_tcp,
+    connect_unix,
+    create_connected_udp_socket,
+    create_tcp_listener,
+    create_udp_socket,
+    create_unix_listener,
+    getaddrinfo,
+    getnameinfo,
+    wait_socket_readable,
+    wait_socket_writable,
+)
+from ._core._streams import create_memory_object_stream
+from ._core._subprocesses import open_process, run_process
+from ._core._synchronization import (
+    CapacityLimiter,
+    CapacityLimiterStatistics,
+    Condition,
+    ConditionStatistics,
+    Event,
+    EventStatistics,
+    Lock,
+    LockStatistics,
+    Semaphore,
+    SemaphoreStatistics,
+    create_capacity_limiter,
+    create_condition,
+    create_event,
+    create_lock,
+    create_semaphore,
+)
+from ._core._tasks import (
+    TASK_STATUS_IGNORED,
+    CancelScope,
+    create_task_group,
+    current_effective_deadline,
+    fail_after,
+    move_on_after,
+    open_cancel_scope,
+)
+from ._core._testing import (
+    TaskInfo,
+    get_current_task,
+    get_running_tasks,
+    wait_all_tasks_blocked,
+)
+from ._core._typedattr import TypedAttributeProvider, TypedAttributeSet, typed_attribute
+
+# Re-exported here, for backwards compatibility
+# isort: off
+from .to_thread import current_default_worker_thread_limiter, run_sync_in_worker_thread
+from .from_thread import (
+    create_blocking_portal,
+    run_async_from_thread,
+    run_sync_from_thread,
+    start_blocking_portal,
+)
+
+# Re-export imports so they look like they live directly in this package
+key: str
+value: Any
+for key, value in list(locals().items()):
+    if getattr(value, "__module__", "").startswith("anyio."):
+        value.__module__ = __name__

venv/lib/python3.11/site-packages/anyio/_backends/_trio.py

@@ -0,0 +1,988 @@
+import array
+import math
+import socket
+from concurrent.futures import Future
+from contextvars import copy_context
+from dataclasses import dataclass
+from functools import partial
+from io import IOBase
+from os import PathLike
+from signal import Signals
+from types import TracebackType
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+    Awaitable,
+    Callable,
+    Collection,
+    ContextManager,
+    Coroutine,
+    Deque,
+    Dict,
+    Generic,
+    Iterable,
+    List,
+    Mapping,
+    NoReturn,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+import sniffio
+import trio.from_thread
+from outcome import Error, Outcome, Value
+from trio.socket import SocketType as TrioSocketType
+from trio.to_thread import run_sync
+
+from .. import CapacityLimiterStatistics, EventStatistics, TaskInfo, abc
+from .._core._compat import DeprecatedAsyncContextManager, DeprecatedAwaitable, T
+from .._core._eventloop import claim_worker_thread
+from .._core._exceptions import (
+    BrokenResourceError,
+    BusyResourceError,
+    ClosedResourceError,
+    EndOfStream,
+)
+from .._core._exceptions import ExceptionGroup as BaseExceptionGroup
+from .._core._sockets import convert_ipv6_sockaddr
+from .._core._synchronization import CapacityLimiter as BaseCapacityLimiter
+from .._core._synchronization import Event as BaseEvent
+from .._core._synchronization import ResourceGuard
+from .._core._tasks import CancelScope as BaseCancelScope
+from ..abc import IPSockAddrType, UDPPacketType
+
+if TYPE_CHECKING:
+    from trio_typing import TaskStatus
+
+try:
+    from trio import lowlevel as trio_lowlevel
+except ImportError:
+    from trio import hazmat as trio_lowlevel  # type: ignore[no-redef]
+    from trio.hazmat import wait_readable, wait_writable
+else:
+    from trio.lowlevel import wait_readable, wait_writable
+
+try:
+    trio_open_process = trio_lowlevel.open_process  # type: ignore[attr-defined]
+except AttributeError:
+    from trio import open_process as trio_open_process
+
+T_Retval = TypeVar("T_Retval")
+T_SockAddr = TypeVar("T_SockAddr", str, IPSockAddrType)
+
+
+#
+# Event loop
+#
+
+run = trio.run
+current_token = trio.lowlevel.current_trio_token
+RunVar = trio.lowlevel.RunVar
+
+
+#
+# Miscellaneous
+#
+
+sleep = trio.sleep
+
+
+#
+# Timeouts and cancellation
+#
+
+
+class CancelScope(BaseCancelScope):
+    def __new__(
+        cls, original: Optional[trio.CancelScope] = None, **kwargs: object
+    ) -> "CancelScope":
+        return object.__new__(cls)
+
+    def __init__(
+        self, original: Optional[trio.CancelScope] = None, **kwargs: Any
+    ) -> None:
+        self.__original = original or trio.CancelScope(**kwargs)
+
+    def __enter__(self) -> "CancelScope":
+        self.__original.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self.__original.__exit__(exc_type, exc_val, exc_tb)
+
+    def cancel(self) -> DeprecatedAwaitable:
+        self.__original.cancel()
+        return DeprecatedAwaitable(self.cancel)
+
+    @property
+    def deadline(self) -> float:
+        return self.__original.deadline
+
+    @deadline.setter
+    def deadline(self, value: float) -> None:
+        self.__original.deadline = value
+
+    @property
+    def cancel_called(self) -> bool:
+        return self.__original.cancel_called
+
+    @property
+    def shield(self) -> bool:
+        return self.__original.shield
+
+    @shield.setter
+    def shield(self, value: bool) -> None:
+        self.__original.shield = value
+
+
+CancelledError = trio.Cancelled
+checkpoint = trio.lowlevel.checkpoint
+checkpoint_if_cancelled = trio.lowlevel.checkpoint_if_cancelled
+cancel_shielded_checkpoint = trio.lowlevel.cancel_shielded_checkpoint
+current_effective_deadline = trio.current_effective_deadline
+current_time = trio.current_time
+
+
+#
+# Task groups
+#
+
+
+class ExceptionGroup(BaseExceptionGroup, trio.MultiError):
+    pass
+
+
+class TaskGroup(abc.TaskGroup):
+    def __init__(self) -> None:
+        self._active = False
+        self._nursery_manager = trio.open_nursery()
+        self.cancel_scope = None  # type: ignore[assignment]
+
+    async def __aenter__(self) -> "TaskGroup":
+        self._active = True
+        self._nursery = await self._nursery_manager.__aenter__()
+        self.cancel_scope = CancelScope(self._nursery.cancel_scope)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        try:
+            return await self._nursery_manager.__aexit__(exc_type, exc_val, exc_tb)
+        except trio.MultiError as exc:
+            raise ExceptionGroup(exc.exceptions) from None
+        finally:
+            self._active = False
+
+    def start_soon(self, func: Callable, *args: object, name: object = None) -> None:
+        if not self._active:
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+        self._nursery.start_soon(func, *args, name=name)
+
+    async def start(
+        self, func: Callable[..., Coroutine], *args: object, name: object = None
+    ) -> object:
+        if not self._active:
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+        return await self._nursery.start(func, *args, name=name)
+
+
+#
+# Threads
+#
+
+
+async def run_sync_in_worker_thread(
+    func: Callable[..., T_Retval],
+    *args: object,
+    cancellable: bool = False,
+    limiter: Optional[trio.CapacityLimiter] = None,
+) -> T_Retval:
+    def wrapper() -> T_Retval:
+        with claim_worker_thread("trio"):
+            return func(*args)
+
+    # TODO: remove explicit context copying when trio 0.20 is the minimum requirement
+    context = copy_context()
+    context.run(sniffio.current_async_library_cvar.set, None)
+    return await run_sync(
+        context.run, wrapper, cancellable=cancellable, limiter=limiter
+    )
+
+
+# TODO: remove this workaround when trio 0.20 is the minimum requirement
+def run_async_from_thread(
+    fn: Callable[..., Awaitable[T_Retval]], *args: Any
+) -> T_Retval:
+    async def wrapper() -> T_Retval:
+        retval: T_Retval
+
+        async def inner() -> None:
+            nonlocal retval
+            __tracebackhide__ = True
+            retval = await fn(*args)
+
+        async with trio.open_nursery() as n:
+            context.run(n.start_soon, inner)
+
+        __tracebackhide__ = True
+        return retval
+
+    context = copy_context()
+    context.run(sniffio.current_async_library_cvar.set, "trio")
+    return trio.from_thread.run(wrapper)
+
+
+def run_sync_from_thread(fn: Callable[..., T_Retval], *args: Any) -> T_Retval:
+    # TODO: remove explicit context copying when trio 0.20 is the minimum requirement
+    retval = trio.from_thread.run_sync(copy_context().run, fn, *args)
+    return cast(T_Retval, retval)
+
+
+class BlockingPortal(abc.BlockingPortal):
+    def __new__(cls) -> "BlockingPortal":
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._token = trio.lowlevel.current_trio_token()
+
+    def _spawn_task_from_thread(
+        self,
+        func: Callable,
+        args: tuple,
+        kwargs: Dict[str, Any],
+        name: object,
+        future: Future,
+    ) -> None:
+        context = copy_context()
+        context.run(sniffio.current_async_library_cvar.set, "trio")
+        trio.from_thread.run_sync(
+            context.run,
+            partial(self._task_group.start_soon, name=name),
+            self._call_func,
+            func,
+            args,
+            kwargs,
+            future,
+            trio_token=self._token,
+        )
+
+
+#
+# Subprocesses
+#
+
+
+@dataclass(eq=False)
+class ReceiveStreamWrapper(abc.ByteReceiveStream):
+    _stream: trio.abc.ReceiveStream
+
+    async def receive(self, max_bytes: Optional[int] = None) -> bytes:
+        try:
+            data = await self._stream.receive_some(max_bytes)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError from exc.__cause__
+        except trio.BrokenResourceError as exc:
+            raise BrokenResourceError from exc.__cause__
+
+        if data:
+            return data
+        else:
+            raise EndOfStream
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+
+@dataclass(eq=False)
+class SendStreamWrapper(abc.ByteSendStream):
+    _stream: trio.abc.SendStream
+
+    async def send(self, item: bytes) -> None:
+        try:
+            await self._stream.send_all(item)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError from exc.__cause__
+        except trio.BrokenResourceError as exc:
+            raise BrokenResourceError from exc.__cause__
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+
+@dataclass(eq=False)
+class Process(abc.Process):
+    _process: trio.Process
+    _stdin: Optional[abc.ByteSendStream]
+    _stdout: Optional[abc.ByteReceiveStream]
+    _stderr: Optional[abc.ByteReceiveStream]
+
+    async def aclose(self) -> None:
+        if self._stdin:
+            await self._stdin.aclose()
+        if self._stdout:
+            await self._stdout.aclose()
+        if self._stderr:
+            await self._stderr.aclose()
+
+        await self.wait()
+
+    async def wait(self) -> int:
+        return await self._process.wait()
+
+    def terminate(self) -> None:
+        self._process.terminate()
+
+    def kill(self) -> None:
+        self._process.kill()
+
+    def send_signal(self, signal: Signals) -> None:
+        self._process.send_signal(signal)
+
+    @property
+    def pid(self) -> int:
+        return self._process.pid
+
+    @property
+    def returncode(self) -> Optional[int]:
+        return self._process.returncode
+
+    @property
+    def stdin(self) -> Optional[abc.ByteSendStream]:
+        return self._stdin
+
+    @property
+    def stdout(self) -> Optional[abc.ByteReceiveStream]:
+        return self._stdout
+
+    @property
+    def stderr(self) -> Optional[abc.ByteReceiveStream]:
+        return self._stderr
+
+
+async def open_process(
+    command: Union[str, bytes, Sequence[Union[str, bytes]]],
+    *,
+    shell: bool,
+    stdin: Union[int, IO[Any], None],
+    stdout: Union[int, IO[Any], None],
+    stderr: Union[int, IO[Any], None],
+    cwd: Union[str, bytes, PathLike, None] = None,
+    env: Optional[Mapping[str, str]] = None,
+    start_new_session: bool = False,
+) -> Process:
+    process = await trio_open_process(
+        command,
+        stdin=stdin,
+        stdout=stdout,
+        stderr=stderr,
+        shell=shell,
+        cwd=cwd,
+        env=env,
+        start_new_session=start_new_session,
+    )
+    stdin_stream = SendStreamWrapper(process.stdin) if process.stdin else None
+    stdout_stream = ReceiveStreamWrapper(process.stdout) if process.stdout else None
+    stderr_stream = ReceiveStreamWrapper(process.stderr) if process.stderr else None
+    return Process(process, stdin_stream, stdout_stream, stderr_stream)
+
+
+class _ProcessPoolShutdownInstrument(trio.abc.Instrument):
+    def after_run(self) -> None:
+        super().after_run()
+
+
+current_default_worker_process_limiter: RunVar = RunVar(
+    "current_default_worker_process_limiter"
+)
+
+
+async def _shutdown_process_pool(workers: Set[Process]) -> None:
+    process: Process
+    try:
+        await sleep(math.inf)
+    except trio.Cancelled:
+        for process in workers:
+            if process.returncode is None:
+                process.kill()
+
+        with CancelScope(shield=True):
+            for process in workers:
+                await process.aclose()
+
+
+def setup_process_pool_exit_at_shutdown(workers: Set[Process]) -> None:
+    trio.lowlevel.spawn_system_task(_shutdown_process_pool, workers)
+
+
+#
+# Sockets and networking
+#
+
+
+class _TrioSocketMixin(Generic[T_SockAddr]):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        self._trio_socket = trio_socket
+        self._closed = False
+
+    def _check_closed(self) -> None:
+        if self._closed:
+            raise ClosedResourceError
+        if self._trio_socket.fileno() < 0:
+            raise BrokenResourceError
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._trio_socket._sock  # type: ignore[attr-defined]
+
+    async def aclose(self) -> None:
+        if self._trio_socket.fileno() >= 0:
+            self._closed = True
+            self._trio_socket.close()
+
+    def _convert_socket_error(self, exc: BaseException) -> "NoReturn":
+        if isinstance(exc, trio.ClosedResourceError):
+            raise ClosedResourceError from exc
+        elif self._trio_socket.fileno() < 0 and self._closed:
+            raise ClosedResourceError from None
+        elif isinstance(exc, OSError):
+            raise BrokenResourceError from exc
+        else:
+            raise exc
+
+
+class SocketStream(_TrioSocketMixin, abc.SocketStream):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        with self._receive_guard:
+            try:
+                data = await self._trio_socket.recv(max_bytes)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+            if data:
+                return data
+            else:
+                raise EndOfStream
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            view = memoryview(item)
+            while view:
+                try:
+                    bytes_sent = await self._trio_socket.send(view)
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+
+                view = view[bytes_sent:]
+
+    async def send_eof(self) -> None:
+        self._trio_socket.shutdown(socket.SHUT_WR)
+
+
+class UNIXSocketStream(SocketStream, abc.UNIXSocketStream):
+    async def receive_fds(self, msglen: int, maxfds: int) -> Tuple[bytes, List[int]]:
+        if not isinstance(msglen, int) or msglen < 0:
+            raise ValueError("msglen must be a non-negative integer")
+        if not isinstance(maxfds, int) or maxfds < 1:
+            raise ValueError("maxfds must be a positive integer")
+
+        fds = array.array("i")
+        await checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    message, ancdata, flags, addr = await self._trio_socket.recvmsg(
+                        msglen, socket.CMSG_LEN(maxfds * fds.itemsize)
+                    )
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+                else:
+                    if not message and not ancdata:
+                        raise EndOfStream
+
+                    break
+
+        for cmsg_level, cmsg_type, cmsg_data in ancdata:
+            if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS:
+                raise RuntimeError(
+                    f"Received unexpected ancillary data; message = {message!r}, "
+                    f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}"
+                )
+
+            fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
+
+        return message, list(fds)
+
+    async def send_fds(
+        self, message: bytes, fds: Collection[Union[int, IOBase]]
+    ) -> None:
+        if not message:
+            raise ValueError("message must not be empty")
+        if not fds:
+            raise ValueError("fds must not be empty")
+
+        filenos: List[int] = []
+        for fd in fds:
+            if isinstance(fd, int):
+                filenos.append(fd)
+            elif isinstance(fd, IOBase):
+                filenos.append(fd.fileno())
+
+        fdarray = array.array("i", filenos)
+        await checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    await self._trio_socket.sendmsg(
+                        [message],
+                        [
+                            (
+                                socket.SOL_SOCKET,
+                                socket.SCM_RIGHTS,  # type: ignore[list-item]
+                                fdarray,
+                            )
+                        ],
+                    )
+                    break
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+
+
+class TCPSocketListener(_TrioSocketMixin, abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        super().__init__(trio.socket.from_stdlib_socket(raw_socket))
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    async def accept(self) -> SocketStream:
+        with self._accept_guard:
+            try:
+                trio_socket, _addr = await self._trio_socket.accept()
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+        trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        return SocketStream(trio_socket)
+
+
+class UNIXSocketListener(_TrioSocketMixin, abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        super().__init__(trio.socket.from_stdlib_socket(raw_socket))
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    async def accept(self) -> UNIXSocketStream:
+        with self._accept_guard:
+            try:
+                trio_socket, _addr = await self._trio_socket.accept()
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+        return UNIXSocketStream(trio_socket)
+
+
+class UDPSocket(_TrioSocketMixin[IPSockAddrType], abc.UDPSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> Tuple[bytes, IPSockAddrType]:
+        with self._receive_guard:
+            try:
+                data, addr = await self._trio_socket.recvfrom(65536)
+                return data, convert_ipv6_sockaddr(addr)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: UDPPacketType) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.sendto(*item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+class ConnectedUDPSocket(_TrioSocketMixin[IPSockAddrType], abc.ConnectedUDPSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> bytes:
+        with self._receive_guard:
+            try:
+                return await self._trio_socket.recv(65536)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.send(item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+async def connect_tcp(
+    host: str, port: int, local_address: Optional[IPSockAddrType] = None
+) -> SocketStream:
+    family = socket.AF_INET6 if ":" in host else socket.AF_INET
+    trio_socket = trio.socket.socket(family)
+    trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+    if local_address:
+        await trio_socket.bind(local_address)
+
+    try:
+        await trio_socket.connect((host, port))
+    except BaseException:
+        trio_socket.close()
+        raise
+
+    return SocketStream(trio_socket)
+
+
+async def connect_unix(path: str) -> UNIXSocketStream:
+    trio_socket = trio.socket.socket(socket.AF_UNIX)
+    try:
+        await trio_socket.connect(path)
+    except BaseException:
+        trio_socket.close()
+        raise
+
+    return UNIXSocketStream(trio_socket)
+
+
+async def create_udp_socket(
+    family: socket.AddressFamily,
+    local_address: Optional[IPSockAddrType],
+    remote_address: Optional[IPSockAddrType],
+    reuse_port: bool,
+) -> Union[UDPSocket, ConnectedUDPSocket]:
+    trio_socket = trio.socket.socket(family=family, type=socket.SOCK_DGRAM)
+
+    if reuse_port:
+        trio_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+    if local_address:
+        await trio_socket.bind(local_address)
+
+    if remote_address:
+        await trio_socket.connect(remote_address)
+        return ConnectedUDPSocket(trio_socket)
+    else:
+        return UDPSocket(trio_socket)
+
+
+getaddrinfo = trio.socket.getaddrinfo
+getnameinfo = trio.socket.getnameinfo
+
+
+async def wait_socket_readable(sock: socket.socket) -> None:
+    try:
+        await wait_readable(sock)
+    except trio.ClosedResourceError as exc:
+        raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+    except trio.BusyResourceError:
+        raise BusyResourceError("reading from") from None
+
+
+async def wait_socket_writable(sock: socket.socket) -> None:
+    try:
+        await wait_writable(sock)
+    except trio.ClosedResourceError as exc:
+        raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+    except trio.BusyResourceError:
+        raise BusyResourceError("writing to") from None
+
+
+#
+# Synchronization
+#
+
+
+class Event(BaseEvent):
+    def __new__(cls) -> "Event":
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        self.__original = trio.Event()
+
+    def is_set(self) -> bool:
+        return self.__original.is_set()
+
+    async def wait(self) -> None:
+        return await self.__original.wait()
+
+    def statistics(self) -> EventStatistics:
+        orig_statistics = self.__original.statistics()
+        return EventStatistics(tasks_waiting=orig_statistics.tasks_waiting)
+
+    def set(self) -> DeprecatedAwaitable:
+        self.__original.set()
+        return DeprecatedAwaitable(self.set)
+
+
+class CapacityLimiter(BaseCapacityLimiter):
+    def __new__(cls, *args: object, **kwargs: object) -> "CapacityLimiter":
+        return object.__new__(cls)
+
+    def __init__(
+        self, *args: Any, original: Optional[trio.CapacityLimiter] = None
+    ) -> None:
+        self.__original = original or trio.CapacityLimiter(*args)
+
+    async def __aenter__(self) -> None:
+        return await self.__original.__aenter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return await self.__original.__aexit__(exc_type, exc_val, exc_tb)
+
+    @property
+    def total_tokens(self) -> float:
+        return self.__original.total_tokens
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        self.__original.total_tokens = value
+
+    @property
+    def borrowed_tokens(self) -> int:
+        return self.__original.borrowed_tokens
+
+    @property
+    def available_tokens(self) -> float:
+        return self.__original.available_tokens
+
+    def acquire_nowait(self) -> DeprecatedAwaitable:
+        self.__original.acquire_nowait()
+        return DeprecatedAwaitable(self.acquire_nowait)
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
+        self.__original.acquire_on_behalf_of_nowait(borrower)
+        return DeprecatedAwaitable(self.acquire_on_behalf_of_nowait)
+
+    async def acquire(self) -> None:
+        await self.__original.acquire()
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        await self.__original.acquire_on_behalf_of(borrower)
+
+    def release(self) -> None:
+        return self.__original.release()
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        return self.__original.release_on_behalf_of(borrower)
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        orig = self.__original.statistics()
+        return CapacityLimiterStatistics(
+            borrowed_tokens=orig.borrowed_tokens,
+            total_tokens=orig.total_tokens,
+            borrowers=orig.borrowers,
+            tasks_waiting=orig.tasks_waiting,
+        )
+
+
+_capacity_limiter_wrapper: RunVar = RunVar("_capacity_limiter_wrapper")
+
+
+def current_default_thread_limiter() -> CapacityLimiter:
+    try:
+        return _capacity_limiter_wrapper.get()
+    except LookupError:
+        limiter = CapacityLimiter(
+            original=trio.to_thread.current_default_thread_limiter()
+        )
+        _capacity_limiter_wrapper.set(limiter)
+        return limiter
+
+
+#
+# Signal handling
+#
+
+
+class _SignalReceiver(DeprecatedAsyncContextManager[T]):
+    def __init__(self, cm: ContextManager[T]):
+        self._cm = cm
+
+    def __enter__(self) -> T:
+        return self._cm.__enter__()
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self._cm.__exit__(exc_type, exc_val, exc_tb)
+
+
+def open_signal_receiver(*signals: Signals) -> _SignalReceiver:
+    cm = trio.open_signal_receiver(*signals)
+    return _SignalReceiver(cm)
+
+
+#
+# Testing and debugging
+#
+
+
+def get_current_task() -> TaskInfo:
+    task = trio_lowlevel.current_task()
+
+    parent_id = None
+    if task.parent_nursery and task.parent_nursery.parent_task:
+        parent_id = id(task.parent_nursery.parent_task)
+
+    return TaskInfo(id(task), parent_id, task.name, task.coro)
+
+
+def get_running_tasks() -> List[TaskInfo]:
+    root_task = trio_lowlevel.current_root_task()
+    task_infos = [TaskInfo(id(root_task), None, root_task.name, root_task.coro)]
+    nurseries = root_task.child_nurseries
+    while nurseries:
+        new_nurseries: List[trio.Nursery] = []
+        for nursery in nurseries:
+            for task in nursery.child_tasks:
+                task_infos.append(
+                    TaskInfo(id(task), id(nursery.parent_task), task.name, task.coro)
+                )
+                new_nurseries.extend(task.child_nurseries)
+
+        nurseries = new_nurseries
+
+    return task_infos
+
+
+def wait_all_tasks_blocked() -> Awaitable[None]:
+    import trio.testing
+
+    return trio.testing.wait_all_tasks_blocked()
+
+
+class TestRunner(abc.TestRunner):
+    def __init__(self, **options: Any) -> None:
+        from collections import deque
+        from queue import Queue
+
+        self._call_queue: "Queue[Callable[..., object]]" = Queue()
+        self._result_queue: Deque[Outcome] = deque()
+        self._stop_event: Optional[trio.Event] = None
+        self._nursery: Optional[trio.Nursery] = None
+        self._options = options
+
+    async def _trio_main(self) -> None:
+        self._stop_event = trio.Event()
+        async with trio.open_nursery() as self._nursery:
+            await self._stop_event.wait()
+
+    async def _call_func(
+        self, func: Callable[..., Awaitable[object]], args: tuple, kwargs: dict
+    ) -> None:
+        try:
+            retval = await func(*args, **kwargs)
+        except BaseException as exc:
+            self._result_queue.append(Error(exc))
+        else:
+            self._result_queue.append(Value(retval))
+
+    def _main_task_finished(self, outcome: object) -> None:
+        self._nursery = None
+
+    def _get_nursery(self) -> trio.Nursery:
+        if self._nursery is None:
+            trio.lowlevel.start_guest_run(
+                self._trio_main,
+                run_sync_soon_threadsafe=self._call_queue.put,
+                done_callback=self._main_task_finished,
+                **self._options,
+            )
+            while self._nursery is None:
+                self._call_queue.get()()
+
+        return self._nursery
+
+    def _call(
+        self, func: Callable[..., Awaitable[T_Retval]], *args: object, **kwargs: object
+    ) -> T_Retval:
+        self._get_nursery().start_soon(self._call_func, func, args, kwargs)
+        while not self._result_queue:
+            self._call_queue.get()()
+
+        outcome = self._result_queue.pop()
+        return outcome.unwrap()
+
+    def close(self) -> None:
+        if self._stop_event:
+            self._stop_event.set()
+            while self._nursery is not None:
+                self._call_queue.get()()
+
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]],
+        kwargs: Dict[str, Any],
+    ) -> Iterable[T_Retval]:
+        async def fixture_runner(*, task_status: "TaskStatus") -> None:
+            agen = fixture_func(**kwargs)
+            retval = await agen.asend(None)
+            task_status.started(retval)
+            await teardown_event.wait()
+            try:
+                await agen.asend(None)
+            except StopAsyncIteration:
+                pass
+            else:
+                await agen.aclose()
+                raise RuntimeError("Async generator fixture did not stop")
+
+        teardown_event = trio.Event()
+        fixture_value = self._call(lambda: self._get_nursery().start(fixture_runner))
+        yield fixture_value
+        teardown_event.set()
+
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        kwargs: Dict[str, Any],
+    ) -> T_Retval:
+        return self._call(fixture_func, **kwargs)
+
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: Dict[str, Any]
+    ) -> None:
+        self._call(test_func, **kwargs)

venv/lib/python3.11/site-packages/anyio/_core/_compat.py

@@ -0,0 +1,218 @@
+from abc import ABCMeta, abstractmethod
+from contextlib import AbstractContextManager
+from types import TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncContextManager,
+    Callable,
+    ContextManager,
+    Generator,
+    Generic,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+from warnings import warn
+
+if TYPE_CHECKING:
+    from ._testing import TaskInfo
+else:
+    TaskInfo = object
+
+T = TypeVar("T")
+AnyDeprecatedAwaitable = Union[
+    "DeprecatedAwaitable",
+    "DeprecatedAwaitableFloat",
+    "DeprecatedAwaitableList[T]",
+    TaskInfo,
+]
+
+
+@overload
+async def maybe_async(__obj: TaskInfo) -> TaskInfo:
+    ...
+
+
+@overload
+async def maybe_async(__obj: "DeprecatedAwaitableFloat") -> float:
+    ...
+
+
+@overload
+async def maybe_async(__obj: "DeprecatedAwaitableList[T]") -> List[T]:
+    ...
+
+
+@overload
+async def maybe_async(__obj: "DeprecatedAwaitable") -> None:
+    ...
+
+
+async def maybe_async(
+    __obj: "AnyDeprecatedAwaitable[T]",
+) -> Union[TaskInfo, float, List[T], None]:
+    """
+    Await on the given object if necessary.
+
+    This function is intended to bridge the gap between AnyIO 2.x and 3.x where some functions and
+    methods were converted from coroutine functions into regular functions.
+
+    Do **not** try to use this for any other purpose!
+
+    :return: the result of awaiting on the object if coroutine, or the object itself otherwise
+
+    .. versionadded:: 2.2
+
+    """
+    return __obj._unwrap()
+
+
+class _ContextManagerWrapper:
+    def __init__(self, cm: ContextManager[T]):
+        self._cm = cm
+
+    async def __aenter__(self) -> T:
+        return self._cm.__enter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self._cm.__exit__(exc_type, exc_val, exc_tb)
+
+
+def maybe_async_cm(
+    cm: Union[ContextManager[T], AsyncContextManager[T]]
+) -> AsyncContextManager[T]:
+    """
+    Wrap a regular context manager as an async one if necessary.
+
+    This function is intended to bridge the gap between AnyIO 2.x and 3.x where some functions and
+    methods were changed to return regular context managers instead of async ones.
+
+    :param cm: a regular or async context manager
+    :return: an async context manager
+
+    .. versionadded:: 2.2
+
+    """
+    if not isinstance(cm, AbstractContextManager):
+        raise TypeError("Given object is not an context manager")
+
+    return _ContextManagerWrapper(cm)
+
+
+def _warn_deprecation(
+    awaitable: "AnyDeprecatedAwaitable[Any]", stacklevel: int = 1
+) -> None:
+    warn(
+        f'Awaiting on {awaitable._name}() is deprecated. Use "await '
+        f"anyio.maybe_async({awaitable._name}(...)) if you have to support both AnyIO 2.x "
+        f'and 3.x, or just remove the "await" if you are completely migrating to AnyIO 3+.',
+        DeprecationWarning,
+        stacklevel=stacklevel + 1,
+    )
+
+
+class DeprecatedAwaitable:
+    def __init__(self, func: Callable[..., "DeprecatedAwaitable"]):
+        self._name = f"{func.__module__}.{func.__qualname__}"
+
+    def __await__(self) -> Generator[None, None, None]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+    def __reduce__(self) -> Tuple[Type[None], Tuple[()]]:
+        return type(None), ()
+
+    def _unwrap(self) -> None:
+        return None
+
+
+class DeprecatedAwaitableFloat(float):
+    def __new__(
+        cls, x: float, func: Callable[..., "DeprecatedAwaitableFloat"]
+    ) -> "DeprecatedAwaitableFloat":
+        return super().__new__(cls, x)
+
+    def __init__(self, x: float, func: Callable[..., "DeprecatedAwaitableFloat"]):
+        self._name = f"{func.__module__}.{func.__qualname__}"
+
+    def __await__(self) -> Generator[None, None, float]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+        return float(self)
+
+    def __reduce__(self) -> Tuple[Type[float], Tuple[float]]:
+        return float, (float(self),)
+
+    def _unwrap(self) -> float:
+        return float(self)
+
+
+class DeprecatedAwaitableList(List[T]):
+    def __init__(
+        self,
+        iterable: Iterable[T] = (),
+        *,
+        func: Callable[..., "DeprecatedAwaitableList[T]"],
+    ):
+        super().__init__(iterable)
+        self._name = f"{func.__module__}.{func.__qualname__}"
+
+    def __await__(self) -> Generator[None, None, List[T]]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+        return list(self)
+
+    def __reduce__(self) -> Tuple[Type[List[T]], Tuple[List[T]]]:
+        return list, (list(self),)
+
+    def _unwrap(self) -> List[T]:
+        return list(self)
+
+
+class DeprecatedAsyncContextManager(Generic[T], metaclass=ABCMeta):
+    @abstractmethod
+    def __enter__(self) -> T:
+        pass
+
+    @abstractmethod
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        pass
+
+    async def __aenter__(self) -> T:
+        warn(
+            f"Using {self.__class__.__name__} as an async context manager has been deprecated. "
+            f'Use "async with anyio.maybe_async_cm(yourcontextmanager) as foo:" if you have to '
+            f'support both AnyIO 2.x and 3.x, or just remove the "async" from "async with" if '
+            f"you are completely migrating to AnyIO 3+.",
+            DeprecationWarning,
+        )
+        return self.__enter__()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        return self.__exit__(exc_type, exc_val, exc_tb)

venv/lib/python3.11/site-packages/anyio/_core/_eventloop.py

@@ -0,0 +1,155 @@
+import math
+import sys
+import threading
+from contextlib import contextmanager
+from importlib import import_module
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    Generator,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+)
+
+import sniffio
+
+# This must be updated when new backends are introduced
+from ._compat import DeprecatedAwaitableFloat
+
+BACKENDS = "asyncio", "trio"
+
+T_Retval = TypeVar("T_Retval")
+threadlocals = threading.local()
+
+
+def run(
+    func: Callable[..., Coroutine[Any, Any, T_Retval]],
+    *args: object,
+    backend: str = "asyncio",
+    backend_options: Optional[Dict[str, Any]] = None,
+) -> T_Retval:
+    """
+    Run the given coroutine function in an asynchronous event loop.
+
+    The current thread must not be already running an event loop.
+
+    :param func: a coroutine function
+    :param args: positional arguments to ``func``
+    :param backend: name of the asynchronous event loop implementation – currently either
+        ``asyncio`` or ``trio``
+    :param backend_options: keyword arguments to call the backend ``run()`` implementation with
+        (documented :ref:`here <backend options>`)
+    :return: the return value of the coroutine function
+    :raises RuntimeError: if an asynchronous event loop is already running in this thread
+    :raises LookupError: if the named backend is not found
+
+    """
+    try:
+        asynclib_name = sniffio.current_async_library()
+    except sniffio.AsyncLibraryNotFoundError:
+        pass
+    else:
+        raise RuntimeError(f"Already running {asynclib_name} in this thread")
+
+    try:
+        asynclib = import_module(f"..._backends._{backend}", package=__name__)
+    except ImportError as exc:
+        raise LookupError(f"No such backend: {backend}") from exc
+
+    token = None
+    if sniffio.current_async_library_cvar.get(None) is None:
+        # Since we're in control of the event loop, we can cache the name of the async library
+        token = sniffio.current_async_library_cvar.set(backend)
+
+    try:
+        backend_options = backend_options or {}
+        return asynclib.run(func, *args, **backend_options)
+    finally:
+        if token:
+            sniffio.current_async_library_cvar.reset(token)
+
+
+async def sleep(delay: float) -> None:
+    """
+    Pause the current task for the specified duration.
+
+    :param delay: the duration, in seconds
+
+    """
+    return await get_asynclib().sleep(delay)
+
+
+async def sleep_forever() -> None:
+    """
+    Pause the current task until it's cancelled.
+
+    This is a shortcut for ``sleep(math.inf)``.
+
+    .. versionadded:: 3.1
+
+    """
+    await sleep(math.inf)
+
+
+async def sleep_until(deadline: float) -> None:
+    """
+    Pause the current task until the given time.
+
+    :param deadline: the absolute time to wake up at (according to the internal monotonic clock of
+        the event loop)
+
+    .. versionadded:: 3.1
+
+    """
+    now = current_time()
+    await sleep(max(deadline - now, 0))
+
+
+def current_time() -> DeprecatedAwaitableFloat:
+    """
+    Return the current value of the event loop's internal clock.
+
+    :return: the clock value (seconds)
+
+    """
+    return DeprecatedAwaitableFloat(get_asynclib().current_time(), current_time)
+
+
+def get_all_backends() -> Tuple[str, ...]:
+    """Return a tuple of the names of all built-in backends."""
+    return BACKENDS
+
+
+def get_cancelled_exc_class() -> Type[BaseException]:
+    """Return the current async library's cancellation exception class."""
+    return get_asynclib().CancelledError
+
+
+#
+# Private API
+#
+
+
+@contextmanager
+def claim_worker_thread(backend: str) -> Generator[Any, None, None]:
+    module = sys.modules["anyio._backends._" + backend]
+    threadlocals.current_async_module = module
+    try:
+        yield
+    finally:
+        del threadlocals.current_async_module
+
+
+def get_asynclib(asynclib_name: Optional[str] = None) -> Any:
+    if asynclib_name is None:
+        asynclib_name = sniffio.current_async_library()
+
+    modulename = "anyio._backends._" + asynclib_name
+    try:
+        return sys.modules[modulename]
+    except KeyError:
+        return import_module(modulename)

venv/lib/python3.11/site-packages/anyio/_core/_exceptions.py

@@ -0,0 +1,93 @@
+from traceback import format_exception
+from typing import List
+
+
+class BrokenResourceError(Exception):
+    """
+    Raised when trying to use a resource that has been rendered unusable due to external causes
+    (e.g. a send stream whose peer has disconnected).
+    """
+
+
+class BrokenWorkerProcess(Exception):
+    """
+    Raised by :func:`run_sync_in_process` if the worker process terminates abruptly or otherwise
+    misbehaves.
+    """
+
+
+class BusyResourceError(Exception):
+    """Raised when two tasks are trying to read from or write to the same resource concurrently."""
+
+    def __init__(self, action: str):
+        super().__init__(f"Another task is already {action} this resource")
+
+
+class ClosedResourceError(Exception):
+    """Raised when trying to use a resource that has been closed."""
+
+
+class DelimiterNotFound(Exception):
+    """
+    Raised during :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    maximum number of bytes has been read without the delimiter being found.
+    """
+
+    def __init__(self, max_bytes: int) -> None:
+        super().__init__(
+            f"The delimiter was not found among the first {max_bytes} bytes"
+        )
+
+
+class EndOfStream(Exception):
+    """Raised when trying to read from a stream that has been closed from the other end."""
+
+
+class ExceptionGroup(BaseException):
+    """
+    Raised when multiple exceptions have been raised in a task group.
+
+    :var ~typing.Sequence[BaseException] exceptions: the sequence of exceptions raised together
+    """
+
+    SEPARATOR = "----------------------------\n"
+
+    exceptions: List[BaseException]
+
+    def __str__(self) -> str:
+        tracebacks = [
+            "".join(format_exception(type(exc), exc, exc.__traceback__))
+            for exc in self.exceptions
+        ]
+        return (
+            f"{len(self.exceptions)} exceptions were raised in the task group:\n"
+            f"{self.SEPARATOR}{self.SEPARATOR.join(tracebacks)}"
+        )
+
+    def __repr__(self) -> str:
+        exception_reprs = ", ".join(repr(exc) for exc in self.exceptions)
+        return f"<{self.__class__.__name__}: {exception_reprs}>"
+
+
+class IncompleteRead(Exception):
+    """
+    Raised during :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    connection is closed before the requested amount of bytes has been read.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(
+            "The stream was closed before the read operation could be completed"
+        )
+
+
+class TypedAttributeLookupError(LookupError):
+    """
+    Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute is not
+    found and no default value has been given.
+    """
+
+
+class WouldBlock(Exception):
+    """Raised by ``X_nowait`` functions if ``X()`` would block."""

venv/lib/python3.11/site-packages/anyio/_core/_fileio.py

@@ -0,0 +1,607 @@
+import os
+import pathlib
+import sys
+from dataclasses import dataclass
+from functools import partial
+from os import PathLike
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    AnyStr,
+    AsyncIterator,
+    Callable,
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    Tuple,
+    Union,
+    cast,
+    overload,
+)
+
+from .. import to_thread
+from ..abc import AsyncResource
+
+if sys.version_info >= (3, 8):
+    from typing import Final
+else:
+    from typing_extensions import Final
+
+if TYPE_CHECKING:
+    from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer
+else:
+    ReadableBuffer = OpenBinaryMode = OpenTextMode = WriteableBuffer = object
+
+
+class AsyncFile(AsyncResource, Generic[AnyStr]):
+    """
+    An asynchronous file object.
+
+    This class wraps a standard file object and provides async friendly versions of the following
+    blocking methods (where available on the original file object):
+
+    * read
+    * read1
+    * readline
+    * readlines
+    * readinto
+    * readinto1
+    * write
+    * writelines
+    * truncate
+    * seek
+    * tell
+    * flush
+
+    All other methods are directly passed through.
+
+    This class supports the asynchronous context manager protocol which closes the underlying file
+    at the end of the context block.
+
+    This class also supports asynchronous iteration::
+
+        async with await open_file(...) as f:
+            async for line in f:
+                print(line)
+    """
+
+    def __init__(self, fp: IO[AnyStr]) -> None:
+        self._fp: Any = fp
+
+    def __getattr__(self, name: str) -> object:
+        return getattr(self._fp, name)
+
+    @property
+    def wrapped(self) -> IO[AnyStr]:
+        """The wrapped file object."""
+        return self._fp
+
+    async def __aiter__(self) -> AsyncIterator[AnyStr]:
+        while True:
+            line = await self.readline()
+            if line:
+                yield line
+            else:
+                break
+
+    async def aclose(self) -> None:
+        return await to_thread.run_sync(self._fp.close)
+
+    async def read(self, size: int = -1) -> AnyStr:
+        return await to_thread.run_sync(self._fp.read, size)
+
+    async def read1(self: "AsyncFile[bytes]", size: int = -1) -> bytes:
+        return await to_thread.run_sync(self._fp.read1, size)
+
+    async def readline(self) -> AnyStr:
+        return await to_thread.run_sync(self._fp.readline)
+
+    async def readlines(self) -> List[AnyStr]:
+        return await to_thread.run_sync(self._fp.readlines)
+
+    async def readinto(self: "AsyncFile[bytes]", b: WriteableBuffer) -> bytes:
+        return await to_thread.run_sync(self._fp.readinto, b)
+
+    async def readinto1(self: "AsyncFile[bytes]", b: WriteableBuffer) -> bytes:
+        return await to_thread.run_sync(self._fp.readinto1, b)
+
+    @overload
+    async def write(self: "AsyncFile[bytes]", b: ReadableBuffer) -> int:
+        ...
+
+    @overload
+    async def write(self: "AsyncFile[str]", b: str) -> int:
+        ...
+
+    async def write(self, b: Union[ReadableBuffer, str]) -> int:
+        return await to_thread.run_sync(self._fp.write, b)
+
+    @overload
+    async def writelines(
+        self: "AsyncFile[bytes]", lines: Iterable[ReadableBuffer]
+    ) -> None:
+        ...
+
+    @overload
+    async def writelines(self: "AsyncFile[str]", lines: Iterable[str]) -> None:
+        ...
+
+    async def writelines(
+        self, lines: Union[Iterable[ReadableBuffer], Iterable[str]]
+    ) -> None:
+        return await to_thread.run_sync(self._fp.writelines, lines)
+
+    async def truncate(self, size: Optional[int] = None) -> int:
+        return await to_thread.run_sync(self._fp.truncate, size)
+
+    async def seek(self, offset: int, whence: Optional[int] = os.SEEK_SET) -> int:
+        return await to_thread.run_sync(self._fp.seek, offset, whence)
+
+    async def tell(self) -> int:
+        return await to_thread.run_sync(self._fp.tell)
+
+    async def flush(self) -> None:
+        return await to_thread.run_sync(self._fp.flush)
+
+
+@overload
+async def open_file(
+    file: Union[str, "PathLike[str]", int],
+    mode: OpenBinaryMode,
+    buffering: int = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+    closefd: bool = ...,
+    opener: Optional[Callable[[str, int], int]] = ...,
+) -> AsyncFile[bytes]:
+    ...
+
+
+@overload
+async def open_file(
+    file: Union[str, "PathLike[str]", int],
+    mode: OpenTextMode = ...,
+    buffering: int = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+    closefd: bool = ...,
+    opener: Optional[Callable[[str, int], int]] = ...,
+) -> AsyncFile[str]:
+    ...
+
+
+async def open_file(
+    file: Union[str, "PathLike[str]", int],
+    mode: str = "r",
+    buffering: int = -1,
+    encoding: Optional[str] = None,
+    errors: Optional[str] = None,
+    newline: Optional[str] = None,
+    closefd: bool = True,
+    opener: Optional[Callable[[str, int], int]] = None,
+) -> AsyncFile[Any]:
+    """
+    Open a file asynchronously.
+
+    The arguments are exactly the same as for the builtin :func:`open`.
+
+    :return: an asynchronous file object
+
+    """
+    fp = await to_thread.run_sync(
+        open, file, mode, buffering, encoding, errors, newline, closefd, opener
+    )
+    return AsyncFile(fp)
+
+
+def wrap_file(file: IO[AnyStr]) -> AsyncFile[AnyStr]:
+    """
+    Wrap an existing file as an asynchronous file.
+
+    :param file: an existing file-like object
+    :return: an asynchronous file object
+
+    """
+    return AsyncFile(file)
+
+
+@dataclass(eq=False)
+class _PathIterator(AsyncIterator["Path"]):
+    iterator: Iterator["PathLike[str]"]
+
+    async def __anext__(self) -> "Path":
+        nextval = await to_thread.run_sync(next, self.iterator, None, cancellable=True)
+        if nextval is None:
+            raise StopAsyncIteration from None
+
+        return Path(cast("PathLike[str]", nextval))
+
+
+class Path:
+    """
+    An asynchronous version of :class:`pathlib.Path`.
+
+    This class cannot be substituted for :class:`pathlib.Path` or :class:`pathlib.PurePath`, but
+    it is compatible with the :class:`os.PathLike` interface.
+
+    It implements the Python 3.10 version of :class:`pathlib.Path` interface, except for the
+    deprecated :meth:`~pathlib.Path.link_to` method.
+
+    Any methods that do disk I/O need to be awaited on. These methods are:
+
+    * :meth:`~pathlib.Path.absolute`
+    * :meth:`~pathlib.Path.chmod`
+    * :meth:`~pathlib.Path.cwd`
+    * :meth:`~pathlib.Path.exists`
+    * :meth:`~pathlib.Path.expanduser`
+    * :meth:`~pathlib.Path.group`
+    * :meth:`~pathlib.Path.hardlink_to`
+    * :meth:`~pathlib.Path.home`
+    * :meth:`~pathlib.Path.is_block_device`
+    * :meth:`~pathlib.Path.is_char_device`
+    * :meth:`~pathlib.Path.is_dir`
+    * :meth:`~pathlib.Path.is_fifo`
+    * :meth:`~pathlib.Path.is_file`
+    * :meth:`~pathlib.Path.is_mount`
+    * :meth:`~pathlib.Path.lchmod`
+    * :meth:`~pathlib.Path.lstat`
+    * :meth:`~pathlib.Path.mkdir`
+    * :meth:`~pathlib.Path.open`
+    * :meth:`~pathlib.Path.owner`
+    * :meth:`~pathlib.Path.read_bytes`
+    * :meth:`~pathlib.Path.read_text`
+    * :meth:`~pathlib.Path.readlink`
+    * :meth:`~pathlib.Path.rename`
+    * :meth:`~pathlib.Path.replace`
+    * :meth:`~pathlib.Path.rmdir`
+    * :meth:`~pathlib.Path.samefile`
+    * :meth:`~pathlib.Path.stat`
+    * :meth:`~pathlib.Path.touch`
+    * :meth:`~pathlib.Path.unlink`
+    * :meth:`~pathlib.Path.write_bytes`
+    * :meth:`~pathlib.Path.write_text`
+
+    Additionally, the following methods return an async iterator yielding :class:`~.Path` objects:
+
+    * :meth:`~pathlib.Path.glob`
+    * :meth:`~pathlib.Path.iterdir`
+    * :meth:`~pathlib.Path.rglob`
+    """
+
+    __slots__ = "_path", "__weakref__"
+
+    __weakref__: Any
+
+    def __init__(self, *args: Union[str, "PathLike[str]"]) -> None:
+        self._path: Final[pathlib.Path] = pathlib.Path(*args)
+
+    def __fspath__(self) -> str:
+        return self._path.__fspath__()
+
+    def __str__(self) -> str:
+        return self._path.__str__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.as_posix()!r})"
+
+    def __bytes__(self) -> bytes:
+        return self._path.__bytes__()
+
+    def __hash__(self) -> int:
+        return self._path.__hash__()
+
+    def __eq__(self, other: object) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__eq__(target)
+
+    def __lt__(self, other: "Path") -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__lt__(target)
+
+    def __le__(self, other: "Path") -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__le__(target)
+
+    def __gt__(self, other: "Path") -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__gt__(target)
+
+    def __ge__(self, other: "Path") -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__ge__(target)
+
+    def __truediv__(self, other: Any) -> "Path":
+        return Path(self._path / other)
+
+    def __rtruediv__(self, other: Any) -> "Path":
+        return Path(other) / self
+
+    @property
+    def parts(self) -> Tuple[str, ...]:
+        return self._path.parts
+
+    @property
+    def drive(self) -> str:
+        return self._path.drive
+
+    @property
+    def root(self) -> str:
+        return self._path.root
+
+    @property
+    def anchor(self) -> str:
+        return self._path.anchor
+
+    @property
+    def parents(self) -> Sequence["Path"]:
+        return tuple(Path(p) for p in self._path.parents)
+
+    @property
+    def parent(self) -> "Path":
+        return Path(self._path.parent)
+
+    @property
+    def name(self) -> str:
+        return self._path.name
+
+    @property
+    def suffix(self) -> str:
+        return self._path.suffix
+
+    @property
+    def suffixes(self) -> List[str]:
+        return self._path.suffixes
+
+    @property
+    def stem(self) -> str:
+        return self._path.stem
+
+    async def absolute(self) -> "Path":
+        path = await to_thread.run_sync(self._path.absolute)
+        return Path(path)
+
+    def as_posix(self) -> str:
+        return self._path.as_posix()
+
+    def as_uri(self) -> str:
+        return self._path.as_uri()
+
+    def match(self, path_pattern: str) -> bool:
+        return self._path.match(path_pattern)
+
+    def is_relative_to(self, *other: Union[str, "PathLike[str]"]) -> bool:
+        try:
+            self.relative_to(*other)
+            return True
+        except ValueError:
+            return False
+
+    async def chmod(self, mode: int, *, follow_symlinks: bool = True) -> None:
+        func = partial(os.chmod, follow_symlinks=follow_symlinks)
+        return await to_thread.run_sync(func, self._path, mode)
+
+    @classmethod
+    async def cwd(cls) -> "Path":
+        path = await to_thread.run_sync(pathlib.Path.cwd)
+        return cls(path)
+
+    async def exists(self) -> bool:
+        return await to_thread.run_sync(self._path.exists, cancellable=True)
+
+    async def expanduser(self) -> "Path":
+        return Path(await to_thread.run_sync(self._path.expanduser, cancellable=True))
+
+    def glob(self, pattern: str) -> AsyncIterator["Path"]:
+        gen = self._path.glob(pattern)
+        return _PathIterator(gen)
+
+    async def group(self) -> str:
+        return await to_thread.run_sync(self._path.group, cancellable=True)
+
+    async def hardlink_to(self, target: Union[str, pathlib.Path, "Path"]) -> None:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(os.link, target, self)
+
+    @classmethod
+    async def home(cls) -> "Path":
+        home_path = await to_thread.run_sync(pathlib.Path.home)
+        return cls(home_path)
+
+    def is_absolute(self) -> bool:
+        return self._path.is_absolute()
+
+    async def is_block_device(self) -> bool:
+        return await to_thread.run_sync(self._path.is_block_device, cancellable=True)
+
+    async def is_char_device(self) -> bool:
+        return await to_thread.run_sync(self._path.is_char_device, cancellable=True)
+
+    async def is_dir(self) -> bool:
+        return await to_thread.run_sync(self._path.is_dir, cancellable=True)
+
+    async def is_fifo(self) -> bool:
+        return await to_thread.run_sync(self._path.is_fifo, cancellable=True)
+
+    async def is_file(self) -> bool:
+        return await to_thread.run_sync(self._path.is_file, cancellable=True)
+
+    async def is_mount(self) -> bool:
+        return await to_thread.run_sync(os.path.ismount, self._path, cancellable=True)
+
+    def is_reserved(self) -> bool:
+        return self._path.is_reserved()
+
+    async def is_socket(self) -> bool:
+        return await to_thread.run_sync(self._path.is_socket, cancellable=True)
+
+    async def is_symlink(self) -> bool:
+        return await to_thread.run_sync(self._path.is_symlink, cancellable=True)
+
+    def iterdir(self) -> AsyncIterator["Path"]:
+        gen = self._path.iterdir()
+        return _PathIterator(gen)
+
+    def joinpath(self, *args: Union[str, "PathLike[str]"]) -> "Path":
+        return Path(self._path.joinpath(*args))
+
+    async def lchmod(self, mode: int) -> None:
+        await to_thread.run_sync(self._path.lchmod, mode)
+
+    async def lstat(self) -> os.stat_result:
+        return await to_thread.run_sync(self._path.lstat, cancellable=True)
+
+    async def mkdir(
+        self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False
+    ) -> None:
+        await to_thread.run_sync(self._path.mkdir, mode, parents, exist_ok)
+
+    @overload
+    async def open(
+        self,
+        mode: OpenBinaryMode,
+        buffering: int = ...,
+        encoding: Optional[str] = ...,
+        errors: Optional[str] = ...,
+        newline: Optional[str] = ...,
+    ) -> AsyncFile[bytes]:
+        ...
+
+    @overload
+    async def open(
+        self,
+        mode: OpenTextMode = ...,
+        buffering: int = ...,
+        encoding: Optional[str] = ...,
+        errors: Optional[str] = ...,
+        newline: Optional[str] = ...,
+    ) -> AsyncFile[str]:
+        ...
+
+    async def open(
+        self,
+        mode: str = "r",
+        buffering: int = -1,
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        newline: Optional[str] = None,
+    ) -> AsyncFile[Any]:
+        fp = await to_thread.run_sync(
+            self._path.open, mode, buffering, encoding, errors, newline
+        )
+        return AsyncFile(fp)
+
+    async def owner(self) -> str:
+        return await to_thread.run_sync(self._path.owner, cancellable=True)
+
+    async def read_bytes(self) -> bytes:
+        return await to_thread.run_sync(self._path.read_bytes)
+
+    async def read_text(
+        self, encoding: Optional[str] = None, errors: Optional[str] = None
+    ) -> str:
+        return await to_thread.run_sync(self._path.read_text, encoding, errors)
+
+    def relative_to(self, *other: Union[str, "PathLike[str]"]) -> "Path":
+        return Path(self._path.relative_to(*other))
+
+    async def readlink(self) -> "Path":
+        target = await to_thread.run_sync(os.readlink, self._path)
+        return Path(cast(str, target))
+
+    async def rename(self, target: Union[str, pathlib.PurePath, "Path"]) -> "Path":
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.rename, target)
+        return Path(target)
+
+    async def replace(self, target: Union[str, pathlib.PurePath, "Path"]) -> "Path":
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.replace, target)
+        return Path(target)
+
+    async def resolve(self, strict: bool = False) -> "Path":
+        func = partial(self._path.resolve, strict=strict)
+        return Path(await to_thread.run_sync(func, cancellable=True))
+
+    def rglob(self, pattern: str) -> AsyncIterator["Path"]:
+        gen = self._path.rglob(pattern)
+        return _PathIterator(gen)
+
+    async def rmdir(self) -> None:
+        await to_thread.run_sync(self._path.rmdir)
+
+    async def samefile(
+        self, other_path: Union[str, bytes, int, pathlib.Path, "Path"]
+    ) -> bool:
+        if isinstance(other_path, Path):
+            other_path = other_path._path
+
+        return await to_thread.run_sync(
+            self._path.samefile, other_path, cancellable=True
+        )
+
+    async def stat(self, *, follow_symlinks: bool = True) -> os.stat_result:
+        func = partial(os.stat, follow_symlinks=follow_symlinks)
+        return await to_thread.run_sync(func, self._path, cancellable=True)
+
+    async def symlink_to(
+        self,
+        target: Union[str, pathlib.Path, "Path"],
+        target_is_directory: bool = False,
+    ) -> None:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.symlink_to, target, target_is_directory)
+
+    async def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None:
+        await to_thread.run_sync(self._path.touch, mode, exist_ok)
+
+    async def unlink(self, missing_ok: bool = False) -> None:
+        try:
+            await to_thread.run_sync(self._path.unlink)
+        except FileNotFoundError:
+            if not missing_ok:
+                raise
+
+    def with_name(self, name: str) -> "Path":
+        return Path(self._path.with_name(name))
+
+    def with_stem(self, stem: str) -> "Path":
+        return Path(self._path.with_name(stem + self._path.suffix))
+
+    def with_suffix(self, suffix: str) -> "Path":
+        return Path(self._path.with_suffix(suffix))
+
+    async def write_bytes(self, data: bytes) -> int:
+        return await to_thread.run_sync(self._path.write_bytes, data)
+
+    async def write_text(
+        self,
+        data: str,
+        encoding: Optional[str] = None,
+        errors: Optional[str] = None,
+        newline: Optional[str] = None,
+    ) -> int:
+        # Path.write_text() does not support the "newline" parameter before Python 3.10
+        def sync_write_text() -> int:
+            with self._path.open(
+                "w", encoding=encoding, errors=errors, newline=newline
+            ) as fp:
+                return fp.write(data)
+
+        return await to_thread.run_sync(sync_write_text)
+
+
+PathLike.register(Path)

venv/lib/python3.11/site-packages/anyio/_core/_resources.py

@@ -0,0 +1,16 @@
+from ..abc import AsyncResource
+from ._tasks import CancelScope
+
+
+async def aclose_forcefully(resource: AsyncResource) -> None:
+    """
+    Close an asynchronous resource in a cancelled scope.
+
+    Doing this closes the resource without waiting on anything.
+
+    :param resource: the resource to close
+
+    """
+    with CancelScope() as scope:
+        scope.cancel()
+        await resource.aclose()

venv/lib/python3.11/site-packages/anyio/_core/_signals.py

@@ -0,0 +1,24 @@
+from typing import AsyncIterator
+
+from ._compat import DeprecatedAsyncContextManager
+from ._eventloop import get_asynclib
+
+
+def open_signal_receiver(
+    *signals: int,
+) -> DeprecatedAsyncContextManager[AsyncIterator[int]]:
+    """
+    Start receiving operating system signals.
+
+    :param signals: signals to receive (e.g. ``signal.SIGINT``)
+    :return: an asynchronous context manager for an asynchronous iterator which yields signal
+        numbers
+
+    .. warning:: Windows does not support signals natively so it is best to avoid relying on this
+        in cross-platform applications.
+
+    .. warning:: On asyncio, this permanently replaces any previous signal handler for the given
+        signals, as set via :meth:`~asyncio.loop.add_signal_handler`.
+
+    """
+    return get_asynclib().open_signal_receiver(*signals)

venv/lib/python3.11/site-packages/anyio/_core/_sockets.py

@@ -0,0 +1,587 @@
+import socket
+import ssl
+import sys
+from ipaddress import IPv6Address, ip_address
+from os import PathLike, chmod
+from pathlib import Path
+from socket import AddressFamily, SocketKind
+from typing import Awaitable, List, Optional, Tuple, Union, cast, overload
+
+from .. import to_thread
+from ..abc import (
+    ConnectedUDPSocket,
+    IPAddressType,
+    IPSockAddrType,
+    SocketListener,
+    SocketStream,
+    UDPSocket,
+    UNIXSocketStream,
+)
+from ..streams.stapled import MultiListener
+from ..streams.tls import TLSStream
+from ._eventloop import get_asynclib
+from ._resources import aclose_forcefully
+from ._synchronization import Event
+from ._tasks import create_task_group, move_on_after
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+IPPROTO_IPV6 = getattr(socket, "IPPROTO_IPV6", 41)  # https://bugs.python.org/issue29515
+
+GetAddrInfoReturnType = List[
+    Tuple[AddressFamily, SocketKind, int, str, Tuple[str, int]]
+]
+AnyIPAddressFamily = Literal[
+    AddressFamily.AF_UNSPEC, AddressFamily.AF_INET, AddressFamily.AF_INET6
+]
+IPAddressFamily = Literal[AddressFamily.AF_INET, AddressFamily.AF_INET6]
+
+
+# tls_hostname given
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    ssl_context: Optional[ssl.SSLContext] = ...,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: str,
+    happy_eyeballs_delay: float = ...,
+) -> TLSStream:
+    ...
+
+
+# ssl_context given
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    ssl_context: ssl.SSLContext,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: Optional[str] = ...,
+    happy_eyeballs_delay: float = ...,
+) -> TLSStream:
+    ...
+
+
+# tls=True
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    tls: Literal[True],
+    ssl_context: Optional[ssl.SSLContext] = ...,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: Optional[str] = ...,
+    happy_eyeballs_delay: float = ...,
+) -> TLSStream:
+    ...
+
+
+# tls=False
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    tls: Literal[False],
+    ssl_context: Optional[ssl.SSLContext] = ...,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: Optional[str] = ...,
+    happy_eyeballs_delay: float = ...,
+) -> SocketStream:
+    ...
+
+
+# No TLS arguments
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = ...,
+    happy_eyeballs_delay: float = ...,
+) -> SocketStream:
+    ...
+
+
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: Optional[IPAddressType] = None,
+    tls: bool = False,
+    ssl_context: Optional[ssl.SSLContext] = None,
+    tls_standard_compatible: bool = True,
+    tls_hostname: Optional[str] = None,
+    happy_eyeballs_delay: float = 0.25,
+) -> Union[SocketStream, TLSStream]:
+    """
+    Connect to a host using the TCP protocol.
+
+    This function implements the stateless version of the Happy Eyeballs algorithm (RFC 6555).
+    If ``address`` is a host name that resolves to multiple IP addresses, each one is tried until
+    one connection attempt succeeds. If the first attempt does not connected within 250
+    milliseconds, a second attempt is started using the next address in the list, and so on.
+    On IPv6 enabled systems, an IPv6 address (if available) is tried first.
+
+    When the connection has been established, a TLS handshake will be done if either
+    ``ssl_context`` or ``tls_hostname`` is not ``None``, or if ``tls`` is ``True``.
+
+    :param remote_host: the IP address or host name to connect to
+    :param remote_port: port on the target host to connect to
+    :param local_host: the interface address or name to bind the socket to before connecting
+    :param tls: ``True`` to do a TLS handshake with the connected stream and return a
+        :class:`~anyio.streams.tls.TLSStream` instead
+    :param ssl_context: the SSL context object to use (if omitted, a default context is created)
+    :param tls_standard_compatible: If ``True``, performs the TLS shutdown handshake before closing
+        the stream and requires that the server does this as well. Otherwise,
+        :exc:`~ssl.SSLEOFError` may be raised during reads from the stream.
+        Some protocols, such as HTTP, require this option to be ``False``.
+        See :meth:`~ssl.SSLContext.wrap_socket` for details.
+    :param tls_hostname: host name to check the server certificate against (defaults to the value
+        of ``remote_host``)
+    :param happy_eyeballs_delay: delay (in seconds) before starting the next connection attempt
+    :return: a socket stream object if no TLS handshake was done, otherwise a TLS stream
+    :raises OSError: if the connection attempt fails
+
+    """
+    # Placed here due to https://github.com/python/mypy/issues/7057
+    connected_stream: Optional[SocketStream] = None
+
+    async def try_connect(remote_host: str, event: Event) -> None:
+        nonlocal connected_stream
+        try:
+            stream = await asynclib.connect_tcp(remote_host, remote_port, local_address)
+        except OSError as exc:
+            oserrors.append(exc)
+            return
+        else:
+            if connected_stream is None:
+                connected_stream = stream
+                tg.cancel_scope.cancel()
+            else:
+                await stream.aclose()
+        finally:
+            event.set()
+
+    asynclib = get_asynclib()
+    local_address: Optional[IPSockAddrType] = None
+    family = socket.AF_UNSPEC
+    if local_host:
+        gai_res = await getaddrinfo(str(local_host), None)
+        family, *_, local_address = gai_res[0]
+
+    target_host = str(remote_host)
+    try:
+        addr_obj = ip_address(remote_host)
+    except ValueError:
+        # getaddrinfo() will raise an exception if name resolution fails
+        gai_res = await getaddrinfo(
+            target_host, remote_port, family=family, type=socket.SOCK_STREAM
+        )
+
+        # Organize the list so that the first address is an IPv6 address (if available) and the
+        # second one is an IPv4 addresses. The rest can be in whatever order.
+        v6_found = v4_found = False
+        target_addrs: List[Tuple[socket.AddressFamily, str]] = []
+        for af, *rest, sa in gai_res:
+            if af == socket.AF_INET6 and not v6_found:
+                v6_found = True
+                target_addrs.insert(0, (af, sa[0]))
+            elif af == socket.AF_INET and not v4_found and v6_found:
+                v4_found = True
+                target_addrs.insert(1, (af, sa[0]))
+            else:
+                target_addrs.append((af, sa[0]))
+    else:
+        if isinstance(addr_obj, IPv6Address):
+            target_addrs = [(socket.AF_INET6, addr_obj.compressed)]
+        else:
+            target_addrs = [(socket.AF_INET, addr_obj.compressed)]
+
+    oserrors: List[OSError] = []
+    async with create_task_group() as tg:
+        for i, (af, addr) in enumerate(target_addrs):
+            event = Event()
+            tg.start_soon(try_connect, addr, event)
+            with move_on_after(happy_eyeballs_delay):
+                await event.wait()
+
+    if connected_stream is None:
+        cause = oserrors[0] if len(oserrors) == 1 else asynclib.ExceptionGroup(oserrors)
+        raise OSError("All connection attempts failed") from cause
+
+    if tls or tls_hostname or ssl_context:
+        try:
+            return await TLSStream.wrap(
+                connected_stream,
+                server_side=False,
+                hostname=tls_hostname or str(remote_host),
+                ssl_context=ssl_context,
+                standard_compatible=tls_standard_compatible,
+            )
+        except BaseException:
+            await aclose_forcefully(connected_stream)
+            raise
+
+    return connected_stream
+
+
+async def connect_unix(path: Union[str, "PathLike[str]"]) -> UNIXSocketStream:
+    """
+    Connect to the given UNIX socket.
+
+    Not available on Windows.
+
+    :param path: path to the socket
+    :return: a socket stream object
+
+    """
+    path = str(Path(path))
+    return await get_asynclib().connect_unix(path)
+
+
+async def create_tcp_listener(
+    *,
+    local_host: Optional[IPAddressType] = None,
+    local_port: int = 0,
+    family: AnyIPAddressFamily = socket.AddressFamily.AF_UNSPEC,
+    backlog: int = 65536,
+    reuse_port: bool = False,
+) -> MultiListener[SocketStream]:
+    """
+    Create a TCP socket listener.
+
+    :param local_port: port number to listen on
+    :param local_host: IP address of the interface to listen on. If omitted, listen on all IPv4
+        and IPv6 interfaces. To listen on all interfaces on a specific address family, use
+        ``0.0.0.0`` for IPv4 or ``::`` for IPv6.
+    :param family: address family (used if ``interface`` was omitted)
+    :param backlog: maximum number of queued incoming connections (up to a maximum of 2**16, or
+        65536)
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same address/port
+        (not supported on Windows)
+    :return: a list of listener objects
+
+    """
+    asynclib = get_asynclib()
+    backlog = min(backlog, 65536)
+    local_host = str(local_host) if local_host is not None else None
+    gai_res = await getaddrinfo(
+        local_host,  # type: ignore[arg-type]
+        local_port,
+        family=family,
+        type=socket.SOCK_STREAM,
+        flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
+    )
+    listeners: List[SocketListener] = []
+    try:
+        # The set() is here to work around a glibc bug:
+        # https://sourceware.org/bugzilla/show_bug.cgi?id=14969
+        for fam, *_, sockaddr in sorted(set(gai_res)):
+            raw_socket = socket.socket(fam)
+            raw_socket.setblocking(False)
+
+            # For Windows, enable exclusive address use. For others, enable address reuse.
+            if sys.platform == "win32":
+                raw_socket.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
+            else:
+                raw_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+            if reuse_port:
+                raw_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+            # If only IPv6 was requested, disable dual stack operation
+            if fam == socket.AF_INET6:
+                raw_socket.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, 1)
+
+            raw_socket.bind(sockaddr)
+            raw_socket.listen(backlog)
+            listener = asynclib.TCPSocketListener(raw_socket)
+            listeners.append(listener)
+    except BaseException:
+        for listener in listeners:
+            await listener.aclose()
+
+        raise
+
+    return MultiListener(listeners)
+
+
+async def create_unix_listener(
+    path: Union[str, "PathLike[str]"],
+    *,
+    mode: Optional[int] = None,
+    backlog: int = 65536,
+) -> SocketListener:
+    """
+    Create a UNIX socket listener.
+
+    Not available on Windows.
+
+    :param path: path of the socket
+    :param mode: permissions to set on the socket
+    :param backlog: maximum number of queued incoming connections (up to a maximum of 2**16, or
+        65536)
+    :return: a listener object
+
+    .. versionchanged:: 3.0
+        If a socket already exists on the file system in the given path, it will be removed first.
+
+    """
+    path_str = str(path)
+    path = Path(path)
+    if path.is_socket():
+        path.unlink()
+
+    backlog = min(backlog, 65536)
+    raw_socket = socket.socket(socket.AF_UNIX)
+    raw_socket.setblocking(False)
+    try:
+        await to_thread.run_sync(raw_socket.bind, path_str, cancellable=True)
+        if mode is not None:
+            await to_thread.run_sync(chmod, path_str, mode, cancellable=True)
+
+        raw_socket.listen(backlog)
+        return get_asynclib().UNIXSocketListener(raw_socket)
+    except BaseException:
+        raw_socket.close()
+        raise
+
+
+async def create_udp_socket(
+    family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC,
+    *,
+    local_host: Optional[IPAddressType] = None,
+    local_port: int = 0,
+    reuse_port: bool = False,
+) -> UDPSocket:
+    """
+    Create a UDP socket.
+
+    If ``port`` has been given, the socket will be bound to this port on the local machine,
+    making this socket suitable for providing UDP based services.
+
+    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically determined from
+        ``local_host`` if omitted
+    :param local_host: IP address or host name of the local interface to bind to
+    :param local_port: local port to bind to
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same address/port
+        (not supported on Windows)
+    :return: a UDP socket
+
+    """
+    if family is AddressFamily.AF_UNSPEC and not local_host:
+        raise ValueError('Either "family" or "local_host" must be given')
+
+    if local_host:
+        gai_res = await getaddrinfo(
+            str(local_host),
+            local_port,
+            family=family,
+            type=socket.SOCK_DGRAM,
+            flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
+        )
+        family = cast(AnyIPAddressFamily, gai_res[0][0])
+        local_address = gai_res[0][-1]
+    elif family is AddressFamily.AF_INET6:
+        local_address = ("::", 0)
+    else:
+        local_address = ("0.0.0.0", 0)
+
+    return await get_asynclib().create_udp_socket(
+        family, local_address, None, reuse_port
+    )
+
+
+async def create_connected_udp_socket(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC,
+    local_host: Optional[IPAddressType] = None,
+    local_port: int = 0,
+    reuse_port: bool = False,
+) -> ConnectedUDPSocket:
+    """
+    Create a connected UDP socket.
+
+    Connected UDP sockets can only communicate with the specified remote host/port, and any packets
+    sent from other sources are dropped.
+
+    :param remote_host: remote host to set as the default target
+    :param remote_port: port on the remote host to set as the default target
+    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically determined from
+        ``local_host`` or ``remote_host`` if omitted
+    :param local_host: IP address or host name of the local interface to bind to
+    :param local_port: local port to bind to
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same address/port
+        (not supported on Windows)
+    :return: a connected UDP socket
+
+    """
+    local_address = None
+    if local_host:
+        gai_res = await getaddrinfo(
+            str(local_host),
+            local_port,
+            family=family,
+            type=socket.SOCK_DGRAM,
+            flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
+        )
+        family = cast(AnyIPAddressFamily, gai_res[0][0])
+        local_address = gai_res[0][-1]
+
+    gai_res = await getaddrinfo(
+        str(remote_host), remote_port, family=family, type=socket.SOCK_DGRAM
+    )
+    family = cast(AnyIPAddressFamily, gai_res[0][0])
+    remote_address = gai_res[0][-1]
+
+    return await get_asynclib().create_udp_socket(
+        family, local_address, remote_address, reuse_port
+    )
+
+
+async def getaddrinfo(
+    host: Union[bytearray, bytes, str],
+    port: Union[str, int, None],
+    *,
+    family: Union[int, AddressFamily] = 0,
+    type: Union[int, SocketKind] = 0,
+    proto: int = 0,
+    flags: int = 0,
+) -> GetAddrInfoReturnType:
+    """
+    Look up a numeric IP address given a host name.
+
+    Internationalized domain names are translated according to the (non-transitional) IDNA 2008
+    standard.
+
+    .. note:: 4-tuple IPv6 socket addresses are automatically converted to 2-tuples of
+        (host, port), unlike what :func:`socket.getaddrinfo` does.
+
+    :param host: host name
+    :param port: port number
+    :param family: socket family (`'AF_INET``, ...)
+    :param type: socket type (``SOCK_STREAM``, ...)
+    :param proto: protocol number
+    :param flags: flags to pass to upstream ``getaddrinfo()``
+    :return: list of tuples containing (family, type, proto, canonname, sockaddr)
+
+    .. seealso:: :func:`socket.getaddrinfo`
+
+    """
+    # Handle unicode hostnames
+    if isinstance(host, str):
+        try:
+            encoded_host = host.encode("ascii")
+        except UnicodeEncodeError:
+            import idna
+
+            encoded_host = idna.encode(host, uts46=True)
+    else:
+        encoded_host = host
+
+    gai_res = await get_asynclib().getaddrinfo(
+        encoded_host, port, family=family, type=type, proto=proto, flags=flags
+    )
+    return [
+        (family, type, proto, canonname, convert_ipv6_sockaddr(sockaddr))
+        for family, type, proto, canonname, sockaddr in gai_res
+    ]
+
+
+def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Awaitable[Tuple[str, str]]:
+    """
+    Look up the host name of an IP address.
+
+    :param sockaddr: socket address (e.g. (ipaddress, port) for IPv4)
+    :param flags: flags to pass to upstream ``getnameinfo()``
+    :return: a tuple of (host name, service name)
+
+    .. seealso:: :func:`socket.getnameinfo`
+
+    """
+    return get_asynclib().getnameinfo(sockaddr, flags)
+
+
+def wait_socket_readable(sock: socket.socket) -> Awaitable[None]:
+    """
+    Wait until the given socket has data to be read.
+
+    This does **NOT** work on Windows when using the asyncio backend with a proactor event loop
+    (default on py3.8+).
+
+    .. warning:: Only use this on raw sockets that have not been wrapped by any higher level
+        constructs like socket streams!
+
+    :param sock: a socket object
+    :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the
+        socket to become readable
+    :raises ~anyio.BusyResourceError: if another task is already waiting for the socket
+        to become readable
+
+    """
+    return get_asynclib().wait_socket_readable(sock)
+
+
+def wait_socket_writable(sock: socket.socket) -> Awaitable[None]:
+    """
+    Wait until the given socket can be written to.
+
+    This does **NOT** work on Windows when using the asyncio backend with a proactor event loop
+    (default on py3.8+).
+
+    .. warning:: Only use this on raw sockets that have not been wrapped by any higher level
+        constructs like socket streams!
+
+    :param sock: a socket object
+    :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the
+        socket to become writable
+    :raises ~anyio.BusyResourceError: if another task is already waiting for the socket
+        to become writable
+
+    """
+    return get_asynclib().wait_socket_writable(sock)
+
+
+#
+# Private API
+#
+
+
+def convert_ipv6_sockaddr(
+    sockaddr: Union[Tuple[str, int, int, int], Tuple[str, int]]
+) -> Tuple[str, int]:
+    """
+    Convert a 4-tuple IPv6 socket address to a 2-tuple (address, port) format.
+
+    If the scope ID is nonzero, it is added to the address, separated with ``%``.
+    Otherwise the flow id and scope id are simply cut off from the tuple.
+    Any other kinds of socket addresses are returned as-is.
+
+    :param sockaddr: the result of :meth:`~socket.socket.getsockname`
+    :return: the converted socket address
+
+    """
+    # This is more complicated than it should be because of MyPy
+    if isinstance(sockaddr, tuple) and len(sockaddr) == 4:
+        host, port, flowinfo, scope_id = cast(Tuple[str, int, int, int], sockaddr)
+        if scope_id:
+            # Add scope_id to the address
+            return f"{host}%{scope_id}", port
+        else:
+            return host, port
+    else:
+        return cast(Tuple[str, int], sockaddr)

venv/lib/python3.11/site-packages/anyio/_core/_streams.py

@@ -0,0 +1,45 @@
+import math
+from typing import Any, Optional, Tuple, Type, TypeVar, overload
+
+from ..streams.memory import (
+    MemoryObjectReceiveStream,
+    MemoryObjectSendStream,
+    MemoryObjectStreamState,
+)
+
+T_Item = TypeVar("T_Item")
+
+
+@overload
+def create_memory_object_stream(
+    max_buffer_size: float, item_type: Type[T_Item]
+) -> Tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]]:
+    ...
+
+
+@overload
+def create_memory_object_stream(
+    max_buffer_size: float = 0,
+) -> Tuple[MemoryObjectSendStream[Any], MemoryObjectReceiveStream[Any]]:
+    ...
+
+
+def create_memory_object_stream(
+    max_buffer_size: float = 0, item_type: Optional[Type[T_Item]] = None
+) -> Tuple[MemoryObjectSendStream[Any], MemoryObjectReceiveStream[Any]]:
+    """
+    Create a memory object stream.
+
+    :param max_buffer_size: number of items held in the buffer until ``send()`` starts blocking
+    :param item_type: type of item, for marking the streams with the right generic type for
+        static typing (not used at run time)
+    :return: a tuple of (send stream, receive stream)
+
+    """
+    if max_buffer_size != math.inf and not isinstance(max_buffer_size, int):
+        raise ValueError("max_buffer_size must be either an integer or math.inf")
+    if max_buffer_size < 0:
+        raise ValueError("max_buffer_size cannot be negative")
+
+    state: MemoryObjectStreamState = MemoryObjectStreamState(max_buffer_size)
+    return MemoryObjectSendStream(state), MemoryObjectReceiveStream(state)

venv/lib/python3.11/site-packages/anyio/_core/_subprocesses.py

@@ -0,0 +1,136 @@
+from io import BytesIO
+from os import PathLike
+from subprocess import DEVNULL, PIPE, CalledProcessError, CompletedProcess
+from typing import (
+    IO,
+    Any,
+    AsyncIterable,
+    List,
+    Mapping,
+    Optional,
+    Sequence,
+    Union,
+    cast,
+)
+
+from ..abc import Process
+from ._eventloop import get_asynclib
+from ._tasks import create_task_group
+
+
+async def run_process(
+    command: Union[str, bytes, Sequence[Union[str, bytes]]],
+    *,
+    input: Optional[bytes] = None,
+    stdout: Union[int, IO[Any], None] = PIPE,
+    stderr: Union[int, IO[Any], None] = PIPE,
+    check: bool = True,
+    cwd: Union[str, bytes, "PathLike[str]", None] = None,
+    env: Optional[Mapping[str, str]] = None,
+    start_new_session: bool = False,
+) -> "CompletedProcess[bytes]":
+    """
+    Run an external command in a subprocess and wait until it completes.
+
+    .. seealso:: :func:`subprocess.run`
+
+    :param command: either a string to pass to the shell, or an iterable of strings containing the
+        executable name or path and its arguments
+    :param input: bytes passed to the standard input of the subprocess
+    :param stdout: either :data:`subprocess.PIPE` or :data:`subprocess.DEVNULL`
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL` or
+        :data:`subprocess.STDOUT`
+    :param check: if ``True``, raise :exc:`~subprocess.CalledProcessError` if the process
+        terminates with a return code other than 0
+    :param cwd: If not ``None``, change the working directory to this before running the command
+    :param env: if not ``None``, this mapping replaces the inherited environment variables from the
+        parent process
+    :param start_new_session: if ``true`` the setsid() system call will be made in the child
+        process prior to the execution of the subprocess. (POSIX only)
+    :return: an object representing the completed process
+    :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process exits with a
+        nonzero return code
+
+    """
+
+    async def drain_stream(stream: AsyncIterable[bytes], index: int) -> None:
+        buffer = BytesIO()
+        async for chunk in stream:
+            buffer.write(chunk)
+
+        stream_contents[index] = buffer.getvalue()
+
+    async with await open_process(
+        command,
+        stdin=PIPE if input else DEVNULL,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        start_new_session=start_new_session,
+    ) as process:
+        stream_contents: List[Optional[bytes]] = [None, None]
+        try:
+            async with create_task_group() as tg:
+                if process.stdout:
+                    tg.start_soon(drain_stream, process.stdout, 0)
+                if process.stderr:
+                    tg.start_soon(drain_stream, process.stderr, 1)
+                if process.stdin and input:
+                    await process.stdin.send(input)
+                    await process.stdin.aclose()
+
+                await process.wait()
+        except BaseException:
+            process.kill()
+            raise
+
+    output, errors = stream_contents
+    if check and process.returncode != 0:
+        raise CalledProcessError(cast(int, process.returncode), command, output, errors)
+
+    return CompletedProcess(command, cast(int, process.returncode), output, errors)
+
+
+async def open_process(
+    command: Union[str, bytes, Sequence[Union[str, bytes]]],
+    *,
+    stdin: Union[int, IO[Any], None] = PIPE,
+    stdout: Union[int, IO[Any], None] = PIPE,
+    stderr: Union[int, IO[Any], None] = PIPE,
+    cwd: Union[str, bytes, "PathLike[str]", None] = None,
+    env: Optional[Mapping[str, str]] = None,
+    start_new_session: bool = False,
+) -> Process:
+    """
+    Start an external command in a subprocess.
+
+    .. seealso:: :class:`subprocess.Popen`
+
+    :param command: either a string to pass to the shell, or an iterable of strings containing the
+        executable name or path and its arguments
+    :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, a
+        file-like object, or ``None``
+    :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        a file-like object, or ``None``
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        :data:`subprocess.STDOUT`, a file-like object, or ``None``
+    :param cwd: If not ``None``, the working directory is changed before executing
+    :param env: If env is not ``None``, it must be a mapping that defines the environment
+        variables for the new process
+    :param start_new_session: if ``true`` the setsid() system call will be made in the child
+        process prior to the execution of the subprocess. (POSIX only)
+    :return: an asynchronous process object
+
+    """
+    shell = isinstance(command, str)
+    return await get_asynclib().open_process(
+        command,
+        shell=shell,
+        stdin=stdin,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        start_new_session=start_new_session,
+    )

venv/lib/python3.11/site-packages/anyio/_core/_synchronization.py

@@ -0,0 +1,595 @@
+from collections import deque
+from dataclasses import dataclass
+from types import TracebackType
+from typing import Deque, Optional, Tuple, Type
+from warnings import warn
+
+from ..lowlevel import cancel_shielded_checkpoint, checkpoint, checkpoint_if_cancelled
+from ._compat import DeprecatedAwaitable
+from ._eventloop import get_asynclib
+from ._exceptions import BusyResourceError, WouldBlock
+from ._tasks import CancelScope
+from ._testing import TaskInfo, get_current_task
+
+
+@dataclass(frozen=True)
+class EventStatistics:
+    """
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Event.wait`
+    """
+
+    tasks_waiting: int
+
+
+@dataclass(frozen=True)
+class CapacityLimiterStatistics:
+    """
+    :ivar int borrowed_tokens: number of tokens currently borrowed by tasks
+    :ivar float total_tokens: total number of available tokens
+    :ivar tuple borrowers: tasks or other objects currently holding tokens borrowed from this
+        limiter
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.CapacityLimiter.acquire` or
+        :meth:`~.CapacityLimiter.acquire_on_behalf_of`
+    """
+
+    borrowed_tokens: int
+    total_tokens: float
+    borrowers: Tuple[object, ...]
+    tasks_waiting: int
+
+
+@dataclass(frozen=True)
+class LockStatistics:
+    """
+    :ivar bool locked: flag indicating if this lock is locked or not
+    :ivar ~anyio.TaskInfo owner: task currently holding the lock (or ``None`` if the lock is not
+        held by any task)
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Lock.acquire`
+    """
+
+    locked: bool
+    owner: Optional[TaskInfo]
+    tasks_waiting: int
+
+
+@dataclass(frozen=True)
+class ConditionStatistics:
+    """
+    :ivar int tasks_waiting: number of tasks blocked on :meth:`~.Condition.wait`
+    :ivar ~anyio.LockStatistics lock_statistics: statistics of the underlying :class:`~.Lock`
+    """
+
+    tasks_waiting: int
+    lock_statistics: LockStatistics
+
+
+@dataclass(frozen=True)
+class SemaphoreStatistics:
+    """
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Semaphore.acquire`
+
+    """
+
+    tasks_waiting: int
+
+
+class Event:
+    def __new__(cls) -> "Event":
+        return get_asynclib().Event()
+
+    def set(self) -> DeprecatedAwaitable:
+        """Set the flag, notifying all listeners."""
+        raise NotImplementedError
+
+    def is_set(self) -> bool:
+        """Return ``True`` if the flag is set, ``False`` if not."""
+        raise NotImplementedError
+
+    async def wait(self) -> None:
+        """
+        Wait until the flag has been set.
+
+        If the flag has already been set when this method is called, it returns immediately.
+
+        """
+        raise NotImplementedError
+
+    def statistics(self) -> EventStatistics:
+        """Return statistics about the current state of this event."""
+        raise NotImplementedError
+
+
+class Lock:
+    _owner_task: Optional[TaskInfo] = None
+
+    def __init__(self) -> None:
+        self._waiters: Deque[Tuple[TaskInfo, Event]] = deque()
+
+    async def __aenter__(self) -> None:
+        await self.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.release()
+
+    async def acquire(self) -> None:
+        """Acquire the lock."""
+        await checkpoint_if_cancelled()
+        try:
+            self.acquire_nowait()
+        except WouldBlock:
+            task = get_current_task()
+            event = Event()
+            token = task, event
+            self._waiters.append(token)
+            try:
+                await event.wait()
+            except BaseException:
+                if not event.is_set():
+                    self._waiters.remove(token)
+                elif self._owner_task == task:
+                    self.release()
+
+                raise
+
+            assert self._owner_task == task
+        else:
+            try:
+                await cancel_shielded_checkpoint()
+            except BaseException:
+                self.release()
+                raise
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the lock, without blocking.
+
+        :raises ~WouldBlock: if the operation would block
+
+        """
+        task = get_current_task()
+        if self._owner_task == task:
+            raise RuntimeError("Attempted to acquire an already held Lock")
+
+        if self._owner_task is not None:
+            raise WouldBlock
+
+        self._owner_task = task
+
+    def release(self) -> DeprecatedAwaitable:
+        """Release the lock."""
+        if self._owner_task != get_current_task():
+            raise RuntimeError("The current task is not holding this lock")
+
+        if self._waiters:
+            self._owner_task, event = self._waiters.popleft()
+            event.set()
+        else:
+            del self._owner_task
+
+        return DeprecatedAwaitable(self.release)
+
+    def locked(self) -> bool:
+        """Return True if the lock is currently held."""
+        return self._owner_task is not None
+
+    def statistics(self) -> LockStatistics:
+        """
+        Return statistics about the current state of this lock.
+
+        .. versionadded:: 3.0
+        """
+        return LockStatistics(self.locked(), self._owner_task, len(self._waiters))
+
+
+class Condition:
+    _owner_task: Optional[TaskInfo] = None
+
+    def __init__(self, lock: Optional[Lock] = None):
+        self._lock = lock or Lock()
+        self._waiters: Deque[Event] = deque()
+
+    async def __aenter__(self) -> None:
+        await self.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.release()
+
+    def _check_acquired(self) -> None:
+        if self._owner_task != get_current_task():
+            raise RuntimeError("The current task is not holding the underlying lock")
+
+    async def acquire(self) -> None:
+        """Acquire the underlying lock."""
+        await self._lock.acquire()
+        self._owner_task = get_current_task()
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the underlying lock, without blocking.
+
+        :raises ~WouldBlock: if the operation would block
+
+        """
+        self._lock.acquire_nowait()
+        self._owner_task = get_current_task()
+
+    def release(self) -> DeprecatedAwaitable:
+        """Release the underlying lock."""
+        self._lock.release()
+        return DeprecatedAwaitable(self.release)
+
+    def locked(self) -> bool:
+        """Return True if the lock is set."""
+        return self._lock.locked()
+
+    def notify(self, n: int = 1) -> None:
+        """Notify exactly n listeners."""
+        self._check_acquired()
+        for _ in range(n):
+            try:
+                event = self._waiters.popleft()
+            except IndexError:
+                break
+
+            event.set()
+
+    def notify_all(self) -> None:
+        """Notify all the listeners."""
+        self._check_acquired()
+        for event in self._waiters:
+            event.set()
+
+        self._waiters.clear()
+
+    async def wait(self) -> None:
+        """Wait for a notification."""
+        await checkpoint()
+        event = Event()
+        self._waiters.append(event)
+        self.release()
+        try:
+            await event.wait()
+        except BaseException:
+            if not event.is_set():
+                self._waiters.remove(event)
+
+            raise
+        finally:
+            with CancelScope(shield=True):
+                await self.acquire()
+
+    def statistics(self) -> ConditionStatistics:
+        """
+        Return statistics about the current state of this condition.
+
+        .. versionadded:: 3.0
+        """
+        return ConditionStatistics(len(self._waiters), self._lock.statistics())
+
+
+class Semaphore:
+    def __init__(self, initial_value: int, *, max_value: Optional[int] = None):
+        if not isinstance(initial_value, int):
+            raise TypeError("initial_value must be an integer")
+        if initial_value < 0:
+            raise ValueError("initial_value must be >= 0")
+        if max_value is not None:
+            if not isinstance(max_value, int):
+                raise TypeError("max_value must be an integer or None")
+            if max_value < initial_value:
+                raise ValueError(
+                    "max_value must be equal to or higher than initial_value"
+                )
+
+        self._value = initial_value
+        self._max_value = max_value
+        self._waiters: Deque[Event] = deque()
+
+    async def __aenter__(self) -> "Semaphore":
+        await self.acquire()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        self.release()
+
+    async def acquire(self) -> None:
+        """Decrement the semaphore value, blocking if necessary."""
+        await checkpoint_if_cancelled()
+        try:
+            self.acquire_nowait()
+        except WouldBlock:
+            event = Event()
+            self._waiters.append(event)
+            try:
+                await event.wait()
+            except BaseException:
+                if not event.is_set():
+                    self._waiters.remove(event)
+                else:
+                    self.release()
+
+                raise
+        else:
+            try:
+                await cancel_shielded_checkpoint()
+            except BaseException:
+                self.release()
+                raise
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the underlying lock, without blocking.
+
+        :raises ~WouldBlock: if the operation would block
+
+        """
+        if self._value == 0:
+            raise WouldBlock
+
+        self._value -= 1
+
+    def release(self) -> DeprecatedAwaitable:
+        """Increment the semaphore value."""
+        if self._max_value is not None and self._value == self._max_value:
+            raise ValueError("semaphore released too many times")
+
+        if self._waiters:
+            self._waiters.popleft().set()
+        else:
+            self._value += 1
+
+        return DeprecatedAwaitable(self.release)
+
+    @property
+    def value(self) -> int:
+        """The current value of the semaphore."""
+        return self._value
+
+    @property
+    def max_value(self) -> Optional[int]:
+        """The maximum value of the semaphore."""
+        return self._max_value
+
+    def statistics(self) -> SemaphoreStatistics:
+        """
+        Return statistics about the current state of this semaphore.
+
+        .. versionadded:: 3.0
+        """
+        return SemaphoreStatistics(len(self._waiters))
+
+
+class CapacityLimiter:
+    def __new__(cls, total_tokens: float) -> "CapacityLimiter":
+        return get_asynclib().CapacityLimiter(total_tokens)
+
+    async def __aenter__(self) -> None:
+        raise NotImplementedError
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        raise NotImplementedError
+
+    @property
+    def total_tokens(self) -> float:
+        """
+        The total number of tokens available for borrowing.
+
+        This is a read-write property. If the total number of tokens is increased, the
+        proportionate number of tasks waiting on this limiter will be granted their tokens.
+
+        .. versionchanged:: 3.0
+            The property is now writable.
+
+        """
+        raise NotImplementedError
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        raise NotImplementedError
+
+    async def set_total_tokens(self, value: float) -> None:
+        warn(
+            "CapacityLimiter.set_total_tokens has been deprecated. Set the value of the"
+            '"total_tokens" attribute directly.',
+            DeprecationWarning,
+        )
+        self.total_tokens = value
+
+    @property
+    def borrowed_tokens(self) -> int:
+        """The number of tokens that have currently been borrowed."""
+        raise NotImplementedError
+
+    @property
+    def available_tokens(self) -> float:
+        """The number of tokens currently available to be borrowed"""
+        raise NotImplementedError
+
+    def acquire_nowait(self) -> DeprecatedAwaitable:
+        """
+        Acquire a token for the current task without waiting for one to become available.
+
+        :raises ~anyio.WouldBlock: if there are no tokens available for borrowing
+
+        """
+        raise NotImplementedError
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> DeprecatedAwaitable:
+        """
+        Acquire a token without waiting for one to become available.
+
+        :param borrower: the entity borrowing a token
+        :raises ~anyio.WouldBlock: if there are no tokens available for borrowing
+
+        """
+        raise NotImplementedError
+
+    async def acquire(self) -> None:
+        """
+        Acquire a token for the current task, waiting if necessary for one to become available.
+
+        """
+        raise NotImplementedError
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        """
+        Acquire a token, waiting if necessary for one to become available.
+
+        :param borrower: the entity borrowing a token
+
+        """
+        raise NotImplementedError
+
+    def release(self) -> None:
+        """
+        Release the token held by the current task.
+        :raises RuntimeError: if the current task has not borrowed a token from this limiter.
+
+        """
+        raise NotImplementedError
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        """
+        Release the token held by the given borrower.
+
+        :raises RuntimeError: if the borrower has not borrowed a token from this limiter.
+
+        """
+        raise NotImplementedError
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        """
+        Return statistics about the current state of this limiter.
+
+        .. versionadded:: 3.0
+
+        """
+        raise NotImplementedError
+
+
+def create_lock() -> Lock:
+    """
+    Create an asynchronous lock.
+
+    :return: a lock object
+
+    .. deprecated:: 3.0
+       Use :class:`~Lock` directly.
+
+    """
+    warn("create_lock() is deprecated -- use Lock() directly", DeprecationWarning)
+    return Lock()
+
+
+def create_condition(lock: Optional[Lock] = None) -> Condition:
+    """
+    Create an asynchronous condition.
+
+    :param lock: the lock to base the condition object on
+    :return: a condition object
+
+    .. deprecated:: 3.0
+       Use :class:`~Condition` directly.
+
+    """
+    warn(
+        "create_condition() is deprecated -- use Condition() directly",
+        DeprecationWarning,
+    )
+    return Condition(lock=lock)
+
+
+def create_event() -> Event:
+    """
+    Create an asynchronous event object.
+
+    :return: an event object
+
+    .. deprecated:: 3.0
+       Use :class:`~Event` directly.
+
+    """
+    warn("create_event() is deprecated -- use Event() directly", DeprecationWarning)
+    return get_asynclib().Event()
+
+
+def create_semaphore(value: int, *, max_value: Optional[int] = None) -> Semaphore:
+    """
+    Create an asynchronous semaphore.
+
+    :param value: the semaphore's initial value
+    :param max_value: if set, makes this a "bounded" semaphore that raises :exc:`ValueError` if the
+        semaphore's value would exceed this number
+    :return: a semaphore object
+
+    .. deprecated:: 3.0
+       Use :class:`~Semaphore` directly.
+
+    """
+    warn(
+        "create_semaphore() is deprecated -- use Semaphore() directly",
+        DeprecationWarning,
+    )
+    return Semaphore(value, max_value=max_value)
+
+
+def create_capacity_limiter(total_tokens: float) -> CapacityLimiter:
+    """
+    Create a capacity limiter.
+
+    :param total_tokens: the total number of tokens available for borrowing (can be an integer or
+        :data:`math.inf`)
+    :return: a capacity limiter object
+
+    .. deprecated:: 3.0
+       Use :class:`~CapacityLimiter` directly.
+
+    """
+    warn(
+        "create_capacity_limiter() is deprecated -- use CapacityLimiter() directly",
+        DeprecationWarning,
+    )
+    return get_asynclib().CapacityLimiter(total_tokens)
+
+
+class ResourceGuard:
+    __slots__ = "action", "_guarded"
+
+    def __init__(self, action: str):
+        self.action = action
+        self._guarded = False
+
+    def __enter__(self) -> None:
+        if self._guarded:
+            raise BusyResourceError(self.action)
+
+        self._guarded = True
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        self._guarded = False
+        return None

venv/lib/python3.11/site-packages/anyio/_core/_tasks.py

@@ -0,0 +1,178 @@
+import math
+from types import TracebackType
+from typing import Optional, Type
+from warnings import warn
+
+from ..abc._tasks import TaskGroup, TaskStatus
+from ._compat import (
+    DeprecatedAsyncContextManager,
+    DeprecatedAwaitable,
+    DeprecatedAwaitableFloat,
+)
+from ._eventloop import get_asynclib
+
+
+class _IgnoredTaskStatus(TaskStatus):
+    def started(self, value: object = None) -> None:
+        pass
+
+
+TASK_STATUS_IGNORED = _IgnoredTaskStatus()
+
+
+class CancelScope(DeprecatedAsyncContextManager["CancelScope"]):
+    """
+    Wraps a unit of work that can be made separately cancellable.
+
+    :param deadline: The time (clock value) when this scope is cancelled automatically
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    """
+
+    def __new__(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> "CancelScope":
+        return get_asynclib().CancelScope(shield=shield, deadline=deadline)
+
+    def cancel(self) -> DeprecatedAwaitable:
+        """Cancel this scope immediately."""
+        raise NotImplementedError
+
+    @property
+    def deadline(self) -> float:
+        """
+        The time (clock value) when this scope is cancelled automatically.
+
+        Will be ``float('inf')`` if no timeout has been set.
+
+        """
+        raise NotImplementedError
+
+    @deadline.setter
+    def deadline(self, value: float) -> None:
+        raise NotImplementedError
+
+    @property
+    def cancel_called(self) -> bool:
+        """``True`` if :meth:`cancel` has been called."""
+        raise NotImplementedError
+
+    @property
+    def shield(self) -> bool:
+        """
+        ``True`` if this scope is shielded from external cancellation.
+
+        While a scope is shielded, it will not receive cancellations from outside.
+
+        """
+        raise NotImplementedError
+
+    @shield.setter
+    def shield(self, value: bool) -> None:
+        raise NotImplementedError
+
+    def __enter__(self) -> "CancelScope":
+        raise NotImplementedError
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        raise NotImplementedError
+
+
+def open_cancel_scope(*, shield: bool = False) -> CancelScope:
+    """
+    Open a cancel scope.
+
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :return: a cancel scope
+
+    .. deprecated:: 3.0
+       Use :class:`~CancelScope` directly.
+
+    """
+    warn(
+        "open_cancel_scope() is deprecated -- use CancelScope() directly",
+        DeprecationWarning,
+    )
+    return get_asynclib().CancelScope(shield=shield)
+
+
+class FailAfterContextManager(DeprecatedAsyncContextManager[CancelScope]):
+    def __init__(self, cancel_scope: CancelScope):
+        self._cancel_scope = cancel_scope
+
+    def __enter__(self) -> CancelScope:
+        return self._cancel_scope.__enter__()
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> Optional[bool]:
+        retval = self._cancel_scope.__exit__(exc_type, exc_val, exc_tb)
+        if self._cancel_scope.cancel_called:
+            raise TimeoutError
+
+        return retval
+
+
+def fail_after(delay: Optional[float], shield: bool = False) -> FailAfterContextManager:
+    """
+    Create a context manager which raises a :class:`TimeoutError` if does not finish in time.
+
+    :param delay: maximum allowed time (in seconds) before raising the exception, or ``None`` to
+        disable the timeout
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :return: a context manager that yields a cancel scope
+    :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.abc.CancelScope`\\]
+
+    """
+    deadline = (
+        (get_asynclib().current_time() + delay) if delay is not None else math.inf
+    )
+    cancel_scope = get_asynclib().CancelScope(deadline=deadline, shield=shield)
+    return FailAfterContextManager(cancel_scope)
+
+
+def move_on_after(delay: Optional[float], shield: bool = False) -> CancelScope:
+    """
+    Create a cancel scope with a deadline that expires after the given delay.
+
+    :param delay: maximum allowed time (in seconds) before exiting the context block, or ``None``
+        to disable the timeout
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :return: a cancel scope
+
+    """
+    deadline = (
+        (get_asynclib().current_time() + delay) if delay is not None else math.inf
+    )
+    return get_asynclib().CancelScope(deadline=deadline, shield=shield)
+
+
+def current_effective_deadline() -> DeprecatedAwaitableFloat:
+    """
+    Return the nearest deadline among all the cancel scopes effective for the current task.
+
+    :return: a clock value from the event loop's internal clock (``float('inf')`` if there is no
+        deadline in effect)
+    :rtype: float
+
+    """
+    return DeprecatedAwaitableFloat(
+        get_asynclib().current_effective_deadline(), current_effective_deadline
+    )
+
+
+def create_task_group() -> "TaskGroup":
+    """
+    Create a task group.
+
+    :return: a task group
+
+    """
+    return get_asynclib().TaskGroup()

venv/lib/python3.11/site-packages/anyio/_core/_testing.py

@@ -0,0 +1,80 @@
+from typing import Any, Awaitable, Generator, Optional, Union
+
+from ._compat import DeprecatedAwaitableList, _warn_deprecation
+from ._eventloop import get_asynclib
+
+
+class TaskInfo:
+    """
+    Represents an asynchronous task.
+
+    :ivar int id: the unique identifier of the task
+    :ivar parent_id: the identifier of the parent task, if any
+    :vartype parent_id: Optional[int]
+    :ivar str name: the description of the task (if any)
+    :ivar ~collections.abc.Coroutine coro: the coroutine object of the task
+    """
+
+    __slots__ = "_name", "id", "parent_id", "name", "coro"
+
+    def __init__(
+        self,
+        id: int,
+        parent_id: Optional[int],
+        name: Optional[str],
+        coro: Union[Generator, Awaitable[Any]],
+    ):
+        func = get_current_task
+        self._name = f"{func.__module__}.{func.__qualname__}"
+        self.id: int = id
+        self.parent_id: Optional[int] = parent_id
+        self.name: Optional[str] = name
+        self.coro: Union[Generator, Awaitable[Any]] = coro
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, TaskInfo):
+            return self.id == other.id
+
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(id={self.id!r}, name={self.name!r})"
+
+    def __await__(self) -> Generator[None, None, "TaskInfo"]:
+        _warn_deprecation(self)
+        if False:
+            yield
+
+        return self
+
+    def _unwrap(self) -> "TaskInfo":
+        return self
+
+
+def get_current_task() -> TaskInfo:
+    """
+    Return the current task.
+
+    :return: a representation of the current task
+
+    """
+    return get_asynclib().get_current_task()
+
+
+def get_running_tasks() -> DeprecatedAwaitableList[TaskInfo]:
+    """
+    Return a list of running tasks in the current event loop.
+
+    :return: a list of task info objects
+
+    """
+    tasks = get_asynclib().get_running_tasks()
+    return DeprecatedAwaitableList(tasks, func=get_running_tasks)
+
+
+async def wait_all_tasks_blocked() -> None:
+    """Wait until all other tasks are waiting for something."""
+    await get_asynclib().wait_all_tasks_blocked()

venv/lib/python3.11/site-packages/anyio/_core/_typedattr.py

@@ -0,0 +1,81 @@
+import sys
+from typing import Any, Callable, Dict, Mapping, TypeVar, Union, overload
+
+from ._exceptions import TypedAttributeLookupError
+
+if sys.version_info >= (3, 8):
+    from typing import final
+else:
+    from typing_extensions import final
+
+T_Attr = TypeVar("T_Attr")
+T_Default = TypeVar("T_Default")
+undefined = object()
+
+
+def typed_attribute() -> Any:
+    """Return a unique object, used to mark typed attributes."""
+    return object()
+
+
+class TypedAttributeSet:
+    """
+    Superclass for typed attribute collections.
+
+    Checks that every public attribute of every subclass has a type annotation.
+    """
+
+    def __init_subclass__(cls) -> None:
+        annotations: Dict[str, Any] = getattr(cls, "__annotations__", {})
+        for attrname in dir(cls):
+            if not attrname.startswith("_") and attrname not in annotations:
+                raise TypeError(
+                    f"Attribute {attrname!r} is missing its type annotation"
+                )
+
+        super().__init_subclass__()
+
+
+class TypedAttributeProvider:
+    """Base class for classes that wish to provide typed extra attributes."""
+
+    @property
+    def extra_attributes(self) -> Mapping[T_Attr, Callable[[], T_Attr]]:
+        """
+        A mapping of the extra attributes to callables that return the corresponding values.
+
+        If the provider wraps another provider, the attributes from that wrapper should also be
+        included in the returned mapping (but the wrapper may override the callables from the
+        wrapped instance).
+
+        """
+        return {}
+
+    @overload
+    def extra(self, attribute: T_Attr) -> T_Attr:
+        ...
+
+    @overload
+    def extra(self, attribute: T_Attr, default: T_Default) -> Union[T_Attr, T_Default]:
+        ...
+
+    @final
+    def extra(self, attribute: Any, default: object = undefined) -> object:
+        """
+        extra(attribute, default=undefined)
+
+        Return the value of the given typed extra attribute.
+
+        :param attribute: the attribute (member of a :class:`~TypedAttributeSet`) to look for
+        :param default: the value that should be returned if no value is found for the attribute
+        :raises ~anyio.TypedAttributeLookupError: if the search failed and no default value was
+            given
+
+        """
+        try:
+            return self.extra_attributes[attribute]()
+        except KeyError:
+            if default is undefined:
+                raise TypedAttributeLookupError("Attribute not found") from None
+            else:
+                return default

venv/lib/python3.11/site-packages/anyio/abc/__init__.py

@@ -0,0 +1,88 @@
+__all__ = (
+    "AsyncResource",
+    "IPAddressType",
+    "IPSockAddrType",
+    "SocketAttribute",
+    "SocketStream",
+    "SocketListener",
+    "UDPSocket",
+    "UNIXSocketStream",
+    "UDPPacketType",
+    "ConnectedUDPSocket",
+    "UnreliableObjectReceiveStream",
+    "UnreliableObjectSendStream",
+    "UnreliableObjectStream",
+    "ObjectReceiveStream",
+    "ObjectSendStream",
+    "ObjectStream",
+    "ByteReceiveStream",
+    "ByteSendStream",
+    "ByteStream",
+    "AnyUnreliableByteReceiveStream",
+    "AnyUnreliableByteSendStream",
+    "AnyUnreliableByteStream",
+    "AnyByteReceiveStream",
+    "AnyByteSendStream",
+    "AnyByteStream",
+    "Listener",
+    "Process",
+    "Event",
+    "Condition",
+    "Lock",
+    "Semaphore",
+    "CapacityLimiter",
+    "CancelScope",
+    "TaskGroup",
+    "TaskStatus",
+    "TestRunner",
+    "BlockingPortal",
+)
+
+from typing import Any
+
+from ._resources import AsyncResource
+from ._sockets import (
+    ConnectedUDPSocket,
+    IPAddressType,
+    IPSockAddrType,
+    SocketAttribute,
+    SocketListener,
+    SocketStream,
+    UDPPacketType,
+    UDPSocket,
+    UNIXSocketStream,
+)
+from ._streams import (
+    AnyByteReceiveStream,
+    AnyByteSendStream,
+    AnyByteStream,
+    AnyUnreliableByteReceiveStream,
+    AnyUnreliableByteSendStream,
+    AnyUnreliableByteStream,
+    ByteReceiveStream,
+    ByteSendStream,
+    ByteStream,
+    Listener,
+    ObjectReceiveStream,
+    ObjectSendStream,
+    ObjectStream,
+    UnreliableObjectReceiveStream,
+    UnreliableObjectSendStream,
+    UnreliableObjectStream,
+)
+from ._subprocesses import Process
+from ._tasks import TaskGroup, TaskStatus
+from ._testing import TestRunner
+
+# Re-exported here, for backwards compatibility
+# isort: off
+from .._core._synchronization import CapacityLimiter, Condition, Event, Lock, Semaphore
+from .._core._tasks import CancelScope
+from ..from_thread import BlockingPortal
+
+# Re-export imports so they look like they live directly in this package
+key: str
+value: Any
+for key, value in list(locals().items()):
+    if getattr(value, "__module__", "").startswith("anyio.abc."):
+        value.__module__ = __name__