From 34f8921273dfef4ebd158ba783fc9a5a441cfe22 Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Tue, 20 Feb 2024 23:29:48 -0600 Subject: [PATCH 01/15] wip --- .tool-versions | 4 +- _config.py | 66 +++++ config.env | 2 + main.py | 375 +++++++++++++++++++++++++ poetry.lock | 726 +++++++++++++++++++++++++++++++++++++++++++++++++ pyproject.toml | 80 ++++++ 6 files changed, 1251 insertions(+), 2 deletions(-) create mode 100644 _config.py create mode 100644 config.env create mode 100644 main.py create mode 100644 poetry.lock create mode 100644 pyproject.toml diff --git a/.tool-versions b/.tool-versions index c3ba1a2..d5c9bbe 100644 --- a/.tool-versions +++ b/.tool-versions @@ -1,2 +1,2 @@ -python 3.11.4 -poetry 1.5.1 +python 3.11.6 +poetry 1.7.1 diff --git a/_config.py b/_config.py new file mode 100644 index 0000000..7f93ee8 --- /dev/null +++ b/_config.py @@ -0,0 +1,66 @@ +#!/usr/bin/env python3 + +from pathlib import Path + +# paths +logged_in_home = str(Path.home()) +steam_apps = f"{logged_in_home}/.local/share/Steam/steamapps" +compat_data = f"{steam_apps}/compatdata" +compat_data_path = f"{compat_data}/NonSteamLaunchers/pfx/drive_c" +steamuser_path = f"{logged_in_home}/.local/share/Steam/steamapps/compatdata/NonSteamLaunchers/pfx/drive_c/users/steamuser/AppData/Local" + +# launchers +amazongames_path1 = f"{compat_data_path}/Program Files/Amazon Games/App/Amazon Games.exe" +amazongames_path2 = f"{steamuser_path}/Amazon Games/App/Amazon Games.exe" +battlenet_path1 = f"{compat_data_path}/Program Files (x86)/Battle.net/Battle.net Launcher.exe" +battlenet_path2 = f"{steamuser_path}/Program Files (x86)/Battle.net/Battle.net Launcher.exe" +dmm_path1 = f"{compat_data_path}/Program Files/DMMGamePlayer/DMMGamePlayer.exe" +dmm_path2 = f"{steamuser_path}/Program Files/DMMGamePlayer/DMMGamePlayer.exe" +eaapp_path1 = f"{compat_data_path}/Program Files/Electronic Arts/EA Desktop/EA Desktop/EADesktop.exe" +eaapp_path2 = f"{steamuser_path}/Program Files/Electronic Arts/EA Desktop/EA Desktop/EADesktop.exe" +epic_games_launcher_path1 = f"{compat_data_path}/Program Files (x86)/Epic Games/Launcher/Portal/Binaries/Win32/EpicGamesLauncher.exe" +epic_games_launcher_path2 = f"{steamuser_path}/Program Files (x86)/Epic Games/Launcher/Portal/Binaries/Win32/EpicGamesLauncher.exe" +glyph_path1 = f"{compat_data_path}/Program Files (x86)/Glyph/GlyphClient.exe" +glyph_path2 = f"{steamuser_path}/Program Files (x86)/Glyph/GlyphClient.exe" +gog_galaxy_path1 = f"{compat_data_path}/Program Files (x86)/GOG Galaxy/GalaxyClient.exe" +gog_galaxy_path2 = f"{steamuser_path}/Program Files (x86)/GOG Galaxy/GalaxyClient.exe" +humblegames_path1 = f"{compat_data_path}/Program Files/Humble App/Humble App.exe" +humblegames_path2 = f"{steamuser_path}/Program Files/Humble App/Humble App.exe" +indiegala_path1 = f"{compat_data_path}/Program Files/IGClient/IGClient.exe" +indiegala_path2 = f"{steamuser_path}/Program Files/IGClient/IGClient.exe" +itchio_path1 = f"{compat_data_path}/users/steamuser/AppData/Local/itch/app-25.6.2/itch.exe" +itchio_path2 = f"{steamuser_path}/itch/app-25.6.2/itch.exe" +legacygames_path1 = f"{compat_data_path}/Program Files/Legacy Games/Legacy Games Launcher/Legacy Games Launcher.exe" +legacygames_path2 = f"{steamuser_path}/Program Files/Legacy Games/Legacy Games Launcher/Legacy Games Launcher.exe" +minecraft_path1 = f"{compat_data_path}/Program Files (x86)/Minecraft Launcher/MinecraftLauncher.exe" +minecraft_path2 = f"{steamuser_path}/Program Files (x86)/Minecraft Launcher/MinecraftLauncher.exe" +origin_path1 = f"{compat_data_path}/Program Files (x86)/Origin/Origin.exe" +origin_path2 = f"{steamuser_path}/Program Files (x86)/Origin/Origin.exe" +psplus_path1 = f"{compat_data_path}/Program Files (x86)/PlayStationPlus/pspluslauncher.exe" +psplus_path2 = f"{steamuser_path}/Program Files (x86)/PlayStationPlus/pspluslauncher.exe" +rockstar_path1 = f"{compat_data_path}/Program Files/Rockstar Games/Launcher/Launcher.exe" +rockstar_path2 = f"{steamuser_path}/Program Files/Rockstar Games/Launcher/Launcher.exe" +uplay_path1 = f"{compat_data_path}/Program Files (x86)/Ubisoft/Ubisoft Game Launcher/upc.exe" +uplay_path2 = f"{steamuser_path}/Program Files (x86)/Ubisoft/Ubisoft Game Launcher/upc.exe" + +# streaming +chromedirectory = "/usr/bin/flatpak" + +# Define a dictionary of original folder names +folder_names = { + 'Epic Games': 'EpicGamesLauncher', + 'Gog Galaxy': 'GogGalaxyLauncher', + 'Ubisoft Connect': 'UplayLauncher', + 'Origin': 'OriginLauncher', + 'Battle.net': 'Battle.netLauncher', + 'EA App': 'TheEAappLauncher', + 'Amazon Games': 'AmazonGamesLauncher', + 'itch.io': 'itchioLauncher', + 'Legacy Games': 'LegacyGamesLauncher', + 'Humble Bundle': 'HumbleGamesLauncher', + 'IndieGala Client': 'IndieGalaLauncher', + 'Rockstar Games Launcher': 'RockstarGamesLauncher', + 'Minecraft: Java Edition': 'MinecraftLauncher', + 'Playstation Plus': 'PlaystationPlusLauncher', + 'DMM Games': 'DMMGameLauncher', +} diff --git a/config.env b/config.env new file mode 100644 index 0000000..0e89482 --- /dev/null +++ b/config.env @@ -0,0 +1,2 @@ +# TODO: export all dynamic vars from NonSteamLaunchers.sh here +# TODO: read into main.py or config.py (latter's preferable) diff --git a/main.py b/main.py new file mode 100644 index 0000000..d9a4a27 --- /dev/null +++ b/main.py @@ -0,0 +1,375 @@ +#!/usr/bin/env python3 + +import binascii +import _config +import os +import re +import shutil +import sys +import vdf +from _config import folder_names +from pathlib import Path + +# Append the path to the vdf module to the system path +python_version = f"{sys.version_info.major}.{sys.version_info.minor}" +sys.path.insert(0, os.path.expanduser( + f"~/Downloads/NonSteamLaunchersInstallation/lib/python{python_version}/site-packages") +) +print(sys.path) + +# $HOME +logged_in_home = str(Path.home()) + +# TODO: test in holoiso +# Define the path of the shortcuts.vdf file +userdata_parent = Path(logged_in_home) / '.steam/root/userdata' +userdata_folder = userdata_folder.glob('*') +shortcuts_vdf_path = None +for file in userdata_folder: + if file.name == 'shortcuts.vdf': + shortcuts_vdf_path = file + break + +# TODO: ^^ +# Load the shortcuts.vdf file +with open(shortcuts_vdf_path, 'rb') as f: + shortcuts = vdf.binary_load(f) + +# Check if the 'shortcuts' key exists in the dictionary +if 'shortcuts' not in shortcuts: + # Create an empty 'shortcuts' entry + shortcuts['shortcuts'] = {} + +# Check the format of the 'shortcuts' entry +if isinstance(shortcuts['shortcuts'], dict): + # The 'shortcuts' entry is a dictionary + for key, value in shortcuts['shortcuts'].items(): + # Check the type of the value + if not isinstance(value, (str, int, dict)): + pass + +# Define the path of the Launchers +# ! Moved to config.py + +# Streaming +chromedirectory = '$chromedirectory' +websites_str = '$custom_websites_str' +custom_websites = websites_str.split(', ') + +app_ids = [] + + +def get_steam_shortcut_id(exe, appname): + unique_id = ''.join([exe, appname]) + id_int = binascii.crc32(str.encode(unique_id)) | 0x80000000 + return id_int + + +app_id_to_name = {} + + +def create_new_entry(shortcutdirectory, appname, launchoptions, startingdir): + if shortcutdirectory != '' and launchoptions != '': + exe = f'"{shortcutdirectory}"' + if shortcutdirectory != chromedirectory: + appid = get_steam_shortcut_id(exe, appname) + app_ids.append(appid) + app_id_to_name[appid] = appname + else: + appid = None + + # Create a new entry for the Steam shortcut + new_entry = { + 'appid': f'{str(appid)}' if appid is not None else '', + 'appname': appname, + 'exe': shortcutdirectory, + 'StartDir': startingdir, + 'icon': '', + 'ShortcutPath': '', + 'LaunchOptions': launchoptions, + 'IsHidden': 0, + 'AllowDesktopConfig': 1, + 'AllowOverlay': 1, + 'OpenVR': 0, + 'Devkit': 0, + 'DevkitGameID': '', + 'LastPlayTime': 0, + 'tags': { + '0': 'favorite' + } + } + + # Add the new entry to the shortcuts dictionary + entry_exists = False + if type(shortcuts['shortcuts']) == list: + for entry in shortcuts['shortcuts']: + entry.setdefault('appname', '') + entry.setdefault('exe', '') + if entry['appname'] == new_entry['appname'] and entry['exe'] == new_entry['exe']: + entry_exists = True + break + if not entry_exists: + shortcuts['shortcuts'].append(new_entry) + elif type(shortcuts['shortcuts']) == dict: + for key in shortcuts['shortcuts'].keys(): + shortcuts['shortcuts'][key].setdefault('appname', '') + shortcuts['shortcuts'][key].setdefault('exe', '') + if shortcuts['shortcuts'][key]['appname'] == new_entry['appname'] and shortcuts['shortcuts'][key]['exe'] == new_entry['exe']: + entry_exists = True + break + if not entry_exists: + # Check if the shortcuts['shortcuts'] dictionary is empty + if not shortcuts['shortcuts']: + max_key = -1 + else: + # Find the highest key value + max_key = max(int(key) for key in shortcuts['shortcuts'].keys()) + # Add the new entry with a key value one higher than the current maximum + shortcuts['shortcuts'][str(max_key + 1)] = new_entry + + +# TODO: extract logic from shell script and move either here or config.py +create_new_entry('$epicshortcutdirectory', 'Epic Games', '$epiclaunchoptions', '$epicstartingdir') +create_new_entry('$gogshortcutdirectory', 'Gog Galaxy', '$goglaunchoptions', '$gogstartingdir') +create_new_entry('$uplayshortcutdirectory', 'Ubisoft Connect', '$uplaylaunchoptions', '$uplaystartingdir') +create_new_entry('$originshortcutdirectory', 'Origin', '$originlaunchoptions', '$originstartingdir') +create_new_entry('$battlenetshortcutdirectory', 'Battle.net', '$battlenetlaunchoptions', '$battlenetstartingdir') +create_new_entry('$eaappshortcutdirectory', 'EA App', '$eaapplaunchoptions', '$eaappstartingdir') +create_new_entry('$amazonshortcutdirectory', 'Amazon Games', '$amazonlaunchoptions', '$amazonstartingdir') +create_new_entry('$itchioshortcutdirectory', 'itch.io', '$itchiolaunchoptions', '$itchiostartingdir') +create_new_entry('$legacyshortcutdirectory', 'Legacy Games', '$legacylaunchoptions', '$legacystartingdir') +create_new_entry('$humbleshortcutdirectory', 'Humble Bundle', '$humblelaunchoptions', '$humblestartingdir') +create_new_entry('$indieshortcutdirectory', 'IndieGala Client', '$indielaunchoptions', '$indiestartingdir') +create_new_entry('$rockstarshortcutdirectory', 'Rockstar Games Launcher', '$rockstarlaunchoptions', '$rockstarstartingdir') +create_new_entry('$glyphshortcutdirectory', 'Glyph', '$glyphlaunchoptions', '$glyphstartingdir') +create_new_entry('$minecraftshortcutdirectory', 'Minecraft: Java Edition', '$minecraftlaunchoptions', '$minecraftstartingdir') +create_new_entry('$psplusshortcutdirectory', 'Playstation Plus', '$pspluslaunchoptions', '$psplusstartingdir') +create_new_entry('$dmmshortcutdirectory', 'DMM Games', '$dmmlaunchoptions', '$dmmstartingdir') +create_new_entry('$chromedirectory', 'Xbox Games Pass', '$xboxchromelaunchoptions', '$chrome_startdir') +create_new_entry('$chromedirectory', 'GeForce Now', '$geforcechromelaunchoptions', '$chrome_startdir') +create_new_entry('$chromedirectory', 'Netflix', '$netlfixchromelaunchoptions', '$chrome_startdir') +create_new_entry('$chromedirectory', 'Hulu', '$huluchromelaunchoptions', '$chrome_startdir') +create_new_entry('$chromedirectory', 'Disney+', '$disneychromelaunchoptions', '$chrome_startdir') +create_new_entry('$chromedirectory', 'Amazon Prime Video', '$amazonchromelaunchoptions', '$chrome_startdir') +create_new_entry('$chromedirectory', 'Youtube', '$youtubechromelaunchoptions', '$chrome_startdir') +create_new_entry('$chromedirectory', 'Amazon Luna', '$lunachromelaunchoptions', '$chrome_startdir') + +# Iterate over each custom website +for custom_website in custom_websites: + # Check if the custom website is not an empty string + if custom_website: + # Remove any leading or trailing spaces from the custom website URL + custom_website = custom_website.strip() + + # Remove the 'http://' or 'https://' prefix and the 'www.' prefix, if present + clean_website = custom_website.replace( + 'http://', '').replace('https://', '').replace('www.', '') + + # Define a regular expression pattern to extract the game name from the URL + pattern = r'/games/([\w-]+)' + + # Use the regex to search for the game name in the custom website URL + match = re.search(pattern, custom_website) + + # Check if a match was found + if match: + # Extract the game name from the match object + game_name = match.group(1) + + # Replace hyphens with spaces + game_name = game_name.replace('-', ' ') + + # Capitalize the first letter of each word in the game name + game_name = game_name.title() + else: + # Use the entire URL as the entry name + game_name = clean_website + + # Define the launch options for this website + chromelaunch_options = f"""run + --branch=stable + --arch=x86_64 + --command=/app/bin/chrome + --file-forwarding com.google.Chrome @@u @@ - + -window-size=1280,800 + --force-device-scale-factor=1.00 + --device-scale-factor=1.00 + --kiosk https://{clean_website}/ + --chrome-kiosk-type=fullscreen + --no-first-run + --enable-features=OverlayScrollbar""" + + # Call the create_new_entry function for this website + create_new_entry('$chromedirectory', game_name, chromelaunch_options, '$chrome_startdir') + +print(f'app_id_to_name: {app_id_to_name}') + +# Save the updated shortcuts dictionary to the shortcuts.vdf file +with open('$shortcuts_vdf_path', 'wb') as f: + vdf.binary_dump(shortcuts, f) + +# Writes to the config.vdf File + +excluded_appids = [] + +# Update the config.vdf file +with open(config_vdf_path, 'r') as f: + config = vdf.load(f) + +# Check if the CompatToolMapping key exists +if 'CompatToolMapping' not in config['InstallConfigStore']['Software']['Valve']['Steam']: + # Create the CompatToolMapping key and set its value to an empty dictionary + config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'] = {} + +for app_id in app_ids: + # Check if the app_id is in the list of excluded appids + if app_id not in excluded_appids: + # Update the CompatToolMapping for this app_id + if str(app_id) in config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping']: + config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)]['name'] = '$compat_tool_name' + config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)]['config'] = '' + config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)]['priority'] = '250' + else: + config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)] = {'name': '$compat_tool_name', 'config': '', 'priority': '250'} + +# Save the updated config dictionary to the config.vdf file +with open('$config_vdf_path', 'w') as f: + vdf.dump(config, f) + +# Load the configset_controller_neptune.vdf file +with open('$controller_config_path', 'r') as f: + config = vdf.load(f) + +# Add new entries for the games +for app_id in app_ids: + config['controller_config'][str(app_id)] = { + 'workshop': 'workshop_id' + } + +# TODO: convert to function +# Add new entries for the installed launchers and games +config['controller_config']['epic games'] = { + 'workshop': '2800178806' +} +config['controller_config']['gog galaxy'] = { + 'workshop': '2877189386' +} +config['controller_config']['ubisoft connect'] = { + 'workshop': '2804140248' +} +config['controller_config']['amazon games'] = { + 'workshop': '2871935783' +} +config['controller_config']['battlenet'] = { + 'workshop': '2887894308' +} +config['controller_config']['Origin'] = { + 'workshop': '2856043168' +} +config['controller_config']['rockstar games launcher'] = { + 'workshop': '1892570391' +} +config['controller_config']['indiegala'] = { + 'template': 'controller_neptune_webbrowser.vdf' +} +config['controller_config']['legacy games'] = { + 'template': 'controller_neptune_webbrowser.vdf' +} +config['controller_config']['ea app'] = { + 'workshop': '2899822740' +} +config['controller_config']['itchio'] = { + 'workshop': '2845891813' +} +config['controller_config']['humble games collection'] = { + 'workshop': '2883791560' +} +config['controller_config']['minecraft java edition'] = { + 'workshop': '2980553929' +} +config['controller_config']['playstation plus'] = { + 'workshop': 'controller_neptune_webbrowser.vdf' +} +config['controller_config']['glyph'] = { + 'template': 'controller_neptune_webbrowser.vdf' +} +config['controller_config']['dmm games'] = { + 'template': 'controller_neptune_webbrowser.vdf' +} +config['controller_config']['amazon prime video'] = { + 'workshop': '2970669392' +} +config['controller_config']['hulu'] = { + 'workshop': '2970669392' +} +config['controller_config']['netflix'] = { + 'workshop': '2970669392' +} +config['controller_config']['disney+'] = { + 'workshop': '2970669392' +} +config['controller_config']['youtube'] = { + 'workshop': '2970669392' +} +config['controller_config']['geforce now'] = { + 'template': 'controller_neptune_gamepad+mouse.vdf' +} +config['controller_config']['amazon luna'] = { + 'template': 'controller_neptune_gamepad+mouse.vdf' +} + +# Save the updated config dictionary to the configset_controller_neptune.vdf file +with open('$controller_config_path', 'w') as f: + vdf.dump(config, f) + +# Define the path to the compatdata directory +compatdata_dir = '${logged_in_home}/.local/share/Steam/steamapps/compatdata' + +# Iterate over each launcher in the folder_names dictionary +for launcher_name, folder in folder_names.items(): + # Define the current path of the folder + current_path = os.path.join(compatdata_dir, folder) + + # Check if the folder exists + if os.path.exists(current_path): + print(f'{launcher_name}: {folder} exists') + # Get the app ID for this launcher from the app_id_to_name dictionary + appid = next(key for key, value in app_id_to_name.items() if value == launcher_name) + + # Define the new path of the folder + new_path = os.path.join(compatdata_dir, str(appid)) + + # Rename the folder + os.rename(current_path, new_path) + + # Define the path of the symbolic link + symlink_path = os.path.join(compatdata_dir, folder) + + # Create a symbolic link to the renamed folder + os.symlink(new_path, symlink_path) + else: + print(f'{launcher_name}: {folder} does not exist') + +# Check if the NonSteamLaunchers folder exists +if os.path.exists(os.path.join(compatdata_dir, 'NonSteamLaunchers')): + # Get the first app ID from the app_ids list + first_app_id = app_ids[0] + + # Define the current path of the NonSteamLaunchers folder + current_path = os.path.join(compatdata_dir, 'NonSteamLaunchers') + + # Check if NonSteamLaunchers is already a symbolic link + if os.path.islink(current_path): + print('NonSteamLaunchers is already a symbolic link') + else: + # Define the new path of the NonSteamLaunchers folder + new_path = os.path.join(compatdata_dir, str(first_app_id)) + + # Move the NonSteamLaunchers folder to the new path + shutil.move(current_path, new_path) + + # Define the path of the symbolic link + symlink_path = os.path.join(compatdata_dir, 'NonSteamLaunchers') + + # Create a symbolic link to the renamed NonSteamLaunchers folder + os.symlink(new_path, symlink_path) diff --git a/poetry.lock b/poetry.lock new file mode 100644 index 0000000..21ee69a --- /dev/null +++ b/poetry.lock @@ -0,0 +1,726 @@ +# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand. + +[[package]] +name = "asttokens" +version = "2.4.1" +description = "Annotate AST trees with source code positions" +optional = false +python-versions = "*" +files = [ + {file = "asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24"}, + {file = "asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0"}, +] + +[package.dependencies] +six = ">=1.12.0" + +[package.extras] +astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] +test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] + +[[package]] +name = "certifi" +version = "2024.2.2" +description = "Python package for providing Mozilla's CA Bundle." +optional = false +python-versions = ">=3.6" +files = [ + {file = "certifi-2024.2.2-py3-none-any.whl", hash = "sha256:dc383c07b76109f368f6106eee2b593b04a011ea4d55f652c6ca24a754d1cdd1"}, + {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"}, +] + +[[package]] +name = "charset-normalizer" +version = "3.3.2" +description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"}, + {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"}, + {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"}, + {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"}, + {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"}, + {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"}, + {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"}, + {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, +] + +[[package]] +name = "colorama" +version = "0.4.6" +description = "Cross-platform colored terminal text." +optional = false +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" +files = [ + {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"}, + {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, +] + +[[package]] +name = "commonmark" +version = "0.9.1" +description = "Python parser for the CommonMark Markdown spec" +optional = false +python-versions = "*" +files = [ + {file = "commonmark-0.9.1-py2.py3-none-any.whl", hash = "sha256:da2f38c92590f83de410ba1a3cbceafbc74fee9def35f9251ba9a971d6d66fd9"}, + {file = "commonmark-0.9.1.tar.gz", hash = "sha256:452f9dc859be7f06631ddcb328b6919c67984aca654e5fefb3914d54691aed60"}, +] + +[package.extras] +test = ["flake8 (==3.7.8)", "hypothesis (==3.55.3)"] + +[[package]] +name = "coverage" +version = "7.4.1" +description = "Code coverage measurement for Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "coverage-7.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:077d366e724f24fc02dbfe9d946534357fda71af9764ff99d73c3c596001bbd7"}, + {file = "coverage-7.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0193657651f5399d433c92f8ae264aff31fc1d066deee4b831549526433f3f61"}, + {file = "coverage-7.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d17bbc946f52ca67adf72a5ee783cd7cd3477f8f8796f59b4974a9b59cacc9ee"}, + {file = "coverage-7.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a3277f5fa7483c927fe3a7b017b39351610265308f5267ac6d4c2b64cc1d8d25"}, + {file = "coverage-7.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6dceb61d40cbfcf45f51e59933c784a50846dc03211054bd76b421a713dcdf19"}, + {file = "coverage-7.4.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6008adeca04a445ea6ef31b2cbaf1d01d02986047606f7da266629afee982630"}, + {file = "coverage-7.4.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:c61f66d93d712f6e03369b6a7769233bfda880b12f417eefdd4f16d1deb2fc4c"}, + {file = "coverage-7.4.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b9bb62fac84d5f2ff523304e59e5c439955fb3b7f44e3d7b2085184db74d733b"}, + {file = "coverage-7.4.1-cp310-cp310-win32.whl", hash = "sha256:f86f368e1c7ce897bf2457b9eb61169a44e2ef797099fb5728482b8d69f3f016"}, + {file = "coverage-7.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:869b5046d41abfea3e381dd143407b0d29b8282a904a19cb908fa24d090cc018"}, + {file = "coverage-7.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b8ffb498a83d7e0305968289441914154fb0ef5d8b3157df02a90c6695978295"}, + {file = "coverage-7.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3cacfaefe6089d477264001f90f55b7881ba615953414999c46cc9713ff93c8c"}, + {file = "coverage-7.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d6850e6e36e332d5511a48a251790ddc545e16e8beaf046c03985c69ccb2676"}, + {file = "coverage-7.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:18e961aa13b6d47f758cc5879383d27b5b3f3dcd9ce8cdbfdc2571fe86feb4dd"}, + {file = "coverage-7.4.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dfd1e1b9f0898817babf840b77ce9fe655ecbe8b1b327983df485b30df8cc011"}, + {file = "coverage-7.4.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6b00e21f86598b6330f0019b40fb397e705135040dbedc2ca9a93c7441178e74"}, + {file = "coverage-7.4.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:536d609c6963c50055bab766d9951b6c394759190d03311f3e9fcf194ca909e1"}, + {file = "coverage-7.4.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7ac8f8eb153724f84885a1374999b7e45734bf93a87d8df1e7ce2146860edef6"}, + {file = "coverage-7.4.1-cp311-cp311-win32.whl", hash = "sha256:f3771b23bb3675a06f5d885c3630b1d01ea6cac9e84a01aaf5508706dba546c5"}, + {file = "coverage-7.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:9d2f9d4cc2a53b38cabc2d6d80f7f9b7e3da26b2f53d48f05876fef7956b6968"}, + {file = "coverage-7.4.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f68ef3660677e6624c8cace943e4765545f8191313a07288a53d3da188bd8581"}, + {file = "coverage-7.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23b27b8a698e749b61809fb637eb98ebf0e505710ec46a8aa6f1be7dc0dc43a6"}, + {file = "coverage-7.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e3424c554391dc9ef4a92ad28665756566a28fecf47308f91841f6c49288e66"}, + {file = "coverage-7.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e0860a348bf7004c812c8368d1fc7f77fe8e4c095d661a579196a9533778e156"}, + {file = "coverage-7.4.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fe558371c1bdf3b8fa03e097c523fb9645b8730399c14fe7721ee9c9e2a545d3"}, + {file = "coverage-7.4.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3468cc8720402af37b6c6e7e2a9cdb9f6c16c728638a2ebc768ba1ef6f26c3a1"}, + {file = "coverage-7.4.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:02f2edb575d62172aa28fe00efe821ae31f25dc3d589055b3fb64d51e52e4ab1"}, + {file = "coverage-7.4.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ca6e61dc52f601d1d224526360cdeab0d0712ec104a2ce6cc5ccef6ed9a233bc"}, + {file = "coverage-7.4.1-cp312-cp312-win32.whl", hash = "sha256:ca7b26a5e456a843b9b6683eada193fc1f65c761b3a473941efe5a291f604c74"}, + {file = "coverage-7.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:85ccc5fa54c2ed64bd91ed3b4a627b9cce04646a659512a051fa82a92c04a448"}, + {file = "coverage-7.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8bdb0285a0202888d19ec6b6d23d5990410decb932b709f2b0dfe216d031d218"}, + {file = "coverage-7.4.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:918440dea04521f499721c039863ef95433314b1db00ff826a02580c1f503e45"}, + {file = "coverage-7.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:379d4c7abad5afbe9d88cc31ea8ca262296480a86af945b08214eb1a556a3e4d"}, + {file = "coverage-7.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b094116f0b6155e36a304ff912f89bbb5067157aff5f94060ff20bbabdc8da06"}, + {file = "coverage-7.4.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2f5968608b1fe2a1d00d01ad1017ee27efd99b3437e08b83ded9b7af3f6f766"}, + {file = "coverage-7.4.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:10e88e7f41e6197ea0429ae18f21ff521d4f4490aa33048f6c6f94c6045a6a75"}, + {file = "coverage-7.4.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a4a3907011d39dbc3e37bdc5df0a8c93853c369039b59efa33a7b6669de04c60"}, + {file = "coverage-7.4.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6d224f0c4c9c98290a6990259073f496fcec1b5cc613eecbd22786d398ded3ad"}, + {file = "coverage-7.4.1-cp38-cp38-win32.whl", hash = "sha256:23f5881362dcb0e1a92b84b3c2809bdc90db892332daab81ad8f642d8ed55042"}, + {file = "coverage-7.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:a07f61fc452c43cd5328b392e52555f7d1952400a1ad09086c4a8addccbd138d"}, + {file = "coverage-7.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8e738a492b6221f8dcf281b67129510835461132b03024830ac0e554311a5c54"}, + {file = "coverage-7.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:46342fed0fff72efcda77040b14728049200cbba1279e0bf1188f1f2078c1d70"}, + {file = "coverage-7.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9641e21670c68c7e57d2053ddf6c443e4f0a6e18e547e86af3fad0795414a628"}, + {file = "coverage-7.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aeb2c2688ed93b027eb0d26aa188ada34acb22dceea256d76390eea135083950"}, + {file = "coverage-7.4.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d12c923757de24e4e2110cf8832d83a886a4cf215c6e61ed506006872b43a6d1"}, + {file = "coverage-7.4.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0491275c3b9971cdbd28a4595c2cb5838f08036bca31765bad5e17edf900b2c7"}, + {file = "coverage-7.4.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:8dfc5e195bbef80aabd81596ef52a1277ee7143fe419efc3c4d8ba2754671756"}, + {file = "coverage-7.4.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:1a78b656a4d12b0490ca72651fe4d9f5e07e3c6461063a9b6265ee45eb2bdd35"}, + {file = "coverage-7.4.1-cp39-cp39-win32.whl", hash = "sha256:f90515974b39f4dea2f27c0959688621b46d96d5a626cf9c53dbc653a895c05c"}, + {file = "coverage-7.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:64e723ca82a84053dd7bfcc986bdb34af8d9da83c521c19d6b472bc6880e191a"}, + {file = "coverage-7.4.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:32a8d985462e37cfdab611a6f95b09d7c091d07668fdc26e47a725ee575fe166"}, + {file = "coverage-7.4.1.tar.gz", hash = "sha256:1ed4b95480952b1a26d863e546fa5094564aa0065e1e5f0d4d0041f293251d04"}, +] + +[package.extras] +toml = ["tomli"] + +[[package]] +name = "decorator" +version = "5.1.1" +description = "Decorators for Humans" +optional = false +python-versions = ">=3.5" +files = [ + {file = "decorator-5.1.1-py3-none-any.whl", hash = "sha256:b8c3f85900b9dc423225913c5aace94729fe1fa9763b38939a95226f02d37186"}, + {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, +] + +[[package]] +name = "execnet" +version = "2.0.2" +description = "execnet: rapid multi-Python deployment" +optional = false +python-versions = ">=3.7" +files = [ + {file = "execnet-2.0.2-py3-none-any.whl", hash = "sha256:88256416ae766bc9e8895c76a87928c0012183da3cc4fc18016e6f050e025f41"}, + {file = "execnet-2.0.2.tar.gz", hash = "sha256:cc59bc4423742fd71ad227122eb0dd44db51efb3dc4095b45ac9a08c770096af"}, +] + +[package.extras] +testing = ["hatch", "pre-commit", "pytest", "tox"] + +[[package]] +name = "executing" +version = "2.0.1" +description = "Get the currently executing AST node of a frame, and other information" +optional = false +python-versions = ">=3.5" +files = [ + {file = "executing-2.0.1-py2.py3-none-any.whl", hash = "sha256:eac49ca94516ccc753f9fb5ce82603156e590b27525a8bc32cce8ae302eb61bc"}, + {file = "executing-2.0.1.tar.gz", hash = "sha256:35afe2ce3affba8ee97f2d69927fa823b08b472b7b994e36a52a964b93d16147"}, +] + +[package.extras] +tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] + +[[package]] +name = "idna" +version = "3.6" +description = "Internationalized Domain Names in Applications (IDNA)" +optional = false +python-versions = ">=3.5" +files = [ + {file = "idna-3.6-py3-none-any.whl", hash = "sha256:c05567e9c24a6b9faaa835c4821bad0590fbb9d5779e7caa6e1cc4978e7eb24f"}, + {file = "idna-3.6.tar.gz", hash = "sha256:9ecdbbd083b06798ae1e86adcbfe8ab1479cf864e4ee30fe4e46a003d12491ca"}, +] + +[[package]] +name = "iniconfig" +version = "2.0.0" +description = "brain-dead simple config-ini parsing" +optional = false +python-versions = ">=3.7" +files = [ + {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"}, + {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, +] + +[[package]] +name = "ipython" +version = "8.21.0" +description = "IPython: Productive Interactive Computing" +optional = false +python-versions = ">=3.10" +files = [ + {file = "ipython-8.21.0-py3-none-any.whl", hash = "sha256:1050a3ab8473488d7eee163796b02e511d0735cf43a04ba2a8348bd0f2eaf8a5"}, + {file = "ipython-8.21.0.tar.gz", hash = "sha256:48fbc236fbe0e138b88773fa0437751f14c3645fb483f1d4c5dee58b37e5ce73"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +decorator = "*" +jedi = ">=0.16" +matplotlib-inline = "*" +pexpect = {version = ">4.3", markers = "sys_platform != \"win32\""} +prompt-toolkit = ">=3.0.41,<3.1.0" +pygments = ">=2.4.0" +stack-data = "*" +traitlets = ">=5" + +[package.extras] +all = ["black", "curio", "docrepr", "exceptiongroup", "ipykernel", "ipyparallel", "ipywidgets", "matplotlib", "matplotlib (!=3.2.0)", "nbconvert", "nbformat", "notebook", "numpy (>=1.23)", "pandas", "pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "qtconsole", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "trio", "typing-extensions"] +black = ["black"] +doc = ["docrepr", "exceptiongroup", "ipykernel", "matplotlib", "pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "typing-extensions"] +kernel = ["ipykernel"] +nbconvert = ["nbconvert"] +nbformat = ["nbformat"] +notebook = ["ipywidgets", "notebook"] +parallel = ["ipyparallel"] +qtconsole = ["qtconsole"] +test = ["pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "testpath"] +test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "testpath", "trio"] + +[[package]] +name = "jedi" +version = "0.19.1" +description = "An autocompletion tool for Python that can be used for text editors." +optional = false +python-versions = ">=3.6" +files = [ + {file = "jedi-0.19.1-py2.py3-none-any.whl", hash = "sha256:e983c654fe5c02867aef4cdfce5a2fbb4a50adc0af145f70504238f18ef5e7e0"}, + {file = "jedi-0.19.1.tar.gz", hash = "sha256:cf0496f3651bc65d7174ac1b7d043eff454892c708a87d1b683e57b569927ffd"}, +] + +[package.dependencies] +parso = ">=0.8.3,<0.9.0" + +[package.extras] +docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alabaster (==0.7.12)", "babel (==2.9.1)", "chardet (==4.0.0)", "commonmark (==0.8.1)", "docutils (==0.17.1)", "future (==0.18.2)", "idna (==2.10)", "imagesize (==1.2.0)", "mock (==1.0.1)", "packaging (==20.9)", "pyparsing (==2.4.7)", "pytz (==2021.1)", "readthedocs-sphinx-ext (==2.1.4)", "recommonmark (==0.5.0)", "requests (==2.25.1)", "six (==1.15.0)", "snowballstemmer (==2.1.0)", "sphinx (==1.8.5)", "sphinx-rtd-theme (==0.4.3)", "sphinxcontrib-serializinghtml (==1.1.4)", "sphinxcontrib-websupport (==1.2.4)", "urllib3 (==1.26.4)"] +qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] +testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] + +[[package]] +name = "matplotlib-inline" +version = "0.1.6" +description = "Inline Matplotlib backend for Jupyter" +optional = false +python-versions = ">=3.5" +files = [ + {file = "matplotlib-inline-0.1.6.tar.gz", hash = "sha256:f887e5f10ba98e8d2b150ddcf4702c1e5f8b3a20005eb0f74bfdbd360ee6f304"}, + {file = "matplotlib_inline-0.1.6-py3-none-any.whl", hash = "sha256:f1f41aab5328aa5aaea9b16d083b128102f8712542f819fe7e6a420ff581b311"}, +] + +[package.dependencies] +traitlets = "*" + +[[package]] +name = "packaging" +version = "23.2" +description = "Core utilities for Python packages" +optional = false +python-versions = ">=3.7" +files = [ + {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"}, + {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"}, +] + +[[package]] +name = "parso" +version = "0.8.3" +description = "A Python Parser" +optional = false +python-versions = ">=3.6" +files = [ + {file = "parso-0.8.3-py2.py3-none-any.whl", hash = "sha256:c001d4636cd3aecdaf33cbb40aebb59b094be2a74c556778ef5576c175e19e75"}, + {file = "parso-0.8.3.tar.gz", hash = "sha256:8c07be290bb59f03588915921e29e8a50002acaf2cdc5fa0e0114f91709fafa0"}, +] + +[package.extras] +qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] +testing = ["docopt", "pytest (<6.0.0)"] + +[[package]] +name = "pexpect" +version = "4.9.0" +description = "Pexpect allows easy control of interactive console applications." +optional = false +python-versions = "*" +files = [ + {file = "pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523"}, + {file = "pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f"}, +] + +[package.dependencies] +ptyprocess = ">=0.5" + +[[package]] +name = "pluggy" +version = "1.4.0" +description = "plugin and hook calling mechanisms for python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "pluggy-1.4.0-py3-none-any.whl", hash = "sha256:7db9f7b503d67d1c5b95f59773ebb58a8c1c288129a88665838012cfb07b8981"}, + {file = "pluggy-1.4.0.tar.gz", hash = "sha256:8c85c2876142a764e5b7548e7d9a0e0ddb46f5185161049a79b7e974454223be"}, +] + +[package.extras] +dev = ["pre-commit", "tox"] +testing = ["pytest", "pytest-benchmark"] + +[[package]] +name = "prompt-toolkit" +version = "3.0.43" +description = "Library for building powerful interactive command lines in Python" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"}, + {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"}, +] + +[package.dependencies] +wcwidth = "*" + +[[package]] +name = "ptyprocess" +version = "0.7.0" +description = "Run a subprocess in a pseudo terminal" +optional = false +python-versions = "*" +files = [ + {file = "ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35"}, + {file = "ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220"}, +] + +[[package]] +name = "pure-eval" +version = "0.2.2" +description = "Safely evaluate AST nodes without side effects" +optional = false +python-versions = "*" +files = [ + {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, + {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, +] + +[package.extras] +tests = ["pytest"] + +[[package]] +name = "py" +version = "1.11.0" +description = "library with cross-python path, ini-parsing, io, code, log facilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +files = [ + {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"}, + {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"}, +] + +[[package]] +name = "pygments" +version = "2.17.2" +description = "Pygments is a syntax highlighting package written in Python." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pygments-2.17.2-py3-none-any.whl", hash = "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c"}, + {file = "pygments-2.17.2.tar.gz", hash = "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367"}, +] + +[package.extras] +plugins = ["importlib-metadata"] +windows-terminal = ["colorama (>=0.4.6)"] + +[[package]] +name = "pytest" +version = "7.4.4" +description = "pytest: simple powerful testing with Python" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-7.4.4-py3-none-any.whl", hash = "sha256:b090cdf5ed60bf4c45261be03239c2c1c22df034fbffe691abe93cd80cea01d8"}, + {file = "pytest-7.4.4.tar.gz", hash = "sha256:2cf0005922c6ace4a3e2ec8b4080eb0d9753fdc93107415332f50ce9e7994280"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "sys_platform == \"win32\""} +iniconfig = "*" +packaging = "*" +pluggy = ">=0.12,<2.0" + +[package.extras] +testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"] + +[[package]] +name = "pytest-asyncio" +version = "0.19.0" +description = "Pytest support for asyncio" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-asyncio-0.19.0.tar.gz", hash = "sha256:ac4ebf3b6207259750bc32f4c1d8fcd7e79739edbc67ad0c58dd150b1d072fed"}, + {file = "pytest_asyncio-0.19.0-py3-none-any.whl", hash = "sha256:7a97e37cfe1ed296e2e84941384bdd37c376453912d397ed39293e0916f521fa"}, +] + +[package.dependencies] +pytest = ">=6.1.0" + +[package.extras] +testing = ["coverage (>=6.2)", "flaky (>=3.5.0)", "hypothesis (>=5.7.1)", "mypy (>=0.931)", "pytest-trio (>=0.7.0)"] + +[[package]] +name = "pytest-cov" +version = "4.1.0" +description = "Pytest plugin for measuring coverage." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-cov-4.1.0.tar.gz", hash = "sha256:3904b13dfbfec47f003b8e77fd5b589cd11904a21ddf1ab38a64f204d6a10ef6"}, + {file = "pytest_cov-4.1.0-py3-none-any.whl", hash = "sha256:6ba70b9e97e69fcc3fb45bfeab2d0a138fb65c4d0d6a41ef33983ad114be8c3a"}, +] + +[package.dependencies] +coverage = {version = ">=5.2.1", extras = ["toml"]} +pytest = ">=4.6" + +[package.extras] +testing = ["fields", "hunter", "process-tests", "pytest-xdist", "six", "virtualenv"] + +[[package]] +name = "pytest-datafiles" +version = "3.0.0" +description = "py.test plugin to create a 'tmp_path' containing predefined files/directories." +optional = false +python-versions = "*" +files = [ + {file = "pytest-datafiles-3.0.0.tar.gz", hash = "sha256:a70c4c66a36d1cdcfc095607f04eee66eaef3fa64cbb62d60c47ce169901d1d4"}, + {file = "pytest_datafiles-3.0.0-py2.py3-none-any.whl", hash = "sha256:2176e10d3f6e76f358925a897e21e2bcc5a0170b92fac4e66ed055eaa2ca6a22"}, +] + +[package.dependencies] +pytest = ">=3.6" + +[[package]] +name = "pytest-forked" +version = "1.6.0" +description = "run tests in isolated forked subprocesses" +optional = false +python-versions = ">=3.7" +files = [ + {file = "pytest-forked-1.6.0.tar.gz", hash = "sha256:4dafd46a9a600f65d822b8f605133ecf5b3e1941ebb3588e943b4e3eb71a5a3f"}, + {file = "pytest_forked-1.6.0-py3-none-any.whl", hash = "sha256:810958f66a91afb1a1e2ae83089d8dc1cd2437ac96b12963042fbb9fb4d16af0"}, +] + +[package.dependencies] +py = "*" +pytest = ">=3.10" + +[[package]] +name = "pytest-xdist" +version = "2.5.0" +description = "pytest xdist plugin for distributed testing and loop-on-failing modes" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pytest-xdist-2.5.0.tar.gz", hash = "sha256:4580deca3ff04ddb2ac53eba39d76cb5dd5edeac050cb6fbc768b0dd712b4edf"}, + {file = "pytest_xdist-2.5.0-py3-none-any.whl", hash = "sha256:6fe5c74fec98906deb8f2d2b616b5c782022744978e7bd4695d39c8f42d0ce65"}, +] + +[package.dependencies] +execnet = ">=1.1" +pytest = ">=6.2.0" +pytest-forked = "*" + +[package.extras] +psutil = ["psutil (>=3.0)"] +setproctitle = ["setproctitle"] +testing = ["filelock"] + +[[package]] +name = "requests" +version = "2.31.0" +description = "Python HTTP for Humans." +optional = false +python-versions = ">=3.7" +files = [ + {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"}, + {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"}, +] + +[package.dependencies] +certifi = ">=2017.4.17" +charset-normalizer = ">=2,<4" +idna = ">=2.5,<4" +urllib3 = ">=1.21.1,<3" + +[package.extras] +socks = ["PySocks (>=1.5.6,!=1.5.7)"] +use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] + +[[package]] +name = "rich" +version = "12.6.0" +description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +optional = false +python-versions = ">=3.6.3,<4.0.0" +files = [ + {file = "rich-12.6.0-py3-none-any.whl", hash = "sha256:a4eb26484f2c82589bd9a17c73d32a010b1e29d89f1604cd9bf3a2097b81bb5e"}, + {file = "rich-12.6.0.tar.gz", hash = "sha256:ba3a3775974105c221d31141f2c116f4fd65c5ceb0698657a11e9f295ec93fd0"}, +] + +[package.dependencies] +commonmark = ">=0.9.0,<0.10.0" +pygments = ">=2.6.0,<3.0.0" + +[package.extras] +jupyter = ["ipywidgets (>=7.5.1,<8.0.0)"] + +[[package]] +name = "ruff" +version = "0.0.269" +description = "An extremely fast Python linter, written in Rust." +optional = false +python-versions = ">=3.7" +files = [ + {file = "ruff-0.0.269-py3-none-macosx_10_7_x86_64.whl", hash = "sha256:3569bcdee679045c09c0161fabc057599759c49219a08d9a4aad2cc3982ccba3"}, + {file = "ruff-0.0.269-py3-none-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:56347da63757a56cbce7d4b3d6044ca4f1941cd1bbff3714f7554360c3361f83"}, + {file = "ruff-0.0.269-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6da8ee25ef2f0cc6cc8e6e20942c1d44d25a36dce35070d7184655bc14f63f63"}, + {file = "ruff-0.0.269-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd81b8e681b9eaa6cf15484f3985bd8bd97c3d114e95bff3e8ea283bf8865062"}, + {file = "ruff-0.0.269-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1f19f59ca3c28742955241fb452f3346241ddbd34e72ac5cb3d84fadebcf6bc8"}, + {file = "ruff-0.0.269-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:f062059b8289a4fab7f6064601b811d447c2f9d3d432a17f689efe4d68988450"}, + {file = "ruff-0.0.269-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f5dc7aac52c58e82510217e3c7efd80765c134c097c2815d59e40face0d1fe6"}, + {file = "ruff-0.0.269-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e131b4dbe798c391090c6407641d6ab12c0fa1bb952379dde45e5000e208dabb"}, + {file = "ruff-0.0.269-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a374434e588e06550df0f8dcb74777290f285678de991fda4e1063c367ab2eb2"}, + {file = "ruff-0.0.269-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:cec2f4b84a14b87f1b121488649eb5b4eaa06467a2387373f750da74bdcb5679"}, + {file = "ruff-0.0.269-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:374b161753a247904aec7a32d45e165302b76b6e83d22d099bf3ff7c232c888f"}, + {file = "ruff-0.0.269-py3-none-musllinux_1_2_i686.whl", hash = "sha256:9ca0a1ddb1d835b5f742db9711c6cf59f213a1ad0088cb1e924a005fd399e7d8"}, + {file = "ruff-0.0.269-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5a20658f0b97d207c7841c13d528f36d666bf445b00b01139f28a8ccb80093bb"}, + {file = "ruff-0.0.269-py3-none-win32.whl", hash = "sha256:03ff42bc91ceca58e0f0f072cb3f9286a9208f609812753474e799a997cdad1a"}, + {file = "ruff-0.0.269-py3-none-win_amd64.whl", hash = "sha256:f3b59ccff57b21ef0967ea8021fd187ec14c528ec65507d8bcbe035912050776"}, + {file = "ruff-0.0.269-py3-none-win_arm64.whl", hash = "sha256:bbeb857b1e508a4487bdb02ca1e6d41dd8d5ac5335a5246e25de8a3dff38c1ff"}, + {file = "ruff-0.0.269.tar.gz", hash = "sha256:11ddcfbab32cf5c420ea9dd5531170ace5a3e59c16d9251c7bd2581f7b16f602"}, +] + +[[package]] +name = "six" +version = "1.16.0" +description = "Python 2 and 3 compatibility utilities" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"}, + {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +description = "Extract data from python stack frames and tracebacks for informative displays" +optional = false +python-versions = "*" +files = [ + {file = "stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695"}, + {file = "stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9"}, +] + +[package.dependencies] +asttokens = ">=2.1.0" +executing = ">=1.2.0" +pure-eval = "*" + +[package.extras] +tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] + +[[package]] +name = "traitlets" +version = "5.14.1" +description = "Traitlets Python configuration system" +optional = false +python-versions = ">=3.8" +files = [ + {file = "traitlets-5.14.1-py3-none-any.whl", hash = "sha256:2e5a030e6eff91737c643231bfcf04a65b0132078dad75e4936700b213652e74"}, + {file = "traitlets-5.14.1.tar.gz", hash = "sha256:8585105b371a04b8316a43d5ce29c098575c2e477850b62b848b964f1444527e"}, +] + +[package.extras] +docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] +test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<7.5)", "pytest-mock", "pytest-mypy-testing"] + +[[package]] +name = "urllib3" +version = "2.2.0" +description = "HTTP library with thread-safe connection pooling, file post, and more." +optional = false +python-versions = ">=3.8" +files = [ + {file = "urllib3-2.2.0-py3-none-any.whl", hash = "sha256:ce3711610ddce217e6d113a2732fafad960a03fd0318c91faa79481e35c11224"}, + {file = "urllib3-2.2.0.tar.gz", hash = "sha256:051d961ad0c62a94e50ecf1af379c3aba230c66c710493493560c0c223c49f20"}, +] + +[package.extras] +brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] +h2 = ["h2 (>=4,<5)"] +socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] +zstd = ["zstandard (>=0.18.0)"] + +[[package]] +name = "vdf" +version = "3.4" +description = "Library for working with Valve's VDF text format" +optional = false +python-versions = "*" +files = [ + {file = "vdf-3.4-py2.py3-none-any.whl", hash = "sha256:68c1a125cc49e343d535af2dd25074e9cb0908c6607f073947c4a04bbe234534"}, + {file = "vdf-3.4.tar.gz", hash = "sha256:fd5419f41e07a1009e5ffd027c7dcbe43d1f7e8ef453aeaa90d9d04b807de2af"}, +] + +[[package]] +name = "wcwidth" +version = "0.2.13" +description = "Measures the displayed width of unicode strings in a terminal" +optional = false +python-versions = "*" +files = [ + {file = "wcwidth-0.2.13-py2.py3-none-any.whl", hash = "sha256:3da69048e4540d84af32131829ff948f1e022c1c6bdb8d6102117aac784f6859"}, + {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, +] + +[metadata] +lock-version = "2.0" +python-versions = "^3.11" +content-hash = "666b8caeb9d4f59459e1a4d29a744549ceb5fea29b953540873124ced9b838a2" diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..cb0c2d0 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,80 @@ +[tool.poetry] +name = "non-steam-launchers" +version = "2.99.1" +description = "" +authors = [ + "moraroy <88516395+moraroy@users.noreply.github.com>", + "pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com>" +] +license = "MIT" +readme = "README.md" + +[tool.poetry.dependencies] +python = "^3.11" +requests = "^2.31.0" +vdf = "^3.4" + +[tool.poetry.group.dev.dependencies] +ipython = "^8.4.0" +pytest = "^7.1.3" +pytest-asyncio = "^0.19.0" +pytest-cov = "^4.0.0" +pytest-datafiles = "^3.0.0" +pytest-xdist = "^2.5.0" +rich = "^12.6.0" +ruff = "^0.0.269" + +[tool.ruff] +# Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default. +select = ["E", "F"] +ignore = [] +# Skip unused variable rules +extend-ignore = ["D203", "E203", "E251", "E266", "E401", "E402", "E501", "F401", "F403"] + +# Allow autofix for all enabled rules (when `--fix`) is provided. +fixable = ["A", "B", "C", "D", "E", "F", "G", "I", "N", "Q", "S", "T", "W", "ANN", "ARG", "BLE", "COM", "DJ", "DTZ", "EM", "ERA", "EXE", "FBT", "ICN", "INP", "ISC", "NPY", "PD", "PGH", "PIE", "PL", "PT", "PTH", "PYI", "RET", "RSE", "RUF", "SIM", "SLF", "TCH", "TID", "TRY", "UP", "YTT"] +unfixable = [] + +# Exclude a variety of commonly ignored directories. +exclude = [ + ".bzr", + ".direnv", + "dist", + ".eggs", + ".git", + ".git-rewrite", + ".hg", + ".mypy_cache", + ".nox", + ".pants.d", + "__pycache__", + ".pytype", + ".ruff_cache", + ".svn", + ".tox", + ".venv", + "__pypackages__", + "_build", + "buck-out", + "build", + "dist", + "node_modules", + "venv", +] + +# Black (default: 88) +line-length = 130 + +# Allow unused variables when underscore-prefixed. +dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$" + +# Assume Python 3.11. +target-version = "py311" + +[tool.ruff.mccabe] +# Unlike Flake8, default to a complexity level of 10. +max-complexity = 10 + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" From f6c291dd3da7026329374a97ec008f2693c6a664 Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Tue, 20 Feb 2024 23:30:53 -0600 Subject: [PATCH 02/15] chore: remove modules Use directly in main python script --- Modules/requests/__init__.py | 180 --- .../__pycache__/__init__.cpython-311.pyc | Bin 6262 -> 0 bytes .../__pycache__/__version__.cpython-311.pyc | Bin 548 -> 0 bytes .../_internal_utils.cpython-311.pyc | Bin 2112 -> 0 bytes .../__pycache__/adapters.cpython-311.pyc | Bin 23104 -> 0 bytes .../requests/__pycache__/api.cpython-311.pyc | Bin 7465 -> 0 bytes .../requests/__pycache__/auth.cpython-311.pyc | Bin 14592 -> 0 bytes .../__pycache__/certs.cpython-311.pyc | Bin 682 -> 0 bytes .../__pycache__/compat.cpython-311.pyc | Bin 2066 -> 0 bytes .../__pycache__/cookies.cpython-311.pyc | Bin 27072 -> 0 bytes .../__pycache__/exceptions.cpython-311.pyc | Bin 8474 -> 0 bytes .../__pycache__/hooks.cpython-311.pyc | Bin 1212 -> 0 bytes .../__pycache__/models.cpython-311.pyc | Bin 38662 -> 0 bytes .../__pycache__/packages.cpython-311.pyc | Bin 1296 -> 0 bytes .../__pycache__/sessions.cpython-311.pyc | Bin 29655 -> 0 bytes .../__pycache__/status_codes.cpython-311.pyc | Bin 6199 -> 0 bytes .../__pycache__/structures.cpython-311.pyc | Bin 6184 -> 0 bytes .../__pycache__/utils.cpython-311.pyc | Bin 40206 -> 0 bytes Modules/requests/__version__.py | 14 - Modules/requests/_internal_utils.py | 50 - Modules/requests/adapters.py | 538 -------- Modules/requests/api.py | 157 --- Modules/requests/auth.py | 315 ----- Modules/requests/certs.py | 17 - Modules/requests/compat.py | 79 -- Modules/requests/cookies.py | 561 -------- Modules/requests/exceptions.py | 141 -- Modules/requests/help.py | 134 -- Modules/requests/hooks.py | 33 - Modules/requests/models.py | 1034 -------------- Modules/requests/packages.py | 28 - Modules/requests/sessions.py | 833 ------------ Modules/requests/status_codes.py | 128 -- Modules/requests/structures.py | 99 -- Modules/requests/utils.py | 1094 --------------- Modules/urllib3/__init__.py | 149 --- .../__pycache__/__init__.cpython-311.pyc | Bin 5338 -> 0 bytes .../_base_connection.cpython-311.pyc | Bin 7123 -> 0 bytes .../__pycache__/_collections.cpython-311.pyc | Bin 26027 -> 0 bytes .../_request_methods.cpython-311.pyc | Bin 8528 -> 0 bytes .../__pycache__/_version.cpython-311.pyc | Bin 247 -> 0 bytes .../__pycache__/connection.cpython-311.pyc | Bin 33075 -> 0 bytes .../connectionpool.cpython-311.pyc | Bin 41191 -> 0 bytes .../__pycache__/exceptions.cpython-311.pyc | Bin 19213 -> 0 bytes .../__pycache__/fields.cpython-311.pyc | Bin 13005 -> 0 bytes .../__pycache__/filepost.cpython-311.pyc | Bin 3858 -> 0 bytes .../__pycache__/poolmanager.cpython-311.pyc | Bin 25554 -> 0 bytes .../__pycache__/response.cpython-311.pyc | Bin 49583 -> 0 bytes Modules/urllib3/_base_connection.py | 172 --- Modules/urllib3/_collections.py | 483 ------- Modules/urllib3/_request_methods.py | 217 --- Modules/urllib3/_version.py | 4 - Modules/urllib3/connection.py | 905 ------------- Modules/urllib3/connectionpool.py | 1182 ----------------- Modules/urllib3/contrib/__init__.py | 0 .../__pycache__/__init__.cpython-311.pyc | Bin 168 -> 0 bytes .../contrib/__pycache__/socks.cpython-311.pyc | Bin 8724 -> 0 bytes Modules/urllib3/contrib/pyopenssl.py | 548 -------- Modules/urllib3/contrib/socks.py | 230 ---- Modules/urllib3/exceptions.py | 318 ----- Modules/urllib3/fields.py | 345 ----- Modules/urllib3/filepost.py | 89 -- Modules/urllib3/poolmanager.py | 638 --------- Modules/urllib3/py.typed | 2 - Modules/urllib3/response.py | 1130 ---------------- Modules/urllib3/util/__init__.py | 42 - .../util/__pycache__/__init__.cpython-311.pyc | Bin 1201 -> 0 bytes .../__pycache__/connection.cpython-311.pyc | Bin 5053 -> 0 bytes .../util/__pycache__/proxy.cpython-311.pyc | Bin 1259 -> 0 bytes .../util/__pycache__/request.cpython-311.pyc | Bin 8875 -> 0 bytes .../util/__pycache__/response.cpython-311.pyc | Bin 3333 -> 0 bytes .../util/__pycache__/retry.cpython-311.pyc | Bin 21043 -> 0 bytes .../util/__pycache__/ssl_.cpython-311.pyc | Bin 17407 -> 0 bytes .../ssl_match_hostname.cpython-311.pyc | Bin 6228 -> 0 bytes .../__pycache__/ssltransport.cpython-311.pyc | Bin 14605 -> 0 bytes .../util/__pycache__/timeout.cpython-311.pyc | Bin 12218 -> 0 bytes .../util/__pycache__/url.cpython-311.pyc | Bin 17754 -> 0 bytes .../util/__pycache__/util.cpython-311.pyc | Bin 2149 -> 0 bytes .../util/__pycache__/wait.cpython-311.pyc | Bin 3720 -> 0 bytes Modules/urllib3/util/connection.py | 137 -- Modules/urllib3/util/proxy.py | 43 - Modules/urllib3/util/request.py | 256 ---- Modules/urllib3/util/response.py | 101 -- Modules/urllib3/util/retry.py | 529 -------- Modules/urllib3/util/ssl_.py | 514 ------- Modules/urllib3/util/ssl_match_hostname.py | 159 --- Modules/urllib3/util/ssltransport.py | 280 ---- Modules/urllib3/util/timeout.py | 279 ---- Modules/urllib3/util/url.py | 471 ------- Modules/urllib3/util/util.py | 42 - Modules/urllib3/util/wait.py | 124 -- Modules/vdf/LICENSE | 19 - Modules/vdf/__init__.py | 519 -------- .../vdf/__pycache__/__init__.cpython-311.pyc | Bin 25255 -> 0 bytes 94 files changed, 15362 deletions(-) delete mode 100644 Modules/requests/__init__.py delete mode 100644 Modules/requests/__pycache__/__init__.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/__version__.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/_internal_utils.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/adapters.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/api.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/auth.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/certs.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/compat.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/cookies.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/exceptions.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/hooks.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/models.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/packages.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/sessions.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/status_codes.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/structures.cpython-311.pyc delete mode 100644 Modules/requests/__pycache__/utils.cpython-311.pyc delete mode 100644 Modules/requests/__version__.py delete mode 100644 Modules/requests/_internal_utils.py delete mode 100644 Modules/requests/adapters.py delete mode 100644 Modules/requests/api.py delete mode 100644 Modules/requests/auth.py delete mode 100644 Modules/requests/certs.py delete mode 100644 Modules/requests/compat.py delete mode 100644 Modules/requests/cookies.py delete mode 100644 Modules/requests/exceptions.py delete mode 100644 Modules/requests/help.py delete mode 100644 Modules/requests/hooks.py delete mode 100644 Modules/requests/models.py delete mode 100644 Modules/requests/packages.py delete mode 100644 Modules/requests/sessions.py delete mode 100644 Modules/requests/status_codes.py delete mode 100644 Modules/requests/structures.py delete mode 100644 Modules/requests/utils.py delete mode 100644 Modules/urllib3/__init__.py delete mode 100644 Modules/urllib3/__pycache__/__init__.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/_base_connection.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/_collections.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/_request_methods.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/_version.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/connection.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/connectionpool.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/exceptions.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/fields.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/filepost.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/poolmanager.cpython-311.pyc delete mode 100644 Modules/urllib3/__pycache__/response.cpython-311.pyc delete mode 100644 Modules/urllib3/_base_connection.py delete mode 100644 Modules/urllib3/_collections.py delete mode 100644 Modules/urllib3/_request_methods.py delete mode 100644 Modules/urllib3/_version.py delete mode 100644 Modules/urllib3/connection.py delete mode 100644 Modules/urllib3/connectionpool.py delete mode 100644 Modules/urllib3/contrib/__init__.py delete mode 100644 Modules/urllib3/contrib/__pycache__/__init__.cpython-311.pyc delete mode 100644 Modules/urllib3/contrib/__pycache__/socks.cpython-311.pyc delete mode 100644 Modules/urllib3/contrib/pyopenssl.py delete mode 100644 Modules/urllib3/contrib/socks.py delete mode 100644 Modules/urllib3/exceptions.py delete mode 100644 Modules/urllib3/fields.py delete mode 100644 Modules/urllib3/filepost.py delete mode 100644 Modules/urllib3/poolmanager.py delete mode 100644 Modules/urllib3/py.typed delete mode 100644 Modules/urllib3/response.py delete mode 100644 Modules/urllib3/util/__init__.py delete mode 100644 Modules/urllib3/util/__pycache__/__init__.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/connection.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/proxy.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/request.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/response.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/retry.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/ssl_.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/ssl_match_hostname.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/ssltransport.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/timeout.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/url.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/util.cpython-311.pyc delete mode 100644 Modules/urllib3/util/__pycache__/wait.cpython-311.pyc delete mode 100644 Modules/urllib3/util/connection.py delete mode 100644 Modules/urllib3/util/proxy.py delete mode 100644 Modules/urllib3/util/request.py delete mode 100644 Modules/urllib3/util/response.py delete mode 100644 Modules/urllib3/util/retry.py delete mode 100644 Modules/urllib3/util/ssl_.py delete mode 100644 Modules/urllib3/util/ssl_match_hostname.py delete mode 100644 Modules/urllib3/util/ssltransport.py delete mode 100644 Modules/urllib3/util/timeout.py delete mode 100644 Modules/urllib3/util/url.py delete mode 100644 Modules/urllib3/util/util.py delete mode 100644 Modules/urllib3/util/wait.py delete mode 100644 Modules/vdf/LICENSE delete mode 100644 Modules/vdf/__init__.py delete mode 100644 Modules/vdf/__pycache__/__init__.cpython-311.pyc diff --git a/Modules/requests/__init__.py b/Modules/requests/__init__.py deleted file mode 100644 index 300a16c..0000000 --- a/Modules/requests/__init__.py +++ /dev/null @@ -1,180 +0,0 @@ -# __ -# /__) _ _ _ _ _/ _ -# / ( (- (/ (/ (- _) / _) -# / - -""" -Requests HTTP Library -~~~~~~~~~~~~~~~~~~~~~ - -Requests is an HTTP library, written in Python, for human beings. -Basic GET usage: - - >>> import requests - >>> r = requests.get('https://www.python.org') - >>> r.status_code - 200 - >>> b'Python is a programming language' in r.content - True - -... or POST: - - >>> payload = dict(key1='value1', key2='value2') - >>> r = requests.post('https://httpbin.org/post', data=payload) - >>> print(r.text) - { - ... - "form": { - "key1": "value1", - "key2": "value2" - }, - ... - } - -The other HTTP methods are supported - see `requests.api`. Full documentation -is at . - -:copyright: (c) 2017 by Kenneth Reitz. -:license: Apache 2.0, see LICENSE for more details. -""" - -import warnings - -import urllib3 - -from .exceptions import RequestsDependencyWarning - -try: - from charset_normalizer import __version__ as charset_normalizer_version -except ImportError: - charset_normalizer_version = None - -try: - from chardet import __version__ as chardet_version -except ImportError: - chardet_version = None - - -def check_compatibility(urllib3_version, chardet_version, charset_normalizer_version): - urllib3_version = urllib3_version.split(".") - assert urllib3_version != ["dev"] # Verify urllib3 isn't installed from git. - - # Sometimes, urllib3 only reports its version as 16.1. - if len(urllib3_version) == 2: - urllib3_version.append("0") - - # Check urllib3 for compatibility. - major, minor, patch = urllib3_version # noqa: F811 - major, minor, patch = int(major), int(minor), int(patch) - # urllib3 >= 1.21.1 - assert major >= 1 - if major == 1: - assert minor >= 21 - - # Check charset_normalizer for compatibility. - if chardet_version: - major, minor, patch = chardet_version.split(".")[:3] - major, minor, patch = int(major), int(minor), int(patch) - # chardet_version >= 3.0.2, < 6.0.0 - assert (3, 0, 2) <= (major, minor, patch) < (6, 0, 0) - elif charset_normalizer_version: - major, minor, patch = charset_normalizer_version.split(".")[:3] - major, minor, patch = int(major), int(minor), int(patch) - # charset_normalizer >= 2.0.0 < 4.0.0 - assert (2, 0, 0) <= (major, minor, patch) < (4, 0, 0) - else: - raise Exception("You need either charset_normalizer or chardet installed") - - -def _check_cryptography(cryptography_version): - # cryptography < 1.3.4 - try: - cryptography_version = list(map(int, cryptography_version.split("."))) - except ValueError: - return - - if cryptography_version < [1, 3, 4]: - warning = "Old version of cryptography ({}) may cause slowdown.".format( - cryptography_version - ) - warnings.warn(warning, RequestsDependencyWarning) - - -# Check imported dependencies for compatibility. -try: - check_compatibility( - urllib3.__version__, chardet_version, charset_normalizer_version - ) -except (AssertionError, ValueError): - warnings.warn( - "urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported " - "version!".format( - urllib3.__version__, chardet_version, charset_normalizer_version - ), - RequestsDependencyWarning, - ) - -# Attempt to enable urllib3's fallback for SNI support -# if the standard library doesn't support SNI or the -# 'ssl' library isn't available. -try: - try: - import ssl - except ImportError: - ssl = None - - if not getattr(ssl, "HAS_SNI", False): - from urllib3.contrib import pyopenssl - - pyopenssl.inject_into_urllib3() - - # Check cryptography version - from cryptography import __version__ as cryptography_version - - _check_cryptography(cryptography_version) -except ImportError: - pass - -# urllib3's DependencyWarnings should be silenced. -from urllib3.exceptions import DependencyWarning - -warnings.simplefilter("ignore", DependencyWarning) - -# Set default logging handler to avoid "No handler found" warnings. -import logging -from logging import NullHandler - -from . import packages, utils -from .__version__ import ( - __author__, - __author_email__, - __build__, - __cake__, - __copyright__, - __description__, - __license__, - __title__, - __url__, - __version__, -) -from .api import delete, get, head, options, patch, post, put, request -from .exceptions import ( - ConnectionError, - ConnectTimeout, - FileModeWarning, - HTTPError, - JSONDecodeError, - ReadTimeout, - RequestException, - Timeout, - TooManyRedirects, - URLRequired, -) -from .models import PreparedRequest, Request, Response -from .sessions import Session, session -from .status_codes import codes - -logging.getLogger(__name__).addHandler(NullHandler()) - -# FileModeWarnings go off per the default. -warnings.simplefilter("default", FileModeWarning, append=True) diff --git a/Modules/requests/__pycache__/__init__.cpython-311.pyc b/Modules/requests/__pycache__/__init__.cpython-311.pyc deleted file mode 100644 index 4d95750823499161d1db30b840299593d0c6f31d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6262 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 diff --git a/Modules/requests/__pycache__/adapters.cpython-311.pyc b/Modules/requests/__pycache__/adapters.cpython-311.pyc deleted file mode 100644 index 03d8a4e3bec4c79ad28cdb71487adff67b45dff6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 23104 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
Y}E;{K5gJQNI6q*CxuHLkS& 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 diff --git a/Modules/requests/__pycache__/api.cpython-311.pyc b/Modules/requests/__pycache__/api.cpython-311.pyc deleted file mode 100644 index f77c3fcbf98fd5438ed2edb36e634f1400beafd3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7465 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 SoIAsni}y*+7mvs%^!k4VEqS^C diff --git a/Modules/requests/__pycache__/certs.cpython-311.pyc b/Modules/requests/__pycache__/certs.cpython-311.pyc deleted file mode 100644 index 89b279a693231b2a420d1acbead0b33cfc75c498..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 682 zcmY*XL2DE-6i#MlZH@M*usyv?sSC>t-bD~m5b7SZr(TA1@@6;eOtK~!bv?)m3M+UN z{09{&{+HrO_9S}I+d^+WnaoZ>U-H6xZ{GXzzP$Oov%`p&-|wd4D<$Mta4se3jPnC; zd?JDz5kW;%(KAD>PrsH%7 zr8dCfK&s{?2x*;>$BmO(K^w2R@>qhQdM=GtH7Yl3K?|;+m~b`5_Hs`_D!HjE;YH~9 z)&QLD82cM6&baZksyXXA6oGI@lKlyNuL% zCx;xxYxMEn%t+t&z<-oFbVCigrv3+MV zpu6U}M+mdFkNvTZDW&Txj3#Rmj+=z;o{|2)`$v3j`RZHTKa2a{ldFpd%f02^`~465 UZ$@uNi*~JJlI;4=Cj6p*0d$nmN&o-= diff --git a/Modules/requests/__pycache__/compat.cpython-311.pyc b/Modules/requests/__pycache__/compat.cpython-311.pyc deleted file mode 100644 index 173fbf490b049f9e03256db1acef0caf68c1be97..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2066 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 diff --git a/Modules/requests/__pycache__/hooks.cpython-311.pyc b/Modules/requests/__pycache__/hooks.cpython-311.pyc deleted file mode 100644 index 24b4d1fd278d3cd58711f5721322b3aa44b6e1f6..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1212 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�JLDuP;?nAGeg3wZA?>w^wk?N(J51jzcx-nSnqFO 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 diff --git a/Modules/requests/__pycache__/sessions.cpython-311.pyc b/Modules/requests/__pycache__/sessions.cpython-311.pyc deleted file mode 100644 index 4147462b28e58fd73ae52b5dc5e3d3f6cf8f21a8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 29655 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 M>2lMo{^(Tof0LL>@&Et; diff --git a/Modules/requests/__pycache__/structures.cpython-311.pyc b/Modules/requests/__pycache__/structures.cpython-311.pyc deleted file mode 100644 index 56925ddf07d71ba245937e9999d7329603331360..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6184 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

=!C?q>8`2KaS zkaW4|w2+{&I4vZ88xNz7LgKHY(?YUS?b&j^4+hA5U$JK?XZt>Cd?C5c+o|>Xq^6q6 z6p}qP^!oZ_z`}#A(kJCk>cm3Q&`h-yk`r*#@UmrPE@o|wlC5#soU?mUWpCClTM7s3 zmM!!$h2(L*jvoQ{rAY_fRHBdsY&_QDEF^v(4|b@Kw0Za;+^$KRz5E&EY@RZL`u_)a CNT19A diff --git a/Modules/requests/__version__.py b/Modules/requests/__version__.py deleted file mode 100644 index 5063c3f..0000000 --- a/Modules/requests/__version__.py +++ /dev/null @@ -1,14 +0,0 @@ -# .-. .-. .-. . . .-. .-. .-. .-. -# |( |- |.| | | |- `-. | `-. -# ' ' `-' `-`.`-' `-' `-' ' `-' - -__title__ = "requests" -__description__ = "Python HTTP for Humans." -__url__ = "https://requests.readthedocs.io" -__version__ = "2.31.0" -__build__ = 0x023100 -__author__ = "Kenneth Reitz" -__author_email__ = "me@kennethreitz.org" -__license__ = "Apache 2.0" -__copyright__ = "Copyright Kenneth Reitz" -__cake__ = "\u2728 \U0001f370 \u2728" diff --git a/Modules/requests/_internal_utils.py b/Modules/requests/_internal_utils.py deleted file mode 100644 index f2cf635..0000000 --- a/Modules/requests/_internal_utils.py +++ /dev/null @@ -1,50 +0,0 @@ -""" -requests._internal_utils -~~~~~~~~~~~~~~ - -Provides utility functions that are consumed internally by Requests -which depend on extremely few external helpers (such as compat) -""" -import re - -from .compat import builtin_str - -_VALID_HEADER_NAME_RE_BYTE = re.compile(rb"^[^:\s][^:\r\n]*$") -_VALID_HEADER_NAME_RE_STR = re.compile(r"^[^:\s][^:\r\n]*$") -_VALID_HEADER_VALUE_RE_BYTE = re.compile(rb"^\S[^\r\n]*$|^$") -_VALID_HEADER_VALUE_RE_STR = re.compile(r"^\S[^\r\n]*$|^$") - -_HEADER_VALIDATORS_STR = (_VALID_HEADER_NAME_RE_STR, _VALID_HEADER_VALUE_RE_STR) -_HEADER_VALIDATORS_BYTE = (_VALID_HEADER_NAME_RE_BYTE, _VALID_HEADER_VALUE_RE_BYTE) -HEADER_VALIDATORS = { - bytes: _HEADER_VALIDATORS_BYTE, - str: _HEADER_VALIDATORS_STR, -} - - -def to_native_string(string, encoding="ascii"): - """Given a string object, regardless of type, returns a representation of - that string in the native string type, encoding and decoding where - necessary. This assumes ASCII unless told otherwise. - """ - if isinstance(string, builtin_str): - out = string - else: - out = string.decode(encoding) - - return out - - -def unicode_is_ascii(u_string): - """Determine if unicode string only contains ASCII characters. - - :param str u_string: unicode string to check. Must be unicode - and not Python 2 `str`. - :rtype: bool - """ - assert isinstance(u_string, str) - try: - u_string.encode("ascii") - return True - except UnicodeEncodeError: - return False diff --git a/Modules/requests/adapters.py b/Modules/requests/adapters.py deleted file mode 100644 index 78e3bb6..0000000 --- a/Modules/requests/adapters.py +++ /dev/null @@ -1,538 +0,0 @@ -""" -requests.adapters -~~~~~~~~~~~~~~~~~ - -This module contains the transport adapters that Requests uses to define -and maintain connections. -""" - -import os.path -import socket # noqa: F401 - -from urllib3.exceptions import ClosedPoolError, ConnectTimeoutError -from urllib3.exceptions import HTTPError as _HTTPError -from urllib3.exceptions import InvalidHeader as _InvalidHeader -from urllib3.exceptions import ( - LocationValueError, - MaxRetryError, - NewConnectionError, - ProtocolError, -) -from urllib3.exceptions import ProxyError as _ProxyError -from urllib3.exceptions import ReadTimeoutError, ResponseError -from urllib3.exceptions import SSLError as _SSLError -from urllib3.poolmanager import PoolManager, proxy_from_url -from urllib3.util import Timeout as TimeoutSauce -from urllib3.util import parse_url -from urllib3.util.retry import Retry - -from .auth import _basic_auth_str -from .compat import basestring, urlparse -from .cookies import extract_cookies_to_jar -from .exceptions import ( - ConnectionError, - ConnectTimeout, - InvalidHeader, - InvalidProxyURL, - InvalidSchema, - InvalidURL, - ProxyError, - ReadTimeout, - RetryError, - SSLError, -) -from .models import Response -from .structures import CaseInsensitiveDict -from .utils import ( - DEFAULT_CA_BUNDLE_PATH, - extract_zipped_paths, - get_auth_from_url, - get_encoding_from_headers, - prepend_scheme_if_needed, - select_proxy, - urldefragauth, -) - -try: - from urllib3.contrib.socks import SOCKSProxyManager -except ImportError: - - def SOCKSProxyManager(*args, **kwargs): - raise InvalidSchema("Missing dependencies for SOCKS support.") - - -DEFAULT_POOLBLOCK = False -DEFAULT_POOLSIZE = 10 -DEFAULT_RETRIES = 0 -DEFAULT_POOL_TIMEOUT = None - - -class BaseAdapter: - """The Base Transport Adapter""" - - def __init__(self): - super().__init__() - - def send( - self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None - ): - """Sends PreparedRequest object. Returns Response object. - - :param request: The :class:`PreparedRequest ` being sent. - :param stream: (optional) Whether to stream the request content. - :param timeout: (optional) How long to wait for the server to send - data before giving up, as a float, or a :ref:`(connect timeout, - read timeout) ` tuple. - :type timeout: float or tuple - :param verify: (optional) Either a boolean, in which case it controls whether we verify - the server's TLS certificate, or a string, in which case it must be a path - to a CA bundle to use - :param cert: (optional) Any user-provided SSL certificate to be trusted. - :param proxies: (optional) The proxies dictionary to apply to the request. - """ - raise NotImplementedError - - def close(self): - """Cleans up adapter specific items.""" - raise NotImplementedError - - -class HTTPAdapter(BaseAdapter): - """The built-in HTTP Adapter for urllib3. - - Provides a general-case interface for Requests sessions to contact HTTP and - HTTPS urls by implementing the Transport Adapter interface. This class will - usually be created by the :class:`Session ` class under the - covers. - - :param pool_connections: The number of urllib3 connection pools to cache. - :param pool_maxsize: The maximum number of connections to save in the pool. - :param max_retries: The maximum number of retries each connection - should attempt. Note, this applies only to failed DNS lookups, socket - connections and connection timeouts, never to requests where data has - made it to the server. By default, Requests does not retry failed - connections. If you need granular control over the conditions under - which we retry a request, import urllib3's ``Retry`` class and pass - that instead. - :param pool_block: Whether the connection pool should block for connections. - - Usage:: - - >>> import requests - >>> s = requests.Session() - >>> a = requests.adapters.HTTPAdapter(max_retries=3) - >>> s.mount('http://', a) - """ - - __attrs__ = [ - "max_retries", - "config", - "_pool_connections", - "_pool_maxsize", - "_pool_block", - ] - - def __init__( - self, - pool_connections=DEFAULT_POOLSIZE, - pool_maxsize=DEFAULT_POOLSIZE, - max_retries=DEFAULT_RETRIES, - pool_block=DEFAULT_POOLBLOCK, - ): - if max_retries == DEFAULT_RETRIES: - self.max_retries = Retry(0, read=False) - else: - self.max_retries = Retry.from_int(max_retries) - self.config = {} - self.proxy_manager = {} - - super().__init__() - - self._pool_connections = pool_connections - self._pool_maxsize = pool_maxsize - self._pool_block = pool_block - - self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block) - - def __getstate__(self): - return {attr: getattr(self, attr, None) for attr in self.__attrs__} - - def __setstate__(self, state): - # Can't handle by adding 'proxy_manager' to self.__attrs__ because - # self.poolmanager uses a lambda function, which isn't pickleable. - self.proxy_manager = {} - self.config = {} - - for attr, value in state.items(): - setattr(self, attr, value) - - self.init_poolmanager( - self._pool_connections, self._pool_maxsize, block=self._pool_block - ) - - def init_poolmanager( - self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs - ): - """Initializes a urllib3 PoolManager. - - This method should not be called from user code, and is only - exposed for use when subclassing the - :class:`HTTPAdapter `. - - :param connections: The number of urllib3 connection pools to cache. - :param maxsize: The maximum number of connections to save in the pool. - :param block: Block when no free connections are available. - :param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager. - """ - # save these values for pickling - self._pool_connections = connections - self._pool_maxsize = maxsize - self._pool_block = block - - self.poolmanager = PoolManager( - num_pools=connections, - maxsize=maxsize, - block=block, - **pool_kwargs, - ) - - def proxy_manager_for(self, proxy, **proxy_kwargs): - """Return urllib3 ProxyManager for the given proxy. - - This method should not be called from user code, and is only - exposed for use when subclassing the - :class:`HTTPAdapter `. - - :param proxy: The proxy to return a urllib3 ProxyManager for. - :param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager. - :returns: ProxyManager - :rtype: urllib3.ProxyManager - """ - if proxy in self.proxy_manager: - manager = self.proxy_manager[proxy] - elif proxy.lower().startswith("socks"): - username, password = get_auth_from_url(proxy) - manager = self.proxy_manager[proxy] = SOCKSProxyManager( - proxy, - username=username, - password=password, - num_pools=self._pool_connections, - maxsize=self._pool_maxsize, - block=self._pool_block, - **proxy_kwargs, - ) - else: - proxy_headers = self.proxy_headers(proxy) - manager = self.proxy_manager[proxy] = proxy_from_url( - proxy, - proxy_headers=proxy_headers, - num_pools=self._pool_connections, - maxsize=self._pool_maxsize, - block=self._pool_block, - **proxy_kwargs, - ) - - return manager - - def cert_verify(self, conn, url, verify, cert): - """Verify a SSL certificate. This method should not be called from user - code, and is only exposed for use when subclassing the - :class:`HTTPAdapter `. - - :param conn: The urllib3 connection object associated with the cert. - :param url: The requested URL. - :param verify: Either a boolean, in which case it controls whether we verify - the server's TLS certificate, or a string, in which case it must be a path - to a CA bundle to use - :param cert: The SSL certificate to verify. - """ - if url.lower().startswith("https") and verify: - - cert_loc = None - - # Allow self-specified cert location. - if verify is not True: - cert_loc = verify - - if not cert_loc: - cert_loc = extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH) - - if not cert_loc or not os.path.exists(cert_loc): - raise OSError( - f"Could not find a suitable TLS CA certificate bundle, " - f"invalid path: {cert_loc}" - ) - - conn.cert_reqs = "CERT_REQUIRED" - - if not os.path.isdir(cert_loc): - conn.ca_certs = cert_loc - else: - conn.ca_cert_dir = cert_loc - else: - conn.cert_reqs = "CERT_NONE" - conn.ca_certs = None - conn.ca_cert_dir = None - - if cert: - if not isinstance(cert, basestring): - conn.cert_file = cert[0] - conn.key_file = cert[1] - else: - conn.cert_file = cert - conn.key_file = None - if conn.cert_file and not os.path.exists(conn.cert_file): - raise OSError( - f"Could not find the TLS certificate file, " - f"invalid path: {conn.cert_file}" - ) - if conn.key_file and not os.path.exists(conn.key_file): - raise OSError( - f"Could not find the TLS key file, invalid path: {conn.key_file}" - ) - - def build_response(self, req, resp): - """Builds a :class:`Response ` object from a urllib3 - response. This should not be called from user code, and is only exposed - for use when subclassing the - :class:`HTTPAdapter ` - - :param req: The :class:`PreparedRequest ` used to generate the response. - :param resp: The urllib3 response object. - :rtype: requests.Response - """ - response = Response() - - # Fallback to None if there's no status_code, for whatever reason. - response.status_code = getattr(resp, "status", None) - - # Make headers case-insensitive. - response.headers = CaseInsensitiveDict(getattr(resp, "headers", {})) - - # Set encoding. - response.encoding = get_encoding_from_headers(response.headers) - response.raw = resp - response.reason = response.raw.reason - - if isinstance(req.url, bytes): - response.url = req.url.decode("utf-8") - else: - response.url = req.url - - # Add new cookies from the server. - extract_cookies_to_jar(response.cookies, req, resp) - - # Give the Response some context. - response.request = req - response.connection = self - - return response - - def get_connection(self, url, proxies=None): - """Returns a urllib3 connection for the given URL. This should not be - called from user code, and is only exposed for use when subclassing the - :class:`HTTPAdapter `. - - :param url: The URL to connect to. - :param proxies: (optional) A Requests-style dictionary of proxies used on this request. - :rtype: urllib3.ConnectionPool - """ - proxy = select_proxy(url, proxies) - - if proxy: - proxy = prepend_scheme_if_needed(proxy, "http") - proxy_url = parse_url(proxy) - if not proxy_url.host: - raise InvalidProxyURL( - "Please check proxy URL. It is malformed " - "and could be missing the host." - ) - proxy_manager = self.proxy_manager_for(proxy) - conn = proxy_manager.connection_from_url(url) - else: - # Only scheme should be lower case - parsed = urlparse(url) - url = parsed.geturl() - conn = self.poolmanager.connection_from_url(url) - - return conn - - def close(self): - """Disposes of any internal state. - - Currently, this closes the PoolManager and any active ProxyManager, - which closes any pooled connections. - """ - self.poolmanager.clear() - for proxy in self.proxy_manager.values(): - proxy.clear() - - def request_url(self, request, proxies): - """Obtain the url to use when making the final request. - - If the message is being sent through a HTTP proxy, the full URL has to - be used. Otherwise, we should only use the path portion of the URL. - - This should not be called from user code, and is only exposed for use - when subclassing the - :class:`HTTPAdapter `. - - :param request: The :class:`PreparedRequest ` being sent. - :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs. - :rtype: str - """ - proxy = select_proxy(request.url, proxies) - scheme = urlparse(request.url).scheme - - is_proxied_http_request = proxy and scheme != "https" - using_socks_proxy = False - if proxy: - proxy_scheme = urlparse(proxy).scheme.lower() - using_socks_proxy = proxy_scheme.startswith("socks") - - url = request.path_url - if is_proxied_http_request and not using_socks_proxy: - url = urldefragauth(request.url) - - return url - - def add_headers(self, request, **kwargs): - """Add any headers needed by the connection. As of v2.0 this does - nothing by default, but is left for overriding by users that subclass - the :class:`HTTPAdapter `. - - This should not be called from user code, and is only exposed for use - when subclassing the - :class:`HTTPAdapter `. - - :param request: The :class:`PreparedRequest ` to add headers to. - :param kwargs: The keyword arguments from the call to send(). - """ - pass - - def proxy_headers(self, proxy): - """Returns a dictionary of the headers to add to any request sent - through a proxy. This works with urllib3 magic to ensure that they are - correctly sent to the proxy, rather than in a tunnelled request if - CONNECT is being used. - - This should not be called from user code, and is only exposed for use - when subclassing the - :class:`HTTPAdapter `. - - :param proxy: The url of the proxy being used for this request. - :rtype: dict - """ - headers = {} - username, password = get_auth_from_url(proxy) - - if username: - headers["Proxy-Authorization"] = _basic_auth_str(username, password) - - return headers - - def send( - self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None - ): - """Sends PreparedRequest object. Returns Response object. - - :param request: The :class:`PreparedRequest ` being sent. - :param stream: (optional) Whether to stream the request content. - :param timeout: (optional) How long to wait for the server to send - data before giving up, as a float, or a :ref:`(connect timeout, - read timeout) ` tuple. - :type timeout: float or tuple or urllib3 Timeout object - :param verify: (optional) Either a boolean, in which case it controls whether - we verify the server's TLS certificate, or a string, in which case it - must be a path to a CA bundle to use - :param cert: (optional) Any user-provided SSL certificate to be trusted. - :param proxies: (optional) The proxies dictionary to apply to the request. - :rtype: requests.Response - """ - - try: - conn = self.get_connection(request.url, proxies) - except LocationValueError as e: - raise InvalidURL(e, request=request) - - self.cert_verify(conn, request.url, verify, cert) - url = self.request_url(request, proxies) - self.add_headers( - request, - stream=stream, - timeout=timeout, - verify=verify, - cert=cert, - proxies=proxies, - ) - - chunked = not (request.body is None or "Content-Length" in request.headers) - - if isinstance(timeout, tuple): - try: - connect, read = timeout - timeout = TimeoutSauce(connect=connect, read=read) - except ValueError: - raise ValueError( - f"Invalid timeout {timeout}. Pass a (connect, read) timeout tuple, " - f"or a single float to set both timeouts to the same value." - ) - elif isinstance(timeout, TimeoutSauce): - pass - else: - timeout = TimeoutSauce(connect=timeout, read=timeout) - - try: - resp = conn.urlopen( - method=request.method, - url=url, - body=request.body, - headers=request.headers, - redirect=False, - assert_same_host=False, - preload_content=False, - decode_content=False, - retries=self.max_retries, - timeout=timeout, - chunked=chunked, - ) - - except (ProtocolError, OSError) as err: - raise ConnectionError(err, request=request) - - except MaxRetryError as e: - if isinstance(e.reason, ConnectTimeoutError): - # TODO: Remove this in 3.0.0: see #2811 - if not isinstance(e.reason, NewConnectionError): - raise ConnectTimeout(e, request=request) - - if isinstance(e.reason, ResponseError): - raise RetryError(e, request=request) - - if isinstance(e.reason, _ProxyError): - raise ProxyError(e, request=request) - - if isinstance(e.reason, _SSLError): - # This branch is for urllib3 v1.22 and later. - raise SSLError(e, request=request) - - raise ConnectionError(e, request=request) - - except ClosedPoolError as e: - raise ConnectionError(e, request=request) - - except _ProxyError as e: - raise ProxyError(e) - - except (_SSLError, _HTTPError) as e: - if isinstance(e, _SSLError): - # This branch is for urllib3 versions earlier than v1.22 - raise SSLError(e, request=request) - elif isinstance(e, ReadTimeoutError): - raise ReadTimeout(e, request=request) - elif isinstance(e, _InvalidHeader): - raise InvalidHeader(e, request=request) - else: - raise - - return self.build_response(request, resp) diff --git a/Modules/requests/api.py b/Modules/requests/api.py deleted file mode 100644 index cd0b3ee..0000000 --- a/Modules/requests/api.py +++ /dev/null @@ -1,157 +0,0 @@ -""" -requests.api -~~~~~~~~~~~~ - -This module implements the Requests API. - -:copyright: (c) 2012 by Kenneth Reitz. -:license: Apache2, see LICENSE for more details. -""" - -from . import sessions - - -def request(method, url, **kwargs): - """Constructs and sends a :class:`Request `. - - :param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``. - :param url: URL for the new :class:`Request` object. - :param params: (optional) Dictionary, list of tuples or bytes to send - in the query string for the :class:`Request`. - :param data: (optional) Dictionary, list of tuples, bytes, or file-like - object to send in the body of the :class:`Request`. - :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. - :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`. - :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`. - :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload. - ``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')`` - or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string - defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers - to add for the file. - :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth. - :param timeout: (optional) How many seconds to wait for the server to send data - before giving up, as a float, or a :ref:`(connect timeout, read - timeout) ` tuple. - :type timeout: float or tuple - :param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``. - :type allow_redirects: bool - :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy. - :param verify: (optional) Either a boolean, in which case it controls whether we verify - the server's TLS certificate, or a string, in which case it must be a path - to a CA bundle to use. Defaults to ``True``. - :param stream: (optional) if ``False``, the response content will be immediately downloaded. - :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair. - :return: :class:`Response ` object - :rtype: requests.Response - - Usage:: - - >>> import requests - >>> req = requests.request('GET', 'https://httpbin.org/get') - >>> req - - """ - - # By using the 'with' statement we are sure the session is closed, thus we - # avoid leaving sockets open which can trigger a ResourceWarning in some - # cases, and look like a memory leak in others. - with sessions.Session() as session: - return session.request(method=method, url=url, **kwargs) - - -def get(url, params=None, **kwargs): - r"""Sends a GET request. - - :param url: URL for the new :class:`Request` object. - :param params: (optional) Dictionary, list of tuples or bytes to send - in the query string for the :class:`Request`. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :return: :class:`Response ` object - :rtype: requests.Response - """ - - return request("get", url, params=params, **kwargs) - - -def options(url, **kwargs): - r"""Sends an OPTIONS request. - - :param url: URL for the new :class:`Request` object. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :return: :class:`Response ` object - :rtype: requests.Response - """ - - return request("options", url, **kwargs) - - -def head(url, **kwargs): - r"""Sends a HEAD request. - - :param url: URL for the new :class:`Request` object. - :param \*\*kwargs: Optional arguments that ``request`` takes. If - `allow_redirects` is not provided, it will be set to `False` (as - opposed to the default :meth:`request` behavior). - :return: :class:`Response ` object - :rtype: requests.Response - """ - - kwargs.setdefault("allow_redirects", False) - return request("head", url, **kwargs) - - -def post(url, data=None, json=None, **kwargs): - r"""Sends a POST request. - - :param url: URL for the new :class:`Request` object. - :param data: (optional) Dictionary, list of tuples, bytes, or file-like - object to send in the body of the :class:`Request`. - :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :return: :class:`Response ` object - :rtype: requests.Response - """ - - return request("post", url, data=data, json=json, **kwargs) - - -def put(url, data=None, **kwargs): - r"""Sends a PUT request. - - :param url: URL for the new :class:`Request` object. - :param data: (optional) Dictionary, list of tuples, bytes, or file-like - object to send in the body of the :class:`Request`. - :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :return: :class:`Response ` object - :rtype: requests.Response - """ - - return request("put", url, data=data, **kwargs) - - -def patch(url, data=None, **kwargs): - r"""Sends a PATCH request. - - :param url: URL for the new :class:`Request` object. - :param data: (optional) Dictionary, list of tuples, bytes, or file-like - object to send in the body of the :class:`Request`. - :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :return: :class:`Response ` object - :rtype: requests.Response - """ - - return request("patch", url, data=data, **kwargs) - - -def delete(url, **kwargs): - r"""Sends a DELETE request. - - :param url: URL for the new :class:`Request` object. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :return: :class:`Response ` object - :rtype: requests.Response - """ - - return request("delete", url, **kwargs) diff --git a/Modules/requests/auth.py b/Modules/requests/auth.py deleted file mode 100644 index 9733686..0000000 --- a/Modules/requests/auth.py +++ /dev/null @@ -1,315 +0,0 @@ -""" -requests.auth -~~~~~~~~~~~~~ - -This module contains the authentication handlers for Requests. -""" - -import hashlib -import os -import re -import threading -import time -import warnings -from base64 import b64encode - -from ._internal_utils import to_native_string -from .compat import basestring, str, urlparse -from .cookies import extract_cookies_to_jar -from .utils import parse_dict_header - -CONTENT_TYPE_FORM_URLENCODED = "application/x-www-form-urlencoded" -CONTENT_TYPE_MULTI_PART = "multipart/form-data" - - -def _basic_auth_str(username, password): - """Returns a Basic Auth string.""" - - # "I want us to put a big-ol' comment on top of it that - # says that this behaviour is dumb but we need to preserve - # it because people are relying on it." - # - Lukasa - # - # These are here solely to maintain backwards compatibility - # for things like ints. This will be removed in 3.0.0. - if not isinstance(username, basestring): - warnings.warn( - "Non-string usernames will no longer be supported in Requests " - "3.0.0. Please convert the object you've passed in ({!r}) to " - "a string or bytes object in the near future to avoid " - "problems.".format(username), - category=DeprecationWarning, - ) - username = str(username) - - if not isinstance(password, basestring): - warnings.warn( - "Non-string passwords will no longer be supported in Requests " - "3.0.0. Please convert the object you've passed in ({!r}) to " - "a string or bytes object in the near future to avoid " - "problems.".format(type(password)), - category=DeprecationWarning, - ) - password = str(password) - # -- End Removal -- - - if isinstance(username, str): - username = username.encode("latin1") - - if isinstance(password, str): - password = password.encode("latin1") - - authstr = "Basic " + to_native_string( - b64encode(b":".join((username, password))).strip() - ) - - return authstr - - -class AuthBase: - """Base class that all auth implementations derive from""" - - def __call__(self, r): - raise NotImplementedError("Auth hooks must be callable.") - - -class HTTPBasicAuth(AuthBase): - """Attaches HTTP Basic Authentication to the given Request object.""" - - def __init__(self, username, password): - self.username = username - self.password = password - - def __eq__(self, other): - return all( - [ - self.username == getattr(other, "username", None), - self.password == getattr(other, "password", None), - ] - ) - - def __ne__(self, other): - return not self == other - - def __call__(self, r): - r.headers["Authorization"] = _basic_auth_str(self.username, self.password) - return r - - -class HTTPProxyAuth(HTTPBasicAuth): - """Attaches HTTP Proxy Authentication to a given Request object.""" - - def __call__(self, r): - r.headers["Proxy-Authorization"] = _basic_auth_str(self.username, self.password) - return r - - -class HTTPDigestAuth(AuthBase): - """Attaches HTTP Digest Authentication to the given Request object.""" - - def __init__(self, username, password): - self.username = username - self.password = password - # Keep state in per-thread local storage - self._thread_local = threading.local() - - def init_per_thread_state(self): - # Ensure state is initialized just once per-thread - if not hasattr(self._thread_local, "init"): - self._thread_local.init = True - self._thread_local.last_nonce = "" - self._thread_local.nonce_count = 0 - self._thread_local.chal = {} - self._thread_local.pos = None - self._thread_local.num_401_calls = None - - def build_digest_header(self, method, url): - """ - :rtype: str - """ - - realm = self._thread_local.chal["realm"] - nonce = self._thread_local.chal["nonce"] - qop = self._thread_local.chal.get("qop") - algorithm = self._thread_local.chal.get("algorithm") - opaque = self._thread_local.chal.get("opaque") - hash_utf8 = None - - if algorithm is None: - _algorithm = "MD5" - else: - _algorithm = algorithm.upper() - # lambdas assume digest modules are imported at the top level - if _algorithm == "MD5" or _algorithm == "MD5-SESS": - - def md5_utf8(x): - if isinstance(x, str): - x = x.encode("utf-8") - return hashlib.md5(x).hexdigest() - - hash_utf8 = md5_utf8 - elif _algorithm == "SHA": - - def sha_utf8(x): - if isinstance(x, str): - x = x.encode("utf-8") - return hashlib.sha1(x).hexdigest() - - hash_utf8 = sha_utf8 - elif _algorithm == "SHA-256": - - def sha256_utf8(x): - if isinstance(x, str): - x = x.encode("utf-8") - return hashlib.sha256(x).hexdigest() - - hash_utf8 = sha256_utf8 - elif _algorithm == "SHA-512": - - def sha512_utf8(x): - if isinstance(x, str): - x = x.encode("utf-8") - return hashlib.sha512(x).hexdigest() - - hash_utf8 = sha512_utf8 - - KD = lambda s, d: hash_utf8(f"{s}:{d}") # noqa:E731 - - if hash_utf8 is None: - return None - - # XXX not implemented yet - entdig = None - p_parsed = urlparse(url) - #: path is request-uri defined in RFC 2616 which should not be empty - path = p_parsed.path or "/" - if p_parsed.query: - path += f"?{p_parsed.query}" - - A1 = f"{self.username}:{realm}:{self.password}" - A2 = f"{method}:{path}" - - HA1 = hash_utf8(A1) - HA2 = hash_utf8(A2) - - if nonce == self._thread_local.last_nonce: - self._thread_local.nonce_count += 1 - else: - self._thread_local.nonce_count = 1 - ncvalue = f"{self._thread_local.nonce_count:08x}" - s = str(self._thread_local.nonce_count).encode("utf-8") - s += nonce.encode("utf-8") - s += time.ctime().encode("utf-8") - s += os.urandom(8) - - cnonce = hashlib.sha1(s).hexdigest()[:16] - if _algorithm == "MD5-SESS": - HA1 = hash_utf8(f"{HA1}:{nonce}:{cnonce}") - - if not qop: - respdig = KD(HA1, f"{nonce}:{HA2}") - elif qop == "auth" or "auth" in qop.split(","): - noncebit = f"{nonce}:{ncvalue}:{cnonce}:auth:{HA2}" - respdig = KD(HA1, noncebit) - else: - # XXX handle auth-int. - return None - - self._thread_local.last_nonce = nonce - - # XXX should the partial digests be encoded too? - base = ( - f'username="{self.username}", realm="{realm}", nonce="{nonce}", ' - f'uri="{path}", response="{respdig}"' - ) - if opaque: - base += f', opaque="{opaque}"' - if algorithm: - base += f', algorithm="{algorithm}"' - if entdig: - base += f', digest="{entdig}"' - if qop: - base += f', qop="auth", nc={ncvalue}, cnonce="{cnonce}"' - - return f"Digest {base}" - - def handle_redirect(self, r, **kwargs): - """Reset num_401_calls counter on redirects.""" - if r.is_redirect: - self._thread_local.num_401_calls = 1 - - def handle_401(self, r, **kwargs): - """ - Takes the given response and tries digest-auth, if needed. - - :rtype: requests.Response - """ - - # If response is not 4xx, do not auth - # See https://github.com/psf/requests/issues/3772 - if not 400 <= r.status_code < 500: - self._thread_local.num_401_calls = 1 - return r - - if self._thread_local.pos is not None: - # Rewind the file position indicator of the body to where - # it was to resend the request. - r.request.body.seek(self._thread_local.pos) - s_auth = r.headers.get("www-authenticate", "") - - if "digest" in s_auth.lower() and self._thread_local.num_401_calls < 2: - - self._thread_local.num_401_calls += 1 - pat = re.compile(r"digest ", flags=re.IGNORECASE) - self._thread_local.chal = parse_dict_header(pat.sub("", s_auth, count=1)) - - # Consume content and release the original connection - # to allow our new request to reuse the same one. - r.content - r.close() - prep = r.request.copy() - extract_cookies_to_jar(prep._cookies, r.request, r.raw) - prep.prepare_cookies(prep._cookies) - - prep.headers["Authorization"] = self.build_digest_header( - prep.method, prep.url - ) - _r = r.connection.send(prep, **kwargs) - _r.history.append(r) - _r.request = prep - - return _r - - self._thread_local.num_401_calls = 1 - return r - - def __call__(self, r): - # Initialize per-thread state, if needed - self.init_per_thread_state() - # If we have a saved nonce, skip the 401 - if self._thread_local.last_nonce: - r.headers["Authorization"] = self.build_digest_header(r.method, r.url) - try: - self._thread_local.pos = r.body.tell() - except AttributeError: - # In the case of HTTPDigestAuth being reused and the body of - # the previous request was a file-like object, pos has the - # file position of the previous body. Ensure it's set to - # None. - self._thread_local.pos = None - r.register_hook("response", self.handle_401) - r.register_hook("response", self.handle_redirect) - self._thread_local.num_401_calls = 1 - - return r - - def __eq__(self, other): - return all( - [ - self.username == getattr(other, "username", None), - self.password == getattr(other, "password", None), - ] - ) - - def __ne__(self, other): - return not self == other diff --git a/Modules/requests/certs.py b/Modules/requests/certs.py deleted file mode 100644 index be422c3..0000000 --- a/Modules/requests/certs.py +++ /dev/null @@ -1,17 +0,0 @@ -#!/usr/bin/env python - -""" -requests.certs -~~~~~~~~~~~~~~ - -This module returns the preferred default CA certificate bundle. There is -only one — the one from the certifi package. - -If you are packaging Requests, e.g., for a Linux distribution or a managed -environment, you can change the definition of where() to return a separately -packaged CA bundle. -""" -from certifi import where - -if __name__ == "__main__": - print(where()) diff --git a/Modules/requests/compat.py b/Modules/requests/compat.py deleted file mode 100644 index 6776163..0000000 --- a/Modules/requests/compat.py +++ /dev/null @@ -1,79 +0,0 @@ -""" -requests.compat -~~~~~~~~~~~~~~~ - -This module previously handled import compatibility issues -between Python 2 and Python 3. It remains for backwards -compatibility until the next major version. -""" - -try: - import chardet -except ImportError: - import charset_normalizer as chardet - -import sys - -# ------- -# Pythons -# ------- - -# Syntax sugar. -_ver = sys.version_info - -#: Python 2.x? -is_py2 = _ver[0] == 2 - -#: Python 3.x? -is_py3 = _ver[0] == 3 - -# json/simplejson module import resolution -has_simplejson = False -try: - import simplejson as json - - has_simplejson = True -except ImportError: - import json - -if has_simplejson: - from simplejson import JSONDecodeError -else: - from json import JSONDecodeError - -# Keep OrderedDict for backwards compatibility. -from collections import OrderedDict -from collections.abc import Callable, Mapping, MutableMapping -from http import cookiejar as cookielib -from http.cookies import Morsel -from io import StringIO - -# -------------- -# Legacy Imports -# -------------- -from urllib.parse import ( - quote, - quote_plus, - unquote, - unquote_plus, - urldefrag, - urlencode, - urljoin, - urlparse, - urlsplit, - urlunparse, -) -from urllib.request import ( - getproxies, - getproxies_environment, - parse_http_list, - proxy_bypass, - proxy_bypass_environment, -) - -builtin_str = str -str = str -bytes = bytes -basestring = (str, bytes) -numeric_types = (int, float) -integer_types = (int,) diff --git a/Modules/requests/cookies.py b/Modules/requests/cookies.py deleted file mode 100644 index bf54ab2..0000000 --- a/Modules/requests/cookies.py +++ /dev/null @@ -1,561 +0,0 @@ -""" -requests.cookies -~~~~~~~~~~~~~~~~ - -Compatibility code to be able to use `cookielib.CookieJar` with requests. - -requests.utils imports from here, so be careful with imports. -""" - -import calendar -import copy -import time - -from ._internal_utils import to_native_string -from .compat import Morsel, MutableMapping, cookielib, urlparse, urlunparse - -try: - import threading -except ImportError: - import dummy_threading as threading - - -class MockRequest: - """Wraps a `requests.Request` to mimic a `urllib2.Request`. - - The code in `cookielib.CookieJar` expects this interface in order to correctly - manage cookie policies, i.e., determine whether a cookie can be set, given the - domains of the request and the cookie. - - The original request object is read-only. The client is responsible for collecting - the new headers via `get_new_headers()` and interpreting them appropriately. You - probably want `get_cookie_header`, defined below. - """ - - def __init__(self, request): - self._r = request - self._new_headers = {} - self.type = urlparse(self._r.url).scheme - - def get_type(self): - return self.type - - def get_host(self): - return urlparse(self._r.url).netloc - - def get_origin_req_host(self): - return self.get_host() - - def get_full_url(self): - # Only return the response's URL if the user hadn't set the Host - # header - if not self._r.headers.get("Host"): - return self._r.url - # If they did set it, retrieve it and reconstruct the expected domain - host = to_native_string(self._r.headers["Host"], encoding="utf-8") - parsed = urlparse(self._r.url) - # Reconstruct the URL as we expect it - return urlunparse( - [ - parsed.scheme, - host, - parsed.path, - parsed.params, - parsed.query, - parsed.fragment, - ] - ) - - def is_unverifiable(self): - return True - - def has_header(self, name): - return name in self._r.headers or name in self._new_headers - - def get_header(self, name, default=None): - return self._r.headers.get(name, self._new_headers.get(name, default)) - - def add_header(self, key, val): - """cookielib has no legitimate use for this method; add it back if you find one.""" - raise NotImplementedError( - "Cookie headers should be added with add_unredirected_header()" - ) - - def add_unredirected_header(self, name, value): - self._new_headers[name] = value - - def get_new_headers(self): - return self._new_headers - - @property - def unverifiable(self): - return self.is_unverifiable() - - @property - def origin_req_host(self): - return self.get_origin_req_host() - - @property - def host(self): - return self.get_host() - - -class MockResponse: - """Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`. - - ...what? Basically, expose the parsed HTTP headers from the server response - the way `cookielib` expects to see them. - """ - - def __init__(self, headers): - """Make a MockResponse for `cookielib` to read. - - :param headers: a httplib.HTTPMessage or analogous carrying the headers - """ - self._headers = headers - - def info(self): - return self._headers - - def getheaders(self, name): - self._headers.getheaders(name) - - -def extract_cookies_to_jar(jar, request, response): - """Extract the cookies from the response into a CookieJar. - - :param jar: cookielib.CookieJar (not necessarily a RequestsCookieJar) - :param request: our own requests.Request object - :param response: urllib3.HTTPResponse object - """ - if not (hasattr(response, "_original_response") and response._original_response): - return - # the _original_response field is the wrapped httplib.HTTPResponse object, - req = MockRequest(request) - # pull out the HTTPMessage with the headers and put it in the mock: - res = MockResponse(response._original_response.msg) - jar.extract_cookies(res, req) - - -def get_cookie_header(jar, request): - """ - Produce an appropriate Cookie header string to be sent with `request`, or None. - - :rtype: str - """ - r = MockRequest(request) - jar.add_cookie_header(r) - return r.get_new_headers().get("Cookie") - - -def remove_cookie_by_name(cookiejar, name, domain=None, path=None): - """Unsets a cookie by name, by default over all domains and paths. - - Wraps CookieJar.clear(), is O(n). - """ - clearables = [] - for cookie in cookiejar: - if cookie.name != name: - continue - if domain is not None and domain != cookie.domain: - continue - if path is not None and path != cookie.path: - continue - clearables.append((cookie.domain, cookie.path, cookie.name)) - - for domain, path, name in clearables: - cookiejar.clear(domain, path, name) - - -class CookieConflictError(RuntimeError): - """There are two cookies that meet the criteria specified in the cookie jar. - Use .get and .set and include domain and path args in order to be more specific. - """ - - -class RequestsCookieJar(cookielib.CookieJar, MutableMapping): - """Compatibility class; is a cookielib.CookieJar, but exposes a dict - interface. - - This is the CookieJar we create by default for requests and sessions that - don't specify one, since some clients may expect response.cookies and - session.cookies to support dict operations. - - Requests does not use the dict interface internally; it's just for - compatibility with external client code. All requests code should work - out of the box with externally provided instances of ``CookieJar``, e.g. - ``LWPCookieJar`` and ``FileCookieJar``. - - Unlike a regular CookieJar, this class is pickleable. - - .. warning:: dictionary operations that are normally O(1) may be O(n). - """ - - def get(self, name, default=None, domain=None, path=None): - """Dict-like get() that also supports optional domain and path args in - order to resolve naming collisions from using one cookie jar over - multiple domains. - - .. warning:: operation is O(n), not O(1). - """ - try: - return self._find_no_duplicates(name, domain, path) - except KeyError: - return default - - def set(self, name, value, **kwargs): - """Dict-like set() that also supports optional domain and path args in - order to resolve naming collisions from using one cookie jar over - multiple domains. - """ - # support client code that unsets cookies by assignment of a None value: - if value is None: - remove_cookie_by_name( - self, name, domain=kwargs.get("domain"), path=kwargs.get("path") - ) - return - - if isinstance(value, Morsel): - c = morsel_to_cookie(value) - else: - c = create_cookie(name, value, **kwargs) - self.set_cookie(c) - return c - - def iterkeys(self): - """Dict-like iterkeys() that returns an iterator of names of cookies - from the jar. - - .. seealso:: itervalues() and iteritems(). - """ - for cookie in iter(self): - yield cookie.name - - def keys(self): - """Dict-like keys() that returns a list of names of cookies from the - jar. - - .. seealso:: values() and items(). - """ - return list(self.iterkeys()) - - def itervalues(self): - """Dict-like itervalues() that returns an iterator of values of cookies - from the jar. - - .. seealso:: iterkeys() and iteritems(). - """ - for cookie in iter(self): - yield cookie.value - - def values(self): - """Dict-like values() that returns a list of values of cookies from the - jar. - - .. seealso:: keys() and items(). - """ - return list(self.itervalues()) - - def iteritems(self): - """Dict-like iteritems() that returns an iterator of name-value tuples - from the jar. - - .. seealso:: iterkeys() and itervalues(). - """ - for cookie in iter(self): - yield cookie.name, cookie.value - - def items(self): - """Dict-like items() that returns a list of name-value tuples from the - jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a - vanilla python dict of key value pairs. - - .. seealso:: keys() and values(). - """ - return list(self.iteritems()) - - def list_domains(self): - """Utility method to list all the domains in the jar.""" - domains = [] - for cookie in iter(self): - if cookie.domain not in domains: - domains.append(cookie.domain) - return domains - - def list_paths(self): - """Utility method to list all the paths in the jar.""" - paths = [] - for cookie in iter(self): - if cookie.path not in paths: - paths.append(cookie.path) - return paths - - def multiple_domains(self): - """Returns True if there are multiple domains in the jar. - Returns False otherwise. - - :rtype: bool - """ - domains = [] - for cookie in iter(self): - if cookie.domain is not None and cookie.domain in domains: - return True - domains.append(cookie.domain) - return False # there is only one domain in jar - - def get_dict(self, domain=None, path=None): - """Takes as an argument an optional domain and path and returns a plain - old Python dict of name-value pairs of cookies that meet the - requirements. - - :rtype: dict - """ - dictionary = {} - for cookie in iter(self): - if (domain is None or cookie.domain == domain) and ( - path is None or cookie.path == path - ): - dictionary[cookie.name] = cookie.value - return dictionary - - def __contains__(self, name): - try: - return super().__contains__(name) - except CookieConflictError: - return True - - def __getitem__(self, name): - """Dict-like __getitem__() for compatibility with client code. Throws - exception if there are more than one cookie with name. In that case, - use the more explicit get() method instead. - - .. warning:: operation is O(n), not O(1). - """ - return self._find_no_duplicates(name) - - def __setitem__(self, name, value): - """Dict-like __setitem__ for compatibility with client code. Throws - exception if there is already a cookie of that name in the jar. In that - case, use the more explicit set() method instead. - """ - self.set(name, value) - - def __delitem__(self, name): - """Deletes a cookie given a name. Wraps ``cookielib.CookieJar``'s - ``remove_cookie_by_name()``. - """ - remove_cookie_by_name(self, name) - - def set_cookie(self, cookie, *args, **kwargs): - if ( - hasattr(cookie.value, "startswith") - and cookie.value.startswith('"') - and cookie.value.endswith('"') - ): - cookie.value = cookie.value.replace('\\"', "") - return super().set_cookie(cookie, *args, **kwargs) - - def update(self, other): - """Updates this jar with cookies from another CookieJar or dict-like""" - if isinstance(other, cookielib.CookieJar): - for cookie in other: - self.set_cookie(copy.copy(cookie)) - else: - super().update(other) - - def _find(self, name, domain=None, path=None): - """Requests uses this method internally to get cookie values. - - If there are conflicting cookies, _find arbitrarily chooses one. - See _find_no_duplicates if you want an exception thrown if there are - conflicting cookies. - - :param name: a string containing name of cookie - :param domain: (optional) string containing domain of cookie - :param path: (optional) string containing path of cookie - :return: cookie.value - """ - for cookie in iter(self): - if cookie.name == name: - if domain is None or cookie.domain == domain: - if path is None or cookie.path == path: - return cookie.value - - raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}") - - def _find_no_duplicates(self, name, domain=None, path=None): - """Both ``__get_item__`` and ``get`` call this function: it's never - used elsewhere in Requests. - - :param name: a string containing name of cookie - :param domain: (optional) string containing domain of cookie - :param path: (optional) string containing path of cookie - :raises KeyError: if cookie is not found - :raises CookieConflictError: if there are multiple cookies - that match name and optionally domain and path - :return: cookie.value - """ - toReturn = None - for cookie in iter(self): - if cookie.name == name: - if domain is None or cookie.domain == domain: - if path is None or cookie.path == path: - if toReturn is not None: - # if there are multiple cookies that meet passed in criteria - raise CookieConflictError( - f"There are multiple cookies with name, {name!r}" - ) - # we will eventually return this as long as no cookie conflict - toReturn = cookie.value - - if toReturn: - return toReturn - raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}") - - def __getstate__(self): - """Unlike a normal CookieJar, this class is pickleable.""" - state = self.__dict__.copy() - # remove the unpickleable RLock object - state.pop("_cookies_lock") - return state - - def __setstate__(self, state): - """Unlike a normal CookieJar, this class is pickleable.""" - self.__dict__.update(state) - if "_cookies_lock" not in self.__dict__: - self._cookies_lock = threading.RLock() - - def copy(self): - """Return a copy of this RequestsCookieJar.""" - new_cj = RequestsCookieJar() - new_cj.set_policy(self.get_policy()) - new_cj.update(self) - return new_cj - - def get_policy(self): - """Return the CookiePolicy instance used.""" - return self._policy - - -def _copy_cookie_jar(jar): - if jar is None: - return None - - if hasattr(jar, "copy"): - # We're dealing with an instance of RequestsCookieJar - return jar.copy() - # We're dealing with a generic CookieJar instance - new_jar = copy.copy(jar) - new_jar.clear() - for cookie in jar: - new_jar.set_cookie(copy.copy(cookie)) - return new_jar - - -def create_cookie(name, value, **kwargs): - """Make a cookie from underspecified parameters. - - By default, the pair of `name` and `value` will be set for the domain '' - and sent on every request (this is sometimes called a "supercookie"). - """ - result = { - "version": 0, - "name": name, - "value": value, - "port": None, - "domain": "", - "path": "/", - "secure": False, - "expires": None, - "discard": True, - "comment": None, - "comment_url": None, - "rest": {"HttpOnly": None}, - "rfc2109": False, - } - - badargs = set(kwargs) - set(result) - if badargs: - raise TypeError( - f"create_cookie() got unexpected keyword arguments: {list(badargs)}" - ) - - result.update(kwargs) - result["port_specified"] = bool(result["port"]) - result["domain_specified"] = bool(result["domain"]) - result["domain_initial_dot"] = result["domain"].startswith(".") - result["path_specified"] = bool(result["path"]) - - return cookielib.Cookie(**result) - - -def morsel_to_cookie(morsel): - """Convert a Morsel object into a Cookie containing the one k/v pair.""" - - expires = None - if morsel["max-age"]: - try: - expires = int(time.time() + int(morsel["max-age"])) - except ValueError: - raise TypeError(f"max-age: {morsel['max-age']} must be integer") - elif morsel["expires"]: - time_template = "%a, %d-%b-%Y %H:%M:%S GMT" - expires = calendar.timegm(time.strptime(morsel["expires"], time_template)) - return create_cookie( - comment=morsel["comment"], - comment_url=bool(morsel["comment"]), - discard=False, - domain=morsel["domain"], - expires=expires, - name=morsel.key, - path=morsel["path"], - port=None, - rest={"HttpOnly": morsel["httponly"]}, - rfc2109=False, - secure=bool(morsel["secure"]), - value=morsel.value, - version=morsel["version"] or 0, - ) - - -def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True): - """Returns a CookieJar from a key/value dictionary. - - :param cookie_dict: Dict of key/values to insert into CookieJar. - :param cookiejar: (optional) A cookiejar to add the cookies to. - :param overwrite: (optional) If False, will not replace cookies - already in the jar with new ones. - :rtype: CookieJar - """ - if cookiejar is None: - cookiejar = RequestsCookieJar() - - if cookie_dict is not None: - names_from_jar = [cookie.name for cookie in cookiejar] - for name in cookie_dict: - if overwrite or (name not in names_from_jar): - cookiejar.set_cookie(create_cookie(name, cookie_dict[name])) - - return cookiejar - - -def merge_cookies(cookiejar, cookies): - """Add cookies to cookiejar and returns a merged CookieJar. - - :param cookiejar: CookieJar object to add the cookies to. - :param cookies: Dictionary or CookieJar object to be added. - :rtype: CookieJar - """ - if not isinstance(cookiejar, cookielib.CookieJar): - raise ValueError("You can only merge into CookieJar") - - if isinstance(cookies, dict): - cookiejar = cookiejar_from_dict(cookies, cookiejar=cookiejar, overwrite=False) - elif isinstance(cookies, cookielib.CookieJar): - try: - cookiejar.update(cookies) - except AttributeError: - for cookie_in_jar in cookies: - cookiejar.set_cookie(cookie_in_jar) - - return cookiejar diff --git a/Modules/requests/exceptions.py b/Modules/requests/exceptions.py deleted file mode 100644 index e1cedf8..0000000 --- a/Modules/requests/exceptions.py +++ /dev/null @@ -1,141 +0,0 @@ -""" -requests.exceptions -~~~~~~~~~~~~~~~~~~~ - -This module contains the set of Requests' exceptions. -""" -from urllib3.exceptions import HTTPError as BaseHTTPError - -from .compat import JSONDecodeError as CompatJSONDecodeError - - -class RequestException(IOError): - """There was an ambiguous exception that occurred while handling your - request. - """ - - def __init__(self, *args, **kwargs): - """Initialize RequestException with `request` and `response` objects.""" - response = kwargs.pop("response", None) - self.response = response - self.request = kwargs.pop("request", None) - if response is not None and not self.request and hasattr(response, "request"): - self.request = self.response.request - super().__init__(*args, **kwargs) - - -class InvalidJSONError(RequestException): - """A JSON error occurred.""" - - -class JSONDecodeError(InvalidJSONError, CompatJSONDecodeError): - """Couldn't decode the text into json""" - - def __init__(self, *args, **kwargs): - """ - Construct the JSONDecodeError instance first with all - args. Then use it's args to construct the IOError so that - the json specific args aren't used as IOError specific args - and the error message from JSONDecodeError is preserved. - """ - CompatJSONDecodeError.__init__(self, *args) - InvalidJSONError.__init__(self, *self.args, **kwargs) - - -class HTTPError(RequestException): - """An HTTP error occurred.""" - - -class ConnectionError(RequestException): - """A Connection error occurred.""" - - -class ProxyError(ConnectionError): - """A proxy error occurred.""" - - -class SSLError(ConnectionError): - """An SSL error occurred.""" - - -class Timeout(RequestException): - """The request timed out. - - Catching this error will catch both - :exc:`~requests.exceptions.ConnectTimeout` and - :exc:`~requests.exceptions.ReadTimeout` errors. - """ - - -class ConnectTimeout(ConnectionError, Timeout): - """The request timed out while trying to connect to the remote server. - - Requests that produced this error are safe to retry. - """ - - -class ReadTimeout(Timeout): - """The server did not send any data in the allotted amount of time.""" - - -class URLRequired(RequestException): - """A valid URL is required to make a request.""" - - -class TooManyRedirects(RequestException): - """Too many redirects.""" - - -class MissingSchema(RequestException, ValueError): - """The URL scheme (e.g. http or https) is missing.""" - - -class InvalidSchema(RequestException, ValueError): - """The URL scheme provided is either invalid or unsupported.""" - - -class InvalidURL(RequestException, ValueError): - """The URL provided was somehow invalid.""" - - -class InvalidHeader(RequestException, ValueError): - """The header value provided was somehow invalid.""" - - -class InvalidProxyURL(InvalidURL): - """The proxy URL provided is invalid.""" - - -class ChunkedEncodingError(RequestException): - """The server declared chunked encoding but sent an invalid chunk.""" - - -class ContentDecodingError(RequestException, BaseHTTPError): - """Failed to decode response content.""" - - -class StreamConsumedError(RequestException, TypeError): - """The content for this response was already consumed.""" - - -class RetryError(RequestException): - """Custom retries logic failed""" - - -class UnrewindableBodyError(RequestException): - """Requests encountered an error when trying to rewind a body.""" - - -# Warnings - - -class RequestsWarning(Warning): - """Base warning for Requests.""" - - -class FileModeWarning(RequestsWarning, DeprecationWarning): - """A file was opened in text mode, but Requests determined its binary length.""" - - -class RequestsDependencyWarning(RequestsWarning): - """An imported dependency doesn't match the expected version range.""" diff --git a/Modules/requests/help.py b/Modules/requests/help.py deleted file mode 100644 index 8fbcd65..0000000 --- a/Modules/requests/help.py +++ /dev/null @@ -1,134 +0,0 @@ -"""Module containing bug report helper(s).""" - -import json -import platform -import ssl -import sys - -import idna -import urllib3 - -from . import __version__ as requests_version - -try: - import charset_normalizer -except ImportError: - charset_normalizer = None - -try: - import chardet -except ImportError: - chardet = None - -try: - from urllib3.contrib import pyopenssl -except ImportError: - pyopenssl = None - OpenSSL = None - cryptography = None -else: - import cryptography - import OpenSSL - - -def _implementation(): - """Return a dict with the Python implementation and version. - - Provide both the name and the version of the Python implementation - currently running. For example, on CPython 3.10.3 it will return - {'name': 'CPython', 'version': '3.10.3'}. - - This function works best on CPython and PyPy: in particular, it probably - doesn't work for Jython or IronPython. Future investigation should be done - to work out the correct shape of the code for those platforms. - """ - implementation = platform.python_implementation() - - if implementation == "CPython": - implementation_version = platform.python_version() - elif implementation == "PyPy": - implementation_version = "{}.{}.{}".format( - sys.pypy_version_info.major, - sys.pypy_version_info.minor, - sys.pypy_version_info.micro, - ) - if sys.pypy_version_info.releaselevel != "final": - implementation_version = "".join( - [implementation_version, sys.pypy_version_info.releaselevel] - ) - elif implementation == "Jython": - implementation_version = platform.python_version() # Complete Guess - elif implementation == "IronPython": - implementation_version = platform.python_version() # Complete Guess - else: - implementation_version = "Unknown" - - return {"name": implementation, "version": implementation_version} - - -def info(): - """Generate information for a bug report.""" - try: - platform_info = { - "system": platform.system(), - "release": platform.release(), - } - except OSError: - platform_info = { - "system": "Unknown", - "release": "Unknown", - } - - implementation_info = _implementation() - urllib3_info = {"version": urllib3.__version__} - charset_normalizer_info = {"version": None} - chardet_info = {"version": None} - if charset_normalizer: - charset_normalizer_info = {"version": charset_normalizer.__version__} - if chardet: - chardet_info = {"version": chardet.__version__} - - pyopenssl_info = { - "version": None, - "openssl_version": "", - } - if OpenSSL: - pyopenssl_info = { - "version": OpenSSL.__version__, - "openssl_version": f"{OpenSSL.SSL.OPENSSL_VERSION_NUMBER:x}", - } - cryptography_info = { - "version": getattr(cryptography, "__version__", ""), - } - idna_info = { - "version": getattr(idna, "__version__", ""), - } - - system_ssl = ssl.OPENSSL_VERSION_NUMBER - system_ssl_info = {"version": f"{system_ssl:x}" if system_ssl is not None else ""} - - return { - "platform": platform_info, - "implementation": implementation_info, - "system_ssl": system_ssl_info, - "using_pyopenssl": pyopenssl is not None, - "using_charset_normalizer": chardet is None, - "pyOpenSSL": pyopenssl_info, - "urllib3": urllib3_info, - "chardet": chardet_info, - "charset_normalizer": charset_normalizer_info, - "cryptography": cryptography_info, - "idna": idna_info, - "requests": { - "version": requests_version, - }, - } - - -def main(): - """Pretty-print the bug information as JSON.""" - print(json.dumps(info(), sort_keys=True, indent=2)) - - -if __name__ == "__main__": - main() diff --git a/Modules/requests/hooks.py b/Modules/requests/hooks.py deleted file mode 100644 index d181ba2..0000000 --- a/Modules/requests/hooks.py +++ /dev/null @@ -1,33 +0,0 @@ -""" -requests.hooks -~~~~~~~~~~~~~~ - -This module provides the capabilities for the Requests hooks system. - -Available hooks: - -``response``: - The response generated from a Request. -""" -HOOKS = ["response"] - - -def default_hooks(): - return {event: [] for event in HOOKS} - - -# TODO: response is the only one - - -def dispatch_hook(key, hooks, hook_data, **kwargs): - """Dispatches a hook dictionary on a given piece of data.""" - hooks = hooks or {} - hooks = hooks.get(key) - if hooks: - if hasattr(hooks, "__call__"): - hooks = [hooks] - for hook in hooks: - _hook_data = hook(hook_data, **kwargs) - if _hook_data is not None: - hook_data = _hook_data - return hook_data diff --git a/Modules/requests/models.py b/Modules/requests/models.py deleted file mode 100644 index 617a413..0000000 --- a/Modules/requests/models.py +++ /dev/null @@ -1,1034 +0,0 @@ -""" -requests.models -~~~~~~~~~~~~~~~ - -This module contains the primary objects that power Requests. -""" - -import datetime - -# Import encoding now, to avoid implicit import later. -# Implicit import within threads may cause LookupError when standard library is in a ZIP, -# such as in Embedded Python. See https://github.com/psf/requests/issues/3578. -import encodings.idna # noqa: F401 -from io import UnsupportedOperation - -from urllib3.exceptions import ( - DecodeError, - LocationParseError, - ProtocolError, - ReadTimeoutError, - SSLError, -) -from urllib3.fields import RequestField -from urllib3.filepost import encode_multipart_formdata -from urllib3.util import parse_url - -from ._internal_utils import to_native_string, unicode_is_ascii -from .auth import HTTPBasicAuth -from .compat import ( - Callable, - JSONDecodeError, - Mapping, - basestring, - builtin_str, - chardet, - cookielib, -) -from .compat import json as complexjson -from .compat import urlencode, urlsplit, urlunparse -from .cookies import _copy_cookie_jar, cookiejar_from_dict, get_cookie_header -from .exceptions import ( - ChunkedEncodingError, - ConnectionError, - ContentDecodingError, - HTTPError, - InvalidJSONError, - InvalidURL, -) -from .exceptions import JSONDecodeError as RequestsJSONDecodeError -from .exceptions import MissingSchema -from .exceptions import SSLError as RequestsSSLError -from .exceptions import StreamConsumedError -from .hooks import default_hooks -from .status_codes import codes -from .structures import CaseInsensitiveDict -from .utils import ( - check_header_validity, - get_auth_from_url, - guess_filename, - guess_json_utf, - iter_slices, - parse_header_links, - requote_uri, - stream_decode_response_unicode, - super_len, - to_key_val_list, -) - -#: The set of HTTP status codes that indicate an automatically -#: processable redirect. -REDIRECT_STATI = ( - codes.moved, # 301 - codes.found, # 302 - codes.other, # 303 - codes.temporary_redirect, # 307 - codes.permanent_redirect, # 308 -) - -DEFAULT_REDIRECT_LIMIT = 30 -CONTENT_CHUNK_SIZE = 10 * 1024 -ITER_CHUNK_SIZE = 512 - - -class RequestEncodingMixin: - @property - def path_url(self): - """Build the path URL to use.""" - - url = [] - - p = urlsplit(self.url) - - path = p.path - if not path: - path = "/" - - url.append(path) - - query = p.query - if query: - url.append("?") - url.append(query) - - return "".join(url) - - @staticmethod - def _encode_params(data): - """Encode parameters in a piece of data. - - Will successfully encode parameters when passed as a dict or a list of - 2-tuples. Order is retained if data is a list of 2-tuples but arbitrary - if parameters are supplied as a dict. - """ - - if isinstance(data, (str, bytes)): - return data - elif hasattr(data, "read"): - return data - elif hasattr(data, "__iter__"): - result = [] - for k, vs in to_key_val_list(data): - if isinstance(vs, basestring) or not hasattr(vs, "__iter__"): - vs = [vs] - for v in vs: - if v is not None: - result.append( - ( - k.encode("utf-8") if isinstance(k, str) else k, - v.encode("utf-8") if isinstance(v, str) else v, - ) - ) - return urlencode(result, doseq=True) - else: - return data - - @staticmethod - def _encode_files(files, data): - """Build the body for a multipart/form-data request. - - Will successfully encode files when passed as a dict or a list of - tuples. Order is retained if data is a list of tuples but arbitrary - if parameters are supplied as a dict. - The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype) - or 4-tuples (filename, fileobj, contentype, custom_headers). - """ - if not files: - raise ValueError("Files must be provided.") - elif isinstance(data, basestring): - raise ValueError("Data must not be a string.") - - new_fields = [] - fields = to_key_val_list(data or {}) - files = to_key_val_list(files or {}) - - for field, val in fields: - if isinstance(val, basestring) or not hasattr(val, "__iter__"): - val = [val] - for v in val: - if v is not None: - # Don't call str() on bytestrings: in Py3 it all goes wrong. - if not isinstance(v, bytes): - v = str(v) - - new_fields.append( - ( - field.decode("utf-8") - if isinstance(field, bytes) - else field, - v.encode("utf-8") if isinstance(v, str) else v, - ) - ) - - for (k, v) in files: - # support for explicit filename - ft = None - fh = None - if isinstance(v, (tuple, list)): - if len(v) == 2: - fn, fp = v - elif len(v) == 3: - fn, fp, ft = v - else: - fn, fp, ft, fh = v - else: - fn = guess_filename(v) or k - fp = v - - if isinstance(fp, (str, bytes, bytearray)): - fdata = fp - elif hasattr(fp, "read"): - fdata = fp.read() - elif fp is None: - continue - else: - fdata = fp - - rf = RequestField(name=k, data=fdata, filename=fn, headers=fh) - rf.make_multipart(content_type=ft) - new_fields.append(rf) - - body, content_type = encode_multipart_formdata(new_fields) - - return body, content_type - - -class RequestHooksMixin: - def register_hook(self, event, hook): - """Properly register a hook.""" - - if event not in self.hooks: - raise ValueError(f'Unsupported event specified, with event name "{event}"') - - if isinstance(hook, Callable): - self.hooks[event].append(hook) - elif hasattr(hook, "__iter__"): - self.hooks[event].extend(h for h in hook if isinstance(h, Callable)) - - def deregister_hook(self, event, hook): - """Deregister a previously registered hook. - Returns True if the hook existed, False if not. - """ - - try: - self.hooks[event].remove(hook) - return True - except ValueError: - return False - - -class Request(RequestHooksMixin): - """A user-created :class:`Request ` object. - - Used to prepare a :class:`PreparedRequest `, which is sent to the server. - - :param method: HTTP method to use. - :param url: URL to send. - :param headers: dictionary of headers to send. - :param files: dictionary of {filename: fileobject} files to multipart upload. - :param data: the body to attach to the request. If a dictionary or - list of tuples ``[(key, value)]`` is provided, form-encoding will - take place. - :param json: json for the body to attach to the request (if files or data is not specified). - :param params: URL parameters to append to the URL. If a dictionary or - list of tuples ``[(key, value)]`` is provided, form-encoding will - take place. - :param auth: Auth handler or (user, pass) tuple. - :param cookies: dictionary or CookieJar of cookies to attach to this request. - :param hooks: dictionary of callback hooks, for internal usage. - - Usage:: - - >>> import requests - >>> req = requests.Request('GET', 'https://httpbin.org/get') - >>> req.prepare() - - """ - - def __init__( - self, - method=None, - url=None, - headers=None, - files=None, - data=None, - params=None, - auth=None, - cookies=None, - hooks=None, - json=None, - ): - - # Default empty dicts for dict params. - data = [] if data is None else data - files = [] if files is None else files - headers = {} if headers is None else headers - params = {} if params is None else params - hooks = {} if hooks is None else hooks - - self.hooks = default_hooks() - for (k, v) in list(hooks.items()): - self.register_hook(event=k, hook=v) - - self.method = method - self.url = url - self.headers = headers - self.files = files - self.data = data - self.json = json - self.params = params - self.auth = auth - self.cookies = cookies - - def __repr__(self): - return f"" - - def prepare(self): - """Constructs a :class:`PreparedRequest ` for transmission and returns it.""" - p = PreparedRequest() - p.prepare( - method=self.method, - url=self.url, - headers=self.headers, - files=self.files, - data=self.data, - json=self.json, - params=self.params, - auth=self.auth, - cookies=self.cookies, - hooks=self.hooks, - ) - return p - - -class PreparedRequest(RequestEncodingMixin, RequestHooksMixin): - """The fully mutable :class:`PreparedRequest ` object, - containing the exact bytes that will be sent to the server. - - Instances are generated from a :class:`Request ` object, and - should not be instantiated manually; doing so may produce undesirable - effects. - - Usage:: - - >>> import requests - >>> req = requests.Request('GET', 'https://httpbin.org/get') - >>> r = req.prepare() - >>> r - - - >>> s = requests.Session() - >>> s.send(r) - - """ - - def __init__(self): - #: HTTP verb to send to the server. - self.method = None - #: HTTP URL to send the request to. - self.url = None - #: dictionary of HTTP headers. - self.headers = None - # The `CookieJar` used to create the Cookie header will be stored here - # after prepare_cookies is called - self._cookies = None - #: request body to send to the server. - self.body = None - #: dictionary of callback hooks, for internal usage. - self.hooks = default_hooks() - #: integer denoting starting position of a readable file-like body. - self._body_position = None - - def prepare( - self, - method=None, - url=None, - headers=None, - files=None, - data=None, - params=None, - auth=None, - cookies=None, - hooks=None, - json=None, - ): - """Prepares the entire request with the given parameters.""" - - self.prepare_method(method) - self.prepare_url(url, params) - self.prepare_headers(headers) - self.prepare_cookies(cookies) - self.prepare_body(data, files, json) - self.prepare_auth(auth, url) - - # Note that prepare_auth must be last to enable authentication schemes - # such as OAuth to work on a fully prepared request. - - # This MUST go after prepare_auth. Authenticators could add a hook - self.prepare_hooks(hooks) - - def __repr__(self): - return f"" - - def copy(self): - p = PreparedRequest() - p.method = self.method - p.url = self.url - p.headers = self.headers.copy() if self.headers is not None else None - p._cookies = _copy_cookie_jar(self._cookies) - p.body = self.body - p.hooks = self.hooks - p._body_position = self._body_position - return p - - def prepare_method(self, method): - """Prepares the given HTTP method.""" - self.method = method - if self.method is not None: - self.method = to_native_string(self.method.upper()) - - @staticmethod - def _get_idna_encoded_host(host): - import idna - - try: - host = idna.encode(host, uts46=True).decode("utf-8") - except idna.IDNAError: - raise UnicodeError - return host - - def prepare_url(self, url, params): - """Prepares the given HTTP URL.""" - #: Accept objects that have string representations. - #: We're unable to blindly call unicode/str functions - #: as this will include the bytestring indicator (b'') - #: on python 3.x. - #: https://github.com/psf/requests/pull/2238 - if isinstance(url, bytes): - url = url.decode("utf8") - else: - url = str(url) - - # Remove leading whitespaces from url - url = url.lstrip() - - # Don't do any URL preparation for non-HTTP schemes like `mailto`, - # `data` etc to work around exceptions from `url_parse`, which - # handles RFC 3986 only. - if ":" in url and not url.lower().startswith("http"): - self.url = url - return - - # Support for unicode domain names and paths. - try: - scheme, auth, host, port, path, query, fragment = parse_url(url) - except LocationParseError as e: - raise InvalidURL(*e.args) - - if not scheme: - raise MissingSchema( - f"Invalid URL {url!r}: No scheme supplied. " - f"Perhaps you meant https://{url}?" - ) - - if not host: - raise InvalidURL(f"Invalid URL {url!r}: No host supplied") - - # In general, we want to try IDNA encoding the hostname if the string contains - # non-ASCII characters. This allows users to automatically get the correct IDNA - # behaviour. For strings containing only ASCII characters, we need to also verify - # it doesn't start with a wildcard (*), before allowing the unencoded hostname. - if not unicode_is_ascii(host): - try: - host = self._get_idna_encoded_host(host) - except UnicodeError: - raise InvalidURL("URL has an invalid label.") - elif host.startswith(("*", ".")): - raise InvalidURL("URL has an invalid label.") - - # Carefully reconstruct the network location - netloc = auth or "" - if netloc: - netloc += "@" - netloc += host - if port: - netloc += f":{port}" - - # Bare domains aren't valid URLs. - if not path: - path = "/" - - if isinstance(params, (str, bytes)): - params = to_native_string(params) - - enc_params = self._encode_params(params) - if enc_params: - if query: - query = f"{query}&{enc_params}" - else: - query = enc_params - - url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment])) - self.url = url - - def prepare_headers(self, headers): - """Prepares the given HTTP headers.""" - - self.headers = CaseInsensitiveDict() - if headers: - for header in headers.items(): - # Raise exception on invalid header value. - check_header_validity(header) - name, value = header - self.headers[to_native_string(name)] = value - - def prepare_body(self, data, files, json=None): - """Prepares the given HTTP body data.""" - - # Check if file, fo, generator, iterator. - # If not, run through normal process. - - # Nottin' on you. - body = None - content_type = None - - if not data and json is not None: - # urllib3 requires a bytes-like body. Python 2's json.dumps - # provides this natively, but Python 3 gives a Unicode string. - content_type = "application/json" - - try: - body = complexjson.dumps(json, allow_nan=False) - except ValueError as ve: - raise InvalidJSONError(ve, request=self) - - if not isinstance(body, bytes): - body = body.encode("utf-8") - - is_stream = all( - [ - hasattr(data, "__iter__"), - not isinstance(data, (basestring, list, tuple, Mapping)), - ] - ) - - if is_stream: - try: - length = super_len(data) - except (TypeError, AttributeError, UnsupportedOperation): - length = None - - body = data - - if getattr(body, "tell", None) is not None: - # Record the current file position before reading. - # This will allow us to rewind a file in the event - # of a redirect. - try: - self._body_position = body.tell() - except OSError: - # This differentiates from None, allowing us to catch - # a failed `tell()` later when trying to rewind the body - self._body_position = object() - - if files: - raise NotImplementedError( - "Streamed bodies and files are mutually exclusive." - ) - - if length: - self.headers["Content-Length"] = builtin_str(length) - else: - self.headers["Transfer-Encoding"] = "chunked" - else: - # Multi-part file uploads. - if files: - (body, content_type) = self._encode_files(files, data) - else: - if data: - body = self._encode_params(data) - if isinstance(data, basestring) or hasattr(data, "read"): - content_type = None - else: - content_type = "application/x-www-form-urlencoded" - - self.prepare_content_length(body) - - # Add content-type if it wasn't explicitly provided. - if content_type and ("content-type" not in self.headers): - self.headers["Content-Type"] = content_type - - self.body = body - - def prepare_content_length(self, body): - """Prepare Content-Length header based on request method and body""" - if body is not None: - length = super_len(body) - if length: - # If length exists, set it. Otherwise, we fallback - # to Transfer-Encoding: chunked. - self.headers["Content-Length"] = builtin_str(length) - elif ( - self.method not in ("GET", "HEAD") - and self.headers.get("Content-Length") is None - ): - # Set Content-Length to 0 for methods that can have a body - # but don't provide one. (i.e. not GET or HEAD) - self.headers["Content-Length"] = "0" - - def prepare_auth(self, auth, url=""): - """Prepares the given HTTP auth data.""" - - # If no Auth is explicitly provided, extract it from the URL first. - if auth is None: - url_auth = get_auth_from_url(self.url) - auth = url_auth if any(url_auth) else None - - if auth: - if isinstance(auth, tuple) and len(auth) == 2: - # special-case basic HTTP auth - auth = HTTPBasicAuth(*auth) - - # Allow auth to make its changes. - r = auth(self) - - # Update self to reflect the auth changes. - self.__dict__.update(r.__dict__) - - # Recompute Content-Length - self.prepare_content_length(self.body) - - def prepare_cookies(self, cookies): - """Prepares the given HTTP cookie data. - - This function eventually generates a ``Cookie`` header from the - given cookies using cookielib. Due to cookielib's design, the header - will not be regenerated if it already exists, meaning this function - can only be called once for the life of the - :class:`PreparedRequest ` object. Any subsequent calls - to ``prepare_cookies`` will have no actual effect, unless the "Cookie" - header is removed beforehand. - """ - if isinstance(cookies, cookielib.CookieJar): - self._cookies = cookies - else: - self._cookies = cookiejar_from_dict(cookies) - - cookie_header = get_cookie_header(self._cookies, self) - if cookie_header is not None: - self.headers["Cookie"] = cookie_header - - def prepare_hooks(self, hooks): - """Prepares the given hooks.""" - # hooks can be passed as None to the prepare method and to this - # method. To prevent iterating over None, simply use an empty list - # if hooks is False-y - hooks = hooks or [] - for event in hooks: - self.register_hook(event, hooks[event]) - - -class Response: - """The :class:`Response ` object, which contains a - server's response to an HTTP request. - """ - - __attrs__ = [ - "_content", - "status_code", - "headers", - "url", - "history", - "encoding", - "reason", - "cookies", - "elapsed", - "request", - ] - - def __init__(self): - self._content = False - self._content_consumed = False - self._next = None - - #: Integer Code of responded HTTP Status, e.g. 404 or 200. - self.status_code = None - - #: Case-insensitive Dictionary of Response Headers. - #: For example, ``headers['content-encoding']`` will return the - #: value of a ``'Content-Encoding'`` response header. - self.headers = CaseInsensitiveDict() - - #: File-like object representation of response (for advanced usage). - #: Use of ``raw`` requires that ``stream=True`` be set on the request. - #: This requirement does not apply for use internally to Requests. - self.raw = None - - #: Final URL location of Response. - self.url = None - - #: Encoding to decode with when accessing r.text. - self.encoding = None - - #: A list of :class:`Response ` objects from - #: the history of the Request. Any redirect responses will end - #: up here. The list is sorted from the oldest to the most recent request. - self.history = [] - - #: Textual reason of responded HTTP Status, e.g. "Not Found" or "OK". - self.reason = None - - #: A CookieJar of Cookies the server sent back. - self.cookies = cookiejar_from_dict({}) - - #: The amount of time elapsed between sending the request - #: and the arrival of the response (as a timedelta). - #: This property specifically measures the time taken between sending - #: the first byte of the request and finishing parsing the headers. It - #: is therefore unaffected by consuming the response content or the - #: value of the ``stream`` keyword argument. - self.elapsed = datetime.timedelta(0) - - #: The :class:`PreparedRequest ` object to which this - #: is a response. - self.request = None - - def __enter__(self): - return self - - def __exit__(self, *args): - self.close() - - def __getstate__(self): - # Consume everything; accessing the content attribute makes - # sure the content has been fully read. - if not self._content_consumed: - self.content - - return {attr: getattr(self, attr, None) for attr in self.__attrs__} - - def __setstate__(self, state): - for name, value in state.items(): - setattr(self, name, value) - - # pickled objects do not have .raw - setattr(self, "_content_consumed", True) - setattr(self, "raw", None) - - def __repr__(self): - return f"" - - def __bool__(self): - """Returns True if :attr:`status_code` is less than 400. - - This attribute checks if the status code of the response is between - 400 and 600 to see if there was a client error or a server error. If - the status code, is between 200 and 400, this will return True. This - is **not** a check to see if the response code is ``200 OK``. - """ - return self.ok - - def __nonzero__(self): - """Returns True if :attr:`status_code` is less than 400. - - This attribute checks if the status code of the response is between - 400 and 600 to see if there was a client error or a server error. If - the status code, is between 200 and 400, this will return True. This - is **not** a check to see if the response code is ``200 OK``. - """ - return self.ok - - def __iter__(self): - """Allows you to use a response as an iterator.""" - return self.iter_content(128) - - @property - def ok(self): - """Returns True if :attr:`status_code` is less than 400, False if not. - - This attribute checks if the status code of the response is between - 400 and 600 to see if there was a client error or a server error. If - the status code is between 200 and 400, this will return True. This - is **not** a check to see if the response code is ``200 OK``. - """ - try: - self.raise_for_status() - except HTTPError: - return False - return True - - @property - def is_redirect(self): - """True if this Response is a well-formed HTTP redirect that could have - been processed automatically (by :meth:`Session.resolve_redirects`). - """ - return "location" in self.headers and self.status_code in REDIRECT_STATI - - @property - def is_permanent_redirect(self): - """True if this Response one of the permanent versions of redirect.""" - return "location" in self.headers and self.status_code in ( - codes.moved_permanently, - codes.permanent_redirect, - ) - - @property - def next(self): - """Returns a PreparedRequest for the next request in a redirect chain, if there is one.""" - return self._next - - @property - def apparent_encoding(self): - """The apparent encoding, provided by the charset_normalizer or chardet libraries.""" - return chardet.detect(self.content)["encoding"] - - def iter_content(self, chunk_size=1, decode_unicode=False): - """Iterates over the response data. When stream=True is set on the - request, this avoids reading the content at once into memory for - large responses. The chunk size is the number of bytes it should - read into memory. This is not necessarily the length of each item - returned as decoding can take place. - - chunk_size must be of type int or None. A value of None will - function differently depending on the value of `stream`. - stream=True will read data as it arrives in whatever size the - chunks are received. If stream=False, data is returned as - a single chunk. - - If decode_unicode is True, content will be decoded using the best - available encoding based on the response. - """ - - def generate(): - # Special case for urllib3. - if hasattr(self.raw, "stream"): - try: - yield from self.raw.stream(chunk_size, decode_content=True) - except ProtocolError as e: - raise ChunkedEncodingError(e) - except DecodeError as e: - raise ContentDecodingError(e) - except ReadTimeoutError as e: - raise ConnectionError(e) - except SSLError as e: - raise RequestsSSLError(e) - else: - # Standard file-like object. - while True: - chunk = self.raw.read(chunk_size) - if not chunk: - break - yield chunk - - self._content_consumed = True - - if self._content_consumed and isinstance(self._content, bool): - raise StreamConsumedError() - elif chunk_size is not None and not isinstance(chunk_size, int): - raise TypeError( - f"chunk_size must be an int, it is instead a {type(chunk_size)}." - ) - # simulate reading small chunks of the content - reused_chunks = iter_slices(self._content, chunk_size) - - stream_chunks = generate() - - chunks = reused_chunks if self._content_consumed else stream_chunks - - if decode_unicode: - chunks = stream_decode_response_unicode(chunks, self) - - return chunks - - def iter_lines( - self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=False, delimiter=None - ): - """Iterates over the response data, one line at a time. When - stream=True is set on the request, this avoids reading the - content at once into memory for large responses. - - .. note:: This method is not reentrant safe. - """ - - pending = None - - for chunk in self.iter_content( - chunk_size=chunk_size, decode_unicode=decode_unicode - ): - - if pending is not None: - chunk = pending + chunk - - if delimiter: - lines = chunk.split(delimiter) - else: - lines = chunk.splitlines() - - if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]: - pending = lines.pop() - else: - pending = None - - yield from lines - - if pending is not None: - yield pending - - @property - def content(self): - """Content of the response, in bytes.""" - - if self._content is False: - # Read the contents. - if self._content_consumed: - raise RuntimeError("The content for this response was already consumed") - - if self.status_code == 0 or self.raw is None: - self._content = None - else: - self._content = b"".join(self.iter_content(CONTENT_CHUNK_SIZE)) or b"" - - self._content_consumed = True - # don't need to release the connection; that's been handled by urllib3 - # since we exhausted the data. - return self._content - - @property - def text(self): - """Content of the response, in unicode. - - If Response.encoding is None, encoding will be guessed using - ``charset_normalizer`` or ``chardet``. - - The encoding of the response content is determined based solely on HTTP - headers, following RFC 2616 to the letter. If you can take advantage of - non-HTTP knowledge to make a better guess at the encoding, you should - set ``r.encoding`` appropriately before accessing this property. - """ - - # Try charset from content-type - content = None - encoding = self.encoding - - if not self.content: - return "" - - # Fallback to auto-detected encoding. - if self.encoding is None: - encoding = self.apparent_encoding - - # Decode unicode from given encoding. - try: - content = str(self.content, encoding, errors="replace") - except (LookupError, TypeError): - # A LookupError is raised if the encoding was not found which could - # indicate a misspelling or similar mistake. - # - # A TypeError can be raised if encoding is None - # - # So we try blindly encoding. - content = str(self.content, errors="replace") - - return content - - def json(self, **kwargs): - r"""Returns the json-encoded content of a response, if any. - - :param \*\*kwargs: Optional arguments that ``json.loads`` takes. - :raises requests.exceptions.JSONDecodeError: If the response body does not - contain valid json. - """ - - if not self.encoding and self.content and len(self.content) > 3: - # No encoding set. JSON RFC 4627 section 3 states we should expect - # UTF-8, -16 or -32. Detect which one to use; If the detection or - # decoding fails, fall back to `self.text` (using charset_normalizer to make - # a best guess). - encoding = guess_json_utf(self.content) - if encoding is not None: - try: - return complexjson.loads(self.content.decode(encoding), **kwargs) - except UnicodeDecodeError: - # Wrong UTF codec detected; usually because it's not UTF-8 - # but some other 8-bit codec. This is an RFC violation, - # and the server didn't bother to tell us what codec *was* - # used. - pass - except JSONDecodeError as e: - raise RequestsJSONDecodeError(e.msg, e.doc, e.pos) - - try: - return complexjson.loads(self.text, **kwargs) - except JSONDecodeError as e: - # Catch JSON-related errors and raise as requests.JSONDecodeError - # This aliases json.JSONDecodeError and simplejson.JSONDecodeError - raise RequestsJSONDecodeError(e.msg, e.doc, e.pos) - - @property - def links(self): - """Returns the parsed header links of the response, if any.""" - - header = self.headers.get("link") - - resolved_links = {} - - if header: - links = parse_header_links(header) - - for link in links: - key = link.get("rel") or link.get("url") - resolved_links[key] = link - - return resolved_links - - def raise_for_status(self): - """Raises :class:`HTTPError`, if one occurred.""" - - http_error_msg = "" - if isinstance(self.reason, bytes): - # We attempt to decode utf-8 first because some servers - # choose to localize their reason strings. If the string - # isn't utf-8, we fall back to iso-8859-1 for all other - # encodings. (See PR #3538) - try: - reason = self.reason.decode("utf-8") - except UnicodeDecodeError: - reason = self.reason.decode("iso-8859-1") - else: - reason = self.reason - - if 400 <= self.status_code < 500: - http_error_msg = ( - f"{self.status_code} Client Error: {reason} for url: {self.url}" - ) - - elif 500 <= self.status_code < 600: - http_error_msg = ( - f"{self.status_code} Server Error: {reason} for url: {self.url}" - ) - - if http_error_msg: - raise HTTPError(http_error_msg, response=self) - - def close(self): - """Releases the connection back to the pool. Once this method has been - called the underlying ``raw`` object must not be accessed again. - - *Note: Should not normally need to be called explicitly.* - """ - if not self._content_consumed: - self.raw.close() - - release_conn = getattr(self.raw, "release_conn", None) - if release_conn is not None: - release_conn() diff --git a/Modules/requests/packages.py b/Modules/requests/packages.py deleted file mode 100644 index 77c45c9..0000000 --- a/Modules/requests/packages.py +++ /dev/null @@ -1,28 +0,0 @@ -import sys - -try: - import chardet -except ImportError: - import warnings - - import charset_normalizer as chardet - - warnings.filterwarnings("ignore", "Trying to detect", module="charset_normalizer") - -# This code exists for backwards compatibility reasons. -# I don't like it either. Just look the other way. :) - -for package in ("urllib3", "idna"): - locals()[package] = __import__(package) - # This traversal is apparently necessary such that the identities are - # preserved (requests.packages.urllib3.* is urllib3.*) - for mod in list(sys.modules): - if mod == package or mod.startswith(f"{package}."): - sys.modules[f"requests.packages.{mod}"] = sys.modules[mod] - -target = chardet.__name__ -for mod in list(sys.modules): - if mod == target or mod.startswith(f"{target}."): - target = target.replace(target, "chardet") - sys.modules[f"requests.packages.{target}"] = sys.modules[mod] -# Kinda cool, though, right? diff --git a/Modules/requests/sessions.py b/Modules/requests/sessions.py deleted file mode 100644 index dbcf2a7..0000000 --- a/Modules/requests/sessions.py +++ /dev/null @@ -1,833 +0,0 @@ -""" -requests.sessions -~~~~~~~~~~~~~~~~~ - -This module provides a Session object to manage and persist settings across -requests (cookies, auth, proxies). -""" -import os -import sys -import time -from collections import OrderedDict -from datetime import timedelta - -from ._internal_utils import to_native_string -from .adapters import HTTPAdapter -from .auth import _basic_auth_str -from .compat import Mapping, cookielib, urljoin, urlparse -from .cookies import ( - RequestsCookieJar, - cookiejar_from_dict, - extract_cookies_to_jar, - merge_cookies, -) -from .exceptions import ( - ChunkedEncodingError, - ContentDecodingError, - InvalidSchema, - TooManyRedirects, -) -from .hooks import default_hooks, dispatch_hook - -# formerly defined here, reexposed here for backward compatibility -from .models import ( # noqa: F401 - DEFAULT_REDIRECT_LIMIT, - REDIRECT_STATI, - PreparedRequest, - Request, -) -from .status_codes import codes -from .structures import CaseInsensitiveDict -from .utils import ( # noqa: F401 - DEFAULT_PORTS, - default_headers, - get_auth_from_url, - get_environ_proxies, - get_netrc_auth, - requote_uri, - resolve_proxies, - rewind_body, - should_bypass_proxies, - to_key_val_list, -) - -# Preferred clock, based on which one is more accurate on a given system. -if sys.platform == "win32": - preferred_clock = time.perf_counter -else: - preferred_clock = time.time - - -def merge_setting(request_setting, session_setting, dict_class=OrderedDict): - """Determines appropriate setting for a given request, taking into account - the explicit setting on that request, and the setting in the session. If a - setting is a dictionary, they will be merged together using `dict_class` - """ - - if session_setting is None: - return request_setting - - if request_setting is None: - return session_setting - - # Bypass if not a dictionary (e.g. verify) - if not ( - isinstance(session_setting, Mapping) and isinstance(request_setting, Mapping) - ): - return request_setting - - merged_setting = dict_class(to_key_val_list(session_setting)) - merged_setting.update(to_key_val_list(request_setting)) - - # Remove keys that are set to None. Extract keys first to avoid altering - # the dictionary during iteration. - none_keys = [k for (k, v) in merged_setting.items() if v is None] - for key in none_keys: - del merged_setting[key] - - return merged_setting - - -def merge_hooks(request_hooks, session_hooks, dict_class=OrderedDict): - """Properly merges both requests and session hooks. - - This is necessary because when request_hooks == {'response': []}, the - merge breaks Session hooks entirely. - """ - if session_hooks is None or session_hooks.get("response") == []: - return request_hooks - - if request_hooks is None or request_hooks.get("response") == []: - return session_hooks - - return merge_setting(request_hooks, session_hooks, dict_class) - - -class SessionRedirectMixin: - def get_redirect_target(self, resp): - """Receives a Response. Returns a redirect URI or ``None``""" - # Due to the nature of how requests processes redirects this method will - # be called at least once upon the original response and at least twice - # on each subsequent redirect response (if any). - # If a custom mixin is used to handle this logic, it may be advantageous - # to cache the redirect location onto the response object as a private - # attribute. - if resp.is_redirect: - location = resp.headers["location"] - # Currently the underlying http module on py3 decode headers - # in latin1, but empirical evidence suggests that latin1 is very - # rarely used with non-ASCII characters in HTTP headers. - # It is more likely to get UTF8 header rather than latin1. - # This causes incorrect handling of UTF8 encoded location headers. - # To solve this, we re-encode the location in latin1. - location = location.encode("latin1") - return to_native_string(location, "utf8") - return None - - def should_strip_auth(self, old_url, new_url): - """Decide whether Authorization header should be removed when redirecting""" - old_parsed = urlparse(old_url) - new_parsed = urlparse(new_url) - if old_parsed.hostname != new_parsed.hostname: - return True - # Special case: allow http -> https redirect when using the standard - # ports. This isn't specified by RFC 7235, but is kept to avoid - # breaking backwards compatibility with older versions of requests - # that allowed any redirects on the same host. - if ( - old_parsed.scheme == "http" - and old_parsed.port in (80, None) - and new_parsed.scheme == "https" - and new_parsed.port in (443, None) - ): - return False - - # Handle default port usage corresponding to scheme. - changed_port = old_parsed.port != new_parsed.port - changed_scheme = old_parsed.scheme != new_parsed.scheme - default_port = (DEFAULT_PORTS.get(old_parsed.scheme, None), None) - if ( - not changed_scheme - and old_parsed.port in default_port - and new_parsed.port in default_port - ): - return False - - # Standard case: root URI must match - return changed_port or changed_scheme - - def resolve_redirects( - self, - resp, - req, - stream=False, - timeout=None, - verify=True, - cert=None, - proxies=None, - yield_requests=False, - **adapter_kwargs, - ): - """Receives a Response. Returns a generator of Responses or Requests.""" - - hist = [] # keep track of history - - url = self.get_redirect_target(resp) - previous_fragment = urlparse(req.url).fragment - while url: - prepared_request = req.copy() - - # Update history and keep track of redirects. - # resp.history must ignore the original request in this loop - hist.append(resp) - resp.history = hist[1:] - - try: - resp.content # Consume socket so it can be released - except (ChunkedEncodingError, ContentDecodingError, RuntimeError): - resp.raw.read(decode_content=False) - - if len(resp.history) >= self.max_redirects: - raise TooManyRedirects( - f"Exceeded {self.max_redirects} redirects.", response=resp - ) - - # Release the connection back into the pool. - resp.close() - - # Handle redirection without scheme (see: RFC 1808 Section 4) - if url.startswith("//"): - parsed_rurl = urlparse(resp.url) - url = ":".join([to_native_string(parsed_rurl.scheme), url]) - - # Normalize url case and attach previous fragment if needed (RFC 7231 7.1.2) - parsed = urlparse(url) - if parsed.fragment == "" and previous_fragment: - parsed = parsed._replace(fragment=previous_fragment) - elif parsed.fragment: - previous_fragment = parsed.fragment - url = parsed.geturl() - - # Facilitate relative 'location' headers, as allowed by RFC 7231. - # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource') - # Compliant with RFC3986, we percent encode the url. - if not parsed.netloc: - url = urljoin(resp.url, requote_uri(url)) - else: - url = requote_uri(url) - - prepared_request.url = to_native_string(url) - - self.rebuild_method(prepared_request, resp) - - # https://github.com/psf/requests/issues/1084 - if resp.status_code not in ( - codes.temporary_redirect, - codes.permanent_redirect, - ): - # https://github.com/psf/requests/issues/3490 - purged_headers = ("Content-Length", "Content-Type", "Transfer-Encoding") - for header in purged_headers: - prepared_request.headers.pop(header, None) - prepared_request.body = None - - headers = prepared_request.headers - headers.pop("Cookie", None) - - # Extract any cookies sent on the response to the cookiejar - # in the new request. Because we've mutated our copied prepared - # request, use the old one that we haven't yet touched. - extract_cookies_to_jar(prepared_request._cookies, req, resp.raw) - merge_cookies(prepared_request._cookies, self.cookies) - prepared_request.prepare_cookies(prepared_request._cookies) - - # Rebuild auth and proxy information. - proxies = self.rebuild_proxies(prepared_request, proxies) - self.rebuild_auth(prepared_request, resp) - - # A failed tell() sets `_body_position` to `object()`. This non-None - # value ensures `rewindable` will be True, allowing us to raise an - # UnrewindableBodyError, instead of hanging the connection. - rewindable = prepared_request._body_position is not None and ( - "Content-Length" in headers or "Transfer-Encoding" in headers - ) - - # Attempt to rewind consumed file-like object. - if rewindable: - rewind_body(prepared_request) - - # Override the original request. - req = prepared_request - - if yield_requests: - yield req - else: - - resp = self.send( - req, - stream=stream, - timeout=timeout, - verify=verify, - cert=cert, - proxies=proxies, - allow_redirects=False, - **adapter_kwargs, - ) - - extract_cookies_to_jar(self.cookies, prepared_request, resp.raw) - - # extract redirect url, if any, for the next loop - url = self.get_redirect_target(resp) - yield resp - - def rebuild_auth(self, prepared_request, response): - """When being redirected we may want to strip authentication from the - request to avoid leaking credentials. This method intelligently removes - and reapplies authentication where possible to avoid credential loss. - """ - headers = prepared_request.headers - url = prepared_request.url - - if "Authorization" in headers and self.should_strip_auth( - response.request.url, url - ): - # If we get redirected to a new host, we should strip out any - # authentication headers. - del headers["Authorization"] - - # .netrc might have more auth for us on our new host. - new_auth = get_netrc_auth(url) if self.trust_env else None - if new_auth is not None: - prepared_request.prepare_auth(new_auth) - - def rebuild_proxies(self, prepared_request, proxies): - """This method re-evaluates the proxy configuration by considering the - environment variables. If we are redirected to a URL covered by - NO_PROXY, we strip the proxy configuration. Otherwise, we set missing - proxy keys for this URL (in case they were stripped by a previous - redirect). - - This method also replaces the Proxy-Authorization header where - necessary. - - :rtype: dict - """ - headers = prepared_request.headers - scheme = urlparse(prepared_request.url).scheme - new_proxies = resolve_proxies(prepared_request, proxies, self.trust_env) - - if "Proxy-Authorization" in headers: - del headers["Proxy-Authorization"] - - try: - username, password = get_auth_from_url(new_proxies[scheme]) - except KeyError: - username, password = None, None - - # urllib3 handles proxy authorization for us in the standard adapter. - # Avoid appending this to TLS tunneled requests where it may be leaked. - if not scheme.startswith('https') and username and password: - headers["Proxy-Authorization"] = _basic_auth_str(username, password) - - return new_proxies - - def rebuild_method(self, prepared_request, response): - """When being redirected we may want to change the method of the request - based on certain specs or browser behavior. - """ - method = prepared_request.method - - # https://tools.ietf.org/html/rfc7231#section-6.4.4 - if response.status_code == codes.see_other and method != "HEAD": - method = "GET" - - # Do what the browsers do, despite standards... - # First, turn 302s into GETs. - if response.status_code == codes.found and method != "HEAD": - method = "GET" - - # Second, if a POST is responded to with a 301, turn it into a GET. - # This bizarre behaviour is explained in Issue 1704. - if response.status_code == codes.moved and method == "POST": - method = "GET" - - prepared_request.method = method - - -class Session(SessionRedirectMixin): - """A Requests session. - - Provides cookie persistence, connection-pooling, and configuration. - - Basic Usage:: - - >>> import requests - >>> s = requests.Session() - >>> s.get('https://httpbin.org/get') - - - Or as a context manager:: - - >>> with requests.Session() as s: - ... s.get('https://httpbin.org/get') - - """ - - __attrs__ = [ - "headers", - "cookies", - "auth", - "proxies", - "hooks", - "params", - "verify", - "cert", - "adapters", - "stream", - "trust_env", - "max_redirects", - ] - - def __init__(self): - - #: A case-insensitive dictionary of headers to be sent on each - #: :class:`Request ` sent from this - #: :class:`Session `. - self.headers = default_headers() - - #: Default Authentication tuple or object to attach to - #: :class:`Request `. - self.auth = None - - #: Dictionary mapping protocol or protocol and host to the URL of the proxy - #: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to - #: be used on each :class:`Request `. - self.proxies = {} - - #: Event-handling hooks. - self.hooks = default_hooks() - - #: Dictionary of querystring data to attach to each - #: :class:`Request `. The dictionary values may be lists for - #: representing multivalued query parameters. - self.params = {} - - #: Stream response content default. - self.stream = False - - #: SSL Verification default. - #: Defaults to `True`, requiring requests to verify the TLS certificate at the - #: remote end. - #: If verify is set to `False`, requests will accept any TLS certificate - #: presented by the server, and will ignore hostname mismatches and/or - #: expired certificates, which will make your application vulnerable to - #: man-in-the-middle (MitM) attacks. - #: Only set this to `False` for testing. - self.verify = True - - #: SSL client certificate default, if String, path to ssl client - #: cert file (.pem). If Tuple, ('cert', 'key') pair. - self.cert = None - - #: Maximum number of redirects allowed. If the request exceeds this - #: limit, a :class:`TooManyRedirects` exception is raised. - #: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is - #: 30. - self.max_redirects = DEFAULT_REDIRECT_LIMIT - - #: Trust environment settings for proxy configuration, default - #: authentication and similar. - self.trust_env = True - - #: A CookieJar containing all currently outstanding cookies set on this - #: session. By default it is a - #: :class:`RequestsCookieJar `, but - #: may be any other ``cookielib.CookieJar`` compatible object. - self.cookies = cookiejar_from_dict({}) - - # Default connection adapters. - self.adapters = OrderedDict() - self.mount("https://", HTTPAdapter()) - self.mount("http://", HTTPAdapter()) - - def __enter__(self): - return self - - def __exit__(self, *args): - self.close() - - def prepare_request(self, request): - """Constructs a :class:`PreparedRequest ` for - transmission and returns it. The :class:`PreparedRequest` has settings - merged from the :class:`Request ` instance and those of the - :class:`Session`. - - :param request: :class:`Request` instance to prepare with this - session's settings. - :rtype: requests.PreparedRequest - """ - cookies = request.cookies or {} - - # Bootstrap CookieJar. - if not isinstance(cookies, cookielib.CookieJar): - cookies = cookiejar_from_dict(cookies) - - # Merge with session cookies - merged_cookies = merge_cookies( - merge_cookies(RequestsCookieJar(), self.cookies), cookies - ) - - # Set environment's basic authentication if not explicitly set. - auth = request.auth - if self.trust_env and not auth and not self.auth: - auth = get_netrc_auth(request.url) - - p = PreparedRequest() - p.prepare( - method=request.method.upper(), - url=request.url, - files=request.files, - data=request.data, - json=request.json, - headers=merge_setting( - request.headers, self.headers, dict_class=CaseInsensitiveDict - ), - params=merge_setting(request.params, self.params), - auth=merge_setting(auth, self.auth), - cookies=merged_cookies, - hooks=merge_hooks(request.hooks, self.hooks), - ) - return p - - def request( - self, - method, - url, - params=None, - data=None, - headers=None, - cookies=None, - files=None, - auth=None, - timeout=None, - allow_redirects=True, - proxies=None, - hooks=None, - stream=None, - verify=None, - cert=None, - json=None, - ): - """Constructs a :class:`Request `, prepares it and sends it. - Returns :class:`Response ` object. - - :param method: method for the new :class:`Request` object. - :param url: URL for the new :class:`Request` object. - :param params: (optional) Dictionary or bytes to be sent in the query - string for the :class:`Request`. - :param data: (optional) Dictionary, list of tuples, bytes, or file-like - object to send in the body of the :class:`Request`. - :param json: (optional) json to send in the body of the - :class:`Request`. - :param headers: (optional) Dictionary of HTTP Headers to send with the - :class:`Request`. - :param cookies: (optional) Dict or CookieJar object to send with the - :class:`Request`. - :param files: (optional) Dictionary of ``'filename': file-like-objects`` - for multipart encoding upload. - :param auth: (optional) Auth tuple or callable to enable - Basic/Digest/Custom HTTP Auth. - :param timeout: (optional) How long to wait for the server to send - data before giving up, as a float, or a :ref:`(connect timeout, - read timeout) ` tuple. - :type timeout: float or tuple - :param allow_redirects: (optional) Set to True by default. - :type allow_redirects: bool - :param proxies: (optional) Dictionary mapping protocol or protocol and - hostname to the URL of the proxy. - :param stream: (optional) whether to immediately download the response - content. Defaults to ``False``. - :param verify: (optional) Either a boolean, in which case it controls whether we verify - the server's TLS certificate, or a string, in which case it must be a path - to a CA bundle to use. Defaults to ``True``. When set to - ``False``, requests will accept any TLS certificate presented by - the server, and will ignore hostname mismatches and/or expired - certificates, which will make your application vulnerable to - man-in-the-middle (MitM) attacks. Setting verify to ``False`` - may be useful during local development or testing. - :param cert: (optional) if String, path to ssl client cert file (.pem). - If Tuple, ('cert', 'key') pair. - :rtype: requests.Response - """ - # Create the Request. - req = Request( - method=method.upper(), - url=url, - headers=headers, - files=files, - data=data or {}, - json=json, - params=params or {}, - auth=auth, - cookies=cookies, - hooks=hooks, - ) - prep = self.prepare_request(req) - - proxies = proxies or {} - - settings = self.merge_environment_settings( - prep.url, proxies, stream, verify, cert - ) - - # Send the request. - send_kwargs = { - "timeout": timeout, - "allow_redirects": allow_redirects, - } - send_kwargs.update(settings) - resp = self.send(prep, **send_kwargs) - - return resp - - def get(self, url, **kwargs): - r"""Sends a GET request. Returns :class:`Response` object. - - :param url: URL for the new :class:`Request` object. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :rtype: requests.Response - """ - - kwargs.setdefault("allow_redirects", True) - return self.request("GET", url, **kwargs) - - def options(self, url, **kwargs): - r"""Sends a OPTIONS request. Returns :class:`Response` object. - - :param url: URL for the new :class:`Request` object. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :rtype: requests.Response - """ - - kwargs.setdefault("allow_redirects", True) - return self.request("OPTIONS", url, **kwargs) - - def head(self, url, **kwargs): - r"""Sends a HEAD request. Returns :class:`Response` object. - - :param url: URL for the new :class:`Request` object. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :rtype: requests.Response - """ - - kwargs.setdefault("allow_redirects", False) - return self.request("HEAD", url, **kwargs) - - def post(self, url, data=None, json=None, **kwargs): - r"""Sends a POST request. Returns :class:`Response` object. - - :param url: URL for the new :class:`Request` object. - :param data: (optional) Dictionary, list of tuples, bytes, or file-like - object to send in the body of the :class:`Request`. - :param json: (optional) json to send in the body of the :class:`Request`. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :rtype: requests.Response - """ - - return self.request("POST", url, data=data, json=json, **kwargs) - - def put(self, url, data=None, **kwargs): - r"""Sends a PUT request. Returns :class:`Response` object. - - :param url: URL for the new :class:`Request` object. - :param data: (optional) Dictionary, list of tuples, bytes, or file-like - object to send in the body of the :class:`Request`. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :rtype: requests.Response - """ - - return self.request("PUT", url, data=data, **kwargs) - - def patch(self, url, data=None, **kwargs): - r"""Sends a PATCH request. Returns :class:`Response` object. - - :param url: URL for the new :class:`Request` object. - :param data: (optional) Dictionary, list of tuples, bytes, or file-like - object to send in the body of the :class:`Request`. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :rtype: requests.Response - """ - - return self.request("PATCH", url, data=data, **kwargs) - - def delete(self, url, **kwargs): - r"""Sends a DELETE request. Returns :class:`Response` object. - - :param url: URL for the new :class:`Request` object. - :param \*\*kwargs: Optional arguments that ``request`` takes. - :rtype: requests.Response - """ - - return self.request("DELETE", url, **kwargs) - - def send(self, request, **kwargs): - """Send a given PreparedRequest. - - :rtype: requests.Response - """ - # Set defaults that the hooks can utilize to ensure they always have - # the correct parameters to reproduce the previous request. - kwargs.setdefault("stream", self.stream) - kwargs.setdefault("verify", self.verify) - kwargs.setdefault("cert", self.cert) - if "proxies" not in kwargs: - kwargs["proxies"] = resolve_proxies(request, self.proxies, self.trust_env) - - # It's possible that users might accidentally send a Request object. - # Guard against that specific failure case. - if isinstance(request, Request): - raise ValueError("You can only send PreparedRequests.") - - # Set up variables needed for resolve_redirects and dispatching of hooks - allow_redirects = kwargs.pop("allow_redirects", True) - stream = kwargs.get("stream") - hooks = request.hooks - - # Get the appropriate adapter to use - adapter = self.get_adapter(url=request.url) - - # Start time (approximately) of the request - start = preferred_clock() - - # Send the request - r = adapter.send(request, **kwargs) - - # Total elapsed time of the request (approximately) - elapsed = preferred_clock() - start - r.elapsed = timedelta(seconds=elapsed) - - # Response manipulation hooks - r = dispatch_hook("response", hooks, r, **kwargs) - - # Persist cookies - if r.history: - - # If the hooks create history then we want those cookies too - for resp in r.history: - extract_cookies_to_jar(self.cookies, resp.request, resp.raw) - - extract_cookies_to_jar(self.cookies, request, r.raw) - - # Resolve redirects if allowed. - if allow_redirects: - # Redirect resolving generator. - gen = self.resolve_redirects(r, request, **kwargs) - history = [resp for resp in gen] - else: - history = [] - - # Shuffle things around if there's history. - if history: - # Insert the first (original) request at the start - history.insert(0, r) - # Get the last request made - r = history.pop() - r.history = history - - # If redirects aren't being followed, store the response on the Request for Response.next(). - if not allow_redirects: - try: - r._next = next( - self.resolve_redirects(r, request, yield_requests=True, **kwargs) - ) - except StopIteration: - pass - - if not stream: - r.content - - return r - - def merge_environment_settings(self, url, proxies, stream, verify, cert): - """ - Check the environment and merge it with some settings. - - :rtype: dict - """ - # Gather clues from the surrounding environment. - if self.trust_env: - # Set environment's proxies. - no_proxy = proxies.get("no_proxy") if proxies is not None else None - env_proxies = get_environ_proxies(url, no_proxy=no_proxy) - for (k, v) in env_proxies.items(): - proxies.setdefault(k, v) - - # Look for requests environment configuration - # and be compatible with cURL. - if verify is True or verify is None: - verify = ( - os.environ.get("REQUESTS_CA_BUNDLE") - or os.environ.get("CURL_CA_BUNDLE") - or verify - ) - - # Merge all the kwargs. - proxies = merge_setting(proxies, self.proxies) - stream = merge_setting(stream, self.stream) - verify = merge_setting(verify, self.verify) - cert = merge_setting(cert, self.cert) - - return {"proxies": proxies, "stream": stream, "verify": verify, "cert": cert} - - def get_adapter(self, url): - """ - Returns the appropriate connection adapter for the given URL. - - :rtype: requests.adapters.BaseAdapter - """ - for (prefix, adapter) in self.adapters.items(): - - if url.lower().startswith(prefix.lower()): - return adapter - - # Nothing matches :-/ - raise InvalidSchema(f"No connection adapters were found for {url!r}") - - def close(self): - """Closes all adapters and as such the session""" - for v in self.adapters.values(): - v.close() - - def mount(self, prefix, adapter): - """Registers a connection adapter to a prefix. - - Adapters are sorted in descending order by prefix length. - """ - self.adapters[prefix] = adapter - keys_to_move = [k for k in self.adapters if len(k) < len(prefix)] - - for key in keys_to_move: - self.adapters[key] = self.adapters.pop(key) - - def __getstate__(self): - state = {attr: getattr(self, attr, None) for attr in self.__attrs__} - return state - - def __setstate__(self, state): - for attr, value in state.items(): - setattr(self, attr, value) - - -def session(): - """ - Returns a :class:`Session` for context-management. - - .. deprecated:: 1.0.0 - - This method has been deprecated since version 1.0.0 and is only kept for - backwards compatibility. New code should use :class:`~requests.sessions.Session` - to create a session. This may be removed at a future date. - - :rtype: Session - """ - return Session() diff --git a/Modules/requests/status_codes.py b/Modules/requests/status_codes.py deleted file mode 100644 index 4bd072b..0000000 --- a/Modules/requests/status_codes.py +++ /dev/null @@ -1,128 +0,0 @@ -r""" -The ``codes`` object defines a mapping from common names for HTTP statuses -to their numerical codes, accessible either as attributes or as dictionary -items. - -Example:: - - >>> import requests - >>> requests.codes['temporary_redirect'] - 307 - >>> requests.codes.teapot - 418 - >>> requests.codes['\o/'] - 200 - -Some codes have multiple names, and both upper- and lower-case versions of -the names are allowed. For example, ``codes.ok``, ``codes.OK``, and -``codes.okay`` all correspond to the HTTP status code 200. -""" - -from .structures import LookupDict - -_codes = { - # Informational. - 100: ("continue",), - 101: ("switching_protocols",), - 102: ("processing",), - 103: ("checkpoint",), - 122: ("uri_too_long", "request_uri_too_long"), - 200: ("ok", "okay", "all_ok", "all_okay", "all_good", "\\o/", "✓"), - 201: ("created",), - 202: ("accepted",), - 203: ("non_authoritative_info", "non_authoritative_information"), - 204: ("no_content",), - 205: ("reset_content", "reset"), - 206: ("partial_content", "partial"), - 207: ("multi_status", "multiple_status", "multi_stati", "multiple_stati"), - 208: ("already_reported",), - 226: ("im_used",), - # Redirection. - 300: ("multiple_choices",), - 301: ("moved_permanently", "moved", "\\o-"), - 302: ("found",), - 303: ("see_other", "other"), - 304: ("not_modified",), - 305: ("use_proxy",), - 306: ("switch_proxy",), - 307: ("temporary_redirect", "temporary_moved", "temporary"), - 308: ( - "permanent_redirect", - "resume_incomplete", - "resume", - ), # "resume" and "resume_incomplete" to be removed in 3.0 - # Client Error. - 400: ("bad_request", "bad"), - 401: ("unauthorized",), - 402: ("payment_required", "payment"), - 403: ("forbidden",), - 404: ("not_found", "-o-"), - 405: ("method_not_allowed", "not_allowed"), - 406: ("not_acceptable",), - 407: ("proxy_authentication_required", "proxy_auth", "proxy_authentication"), - 408: ("request_timeout", "timeout"), - 409: ("conflict",), - 410: ("gone",), - 411: ("length_required",), - 412: ("precondition_failed", "precondition"), - 413: ("request_entity_too_large",), - 414: ("request_uri_too_large",), - 415: ("unsupported_media_type", "unsupported_media", "media_type"), - 416: ( - "requested_range_not_satisfiable", - "requested_range", - "range_not_satisfiable", - ), - 417: ("expectation_failed",), - 418: ("im_a_teapot", "teapot", "i_am_a_teapot"), - 421: ("misdirected_request",), - 422: ("unprocessable_entity", "unprocessable"), - 423: ("locked",), - 424: ("failed_dependency", "dependency"), - 425: ("unordered_collection", "unordered"), - 426: ("upgrade_required", "upgrade"), - 428: ("precondition_required", "precondition"), - 429: ("too_many_requests", "too_many"), - 431: ("header_fields_too_large", "fields_too_large"), - 444: ("no_response", "none"), - 449: ("retry_with", "retry"), - 450: ("blocked_by_windows_parental_controls", "parental_controls"), - 451: ("unavailable_for_legal_reasons", "legal_reasons"), - 499: ("client_closed_request",), - # Server Error. - 500: ("internal_server_error", "server_error", "/o\\", "✗"), - 501: ("not_implemented",), - 502: ("bad_gateway",), - 503: ("service_unavailable", "unavailable"), - 504: ("gateway_timeout",), - 505: ("http_version_not_supported", "http_version"), - 506: ("variant_also_negotiates",), - 507: ("insufficient_storage",), - 509: ("bandwidth_limit_exceeded", "bandwidth"), - 510: ("not_extended",), - 511: ("network_authentication_required", "network_auth", "network_authentication"), -} - -codes = LookupDict(name="status_codes") - - -def _init(): - for code, titles in _codes.items(): - for title in titles: - setattr(codes, title, code) - if not title.startswith(("\\", "/")): - setattr(codes, title.upper(), code) - - def doc(code): - names = ", ".join(f"``{n}``" for n in _codes[code]) - return "* %d: %s" % (code, names) - - global __doc__ - __doc__ = ( - __doc__ + "\n" + "\n".join(doc(code) for code in sorted(_codes)) - if __doc__ is not None - else None - ) - - -_init() diff --git a/Modules/requests/structures.py b/Modules/requests/structures.py deleted file mode 100644 index 188e13e..0000000 --- a/Modules/requests/structures.py +++ /dev/null @@ -1,99 +0,0 @@ -""" -requests.structures -~~~~~~~~~~~~~~~~~~~ - -Data structures that power Requests. -""" - -from collections import OrderedDict - -from .compat import Mapping, MutableMapping - - -class CaseInsensitiveDict(MutableMapping): - """A case-insensitive ``dict``-like object. - - Implements all methods and operations of - ``MutableMapping`` as well as dict's ``copy``. Also - provides ``lower_items``. - - All keys are expected to be strings. The structure remembers the - case of the last key to be set, and ``iter(instance)``, - ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()`` - will contain case-sensitive keys. However, querying and contains - testing is case insensitive:: - - cid = CaseInsensitiveDict() - cid['Accept'] = 'application/json' - cid['aCCEPT'] == 'application/json' # True - list(cid) == ['Accept'] # True - - For example, ``headers['content-encoding']`` will return the - value of a ``'Content-Encoding'`` response header, regardless - of how the header name was originally stored. - - If the constructor, ``.update``, or equality comparison - operations are given keys that have equal ``.lower()``s, the - behavior is undefined. - """ - - def __init__(self, data=None, **kwargs): - self._store = OrderedDict() - if data is None: - data = {} - self.update(data, **kwargs) - - def __setitem__(self, key, value): - # Use the lowercased key for lookups, but store the actual - # key alongside the value. - self._store[key.lower()] = (key, value) - - def __getitem__(self, key): - return self._store[key.lower()][1] - - def __delitem__(self, key): - del self._store[key.lower()] - - def __iter__(self): - return (casedkey for casedkey, mappedvalue in self._store.values()) - - def __len__(self): - return len(self._store) - - def lower_items(self): - """Like iteritems(), but with all lowercase keys.""" - return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items()) - - def __eq__(self, other): - if isinstance(other, Mapping): - other = CaseInsensitiveDict(other) - else: - return NotImplemented - # Compare insensitively - return dict(self.lower_items()) == dict(other.lower_items()) - - # Copy is required - def copy(self): - return CaseInsensitiveDict(self._store.values()) - - def __repr__(self): - return str(dict(self.items())) - - -class LookupDict(dict): - """Dictionary lookup object.""" - - def __init__(self, name=None): - self.name = name - super().__init__() - - def __repr__(self): - return f"" - - def __getitem__(self, key): - # We allow fall-through here, so values default to None - - return self.__dict__.get(key, None) - - def get(self, key, default=None): - return self.__dict__.get(key, default) diff --git a/Modules/requests/utils.py b/Modules/requests/utils.py deleted file mode 100644 index a367417..0000000 --- a/Modules/requests/utils.py +++ /dev/null @@ -1,1094 +0,0 @@ -""" -requests.utils -~~~~~~~~~~~~~~ - -This module provides utility functions that are used within Requests -that are also useful for external consumption. -""" - -import codecs -import contextlib -import io -import os -import re -import socket -import struct -import sys -import tempfile -import warnings -import zipfile -from collections import OrderedDict - -from urllib3.util import make_headers, parse_url - -from . import certs -from .__version__ import __version__ - -# to_native_string is unused here, but imported here for backwards compatibility -from ._internal_utils import ( # noqa: F401 - _HEADER_VALIDATORS_BYTE, - _HEADER_VALIDATORS_STR, - HEADER_VALIDATORS, - to_native_string, -) -from .compat import ( - Mapping, - basestring, - bytes, - getproxies, - getproxies_environment, - integer_types, -) -from .compat import parse_http_list as _parse_list_header -from .compat import ( - proxy_bypass, - proxy_bypass_environment, - quote, - str, - unquote, - urlparse, - urlunparse, -) -from .cookies import cookiejar_from_dict -from .exceptions import ( - FileModeWarning, - InvalidHeader, - InvalidURL, - UnrewindableBodyError, -) -from .structures import CaseInsensitiveDict - -NETRC_FILES = (".netrc", "_netrc") - -DEFAULT_CA_BUNDLE_PATH = certs.where() - -DEFAULT_PORTS = {"http": 80, "https": 443} - -# Ensure that ', ' is used to preserve previous delimiter behavior. -DEFAULT_ACCEPT_ENCODING = ", ".join( - re.split(r",\s*", make_headers(accept_encoding=True)["accept-encoding"]) -) - - -if sys.platform == "win32": - # provide a proxy_bypass version on Windows without DNS lookups - - def proxy_bypass_registry(host): - try: - import winreg - except ImportError: - return False - - try: - internetSettings = winreg.OpenKey( - winreg.HKEY_CURRENT_USER, - r"Software\Microsoft\Windows\CurrentVersion\Internet Settings", - ) - # ProxyEnable could be REG_SZ or REG_DWORD, normalizing it - proxyEnable = int(winreg.QueryValueEx(internetSettings, "ProxyEnable")[0]) - # ProxyOverride is almost always a string - proxyOverride = winreg.QueryValueEx(internetSettings, "ProxyOverride")[0] - except (OSError, ValueError): - return False - if not proxyEnable or not proxyOverride: - return False - - # make a check value list from the registry entry: replace the - # '' string by the localhost entry and the corresponding - # canonical entry. - proxyOverride = proxyOverride.split(";") - # now check if we match one of the registry values. - for test in proxyOverride: - if test == "": - if "." not in host: - return True - test = test.replace(".", r"\.") # mask dots - test = test.replace("*", r".*") # change glob sequence - test = test.replace("?", r".") # change glob char - if re.match(test, host, re.I): - return True - return False - - def proxy_bypass(host): # noqa - """Return True, if the host should be bypassed. - - Checks proxy settings gathered from the environment, if specified, - or the registry. - """ - if getproxies_environment(): - return proxy_bypass_environment(host) - else: - return proxy_bypass_registry(host) - - -def dict_to_sequence(d): - """Returns an internal sequence dictionary update.""" - - if hasattr(d, "items"): - d = d.items() - - return d - - -def super_len(o): - total_length = None - current_position = 0 - - if hasattr(o, "__len__"): - total_length = len(o) - - elif hasattr(o, "len"): - total_length = o.len - - elif hasattr(o, "fileno"): - try: - fileno = o.fileno() - except (io.UnsupportedOperation, AttributeError): - # AttributeError is a surprising exception, seeing as how we've just checked - # that `hasattr(o, 'fileno')`. It happens for objects obtained via - # `Tarfile.extractfile()`, per issue 5229. - pass - else: - total_length = os.fstat(fileno).st_size - - # Having used fstat to determine the file length, we need to - # confirm that this file was opened up in binary mode. - if "b" not in o.mode: - warnings.warn( - ( - "Requests has determined the content-length for this " - "request using the binary size of the file: however, the " - "file has been opened in text mode (i.e. without the 'b' " - "flag in the mode). This may lead to an incorrect " - "content-length. In Requests 3.0, support will be removed " - "for files in text mode." - ), - FileModeWarning, - ) - - if hasattr(o, "tell"): - try: - current_position = o.tell() - except OSError: - # This can happen in some weird situations, such as when the file - # is actually a special file descriptor like stdin. In this - # instance, we don't know what the length is, so set it to zero and - # let requests chunk it instead. - if total_length is not None: - current_position = total_length - else: - if hasattr(o, "seek") and total_length is None: - # StringIO and BytesIO have seek but no usable fileno - try: - # seek to end of file - o.seek(0, 2) - total_length = o.tell() - - # seek back to current position to support - # partially read file-like objects - o.seek(current_position or 0) - except OSError: - total_length = 0 - - if total_length is None: - total_length = 0 - - return max(0, total_length - current_position) - - -def get_netrc_auth(url, raise_errors=False): - """Returns the Requests tuple auth for a given url from netrc.""" - - netrc_file = os.environ.get("NETRC") - if netrc_file is not None: - netrc_locations = (netrc_file,) - else: - netrc_locations = (f"~/{f}" for f in NETRC_FILES) - - try: - from netrc import NetrcParseError, netrc - - netrc_path = None - - for f in netrc_locations: - try: - loc = os.path.expanduser(f) - except KeyError: - # os.path.expanduser can fail when $HOME is undefined and - # getpwuid fails. See https://bugs.python.org/issue20164 & - # https://github.com/psf/requests/issues/1846 - return - - if os.path.exists(loc): - netrc_path = loc - break - - # Abort early if there isn't one. - if netrc_path is None: - return - - ri = urlparse(url) - - # Strip port numbers from netloc. This weird `if...encode`` dance is - # used for Python 3.2, which doesn't support unicode literals. - splitstr = b":" - if isinstance(url, str): - splitstr = splitstr.decode("ascii") - host = ri.netloc.split(splitstr)[0] - - try: - _netrc = netrc(netrc_path).authenticators(host) - if _netrc: - # Return with login / password - login_i = 0 if _netrc[0] else 1 - return (_netrc[login_i], _netrc[2]) - except (NetrcParseError, OSError): - # If there was a parsing error or a permissions issue reading the file, - # we'll just skip netrc auth unless explicitly asked to raise errors. - if raise_errors: - raise - - # App Engine hackiness. - except (ImportError, AttributeError): - pass - - -def guess_filename(obj): - """Tries to guess the filename of the given object.""" - name = getattr(obj, "name", None) - if name and isinstance(name, basestring) and name[0] != "<" and name[-1] != ">": - return os.path.basename(name) - - -def extract_zipped_paths(path): - """Replace nonexistent paths that look like they refer to a member of a zip - archive with the location of an extracted copy of the target, or else - just return the provided path unchanged. - """ - if os.path.exists(path): - # this is already a valid path, no need to do anything further - return path - - # find the first valid part of the provided path and treat that as a zip archive - # assume the rest of the path is the name of a member in the archive - archive, member = os.path.split(path) - while archive and not os.path.exists(archive): - archive, prefix = os.path.split(archive) - if not prefix: - # If we don't check for an empty prefix after the split (in other words, archive remains unchanged after the split), - # we _can_ end up in an infinite loop on a rare corner case affecting a small number of users - break - member = "/".join([prefix, member]) - - if not zipfile.is_zipfile(archive): - return path - - zip_file = zipfile.ZipFile(archive) - if member not in zip_file.namelist(): - return path - - # we have a valid zip archive and a valid member of that archive - tmp = tempfile.gettempdir() - extracted_path = os.path.join(tmp, member.split("/")[-1]) - if not os.path.exists(extracted_path): - # use read + write to avoid the creating nested folders, we only want the file, avoids mkdir racing condition - with atomic_open(extracted_path) as file_handler: - file_handler.write(zip_file.read(member)) - return extracted_path - - -@contextlib.contextmanager -def atomic_open(filename): - """Write a file to the disk in an atomic fashion""" - tmp_descriptor, tmp_name = tempfile.mkstemp(dir=os.path.dirname(filename)) - try: - with os.fdopen(tmp_descriptor, "wb") as tmp_handler: - yield tmp_handler - os.replace(tmp_name, filename) - except BaseException: - os.remove(tmp_name) - raise - - -def from_key_val_list(value): - """Take an object and test to see if it can be represented as a - dictionary. Unless it can not be represented as such, return an - OrderedDict, e.g., - - :: - - >>> from_key_val_list([('key', 'val')]) - OrderedDict([('key', 'val')]) - >>> from_key_val_list('string') - Traceback (most recent call last): - ... - ValueError: cannot encode objects that are not 2-tuples - >>> from_key_val_list({'key': 'val'}) - OrderedDict([('key', 'val')]) - - :rtype: OrderedDict - """ - if value is None: - return None - - if isinstance(value, (str, bytes, bool, int)): - raise ValueError("cannot encode objects that are not 2-tuples") - - return OrderedDict(value) - - -def to_key_val_list(value): - """Take an object and test to see if it can be represented as a - dictionary. If it can be, return a list of tuples, e.g., - - :: - - >>> to_key_val_list([('key', 'val')]) - [('key', 'val')] - >>> to_key_val_list({'key': 'val'}) - [('key', 'val')] - >>> to_key_val_list('string') - Traceback (most recent call last): - ... - ValueError: cannot encode objects that are not 2-tuples - - :rtype: list - """ - if value is None: - return None - - if isinstance(value, (str, bytes, bool, int)): - raise ValueError("cannot encode objects that are not 2-tuples") - - if isinstance(value, Mapping): - value = value.items() - - return list(value) - - -# From mitsuhiko/werkzeug (used with permission). -def parse_list_header(value): - """Parse lists as described by RFC 2068 Section 2. - - In particular, parse comma-separated lists where the elements of - the list may include quoted-strings. A quoted-string could - contain a comma. A non-quoted string could have quotes in the - middle. Quotes are removed automatically after parsing. - - It basically works like :func:`parse_set_header` just that items - may appear multiple times and case sensitivity is preserved. - - The return value is a standard :class:`list`: - - >>> parse_list_header('token, "quoted value"') - ['token', 'quoted value'] - - To create a header from the :class:`list` again, use the - :func:`dump_header` function. - - :param value: a string with a list header. - :return: :class:`list` - :rtype: list - """ - result = [] - for item in _parse_list_header(value): - if item[:1] == item[-1:] == '"': - item = unquote_header_value(item[1:-1]) - result.append(item) - return result - - -# From mitsuhiko/werkzeug (used with permission). -def parse_dict_header(value): - """Parse lists of key, value pairs as described by RFC 2068 Section 2 and - convert them into a python dict: - - >>> d = parse_dict_header('foo="is a fish", bar="as well"') - >>> type(d) is dict - True - >>> sorted(d.items()) - [('bar', 'as well'), ('foo', 'is a fish')] - - If there is no value for a key it will be `None`: - - >>> parse_dict_header('key_without_value') - {'key_without_value': None} - - To create a header from the :class:`dict` again, use the - :func:`dump_header` function. - - :param value: a string with a dict header. - :return: :class:`dict` - :rtype: dict - """ - result = {} - for item in _parse_list_header(value): - if "=" not in item: - result[item] = None - continue - name, value = item.split("=", 1) - if value[:1] == value[-1:] == '"': - value = unquote_header_value(value[1:-1]) - result[name] = value - return result - - -# From mitsuhiko/werkzeug (used with permission). -def unquote_header_value(value, is_filename=False): - r"""Unquotes a header value. (Reversal of :func:`quote_header_value`). - This does not use the real unquoting but what browsers are actually - using for quoting. - - :param value: the header value to unquote. - :rtype: str - """ - if value and value[0] == value[-1] == '"': - # this is not the real unquoting, but fixing this so that the - # RFC is met will result in bugs with internet explorer and - # probably some other browsers as well. IE for example is - # uploading files with "C:\foo\bar.txt" as filename - value = value[1:-1] - - # if this is a filename and the starting characters look like - # a UNC path, then just return the value without quotes. Using the - # replace sequence below on a UNC path has the effect of turning - # the leading double slash into a single slash and then - # _fix_ie_filename() doesn't work correctly. See #458. - if not is_filename or value[:2] != "\\\\": - return value.replace("\\\\", "\\").replace('\\"', '"') - return value - - -def dict_from_cookiejar(cj): - """Returns a key/value dictionary from a CookieJar. - - :param cj: CookieJar object to extract cookies from. - :rtype: dict - """ - - cookie_dict = {} - - for cookie in cj: - cookie_dict[cookie.name] = cookie.value - - return cookie_dict - - -def add_dict_to_cookiejar(cj, cookie_dict): - """Returns a CookieJar from a key/value dictionary. - - :param cj: CookieJar to insert cookies into. - :param cookie_dict: Dict of key/values to insert into CookieJar. - :rtype: CookieJar - """ - - return cookiejar_from_dict(cookie_dict, cj) - - -def get_encodings_from_content(content): - """Returns encodings from given content string. - - :param content: bytestring to extract encodings from. - """ - warnings.warn( - ( - "In requests 3.0, get_encodings_from_content will be removed. For " - "more information, please see the discussion on issue #2266. (This" - " warning should only appear once.)" - ), - DeprecationWarning, - ) - - charset_re = re.compile(r']', flags=re.I) - pragma_re = re.compile(r']', flags=re.I) - xml_re = re.compile(r'^<\?xml.*?encoding=["\']*(.+?)["\'>]') - - return ( - charset_re.findall(content) - + pragma_re.findall(content) - + xml_re.findall(content) - ) - - -def _parse_content_type_header(header): - """Returns content type and parameters from given header - - :param header: string - :return: tuple containing content type and dictionary of - parameters - """ - - tokens = header.split(";") - content_type, params = tokens[0].strip(), tokens[1:] - params_dict = {} - items_to_strip = "\"' " - - for param in params: - param = param.strip() - if param: - key, value = param, True - index_of_equals = param.find("=") - if index_of_equals != -1: - key = param[:index_of_equals].strip(items_to_strip) - value = param[index_of_equals + 1 :].strip(items_to_strip) - params_dict[key.lower()] = value - return content_type, params_dict - - -def get_encoding_from_headers(headers): - """Returns encodings from given HTTP Header Dict. - - :param headers: dictionary to extract encoding from. - :rtype: str - """ - - content_type = headers.get("content-type") - - if not content_type: - return None - - content_type, params = _parse_content_type_header(content_type) - - if "charset" in params: - return params["charset"].strip("'\"") - - if "text" in content_type: - return "ISO-8859-1" - - if "application/json" in content_type: - # Assume UTF-8 based on RFC 4627: https://www.ietf.org/rfc/rfc4627.txt since the charset was unset - return "utf-8" - - -def stream_decode_response_unicode(iterator, r): - """Stream decodes an iterator.""" - - if r.encoding is None: - yield from iterator - return - - decoder = codecs.getincrementaldecoder(r.encoding)(errors="replace") - for chunk in iterator: - rv = decoder.decode(chunk) - if rv: - yield rv - rv = decoder.decode(b"", final=True) - if rv: - yield rv - - -def iter_slices(string, slice_length): - """Iterate over slices of a string.""" - pos = 0 - if slice_length is None or slice_length <= 0: - slice_length = len(string) - while pos < len(string): - yield string[pos : pos + slice_length] - pos += slice_length - - -def get_unicode_from_response(r): - """Returns the requested content back in unicode. - - :param r: Response object to get unicode content from. - - Tried: - - 1. charset from content-type - 2. fall back and replace all unicode characters - - :rtype: str - """ - warnings.warn( - ( - "In requests 3.0, get_unicode_from_response will be removed. For " - "more information, please see the discussion on issue #2266. (This" - " warning should only appear once.)" - ), - DeprecationWarning, - ) - - tried_encodings = [] - - # Try charset from content-type - encoding = get_encoding_from_headers(r.headers) - - if encoding: - try: - return str(r.content, encoding) - except UnicodeError: - tried_encodings.append(encoding) - - # Fall back: - try: - return str(r.content, encoding, errors="replace") - except TypeError: - return r.content - - -# The unreserved URI characters (RFC 3986) -UNRESERVED_SET = frozenset( - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789-._~" -) - - -def unquote_unreserved(uri): - """Un-escape any percent-escape sequences in a URI that are unreserved - characters. This leaves all reserved, illegal and non-ASCII bytes encoded. - - :rtype: str - """ - parts = uri.split("%") - for i in range(1, len(parts)): - h = parts[i][0:2] - if len(h) == 2 and h.isalnum(): - try: - c = chr(int(h, 16)) - except ValueError: - raise InvalidURL(f"Invalid percent-escape sequence: '{h}'") - - if c in UNRESERVED_SET: - parts[i] = c + parts[i][2:] - else: - parts[i] = f"%{parts[i]}" - else: - parts[i] = f"%{parts[i]}" - return "".join(parts) - - -def requote_uri(uri): - """Re-quote the given URI. - - This function passes the given URI through an unquote/quote cycle to - ensure that it is fully and consistently quoted. - - :rtype: str - """ - safe_with_percent = "!#$%&'()*+,/:;=?@[]~" - safe_without_percent = "!#$&'()*+,/:;=?@[]~" - try: - # Unquote only the unreserved characters - # Then quote only illegal characters (do not quote reserved, - # unreserved, or '%') - return quote(unquote_unreserved(uri), safe=safe_with_percent) - except InvalidURL: - # We couldn't unquote the given URI, so let's try quoting it, but - # there may be unquoted '%'s in the URI. We need to make sure they're - # properly quoted so they do not cause issues elsewhere. - return quote(uri, safe=safe_without_percent) - - -def address_in_network(ip, net): - """This function allows you to check if an IP belongs to a network subnet - - Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24 - returns False if ip = 192.168.1.1 and net = 192.168.100.0/24 - - :rtype: bool - """ - ipaddr = struct.unpack("=L", socket.inet_aton(ip))[0] - netaddr, bits = net.split("/") - netmask = struct.unpack("=L", socket.inet_aton(dotted_netmask(int(bits))))[0] - network = struct.unpack("=L", socket.inet_aton(netaddr))[0] & netmask - return (ipaddr & netmask) == (network & netmask) - - -def dotted_netmask(mask): - """Converts mask from /xx format to xxx.xxx.xxx.xxx - - Example: if mask is 24 function returns 255.255.255.0 - - :rtype: str - """ - bits = 0xFFFFFFFF ^ (1 << 32 - mask) - 1 - return socket.inet_ntoa(struct.pack(">I", bits)) - - -def is_ipv4_address(string_ip): - """ - :rtype: bool - """ - try: - socket.inet_aton(string_ip) - except OSError: - return False - return True - - -def is_valid_cidr(string_network): - """ - Very simple check of the cidr format in no_proxy variable. - - :rtype: bool - """ - if string_network.count("/") == 1: - try: - mask = int(string_network.split("/")[1]) - except ValueError: - return False - - if mask < 1 or mask > 32: - return False - - try: - socket.inet_aton(string_network.split("/")[0]) - except OSError: - return False - else: - return False - return True - - -@contextlib.contextmanager -def set_environ(env_name, value): - """Set the environment variable 'env_name' to 'value' - - Save previous value, yield, and then restore the previous value stored in - the environment variable 'env_name'. - - If 'value' is None, do nothing""" - value_changed = value is not None - if value_changed: - old_value = os.environ.get(env_name) - os.environ[env_name] = value - try: - yield - finally: - if value_changed: - if old_value is None: - del os.environ[env_name] - else: - os.environ[env_name] = old_value - - -def should_bypass_proxies(url, no_proxy): - """ - Returns whether we should bypass proxies or not. - - :rtype: bool - """ - # Prioritize lowercase environment variables over uppercase - # to keep a consistent behaviour with other http projects (curl, wget). - def get_proxy(key): - return os.environ.get(key) or os.environ.get(key.upper()) - - # First check whether no_proxy is defined. If it is, check that the URL - # we're getting isn't in the no_proxy list. - no_proxy_arg = no_proxy - if no_proxy is None: - no_proxy = get_proxy("no_proxy") - parsed = urlparse(url) - - if parsed.hostname is None: - # URLs don't always have hostnames, e.g. file:/// urls. - return True - - if no_proxy: - # We need to check whether we match here. We need to see if we match - # the end of the hostname, both with and without the port. - no_proxy = (host for host in no_proxy.replace(" ", "").split(",") if host) - - if is_ipv4_address(parsed.hostname): - for proxy_ip in no_proxy: - if is_valid_cidr(proxy_ip): - if address_in_network(parsed.hostname, proxy_ip): - return True - elif parsed.hostname == proxy_ip: - # If no_proxy ip was defined in plain IP notation instead of cidr notation & - # matches the IP of the index - return True - else: - host_with_port = parsed.hostname - if parsed.port: - host_with_port += f":{parsed.port}" - - for host in no_proxy: - if parsed.hostname.endswith(host) or host_with_port.endswith(host): - # The URL does match something in no_proxy, so we don't want - # to apply the proxies on this URL. - return True - - with set_environ("no_proxy", no_proxy_arg): - # parsed.hostname can be `None` in cases such as a file URI. - try: - bypass = proxy_bypass(parsed.hostname) - except (TypeError, socket.gaierror): - bypass = False - - if bypass: - return True - - return False - - -def get_environ_proxies(url, no_proxy=None): - """ - Return a dict of environment proxies. - - :rtype: dict - """ - if should_bypass_proxies(url, no_proxy=no_proxy): - return {} - else: - return getproxies() - - -def select_proxy(url, proxies): - """Select a proxy for the url, if applicable. - - :param url: The url being for the request - :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs - """ - proxies = proxies or {} - urlparts = urlparse(url) - if urlparts.hostname is None: - return proxies.get(urlparts.scheme, proxies.get("all")) - - proxy_keys = [ - urlparts.scheme + "://" + urlparts.hostname, - urlparts.scheme, - "all://" + urlparts.hostname, - "all", - ] - proxy = None - for proxy_key in proxy_keys: - if proxy_key in proxies: - proxy = proxies[proxy_key] - break - - return proxy - - -def resolve_proxies(request, proxies, trust_env=True): - """This method takes proxy information from a request and configuration - input to resolve a mapping of target proxies. This will consider settings - such a NO_PROXY to strip proxy configurations. - - :param request: Request or PreparedRequest - :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs - :param trust_env: Boolean declaring whether to trust environment configs - - :rtype: dict - """ - proxies = proxies if proxies is not None else {} - url = request.url - scheme = urlparse(url).scheme - no_proxy = proxies.get("no_proxy") - new_proxies = proxies.copy() - - if trust_env and not should_bypass_proxies(url, no_proxy=no_proxy): - environ_proxies = get_environ_proxies(url, no_proxy=no_proxy) - - proxy = environ_proxies.get(scheme, environ_proxies.get("all")) - - if proxy: - new_proxies.setdefault(scheme, proxy) - return new_proxies - - -def default_user_agent(name="python-requests"): - """ - Return a string representing the default user agent. - - :rtype: str - """ - return f"{name}/{__version__}" - - -def default_headers(): - """ - :rtype: requests.structures.CaseInsensitiveDict - """ - return CaseInsensitiveDict( - { - "User-Agent": default_user_agent(), - "Accept-Encoding": DEFAULT_ACCEPT_ENCODING, - "Accept": "*/*", - "Connection": "keep-alive", - } - ) - - -def parse_header_links(value): - """Return a list of parsed link headers proxies. - - i.e. Link: ; rel=front; type="image/jpeg",; rel=back;type="image/jpeg" - - :rtype: list - """ - - links = [] - - replace_chars = " '\"" - - value = value.strip(replace_chars) - if not value: - return links - - for val in re.split(", *<", value): - try: - url, params = val.split(";", 1) - except ValueError: - url, params = val, "" - - link = {"url": url.strip("<> '\"")} - - for param in params.split(";"): - try: - key, value = param.split("=") - except ValueError: - break - - link[key.strip(replace_chars)] = value.strip(replace_chars) - - links.append(link) - - return links - - -# Null bytes; no need to recreate these on each call to guess_json_utf -_null = "\x00".encode("ascii") # encoding to ASCII for Python 3 -_null2 = _null * 2 -_null3 = _null * 3 - - -def guess_json_utf(data): - """ - :rtype: str - """ - # JSON always starts with two ASCII characters, so detection is as - # easy as counting the nulls and from their location and count - # determine the encoding. Also detect a BOM, if present. - sample = data[:4] - if sample in (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE): - return "utf-32" # BOM included - if sample[:3] == codecs.BOM_UTF8: - return "utf-8-sig" # BOM included, MS style (discouraged) - if sample[:2] in (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE): - return "utf-16" # BOM included - nullcount = sample.count(_null) - if nullcount == 0: - return "utf-8" - if nullcount == 2: - if sample[::2] == _null2: # 1st and 3rd are null - return "utf-16-be" - if sample[1::2] == _null2: # 2nd and 4th are null - return "utf-16-le" - # Did not detect 2 valid UTF-16 ascii-range characters - if nullcount == 3: - if sample[:3] == _null3: - return "utf-32-be" - if sample[1:] == _null3: - return "utf-32-le" - # Did not detect a valid UTF-32 ascii-range character - return None - - -def prepend_scheme_if_needed(url, new_scheme): - """Given a URL that may or may not have a scheme, prepend the given scheme. - Does not replace a present scheme with the one provided as an argument. - - :rtype: str - """ - parsed = parse_url(url) - scheme, auth, host, port, path, query, fragment = parsed - - # A defect in urlparse determines that there isn't a netloc present in some - # urls. We previously assumed parsing was overly cautious, and swapped the - # netloc and path. Due to a lack of tests on the original defect, this is - # maintained with parse_url for backwards compatibility. - netloc = parsed.netloc - if not netloc: - netloc, path = path, netloc - - if auth: - # parse_url doesn't provide the netloc with auth - # so we'll add it ourselves. - netloc = "@".join([auth, netloc]) - if scheme is None: - scheme = new_scheme - if path is None: - path = "" - - return urlunparse((scheme, netloc, path, "", query, fragment)) - - -def get_auth_from_url(url): - """Given a url with authentication components, extract them into a tuple of - username,password. - - :rtype: (str,str) - """ - parsed = urlparse(url) - - try: - auth = (unquote(parsed.username), unquote(parsed.password)) - except (AttributeError, TypeError): - auth = ("", "") - - return auth - - -def check_header_validity(header): - """Verifies that header parts don't contain leading whitespace - reserved characters, or return characters. - - :param header: tuple, in the format (name, value). - """ - name, value = header - _validate_header_part(header, name, 0) - _validate_header_part(header, value, 1) - - -def _validate_header_part(header, header_part, header_validator_index): - if isinstance(header_part, str): - validator = _HEADER_VALIDATORS_STR[header_validator_index] - elif isinstance(header_part, bytes): - validator = _HEADER_VALIDATORS_BYTE[header_validator_index] - else: - raise InvalidHeader( - f"Header part ({header_part!r}) from {header} " - f"must be of type str or bytes, not {type(header_part)}" - ) - - if not validator.match(header_part): - header_kind = "name" if header_validator_index == 0 else "value" - raise InvalidHeader( - f"Invalid leading whitespace, reserved character(s), or return" - f"character(s) in header {header_kind}: {header_part!r}" - ) - - -def urldefragauth(url): - """ - Given a url remove the fragment and the authentication part. - - :rtype: str - """ - scheme, netloc, path, params, query, fragment = urlparse(url) - - # see func:`prepend_scheme_if_needed` - if not netloc: - netloc, path = path, netloc - - netloc = netloc.rsplit("@", 1)[-1] - - return urlunparse((scheme, netloc, path, params, query, "")) - - -def rewind_body(prepared_request): - """Move file pointer back to its recorded starting position - so it can be read again on redirect. - """ - body_seek = getattr(prepared_request.body, "seek", None) - if body_seek is not None and isinstance( - prepared_request._body_position, integer_types - ): - try: - body_seek(prepared_request._body_position) - except OSError: - raise UnrewindableBodyError( - "An error occurred when rewinding request body for redirect." - ) - else: - raise UnrewindableBodyError("Unable to rewind request body for redirect.") diff --git a/Modules/urllib3/__init__.py b/Modules/urllib3/__init__.py deleted file mode 100644 index 46c8976..0000000 --- a/Modules/urllib3/__init__.py +++ /dev/null @@ -1,149 +0,0 @@ -""" -Python HTTP library with thread-safe connection pooling, file post support, user friendly, and more -""" - -from __future__ import annotations - -# Set default logging handler to avoid "No handler found" warnings. -import logging -import typing -import warnings -from logging import NullHandler - -from . import exceptions -from ._base_connection import _TYPE_BODY -from ._collections import HTTPHeaderDict -from ._version import __version__ -from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, connection_from_url -from .filepost import _TYPE_FIELDS, encode_multipart_formdata -from .poolmanager import PoolManager, ProxyManager, proxy_from_url -from .response import BaseHTTPResponse, HTTPResponse -from .util.request import make_headers -from .util.retry import Retry -from .util.timeout import Timeout - -# Ensure that Python is compiled with OpenSSL 1.1.1+ -# If the 'ssl' module isn't available at all that's -# fine, we only care if the module is available. -try: - import ssl -except ImportError: - pass -else: - if not ssl.OPENSSL_VERSION.startswith("OpenSSL "): # Defensive: - warnings.warn( - "urllib3 v2 only supports OpenSSL 1.1.1+, currently " - f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. " - "See: https://github.com/urllib3/urllib3/issues/3020", - exceptions.NotOpenSSLWarning, - ) - elif ssl.OPENSSL_VERSION_INFO < (1, 1, 1): # Defensive: - raise ImportError( - "urllib3 v2 only supports OpenSSL 1.1.1+, currently " - f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. " - "See: https://github.com/urllib3/urllib3/issues/2168" - ) - -__author__ = "Andrey Petrov (andrey.petrov@shazow.net)" -__license__ = "MIT" -__version__ = __version__ - -__all__ = ( - "HTTPConnectionPool", - "HTTPHeaderDict", - "HTTPSConnectionPool", - "PoolManager", - "ProxyManager", - "HTTPResponse", - "Retry", - "Timeout", - "add_stderr_logger", - "connection_from_url", - "disable_warnings", - "encode_multipart_formdata", - "make_headers", - "proxy_from_url", - "request", - "BaseHTTPResponse", -) - -logging.getLogger(__name__).addHandler(NullHandler()) - - -def add_stderr_logger( - level: int = logging.DEBUG, -) -> logging.StreamHandler[typing.TextIO]: - """ - Helper for quickly adding a StreamHandler to the logger. Useful for - debugging. - - Returns the handler after adding it. - """ - # This method needs to be in this __init__.py to get the __name__ correct - # even if urllib3 is vendored within another package. - logger = logging.getLogger(__name__) - handler = logging.StreamHandler() - handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s")) - logger.addHandler(handler) - logger.setLevel(level) - logger.debug("Added a stderr logging handler to logger: %s", __name__) - return handler - - -# ... Clean up. -del NullHandler - - -# All warning filters *must* be appended unless you're really certain that they -# shouldn't be: otherwise, it's very hard for users to use most Python -# mechanisms to silence them. -# SecurityWarning's always go off by default. -warnings.simplefilter("always", exceptions.SecurityWarning, append=True) -# InsecurePlatformWarning's don't vary between requests, so we keep it default. -warnings.simplefilter("default", exceptions.InsecurePlatformWarning, append=True) - - -def disable_warnings(category: type[Warning] = exceptions.HTTPWarning) -> None: - """ - Helper for quickly disabling all urllib3 warnings. - """ - warnings.simplefilter("ignore", category) - - -_DEFAULT_POOL = PoolManager() - - -def request( - method: str, - url: str, - *, - body: _TYPE_BODY | None = None, - fields: _TYPE_FIELDS | None = None, - headers: typing.Mapping[str, str] | None = None, - preload_content: bool | None = True, - decode_content: bool | None = True, - redirect: bool | None = True, - retries: Retry | bool | int | None = None, - timeout: Timeout | float | int | None = 3, - json: typing.Any | None = None, -) -> BaseHTTPResponse: - """ - A convenience, top-level request method. It uses a module-global ``PoolManager`` instance. - Therefore, its side effects could be shared across dependencies relying on it. - To avoid side effects create a new ``PoolManager`` instance and use it instead. - The method does not accept low-level ``**urlopen_kw`` keyword arguments. - """ - - return _DEFAULT_POOL.request( - method, - url, - body=body, - fields=fields, - headers=headers, - preload_content=preload_content, - decode_content=decode_content, - redirect=redirect, - retries=retries, - timeout=timeout, - json=json, - ) diff --git a/Modules/urllib3/__pycache__/__init__.cpython-311.pyc b/Modules/urllib3/__pycache__/__init__.cpython-311.pyc deleted file mode 100644 index 181279c9852f3100290ed93f8bcfdefb9140d8d3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5338 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 diff --git a/Modules/urllib3/__pycache__/_base_connection.cpython-311.pyc b/Modules/urllib3/__pycache__/_base_connection.cpython-311.pyc deleted file mode 100644 index 1574d596dd27ce15e256dad7a7c29072c8f0ce3b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7123 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 diff --git a/Modules/urllib3/__pycache__/_collections.cpython-311.pyc b/Modules/urllib3/__pycache__/_collections.cpython-311.pyc deleted file mode 100644 index 2bbe86952cb9c8284acc3aa90d3f40313bb3435a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 26027 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 L_0wZxX9t*M{ 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 diff --git a/Modules/urllib3/__pycache__/connection.cpython-311.pyc b/Modules/urllib3/__pycache__/connection.cpython-311.pyc deleted file mode 100644 index 2b257e5b4392fae028b01683c05a59d4a5cf2357..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 33075 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 diff --git a/Modules/urllib3/__pycache__/connectionpool.cpython-311.pyc b/Modules/urllib3/__pycache__/connectionpool.cpython-311.pyc deleted file mode 100644 index 4b690fbf16b123036fd689343396c4571e7a258f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 41191 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 z%0A*L>18T=$p8S0Uj*x@4y;9eP_t59xlYfG>@T=kJ+D%p&HI1-!aTqWnG|g%#nx(A zj#$W)gJO6<7chxkDHtD-M#1-dol5uTJZ#`Ym6K*w|bn!+*Cb!m z@3!_7TOaxGcZz$?7Fy30ThEcw-rdAQIvR%{zvahDofm!IS+^rLK4g)J@K7Lo={ygC74Rw>w2 zYHlyJ_0lgqTI$_i8alAnAo<%rMgJgwIBSOUIg~epy(Be)!h-G~vE}i*0W_)GYjr$Q zu;KcZw+4$HTW$xo!iw5;GZrz~N)?aKLrQNhm*I!zbYQ3xl*>&@q zw*%pPAbhuFGbCU)`}4i0KlZ^9KQt6+N5Da+LJ9`)*)VBQu2s9djiuJkJFP>vTZam* zkz#9P`S|kj&+i7i-nx(vY({i1eWN+3#~okqZC~%|p?Z4#;EnQtCDs54cAiDl5@$m$jPXocpVNsWI@XWRw;RNU$I0NCVekS;KFztF1ZA zImMS?LRBwbGEkH;!fSMmHoak#LG1QR8|Dl)WBN+mw0u(v_0tV$am)IT7H1`ewd0J#|>KQE&k z`uqAT-V&donu|41tbIPL`5CebLAop(3K*>s4$vt5=STvh6r!2HYX@IFc(cDy*Hf%x zHS;!z8dr8>gbt3}n*IBeZ%^hueaqD=j+NavL#vKbLuDh}=Y zXmercP;uzc?cPKA-a{zD^7y@A%T3o!IUnf1<@%uR!>K=e?qk=Fy!oM%w*x2ho|8OV z2s;qOYdJ{Uo`Jg=ErHz>=obSs0-nU192xz&U#IO{;{8b;!nZNoGxs}8@sVKzNtYbe z>4*rnCCyrNX{CBJCh$JTXWxcfApxzN1;Jd<6qzqI()h;z<3HjD8v~WOL zDE9}|_8w%>p<}7-r8ZM^n5)fHWRd zo?L+UcXY^}rIr;(Y65jSXqFBouSRd;9eT6r6)F3K`7V3d;-YjR zcCT*JpR9L#8W5(nEj2?3%A*=W(8|%>0(`0wYPXH6+pVeS{>s$weIv$gQ?5yE#>^w6 zWZkvFoZipMaTmeyIZ{(VFIV(&~3G2Lgq%T4z3+MkxXQO^U` z__`ls&N4P~-S*O}@BOv*tg$xzSL)dfA=huzvmwk~^uYT@FFa`OetEy zGl;%p75l)1E&&mEED~n@e_b;nB{p6fk|W(Dij@sd3g}>dCm{EOX(5PcSpo$HBgqD0 zV3rG`K;cZ9gr`GzpMuIharuQv3wnf!gi$&whZ?&A2|yO6Tp-mn-k9b&jUZ5dY&!?i z=wvztrG5xJAg+MT25dW1Ni;~=&{hFfdw>ZOSbKt~T4*U)lhH-#+8ze2(AEtM8)rXb zrKDiMh=hey5(w8=DuYcFFqVQ%tEh2&&YI&)g&gL9*cXQnjm-_Zff!=eew9zD?R04% z=N~7fjtp#1$`JQu(vY7J-3@(9Yij4gH0QpeZ6(m-htVjK?!#Ei`FJ9pwMua{nci=; zKz^$QB9l#--)e#URtrRkDY2P|)nnb@jLuvuEN1PW_TK}Nz z1|1<*Qle#!w<~9=ERUM%6Ga zgnG_{HEMWMFQhJMoAR7Bx4$v!G*-lSU7a=iljv?%*&(GYGErbL$VfIObuA?t6=ql1 z`+MD1XQ0=>;0Y>ex=t8MnnI==9wtRah8cR=cBETV-=vL4$P+*T#sMj7f)A`rNx??S zI#B@IjVW8H*5U39t^h=J`UpV6wC_KJJgBZF|zX(IsZomn!;cpZ|^49VBaky2Q<1&okN?BTOhO z%4NC(CYcK5^cjWlNM=)@SP!+;8akY|rq|bXj8ND$6j%f6C0#!4T#$Jg7#rz0T&i51;3wc}SaYXiyzuizqdsNdGI9;op(-7v%hVatwW~I8Kj( zy%cP5Kn)A@in3nB*;@h+qYR;4xBVd8NUbpAMh&5s$>A!0Vfu@8T<+~`%y`ku4_vs% zh2)%gmqP9DCGu^C1DkVX1rMW2WLKgWBpXuikTXgSF{*?>y`OwJa+ctbr7N5`QN1uv zJGs?YD149{(gsxjkQ`IX@2B+m4mptXO6m{E`BQTKjGWu#kO)rb`jL21?INd_9FlOT zB;XS2fd7JgBp-yr9@$(-0v6-ElB*eU%0V0|nPqn-p(yjh^uQ{`|1LRyk3Oo=)|PTJ z?HtwzdX&t7lR~QcbBgJum>p0j6kElCnMDPL5uN43jnoc`(70`i8^{TLXlcMzhfIjy?wSZrg14cpu5s&l;HHJT@xF3-7PsvG>!^8ZqGAz`4 z_^ezDZE@(t(kVdYMqv3c@5A-g&U#{lFsP6w=clkRz zU3v}^J9DLm)H8m4-YK>8-pqXO8#lhO3=@Gv#cmiP>|is4rIwBxiREL$DB;6}K%^MJ zwp@qzSqB*)Osziq;fp^D{k$vR@=T%SnPST`%dk$^ny>3Eb#8&d1*m9rQS3dd<97xg zzCG~phqHx&{lx(oftsMr!$3$=CGS)YBTgM6=yNeyWm!E`Y z$r}e>KX_}~%0XRWrv-<{CV?a~{(jYWMg{I_MjlZoPwQnCV zbta)U*|Sw>POi1mYl)mTsi|kJU4L9Yz81#m5z8mPb5fXwf?^`dtU33fJ9x4b9)u}A z=ovx>$lrd~hhG!BP%(wBDO5~b)*8H|VmjareM%1dkWoi3zU~cwB|TH9qCyGtlThc~ z(B`|L@ZC@slw#NFsv8?LN2+(*2J@RA{pe|3JM~^mw@~**``&b}KK!BU z$NfLr_JffhjpUy?TReOY9oI@7*Gh`8t@X>t&?){9nc@7->FcMLPvfyEM8jYI;|@LH zK=V+KPCBFz)T=!H2$Zf+9jJ$fF+xl`ETzugmGRQRa6Z^~FMwV0F8?69x1srs`q%4k zW(&cAVsIcI96(ate?2K7u{AGpq0*6k&o!ypTmK2B`IE0cSqhGQ{Or$W^XHzy1SQp5 zI4CllYAF<6*?r?NO<$LWV=MpKO2P12AQ-A&3rg+bQg?)Y7?JIL+KB9?cgUxHt%pWr zuki>YHTAF#(><8)I&rJ*PUP6_$gx7?L@{y#0Hag~K-KT9F9lk!|L$u4ZA{I;;Jx;q zmFjz~oiKCLLH1WWb{0E!-szaQ-7!(CfIO!zJ_;R~TiF%-#%BBfA!skL_{K!4P9VbOH{ zW}&MKyQxKAUmn&|eNDo|>gw@=Z+p?VJ@4CYm_FNfYc{`Yyx==h^c~6jj+B~ujppp* z+1mn^H%pzpH(xCFj^63rb-Q=hho=g?hl{<33ms#{jZrZ9eLje&TY#{}XrXF|YF{ zUBky*&Y!y6@c-01fbgGguQ~;H^pI;}uk&ZS#vYy6<^1`G8(}}+@vX2qT|B*hdsQ5<|#!ba}{{=mA12IC!WoJr;!@h64{Y%5gW$2^FZ@@uC%uM+e zeHaOgZ7yH6P~02;*2to4_{@SbN%Sba_;=*oCC4oMzo*Cljhu}Ne~(^VCC4ayq**;l z0a0>h$cd4&hn#wHNFPN#PtGtoN67ixxGCJV#+nWBmv6ohIif zIpgG9&>bpKh79Unv;3`9?W8lT$eD9U^`UD=v7o@Hi(7Kj?gux_yXX#v zZ>hDd)Y4hnwWqXwXQ{idwEtjf+m5x?N8Jb4qz#-!M>xOYlyVKS{HL*K8r2ZkQKzM*bdbj59?Jo^&UF*zLxq%Zr zz`f+Ibpx{6owktsN!avU=kC_>K|{57m-+@NH{?7pTx#nsjqalSd;8aV=iQXym%E~C zsaI$5Z(L2n=lCoK&wmG{=k+J1e%ZNR+BsX=DPQ7gu1Vg#EX_G^qOl(*sy-}_;zX`m zoN&Ao_d0nGzuWaK-?VQT2E?cRQ1sYaZX#mJa$*KCzhj*sqnI0WjuiMI($Pg!73X_U zWQbgdh04ijTsd28OWHFe3gKPGw83#^Mw9AbA3Kgtf%Ziz3jq%2YrG?=4V@teCM0p` zXJ#k>56r~^A2$s%k1$D=4r2>>eD11+DXeX8hX8D&#PF%camFTf{+5p6)!6zn_Cae^ znF6P3X6CYTm5=cy`O?hHEGfzpSIzPWx;Udf#-bE~p0ujWijXL%U=bygNkoxn2HA-K zN}moMyMpRaO~L+Ul@K%+DS^OFW?J4qgUSK=X!aR<~l7*TGG2|@lE#0CYB?oC0?3_Utgw6{SJi4-*SOS^FcG}I( zCrMTeqURY#e%WCwV&VGDR^+lr?-TVAOro;a=oHOM9dbWN%+eg4!lG|O@L8L>?9sX= zQ?9f0Nx6w0lGvXKgPM9r-ET(V$kfESXGF*835vL}7p-y20c~XKqxXKND1!ZfOg)Ll z_4A-yXBjjmx*--R!V+ei1q@-A7;5-;eD;6B^LHF?z(~LKU{zYp32zXWsR(RW=pm@11@PoC zo`QHHJ{w=T20YaoPmOq@dhwNm33K!O6*>zvS!lJEoH}y+a3Zbh7%~xf<9_lnW^tK(j3Y9Z^i6tXq>%B!2WIu4TtpdOL@H&R z;mWqdam;Khp2Hhn*91a9xP>?}zyd}I>KX@f+(D;gsE0qtj-(xuxBb6&f2Zbp4Q*-k z1^L$miVFM)cHzPP#g4TmW2a(B!iG=Uy(l&=YP%QPaTdmPf2n;FZuR;NyD@P<2KJbS z`DN#3dTcA{_x?xdIb723y(9G8Rob+h?!9^bi4~EN;UEfa+pkxR0My3u8DXgQ{fa6E z0HL|!GKaA2(6oh}&=jspVdoxp;yE@p^akx$%kDe)U3z-(8^ad{suBLa@eUKg@l}qF z#!d!d`S9T*;NYH5#51sd6NWV*J|Nx-T(ONUy>Q{8&;b}bJvn(~Y-&W6Xgpp-iGVgU zs<{__LBh}goQ%{6zB|3+!(+6Qq}9VlyjSQIAN>UFLEV@-H8l)Saw#-Uug$DFW2uXq zDgd|`VmkAi6%{;ak_@4~WLlHYL~(liZw|blBD6wPnmt|nmCR}r9 z@?jbV#C&-G?~EsNE9uL$&1ZvfPRk582K7=^#W5~5ycS583}}4Ggv6H9n~;l7?+5t( z7C%u&d?7qw@zX5l3*ikGKlLJC2-omo-u4x;gd1y|T>U1sZj1hoRw!Vvp2Z19u?T`f z*0s@*F*+7xA~zK%tmSwGaf(djT;(Y;=d82WdW?*7_wHSbV`F@zf|dcHqCA(vWQCaM!w# zAh^JAdc<)(y+(i(^wtW1NsJ%cx=Q`Z0J8)Sp@$Df4p*&!7O}-ux&NKkM03Xn8=FS@ z>n}Uv$zK^DC^MKf&^zndJFsKyxMU!V!lJR&NNVLi2iXam!}!Ot`9Gipi#wi9333kP zkeGvFF);5%)a zX?P^1`G7?pdKji5_9tkreH)R1P112?^@K~_@$}sG^gxW_87O)N@}7Y;-lPuhk;B`G zDMuDazB74!a(NQc%3=U!MZDg6NV~3|T5~y@2R_dJ=qfg{H$yn7J7f=k=+l6Qgd=cB zvSW3e_?{Et0Ug=)Uy!HE5SA!N0rS|$u+~Lg!JwDJ81%A_F?@c@#DtgPF-5^X2FyMR zBie##Q-S*Pw*(+9+(wPvODLL3>!eBE>3n5Ee$@XD4i<<9G9~#_!ptg}lJ8I$L0BGB zFjy}Lk69&=h(;q0F-}lS=?Ot?{3nV^&QCC%Grxof!@&GotEwaZBRL&Xee<=WrO|`e zPUT$(#joHx2)WCHIF4Y|fqAxh3$fGSAKq4acpv@tJX(ruFKybqwsq9~@S606&UuHQ zSc7(_XUGkhXm`#!n%o#ce+5T?PHq5$XI@cKs zp###~^C7E&5fhlgkbA{eE;8F8YsNT$M;f4!Hba8fhmCr1fJ}iAS&bU3e;aYfu7RLu zl<63q&K$-$)hZ5CfhGpyPAQYmH)beJF^><+R#D5&Gp;{S*$38ggzUDGmMFEa zwiQm)0&XTuMq`aMG+l9==q}EwL1SZO0`E##brqZBj=UHnqpbV)n|tOC9z4kCZuo!& z>y5IG7+Q09h}JtScNfy>3khWe+j&NZB1We4v8sIu-BRAhH#`J&x1nv}Aw42fxxYMv zi6e+!;<-fJLP3ov0b$UEr{V>ARV~CwVS=Yj8UH>-+Di_7y3U|WlZopawCwyl2if$>t@DMZ zoyDe|*TzdV{*~6-HEsEtwz~l+`s4%q@Vf;&EBih?FCOxqeV+vAps~PS{BBLb`S7fG z$b0q*K*Oac@Gojai-QeiBcKczY@E@ebG%q!^j?*yJvD~Sz|wX~kQ_R_;4^|0pw(S9 z*Ty*0ubzQAi2OHB`9-9xZl_?OJ z2727+5%@7$#g%h>;IOmMOl}5xp=xnjkm^DeoTy~BDXv>FHzzOe(lHg}$zUR|Zx)FV z{3E1VtO{}%r?p;ye`G!HYy=|%z-24SR>@YQbsl&YwUqs#CDbaYD+C!td_rNumGFUbtzp(X!v~HEJ@FQb z)JjepIRx%mCtIk9chO@vIiy-Fw8+EcE0EI%rySsImX<HvK{XhviuW}!&m$`M&~NLGEB^F^X-)?U|=(XcY1I1-_>woqCg{uB^L0IF^Df*12A z$Tvb!ydnw=%Ck;>*-z$cqhrU9j6Hc`@))$=GXPQ)o7g`p(T!y<)Y~Tj86h8I+VQ&- z=zcl{v2)oij=d+?P_CImFFzAg)m`-I!xU6~{Yp}A-u}BM4d?B@lKl~HOVYNy z{kK--byR^X@n6&lNsfJaX|MISR#i_~{!MdwB*#!*+HC!mq=)kMUrE}NxBp7g6ZwsP zC8;}a|COYN^Y&j!I-Gy-uOvnC8~rvaL*HjtnRz!ggwR^zMIdkDz~2hXguHjL@{{in*W}+b-Cqw z4`O-yir&6!)oY#+2av$^&ZiXiEAxfyfY$qsiPgd4rd|1_-FYdvR(;a%fL7AR?#-TC zJ)iQsUs+>JcbuwnfK#%uoA226DZl!aHNuRm!?ABovOD{wD$loi*Qy*2aENs0Qzuk` p^-#~3#|SurYm(jBEFE`DIM$pl$64rWJ;1H^IIy}uz+p)A{{z?Db%g)` diff --git a/Modules/urllib3/__pycache__/exceptions.cpython-311.pyc b/Modules/urllib3/__pycache__/exceptions.cpython-311.pyc deleted file mode 100644 index 5a27bfc98a0b9c15a5a5b6912b06290434befb97..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 19213 zcmc&*Yit}xa-P|pC6{lCq$$yQjh-YeYAIQkY*DiOpeRbVM9HM&vw4@SmODdot$pxj zb|sM~UzEUznZ!w$OAhA6=R^q(J}b_{36S9OD+lC9fcyx?2L)jkIKV;R9|rP+0tMut zKgn0sGqdxeWG07XcBZzstEaoVx~jXny7q@HEsYYcZ+4CAclS!tzta!rsuKx$tvMk{ z?@OAb$$6 zdV%ZHdr`0d%|6EV1N)TT7kIOuaR-1K2=V+W#vKGM6~Y~0+#qm=Lbw6O9R}`c{a}ci z6l0G7`;49nP&3H5qre>t;SMqGS>T=vaqckVjsrKOcL(ZxnsFz9JE=b%z#U=S^T3@7 z;htgK3&6b?!X0JYOTfJx!X0DWFmR_sv^>kW5#Y|~s(vsqPR}uR6xg$&9v)}hIpAK= zyYz;@n@PsL3hem^>=0uw06P|{_XOiE0(VJ2sUHf|`#fV`19lwL`sa;PjGF-Na;Vl9 z7Iufl{4jBsc4SjcgqFcG&3{$X?n*gHl*6}+ru9uDZtWYQc zsWx2lS_k0!k}gfknuJ+d#*9pK#;Xlf$%tW;jD+@||X^p3PY0l*z=RbW@(J!}zsS8%P+$_zeceZ@OftI*qKU zW-~mPH*y%uqMA|X@KUO((3g=!qt*I?kjrY^EF0B2LoZj1VpSO{K>%&?h(rksy@cQL z+7uGsmEV_c$+x65VfZS0%6^2LPwae2x)XDgp2RKr0~igrVjoB!#y^6veqswOT7U^L zA>ECQEyRY@{Q}u-Ia|!$i^4ZWl|L?(@(l)=vpNUy<6z=cEictPcO6q+?GCX>wNFq%eSny16J|? zQ`lc8ctnHEj54-TY8!#=0C!^|y^qrMMl0o0T}C^BO$3O6Mn6Ec#pZEV&*wo^FY=hu z7X_!uj4}x9B*fPMz*^_Cq8zuBVG0AU{kgg#MASv>A#%iucd)XeJC z!0ObZHTl%3wc0$cf3u>SWuZ~eMQD`EdJ_|4rmW6puInlUu9VGX%9t>(jGs4CHD*`i znArrgNj_^F&ysjL7o}M|CXryZiv91@>Q?+Ch}esB8JgXUX1s$zIF3#psd1`8364 z#a>_nnnHTxYLzBU$4PUH!zkDvW4#f5>qCY|by#Q@HV5c-)aGd_OfqDv%^l^A_Ji3^ z6>H~FtL>TcySW7MW6vJlSBdmes#Kd_a`p3sJIa>d3%<4rIxoTE7%DL%W7DBF0XL5N{rIn

ONQZLJC9fR<^e&NCuzrv+ zqbpkcByd`ztKYR{vZ>m5$tc~N7hN0hcC9?Cdx%%dB^9e9l@*;#RU1YegQ(hCGIBGy zVkV#FWwkbsRudw_olbpgrYq5oa+h5hmZZQc>A_Hc#f3FC7F6e3G(ouPO>3plgLqA| zjpKN|UlHofk~)M8)|05Uv9rb^SFK;d3nob`)Y`AloA2!VEZKK2*=HsDR(9-JRPH6W zT6_zAsjG3v;AWqrwp|AGN3Jo|wshKKFk@}mMQ@Q=6jCOVBZI&RJmv%dXsmr!lw+21 zY_(2G?68#WxIa_2lXC4P_4&#`NF%l4lSX@#9-&B0r}b<}(}lpD@Csa}QZ5y+A;_vQ zhD#dkPIU@)x2D44hKXO+i{*ot=jUuCTSuEtfg*#z89X6v8nG1n7W7lW4btBNVJMff zj%j(y+XEApJlT;mYNe>(oWl+U)X!$-=JX==2|4YcA=c1A!`_>$(+LtTgTO0zLT2+> zOR;a!2`cF81gRA+d5xxf@036jLW2ZbxrL{KrgvH<6}FfYFtb{*1^-5_Y=}<$l;mr$K3LCWZA(=D5d3Vm!~Odw?+O07w{omQuG*(A+uoD!o8@ zi}?!k)8_3kmYP2Axb*3;)o}^;k6#zxfQ$8C__iWl%jTWY&yoZ8k^`1=3+-SVDB4D0 zQb*8UZFKI|t#9E+PPW7JI)N*Af|KoPESX5IN(8#4SL88yHC~@MxGHTFh@Ma@Sv>Cb zKh^X0vn8`UJew)b=$e>^U-0TVOc(uT&McE!klv{?df8Mn5ER}3sI+^|5Y%%sMRgW+ zrM`@Vs7Q^dx95k4O+2$e9dgBTjo;DQFpb(s8|)2m404aT$hkg3!n1w$V4M;XZN4Mq z{uXJM&osc!a-sJ!CNPZ*oDwGLK-WCl0O42Bf>?RaBNY~Y$`#A|9;Bj$zbD9jSN;q1 z4w(c({ySfme+0>Y3HM^X-^TEZ`^x4W(3Ivyd{|QYW#d)U(jP7LOydRMYolPCrJq5g zoE9I0z*~6CivS)wVnsP;Dd(W2XXH_cbt18IRoW;JVofb%@wk^gppUR2HeJpY^irif z0sokgFppOXz4v+DfTUBr-B=# zz1gN+DBjtK>BGwq^3_b~2cK>MGcz+3(n^tM4`SWJK<%t0}H7nu+7YL;~}~#2o-N^K&(( z(46Q4f|>Nf2ASC&?9IZNM>15f5?i-iUdMcv)pOTLPP9xJ6Pi&fs2Bp>xUL(~{kjYa z4FbQ6CnOw~EXBS>f2iOF`_mc0>V+4-dY7`cb%Z|ge(h16d7U~#;N7UsykaT#EjmL5 zeVvIT1DCvZ5-@0F+IvlQ&FTrQNo#mV@lV^6b!>Rn!|-gbc8uva?4HBDE;Qq;x7Rm> z(NCR%3o0{}&zZ9rtD=6xvqep*S4{ZX^YiM+@WrvQ@sTrECPq%fnM+(T>OrPw=e3P~ zl7BC2cLd4*b0@Aren2cMZ{n-Awm2J8&aGKewAu&ksI6hXxr@nfQJs4UbOQJsNv_pN z)BgLCcWw1Jk>s*%U!V}qtp79~v?Aeha(RbgggyBUvhsV$X6PkX0X)*>dD<9g`W%#v zoq#mg@O(8z3Royz$I1(LiEZ(#*Pl)uP936=L`5`iy};ryB%`Iiq=g%YIgJp2?6tgp zUC+bIowN@n%&J1EYR752EeMi*dLh^wbba-pwuQ|R3?%Zu1Efg~mD|!6$@ceJR%3F@ z(Jz{JtZd%0+K^~yye|PfAb?d5pjB$`dT-uJZeeD_F5t0SPvqc|WAP(A7U@=eMY)u# zNr#8RvWm1n-=LQX{01H~3*cL%$1P?2aV}-4u9Xbc9x_w~xF1K}J8uMXYj`mwP^;9S zd)d+;uaVe=ri6ytX^p$*Y^-*U;lK<>b)|fTj@E?k_j+}o3`~^{&mb>OF~zNJFZbEOzSpxozk~Wuy^F0%8#O13cz1fKNUTTgu_b zcy=RPzC!+}R(jma9+*cMj;$kwx$-=D4uqf$dj(A#{;5U<&Kek(|6AP3U07BZNvEz zTz$3v1V+Z$d%_2(a$P)%7I zq`KpL39A~Wt=BX8ioFpz=^Y4=21&sRSn~|tFiPMx`&csSOzt|!#laX>xw%St9g63O zMgo6@C&c|TmSW$cA5_rSk2o@Lturmx^R!$?r+)6VoUFP%yOc3ZyJydPdj_9CnrCJ> z1I%0@m(LjX;RkFqc-pXj)40^SR!u_Am|1}X)~vfB2a!Z8p4uroTmYDvKa9N{^O`AN zZAK2BoAZgh+Zvq=(Dr{*ZFXk5`A}U29b%(zBIQ_Ql=e)<3VsGHGDjk6d~;{wzeREL z2msH-hwjW;9fxoSr{B$=C3oFR?y{1*KHs8ZU*EEb4-YNKUuG$XCn8?oR1^r6# zTCsGaxbU=ByfQV(VYS9i9@BDVZmwjIPu=7XRXN?WPS+Fdhr>J@Ltera)m6)fQNb9M~n6 z@YC2TV2z_S0jqU6lY_HexG3Sqq!=HVjpUQ(p~;h@kK=s&9_WQFxs z>~}HWA|F!4Ow;kz+re^UFppY6dccscwv3L9jf|fgPLGU_UmUNtPFxxpK6l3X9gLUy z7S%xDAMpenCo9UBrHp;vmAZXl<%#ESkI_dklU|5sW(P1qW`c?FYTJYkr&6vwZ|{*7 z4p9Qk;ZtpF+~D3VkWpaT<-kRR*sxQLJR!4Z$WrWE5KaX*NO<=- zg!F-Q>>1b_?a)8yrN5A2gN7#!ICF3~kDiI+c-xRzXQllWBA>uN;|Z;_6rUq*K|U4S zAo-gxNnC`N8F2#+<^5jDE9|%QPIVMvfcQTnW6Vdh{2ij1z`sV(e8f`hThL4eH%jva zha-|x(4pBUEh1WxotA9sR80Hi6P5sW`E2k+lm4qjI)R^3;x>U!0+h8uA~!p7aVeiE zlkhsEp7XMoLNzc$sF%-A407lO$6Hnmwo8b3grusO>)5Wr$E4H2Gb~NJ!gWMukq9R6 zZ+Jo?Ghr$AEqX=;H`udH@M!2bs4Qk(WzDkh)!Q+MdZvt+(YZ49qL9(p*PScSdWk-W zSX5zk7IMNlUgB8Rj5r*Hheou4qufV%c7L6EOW+GUYeCO$oIJZeAbL$NY_QiI&MXgw z8J?{auj$&t2`3MZKV3tV8Ov8zU};(}892|SY)tu>=h1TncoN!NXYhWLx5A&~91XIOo2uX_13ql{`*FI4a8y$@GVp|QPy2cCBL<{x&h+&^ zYD9mVI!$1e668e^ETAkO3v9z#UfT^!U{Pt(>JctTQMhpQVx?}xBGY1!pK;-zxDQUZ z)VyAt!4ZX4(#>LT8Inq;7H+J>upQ=co=b_7_KC_A#|6-S+&PW+a?KwmewBB)v^9r7 zlvN!5R0J34)bi?8Soq~!CVy2FyI#V{P!_!6vrcSbW}x#^Zy|029spPjWuOXJI*6OL zT2$-pDynhRUrjos*ACONadg|ch-vukFwGwm%#ljA;R6?|6R8A;(C^?i<97jIIug5U z879?^O@}9R7gL`%P~No={|hC}E&w=w#0lX_U_&A7W|smKrP`U^y-4r@tS27V8)G;f zTd0%l9n_$ofWCb>1jm;V6GD6&Q1O$UCJw9mjqjpzqYuEOw(T%p#4a1~-6DuL+#!L8 zqqMmbZ=geMFRnDVzjvO%h1Ep-v<#nYydCb?ctax#Fd1ab#_v#L#7l!y+bHD?>?Qm6 zZlv)h4EFcw1u~?BUJyfBvKjm*esRcxv$aCxLM%bkAc58x?XCPEsU$$a~afc&!Pl*IMm3C(b>GX-*K@v~a-A6BC7_iEItqGX(}rn7yfL(n%T( zAfs9*^tPJdfqk5?lLLqX;P1FS@FqUOkJ|Y?PUKwyyd}S7cNHi2QksO3FIF4H{Y3$O z#3R03wdt>`DrLl7^Qc$b1;G%h0v3GOtwIF8k9Uj@0UX70Ga?jgYnX|yaF4(d1XSw- z$|KN74Ze&-O|@2(qn2_sa?jbkjz+Pn3ALh1eQIUP-6QGa_`OZlEcvk>sT8klDgI%=-ShkV&8&XD(EBER)=-mEbI935UqG~ z-tTBR%y}0wMf}^!;FXxoUfXrSZaYfzUfK4qkfY!s4&ID#IGd}mC_)tCk=Muv$>D6W zCST(cMog35hA;0nB9h;Z73;J(|HDQ3F#hxK?6EH|F;;CLA7h^Uk_)G}m+VHGg)s=v zz39t;V}xNh58Id>v1CpR4GzM7R4Hj9y|BywzIRJzyLA>+w=VpLh~ErUV$6UK#ymh& zSn<~I*tpZn9+D6{dSN7LR*9ULU)CEOVW03(ud??XVbUmv5FTMiwSWdDbXZW@hc({~WZz4p#LHX!Pck zmMDY3V3f9!16ACjGgQ#m8R!9B>u78AVQ7b#XUKPq6-)TH#%#AJ0x%KPg#Bw;Oh9Sa zp;T%>#dbi&i4VMA@O5DShxj3i)z6n^Qa9{>?2+dRu2$?Zs`VQG!P0!#i6Dyd*M0xG z{Do>urAYPaTAE^F9(IW3;})61Vb!<0$o-@=9(nB>NC?%RgYxsCYV3m;)I7dn2Y%!q z-}>WY)q2NgylDV#VL>nl@eHY~a?U?@_=M+E5ae;PlHmaR*%yzxHOzNc6OYm8pTJ9y zduU?!cI%1$I}KLH1>8R(fO~zXt5@sl45sHVh#n^DFDdmH{rfX2L*PiH{=H!-Z_s)O z{o4Q#B1^Sq@wnIH_3w!*MMJ-lD{AB(p&hM|(c@0|2AmY73LVj5(*&1<@V~N45$BQQ zJmkGORiI`NtA-783*C+~){16AksYV~YP4TTNW9;2+M_%vHvvo(FCyp6=j#@zgHV&IkhTHK}leNaO^m6Q?490p6bi2R*IzKsX@Cy6sbu*~Cql9*znk_nmo0U0z;J(OCW57pi-!wVM%OK)20G137d9EmSxRmV2zdL-z^spoUdt`3SKq z2!uEvAwJuvWUCCbEew`-SpAq9fOt^D?v~}V%<3q(JW0$r%dB?s5Mopx2FpDpn5f%D Yb$RA*)Z@hGuzBDYnf18%9DIZ2$lO diff --git a/Modules/urllib3/__pycache__/fields.cpython-311.pyc b/Modules/urllib3/__pycache__/fields.cpython-311.pyc deleted file mode 100644 index b4c11f871c83a9b3db0ed9cba97406159abc02d9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 13005 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 UUv~4@-mT$dmjBH*rEJ^(8#J8arvLx| diff --git a/Modules/urllib3/__pycache__/filepost.cpython-311.pyc b/Modules/urllib3/__pycache__/filepost.cpython-311.pyc deleted file mode 100644 index c58f064b8441b28bcf631a74af61ceb778a4bdf8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3858 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 diff --git a/Modules/urllib3/__pycache__/response.cpython-311.pyc b/Modules/urllib3/__pycache__/response.cpython-311.pyc deleted file mode 100644 index 464effe19ed0fd6041e18e98e880d3e64be4e1ce..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 49583 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 None: - ... - - def set_tunnel( - self, - host: str, - port: int | None = None, - headers: typing.Mapping[str, str] | None = None, - scheme: str = "http", - ) -> None: - ... - - def connect(self) -> None: - ... - - def request( - self, - method: str, - url: str, - body: _TYPE_BODY | None = None, - headers: typing.Mapping[str, str] | None = None, - # We know *at least* botocore is depending on the order of the - # first 3 parameters so to be safe we only mark the later ones - # as keyword-only to ensure we have space to extend. - *, - chunked: bool = False, - preload_content: bool = True, - decode_content: bool = True, - enforce_content_length: bool = True, - ) -> None: - ... - - def getresponse(self) -> BaseHTTPResponse: - ... - - def close(self) -> None: - ... - - @property - def is_closed(self) -> bool: - """Whether the connection either is brand new or has been previously closed. - If this property is True then both ``is_connected`` and ``has_connected_to_proxy`` - properties must be False. - """ - - @property - def is_connected(self) -> bool: - """Whether the connection is actively connected to any origin (proxy or target)""" - - @property - def has_connected_to_proxy(self) -> bool: - """Whether the connection has successfully connected to its proxy. - This returns False if no proxy is in use. Used to determine whether - errors are coming from the proxy layer or from tunnelling to the target origin. - """ - - class BaseHTTPSConnection(BaseHTTPConnection, Protocol): - default_port: typing.ClassVar[int] - default_socket_options: typing.ClassVar[_TYPE_SOCKET_OPTIONS] - - # Certificate verification methods - cert_reqs: int | str | None - assert_hostname: None | str | Literal[False] - assert_fingerprint: str | None - ssl_context: ssl.SSLContext | None - - # Trusted CAs - ca_certs: str | None - ca_cert_dir: str | None - ca_cert_data: None | str | bytes - - # TLS version - ssl_minimum_version: int | None - ssl_maximum_version: int | None - ssl_version: int | str | None # Deprecated - - # Client certificates - cert_file: str | None - key_file: str | None - key_password: str | None - - def __init__( - self, - host: str, - port: int | None = None, - *, - timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, - source_address: tuple[str, int] | None = None, - blocksize: int = 16384, - socket_options: _TYPE_SOCKET_OPTIONS | None = ..., - proxy: Url | None = None, - proxy_config: ProxyConfig | None = None, - cert_reqs: int | str | None = None, - assert_hostname: None | str | Literal[False] = None, - assert_fingerprint: str | None = None, - server_hostname: str | None = None, - ssl_context: ssl.SSLContext | None = None, - ca_certs: str | None = None, - ca_cert_dir: str | None = None, - ca_cert_data: None | str | bytes = None, - ssl_minimum_version: int | None = None, - ssl_maximum_version: int | None = None, - ssl_version: int | str | None = None, # Deprecated - cert_file: str | None = None, - key_file: str | None = None, - key_password: str | None = None, - ) -> None: - ... diff --git a/Modules/urllib3/_collections.py b/Modules/urllib3/_collections.py deleted file mode 100644 index 55b0324..0000000 --- a/Modules/urllib3/_collections.py +++ /dev/null @@ -1,483 +0,0 @@ -from __future__ import annotations - -import typing -from collections import OrderedDict -from enum import Enum, auto -from threading import RLock - -if typing.TYPE_CHECKING: - # We can only import Protocol if TYPE_CHECKING because it's a development - # dependency, and is not available at runtime. - from typing import Protocol - - from typing_extensions import Self - - class HasGettableStringKeys(Protocol): - def keys(self) -> typing.Iterator[str]: - ... - - def __getitem__(self, key: str) -> str: - ... - - -__all__ = ["RecentlyUsedContainer", "HTTPHeaderDict"] - - -# Key type -_KT = typing.TypeVar("_KT") -# Value type -_VT = typing.TypeVar("_VT") -# Default type -_DT = typing.TypeVar("_DT") - -ValidHTTPHeaderSource = typing.Union[ - "HTTPHeaderDict", - typing.Mapping[str, str], - typing.Iterable[typing.Tuple[str, str]], - "HasGettableStringKeys", -] - - -class _Sentinel(Enum): - not_passed = auto() - - -def ensure_can_construct_http_header_dict( - potential: object, -) -> ValidHTTPHeaderSource | None: - if isinstance(potential, HTTPHeaderDict): - return potential - elif isinstance(potential, typing.Mapping): - # Full runtime checking of the contents of a Mapping is expensive, so for the - # purposes of typechecking, we assume that any Mapping is the right shape. - return typing.cast(typing.Mapping[str, str], potential) - elif isinstance(potential, typing.Iterable): - # Similarly to Mapping, full runtime checking of the contents of an Iterable is - # expensive, so for the purposes of typechecking, we assume that any Iterable - # is the right shape. - return typing.cast(typing.Iterable[typing.Tuple[str, str]], potential) - elif hasattr(potential, "keys") and hasattr(potential, "__getitem__"): - return typing.cast("HasGettableStringKeys", potential) - else: - return None - - -class RecentlyUsedContainer(typing.Generic[_KT, _VT], typing.MutableMapping[_KT, _VT]): - """ - Provides a thread-safe dict-like container which maintains up to - ``maxsize`` keys while throwing away the least-recently-used keys beyond - ``maxsize``. - - :param maxsize: - Maximum number of recent elements to retain. - - :param dispose_func: - Every time an item is evicted from the container, - ``dispose_func(value)`` is called. Callback which will get called - """ - - _container: typing.OrderedDict[_KT, _VT] - _maxsize: int - dispose_func: typing.Callable[[_VT], None] | None - lock: RLock - - def __init__( - self, - maxsize: int = 10, - dispose_func: typing.Callable[[_VT], None] | None = None, - ) -> None: - super().__init__() - self._maxsize = maxsize - self.dispose_func = dispose_func - self._container = OrderedDict() - self.lock = RLock() - - def __getitem__(self, key: _KT) -> _VT: - # Re-insert the item, moving it to the end of the eviction line. - with self.lock: - item = self._container.pop(key) - self._container[key] = item - return item - - def __setitem__(self, key: _KT, value: _VT) -> None: - evicted_item = None - with self.lock: - # Possibly evict the existing value of 'key' - try: - # If the key exists, we'll overwrite it, which won't change the - # size of the pool. Because accessing a key should move it to - # the end of the eviction line, we pop it out first. - evicted_item = key, self._container.pop(key) - self._container[key] = value - except KeyError: - # When the key does not exist, we insert the value first so that - # evicting works in all cases, including when self._maxsize is 0 - self._container[key] = value - if len(self._container) > self._maxsize: - # If we didn't evict an existing value, and we've hit our maximum - # size, then we have to evict the least recently used item from - # the beginning of the container. - evicted_item = self._container.popitem(last=False) - - # After releasing the lock on the pool, dispose of any evicted value. - if evicted_item is not None and self.dispose_func: - _, evicted_value = evicted_item - self.dispose_func(evicted_value) - - def __delitem__(self, key: _KT) -> None: - with self.lock: - value = self._container.pop(key) - - if self.dispose_func: - self.dispose_func(value) - - def __len__(self) -> int: - with self.lock: - return len(self._container) - - def __iter__(self) -> typing.NoReturn: - raise NotImplementedError( - "Iteration over this class is unlikely to be threadsafe." - ) - - def clear(self) -> None: - with self.lock: - # Copy pointers to all values, then wipe the mapping - values = list(self._container.values()) - self._container.clear() - - if self.dispose_func: - for value in values: - self.dispose_func(value) - - def keys(self) -> set[_KT]: # type: ignore[override] - with self.lock: - return set(self._container.keys()) - - -class HTTPHeaderDictItemView(typing.Set[typing.Tuple[str, str]]): - """ - HTTPHeaderDict is unusual for a Mapping[str, str] in that it has two modes of - address. - - If we directly try to get an item with a particular name, we will get a string - back that is the concatenated version of all the values: - - >>> d['X-Header-Name'] - 'Value1, Value2, Value3' - - However, if we iterate over an HTTPHeaderDict's items, we will optionally combine - these values based on whether combine=True was called when building up the dictionary - - >>> d = HTTPHeaderDict({"A": "1", "B": "foo"}) - >>> d.add("A", "2", combine=True) - >>> d.add("B", "bar") - >>> list(d.items()) - [ - ('A', '1, 2'), - ('B', 'foo'), - ('B', 'bar'), - ] - - This class conforms to the interface required by the MutableMapping ABC while - also giving us the nonstandard iteration behavior we want; items with duplicate - keys, ordered by time of first insertion. - """ - - _headers: HTTPHeaderDict - - def __init__(self, headers: HTTPHeaderDict) -> None: - self._headers = headers - - def __len__(self) -> int: - return len(list(self._headers.iteritems())) - - def __iter__(self) -> typing.Iterator[tuple[str, str]]: - return self._headers.iteritems() - - def __contains__(self, item: object) -> bool: - if isinstance(item, tuple) and len(item) == 2: - passed_key, passed_val = item - if isinstance(passed_key, str) and isinstance(passed_val, str): - return self._headers._has_value_for_header(passed_key, passed_val) - return False - - -class HTTPHeaderDict(typing.MutableMapping[str, str]): - """ - :param headers: - An iterable of field-value pairs. Must not contain multiple field names - when compared case-insensitively. - - :param kwargs: - Additional field-value pairs to pass in to ``dict.update``. - - A ``dict`` like container for storing HTTP Headers. - - Field names are stored and compared case-insensitively in compliance with - RFC 7230. Iteration provides the first case-sensitive key seen for each - case-insensitive pair. - - Using ``__setitem__`` syntax overwrites fields that compare equal - case-insensitively in order to maintain ``dict``'s api. For fields that - compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add`` - in a loop. - - If multiple fields that are equal case-insensitively are passed to the - constructor or ``.update``, the behavior is undefined and some will be - lost. - - >>> headers = HTTPHeaderDict() - >>> headers.add('Set-Cookie', 'foo=bar') - >>> headers.add('set-cookie', 'baz=quxx') - >>> headers['content-length'] = '7' - >>> headers['SET-cookie'] - 'foo=bar, baz=quxx' - >>> headers['Content-Length'] - '7' - """ - - _container: typing.MutableMapping[str, list[str]] - - def __init__(self, headers: ValidHTTPHeaderSource | None = None, **kwargs: str): - super().__init__() - self._container = {} # 'dict' is insert-ordered - if headers is not None: - if isinstance(headers, HTTPHeaderDict): - self._copy_from(headers) - else: - self.extend(headers) - if kwargs: - self.extend(kwargs) - - def __setitem__(self, key: str, val: str) -> None: - # avoid a bytes/str comparison by decoding before httplib - if isinstance(key, bytes): - key = key.decode("latin-1") - self._container[key.lower()] = [key, val] - - def __getitem__(self, key: str) -> str: - val = self._container[key.lower()] - return ", ".join(val[1:]) - - def __delitem__(self, key: str) -> None: - del self._container[key.lower()] - - def __contains__(self, key: object) -> bool: - if isinstance(key, str): - return key.lower() in self._container - return False - - def setdefault(self, key: str, default: str = "") -> str: - return super().setdefault(key, default) - - def __eq__(self, other: object) -> bool: - maybe_constructable = ensure_can_construct_http_header_dict(other) - if maybe_constructable is None: - return False - else: - other_as_http_header_dict = type(self)(maybe_constructable) - - return {k.lower(): v for k, v in self.itermerged()} == { - k.lower(): v for k, v in other_as_http_header_dict.itermerged() - } - - def __ne__(self, other: object) -> bool: - return not self.__eq__(other) - - def __len__(self) -> int: - return len(self._container) - - def __iter__(self) -> typing.Iterator[str]: - # Only provide the originally cased names - for vals in self._container.values(): - yield vals[0] - - def discard(self, key: str) -> None: - try: - del self[key] - except KeyError: - pass - - def add(self, key: str, val: str, *, combine: bool = False) -> None: - """Adds a (name, value) pair, doesn't overwrite the value if it already - exists. - - If this is called with combine=True, instead of adding a new header value - as a distinct item during iteration, this will instead append the value to - any existing header value with a comma. If no existing header value exists - for the key, then the value will simply be added, ignoring the combine parameter. - - >>> headers = HTTPHeaderDict(foo='bar') - >>> headers.add('Foo', 'baz') - >>> headers['foo'] - 'bar, baz' - >>> list(headers.items()) - [('foo', 'bar'), ('foo', 'baz')] - >>> headers.add('foo', 'quz', combine=True) - >>> list(headers.items()) - [('foo', 'bar, baz, quz')] - """ - # avoid a bytes/str comparison by decoding before httplib - if isinstance(key, bytes): - key = key.decode("latin-1") - key_lower = key.lower() - new_vals = [key, val] - # Keep the common case aka no item present as fast as possible - vals = self._container.setdefault(key_lower, new_vals) - if new_vals is not vals: - # if there are values here, then there is at least the initial - # key/value pair - assert len(vals) >= 2 - if combine: - vals[-1] = vals[-1] + ", " + val - else: - vals.append(val) - - def extend(self, *args: ValidHTTPHeaderSource, **kwargs: str) -> None: - """Generic import function for any type of header-like object. - Adapted version of MutableMapping.update in order to insert items - with self.add instead of self.__setitem__ - """ - if len(args) > 1: - raise TypeError( - f"extend() takes at most 1 positional arguments ({len(args)} given)" - ) - other = args[0] if len(args) >= 1 else () - - if isinstance(other, HTTPHeaderDict): - for key, val in other.iteritems(): - self.add(key, val) - elif isinstance(other, typing.Mapping): - for key, val in other.items(): - self.add(key, val) - elif isinstance(other, typing.Iterable): - other = typing.cast(typing.Iterable[typing.Tuple[str, str]], other) - for key, value in other: - self.add(key, value) - elif hasattr(other, "keys") and hasattr(other, "__getitem__"): - # THIS IS NOT A TYPESAFE BRANCH - # In this branch, the object has a `keys` attr but is not a Mapping or any of - # the other types indicated in the method signature. We do some stuff with - # it as though it partially implements the Mapping interface, but we're not - # doing that stuff safely AT ALL. - for key in other.keys(): - self.add(key, other[key]) - - for key, value in kwargs.items(): - self.add(key, value) - - @typing.overload - def getlist(self, key: str) -> list[str]: - ... - - @typing.overload - def getlist(self, key: str, default: _DT) -> list[str] | _DT: - ... - - def getlist( - self, key: str, default: _Sentinel | _DT = _Sentinel.not_passed - ) -> list[str] | _DT: - """Returns a list of all the values for the named field. Returns an - empty list if the key doesn't exist.""" - try: - vals = self._container[key.lower()] - except KeyError: - if default is _Sentinel.not_passed: - # _DT is unbound; empty list is instance of List[str] - return [] - # _DT is bound; default is instance of _DT - return default - else: - # _DT may or may not be bound; vals[1:] is instance of List[str], which - # meets our external interface requirement of `Union[List[str], _DT]`. - return vals[1:] - - def _prepare_for_method_change(self) -> Self: - """ - Remove content-specific header fields before changing the request - method to GET or HEAD according to RFC 9110, Section 15.4. - """ - content_specific_headers = [ - "Content-Encoding", - "Content-Language", - "Content-Location", - "Content-Type", - "Content-Length", - "Digest", - "Last-Modified", - ] - for header in content_specific_headers: - self.discard(header) - return self - - # Backwards compatibility for httplib - getheaders = getlist - getallmatchingheaders = getlist - iget = getlist - - # Backwards compatibility for http.cookiejar - get_all = getlist - - def __repr__(self) -> str: - return f"{type(self).__name__}({dict(self.itermerged())})" - - def _copy_from(self, other: HTTPHeaderDict) -> None: - for key in other: - val = other.getlist(key) - self._container[key.lower()] = [key, *val] - - def copy(self) -> HTTPHeaderDict: - clone = type(self)() - clone._copy_from(self) - return clone - - def iteritems(self) -> typing.Iterator[tuple[str, str]]: - """Iterate over all header lines, including duplicate ones.""" - for key in self: - vals = self._container[key.lower()] - for val in vals[1:]: - yield vals[0], val - - def itermerged(self) -> typing.Iterator[tuple[str, str]]: - """Iterate over all headers, merging duplicate ones together.""" - for key in self: - val = self._container[key.lower()] - yield val[0], ", ".join(val[1:]) - - def items(self) -> HTTPHeaderDictItemView: # type: ignore[override] - return HTTPHeaderDictItemView(self) - - def _has_value_for_header(self, header_name: str, potential_value: str) -> bool: - if header_name in self: - return potential_value in self._container[header_name.lower()][1:] - return False - - def __ior__(self, other: object) -> HTTPHeaderDict: - # Supports extending a header dict in-place using operator |= - # combining items with add instead of __setitem__ - maybe_constructable = ensure_can_construct_http_header_dict(other) - if maybe_constructable is None: - return NotImplemented - self.extend(maybe_constructable) - return self - - def __or__(self, other: object) -> HTTPHeaderDict: - # Supports merging header dicts using operator | - # combining items with add instead of __setitem__ - maybe_constructable = ensure_can_construct_http_header_dict(other) - if maybe_constructable is None: - return NotImplemented - result = self.copy() - result.extend(maybe_constructable) - return result - - def __ror__(self, other: object) -> HTTPHeaderDict: - # Supports merging header dicts using operator | when other is on left side - # combining items with add instead of __setitem__ - maybe_constructable = ensure_can_construct_http_header_dict(other) - if maybe_constructable is None: - return NotImplemented - result = type(self)(maybe_constructable) - result.extend(self) - return result diff --git a/Modules/urllib3/_request_methods.py b/Modules/urllib3/_request_methods.py deleted file mode 100644 index 1d0f346..0000000 --- a/Modules/urllib3/_request_methods.py +++ /dev/null @@ -1,217 +0,0 @@ -from __future__ import annotations - -import json as _json -import typing -from urllib.parse import urlencode - -from ._base_connection import _TYPE_BODY -from ._collections import HTTPHeaderDict -from .filepost import _TYPE_FIELDS, encode_multipart_formdata -from .response import BaseHTTPResponse - -__all__ = ["RequestMethods"] - -_TYPE_ENCODE_URL_FIELDS = typing.Union[ - typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]], - typing.Mapping[str, typing.Union[str, bytes]], -] - - -class RequestMethods: - """ - Convenience mixin for classes who implement a :meth:`urlopen` method, such - as :class:`urllib3.HTTPConnectionPool` and - :class:`urllib3.PoolManager`. - - Provides behavior for making common types of HTTP request methods and - decides which type of request field encoding to use. - - Specifically, - - :meth:`.request_encode_url` is for sending requests whose fields are - encoded in the URL (such as GET, HEAD, DELETE). - - :meth:`.request_encode_body` is for sending requests whose fields are - encoded in the *body* of the request using multipart or www-form-urlencoded - (such as for POST, PUT, PATCH). - - :meth:`.request` is for making any kind of request, it will look up the - appropriate encoding format and use one of the above two methods to make - the request. - - Initializer parameters: - - :param headers: - Headers to include with all requests, unless other headers are given - explicitly. - """ - - _encode_url_methods = {"DELETE", "GET", "HEAD", "OPTIONS"} - - def __init__(self, headers: typing.Mapping[str, str] | None = None) -> None: - self.headers = headers or {} - - def urlopen( - self, - method: str, - url: str, - body: _TYPE_BODY | None = None, - headers: typing.Mapping[str, str] | None = None, - encode_multipart: bool = True, - multipart_boundary: str | None = None, - **kw: typing.Any, - ) -> BaseHTTPResponse: # Abstract - raise NotImplementedError( - "Classes extending RequestMethods must implement " - "their own ``urlopen`` method." - ) - - def request( - self, - method: str, - url: str, - body: _TYPE_BODY | None = None, - fields: _TYPE_FIELDS | None = None, - headers: typing.Mapping[str, str] | None = None, - json: typing.Any | None = None, - **urlopen_kw: typing.Any, - ) -> BaseHTTPResponse: - """ - Make a request using :meth:`urlopen` with the appropriate encoding of - ``fields`` based on the ``method`` used. - - This is a convenience method that requires the least amount of manual - effort. It can be used in most situations, while still having the - option to drop down to more specific methods when necessary, such as - :meth:`request_encode_url`, :meth:`request_encode_body`, - or even the lowest level :meth:`urlopen`. - """ - method = method.upper() - - if json is not None and body is not None: - raise TypeError( - "request got values for both 'body' and 'json' parameters which are mutually exclusive" - ) - - if json is not None: - if headers is None: - headers = self.headers.copy() # type: ignore - if not ("content-type" in map(str.lower, headers.keys())): - headers["Content-Type"] = "application/json" # type: ignore - - body = _json.dumps(json, separators=(",", ":"), ensure_ascii=False).encode( - "utf-8" - ) - - if body is not None: - urlopen_kw["body"] = body - - if method in self._encode_url_methods: - return self.request_encode_url( - method, - url, - fields=fields, # type: ignore[arg-type] - headers=headers, - **urlopen_kw, - ) - else: - return self.request_encode_body( - method, url, fields=fields, headers=headers, **urlopen_kw - ) - - def request_encode_url( - self, - method: str, - url: str, - fields: _TYPE_ENCODE_URL_FIELDS | None = None, - headers: typing.Mapping[str, str] | None = None, - **urlopen_kw: str, - ) -> BaseHTTPResponse: - """ - Make a request using :meth:`urlopen` with the ``fields`` encoded in - the url. This is useful for request methods like GET, HEAD, DELETE, etc. - """ - if headers is None: - headers = self.headers - - extra_kw: dict[str, typing.Any] = {"headers": headers} - extra_kw.update(urlopen_kw) - - if fields: - url += "?" + urlencode(fields) - - return self.urlopen(method, url, **extra_kw) - - def request_encode_body( - self, - method: str, - url: str, - fields: _TYPE_FIELDS | None = None, - headers: typing.Mapping[str, str] | None = None, - encode_multipart: bool = True, - multipart_boundary: str | None = None, - **urlopen_kw: str, - ) -> BaseHTTPResponse: - """ - Make a request using :meth:`urlopen` with the ``fields`` encoded in - the body. This is useful for request methods like POST, PUT, PATCH, etc. - - When ``encode_multipart=True`` (default), then - :func:`urllib3.encode_multipart_formdata` is used to encode - the payload with the appropriate content type. Otherwise - :func:`urllib.parse.urlencode` is used with the - 'application/x-www-form-urlencoded' content type. - - Multipart encoding must be used when posting files, and it's reasonably - safe to use it in other times too. However, it may break request - signing, such as with OAuth. - - Supports an optional ``fields`` parameter of key/value strings AND - key/filetuple. A filetuple is a (filename, data, MIME type) tuple where - the MIME type is optional. For example:: - - fields = { - 'foo': 'bar', - 'fakefile': ('foofile.txt', 'contents of foofile'), - 'realfile': ('barfile.txt', open('realfile').read()), - 'typedfile': ('bazfile.bin', open('bazfile').read(), - 'image/jpeg'), - 'nonamefile': 'contents of nonamefile field', - } - - When uploading a file, providing a filename (the first parameter of the - tuple) is optional but recommended to best mimic behavior of browsers. - - Note that if ``headers`` are supplied, the 'Content-Type' header will - be overwritten because it depends on the dynamic random boundary string - which is used to compose the body of the request. The random boundary - string can be explicitly set with the ``multipart_boundary`` parameter. - """ - if headers is None: - headers = self.headers - - extra_kw: dict[str, typing.Any] = {"headers": HTTPHeaderDict(headers)} - body: bytes | str - - if fields: - if "body" in urlopen_kw: - raise TypeError( - "request got values for both 'fields' and 'body', can only specify one." - ) - - if encode_multipart: - body, content_type = encode_multipart_formdata( - fields, boundary=multipart_boundary - ) - else: - body, content_type = ( - urlencode(fields), # type: ignore[arg-type] - "application/x-www-form-urlencoded", - ) - - extra_kw["body"] = body - extra_kw["headers"].setdefault("Content-Type", content_type) - - extra_kw.update(urlopen_kw) - - return self.urlopen(method, url, **extra_kw) diff --git a/Modules/urllib3/_version.py b/Modules/urllib3/_version.py deleted file mode 100644 index 409ba3f..0000000 --- a/Modules/urllib3/_version.py +++ /dev/null @@ -1,4 +0,0 @@ -# This file is protected via CODEOWNERS -from __future__ import annotations - -__version__ = "2.1.0" diff --git a/Modules/urllib3/connection.py b/Modules/urllib3/connection.py deleted file mode 100644 index 38a2fd6..0000000 --- a/Modules/urllib3/connection.py +++ /dev/null @@ -1,905 +0,0 @@ -from __future__ import annotations - -import datetime -import logging -import os -import re -import socket -import sys -import typing -import warnings -from http.client import HTTPConnection as _HTTPConnection -from http.client import HTTPException as HTTPException # noqa: F401 -from http.client import ResponseNotReady -from socket import timeout as SocketTimeout - -if typing.TYPE_CHECKING: - from typing import Literal - - from .response import HTTPResponse - from .util.ssl_ import _TYPE_PEER_CERT_RET_DICT - from .util.ssltransport import SSLTransport - -from ._collections import HTTPHeaderDict -from .util.response import assert_header_parsing -from .util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT, Timeout -from .util.util import to_str -from .util.wait import wait_for_read - -try: # Compiled with SSL? - import ssl - - BaseSSLError = ssl.SSLError -except (ImportError, AttributeError): - ssl = None # type: ignore[assignment] - - class BaseSSLError(BaseException): # type: ignore[no-redef] - pass - - -from ._base_connection import _TYPE_BODY -from ._base_connection import ProxyConfig as ProxyConfig -from ._base_connection import _ResponseOptions as _ResponseOptions -from ._version import __version__ -from .exceptions import ( - ConnectTimeoutError, - HeaderParsingError, - NameResolutionError, - NewConnectionError, - ProxyError, - SystemTimeWarning, -) -from .util import SKIP_HEADER, SKIPPABLE_HEADERS, connection, ssl_ -from .util.request import body_to_chunks -from .util.ssl_ import assert_fingerprint as _assert_fingerprint -from .util.ssl_ import ( - create_urllib3_context, - is_ipaddress, - resolve_cert_reqs, - resolve_ssl_version, - ssl_wrap_socket, -) -from .util.ssl_match_hostname import CertificateError, match_hostname -from .util.url import Url - -# Not a no-op, we're adding this to the namespace so it can be imported. -ConnectionError = ConnectionError -BrokenPipeError = BrokenPipeError - - -log = logging.getLogger(__name__) - -port_by_scheme = {"http": 80, "https": 443} - -# When it comes time to update this value as a part of regular maintenance -# (ie test_recent_date is failing) update it to ~6 months before the current date. -RECENT_DATE = datetime.date(2022, 1, 1) - -_CONTAINS_CONTROL_CHAR_RE = re.compile(r"[^-!#$%&'*+.^_`|~0-9a-zA-Z]") - -_HAS_SYS_AUDIT = hasattr(sys, "audit") - - -class HTTPConnection(_HTTPConnection): - """ - Based on :class:`http.client.HTTPConnection` but provides an extra constructor - backwards-compatibility layer between older and newer Pythons. - - Additional keyword parameters are used to configure attributes of the connection. - Accepted parameters include: - - - ``source_address``: Set the source address for the current connection. - - ``socket_options``: Set specific options on the underlying socket. If not specified, then - defaults are loaded from ``HTTPConnection.default_socket_options`` which includes disabling - Nagle's algorithm (sets TCP_NODELAY to 1) unless the connection is behind a proxy. - - For example, if you wish to enable TCP Keep Alive in addition to the defaults, - you might pass: - - .. code-block:: python - - HTTPConnection.default_socket_options + [ - (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1), - ] - - Or you may want to disable the defaults by passing an empty list (e.g., ``[]``). - """ - - default_port: typing.ClassVar[int] = port_by_scheme["http"] # type: ignore[misc] - - #: Disable Nagle's algorithm by default. - #: ``[(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]`` - default_socket_options: typing.ClassVar[connection._TYPE_SOCKET_OPTIONS] = [ - (socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) - ] - - #: Whether this connection verifies the host's certificate. - is_verified: bool = False - - #: Whether this proxy connection verified the proxy host's certificate. - # If no proxy is currently connected to the value will be ``None``. - proxy_is_verified: bool | None = None - - blocksize: int - source_address: tuple[str, int] | None - socket_options: connection._TYPE_SOCKET_OPTIONS | None - - _has_connected_to_proxy: bool - _response_options: _ResponseOptions | None - _tunnel_host: str | None - _tunnel_port: int | None - _tunnel_scheme: str | None - - def __init__( - self, - host: str, - port: int | None = None, - *, - timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, - source_address: tuple[str, int] | None = None, - blocksize: int = 16384, - socket_options: None - | (connection._TYPE_SOCKET_OPTIONS) = default_socket_options, - proxy: Url | None = None, - proxy_config: ProxyConfig | None = None, - ) -> None: - super().__init__( - host=host, - port=port, - timeout=Timeout.resolve_default_timeout(timeout), - source_address=source_address, - blocksize=blocksize, - ) - self.socket_options = socket_options - self.proxy = proxy - self.proxy_config = proxy_config - - self._has_connected_to_proxy = False - self._response_options = None - self._tunnel_host: str | None = None - self._tunnel_port: int | None = None - self._tunnel_scheme: str | None = None - - # https://github.com/python/mypy/issues/4125 - # Mypy treats this as LSP violation, which is considered a bug. - # If `host` is made a property it violates LSP, because a writeable attribute is overridden with a read-only one. - # However, there is also a `host` setter so LSP is not violated. - # Potentially, a `@host.deleter` might be needed depending on how this issue will be fixed. - @property - def host(self) -> str: - """ - Getter method to remove any trailing dots that indicate the hostname is an FQDN. - - In general, SSL certificates don't include the trailing dot indicating a - fully-qualified domain name, and thus, they don't validate properly when - checked against a domain name that includes the dot. In addition, some - servers may not expect to receive the trailing dot when provided. - - However, the hostname with trailing dot is critical to DNS resolution; doing a - lookup with the trailing dot will properly only resolve the appropriate FQDN, - whereas a lookup without a trailing dot will search the system's search domain - list. Thus, it's important to keep the original host around for use only in - those cases where it's appropriate (i.e., when doing DNS lookup to establish the - actual TCP connection across which we're going to send HTTP requests). - """ - return self._dns_host.rstrip(".") - - @host.setter - def host(self, value: str) -> None: - """ - Setter for the `host` property. - - We assume that only urllib3 uses the _dns_host attribute; httplib itself - only uses `host`, and it seems reasonable that other libraries follow suit. - """ - self._dns_host = value - - def _new_conn(self) -> socket.socket: - """Establish a socket connection and set nodelay settings on it. - - :return: New socket connection. - """ - try: - sock = connection.create_connection( - (self._dns_host, self.port), - self.timeout, - source_address=self.source_address, - socket_options=self.socket_options, - ) - except socket.gaierror as e: - raise NameResolutionError(self.host, self, e) from e - except SocketTimeout as e: - raise ConnectTimeoutError( - self, - f"Connection to {self.host} timed out. (connect timeout={self.timeout})", - ) from e - - except OSError as e: - raise NewConnectionError( - self, f"Failed to establish a new connection: {e}" - ) from e - - # Audit hooks are only available in Python 3.8+ - if _HAS_SYS_AUDIT: - sys.audit("http.client.connect", self, self.host, self.port) - - return sock - - def set_tunnel( - self, - host: str, - port: int | None = None, - headers: typing.Mapping[str, str] | None = None, - scheme: str = "http", - ) -> None: - if scheme not in ("http", "https"): - raise ValueError( - f"Invalid proxy scheme for tunneling: {scheme!r}, must be either 'http' or 'https'" - ) - super().set_tunnel(host, port=port, headers=headers) - self._tunnel_scheme = scheme - - def connect(self) -> None: - self.sock = self._new_conn() - if self._tunnel_host: - # If we're tunneling it means we're connected to our proxy. - self._has_connected_to_proxy = True - - # TODO: Fix tunnel so it doesn't depend on self.sock state. - self._tunnel() # type: ignore[attr-defined] - - # If there's a proxy to be connected to we are fully connected. - # This is set twice (once above and here) due to forwarding proxies - # not using tunnelling. - self._has_connected_to_proxy = bool(self.proxy) - - @property - def is_closed(self) -> bool: - return self.sock is None - - @property - def is_connected(self) -> bool: - if self.sock is None: - return False - return not wait_for_read(self.sock, timeout=0.0) - - @property - def has_connected_to_proxy(self) -> bool: - return self._has_connected_to_proxy - - def close(self) -> None: - try: - super().close() - finally: - # Reset all stateful properties so connection - # can be re-used without leaking prior configs. - self.sock = None - self.is_verified = False - self.proxy_is_verified = None - self._has_connected_to_proxy = False - self._response_options = None - self._tunnel_host = None - self._tunnel_port = None - self._tunnel_scheme = None - - def putrequest( - self, - method: str, - url: str, - skip_host: bool = False, - skip_accept_encoding: bool = False, - ) -> None: - """""" - # Empty docstring because the indentation of CPython's implementation - # is broken but we don't want this method in our documentation. - match = _CONTAINS_CONTROL_CHAR_RE.search(method) - if match: - raise ValueError( - f"Method cannot contain non-token characters {method!r} (found at least {match.group()!r})" - ) - - return super().putrequest( - method, url, skip_host=skip_host, skip_accept_encoding=skip_accept_encoding - ) - - def putheader(self, header: str, *values: str) -> None: - """""" - if not any(isinstance(v, str) and v == SKIP_HEADER for v in values): - super().putheader(header, *values) - elif to_str(header.lower()) not in SKIPPABLE_HEADERS: - skippable_headers = "', '".join( - [str.title(header) for header in sorted(SKIPPABLE_HEADERS)] - ) - raise ValueError( - f"urllib3.util.SKIP_HEADER only supports '{skippable_headers}'" - ) - - # `request` method's signature intentionally violates LSP. - # urllib3's API is different from `http.client.HTTPConnection` and the subclassing is only incidental. - def request( # type: ignore[override] - self, - method: str, - url: str, - body: _TYPE_BODY | None = None, - headers: typing.Mapping[str, str] | None = None, - *, - chunked: bool = False, - preload_content: bool = True, - decode_content: bool = True, - enforce_content_length: bool = True, - ) -> None: - # Update the inner socket's timeout value to send the request. - # This only triggers if the connection is re-used. - if self.sock is not None: - self.sock.settimeout(self.timeout) - - # Store these values to be fed into the HTTPResponse - # object later. TODO: Remove this in favor of a real - # HTTP lifecycle mechanism. - - # We have to store these before we call .request() - # because sometimes we can still salvage a response - # off the wire even if we aren't able to completely - # send the request body. - self._response_options = _ResponseOptions( - request_method=method, - request_url=url, - preload_content=preload_content, - decode_content=decode_content, - enforce_content_length=enforce_content_length, - ) - - if headers is None: - headers = {} - header_keys = frozenset(to_str(k.lower()) for k in headers) - skip_accept_encoding = "accept-encoding" in header_keys - skip_host = "host" in header_keys - self.putrequest( - method, url, skip_accept_encoding=skip_accept_encoding, skip_host=skip_host - ) - - # Transform the body into an iterable of sendall()-able chunks - # and detect if an explicit Content-Length is doable. - chunks_and_cl = body_to_chunks(body, method=method, blocksize=self.blocksize) - chunks = chunks_and_cl.chunks - content_length = chunks_and_cl.content_length - - # When chunked is explicit set to 'True' we respect that. - if chunked: - if "transfer-encoding" not in header_keys: - self.putheader("Transfer-Encoding", "chunked") - else: - # Detect whether a framing mechanism is already in use. If so - # we respect that value, otherwise we pick chunked vs content-length - # depending on the type of 'body'. - if "content-length" in header_keys: - chunked = False - elif "transfer-encoding" in header_keys: - chunked = True - - # Otherwise we go off the recommendation of 'body_to_chunks()'. - else: - chunked = False - if content_length is None: - if chunks is not None: - chunked = True - self.putheader("Transfer-Encoding", "chunked") - else: - self.putheader("Content-Length", str(content_length)) - - # Now that framing headers are out of the way we send all the other headers. - if "user-agent" not in header_keys: - self.putheader("User-Agent", _get_default_user_agent()) - for header, value in headers.items(): - self.putheader(header, value) - self.endheaders() - - # If we're given a body we start sending that in chunks. - if chunks is not None: - for chunk in chunks: - # Sending empty chunks isn't allowed for TE: chunked - # as it indicates the end of the body. - if not chunk: - continue - if isinstance(chunk, str): - chunk = chunk.encode("utf-8") - if chunked: - self.send(b"%x\r\n%b\r\n" % (len(chunk), chunk)) - else: - self.send(chunk) - - # Regardless of whether we have a body or not, if we're in - # chunked mode we want to send an explicit empty chunk. - if chunked: - self.send(b"0\r\n\r\n") - - def request_chunked( - self, - method: str, - url: str, - body: _TYPE_BODY | None = None, - headers: typing.Mapping[str, str] | None = None, - ) -> None: - """ - Alternative to the common request method, which sends the - body with chunked encoding and not as one block - """ - warnings.warn( - "HTTPConnection.request_chunked() is deprecated and will be removed " - "in urllib3 v2.1.0. Instead use HTTPConnection.request(..., chunked=True).", - category=DeprecationWarning, - stacklevel=2, - ) - self.request(method, url, body=body, headers=headers, chunked=True) - - def getresponse( # type: ignore[override] - self, - ) -> HTTPResponse: - """ - Get the response from the server. - - If the HTTPConnection is in the correct state, returns an instance of HTTPResponse or of whatever object is returned by the response_class variable. - - If a request has not been sent or if a previous response has not be handled, ResponseNotReady is raised. If the HTTP response indicates that the connection should be closed, then it will be closed before the response is returned. When the connection is closed, the underlying socket is closed. - """ - # Raise the same error as http.client.HTTPConnection - if self._response_options is None: - raise ResponseNotReady() - - # Reset this attribute for being used again. - resp_options = self._response_options - self._response_options = None - - # Since the connection's timeout value may have been updated - # we need to set the timeout on the socket. - self.sock.settimeout(self.timeout) - - # This is needed here to avoid circular import errors - from .response import HTTPResponse - - # Get the response from http.client.HTTPConnection - httplib_response = super().getresponse() - - try: - assert_header_parsing(httplib_response.msg) - except (HeaderParsingError, TypeError) as hpe: - log.warning( - "Failed to parse headers (url=%s): %s", - _url_from_connection(self, resp_options.request_url), - hpe, - exc_info=True, - ) - - headers = HTTPHeaderDict(httplib_response.msg.items()) - - response = HTTPResponse( - body=httplib_response, - headers=headers, - status=httplib_response.status, - version=httplib_response.version, - reason=httplib_response.reason, - preload_content=resp_options.preload_content, - decode_content=resp_options.decode_content, - original_response=httplib_response, - enforce_content_length=resp_options.enforce_content_length, - request_method=resp_options.request_method, - request_url=resp_options.request_url, - ) - return response - - -class HTTPSConnection(HTTPConnection): - """ - Many of the parameters to this constructor are passed to the underlying SSL - socket by means of :py:func:`urllib3.util.ssl_wrap_socket`. - """ - - default_port = port_by_scheme["https"] # type: ignore[misc] - - cert_reqs: int | str | None = None - ca_certs: str | None = None - ca_cert_dir: str | None = None - ca_cert_data: None | str | bytes = None - ssl_version: int | str | None = None - ssl_minimum_version: int | None = None - ssl_maximum_version: int | None = None - assert_fingerprint: str | None = None - - def __init__( - self, - host: str, - port: int | None = None, - *, - timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, - source_address: tuple[str, int] | None = None, - blocksize: int = 16384, - socket_options: None - | (connection._TYPE_SOCKET_OPTIONS) = HTTPConnection.default_socket_options, - proxy: Url | None = None, - proxy_config: ProxyConfig | None = None, - cert_reqs: int | str | None = None, - assert_hostname: None | str | Literal[False] = None, - assert_fingerprint: str | None = None, - server_hostname: str | None = None, - ssl_context: ssl.SSLContext | None = None, - ca_certs: str | None = None, - ca_cert_dir: str | None = None, - ca_cert_data: None | str | bytes = None, - ssl_minimum_version: int | None = None, - ssl_maximum_version: int | None = None, - ssl_version: int | str | None = None, # Deprecated - cert_file: str | None = None, - key_file: str | None = None, - key_password: str | None = None, - ) -> None: - super().__init__( - host, - port=port, - timeout=timeout, - source_address=source_address, - blocksize=blocksize, - socket_options=socket_options, - proxy=proxy, - proxy_config=proxy_config, - ) - - self.key_file = key_file - self.cert_file = cert_file - self.key_password = key_password - self.ssl_context = ssl_context - self.server_hostname = server_hostname - self.assert_hostname = assert_hostname - self.assert_fingerprint = assert_fingerprint - self.ssl_version = ssl_version - self.ssl_minimum_version = ssl_minimum_version - self.ssl_maximum_version = ssl_maximum_version - self.ca_certs = ca_certs and os.path.expanduser(ca_certs) - self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir) - self.ca_cert_data = ca_cert_data - - # cert_reqs depends on ssl_context so calculate last. - if cert_reqs is None: - if self.ssl_context is not None: - cert_reqs = self.ssl_context.verify_mode - else: - cert_reqs = resolve_cert_reqs(None) - self.cert_reqs = cert_reqs - - def set_cert( - self, - key_file: str | None = None, - cert_file: str | None = None, - cert_reqs: int | str | None = None, - key_password: str | None = None, - ca_certs: str | None = None, - assert_hostname: None | str | Literal[False] = None, - assert_fingerprint: str | None = None, - ca_cert_dir: str | None = None, - ca_cert_data: None | str | bytes = None, - ) -> None: - """ - This method should only be called once, before the connection is used. - """ - warnings.warn( - "HTTPSConnection.set_cert() is deprecated and will be removed " - "in urllib3 v2.1.0. Instead provide the parameters to the " - "HTTPSConnection constructor.", - category=DeprecationWarning, - stacklevel=2, - ) - - # If cert_reqs is not provided we'll assume CERT_REQUIRED unless we also - # have an SSLContext object in which case we'll use its verify_mode. - if cert_reqs is None: - if self.ssl_context is not None: - cert_reqs = self.ssl_context.verify_mode - else: - cert_reqs = resolve_cert_reqs(None) - - self.key_file = key_file - self.cert_file = cert_file - self.cert_reqs = cert_reqs - self.key_password = key_password - self.assert_hostname = assert_hostname - self.assert_fingerprint = assert_fingerprint - self.ca_certs = ca_certs and os.path.expanduser(ca_certs) - self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir) - self.ca_cert_data = ca_cert_data - - def connect(self) -> None: - sock: socket.socket | ssl.SSLSocket - self.sock = sock = self._new_conn() - server_hostname: str = self.host - tls_in_tls = False - - # Do we need to establish a tunnel? - if self._tunnel_host is not None: - # We're tunneling to an HTTPS origin so need to do TLS-in-TLS. - if self._tunnel_scheme == "https": - self.sock = sock = self._connect_tls_proxy(self.host, sock) - tls_in_tls = True - - # If we're tunneling it means we're connected to our proxy. - self._has_connected_to_proxy = True - - self._tunnel() # type: ignore[attr-defined] - # Override the host with the one we're requesting data from. - server_hostname = self._tunnel_host - - if self.server_hostname is not None: - server_hostname = self.server_hostname - - is_time_off = datetime.date.today() < RECENT_DATE - if is_time_off: - warnings.warn( - ( - f"System time is way off (before {RECENT_DATE}). This will probably " - "lead to SSL verification errors" - ), - SystemTimeWarning, - ) - - sock_and_verified = _ssl_wrap_socket_and_match_hostname( - sock=sock, - cert_reqs=self.cert_reqs, - ssl_version=self.ssl_version, - ssl_minimum_version=self.ssl_minimum_version, - ssl_maximum_version=self.ssl_maximum_version, - ca_certs=self.ca_certs, - ca_cert_dir=self.ca_cert_dir, - ca_cert_data=self.ca_cert_data, - cert_file=self.cert_file, - key_file=self.key_file, - key_password=self.key_password, - server_hostname=server_hostname, - ssl_context=self.ssl_context, - tls_in_tls=tls_in_tls, - assert_hostname=self.assert_hostname, - assert_fingerprint=self.assert_fingerprint, - ) - self.sock = sock_and_verified.socket - self.is_verified = sock_and_verified.is_verified - - # If there's a proxy to be connected to we are fully connected. - # This is set twice (once above and here) due to forwarding proxies - # not using tunnelling. - self._has_connected_to_proxy = bool(self.proxy) - - def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket: - """ - Establish a TLS connection to the proxy using the provided SSL context. - """ - # `_connect_tls_proxy` is called when self._tunnel_host is truthy. - proxy_config = typing.cast(ProxyConfig, self.proxy_config) - ssl_context = proxy_config.ssl_context - sock_and_verified = _ssl_wrap_socket_and_match_hostname( - sock, - cert_reqs=self.cert_reqs, - ssl_version=self.ssl_version, - ssl_minimum_version=self.ssl_minimum_version, - ssl_maximum_version=self.ssl_maximum_version, - ca_certs=self.ca_certs, - ca_cert_dir=self.ca_cert_dir, - ca_cert_data=self.ca_cert_data, - server_hostname=hostname, - ssl_context=ssl_context, - assert_hostname=proxy_config.assert_hostname, - assert_fingerprint=proxy_config.assert_fingerprint, - # Features that aren't implemented for proxies yet: - cert_file=None, - key_file=None, - key_password=None, - tls_in_tls=False, - ) - self.proxy_is_verified = sock_and_verified.is_verified - return sock_and_verified.socket # type: ignore[return-value] - - -class _WrappedAndVerifiedSocket(typing.NamedTuple): - """ - Wrapped socket and whether the connection is - verified after the TLS handshake - """ - - socket: ssl.SSLSocket | SSLTransport - is_verified: bool - - -def _ssl_wrap_socket_and_match_hostname( - sock: socket.socket, - *, - cert_reqs: None | str | int, - ssl_version: None | str | int, - ssl_minimum_version: int | None, - ssl_maximum_version: int | None, - cert_file: str | None, - key_file: str | None, - key_password: str | None, - ca_certs: str | None, - ca_cert_dir: str | None, - ca_cert_data: None | str | bytes, - assert_hostname: None | str | Literal[False], - assert_fingerprint: str | None, - server_hostname: str | None, - ssl_context: ssl.SSLContext | None, - tls_in_tls: bool = False, -) -> _WrappedAndVerifiedSocket: - """Logic for constructing an SSLContext from all TLS parameters, passing - that down into ssl_wrap_socket, and then doing certificate verification - either via hostname or fingerprint. This function exists to guarantee - that both proxies and targets have the same behavior when connecting via TLS. - """ - default_ssl_context = False - if ssl_context is None: - default_ssl_context = True - context = create_urllib3_context( - ssl_version=resolve_ssl_version(ssl_version), - ssl_minimum_version=ssl_minimum_version, - ssl_maximum_version=ssl_maximum_version, - cert_reqs=resolve_cert_reqs(cert_reqs), - ) - else: - context = ssl_context - - context.verify_mode = resolve_cert_reqs(cert_reqs) - - # In some cases, we want to verify hostnames ourselves - if ( - # `ssl` can't verify fingerprints or alternate hostnames - assert_fingerprint - or assert_hostname - # assert_hostname can be set to False to disable hostname checking - or assert_hostname is False - # We still support OpenSSL 1.0.2, which prevents us from verifying - # hostnames easily: https://github.com/pyca/pyopenssl/pull/933 - or ssl_.IS_PYOPENSSL - or not ssl_.HAS_NEVER_CHECK_COMMON_NAME - ): - context.check_hostname = False - - # Try to load OS default certs if none are given. We need to do the hasattr() check - # for custom pyOpenSSL SSLContext objects because they don't support - # load_default_certs(). - if ( - not ca_certs - and not ca_cert_dir - and not ca_cert_data - and default_ssl_context - and hasattr(context, "load_default_certs") - ): - context.load_default_certs() - - # Ensure that IPv6 addresses are in the proper format and don't have a - # scope ID. Python's SSL module fails to recognize scoped IPv6 addresses - # and interprets them as DNS hostnames. - if server_hostname is not None: - normalized = server_hostname.strip("[]") - if "%" in normalized: - normalized = normalized[: normalized.rfind("%")] - if is_ipaddress(normalized): - server_hostname = normalized - - ssl_sock = ssl_wrap_socket( - sock=sock, - keyfile=key_file, - certfile=cert_file, - key_password=key_password, - ca_certs=ca_certs, - ca_cert_dir=ca_cert_dir, - ca_cert_data=ca_cert_data, - server_hostname=server_hostname, - ssl_context=context, - tls_in_tls=tls_in_tls, - ) - - try: - if assert_fingerprint: - _assert_fingerprint( - ssl_sock.getpeercert(binary_form=True), assert_fingerprint - ) - elif ( - context.verify_mode != ssl.CERT_NONE - and not context.check_hostname - and assert_hostname is not False - ): - cert: _TYPE_PEER_CERT_RET_DICT = ssl_sock.getpeercert() # type: ignore[assignment] - - # Need to signal to our match_hostname whether to use 'commonName' or not. - # If we're using our own constructed SSLContext we explicitly set 'False' - # because PyPy hard-codes 'True' from SSLContext.hostname_checks_common_name. - if default_ssl_context: - hostname_checks_common_name = False - else: - hostname_checks_common_name = ( - getattr(context, "hostname_checks_common_name", False) or False - ) - - _match_hostname( - cert, - assert_hostname or server_hostname, # type: ignore[arg-type] - hostname_checks_common_name, - ) - - return _WrappedAndVerifiedSocket( - socket=ssl_sock, - is_verified=context.verify_mode == ssl.CERT_REQUIRED - or bool(assert_fingerprint), - ) - except BaseException: - ssl_sock.close() - raise - - -def _match_hostname( - cert: _TYPE_PEER_CERT_RET_DICT | None, - asserted_hostname: str, - hostname_checks_common_name: bool = False, -) -> None: - # Our upstream implementation of ssl.match_hostname() - # only applies this normalization to IP addresses so it doesn't - # match DNS SANs so we do the same thing! - stripped_hostname = asserted_hostname.strip("[]") - if is_ipaddress(stripped_hostname): - asserted_hostname = stripped_hostname - - try: - match_hostname(cert, asserted_hostname, hostname_checks_common_name) - except CertificateError as e: - log.warning( - "Certificate did not match expected hostname: %s. Certificate: %s", - asserted_hostname, - cert, - ) - # Add cert to exception and reraise so client code can inspect - # the cert when catching the exception, if they want to - e._peer_cert = cert # type: ignore[attr-defined] - raise - - -def _wrap_proxy_error(err: Exception, proxy_scheme: str | None) -> ProxyError: - # Look for the phrase 'wrong version number', if found - # then we should warn the user that we're very sure that - # this proxy is HTTP-only and they have a configuration issue. - error_normalized = " ".join(re.split("[^a-z]", str(err).lower())) - is_likely_http_proxy = ( - "wrong version number" in error_normalized - or "unknown protocol" in error_normalized - ) - http_proxy_warning = ( - ". Your proxy appears to only use HTTP and not HTTPS, " - "try changing your proxy URL to be HTTP. See: " - "https://urllib3.readthedocs.io/en/latest/advanced-usage.html" - "#https-proxy-error-http-proxy" - ) - new_err = ProxyError( - f"Unable to connect to proxy" - f"{http_proxy_warning if is_likely_http_proxy and proxy_scheme == 'https' else ''}", - err, - ) - new_err.__cause__ = err - return new_err - - -def _get_default_user_agent() -> str: - return f"python-urllib3/{__version__}" - - -class DummyConnection: - """Used to detect a failed ConnectionCls import.""" - - -if not ssl: - HTTPSConnection = DummyConnection # type: ignore[misc, assignment] # noqa: F811 - - -VerifiedHTTPSConnection = HTTPSConnection - - -def _url_from_connection( - conn: HTTPConnection | HTTPSConnection, path: str | None = None -) -> str: - """Returns the URL from a given connection. This is mainly used for testing and logging.""" - - scheme = "https" if isinstance(conn, HTTPSConnection) else "http" - - return Url(scheme=scheme, host=conn.host, port=conn.port, path=path).url diff --git a/Modules/urllib3/connectionpool.py b/Modules/urllib3/connectionpool.py deleted file mode 100644 index 70048b7..0000000 --- a/Modules/urllib3/connectionpool.py +++ /dev/null @@ -1,1182 +0,0 @@ -from __future__ import annotations - -import errno -import logging -import queue -import sys -import typing -import warnings -import weakref -from socket import timeout as SocketTimeout -from types import TracebackType - -from ._base_connection import _TYPE_BODY -from ._collections import HTTPHeaderDict -from ._request_methods import RequestMethods -from .connection import ( - BaseSSLError, - BrokenPipeError, - DummyConnection, - HTTPConnection, - HTTPException, - HTTPSConnection, - ProxyConfig, - _wrap_proxy_error, -) -from .connection import port_by_scheme as port_by_scheme -from .exceptions import ( - ClosedPoolError, - EmptyPoolError, - FullPoolError, - HostChangedError, - InsecureRequestWarning, - LocationValueError, - MaxRetryError, - NewConnectionError, - ProtocolError, - ProxyError, - ReadTimeoutError, - SSLError, - TimeoutError, -) -from .response import BaseHTTPResponse -from .util.connection import is_connection_dropped -from .util.proxy import connection_requires_http_tunnel -from .util.request import _TYPE_BODY_POSITION, set_file_position -from .util.retry import Retry -from .util.ssl_match_hostname import CertificateError -from .util.timeout import _DEFAULT_TIMEOUT, _TYPE_DEFAULT, Timeout -from .util.url import Url, _encode_target -from .util.url import _normalize_host as normalize_host -from .util.url import parse_url -from .util.util import to_str - -if typing.TYPE_CHECKING: - import ssl - from typing import Literal - - from ._base_connection import BaseHTTPConnection, BaseHTTPSConnection - -log = logging.getLogger(__name__) - -_TYPE_TIMEOUT = typing.Union[Timeout, float, _TYPE_DEFAULT, None] - -_SelfT = typing.TypeVar("_SelfT") - - -# Pool objects -class ConnectionPool: - """ - Base class for all connection pools, such as - :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`. - - .. note:: - ConnectionPool.urlopen() does not normalize or percent-encode target URIs - which is useful if your target server doesn't support percent-encoded - target URIs. - """ - - scheme: str | None = None - QueueCls = queue.LifoQueue - - def __init__(self, host: str, port: int | None = None) -> None: - if not host: - raise LocationValueError("No host specified.") - - self.host = _normalize_host(host, scheme=self.scheme) - self.port = port - - # This property uses 'normalize_host()' (not '_normalize_host()') - # to avoid removing square braces around IPv6 addresses. - # This value is sent to `HTTPConnection.set_tunnel()` if called - # because square braces are required for HTTP CONNECT tunneling. - self._tunnel_host = normalize_host(host, scheme=self.scheme).lower() - - def __str__(self) -> str: - return f"{type(self).__name__}(host={self.host!r}, port={self.port!r})" - - def __enter__(self: _SelfT) -> _SelfT: - return self - - def __exit__( - self, - exc_type: type[BaseException] | None, - exc_val: BaseException | None, - exc_tb: TracebackType | None, - ) -> Literal[False]: - self.close() - # Return False to re-raise any potential exceptions - return False - - def close(self) -> None: - """ - Close all pooled connections and disable the pool. - """ - - -# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252 -_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK} - - -class HTTPConnectionPool(ConnectionPool, RequestMethods): - """ - Thread-safe connection pool for one host. - - :param host: - Host used for this HTTP Connection (e.g. "localhost"), passed into - :class:`http.client.HTTPConnection`. - - :param port: - Port used for this HTTP Connection (None is equivalent to 80), passed - into :class:`http.client.HTTPConnection`. - - :param timeout: - Socket timeout in seconds for each individual connection. This can - be a float or integer, which sets the timeout for the HTTP request, - or an instance of :class:`urllib3.util.Timeout` which gives you more - fine-grained control over request timeouts. After the constructor has - been parsed, this is always a `urllib3.util.Timeout` object. - - :param maxsize: - Number of connections to save that can be reused. More than 1 is useful - in multithreaded situations. If ``block`` is set to False, more - connections will be created but they will not be saved once they've - been used. - - :param block: - If set to True, no more than ``maxsize`` connections will be used at - a time. When no free connections are available, the call will block - until a connection has been released. This is a useful side effect for - particular multithreaded situations where one does not want to use more - than maxsize connections per host to prevent flooding. - - :param headers: - Headers to include with all requests, unless other headers are given - explicitly. - - :param retries: - Retry configuration to use by default with requests in this pool. - - :param _proxy: - Parsed proxy URL, should not be used directly, instead, see - :class:`urllib3.ProxyManager` - - :param _proxy_headers: - A dictionary with proxy headers, should not be used directly, - instead, see :class:`urllib3.ProxyManager` - - :param \\**conn_kw: - Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`, - :class:`urllib3.connection.HTTPSConnection` instances. - """ - - scheme = "http" - ConnectionCls: ( - type[BaseHTTPConnection] | type[BaseHTTPSConnection] - ) = HTTPConnection - - def __init__( - self, - host: str, - port: int | None = None, - timeout: _TYPE_TIMEOUT | None = _DEFAULT_TIMEOUT, - maxsize: int = 1, - block: bool = False, - headers: typing.Mapping[str, str] | None = None, - retries: Retry | bool | int | None = None, - _proxy: Url | None = None, - _proxy_headers: typing.Mapping[str, str] | None = None, - _proxy_config: ProxyConfig | None = None, - **conn_kw: typing.Any, - ): - ConnectionPool.__init__(self, host, port) - RequestMethods.__init__(self, headers) - - if not isinstance(timeout, Timeout): - timeout = Timeout.from_float(timeout) - - if retries is None: - retries = Retry.DEFAULT - - self.timeout = timeout - self.retries = retries - - self.pool: queue.LifoQueue[typing.Any] | None = self.QueueCls(maxsize) - self.block = block - - self.proxy = _proxy - self.proxy_headers = _proxy_headers or {} - self.proxy_config = _proxy_config - - # Fill the queue up so that doing get() on it will block properly - for _ in range(maxsize): - self.pool.put(None) - - # These are mostly for testing and debugging purposes. - self.num_connections = 0 - self.num_requests = 0 - self.conn_kw = conn_kw - - if self.proxy: - # Enable Nagle's algorithm for proxies, to avoid packet fragmentation. - # We cannot know if the user has added default socket options, so we cannot replace the - # list. - self.conn_kw.setdefault("socket_options", []) - - self.conn_kw["proxy"] = self.proxy - self.conn_kw["proxy_config"] = self.proxy_config - - # Do not pass 'self' as callback to 'finalize'. - # Then the 'finalize' would keep an endless living (leak) to self. - # By just passing a reference to the pool allows the garbage collector - # to free self if nobody else has a reference to it. - pool = self.pool - - # Close all the HTTPConnections in the pool before the - # HTTPConnectionPool object is garbage collected. - weakref.finalize(self, _close_pool_connections, pool) - - def _new_conn(self) -> BaseHTTPConnection: - """ - Return a fresh :class:`HTTPConnection`. - """ - self.num_connections += 1 - log.debug( - "Starting new HTTP connection (%d): %s:%s", - self.num_connections, - self.host, - self.port or "80", - ) - - conn = self.ConnectionCls( - host=self.host, - port=self.port, - timeout=self.timeout.connect_timeout, - **self.conn_kw, - ) - return conn - - def _get_conn(self, timeout: float | None = None) -> BaseHTTPConnection: - """ - Get a connection. Will return a pooled connection if one is available. - - If no connections are available and :prop:`.block` is ``False``, then a - fresh connection is returned. - - :param timeout: - Seconds to wait before giving up and raising - :class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and - :prop:`.block` is ``True``. - """ - conn = None - - if self.pool is None: - raise ClosedPoolError(self, "Pool is closed.") - - try: - conn = self.pool.get(block=self.block, timeout=timeout) - - except AttributeError: # self.pool is None - raise ClosedPoolError(self, "Pool is closed.") from None # Defensive: - - except queue.Empty: - if self.block: - raise EmptyPoolError( - self, - "Pool is empty and a new connection can't be opened due to blocking mode.", - ) from None - pass # Oh well, we'll create a new connection then - - # If this is a persistent connection, check if it got disconnected - if conn and is_connection_dropped(conn): - log.debug("Resetting dropped connection: %s", self.host) - conn.close() - - return conn or self._new_conn() - - def _put_conn(self, conn: BaseHTTPConnection | None) -> None: - """ - Put a connection back into the pool. - - :param conn: - Connection object for the current host and port as returned by - :meth:`._new_conn` or :meth:`._get_conn`. - - If the pool is already full, the connection is closed and discarded - because we exceeded maxsize. If connections are discarded frequently, - then maxsize should be increased. - - If the pool is closed, then the connection will be closed and discarded. - """ - if self.pool is not None: - try: - self.pool.put(conn, block=False) - return # Everything is dandy, done. - except AttributeError: - # self.pool is None. - pass - except queue.Full: - # Connection never got put back into the pool, close it. - if conn: - conn.close() - - if self.block: - # This should never happen if you got the conn from self._get_conn - raise FullPoolError( - self, - "Pool reached maximum size and no more connections are allowed.", - ) from None - - log.warning( - "Connection pool is full, discarding connection: %s. Connection pool size: %s", - self.host, - self.pool.qsize(), - ) - - # Connection never got put back into the pool, close it. - if conn: - conn.close() - - def _validate_conn(self, conn: BaseHTTPConnection) -> None: - """ - Called right before a request is made, after the socket is created. - """ - - def _prepare_proxy(self, conn: BaseHTTPConnection) -> None: - # Nothing to do for HTTP connections. - pass - - def _get_timeout(self, timeout: _TYPE_TIMEOUT) -> Timeout: - """Helper that always returns a :class:`urllib3.util.Timeout`""" - if timeout is _DEFAULT_TIMEOUT: - return self.timeout.clone() - - if isinstance(timeout, Timeout): - return timeout.clone() - else: - # User passed us an int/float. This is for backwards compatibility, - # can be removed later - return Timeout.from_float(timeout) - - def _raise_timeout( - self, - err: BaseSSLError | OSError | SocketTimeout, - url: str, - timeout_value: _TYPE_TIMEOUT | None, - ) -> None: - """Is the error actually a timeout? Will raise a ReadTimeout or pass""" - - if isinstance(err, SocketTimeout): - raise ReadTimeoutError( - self, url, f"Read timed out. (read timeout={timeout_value})" - ) from err - - # See the above comment about EAGAIN in Python 3. - if hasattr(err, "errno") and err.errno in _blocking_errnos: - raise ReadTimeoutError( - self, url, f"Read timed out. (read timeout={timeout_value})" - ) from err - - def _make_request( - self, - conn: BaseHTTPConnection, - method: str, - url: str, - body: _TYPE_BODY | None = None, - headers: typing.Mapping[str, str] | None = None, - retries: Retry | None = None, - timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, - chunked: bool = False, - response_conn: BaseHTTPConnection | None = None, - preload_content: bool = True, - decode_content: bool = True, - enforce_content_length: bool = True, - ) -> BaseHTTPResponse: - """ - Perform a request on a given urllib connection object taken from our - pool. - - :param conn: - a connection from one of our connection pools - - :param method: - HTTP request method (such as GET, POST, PUT, etc.) - - :param url: - The URL to perform the request on. - - :param body: - Data to send in the request body, either :class:`str`, :class:`bytes`, - an iterable of :class:`str`/:class:`bytes`, or a file-like object. - - :param headers: - Dictionary of custom headers to send, such as User-Agent, - If-None-Match, etc. If None, pool headers are used. If provided, - these headers completely replace any pool-specific headers. - - :param retries: - Configure the number of retries to allow before raising a - :class:`~urllib3.exceptions.MaxRetryError` exception. - - Pass ``None`` to retry until you receive a response. Pass a - :class:`~urllib3.util.retry.Retry` object for fine-grained control - over different types of retries. - Pass an integer number to retry connection errors that many times, - but no other types of errors. Pass zero to never retry. - - If ``False``, then retries are disabled and any exception is raised - immediately. Also, instead of raising a MaxRetryError on redirects, - the redirect response will be returned. - - :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int. - - :param timeout: - If specified, overrides the default timeout for this one - request. It may be a float (in seconds) or an instance of - :class:`urllib3.util.Timeout`. - - :param chunked: - If True, urllib3 will send the body using chunked transfer - encoding. Otherwise, urllib3 will send the body using the standard - content-length form. Defaults to False. - - :param response_conn: - Set this to ``None`` if you will handle releasing the connection or - set the connection to have the response release it. - - :param preload_content: - If True, the response's body will be preloaded during construction. - - :param decode_content: - If True, will attempt to decode the body based on the - 'content-encoding' header. - - :param enforce_content_length: - Enforce content length checking. Body returned by server must match - value of Content-Length header, if present. Otherwise, raise error. - """ - self.num_requests += 1 - - timeout_obj = self._get_timeout(timeout) - timeout_obj.start_connect() - conn.timeout = Timeout.resolve_default_timeout(timeout_obj.connect_timeout) - - try: - # Trigger any extra validation we need to do. - try: - self._validate_conn(conn) - except (SocketTimeout, BaseSSLError) as e: - self._raise_timeout(err=e, url=url, timeout_value=conn.timeout) - raise - - # _validate_conn() starts the connection to an HTTPS proxy - # so we need to wrap errors with 'ProxyError' here too. - except ( - OSError, - NewConnectionError, - TimeoutError, - BaseSSLError, - CertificateError, - SSLError, - ) as e: - new_e: Exception = e - if isinstance(e, (BaseSSLError, CertificateError)): - new_e = SSLError(e) - # If the connection didn't successfully connect to it's proxy - # then there - if isinstance( - new_e, (OSError, NewConnectionError, TimeoutError, SSLError) - ) and (conn and conn.proxy and not conn.has_connected_to_proxy): - new_e = _wrap_proxy_error(new_e, conn.proxy.scheme) - raise new_e - - # conn.request() calls http.client.*.request, not the method in - # urllib3.request. It also calls makefile (recv) on the socket. - try: - conn.request( - method, - url, - body=body, - headers=headers, - chunked=chunked, - preload_content=preload_content, - decode_content=decode_content, - enforce_content_length=enforce_content_length, - ) - - # We are swallowing BrokenPipeError (errno.EPIPE) since the server is - # legitimately able to close the connection after sending a valid response. - # With this behaviour, the received response is still readable. - except BrokenPipeError: - pass - except OSError as e: - # MacOS/Linux - # EPROTOTYPE is needed on macOS - # https://erickt.github.io/blog/2014/11/19/adventures-in-debugging-a-potential-osx-kernel-bug/ - if e.errno != errno.EPROTOTYPE: - raise - - # Reset the timeout for the recv() on the socket - read_timeout = timeout_obj.read_timeout - - if not conn.is_closed: - # In Python 3 socket.py will catch EAGAIN and return None when you - # try and read into the file pointer created by http.client, which - # instead raises a BadStatusLine exception. Instead of catching - # the exception and assuming all BadStatusLine exceptions are read - # timeouts, check for a zero timeout before making the request. - if read_timeout == 0: - raise ReadTimeoutError( - self, url, f"Read timed out. (read timeout={read_timeout})" - ) - conn.timeout = read_timeout - - # Receive the response from the server - try: - response = conn.getresponse() - except (BaseSSLError, OSError) as e: - self._raise_timeout(err=e, url=url, timeout_value=read_timeout) - raise - - # Set properties that are used by the pooling layer. - response.retries = retries - response._connection = response_conn # type: ignore[attr-defined] - response._pool = self # type: ignore[attr-defined] - - log.debug( - '%s://%s:%s "%s %s %s" %s %s', - self.scheme, - self.host, - self.port, - method, - url, - # HTTP version - conn._http_vsn_str, # type: ignore[attr-defined] - response.status, - response.length_remaining, # type: ignore[attr-defined] - ) - - return response - - def close(self) -> None: - """ - Close all pooled connections and disable the pool. - """ - if self.pool is None: - return - # Disable access to the pool - old_pool, self.pool = self.pool, None - - # Close all the HTTPConnections in the pool. - _close_pool_connections(old_pool) - - def is_same_host(self, url: str) -> bool: - """ - Check if the given ``url`` is a member of the same host as this - connection pool. - """ - if url.startswith("/"): - return True - - # TODO: Add optional support for socket.gethostbyname checking. - scheme, _, host, port, *_ = parse_url(url) - scheme = scheme or "http" - if host is not None: - host = _normalize_host(host, scheme=scheme) - - # Use explicit default port for comparison when none is given - if self.port and not port: - port = port_by_scheme.get(scheme) - elif not self.port and port == port_by_scheme.get(scheme): - port = None - - return (scheme, host, port) == (self.scheme, self.host, self.port) - - def urlopen( # type: ignore[override] - self, - method: str, - url: str, - body: _TYPE_BODY | None = None, - headers: typing.Mapping[str, str] | None = None, - retries: Retry | bool | int | None = None, - redirect: bool = True, - assert_same_host: bool = True, - timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, - pool_timeout: int | None = None, - release_conn: bool | None = None, - chunked: bool = False, - body_pos: _TYPE_BODY_POSITION | None = None, - preload_content: bool = True, - decode_content: bool = True, - **response_kw: typing.Any, - ) -> BaseHTTPResponse: - """ - Get a connection from the pool and perform an HTTP request. This is the - lowest level call for making a request, so you'll need to specify all - the raw details. - - .. note:: - - More commonly, it's appropriate to use a convenience method - such as :meth:`request`. - - .. note:: - - `release_conn` will only behave as expected if - `preload_content=False` because we want to make - `preload_content=False` the default behaviour someday soon without - breaking backwards compatibility. - - :param method: - HTTP request method (such as GET, POST, PUT, etc.) - - :param url: - The URL to perform the request on. - - :param body: - Data to send in the request body, either :class:`str`, :class:`bytes`, - an iterable of :class:`str`/:class:`bytes`, or a file-like object. - - :param headers: - Dictionary of custom headers to send, such as User-Agent, - If-None-Match, etc. If None, pool headers are used. If provided, - these headers completely replace any pool-specific headers. - - :param retries: - Configure the number of retries to allow before raising a - :class:`~urllib3.exceptions.MaxRetryError` exception. - - Pass ``None`` to retry until you receive a response. Pass a - :class:`~urllib3.util.retry.Retry` object for fine-grained control - over different types of retries. - Pass an integer number to retry connection errors that many times, - but no other types of errors. Pass zero to never retry. - - If ``False``, then retries are disabled and any exception is raised - immediately. Also, instead of raising a MaxRetryError on redirects, - the redirect response will be returned. - - :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int. - - :param redirect: - If True, automatically handle redirects (status codes 301, 302, - 303, 307, 308). Each redirect counts as a retry. Disabling retries - will disable redirect, too. - - :param assert_same_host: - If ``True``, will make sure that the host of the pool requests is - consistent else will raise HostChangedError. When ``False``, you can - use the pool on an HTTP proxy and request foreign hosts. - - :param timeout: - If specified, overrides the default timeout for this one - request. It may be a float (in seconds) or an instance of - :class:`urllib3.util.Timeout`. - - :param pool_timeout: - If set and the pool is set to block=True, then this method will - block for ``pool_timeout`` seconds and raise EmptyPoolError if no - connection is available within the time period. - - :param bool preload_content: - If True, the response's body will be preloaded into memory. - - :param bool decode_content: - If True, will attempt to decode the body based on the - 'content-encoding' header. - - :param release_conn: - If False, then the urlopen call will not release the connection - back into the pool once a response is received (but will release if - you read the entire contents of the response such as when - `preload_content=True`). This is useful if you're not preloading - the response's content immediately. You will need to call - ``r.release_conn()`` on the response ``r`` to return the connection - back into the pool. If None, it takes the value of ``preload_content`` - which defaults to ``True``. - - :param bool chunked: - If True, urllib3 will send the body using chunked transfer - encoding. Otherwise, urllib3 will send the body using the standard - content-length form. Defaults to False. - - :param int body_pos: - Position to seek to in file-like body in the event of a retry or - redirect. Typically this won't need to be set because urllib3 will - auto-populate the value when needed. - """ - parsed_url = parse_url(url) - destination_scheme = parsed_url.scheme - - if headers is None: - headers = self.headers - - if not isinstance(retries, Retry): - retries = Retry.from_int(retries, redirect=redirect, default=self.retries) - - if release_conn is None: - release_conn = preload_content - - # Check host - if assert_same_host and not self.is_same_host(url): - raise HostChangedError(self, url, retries) - - # Ensure that the URL we're connecting to is properly encoded - if url.startswith("/"): - url = to_str(_encode_target(url)) - else: - url = to_str(parsed_url.url) - - conn = None - - # Track whether `conn` needs to be released before - # returning/raising/recursing. Update this variable if necessary, and - # leave `release_conn` constant throughout the function. That way, if - # the function recurses, the original value of `release_conn` will be - # passed down into the recursive call, and its value will be respected. - # - # See issue #651 [1] for details. - # - # [1] - release_this_conn = release_conn - - http_tunnel_required = connection_requires_http_tunnel( - self.proxy, self.proxy_config, destination_scheme - ) - - # Merge the proxy headers. Only done when not using HTTP CONNECT. We - # have to copy the headers dict so we can safely change it without those - # changes being reflected in anyone else's copy. - if not http_tunnel_required: - headers = headers.copy() # type: ignore[attr-defined] - headers.update(self.proxy_headers) # type: ignore[union-attr] - - # Must keep the exception bound to a separate variable or else Python 3 - # complains about UnboundLocalError. - err = None - - # Keep track of whether we cleanly exited the except block. This - # ensures we do proper cleanup in finally. - clean_exit = False - - # Rewind body position, if needed. Record current position - # for future rewinds in the event of a redirect/retry. - body_pos = set_file_position(body, body_pos) - - try: - # Request a connection from the queue. - timeout_obj = self._get_timeout(timeout) - conn = self._get_conn(timeout=pool_timeout) - - conn.timeout = timeout_obj.connect_timeout # type: ignore[assignment] - - # Is this a closed/new connection that requires CONNECT tunnelling? - if self.proxy is not None and http_tunnel_required and conn.is_closed: - try: - self._prepare_proxy(conn) - except (BaseSSLError, OSError, SocketTimeout) as e: - self._raise_timeout( - err=e, url=self.proxy.url, timeout_value=conn.timeout - ) - raise - - # If we're going to release the connection in ``finally:``, then - # the response doesn't need to know about the connection. Otherwise - # it will also try to release it and we'll have a double-release - # mess. - response_conn = conn if not release_conn else None - - # Make the request on the HTTPConnection object - response = self._make_request( - conn, - method, - url, - timeout=timeout_obj, - body=body, - headers=headers, - chunked=chunked, - retries=retries, - response_conn=response_conn, - preload_content=preload_content, - decode_content=decode_content, - **response_kw, - ) - - # Everything went great! - clean_exit = True - - except EmptyPoolError: - # Didn't get a connection from the pool, no need to clean up - clean_exit = True - release_this_conn = False - raise - - except ( - TimeoutError, - HTTPException, - OSError, - ProtocolError, - BaseSSLError, - SSLError, - CertificateError, - ProxyError, - ) as e: - # Discard the connection for these exceptions. It will be - # replaced during the next _get_conn() call. - clean_exit = False - new_e: Exception = e - if isinstance(e, (BaseSSLError, CertificateError)): - new_e = SSLError(e) - if isinstance( - new_e, - ( - OSError, - NewConnectionError, - TimeoutError, - SSLError, - HTTPException, - ), - ) and (conn and conn.proxy and not conn.has_connected_to_proxy): - new_e = _wrap_proxy_error(new_e, conn.proxy.scheme) - elif isinstance(new_e, (OSError, HTTPException)): - new_e = ProtocolError("Connection aborted.", new_e) - - retries = retries.increment( - method, url, error=new_e, _pool=self, _stacktrace=sys.exc_info()[2] - ) - retries.sleep() - - # Keep track of the error for the retry warning. - err = e - - finally: - if not clean_exit: - # We hit some kind of exception, handled or otherwise. We need - # to throw the connection away unless explicitly told not to. - # Close the connection, set the variable to None, and make sure - # we put the None back in the pool to avoid leaking it. - if conn: - conn.close() - conn = None - release_this_conn = True - - if release_this_conn: - # Put the connection back to be reused. If the connection is - # expired then it will be None, which will get replaced with a - # fresh connection during _get_conn. - self._put_conn(conn) - - if not conn: - # Try again - log.warning( - "Retrying (%r) after connection broken by '%r': %s", retries, err, url - ) - return self.urlopen( - method, - url, - body, - headers, - retries, - redirect, - assert_same_host, - timeout=timeout, - pool_timeout=pool_timeout, - release_conn=release_conn, - chunked=chunked, - body_pos=body_pos, - preload_content=preload_content, - decode_content=decode_content, - **response_kw, - ) - - # Handle redirect? - redirect_location = redirect and response.get_redirect_location() - if redirect_location: - if response.status == 303: - # Change the method according to RFC 9110, Section 15.4.4. - method = "GET" - # And lose the body not to transfer anything sensitive. - body = None - headers = HTTPHeaderDict(headers)._prepare_for_method_change() - - try: - retries = retries.increment(method, url, response=response, _pool=self) - except MaxRetryError: - if retries.raise_on_redirect: - response.drain_conn() - raise - return response - - response.drain_conn() - retries.sleep_for_retry(response) - log.debug("Redirecting %s -> %s", url, redirect_location) - return self.urlopen( - method, - redirect_location, - body, - headers, - retries=retries, - redirect=redirect, - assert_same_host=assert_same_host, - timeout=timeout, - pool_timeout=pool_timeout, - release_conn=release_conn, - chunked=chunked, - body_pos=body_pos, - preload_content=preload_content, - decode_content=decode_content, - **response_kw, - ) - - # Check if we should retry the HTTP response. - has_retry_after = bool(response.headers.get("Retry-After")) - if retries.is_retry(method, response.status, has_retry_after): - try: - retries = retries.increment(method, url, response=response, _pool=self) - except MaxRetryError: - if retries.raise_on_status: - response.drain_conn() - raise - return response - - response.drain_conn() - retries.sleep(response) - log.debug("Retry: %s", url) - return self.urlopen( - method, - url, - body, - headers, - retries=retries, - redirect=redirect, - assert_same_host=assert_same_host, - timeout=timeout, - pool_timeout=pool_timeout, - release_conn=release_conn, - chunked=chunked, - body_pos=body_pos, - preload_content=preload_content, - decode_content=decode_content, - **response_kw, - ) - - return response - - -class HTTPSConnectionPool(HTTPConnectionPool): - """ - Same as :class:`.HTTPConnectionPool`, but HTTPS. - - :class:`.HTTPSConnection` uses one of ``assert_fingerprint``, - ``assert_hostname`` and ``host`` in this order to verify connections. - If ``assert_hostname`` is False, no verification is done. - - The ``key_file``, ``cert_file``, ``cert_reqs``, ``ca_certs``, - ``ca_cert_dir``, ``ssl_version``, ``key_password`` are only used if :mod:`ssl` - is available and are fed into :meth:`urllib3.util.ssl_wrap_socket` to upgrade - the connection socket into an SSL socket. - """ - - scheme = "https" - ConnectionCls: type[BaseHTTPSConnection] = HTTPSConnection - - def __init__( - self, - host: str, - port: int | None = None, - timeout: _TYPE_TIMEOUT | None = _DEFAULT_TIMEOUT, - maxsize: int = 1, - block: bool = False, - headers: typing.Mapping[str, str] | None = None, - retries: Retry | bool | int | None = None, - _proxy: Url | None = None, - _proxy_headers: typing.Mapping[str, str] | None = None, - key_file: str | None = None, - cert_file: str | None = None, - cert_reqs: int | str | None = None, - key_password: str | None = None, - ca_certs: str | None = None, - ssl_version: int | str | None = None, - ssl_minimum_version: ssl.TLSVersion | None = None, - ssl_maximum_version: ssl.TLSVersion | None = None, - assert_hostname: str | Literal[False] | None = None, - assert_fingerprint: str | None = None, - ca_cert_dir: str | None = None, - **conn_kw: typing.Any, - ) -> None: - super().__init__( - host, - port, - timeout, - maxsize, - block, - headers, - retries, - _proxy, - _proxy_headers, - **conn_kw, - ) - - self.key_file = key_file - self.cert_file = cert_file - self.cert_reqs = cert_reqs - self.key_password = key_password - self.ca_certs = ca_certs - self.ca_cert_dir = ca_cert_dir - self.ssl_version = ssl_version - self.ssl_minimum_version = ssl_minimum_version - self.ssl_maximum_version = ssl_maximum_version - self.assert_hostname = assert_hostname - self.assert_fingerprint = assert_fingerprint - - def _prepare_proxy(self, conn: HTTPSConnection) -> None: # type: ignore[override] - """Establishes a tunnel connection through HTTP CONNECT.""" - if self.proxy and self.proxy.scheme == "https": - tunnel_scheme = "https" - else: - tunnel_scheme = "http" - - conn.set_tunnel( - scheme=tunnel_scheme, - host=self._tunnel_host, - port=self.port, - headers=self.proxy_headers, - ) - conn.connect() - - def _new_conn(self) -> BaseHTTPSConnection: - """ - Return a fresh :class:`urllib3.connection.HTTPConnection`. - """ - self.num_connections += 1 - log.debug( - "Starting new HTTPS connection (%d): %s:%s", - self.num_connections, - self.host, - self.port or "443", - ) - - if not self.ConnectionCls or self.ConnectionCls is DummyConnection: # type: ignore[comparison-overlap] - raise ImportError( - "Can't connect to HTTPS URL because the SSL module is not available." - ) - - actual_host: str = self.host - actual_port = self.port - if self.proxy is not None and self.proxy.host is not None: - actual_host = self.proxy.host - actual_port = self.proxy.port - - return self.ConnectionCls( - host=actual_host, - port=actual_port, - timeout=self.timeout.connect_timeout, - cert_file=self.cert_file, - key_file=self.key_file, - key_password=self.key_password, - cert_reqs=self.cert_reqs, - ca_certs=self.ca_certs, - ca_cert_dir=self.ca_cert_dir, - assert_hostname=self.assert_hostname, - assert_fingerprint=self.assert_fingerprint, - ssl_version=self.ssl_version, - ssl_minimum_version=self.ssl_minimum_version, - ssl_maximum_version=self.ssl_maximum_version, - **self.conn_kw, - ) - - def _validate_conn(self, conn: BaseHTTPConnection) -> None: - """ - Called right before a request is made, after the socket is created. - """ - super()._validate_conn(conn) - - # Force connect early to allow us to validate the connection. - if conn.is_closed: - conn.connect() - - if not conn.is_verified: - warnings.warn( - ( - f"Unverified HTTPS request is being made to host '{conn.host}'. " - "Adding certificate verification is strongly advised. See: " - "https://urllib3.readthedocs.io/en/latest/advanced-usage.html" - "#tls-warnings" - ), - InsecureRequestWarning, - ) - - -def connection_from_url(url: str, **kw: typing.Any) -> HTTPConnectionPool: - """ - Given a url, return an :class:`.ConnectionPool` instance of its host. - - This is a shortcut for not having to parse out the scheme, host, and port - of the url before creating an :class:`.ConnectionPool` instance. - - :param url: - Absolute URL string that must include the scheme. Port is optional. - - :param \\**kw: - Passes additional parameters to the constructor of the appropriate - :class:`.ConnectionPool`. Useful for specifying things like - timeout, maxsize, headers, etc. - - Example:: - - >>> conn = connection_from_url('http://google.com/') - >>> r = conn.request('GET', '/') - """ - scheme, _, host, port, *_ = parse_url(url) - scheme = scheme or "http" - port = port or port_by_scheme.get(scheme, 80) - if scheme == "https": - return HTTPSConnectionPool(host, port=port, **kw) # type: ignore[arg-type] - else: - return HTTPConnectionPool(host, port=port, **kw) # type: ignore[arg-type] - - -@typing.overload -def _normalize_host(host: None, scheme: str | None) -> None: - ... - - -@typing.overload -def _normalize_host(host: str, scheme: str | None) -> str: - ... - - -def _normalize_host(host: str | None, scheme: str | None) -> str | None: - """ - Normalize hosts for comparisons and use with sockets. - """ - - host = normalize_host(host, scheme) - - # httplib doesn't like it when we include brackets in IPv6 addresses - # Specifically, if we include brackets but also pass the port then - # httplib crazily doubles up the square brackets on the Host header. - # Instead, we need to make sure we never pass ``None`` as the port. - # However, for backward compatibility reasons we can't actually - # *assert* that. See http://bugs.python.org/issue28539 - if host and host.startswith("[") and host.endswith("]"): - host = host[1:-1] - return host - - -def _url_from_pool( - pool: HTTPConnectionPool | HTTPSConnectionPool, path: str | None = None -) -> str: - """Returns the URL from a given connection pool. This is mainly used for testing and logging.""" - return Url(scheme=pool.scheme, host=pool.host, port=pool.port, path=path).url - - -def _close_pool_connections(pool: queue.LifoQueue[typing.Any]) -> None: - """Drains a queue of connections and closes each one.""" - try: - while True: - conn = pool.get(block=False) - if conn: - conn.close() - except queue.Empty: - pass # Done. diff --git a/Modules/urllib3/contrib/__init__.py b/Modules/urllib3/contrib/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/Modules/urllib3/contrib/__pycache__/__init__.cpython-311.pyc b/Modules/urllib3/contrib/__pycache__/__init__.cpython-311.pyc deleted file mode 100644 index 2b6009f62ce5fb8e849c024ea44340899924f1ba..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 168 zcmZ3^%ge<81cf3&sUZ3>h=2h`DC095kTIPhg&~+hlhJP_LlF~@{~09t%UVApKQ~oB zB{ex)UoSa7FD)}&zqqovBsDihzqB~DNWZiwCnqz>SRW`?Qk0pbA0MBYmst`YuUAm{ li^C>2KczG$)vkyYXcow}Vtyd;ftit!@dE>lC}IYR0RYw=CsqIe diff --git a/Modules/urllib3/contrib/__pycache__/socks.cpython-311.pyc b/Modules/urllib3/contrib/__pycache__/socks.cpython-311.pyc deleted file mode 100644 index f9e7cc59ef935fbef9e5084d0a943c2c36a1ab78..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8724 zcmb_CS!^3emeuU$EsEkHiMp(gb=b5eD)BK%G`1&-kJw2pE0&$a%mx(AZdtUOO}V;d zSpqfDWDKk_@b2bg77;KWz`$lbS!95jkNsHeSCZKQ_G3RNkANW>Fd$$tANiwU8wmWh z?^Pc>B&{)v?QT9*)vM#xd#~P6_HRO=0DuvB(#q++uUilBuH+>Q}Cv}9B~oZecfkID|uw^0~aA* z!_QiQd`cF{ZT<>b*O@l|UhwZh<)k$)|)0t?AZ6I2~qnztUESq$7oBI?Cz+ zSSyx}72@eQs|S_#LPxrTm0Og~LL!}TDDFyksUeGEH}v4sT~~-I)KL&p{DtmxH&Xr< zky`H%DJ*wC;DKiNnNPZh;o1Nfkz1Q^y$lxxTuknj!w&=)2|sIOAH&80+b&0%M($y_ z4#0KF(I#9!!zBRMC3iI8M2Vj!$?oiDZbAZ==JJ|YC`t>8Ear-;p3SS8I8TeW@>;&A zW))Fen4d3FU7Rgaar(l^ccu}0J1=YEEG-tq#k@Y3R|5-FQSw(0r^NdCtf87Y?#PJs zcS78sRYm!>E~~hPSe&&G$q_NDN&&XYQJAVI%4+s15SG_rwFNb&Gm`T9(ugR-x-u1k zT0N^M;?&Y~F?T}~fk?Xv=+Xk#&X7tG28c5=8upu+!S!i26#xdv*1qzEc||VBzyn;z z-nhob%`U(qG^<{dkz8xH;;fw27pSbI#B;isRkUKj*)lFRTU3S)aa7I~ z3&3khmPEZME@+Nu7C0SgYlT|z$stgJU!h~hA zFjWDLiikV_C1Tq>Qd608Q@4&V&eV0&OxZZxIWkc@11XbXM{D|nGmMA;f5Z+&{dyWK z_`yyzSyV8VupQ3K0Arb)fIE1Kt>cC?G_WqPmq4vQ}Ed8tPG5|8%wo4Ge_FdW>8nY*1@?C(zs-Dkfbs2bL84pJ6U%6eT z&TPA=DksK|*~>KT{d+X{NzMpnRX8im0%?=qquYbV$SHXq&x)E``XEbHP{QT!%oAo? zXHZ4kD4|&Lp!aP5mN7If8t|kzk8*@VF4;4JB_9{Hc{!J#h3zT|*jCG!rbO`!oWep8 z4pd%+lU-objDR-C;+(F}YhV#@(R%jMrKywFDJ!Z*80*uu2IvxP>@rm>Dn_iS8#Y4Mm^JW{ zIsa)&i`0lt%8RuLSsQX3hn&x<*=sU|s((I9H5sijRxT~g%hIWQPS2SR*@Tv7=bpR^ z^)HA_(i}uQuFDY7$h_n_2CWhgCBZ4Vos!2Xd0EK^{rs#H0IwW0Vwp=(mG=?kN+F>if7~4T=eu+k4I0NUQpj`&ATK86jjxzf;gpP{PU1r~g z(A`*0lm+}YghYiE>~ibs+pBN?41TL`Q_)^$XZei)`fuwbC~;|CYFQ(*oaDdLk`|

iDA$=ng}2R(=;-pXge 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 diff --git a/Modules/urllib3/contrib/pyopenssl.py b/Modules/urllib3/contrib/pyopenssl.py deleted file mode 100644 index 3987d63..0000000 --- a/Modules/urllib3/contrib/pyopenssl.py +++ /dev/null @@ -1,548 +0,0 @@ -""" -Module for using pyOpenSSL as a TLS backend. This module was relevant before -the standard library ``ssl`` module supported SNI, but now that we've dropped -support for Python 2.7 all relevant Python versions support SNI so -**this module is no longer recommended**. - -This needs the following packages installed: - -* `pyOpenSSL`_ (tested with 16.0.0) -* `cryptography`_ (minimum 1.3.4, from pyopenssl) -* `idna`_ (minimum 2.0) - -However, pyOpenSSL depends on cryptography, so while we use all three directly here we -end up having relatively few packages required. - -You can install them with the following command: - -.. code-block:: bash - - $ python -m pip install pyopenssl cryptography idna - -To activate certificate checking, call -:func:`~urllib3.contrib.pyopenssl.inject_into_urllib3` from your Python code -before you begin making HTTP requests. This can be done in a ``sitecustomize`` -module, or at any other time before your application begins using ``urllib3``, -like this: - -.. code-block:: python - - try: - import urllib3.contrib.pyopenssl - urllib3.contrib.pyopenssl.inject_into_urllib3() - except ImportError: - pass - -.. _pyopenssl: https://www.pyopenssl.org -.. _cryptography: https://cryptography.io -.. _idna: https://github.com/kjd/idna -""" - -from __future__ import annotations - -import OpenSSL.SSL # type: ignore[import] -from cryptography import x509 - -try: - from cryptography.x509 import UnsupportedExtension # type: ignore[attr-defined] -except ImportError: - # UnsupportedExtension is gone in cryptography >= 2.1.0 - class UnsupportedExtension(Exception): # type: ignore[no-redef] - pass - - -import logging -import ssl -import typing -from io import BytesIO -from socket import socket as socket_cls -from socket import timeout - -from .. import util - -if typing.TYPE_CHECKING: - from OpenSSL.crypto import X509 # type: ignore[import] - - -__all__ = ["inject_into_urllib3", "extract_from_urllib3"] - -# Map from urllib3 to PyOpenSSL compatible parameter-values. -_openssl_versions = { - util.ssl_.PROTOCOL_TLS: OpenSSL.SSL.SSLv23_METHOD, # type: ignore[attr-defined] - util.ssl_.PROTOCOL_TLS_CLIENT: OpenSSL.SSL.SSLv23_METHOD, # type: ignore[attr-defined] - ssl.PROTOCOL_TLSv1: OpenSSL.SSL.TLSv1_METHOD, -} - -if hasattr(ssl, "PROTOCOL_TLSv1_1") and hasattr(OpenSSL.SSL, "TLSv1_1_METHOD"): - _openssl_versions[ssl.PROTOCOL_TLSv1_1] = OpenSSL.SSL.TLSv1_1_METHOD - -if hasattr(ssl, "PROTOCOL_TLSv1_2") and hasattr(OpenSSL.SSL, "TLSv1_2_METHOD"): - _openssl_versions[ssl.PROTOCOL_TLSv1_2] = OpenSSL.SSL.TLSv1_2_METHOD - - -_stdlib_to_openssl_verify = { - ssl.CERT_NONE: OpenSSL.SSL.VERIFY_NONE, - ssl.CERT_OPTIONAL: OpenSSL.SSL.VERIFY_PEER, - ssl.CERT_REQUIRED: OpenSSL.SSL.VERIFY_PEER - + OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT, -} -_openssl_to_stdlib_verify = {v: k for k, v in _stdlib_to_openssl_verify.items()} - -# The SSLvX values are the most likely to be missing in the future -# but we check them all just to be sure. -_OP_NO_SSLv2_OR_SSLv3: int = getattr(OpenSSL.SSL, "OP_NO_SSLv2", 0) | getattr( - OpenSSL.SSL, "OP_NO_SSLv3", 0 -) -_OP_NO_TLSv1: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1", 0) -_OP_NO_TLSv1_1: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1_1", 0) -_OP_NO_TLSv1_2: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1_2", 0) -_OP_NO_TLSv1_3: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1_3", 0) - -_openssl_to_ssl_minimum_version: dict[int, int] = { - ssl.TLSVersion.MINIMUM_SUPPORTED: _OP_NO_SSLv2_OR_SSLv3, - ssl.TLSVersion.TLSv1: _OP_NO_SSLv2_OR_SSLv3, - ssl.TLSVersion.TLSv1_1: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1, - ssl.TLSVersion.TLSv1_2: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1 | _OP_NO_TLSv1_1, - ssl.TLSVersion.TLSv1_3: ( - _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1 | _OP_NO_TLSv1_1 | _OP_NO_TLSv1_2 - ), - ssl.TLSVersion.MAXIMUM_SUPPORTED: ( - _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1 | _OP_NO_TLSv1_1 | _OP_NO_TLSv1_2 - ), -} -_openssl_to_ssl_maximum_version: dict[int, int] = { - ssl.TLSVersion.MINIMUM_SUPPORTED: ( - _OP_NO_SSLv2_OR_SSLv3 - | _OP_NO_TLSv1 - | _OP_NO_TLSv1_1 - | _OP_NO_TLSv1_2 - | _OP_NO_TLSv1_3 - ), - ssl.TLSVersion.TLSv1: ( - _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1_1 | _OP_NO_TLSv1_2 | _OP_NO_TLSv1_3 - ), - ssl.TLSVersion.TLSv1_1: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1_2 | _OP_NO_TLSv1_3, - ssl.TLSVersion.TLSv1_2: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1_3, - ssl.TLSVersion.TLSv1_3: _OP_NO_SSLv2_OR_SSLv3, - ssl.TLSVersion.MAXIMUM_SUPPORTED: _OP_NO_SSLv2_OR_SSLv3, -} - -# OpenSSL will only write 16K at a time -SSL_WRITE_BLOCKSIZE = 16384 - -orig_util_SSLContext = util.ssl_.SSLContext - - -log = logging.getLogger(__name__) - - -def inject_into_urllib3() -> None: - "Monkey-patch urllib3 with PyOpenSSL-backed SSL-support." - - _validate_dependencies_met() - - util.SSLContext = PyOpenSSLContext # type: ignore[assignment] - util.ssl_.SSLContext = PyOpenSSLContext # type: ignore[assignment] - util.IS_PYOPENSSL = True - util.ssl_.IS_PYOPENSSL = True - - -def extract_from_urllib3() -> None: - "Undo monkey-patching by :func:`inject_into_urllib3`." - - util.SSLContext = orig_util_SSLContext - util.ssl_.SSLContext = orig_util_SSLContext - util.IS_PYOPENSSL = False - util.ssl_.IS_PYOPENSSL = False - - -def _validate_dependencies_met() -> None: - """ - Verifies that PyOpenSSL's package-level dependencies have been met. - Throws `ImportError` if they are not met. - """ - # Method added in `cryptography==1.1`; not available in older versions - from cryptography.x509.extensions import Extensions - - if getattr(Extensions, "get_extension_for_class", None) is None: - raise ImportError( - "'cryptography' module missing required functionality. " - "Try upgrading to v1.3.4 or newer." - ) - - # pyOpenSSL 0.14 and above use cryptography for OpenSSL bindings. The _x509 - # attribute is only present on those versions. - from OpenSSL.crypto import X509 - - x509 = X509() - if getattr(x509, "_x509", None) is None: - raise ImportError( - "'pyOpenSSL' module missing required functionality. " - "Try upgrading to v0.14 or newer." - ) - - -def _dnsname_to_stdlib(name: str) -> str | None: - """ - Converts a dNSName SubjectAlternativeName field to the form used by the - standard library on the given Python version. - - Cryptography produces a dNSName as a unicode string that was idna-decoded - from ASCII bytes. We need to idna-encode that string to get it back, and - then on Python 3 we also need to convert to unicode via UTF-8 (the stdlib - uses PyUnicode_FromStringAndSize on it, which decodes via UTF-8). - - If the name cannot be idna-encoded then we return None signalling that - the name given should be skipped. - """ - - def idna_encode(name: str) -> bytes | None: - """ - Borrowed wholesale from the Python Cryptography Project. It turns out - that we can't just safely call `idna.encode`: it can explode for - wildcard names. This avoids that problem. - """ - import idna - - try: - for prefix in ["*.", "."]: - if name.startswith(prefix): - name = name[len(prefix) :] - return prefix.encode("ascii") + idna.encode(name) - return idna.encode(name) - except idna.core.IDNAError: - return None - - # Don't send IPv6 addresses through the IDNA encoder. - if ":" in name: - return name - - encoded_name = idna_encode(name) - if encoded_name is None: - return None - return encoded_name.decode("utf-8") - - -def get_subj_alt_name(peer_cert: X509) -> list[tuple[str, str]]: - """ - Given an PyOpenSSL certificate, provides all the subject alternative names. - """ - cert = peer_cert.to_cryptography() - - # We want to find the SAN extension. Ask Cryptography to locate it (it's - # faster than looping in Python) - try: - ext = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value - except x509.ExtensionNotFound: - # No such extension, return the empty list. - return [] - except ( - x509.DuplicateExtension, - UnsupportedExtension, - x509.UnsupportedGeneralNameType, - UnicodeError, - ) as e: - # A problem has been found with the quality of the certificate. Assume - # no SAN field is present. - log.warning( - "A problem was encountered with the certificate that prevented " - "urllib3 from finding the SubjectAlternativeName field. This can " - "affect certificate validation. The error was %s", - e, - ) - return [] - - # We want to return dNSName and iPAddress fields. We need to cast the IPs - # back to strings because the match_hostname function wants them as - # strings. - # Sadly the DNS names need to be idna encoded and then, on Python 3, UTF-8 - # decoded. This is pretty frustrating, but that's what the standard library - # does with certificates, and so we need to attempt to do the same. - # We also want to skip over names which cannot be idna encoded. - names = [ - ("DNS", name) - for name in map(_dnsname_to_stdlib, ext.get_values_for_type(x509.DNSName)) - if name is not None - ] - names.extend( - ("IP Address", str(name)) for name in ext.get_values_for_type(x509.IPAddress) - ) - - return names - - -class WrappedSocket: - """API-compatibility wrapper for Python OpenSSL's Connection-class.""" - - def __init__( - self, - connection: OpenSSL.SSL.Connection, - socket: socket_cls, - suppress_ragged_eofs: bool = True, - ) -> None: - self.connection = connection - self.socket = socket - self.suppress_ragged_eofs = suppress_ragged_eofs - self._io_refs = 0 - self._closed = False - - def fileno(self) -> int: - return self.socket.fileno() - - # Copy-pasted from Python 3.5 source code - def _decref_socketios(self) -> None: - if self._io_refs > 0: - self._io_refs -= 1 - if self._closed: - self.close() - - def recv(self, *args: typing.Any, **kwargs: typing.Any) -> bytes: - try: - data = self.connection.recv(*args, **kwargs) - except OpenSSL.SSL.SysCallError as e: - if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"): - return b"" - else: - raise OSError(e.args[0], str(e)) from e - except OpenSSL.SSL.ZeroReturnError: - if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN: - return b"" - else: - raise - except OpenSSL.SSL.WantReadError as e: - if not util.wait_for_read(self.socket, self.socket.gettimeout()): - raise timeout("The read operation timed out") from e - else: - return self.recv(*args, **kwargs) - - # TLS 1.3 post-handshake authentication - except OpenSSL.SSL.Error as e: - raise ssl.SSLError(f"read error: {e!r}") from e - else: - return data # type: ignore[no-any-return] - - def recv_into(self, *args: typing.Any, **kwargs: typing.Any) -> int: - try: - return self.connection.recv_into(*args, **kwargs) # type: ignore[no-any-return] - except OpenSSL.SSL.SysCallError as e: - if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"): - return 0 - else: - raise OSError(e.args[0], str(e)) from e - except OpenSSL.SSL.ZeroReturnError: - if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN: - return 0 - else: - raise - except OpenSSL.SSL.WantReadError as e: - if not util.wait_for_read(self.socket, self.socket.gettimeout()): - raise timeout("The read operation timed out") from e - else: - return self.recv_into(*args, **kwargs) - - # TLS 1.3 post-handshake authentication - except OpenSSL.SSL.Error as e: - raise ssl.SSLError(f"read error: {e!r}") from e - - def settimeout(self, timeout: float) -> None: - return self.socket.settimeout(timeout) - - def _send_until_done(self, data: bytes) -> int: - while True: - try: - return self.connection.send(data) # type: ignore[no-any-return] - except OpenSSL.SSL.WantWriteError as e: - if not util.wait_for_write(self.socket, self.socket.gettimeout()): - raise timeout() from e - continue - except OpenSSL.SSL.SysCallError as e: - raise OSError(e.args[0], str(e)) from e - - def sendall(self, data: bytes) -> None: - total_sent = 0 - while total_sent < len(data): - sent = self._send_until_done( - data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE] - ) - total_sent += sent - - def shutdown(self) -> None: - # FIXME rethrow compatible exceptions should we ever use this - self.connection.shutdown() - - def close(self) -> None: - self._closed = True - if self._io_refs <= 0: - self._real_close() - - def _real_close(self) -> None: - try: - return self.connection.close() # type: ignore[no-any-return] - except OpenSSL.SSL.Error: - return - - def getpeercert( - self, binary_form: bool = False - ) -> dict[str, list[typing.Any]] | None: - x509 = self.connection.get_peer_certificate() - - if not x509: - return x509 # type: ignore[no-any-return] - - if binary_form: - return OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, x509) # type: ignore[no-any-return] - - return { - "subject": ((("commonName", x509.get_subject().CN),),), # type: ignore[dict-item] - "subjectAltName": get_subj_alt_name(x509), - } - - def version(self) -> str: - return self.connection.get_protocol_version_name() # type: ignore[no-any-return] - - -WrappedSocket.makefile = socket_cls.makefile # type: ignore[attr-defined] - - -class PyOpenSSLContext: - """ - I am a wrapper class for the PyOpenSSL ``Context`` object. I am responsible - for translating the interface of the standard library ``SSLContext`` object - to calls into PyOpenSSL. - """ - - def __init__(self, protocol: int) -> None: - self.protocol = _openssl_versions[protocol] - self._ctx = OpenSSL.SSL.Context(self.protocol) - self._options = 0 - self.check_hostname = False - self._minimum_version: int = ssl.TLSVersion.MINIMUM_SUPPORTED - self._maximum_version: int = ssl.TLSVersion.MAXIMUM_SUPPORTED - - @property - def options(self) -> int: - return self._options - - @options.setter - def options(self, value: int) -> None: - self._options = value - self._set_ctx_options() - - @property - def verify_mode(self) -> int: - return _openssl_to_stdlib_verify[self._ctx.get_verify_mode()] - - @verify_mode.setter - def verify_mode(self, value: ssl.VerifyMode) -> None: - self._ctx.set_verify(_stdlib_to_openssl_verify[value], _verify_callback) - - def set_default_verify_paths(self) -> None: - self._ctx.set_default_verify_paths() - - def set_ciphers(self, ciphers: bytes | str) -> None: - if isinstance(ciphers, str): - ciphers = ciphers.encode("utf-8") - self._ctx.set_cipher_list(ciphers) - - def load_verify_locations( - self, - cafile: str | None = None, - capath: str | None = None, - cadata: bytes | None = None, - ) -> None: - if cafile is not None: - cafile = cafile.encode("utf-8") # type: ignore[assignment] - if capath is not None: - capath = capath.encode("utf-8") # type: ignore[assignment] - try: - self._ctx.load_verify_locations(cafile, capath) - if cadata is not None: - self._ctx.load_verify_locations(BytesIO(cadata)) - except OpenSSL.SSL.Error as e: - raise ssl.SSLError(f"unable to load trusted certificates: {e!r}") from e - - def load_cert_chain( - self, - certfile: str, - keyfile: str | None = None, - password: str | None = None, - ) -> None: - try: - self._ctx.use_certificate_chain_file(certfile) - if password is not None: - if not isinstance(password, bytes): - password = password.encode("utf-8") # type: ignore[assignment] - self._ctx.set_passwd_cb(lambda *_: password) - self._ctx.use_privatekey_file(keyfile or certfile) - except OpenSSL.SSL.Error as e: - raise ssl.SSLError(f"Unable to load certificate chain: {e!r}") from e - - def set_alpn_protocols(self, protocols: list[bytes | str]) -> None: - protocols = [util.util.to_bytes(p, "ascii") for p in protocols] - return self._ctx.set_alpn_protos(protocols) # type: ignore[no-any-return] - - def wrap_socket( - self, - sock: socket_cls, - server_side: bool = False, - do_handshake_on_connect: bool = True, - suppress_ragged_eofs: bool = True, - server_hostname: bytes | str | None = None, - ) -> WrappedSocket: - cnx = OpenSSL.SSL.Connection(self._ctx, sock) - - # If server_hostname is an IP, don't use it for SNI, per RFC6066 Section 3 - if server_hostname and not util.ssl_.is_ipaddress(server_hostname): - if isinstance(server_hostname, str): - server_hostname = server_hostname.encode("utf-8") - cnx.set_tlsext_host_name(server_hostname) - - cnx.set_connect_state() - - while True: - try: - cnx.do_handshake() - except OpenSSL.SSL.WantReadError as e: - if not util.wait_for_read(sock, sock.gettimeout()): - raise timeout("select timed out") from e - continue - except OpenSSL.SSL.Error as e: - raise ssl.SSLError(f"bad handshake: {e!r}") from e - break - - return WrappedSocket(cnx, sock) - - def _set_ctx_options(self) -> None: - self._ctx.set_options( - self._options - | _openssl_to_ssl_minimum_version[self._minimum_version] - | _openssl_to_ssl_maximum_version[self._maximum_version] - ) - - @property - def minimum_version(self) -> int: - return self._minimum_version - - @minimum_version.setter - def minimum_version(self, minimum_version: int) -> None: - self._minimum_version = minimum_version - self._set_ctx_options() - - @property - def maximum_version(self) -> int: - return self._maximum_version - - @maximum_version.setter - def maximum_version(self, maximum_version: int) -> None: - self._maximum_version = maximum_version - self._set_ctx_options() - - -def _verify_callback( - cnx: OpenSSL.SSL.Connection, - x509: X509, - err_no: int, - err_depth: int, - return_code: int, -) -> bool: - return err_no == 0 diff --git a/Modules/urllib3/contrib/socks.py b/Modules/urllib3/contrib/socks.py deleted file mode 100644 index 6c3bb76..0000000 --- a/Modules/urllib3/contrib/socks.py +++ /dev/null @@ -1,230 +0,0 @@ -""" -This module contains provisional support for SOCKS proxies from within -urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and -SOCKS5. To enable its functionality, either install PySocks or install this -module with the ``socks`` extra. - -The SOCKS implementation supports the full range of urllib3 features. It also -supports the following SOCKS features: - -- SOCKS4A (``proxy_url='socks4a://...``) -- SOCKS4 (``proxy_url='socks4://...``) -- SOCKS5 with remote DNS (``proxy_url='socks5h://...``) -- SOCKS5 with local DNS (``proxy_url='socks5://...``) -- Usernames and passwords for the SOCKS proxy - -.. note:: - It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in - your ``proxy_url`` to ensure that DNS resolution is done from the remote - server instead of client-side when connecting to a domain name. - -SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5 -supports IPv4, IPv6, and domain names. - -When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url`` -will be sent as the ``userid`` section of the SOCKS request: - -.. code-block:: python - - proxy_url="socks4a://@proxy-host" - -When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion -of the ``proxy_url`` will be sent as the username/password to authenticate -with the proxy: - -.. code-block:: python - - proxy_url="socks5h://:@proxy-host" - -""" - -from __future__ import annotations - -try: - import socks # type: ignore[import] -except ImportError: - import warnings - - from ..exceptions import DependencyWarning - - warnings.warn( - ( - "SOCKS support in urllib3 requires the installation of optional " - "dependencies: specifically, PySocks. For more information, see " - "https://urllib3.readthedocs.io/en/latest/contrib.html#socks-proxies" - ), - DependencyWarning, - ) - raise - -import typing -from socket import timeout as SocketTimeout - -from ..connection import HTTPConnection, HTTPSConnection -from ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool -from ..exceptions import ConnectTimeoutError, NewConnectionError -from ..poolmanager import PoolManager -from ..util.url import parse_url - -try: - import ssl -except ImportError: - ssl = None # type: ignore[assignment] - -from typing import TypedDict - - -class _TYPE_SOCKS_OPTIONS(TypedDict): - socks_version: int - proxy_host: str | None - proxy_port: str | None - username: str | None - password: str | None - rdns: bool - - -class SOCKSConnection(HTTPConnection): - """ - A plain-text HTTP connection that connects via a SOCKS proxy. - """ - - def __init__( - self, - _socks_options: _TYPE_SOCKS_OPTIONS, - *args: typing.Any, - **kwargs: typing.Any, - ) -> None: - self._socks_options = _socks_options - super().__init__(*args, **kwargs) - - def _new_conn(self) -> socks.socksocket: - """ - Establish a new connection via the SOCKS proxy. - """ - extra_kw: dict[str, typing.Any] = {} - if self.source_address: - extra_kw["source_address"] = self.source_address - - if self.socket_options: - extra_kw["socket_options"] = self.socket_options - - try: - conn = socks.create_connection( - (self.host, self.port), - proxy_type=self._socks_options["socks_version"], - proxy_addr=self._socks_options["proxy_host"], - proxy_port=self._socks_options["proxy_port"], - proxy_username=self._socks_options["username"], - proxy_password=self._socks_options["password"], - proxy_rdns=self._socks_options["rdns"], - timeout=self.timeout, - **extra_kw, - ) - - except SocketTimeout as e: - raise ConnectTimeoutError( - self, - f"Connection to {self.host} timed out. (connect timeout={self.timeout})", - ) from e - - except socks.ProxyError as e: - # This is fragile as hell, but it seems to be the only way to raise - # useful errors here. - if e.socket_err: - error = e.socket_err - if isinstance(error, SocketTimeout): - raise ConnectTimeoutError( - self, - f"Connection to {self.host} timed out. (connect timeout={self.timeout})", - ) from e - else: - # Adding `from e` messes with coverage somehow, so it's omitted. - # See #2386. - raise NewConnectionError( - self, f"Failed to establish a new connection: {error}" - ) - else: - raise NewConnectionError( - self, f"Failed to establish a new connection: {e}" - ) from e - - except OSError as e: # Defensive: PySocks should catch all these. - raise NewConnectionError( - self, f"Failed to establish a new connection: {e}" - ) from e - - return conn - - -# We don't need to duplicate the Verified/Unverified distinction from -# urllib3/connection.py here because the HTTPSConnection will already have been -# correctly set to either the Verified or Unverified form by that module. This -# means the SOCKSHTTPSConnection will automatically be the correct type. -class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection): - pass - - -class SOCKSHTTPConnectionPool(HTTPConnectionPool): - ConnectionCls = SOCKSConnection - - -class SOCKSHTTPSConnectionPool(HTTPSConnectionPool): - ConnectionCls = SOCKSHTTPSConnection - - -class SOCKSProxyManager(PoolManager): - """ - A version of the urllib3 ProxyManager that routes connections via the - defined SOCKS proxy. - """ - - pool_classes_by_scheme = { - "http": SOCKSHTTPConnectionPool, - "https": SOCKSHTTPSConnectionPool, - } - - def __init__( - self, - proxy_url: str, - username: str | None = None, - password: str | None = None, - num_pools: int = 10, - headers: typing.Mapping[str, str] | None = None, - **connection_pool_kw: typing.Any, - ): - parsed = parse_url(proxy_url) - - if username is None and password is None and parsed.auth is not None: - split = parsed.auth.split(":") - if len(split) == 2: - username, password = split - if parsed.scheme == "socks5": - socks_version = socks.PROXY_TYPE_SOCKS5 - rdns = False - elif parsed.scheme == "socks5h": - socks_version = socks.PROXY_TYPE_SOCKS5 - rdns = True - elif parsed.scheme == "socks4": - socks_version = socks.PROXY_TYPE_SOCKS4 - rdns = False - elif parsed.scheme == "socks4a": - socks_version = socks.PROXY_TYPE_SOCKS4 - rdns = True - else: - raise ValueError(f"Unable to determine SOCKS version from {proxy_url}") - - self.proxy_url = proxy_url - - socks_options = { - "socks_version": socks_version, - "proxy_host": parsed.host, - "proxy_port": parsed.port, - "username": username, - "password": password, - "rdns": rdns, - } - connection_pool_kw["_socks_options"] = socks_options - - super().__init__(num_pools, headers, **connection_pool_kw) - - self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme diff --git a/Modules/urllib3/exceptions.py b/Modules/urllib3/exceptions.py deleted file mode 100644 index 5bb9236..0000000 --- a/Modules/urllib3/exceptions.py +++ /dev/null @@ -1,318 +0,0 @@ -from __future__ import annotations - -import socket -import typing -import warnings -from email.errors import MessageDefect -from http.client import IncompleteRead as httplib_IncompleteRead - -if typing.TYPE_CHECKING: - from .connection import HTTPConnection - from .connectionpool import ConnectionPool - from .response import HTTPResponse - from .util.retry import Retry - -# Base Exceptions - - -class HTTPError(Exception): - """Base exception used by this module.""" - - -class HTTPWarning(Warning): - """Base warning used by this module.""" - - -_TYPE_REDUCE_RESULT = typing.Tuple[ - typing.Callable[..., object], typing.Tuple[object, ...] -] - - -class PoolError(HTTPError): - """Base exception for errors caused within a pool.""" - - def __init__(self, pool: ConnectionPool, message: str) -> None: - self.pool = pool - super().__init__(f"{pool}: {message}") - - def __reduce__(self) -> _TYPE_REDUCE_RESULT: - # For pickling purposes. - return self.__class__, (None, None) - - -class RequestError(PoolError): - """Base exception for PoolErrors that have associated URLs.""" - - def __init__(self, pool: ConnectionPool, url: str, message: str) -> None: - self.url = url - super().__init__(pool, message) - - def __reduce__(self) -> _TYPE_REDUCE_RESULT: - # For pickling purposes. - return self.__class__, (None, self.url, None) - - -class SSLError(HTTPError): - """Raised when SSL certificate fails in an HTTPS connection.""" - - -class ProxyError(HTTPError): - """Raised when the connection to a proxy fails.""" - - # The original error is also available as __cause__. - original_error: Exception - - def __init__(self, message: str, error: Exception) -> None: - super().__init__(message, error) - self.original_error = error - - -class DecodeError(HTTPError): - """Raised when automatic decoding based on Content-Type fails.""" - - -class ProtocolError(HTTPError): - """Raised when something unexpected happens mid-request/response.""" - - -#: Renamed to ProtocolError but aliased for backwards compatibility. -ConnectionError = ProtocolError - - -# Leaf Exceptions - - -class MaxRetryError(RequestError): - """Raised when the maximum number of retries is exceeded. - - :param pool: The connection pool - :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool` - :param str url: The requested Url - :param reason: The underlying error - :type reason: :class:`Exception` - - """ - - def __init__( - self, pool: ConnectionPool, url: str, reason: Exception | None = None - ) -> None: - self.reason = reason - - message = f"Max retries exceeded with url: {url} (Caused by {reason!r})" - - super().__init__(pool, url, message) - - -class HostChangedError(RequestError): - """Raised when an existing pool gets a request for a foreign host.""" - - def __init__( - self, pool: ConnectionPool, url: str, retries: Retry | int = 3 - ) -> None: - message = f"Tried to open a foreign host with url: {url}" - super().__init__(pool, url, message) - self.retries = retries - - -class TimeoutStateError(HTTPError): - """Raised when passing an invalid state to a timeout""" - - -class TimeoutError(HTTPError): - """Raised when a socket timeout error occurs. - - Catching this error will catch both :exc:`ReadTimeoutErrors - ` and :exc:`ConnectTimeoutErrors `. - """ - - -class ReadTimeoutError(TimeoutError, RequestError): - """Raised when a socket timeout occurs while receiving data from a server""" - - -# This timeout error does not have a URL attached and needs to inherit from the -# base HTTPError -class ConnectTimeoutError(TimeoutError): - """Raised when a socket timeout occurs while connecting to a server""" - - -class NewConnectionError(ConnectTimeoutError, HTTPError): - """Raised when we fail to establish a new connection. Usually ECONNREFUSED.""" - - def __init__(self, conn: HTTPConnection, message: str) -> None: - self.conn = conn - super().__init__(f"{conn}: {message}") - - @property - def pool(self) -> HTTPConnection: - warnings.warn( - "The 'pool' property is deprecated and will be removed " - "in urllib3 v2.1.0. Use 'conn' instead.", - DeprecationWarning, - stacklevel=2, - ) - - return self.conn - - -class NameResolutionError(NewConnectionError): - """Raised when host name resolution fails.""" - - def __init__(self, host: str, conn: HTTPConnection, reason: socket.gaierror): - message = f"Failed to resolve '{host}' ({reason})" - super().__init__(conn, message) - - -class EmptyPoolError(PoolError): - """Raised when a pool runs out of connections and no more are allowed.""" - - -class FullPoolError(PoolError): - """Raised when we try to add a connection to a full pool in blocking mode.""" - - -class ClosedPoolError(PoolError): - """Raised when a request enters a pool after the pool has been closed.""" - - -class LocationValueError(ValueError, HTTPError): - """Raised when there is something wrong with a given URL input.""" - - -class LocationParseError(LocationValueError): - """Raised when get_host or similar fails to parse the URL input.""" - - def __init__(self, location: str) -> None: - message = f"Failed to parse: {location}" - super().__init__(message) - - self.location = location - - -class URLSchemeUnknown(LocationValueError): - """Raised when a URL input has an unsupported scheme.""" - - def __init__(self, scheme: str): - message = f"Not supported URL scheme {scheme}" - super().__init__(message) - - self.scheme = scheme - - -class ResponseError(HTTPError): - """Used as a container for an error reason supplied in a MaxRetryError.""" - - GENERIC_ERROR = "too many error responses" - SPECIFIC_ERROR = "too many {status_code} error responses" - - -class SecurityWarning(HTTPWarning): - """Warned when performing security reducing actions""" - - -class InsecureRequestWarning(SecurityWarning): - """Warned when making an unverified HTTPS request.""" - - -class NotOpenSSLWarning(SecurityWarning): - """Warned when using unsupported SSL library""" - - -class SystemTimeWarning(SecurityWarning): - """Warned when system time is suspected to be wrong""" - - -class InsecurePlatformWarning(SecurityWarning): - """Warned when certain TLS/SSL configuration is not available on a platform.""" - - -class DependencyWarning(HTTPWarning): - """ - Warned when an attempt is made to import a module with missing optional - dependencies. - """ - - -class ResponseNotChunked(ProtocolError, ValueError): - """Response needs to be chunked in order to read it as chunks.""" - - -class BodyNotHttplibCompatible(HTTPError): - """ - Body should be :class:`http.client.HTTPResponse` like - (have an fp attribute which returns raw chunks) for read_chunked(). - """ - - -class IncompleteRead(HTTPError, httplib_IncompleteRead): - """ - Response length doesn't match expected Content-Length - - Subclass of :class:`http.client.IncompleteRead` to allow int value - for ``partial`` to avoid creating large objects on streamed reads. - """ - - def __init__(self, partial: int, expected: int) -> None: - self.partial = partial # type: ignore[assignment] - self.expected = expected - - def __repr__(self) -> str: - return "IncompleteRead(%i bytes read, %i more expected)" % ( - self.partial, # type: ignore[str-format] - self.expected, - ) - - -class InvalidChunkLength(HTTPError, httplib_IncompleteRead): - """Invalid chunk length in a chunked response.""" - - def __init__(self, response: HTTPResponse, length: bytes) -> None: - self.partial: int = response.tell() # type: ignore[assignment] - self.expected: int | None = response.length_remaining - self.response = response - self.length = length - - def __repr__(self) -> str: - return "InvalidChunkLength(got length %r, %i bytes read)" % ( - self.length, - self.partial, - ) - - -class InvalidHeader(HTTPError): - """The header provided was somehow invalid.""" - - -class ProxySchemeUnknown(AssertionError, URLSchemeUnknown): - """ProxyManager does not support the supplied scheme""" - - # TODO(t-8ch): Stop inheriting from AssertionError in v2.0. - - def __init__(self, scheme: str | None) -> None: - # 'localhost' is here because our URL parser parses - # localhost:8080 -> scheme=localhost, remove if we fix this. - if scheme == "localhost": - scheme = None - if scheme is None: - message = "Proxy URL had no scheme, should start with http:// or https://" - else: - message = f"Proxy URL had unsupported scheme {scheme}, should use http:// or https://" - super().__init__(message) - - -class ProxySchemeUnsupported(ValueError): - """Fetching HTTPS resources through HTTPS proxies is unsupported""" - - -class HeaderParsingError(HTTPError): - """Raised by assert_header_parsing, but we convert it to a log.warning statement.""" - - def __init__( - self, defects: list[MessageDefect], unparsed_data: bytes | str | None - ) -> None: - message = f"{defects or 'Unknown'}, unparsed data: {unparsed_data!r}" - super().__init__(message) - - -class UnrewindableBodyError(HTTPError): - """urllib3 encountered an error when trying to rewind a body""" diff --git a/Modules/urllib3/fields.py b/Modules/urllib3/fields.py deleted file mode 100644 index 51d898e..0000000 --- a/Modules/urllib3/fields.py +++ /dev/null @@ -1,345 +0,0 @@ -from __future__ import annotations - -import email.utils -import mimetypes -import typing - -_TYPE_FIELD_VALUE = typing.Union[str, bytes] -_TYPE_FIELD_VALUE_TUPLE = typing.Union[ - _TYPE_FIELD_VALUE, - typing.Tuple[str, _TYPE_FIELD_VALUE], - typing.Tuple[str, _TYPE_FIELD_VALUE, str], -] - - -def guess_content_type( - filename: str | None, default: str = "application/octet-stream" -) -> str: - """ - Guess the "Content-Type" of a file. - - :param filename: - The filename to guess the "Content-Type" of using :mod:`mimetypes`. - :param default: - If no "Content-Type" can be guessed, default to `default`. - """ - if filename: - return mimetypes.guess_type(filename)[0] or default - return default - - -def format_header_param_rfc2231(name: str, value: _TYPE_FIELD_VALUE) -> str: - """ - Helper function to format and quote a single header parameter using the - strategy defined in RFC 2231. - - Particularly useful for header parameters which might contain - non-ASCII values, like file names. This follows - `RFC 2388 Section 4.4 `_. - - :param name: - The name of the parameter, a string expected to be ASCII only. - :param value: - The value of the parameter, provided as ``bytes`` or `str``. - :returns: - An RFC-2231-formatted unicode string. - - .. deprecated:: 2.0.0 - Will be removed in urllib3 v2.1.0. This is not valid for - ``multipart/form-data`` header parameters. - """ - import warnings - - warnings.warn( - "'format_header_param_rfc2231' is deprecated and will be " - "removed in urllib3 v2.1.0. This is not valid for " - "multipart/form-data header parameters.", - DeprecationWarning, - stacklevel=2, - ) - - if isinstance(value, bytes): - value = value.decode("utf-8") - - if not any(ch in value for ch in '"\\\r\n'): - result = f'{name}="{value}"' - try: - result.encode("ascii") - except (UnicodeEncodeError, UnicodeDecodeError): - pass - else: - return result - - value = email.utils.encode_rfc2231(value, "utf-8") - value = f"{name}*={value}" - - return value - - -def format_multipart_header_param(name: str, value: _TYPE_FIELD_VALUE) -> str: - """ - Format and quote a single multipart header parameter. - - This follows the `WHATWG HTML Standard`_ as of 2021/06/10, matching - the behavior of current browser and curl versions. Values are - assumed to be UTF-8. The ``\\n``, ``\\r``, and ``"`` characters are - percent encoded. - - .. _WHATWG HTML Standard: - https://html.spec.whatwg.org/multipage/ - form-control-infrastructure.html#multipart-form-data - - :param name: - The name of the parameter, an ASCII-only ``str``. - :param value: - The value of the parameter, a ``str`` or UTF-8 encoded - ``bytes``. - :returns: - A string ``name="value"`` with the escaped value. - - .. versionchanged:: 2.0.0 - Matches the WHATWG HTML Standard as of 2021/06/10. Control - characters are no longer percent encoded. - - .. versionchanged:: 2.0.0 - Renamed from ``format_header_param_html5`` and - ``format_header_param``. The old names will be removed in - urllib3 v2.1.0. - """ - if isinstance(value, bytes): - value = value.decode("utf-8") - - # percent encode \n \r " - value = value.translate({10: "%0A", 13: "%0D", 34: "%22"}) - return f'{name}="{value}"' - - -def format_header_param_html5(name: str, value: _TYPE_FIELD_VALUE) -> str: - """ - .. deprecated:: 2.0.0 - Renamed to :func:`format_multipart_header_param`. Will be - removed in urllib3 v2.1.0. - """ - import warnings - - warnings.warn( - "'format_header_param_html5' has been renamed to " - "'format_multipart_header_param'. The old name will be " - "removed in urllib3 v2.1.0.", - DeprecationWarning, - stacklevel=2, - ) - return format_multipart_header_param(name, value) - - -def format_header_param(name: str, value: _TYPE_FIELD_VALUE) -> str: - """ - .. deprecated:: 2.0.0 - Renamed to :func:`format_multipart_header_param`. Will be - removed in urllib3 v2.1.0. - """ - import warnings - - warnings.warn( - "'format_header_param' has been renamed to " - "'format_multipart_header_param'. The old name will be " - "removed in urllib3 v2.1.0.", - DeprecationWarning, - stacklevel=2, - ) - return format_multipart_header_param(name, value) - - -class RequestField: - """ - A data container for request body parameters. - - :param name: - The name of this request field. Must be unicode. - :param data: - The data/value body. - :param filename: - An optional filename of the request field. Must be unicode. - :param headers: - An optional dict-like object of headers to initially use for the field. - - .. versionchanged:: 2.0.0 - The ``header_formatter`` parameter is deprecated and will - be removed in urllib3 v2.1.0. - """ - - def __init__( - self, - name: str, - data: _TYPE_FIELD_VALUE, - filename: str | None = None, - headers: typing.Mapping[str, str] | None = None, - header_formatter: typing.Callable[[str, _TYPE_FIELD_VALUE], str] | None = None, - ): - self._name = name - self._filename = filename - self.data = data - self.headers: dict[str, str | None] = {} - if headers: - self.headers = dict(headers) - - if header_formatter is not None: - import warnings - - warnings.warn( - "The 'header_formatter' parameter is deprecated and " - "will be removed in urllib3 v2.1.0.", - DeprecationWarning, - stacklevel=2, - ) - self.header_formatter = header_formatter - else: - self.header_formatter = format_multipart_header_param - - @classmethod - def from_tuples( - cls, - fieldname: str, - value: _TYPE_FIELD_VALUE_TUPLE, - header_formatter: typing.Callable[[str, _TYPE_FIELD_VALUE], str] | None = None, - ) -> RequestField: - """ - A :class:`~urllib3.fields.RequestField` factory from old-style tuple parameters. - - Supports constructing :class:`~urllib3.fields.RequestField` from - parameter of key/value strings AND key/filetuple. A filetuple is a - (filename, data, MIME type) tuple where the MIME type is optional. - For example:: - - 'foo': 'bar', - 'fakefile': ('foofile.txt', 'contents of foofile'), - 'realfile': ('barfile.txt', open('realfile').read()), - 'typedfile': ('bazfile.bin', open('bazfile').read(), 'image/jpeg'), - 'nonamefile': 'contents of nonamefile field', - - Field names and filenames must be unicode. - """ - filename: str | None - content_type: str | None - data: _TYPE_FIELD_VALUE - - if isinstance(value, tuple): - if len(value) == 3: - filename, data, content_type = typing.cast( - typing.Tuple[str, _TYPE_FIELD_VALUE, str], value - ) - else: - filename, data = typing.cast( - typing.Tuple[str, _TYPE_FIELD_VALUE], value - ) - content_type = guess_content_type(filename) - else: - filename = None - content_type = None - data = value - - request_param = cls( - fieldname, data, filename=filename, header_formatter=header_formatter - ) - request_param.make_multipart(content_type=content_type) - - return request_param - - def _render_part(self, name: str, value: _TYPE_FIELD_VALUE) -> str: - """ - Override this method to change how each multipart header - parameter is formatted. By default, this calls - :func:`format_multipart_header_param`. - - :param name: - The name of the parameter, an ASCII-only ``str``. - :param value: - The value of the parameter, a ``str`` or UTF-8 encoded - ``bytes``. - - :meta public: - """ - return self.header_formatter(name, value) - - def _render_parts( - self, - header_parts: ( - dict[str, _TYPE_FIELD_VALUE | None] - | typing.Sequence[tuple[str, _TYPE_FIELD_VALUE | None]] - ), - ) -> str: - """ - Helper function to format and quote a single header. - - Useful for single headers that are composed of multiple items. E.g., - 'Content-Disposition' fields. - - :param header_parts: - A sequence of (k, v) tuples or a :class:`dict` of (k, v) to format - as `k1="v1"; k2="v2"; ...`. - """ - iterable: typing.Iterable[tuple[str, _TYPE_FIELD_VALUE | None]] - - parts = [] - if isinstance(header_parts, dict): - iterable = header_parts.items() - else: - iterable = header_parts - - for name, value in iterable: - if value is not None: - parts.append(self._render_part(name, value)) - - return "; ".join(parts) - - def render_headers(self) -> str: - """ - Renders the headers for this request field. - """ - lines = [] - - sort_keys = ["Content-Disposition", "Content-Type", "Content-Location"] - for sort_key in sort_keys: - if self.headers.get(sort_key, False): - lines.append(f"{sort_key}: {self.headers[sort_key]}") - - for header_name, header_value in self.headers.items(): - if header_name not in sort_keys: - if header_value: - lines.append(f"{header_name}: {header_value}") - - lines.append("\r\n") - return "\r\n".join(lines) - - def make_multipart( - self, - content_disposition: str | None = None, - content_type: str | None = None, - content_location: str | None = None, - ) -> None: - """ - Makes this request field into a multipart request field. - - This method overrides "Content-Disposition", "Content-Type" and - "Content-Location" headers to the request parameter. - - :param content_disposition: - The 'Content-Disposition' of the request body. Defaults to 'form-data' - :param content_type: - The 'Content-Type' of the request body. - :param content_location: - The 'Content-Location' of the request body. - - """ - content_disposition = (content_disposition or "form-data") + "; ".join( - [ - "", - self._render_parts( - (("name", self._name), ("filename", self._filename)) - ), - ] - ) - - self.headers["Content-Disposition"] = content_disposition - self.headers["Content-Type"] = content_type - self.headers["Content-Location"] = content_location diff --git a/Modules/urllib3/filepost.py b/Modules/urllib3/filepost.py deleted file mode 100644 index 1c90a21..0000000 --- a/Modules/urllib3/filepost.py +++ /dev/null @@ -1,89 +0,0 @@ -from __future__ import annotations - -import binascii -import codecs -import os -import typing -from io import BytesIO - -from .fields import _TYPE_FIELD_VALUE_TUPLE, RequestField - -writer = codecs.lookup("utf-8")[3] - -_TYPE_FIELDS_SEQUENCE = typing.Sequence[ - typing.Union[typing.Tuple[str, _TYPE_FIELD_VALUE_TUPLE], RequestField] -] -_TYPE_FIELDS = typing.Union[ - _TYPE_FIELDS_SEQUENCE, - typing.Mapping[str, _TYPE_FIELD_VALUE_TUPLE], -] - - -def choose_boundary() -> str: - """ - Our embarrassingly-simple replacement for mimetools.choose_boundary. - """ - return binascii.hexlify(os.urandom(16)).decode() - - -def iter_field_objects(fields: _TYPE_FIELDS) -> typing.Iterable[RequestField]: - """ - Iterate over fields. - - Supports list of (k, v) tuples and dicts, and lists of - :class:`~urllib3.fields.RequestField`. - - """ - iterable: typing.Iterable[RequestField | tuple[str, _TYPE_FIELD_VALUE_TUPLE]] - - if isinstance(fields, typing.Mapping): - iterable = fields.items() - else: - iterable = fields - - for field in iterable: - if isinstance(field, RequestField): - yield field - else: - yield RequestField.from_tuples(*field) - - -def encode_multipart_formdata( - fields: _TYPE_FIELDS, boundary: str | None = None -) -> tuple[bytes, str]: - """ - Encode a dictionary of ``fields`` using the multipart/form-data MIME format. - - :param fields: - Dictionary of fields or list of (key, :class:`~urllib3.fields.RequestField`). - Values are processed by :func:`urllib3.fields.RequestField.from_tuples`. - - :param boundary: - If not specified, then a random boundary will be generated using - :func:`urllib3.filepost.choose_boundary`. - """ - body = BytesIO() - if boundary is None: - boundary = choose_boundary() - - for field in iter_field_objects(fields): - body.write(f"--{boundary}\r\n".encode("latin-1")) - - writer(body).write(field.render_headers()) - data = field.data - - if isinstance(data, int): - data = str(data) # Backwards compatibility - - if isinstance(data, str): - writer(body).write(data) - else: - body.write(data) - - body.write(b"\r\n") - - body.write(f"--{boundary}--\r\n".encode("latin-1")) - - content_type = f"multipart/form-data; boundary={boundary}" - - return body.getvalue(), content_type diff --git a/Modules/urllib3/poolmanager.py b/Modules/urllib3/poolmanager.py deleted file mode 100644 index 32da0a0..0000000 --- a/Modules/urllib3/poolmanager.py +++ /dev/null @@ -1,638 +0,0 @@ -from __future__ import annotations - -import functools -import logging -import typing -import warnings -from types import TracebackType -from urllib.parse import urljoin - -from ._collections import HTTPHeaderDict, RecentlyUsedContainer -from ._request_methods import RequestMethods -from .connection import ProxyConfig -from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, port_by_scheme -from .exceptions import ( - LocationValueError, - MaxRetryError, - ProxySchemeUnknown, - URLSchemeUnknown, -) -from .response import BaseHTTPResponse -from .util.connection import _TYPE_SOCKET_OPTIONS -from .util.proxy import connection_requires_http_tunnel -from .util.retry import Retry -from .util.timeout import Timeout -from .util.url import Url, parse_url - -if typing.TYPE_CHECKING: - import ssl - from typing import Literal - -__all__ = ["PoolManager", "ProxyManager", "proxy_from_url"] - - -log = logging.getLogger(__name__) - -SSL_KEYWORDS = ( - "key_file", - "cert_file", - "cert_reqs", - "ca_certs", - "ca_cert_data", - "ssl_version", - "ssl_minimum_version", - "ssl_maximum_version", - "ca_cert_dir", - "ssl_context", - "key_password", - "server_hostname", -) -# Default value for `blocksize` - a new parameter introduced to -# http.client.HTTPConnection & http.client.HTTPSConnection in Python 3.7 -_DEFAULT_BLOCKSIZE = 16384 - -_SelfT = typing.TypeVar("_SelfT") - - -class PoolKey(typing.NamedTuple): - """ - All known keyword arguments that could be provided to the pool manager, its - pools, or the underlying connections. - - All custom key schemes should include the fields in this key at a minimum. - """ - - key_scheme: str - key_host: str - key_port: int | None - key_timeout: Timeout | float | int | None - key_retries: Retry | bool | int | None - key_block: bool | None - key_source_address: tuple[str, int] | None - key_key_file: str | None - key_key_password: str | None - key_cert_file: str | None - key_cert_reqs: str | None - key_ca_certs: str | None - key_ca_cert_data: str | bytes | None - key_ssl_version: int | str | None - key_ssl_minimum_version: ssl.TLSVersion | None - key_ssl_maximum_version: ssl.TLSVersion | None - key_ca_cert_dir: str | None - key_ssl_context: ssl.SSLContext | None - key_maxsize: int | None - key_headers: frozenset[tuple[str, str]] | None - key__proxy: Url | None - key__proxy_headers: frozenset[tuple[str, str]] | None - key__proxy_config: ProxyConfig | None - key_socket_options: _TYPE_SOCKET_OPTIONS | None - key__socks_options: frozenset[tuple[str, str]] | None - key_assert_hostname: bool | str | None - key_assert_fingerprint: str | None - key_server_hostname: str | None - key_blocksize: int | None - - -def _default_key_normalizer( - key_class: type[PoolKey], request_context: dict[str, typing.Any] -) -> PoolKey: - """ - Create a pool key out of a request context dictionary. - - According to RFC 3986, both the scheme and host are case-insensitive. - Therefore, this function normalizes both before constructing the pool - key for an HTTPS request. If you wish to change this behaviour, provide - alternate callables to ``key_fn_by_scheme``. - - :param key_class: - The class to use when constructing the key. This should be a namedtuple - with the ``scheme`` and ``host`` keys at a minimum. - :type key_class: namedtuple - :param request_context: - A dictionary-like object that contain the context for a request. - :type request_context: dict - - :return: A namedtuple that can be used as a connection pool key. - :rtype: PoolKey - """ - # Since we mutate the dictionary, make a copy first - context = request_context.copy() - context["scheme"] = context["scheme"].lower() - context["host"] = context["host"].lower() - - # These are both dictionaries and need to be transformed into frozensets - for key in ("headers", "_proxy_headers", "_socks_options"): - if key in context and context[key] is not None: - context[key] = frozenset(context[key].items()) - - # The socket_options key may be a list and needs to be transformed into a - # tuple. - socket_opts = context.get("socket_options") - if socket_opts is not None: - context["socket_options"] = tuple(socket_opts) - - # Map the kwargs to the names in the namedtuple - this is necessary since - # namedtuples can't have fields starting with '_'. - for key in list(context.keys()): - context["key_" + key] = context.pop(key) - - # Default to ``None`` for keys missing from the context - for field in key_class._fields: - if field not in context: - context[field] = None - - # Default key_blocksize to _DEFAULT_BLOCKSIZE if missing from the context - if context.get("key_blocksize") is None: - context["key_blocksize"] = _DEFAULT_BLOCKSIZE - - return key_class(**context) - - -#: A dictionary that maps a scheme to a callable that creates a pool key. -#: This can be used to alter the way pool keys are constructed, if desired. -#: Each PoolManager makes a copy of this dictionary so they can be configured -#: globally here, or individually on the instance. -key_fn_by_scheme = { - "http": functools.partial(_default_key_normalizer, PoolKey), - "https": functools.partial(_default_key_normalizer, PoolKey), -} - -pool_classes_by_scheme = {"http": HTTPConnectionPool, "https": HTTPSConnectionPool} - - -class PoolManager(RequestMethods): - """ - Allows for arbitrary requests while transparently keeping track of - necessary connection pools for you. - - :param num_pools: - Number of connection pools to cache before discarding the least - recently used pool. - - :param headers: - Headers to include with all requests, unless other headers are given - explicitly. - - :param \\**connection_pool_kw: - Additional parameters are used to create fresh - :class:`urllib3.connectionpool.ConnectionPool` instances. - - Example: - - .. code-block:: python - - import urllib3 - - http = urllib3.PoolManager(num_pools=2) - - resp1 = http.request("GET", "https://google.com/") - resp2 = http.request("GET", "https://google.com/mail") - resp3 = http.request("GET", "https://yahoo.com/") - - print(len(http.pools)) - # 2 - - """ - - proxy: Url | None = None - proxy_config: ProxyConfig | None = None - - def __init__( - self, - num_pools: int = 10, - headers: typing.Mapping[str, str] | None = None, - **connection_pool_kw: typing.Any, - ) -> None: - super().__init__(headers) - self.connection_pool_kw = connection_pool_kw - - self.pools: RecentlyUsedContainer[PoolKey, HTTPConnectionPool] - self.pools = RecentlyUsedContainer(num_pools) - - # Locally set the pool classes and keys so other PoolManagers can - # override them. - self.pool_classes_by_scheme = pool_classes_by_scheme - self.key_fn_by_scheme = key_fn_by_scheme.copy() - - def __enter__(self: _SelfT) -> _SelfT: - return self - - def __exit__( - self, - exc_type: type[BaseException] | None, - exc_val: BaseException | None, - exc_tb: TracebackType | None, - ) -> Literal[False]: - self.clear() - # Return False to re-raise any potential exceptions - return False - - def _new_pool( - self, - scheme: str, - host: str, - port: int, - request_context: dict[str, typing.Any] | None = None, - ) -> HTTPConnectionPool: - """ - Create a new :class:`urllib3.connectionpool.ConnectionPool` based on host, port, scheme, and - any additional pool keyword arguments. - - If ``request_context`` is provided, it is provided as keyword arguments - to the pool class used. This method is used to actually create the - connection pools handed out by :meth:`connection_from_url` and - companion methods. It is intended to be overridden for customization. - """ - pool_cls: type[HTTPConnectionPool] = self.pool_classes_by_scheme[scheme] - if request_context is None: - request_context = self.connection_pool_kw.copy() - - # Default blocksize to _DEFAULT_BLOCKSIZE if missing or explicitly - # set to 'None' in the request_context. - if request_context.get("blocksize") is None: - request_context["blocksize"] = _DEFAULT_BLOCKSIZE - - # Although the context has everything necessary to create the pool, - # this function has historically only used the scheme, host, and port - # in the positional args. When an API change is acceptable these can - # be removed. - for key in ("scheme", "host", "port"): - request_context.pop(key, None) - - if scheme == "http": - for kw in SSL_KEYWORDS: - request_context.pop(kw, None) - - return pool_cls(host, port, **request_context) - - def clear(self) -> None: - """ - Empty our store of pools and direct them all to close. - - This will not affect in-flight connections, but they will not be - re-used after completion. - """ - self.pools.clear() - - def connection_from_host( - self, - host: str | None, - port: int | None = None, - scheme: str | None = "http", - pool_kwargs: dict[str, typing.Any] | None = None, - ) -> HTTPConnectionPool: - """ - Get a :class:`urllib3.connectionpool.ConnectionPool` based on the host, port, and scheme. - - If ``port`` isn't given, it will be derived from the ``scheme`` using - ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is - provided, it is merged with the instance's ``connection_pool_kw`` - variable and used to create the new connection pool, if one is - needed. - """ - - if not host: - raise LocationValueError("No host specified.") - - request_context = self._merge_pool_kwargs(pool_kwargs) - request_context["scheme"] = scheme or "http" - if not port: - port = port_by_scheme.get(request_context["scheme"].lower(), 80) - request_context["port"] = port - request_context["host"] = host - - return self.connection_from_context(request_context) - - def connection_from_context( - self, request_context: dict[str, typing.Any] - ) -> HTTPConnectionPool: - """ - Get a :class:`urllib3.connectionpool.ConnectionPool` based on the request context. - - ``request_context`` must at least contain the ``scheme`` key and its - value must be a key in ``key_fn_by_scheme`` instance variable. - """ - if "strict" in request_context: - warnings.warn( - "The 'strict' parameter is no longer needed on Python 3+. " - "This will raise an error in urllib3 v2.1.0.", - DeprecationWarning, - ) - request_context.pop("strict") - - scheme = request_context["scheme"].lower() - pool_key_constructor = self.key_fn_by_scheme.get(scheme) - if not pool_key_constructor: - raise URLSchemeUnknown(scheme) - pool_key = pool_key_constructor(request_context) - - return self.connection_from_pool_key(pool_key, request_context=request_context) - - def connection_from_pool_key( - self, pool_key: PoolKey, request_context: dict[str, typing.Any] - ) -> HTTPConnectionPool: - """ - Get a :class:`urllib3.connectionpool.ConnectionPool` based on the provided pool key. - - ``pool_key`` should be a namedtuple that only contains immutable - objects. At a minimum it must have the ``scheme``, ``host``, and - ``port`` fields. - """ - with self.pools.lock: - # If the scheme, host, or port doesn't match existing open - # connections, open a new ConnectionPool. - pool = self.pools.get(pool_key) - if pool: - return pool - - # Make a fresh ConnectionPool of the desired type - scheme = request_context["scheme"] - host = request_context["host"] - port = request_context["port"] - pool = self._new_pool(scheme, host, port, request_context=request_context) - self.pools[pool_key] = pool - - return pool - - def connection_from_url( - self, url: str, pool_kwargs: dict[str, typing.Any] | None = None - ) -> HTTPConnectionPool: - """ - Similar to :func:`urllib3.connectionpool.connection_from_url`. - - If ``pool_kwargs`` is not provided and a new pool needs to be - constructed, ``self.connection_pool_kw`` is used to initialize - the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs`` - is provided, it is used instead. Note that if a new pool does not - need to be created for the request, the provided ``pool_kwargs`` are - not used. - """ - u = parse_url(url) - return self.connection_from_host( - u.host, port=u.port, scheme=u.scheme, pool_kwargs=pool_kwargs - ) - - def _merge_pool_kwargs( - self, override: dict[str, typing.Any] | None - ) -> dict[str, typing.Any]: - """ - Merge a dictionary of override values for self.connection_pool_kw. - - This does not modify self.connection_pool_kw and returns a new dict. - Any keys in the override dictionary with a value of ``None`` are - removed from the merged dictionary. - """ - base_pool_kwargs = self.connection_pool_kw.copy() - if override: - for key, value in override.items(): - if value is None: - try: - del base_pool_kwargs[key] - except KeyError: - pass - else: - base_pool_kwargs[key] = value - return base_pool_kwargs - - def _proxy_requires_url_absolute_form(self, parsed_url: Url) -> bool: - """ - Indicates if the proxy requires the complete destination URL in the - request. Normally this is only needed when not using an HTTP CONNECT - tunnel. - """ - if self.proxy is None: - return False - - return not connection_requires_http_tunnel( - self.proxy, self.proxy_config, parsed_url.scheme - ) - - def urlopen( # type: ignore[override] - self, method: str, url: str, redirect: bool = True, **kw: typing.Any - ) -> BaseHTTPResponse: - """ - Same as :meth:`urllib3.HTTPConnectionPool.urlopen` - with custom cross-host redirect logic and only sends the request-uri - portion of the ``url``. - - The given ``url`` parameter must be absolute, such that an appropriate - :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it. - """ - u = parse_url(url) - - if u.scheme is None: - warnings.warn( - "URLs without a scheme (ie 'https://') are deprecated and will raise an error " - "in a future version of urllib3. To avoid this DeprecationWarning ensure all URLs " - "start with 'https://' or 'http://'. Read more in this issue: " - "https://github.com/urllib3/urllib3/issues/2920", - category=DeprecationWarning, - stacklevel=2, - ) - - conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme) - - kw["assert_same_host"] = False - kw["redirect"] = False - - if "headers" not in kw: - kw["headers"] = self.headers - - if self._proxy_requires_url_absolute_form(u): - response = conn.urlopen(method, url, **kw) - else: - response = conn.urlopen(method, u.request_uri, **kw) - - redirect_location = redirect and response.get_redirect_location() - if not redirect_location: - return response - - # Support relative URLs for redirecting. - redirect_location = urljoin(url, redirect_location) - - if response.status == 303: - # Change the method according to RFC 9110, Section 15.4.4. - method = "GET" - # And lose the body not to transfer anything sensitive. - kw["body"] = None - kw["headers"] = HTTPHeaderDict(kw["headers"])._prepare_for_method_change() - - retries = kw.get("retries") - if not isinstance(retries, Retry): - retries = Retry.from_int(retries, redirect=redirect) - - # Strip headers marked as unsafe to forward to the redirected location. - # Check remove_headers_on_redirect to avoid a potential network call within - # conn.is_same_host() which may use socket.gethostbyname() in the future. - if retries.remove_headers_on_redirect and not conn.is_same_host( - redirect_location - ): - new_headers = kw["headers"].copy() - for header in kw["headers"]: - if header.lower() in retries.remove_headers_on_redirect: - new_headers.pop(header, None) - kw["headers"] = new_headers - - try: - retries = retries.increment(method, url, response=response, _pool=conn) - except MaxRetryError: - if retries.raise_on_redirect: - response.drain_conn() - raise - return response - - kw["retries"] = retries - kw["redirect"] = redirect - - log.info("Redirecting %s -> %s", url, redirect_location) - - response.drain_conn() - return self.urlopen(method, redirect_location, **kw) - - -class ProxyManager(PoolManager): - """ - Behaves just like :class:`PoolManager`, but sends all requests through - the defined proxy, using the CONNECT method for HTTPS URLs. - - :param proxy_url: - The URL of the proxy to be used. - - :param proxy_headers: - A dictionary containing headers that will be sent to the proxy. In case - of HTTP they are being sent with each request, while in the - HTTPS/CONNECT case they are sent only once. Could be used for proxy - authentication. - - :param proxy_ssl_context: - The proxy SSL context is used to establish the TLS connection to the - proxy when using HTTPS proxies. - - :param use_forwarding_for_https: - (Defaults to False) If set to True will forward requests to the HTTPS - proxy to be made on behalf of the client instead of creating a TLS - tunnel via the CONNECT method. **Enabling this flag means that request - and response headers and content will be visible from the HTTPS proxy** - whereas tunneling keeps request and response headers and content - private. IP address, target hostname, SNI, and port are always visible - to an HTTPS proxy even when this flag is disabled. - - :param proxy_assert_hostname: - The hostname of the certificate to verify against. - - :param proxy_assert_fingerprint: - The fingerprint of the certificate to verify against. - - Example: - - .. code-block:: python - - import urllib3 - - proxy = urllib3.ProxyManager("https://localhost:3128/") - - resp1 = proxy.request("GET", "https://google.com/") - resp2 = proxy.request("GET", "https://httpbin.org/") - - print(len(proxy.pools)) - # 1 - - resp3 = proxy.request("GET", "https://httpbin.org/") - resp4 = proxy.request("GET", "https://twitter.com/") - - print(len(proxy.pools)) - # 3 - - """ - - def __init__( - self, - proxy_url: str, - num_pools: int = 10, - headers: typing.Mapping[str, str] | None = None, - proxy_headers: typing.Mapping[str, str] | None = None, - proxy_ssl_context: ssl.SSLContext | None = None, - use_forwarding_for_https: bool = False, - proxy_assert_hostname: None | str | Literal[False] = None, - proxy_assert_fingerprint: str | None = None, - **connection_pool_kw: typing.Any, - ) -> None: - if isinstance(proxy_url, HTTPConnectionPool): - str_proxy_url = f"{proxy_url.scheme}://{proxy_url.host}:{proxy_url.port}" - else: - str_proxy_url = proxy_url - proxy = parse_url(str_proxy_url) - - if proxy.scheme not in ("http", "https"): - raise ProxySchemeUnknown(proxy.scheme) - - if not proxy.port: - port = port_by_scheme.get(proxy.scheme, 80) - proxy = proxy._replace(port=port) - - self.proxy = proxy - self.proxy_headers = proxy_headers or {} - self.proxy_ssl_context = proxy_ssl_context - self.proxy_config = ProxyConfig( - proxy_ssl_context, - use_forwarding_for_https, - proxy_assert_hostname, - proxy_assert_fingerprint, - ) - - connection_pool_kw["_proxy"] = self.proxy - connection_pool_kw["_proxy_headers"] = self.proxy_headers - connection_pool_kw["_proxy_config"] = self.proxy_config - - super().__init__(num_pools, headers, **connection_pool_kw) - - def connection_from_host( - self, - host: str | None, - port: int | None = None, - scheme: str | None = "http", - pool_kwargs: dict[str, typing.Any] | None = None, - ) -> HTTPConnectionPool: - if scheme == "https": - return super().connection_from_host( - host, port, scheme, pool_kwargs=pool_kwargs - ) - - return super().connection_from_host( - self.proxy.host, self.proxy.port, self.proxy.scheme, pool_kwargs=pool_kwargs # type: ignore[union-attr] - ) - - def _set_proxy_headers( - self, url: str, headers: typing.Mapping[str, str] | None = None - ) -> typing.Mapping[str, str]: - """ - Sets headers needed by proxies: specifically, the Accept and Host - headers. Only sets headers not provided by the user. - """ - headers_ = {"Accept": "*/*"} - - netloc = parse_url(url).netloc - if netloc: - headers_["Host"] = netloc - - if headers: - headers_.update(headers) - return headers_ - - def urlopen( # type: ignore[override] - self, method: str, url: str, redirect: bool = True, **kw: typing.Any - ) -> BaseHTTPResponse: - "Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute." - u = parse_url(url) - if not connection_requires_http_tunnel(self.proxy, self.proxy_config, u.scheme): - # For connections using HTTP CONNECT, httplib sets the necessary - # headers on the CONNECT to the proxy. If we're not using CONNECT, - # we'll definitely need to set 'Host' at the very least. - headers = kw.get("headers", self.headers) - kw["headers"] = self._set_proxy_headers(url, headers) - - return super().urlopen(method, url, redirect=redirect, **kw) - - -def proxy_from_url(url: str, **kw: typing.Any) -> ProxyManager: - return ProxyManager(proxy_url=url, **kw) diff --git a/Modules/urllib3/py.typed b/Modules/urllib3/py.typed deleted file mode 100644 index 5f3ea3d..0000000 --- a/Modules/urllib3/py.typed +++ /dev/null @@ -1,2 +0,0 @@ -# Instruct type checkers to look for inline type annotations in this package. -# See PEP 561. diff --git a/Modules/urllib3/response.py b/Modules/urllib3/response.py deleted file mode 100644 index 37936f9..0000000 --- a/Modules/urllib3/response.py +++ /dev/null @@ -1,1130 +0,0 @@ -from __future__ import annotations - -import collections -import io -import json as _json -import logging -import re -import sys -import typing -import warnings -import zlib -from contextlib import contextmanager -from http.client import HTTPMessage as _HttplibHTTPMessage -from http.client import HTTPResponse as _HttplibHTTPResponse -from socket import timeout as SocketTimeout - -try: - try: - import brotlicffi as brotli # type: ignore[import] - except ImportError: - import brotli # type: ignore[import] -except ImportError: - brotli = None - -try: - import zstandard as zstd # type: ignore[import] - - # The package 'zstandard' added the 'eof' property starting - # in v0.18.0 which we require to ensure a complete and - # valid zstd stream was fed into the ZstdDecoder. - # See: https://github.com/urllib3/urllib3/pull/2624 - _zstd_version = _zstd_version = tuple( - map(int, re.search(r"^([0-9]+)\.([0-9]+)", zstd.__version__).groups()) # type: ignore[union-attr] - ) - if _zstd_version < (0, 18): # Defensive: - zstd = None - -except (AttributeError, ImportError, ValueError): # Defensive: - zstd = None - -from . import util -from ._base_connection import _TYPE_BODY -from ._collections import HTTPHeaderDict -from .connection import BaseSSLError, HTTPConnection, HTTPException -from .exceptions import ( - BodyNotHttplibCompatible, - DecodeError, - HTTPError, - IncompleteRead, - InvalidChunkLength, - InvalidHeader, - ProtocolError, - ReadTimeoutError, - ResponseNotChunked, - SSLError, -) -from .util.response import is_fp_closed, is_response_to_head -from .util.retry import Retry - -if typing.TYPE_CHECKING: - from typing import Literal - - from .connectionpool import HTTPConnectionPool - -log = logging.getLogger(__name__) - - -class ContentDecoder: - def decompress(self, data: bytes) -> bytes: - raise NotImplementedError() - - def flush(self) -> bytes: - raise NotImplementedError() - - -class DeflateDecoder(ContentDecoder): - def __init__(self) -> None: - self._first_try = True - self._data = b"" - self._obj = zlib.decompressobj() - - def decompress(self, data: bytes) -> bytes: - if not data: - return data - - if not self._first_try: - return self._obj.decompress(data) - - self._data += data - try: - decompressed = self._obj.decompress(data) - if decompressed: - self._first_try = False - self._data = None # type: ignore[assignment] - return decompressed - except zlib.error: - self._first_try = False - self._obj = zlib.decompressobj(-zlib.MAX_WBITS) - try: - return self.decompress(self._data) - finally: - self._data = None # type: ignore[assignment] - - def flush(self) -> bytes: - return self._obj.flush() - - -class GzipDecoderState: - FIRST_MEMBER = 0 - OTHER_MEMBERS = 1 - SWALLOW_DATA = 2 - - -class GzipDecoder(ContentDecoder): - def __init__(self) -> None: - self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS) - self._state = GzipDecoderState.FIRST_MEMBER - - def decompress(self, data: bytes) -> bytes: - ret = bytearray() - if self._state == GzipDecoderState.SWALLOW_DATA or not data: - return bytes(ret) - while True: - try: - ret += self._obj.decompress(data) - except zlib.error: - previous_state = self._state - # Ignore data after the first error - self._state = GzipDecoderState.SWALLOW_DATA - if previous_state == GzipDecoderState.OTHER_MEMBERS: - # Allow trailing garbage acceptable in other gzip clients - return bytes(ret) - raise - data = self._obj.unused_data - if not data: - return bytes(ret) - self._state = GzipDecoderState.OTHER_MEMBERS - self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS) - - def flush(self) -> bytes: - return self._obj.flush() - - -if brotli is not None: - - class BrotliDecoder(ContentDecoder): - # Supports both 'brotlipy' and 'Brotli' packages - # since they share an import name. The top branches - # are for 'brotlipy' and bottom branches for 'Brotli' - def __init__(self) -> None: - self._obj = brotli.Decompressor() - if hasattr(self._obj, "decompress"): - setattr(self, "decompress", self._obj.decompress) - else: - setattr(self, "decompress", self._obj.process) - - def flush(self) -> bytes: - if hasattr(self._obj, "flush"): - return self._obj.flush() # type: ignore[no-any-return] - return b"" - - -if zstd is not None: - - class ZstdDecoder(ContentDecoder): - def __init__(self) -> None: - self._obj = zstd.ZstdDecompressor().decompressobj() - - def decompress(self, data: bytes) -> bytes: - if not data: - return b"" - data_parts = [self._obj.decompress(data)] - while self._obj.eof and self._obj.unused_data: - unused_data = self._obj.unused_data - self._obj = zstd.ZstdDecompressor().decompressobj() - data_parts.append(self._obj.decompress(unused_data)) - return b"".join(data_parts) - - def flush(self) -> bytes: - ret = self._obj.flush() # note: this is a no-op - if not self._obj.eof: - raise DecodeError("Zstandard data is incomplete") - return ret # type: ignore[no-any-return] - - -class MultiDecoder(ContentDecoder): - """ - From RFC7231: - If one or more encodings have been applied to a representation, the - sender that applied the encodings MUST generate a Content-Encoding - header field that lists the content codings in the order in which - they were applied. - """ - - def __init__(self, modes: str) -> None: - self._decoders = [_get_decoder(m.strip()) for m in modes.split(",")] - - def flush(self) -> bytes: - return self._decoders[0].flush() - - def decompress(self, data: bytes) -> bytes: - for d in reversed(self._decoders): - data = d.decompress(data) - return data - - -def _get_decoder(mode: str) -> ContentDecoder: - if "," in mode: - return MultiDecoder(mode) - - # According to RFC 9110 section 8.4.1.3, recipients should - # consider x-gzip equivalent to gzip - if mode in ("gzip", "x-gzip"): - return GzipDecoder() - - if brotli is not None and mode == "br": - return BrotliDecoder() - - if zstd is not None and mode == "zstd": - return ZstdDecoder() - - return DeflateDecoder() - - -class BytesQueueBuffer: - """Memory-efficient bytes buffer - - To return decoded data in read() and still follow the BufferedIOBase API, we need a - buffer to always return the correct amount of bytes. - - This buffer should be filled using calls to put() - - Our maximum memory usage is determined by the sum of the size of: - - * self.buffer, which contains the full data - * the largest chunk that we will copy in get() - - The worst case scenario is a single chunk, in which case we'll make a full copy of - the data inside get(). - """ - - def __init__(self) -> None: - self.buffer: typing.Deque[bytes] = collections.deque() - self._size: int = 0 - - def __len__(self) -> int: - return self._size - - def put(self, data: bytes) -> None: - self.buffer.append(data) - self._size += len(data) - - def get(self, n: int) -> bytes: - if n == 0: - return b"" - elif not self.buffer: - raise RuntimeError("buffer is empty") - elif n < 0: - raise ValueError("n should be > 0") - - fetched = 0 - ret = io.BytesIO() - while fetched < n: - remaining = n - fetched - chunk = self.buffer.popleft() - chunk_length = len(chunk) - if remaining < chunk_length: - left_chunk, right_chunk = chunk[:remaining], chunk[remaining:] - ret.write(left_chunk) - self.buffer.appendleft(right_chunk) - self._size -= remaining - break - else: - ret.write(chunk) - self._size -= chunk_length - fetched += chunk_length - - if not self.buffer: - break - - return ret.getvalue() - - -class BaseHTTPResponse(io.IOBase): - CONTENT_DECODERS = ["gzip", "x-gzip", "deflate"] - if brotli is not None: - CONTENT_DECODERS += ["br"] - if zstd is not None: - CONTENT_DECODERS += ["zstd"] - REDIRECT_STATUSES = [301, 302, 303, 307, 308] - - DECODER_ERROR_CLASSES: tuple[type[Exception], ...] = (IOError, zlib.error) - if brotli is not None: - DECODER_ERROR_CLASSES += (brotli.error,) - - if zstd is not None: - DECODER_ERROR_CLASSES += (zstd.ZstdError,) - - def __init__( - self, - *, - headers: typing.Mapping[str, str] | typing.Mapping[bytes, bytes] | None = None, - status: int, - version: int, - reason: str | None, - decode_content: bool, - request_url: str | None, - retries: Retry | None = None, - ) -> None: - if isinstance(headers, HTTPHeaderDict): - self.headers = headers - else: - self.headers = HTTPHeaderDict(headers) # type: ignore[arg-type] - self.status = status - self.version = version - self.reason = reason - self.decode_content = decode_content - self._has_decoded_content = False - self._request_url: str | None = request_url - self.retries = retries - - self.chunked = False - tr_enc = self.headers.get("transfer-encoding", "").lower() - # Don't incur the penalty of creating a list and then discarding it - encodings = (enc.strip() for enc in tr_enc.split(",")) - if "chunked" in encodings: - self.chunked = True - - self._decoder: ContentDecoder | None = None - - def get_redirect_location(self) -> str | None | Literal[False]: - """ - Should we redirect and where to? - - :returns: Truthy redirect location string if we got a redirect status - code and valid location. ``None`` if redirect status and no - location. ``False`` if not a redirect status code. - """ - if self.status in self.REDIRECT_STATUSES: - return self.headers.get("location") - return False - - @property - def data(self) -> bytes: - raise NotImplementedError() - - def json(self) -> typing.Any: - """ - Parses the body of the HTTP response as JSON. - - To use a custom JSON decoder pass the result of :attr:`HTTPResponse.data` to the decoder. - - This method can raise either `UnicodeDecodeError` or `json.JSONDecodeError`. - - Read more :ref:`here `. - """ - data = self.data.decode("utf-8") - return _json.loads(data) - - @property - def url(self) -> str | None: - raise NotImplementedError() - - @url.setter - def url(self, url: str | None) -> None: - raise NotImplementedError() - - @property - def connection(self) -> HTTPConnection | None: - raise NotImplementedError() - - @property - def retries(self) -> Retry | None: - return self._retries - - @retries.setter - def retries(self, retries: Retry | None) -> None: - # Override the request_url if retries has a redirect location. - if retries is not None and retries.history: - self.url = retries.history[-1].redirect_location - self._retries = retries - - def stream( - self, amt: int | None = 2**16, decode_content: bool | None = None - ) -> typing.Iterator[bytes]: - raise NotImplementedError() - - def read( - self, - amt: int | None = None, - decode_content: bool | None = None, - cache_content: bool = False, - ) -> bytes: - raise NotImplementedError() - - def read_chunked( - self, - amt: int | None = None, - decode_content: bool | None = None, - ) -> typing.Iterator[bytes]: - raise NotImplementedError() - - def release_conn(self) -> None: - raise NotImplementedError() - - def drain_conn(self) -> None: - raise NotImplementedError() - - def close(self) -> None: - raise NotImplementedError() - - def _init_decoder(self) -> None: - """ - Set-up the _decoder attribute if necessary. - """ - # Note: content-encoding value should be case-insensitive, per RFC 7230 - # Section 3.2 - content_encoding = self.headers.get("content-encoding", "").lower() - if self._decoder is None: - if content_encoding in self.CONTENT_DECODERS: - self._decoder = _get_decoder(content_encoding) - elif "," in content_encoding: - encodings = [ - e.strip() - for e in content_encoding.split(",") - if e.strip() in self.CONTENT_DECODERS - ] - if encodings: - self._decoder = _get_decoder(content_encoding) - - def _decode( - self, data: bytes, decode_content: bool | None, flush_decoder: bool - ) -> bytes: - """ - Decode the data passed in and potentially flush the decoder. - """ - if not decode_content: - if self._has_decoded_content: - raise RuntimeError( - "Calling read(decode_content=False) is not supported after " - "read(decode_content=True) was called." - ) - return data - - try: - if self._decoder: - data = self._decoder.decompress(data) - self._has_decoded_content = True - except self.DECODER_ERROR_CLASSES as e: - content_encoding = self.headers.get("content-encoding", "").lower() - raise DecodeError( - "Received response with content-encoding: %s, but " - "failed to decode it." % content_encoding, - e, - ) from e - if flush_decoder: - data += self._flush_decoder() - - return data - - def _flush_decoder(self) -> bytes: - """ - Flushes the decoder. Should only be called if the decoder is actually - being used. - """ - if self._decoder: - return self._decoder.decompress(b"") + self._decoder.flush() - return b"" - - # Compatibility methods for `io` module - def readinto(self, b: bytearray) -> int: - temp = self.read(len(b)) - if len(temp) == 0: - return 0 - else: - b[: len(temp)] = temp - return len(temp) - - # Compatibility methods for http.client.HTTPResponse - def getheaders(self) -> HTTPHeaderDict: - warnings.warn( - "HTTPResponse.getheaders() is deprecated and will be removed " - "in urllib3 v2.1.0. Instead access HTTPResponse.headers directly.", - category=DeprecationWarning, - stacklevel=2, - ) - return self.headers - - def getheader(self, name: str, default: str | None = None) -> str | None: - warnings.warn( - "HTTPResponse.getheader() is deprecated and will be removed " - "in urllib3 v2.1.0. Instead use HTTPResponse.headers.get(name, default).", - category=DeprecationWarning, - stacklevel=2, - ) - return self.headers.get(name, default) - - # Compatibility method for http.cookiejar - def info(self) -> HTTPHeaderDict: - return self.headers - - def geturl(self) -> str | None: - return self.url - - -class HTTPResponse(BaseHTTPResponse): - """ - HTTP Response container. - - Backwards-compatible with :class:`http.client.HTTPResponse` but the response ``body`` is - loaded and decoded on-demand when the ``data`` property is accessed. This - class is also compatible with the Python standard library's :mod:`io` - module, and can hence be treated as a readable object in the context of that - framework. - - Extra parameters for behaviour not present in :class:`http.client.HTTPResponse`: - - :param preload_content: - If True, the response's body will be preloaded during construction. - - :param decode_content: - If True, will attempt to decode the body based on the - 'content-encoding' header. - - :param original_response: - When this HTTPResponse wrapper is generated from an :class:`http.client.HTTPResponse` - object, it's convenient to include the original for debug purposes. It's - otherwise unused. - - :param retries: - The retries contains the last :class:`~urllib3.util.retry.Retry` that - was used during the request. - - :param enforce_content_length: - Enforce content length checking. Body returned by server must match - value of Content-Length header, if present. Otherwise, raise error. - """ - - def __init__( - self, - body: _TYPE_BODY = "", - headers: typing.Mapping[str, str] | typing.Mapping[bytes, bytes] | None = None, - status: int = 0, - version: int = 0, - reason: str | None = None, - preload_content: bool = True, - decode_content: bool = True, - original_response: _HttplibHTTPResponse | None = None, - pool: HTTPConnectionPool | None = None, - connection: HTTPConnection | None = None, - msg: _HttplibHTTPMessage | None = None, - retries: Retry | None = None, - enforce_content_length: bool = True, - request_method: str | None = None, - request_url: str | None = None, - auto_close: bool = True, - ) -> None: - super().__init__( - headers=headers, - status=status, - version=version, - reason=reason, - decode_content=decode_content, - request_url=request_url, - retries=retries, - ) - - self.enforce_content_length = enforce_content_length - self.auto_close = auto_close - - self._body = None - self._fp: _HttplibHTTPResponse | None = None - self._original_response = original_response - self._fp_bytes_read = 0 - self.msg = msg - - if body and isinstance(body, (str, bytes)): - self._body = body - - self._pool = pool - self._connection = connection - - if hasattr(body, "read"): - self._fp = body # type: ignore[assignment] - - # Are we using the chunked-style of transfer encoding? - self.chunk_left: int | None = None - - # Determine length of response - self.length_remaining = self._init_length(request_method) - - # Used to return the correct amount of bytes for partial read()s - self._decoded_buffer = BytesQueueBuffer() - - # If requested, preload the body. - if preload_content and not self._body: - self._body = self.read(decode_content=decode_content) - - def release_conn(self) -> None: - if not self._pool or not self._connection: - return None - - self._pool._put_conn(self._connection) - self._connection = None - - def drain_conn(self) -> None: - """ - Read and discard any remaining HTTP response data in the response connection. - - Unread data in the HTTPResponse connection blocks the connection from being released back to the pool. - """ - try: - self.read() - except (HTTPError, OSError, BaseSSLError, HTTPException): - pass - - @property - def data(self) -> bytes: - # For backwards-compat with earlier urllib3 0.4 and earlier. - if self._body: - return self._body # type: ignore[return-value] - - if self._fp: - return self.read(cache_content=True) - - return None # type: ignore[return-value] - - @property - def connection(self) -> HTTPConnection | None: - return self._connection - - def isclosed(self) -> bool: - return is_fp_closed(self._fp) - - def tell(self) -> int: - """ - Obtain the number of bytes pulled over the wire so far. May differ from - the amount of content returned by :meth:``urllib3.response.HTTPResponse.read`` - if bytes are encoded on the wire (e.g, compressed). - """ - return self._fp_bytes_read - - def _init_length(self, request_method: str | None) -> int | None: - """ - Set initial length value for Response content if available. - """ - length: int | None - content_length: str | None = self.headers.get("content-length") - - if content_length is not None: - if self.chunked: - # This Response will fail with an IncompleteRead if it can't be - # received as chunked. This method falls back to attempt reading - # the response before raising an exception. - log.warning( - "Received response with both Content-Length and " - "Transfer-Encoding set. This is expressly forbidden " - "by RFC 7230 sec 3.3.2. Ignoring Content-Length and " - "attempting to process response as Transfer-Encoding: " - "chunked." - ) - return None - - try: - # RFC 7230 section 3.3.2 specifies multiple content lengths can - # be sent in a single Content-Length header - # (e.g. Content-Length: 42, 42). This line ensures the values - # are all valid ints and that as long as the `set` length is 1, - # all values are the same. Otherwise, the header is invalid. - lengths = {int(val) for val in content_length.split(",")} - if len(lengths) > 1: - raise InvalidHeader( - "Content-Length contained multiple " - "unmatching values (%s)" % content_length - ) - length = lengths.pop() - except ValueError: - length = None - else: - if length < 0: - length = None - - else: # if content_length is None - length = None - - # Convert status to int for comparison - # In some cases, httplib returns a status of "_UNKNOWN" - try: - status = int(self.status) - except ValueError: - status = 0 - - # Check for responses that shouldn't include a body - if status in (204, 304) or 100 <= status < 200 or request_method == "HEAD": - length = 0 - - return length - - @contextmanager - def _error_catcher(self) -> typing.Generator[None, None, None]: - """ - Catch low-level python exceptions, instead re-raising urllib3 - variants, so that low-level exceptions are not leaked in the - high-level api. - - On exit, release the connection back to the pool. - """ - clean_exit = False - - try: - try: - yield - - except SocketTimeout as e: - # FIXME: Ideally we'd like to include the url in the ReadTimeoutError but - # there is yet no clean way to get at it from this context. - raise ReadTimeoutError(self._pool, None, "Read timed out.") from e # type: ignore[arg-type] - - except BaseSSLError as e: - # FIXME: Is there a better way to differentiate between SSLErrors? - if "read operation timed out" not in str(e): - # SSL errors related to framing/MAC get wrapped and reraised here - raise SSLError(e) from e - - raise ReadTimeoutError(self._pool, None, "Read timed out.") from e # type: ignore[arg-type] - - except (HTTPException, OSError) as e: - # This includes IncompleteRead. - raise ProtocolError(f"Connection broken: {e!r}", e) from e - - # If no exception is thrown, we should avoid cleaning up - # unnecessarily. - clean_exit = True - finally: - # If we didn't terminate cleanly, we need to throw away our - # connection. - if not clean_exit: - # The response may not be closed but we're not going to use it - # anymore so close it now to ensure that the connection is - # released back to the pool. - if self._original_response: - self._original_response.close() - - # Closing the response may not actually be sufficient to close - # everything, so if we have a hold of the connection close that - # too. - if self._connection: - self._connection.close() - - # If we hold the original response but it's closed now, we should - # return the connection back to the pool. - if self._original_response and self._original_response.isclosed(): - self.release_conn() - - def _fp_read(self, amt: int | None = None) -> bytes: - """ - Read a response with the thought that reading the number of bytes - larger than can fit in a 32-bit int at a time via SSL in some - known cases leads to an overflow error that has to be prevented - if `amt` or `self.length_remaining` indicate that a problem may - happen. - - The known cases: - * 3.8 <= CPython < 3.9.7 because of a bug - https://github.com/urllib3/urllib3/issues/2513#issuecomment-1152559900. - * urllib3 injected with pyOpenSSL-backed SSL-support. - * CPython < 3.10 only when `amt` does not fit 32-bit int. - """ - assert self._fp - c_int_max = 2**31 - 1 - if ( - (amt and amt > c_int_max) - or (self.length_remaining and self.length_remaining > c_int_max) - ) and (util.IS_PYOPENSSL or sys.version_info < (3, 10)): - buffer = io.BytesIO() - # Besides `max_chunk_amt` being a maximum chunk size, it - # affects memory overhead of reading a response by this - # method in CPython. - # `c_int_max` equal to 2 GiB - 1 byte is the actual maximum - # chunk size that does not lead to an overflow error, but - # 256 MiB is a compromise. - max_chunk_amt = 2**28 - while amt is None or amt != 0: - if amt is not None: - chunk_amt = min(amt, max_chunk_amt) - amt -= chunk_amt - else: - chunk_amt = max_chunk_amt - data = self._fp.read(chunk_amt) - if not data: - break - buffer.write(data) - del data # to reduce peak memory usage by `max_chunk_amt`. - return buffer.getvalue() - else: - # StringIO doesn't like amt=None - return self._fp.read(amt) if amt is not None else self._fp.read() - - def _raw_read( - self, - amt: int | None = None, - ) -> bytes: - """ - Reads `amt` of bytes from the socket. - """ - if self._fp is None: - return None # type: ignore[return-value] - - fp_closed = getattr(self._fp, "closed", False) - - with self._error_catcher(): - data = self._fp_read(amt) if not fp_closed else b"" - if amt is not None and amt != 0 and not data: - # Platform-specific: Buggy versions of Python. - # Close the connection when no data is returned - # - # This is redundant to what httplib/http.client _should_ - # already do. However, versions of python released before - # December 15, 2012 (http://bugs.python.org/issue16298) do - # not properly close the connection in all cases. There is - # no harm in redundantly calling close. - self._fp.close() - if ( - self.enforce_content_length - and self.length_remaining is not None - and self.length_remaining != 0 - ): - # This is an edge case that httplib failed to cover due - # to concerns of backward compatibility. We're - # addressing it here to make sure IncompleteRead is - # raised during streaming, so all calls with incorrect - # Content-Length are caught. - raise IncompleteRead(self._fp_bytes_read, self.length_remaining) - - if data: - self._fp_bytes_read += len(data) - if self.length_remaining is not None: - self.length_remaining -= len(data) - return data - - def read( - self, - amt: int | None = None, - decode_content: bool | None = None, - cache_content: bool = False, - ) -> bytes: - """ - Similar to :meth:`http.client.HTTPResponse.read`, but with two additional - parameters: ``decode_content`` and ``cache_content``. - - :param amt: - How much of the content to read. If specified, caching is skipped - because it doesn't make sense to cache partial content as the full - response. - - :param decode_content: - If True, will attempt to decode the body based on the - 'content-encoding' header. - - :param cache_content: - If True, will save the returned data such that the same result is - returned despite of the state of the underlying file object. This - is useful if you want the ``.data`` property to continue working - after having ``.read()`` the file object. (Overridden if ``amt`` is - set.) - """ - self._init_decoder() - if decode_content is None: - decode_content = self.decode_content - - if amt is not None: - cache_content = False - - if len(self._decoded_buffer) >= amt: - return self._decoded_buffer.get(amt) - - data = self._raw_read(amt) - - flush_decoder = amt is None or (amt != 0 and not data) - - if not data and len(self._decoded_buffer) == 0: - return data - - if amt is None: - data = self._decode(data, decode_content, flush_decoder) - if cache_content: - self._body = data - else: - # do not waste memory on buffer when not decoding - if not decode_content: - if self._has_decoded_content: - raise RuntimeError( - "Calling read(decode_content=False) is not supported after " - "read(decode_content=True) was called." - ) - return data - - decoded_data = self._decode(data, decode_content, flush_decoder) - self._decoded_buffer.put(decoded_data) - - while len(self._decoded_buffer) < amt and data: - # TODO make sure to initially read enough data to get past the headers - # For example, the GZ file header takes 10 bytes, we don't want to read - # it one byte at a time - data = self._raw_read(amt) - decoded_data = self._decode(data, decode_content, flush_decoder) - self._decoded_buffer.put(decoded_data) - data = self._decoded_buffer.get(amt) - - return data - - def stream( - self, amt: int | None = 2**16, decode_content: bool | None = None - ) -> typing.Generator[bytes, None, None]: - """ - A generator wrapper for the read() method. A call will block until - ``amt`` bytes have been read from the connection or until the - connection is closed. - - :param amt: - How much of the content to read. The generator will return up to - much data per iteration, but may return less. This is particularly - likely when using compressed data. However, the empty string will - never be returned. - - :param decode_content: - If True, will attempt to decode the body based on the - 'content-encoding' header. - """ - if self.chunked and self.supports_chunked_reads(): - yield from self.read_chunked(amt, decode_content=decode_content) - else: - while not is_fp_closed(self._fp) or len(self._decoded_buffer) > 0: - data = self.read(amt=amt, decode_content=decode_content) - - if data: - yield data - - # Overrides from io.IOBase - def readable(self) -> bool: - return True - - def close(self) -> None: - if not self.closed and self._fp: - self._fp.close() - - if self._connection: - self._connection.close() - - if not self.auto_close: - io.IOBase.close(self) - - @property - def closed(self) -> bool: - if not self.auto_close: - return io.IOBase.closed.__get__(self) # type: ignore[no-any-return] - elif self._fp is None: - return True - elif hasattr(self._fp, "isclosed"): - return self._fp.isclosed() - elif hasattr(self._fp, "closed"): - return self._fp.closed - else: - return True - - def fileno(self) -> int: - if self._fp is None: - raise OSError("HTTPResponse has no file to get a fileno from") - elif hasattr(self._fp, "fileno"): - return self._fp.fileno() - else: - raise OSError( - "The file-like object this HTTPResponse is wrapped " - "around has no file descriptor" - ) - - def flush(self) -> None: - if ( - self._fp is not None - and hasattr(self._fp, "flush") - and not getattr(self._fp, "closed", False) - ): - return self._fp.flush() - - def supports_chunked_reads(self) -> bool: - """ - Checks if the underlying file-like object looks like a - :class:`http.client.HTTPResponse` object. We do this by testing for - the fp attribute. If it is present we assume it returns raw chunks as - processed by read_chunked(). - """ - return hasattr(self._fp, "fp") - - def _update_chunk_length(self) -> None: - # First, we'll figure out length of a chunk and then - # we'll try to read it from socket. - if self.chunk_left is not None: - return None - line = self._fp.fp.readline() # type: ignore[union-attr] - line = line.split(b";", 1)[0] - try: - self.chunk_left = int(line, 16) - except ValueError: - # Invalid chunked protocol response, abort. - self.close() - raise InvalidChunkLength(self, line) from None - - def _handle_chunk(self, amt: int | None) -> bytes: - returned_chunk = None - if amt is None: - chunk = self._fp._safe_read(self.chunk_left) # type: ignore[union-attr] - returned_chunk = chunk - self._fp._safe_read(2) # type: ignore[union-attr] # Toss the CRLF at the end of the chunk. - self.chunk_left = None - elif self.chunk_left is not None and amt < self.chunk_left: - value = self._fp._safe_read(amt) # type: ignore[union-attr] - self.chunk_left = self.chunk_left - amt - returned_chunk = value - elif amt == self.chunk_left: - value = self._fp._safe_read(amt) # type: ignore[union-attr] - self._fp._safe_read(2) # type: ignore[union-attr] # Toss the CRLF at the end of the chunk. - self.chunk_left = None - returned_chunk = value - else: # amt > self.chunk_left - returned_chunk = self._fp._safe_read(self.chunk_left) # type: ignore[union-attr] - self._fp._safe_read(2) # type: ignore[union-attr] # Toss the CRLF at the end of the chunk. - self.chunk_left = None - return returned_chunk # type: ignore[no-any-return] - - def read_chunked( - self, amt: int | None = None, decode_content: bool | None = None - ) -> typing.Generator[bytes, None, None]: - """ - Similar to :meth:`HTTPResponse.read`, but with an additional - parameter: ``decode_content``. - - :param amt: - How much of the content to read. If specified, caching is skipped - because it doesn't make sense to cache partial content as the full - response. - - :param decode_content: - If True, will attempt to decode the body based on the - 'content-encoding' header. - """ - self._init_decoder() - # FIXME: Rewrite this method and make it a class with a better structured logic. - if not self.chunked: - raise ResponseNotChunked( - "Response is not chunked. " - "Header 'transfer-encoding: chunked' is missing." - ) - if not self.supports_chunked_reads(): - raise BodyNotHttplibCompatible( - "Body should be http.client.HTTPResponse like. " - "It should have have an fp attribute which returns raw chunks." - ) - - with self._error_catcher(): - # Don't bother reading the body of a HEAD request. - if self._original_response and is_response_to_head(self._original_response): - self._original_response.close() - return None - - # If a response is already read and closed - # then return immediately. - if self._fp.fp is None: # type: ignore[union-attr] - return None - - while True: - self._update_chunk_length() - if self.chunk_left == 0: - break - chunk = self._handle_chunk(amt) - decoded = self._decode( - chunk, decode_content=decode_content, flush_decoder=False - ) - if decoded: - yield decoded - - if decode_content: - # On CPython and PyPy, we should never need to flush the - # decoder. However, on Jython we *might* need to, so - # lets defensively do it anyway. - decoded = self._flush_decoder() - if decoded: # Platform-specific: Jython. - yield decoded - - # Chunk content ends with \r\n: discard it. - while self._fp is not None: - line = self._fp.fp.readline() - if not line: - # Some sites may not end with '\r\n'. - break - if line == b"\r\n": - break - - # We read everything; close the "file". - if self._original_response: - self._original_response.close() - - @property - def url(self) -> str | None: - """ - Returns the URL that was the source of this response. - If the request that generated this response redirected, this method - will return the final redirect location. - """ - return self._request_url - - @url.setter - def url(self, url: str) -> None: - self._request_url = url - - def __iter__(self) -> typing.Iterator[bytes]: - buffer: list[bytes] = [] - for chunk in self.stream(decode_content=True): - if b"\n" in chunk: - chunks = chunk.split(b"\n") - yield b"".join(buffer) + chunks[0] + b"\n" - for x in chunks[1:-1]: - yield x + b"\n" - if chunks[-1]: - buffer = [chunks[-1]] - else: - buffer = [] - else: - buffer.append(chunk) - if buffer: - yield b"".join(buffer) diff --git a/Modules/urllib3/util/__init__.py b/Modules/urllib3/util/__init__.py deleted file mode 100644 index 5341260..0000000 --- a/Modules/urllib3/util/__init__.py +++ /dev/null @@ -1,42 +0,0 @@ -# For backwards compatibility, provide imports that used to be here. -from __future__ import annotations - -from .connection import is_connection_dropped -from .request import SKIP_HEADER, SKIPPABLE_HEADERS, make_headers -from .response import is_fp_closed -from .retry import Retry -from .ssl_ import ( - ALPN_PROTOCOLS, - IS_PYOPENSSL, - SSLContext, - assert_fingerprint, - create_urllib3_context, - resolve_cert_reqs, - resolve_ssl_version, - ssl_wrap_socket, -) -from .timeout import Timeout -from .url import Url, parse_url -from .wait import wait_for_read, wait_for_write - -__all__ = ( - "IS_PYOPENSSL", - "SSLContext", - "ALPN_PROTOCOLS", - "Retry", - "Timeout", - "Url", - "assert_fingerprint", - "create_urllib3_context", - "is_connection_dropped", - "is_fp_closed", - "parse_url", - "make_headers", - "resolve_cert_reqs", - "resolve_ssl_version", - "ssl_wrap_socket", - "wait_for_read", - "wait_for_write", - "SKIP_HEADER", - "SKIPPABLE_HEADERS", -) diff --git a/Modules/urllib3/util/__pycache__/__init__.cpython-311.pyc b/Modules/urllib3/util/__pycache__/__init__.cpython-311.pyc deleted file mode 100644 index 1f13a32a899ea2b449e1aafffa69b5f4a1cc488c..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1201 zcmcJNzi-n(6vxkT5+`wfG(VcQv;_&o;DLHzVL(WsM4}>UqNEJmax(FywR&f}cjuOF z{1@yji2o*IbWo44FaeE4FmWY-y|7oLNoQVBujHJNAoaGEoh~=94XKuET(>*l&B5u)VD~P zR$zrzVU^Zkjjq8pT8DMofDPJ&P1=I3^t}REr)}6y{UX_*n{bnE!L2kdkw0A@mQyk&!RZSzGF&z^xh5aZL_=}JYk8{ifngro7W-$vwA=_hyJ%Lfe2njyF)LPSb z>kRXVoMSZB6%3zo*}PA2PSCkhr3R8U9b7OkMm!pyVxg2-M*+oABAkpgKQbbVvB!A& z1(m5>c!5$7G1b%aW%W;Z!2*GuCM&DGv5JPRp|1&RYP2+}8a0iaMp0v3qoA>-QP*f_ zv^6#~@*0-Hq4QXl5Sk<+VHhE%?jDe(=ly_2PQX(8khg3wQJqy7fBuiTS}V%Nvx zQ+H2Ep9IG)zvKc_-%XS@_wFp+L(^Z>+&h+0lTP;`JW?*x=YV%Cd$jrh2MGF|aQ?T>5&A^lCLpB5M^dXyP OTXyEFrGM<1+S6~=c13*v diff --git a/Modules/urllib3/util/__pycache__/connection.cpython-311.pyc b/Modules/urllib3/util/__pycache__/connection.cpython-311.pyc deleted file mode 100644 index 820c9b658baa690cdfc39aa9761c5a1dbfa9f521..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 5053 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 diff --git a/Modules/urllib3/util/__pycache__/retry.cpython-311.pyc b/Modules/urllib3/util/__pycache__/retry.cpython-311.pyc deleted file mode 100644 index 6daca3c579bc4ac583e494752ac8bc99e81e42c3..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 21043 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%0A7E`mPPR+eVPZ9yyXgcZ`A;zsLi^Y#l+`C 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 diff --git a/Modules/urllib3/util/__pycache__/ssltransport.cpython-311.pyc b/Modules/urllib3/util/__pycache__/ssltransport.cpython-311.pyc deleted file mode 100644 index cc4375a53ef0609808c86dfbbc60cc92ea926a46..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 14605 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 diff --git a/Modules/urllib3/util/__pycache__/timeout.cpython-311.pyc b/Modules/urllib3/util/__pycache__/timeout.cpython-311.pyc deleted file mode 100644 index 3ccbb6b03ddcc02e20cb993d2b7268edf64da0a8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 12218 zcmd5?TWs7`dM4*0jiixAS6g;$hmjpyBg-S_qFl!I?%J~K^{ykkvAo-8w>zSS9Er{h zsgN8inyP^u7=^p=g9{i)fFy+rTvAV7>h|Ayv`#&xbsa?op!JG+ zJoov}{d%$x*&$w~;Aw7v&6C7D-5*6T3;y{vH>gD}Na>z0=rt|ZyHwM(T-7x!)0x40 zY}zcBaPM2xT}>~j<)Z5vCEY5!Ul0sxndR>nFiM}cZOcYw{FGs;#XO&bm$G+z*pG*I zBwd=5H3?*tK|(?yTJO%yzIJ{(cXImF@r!3?zxZEVGwE18k;|ECNzdi#ow;1e(#l18 zPUdoNl+~iw5_hfFb@OBCAx-klixW#$NuSX4{Oc2$yk!=Q#R+HCarKfmQFe5DqHGt7 z#=>(GW!ET9cSa^D;ANP zJ@d-+xr?(+l<-(AKm2!q2`B+E11lUc^g4BO3Rk*DjtV} zdXLM>G0~JE=4U)4MuDKI=iOt^W)6=lwytW&Ud$X$2g8?KcR4inJP>+CHPuDk9`zs} z^X{QRw(ig%8k@28H_E!>j*gt3o*fxiMyS%sPE6=;s-@+k4lylFjD*H6+lJ|m5`>I{ zomF8=CGY?h>PS0p+Sur>ZetmiGCx0KnfmkOu~K(O<60sY)GH46}*!cy`M9 zypClk=Sl{bZ?*@8Y%6TJLcfK%v6c27Z@J|X8gX1%wygzhp;cv`;4T*NRurv1Zi2S7 zASg=Rg?aNEkCO6%?pazyEve6pWiL+T`SV1~_E z(RGsq9h`;@xEyQ;w%aVIS7xRh&-nOC!rxY$*N*Miz7S3oTkV2K%V*cRWqNy#Pf z%sUa$*4?rl+LWg9{n^>`zG@F?lT#SzncH#YJQMr_j&gG50(G{Ew0$)T3K|$H)`Gsu zQQ+Qfp!j^ASWK6S?WLRpH=%mHg)p5OUJWTL%)^`ju51i5Uo2~Z^eq{SOUl&wiwblZ z)GK>+R@7x!SF+)@wFv8|*k#jXHWNDyJy+0RShnG=Lj7OXi{k-$wgQz7los?Q^)mX1 z?M6h09Z)sRAUB_bXQEHao|D{D9}X-L6irE2oida^;Xy3`$u^Nc*Vc{GL>ggJ2y23n zhmwcRWs~8RZ>9imqCT65QEZEXCf-w{Pe{RkX1d6casz^jjhj)3^Cio1#W;sA+E7J~KwMabp2I#QtbF6hsFdM$AEuv%sl^p_ z)$yS*LZ}YRyio|OhvR~hC89cLOn|{s8@t0OxTLc@(=?6&9_l_kSg>agiw;~FGeX+N zB7D?w0z^1kWyn~VfJ{fZ>gxg39GVldS~ASCOYVwAt_!1VXfK^9D63Z4Ru(OE#S*C( z6unizYOtRLe^ek&4m>jqzO7v$hc8bKypKPvXPhZzc(JxZ5=)Muw<2X^MRoHK<`E#z zge^Ru;$R>6ki4n6c@iyl9BHpfIWGj39zP19aLXt^R)6eVvKDO_1swUMVYZyV z0!>1Y7MrmtH(>9iVi-j_Uhm6YR*Qy)7+(0%2)qSR;yI!U>ss&0As(?^(S`s$=IF%& zYYf0TG$Uymo5FpH;mIS&ujc`u?x@b1$Z?@_$_ z)W&=4g9IoZpQ&{CF=nORi$y94=phonW8cVW@E}Hht&Ol*vY(_vp@R7Hv22gv<`5zQ zMQwfAZl)-&S);C56zkHx{%tqhza6_dR_lMdnkwOUC-$pu{`9Z0f9vE=)t@cYezxR2 zqgSHDiPr9EnQxNJzgE_mcilurA_XJk^LU``;NmW>vSjzTK5-(c%GhweUeyttnYNVDL zsisCgU8yE!_+sOb|FT|>QAQ~rLOPI?C6FIWl&^HG$y=5gS(7hF;iaO7F9ldQ$Q0z< z?3CLMth@_59&iI`dt2_1+z!zST_HEO%aS?1S91M)q9nO(LGMCjA4Eo$nr4WuMc$LO z*qV$o{z1GMo+iH?S&`n1z9y|;<~3Psd!5Ok3Lk7^0mg|857Sy9!{kNajG0+j;2;QLRb;5x5GXp|WO!qU z^Lz+Bv7j(CJeV~E!ng50EYf-KAjpyO{DD<+50IWAA4GQ?+|cl81!4%f z;fdu{WGpoW*4TlYCeT?#z+%!8%7}(J41z-Li=+IAs#y*;tH44dcm;)21u0zJHu8KF z{6vS65b(6gAEqQKaP>hE$ck=TESM%wfyLUwiJ{oe)tN`p9C8P^%v4T#`;xqQazc=* zP?2A-iaO@xm@8*orBo*O32h9h7sHDXK2zxtP}m5i5=S)dD3t@_3Rq7|`|aax(oB`U z<2*+9_<``Wk`%rZai}uI!LfyUo_>I}mtawU8{w40nRFY|U-eGIF-#aoGY>UF>#cVN z45`N%!Rj5e(D6J?9<4|7MaRwnQF{V~Ls|#qXC~9$L-_9yDz3#k|1}LrV~fCSZj+LI z*N(kAefR0f>Mr_i4h&yA`*%@HzpD|E`^FzcqXRu(N+=pq zw7aK~XzLihm+ZUo^xvGle)byvzP{JHVa7~V_`zAOK{a;#@2g!b!Iv$mN9Zeq}kN*1b zt`ptTKXs3sn26>{TEs<)8?2BY?!&_t*FavAf3d}}gR+XKy#O!;CkaXk`%PaFDM+4+ zL!_oJs(D0|o{aHb5Tut|^%T<~$dOX224@vW)Q}TR8y9f~sV4!7$6EgW^<1{mG@=BS zT+Ck{O?yGAaLXM}ZRHulq#?5TqUt!=c~9KteQ?&oB_51J1N-wEre<6=G^RQDf>;1R zsLjuNc+JoAUE@Pq#sqvDx|9wrl+8SapRKCf1He_{qv=LUiY_k^$Z=qqqbA*yC7qp} z_mTxo3IEKNKwv&d9&*rO)$B2i)52d+)+W`MeLU^p*Dw#8d~NtObex2$7jWY~4#}Kw zkUJ^4lw&HQ((iF06V%;7S0=yf(pS5r-tF(6zWw8BYH}krSxZe;6O+t^X>!cSnPNhG z5)WI1SPDGaus0j_WFh1j9h^ooA%|ZP2zlOuNK)c7WFtKa`6TidLdgp_wypsa#gfR# z^*|Kp9D|M~m_pZ89Ak*E(M0}~#IgX-Zm9*DkV#9?O_rBnV<~2)7~Q}ou~rZ)Q>@o~h#re5h5 zJZG<;QYY@Yel<+&cHjT2JJ0_r`|0ez%vDq8H&W+osq@vudB%2|T<<2{gL9nsMLdvG zehGJeT}g$#)K=fq_0GPjcM#V!JMM@lJ!llk2CyL`(aJwxAi6h61&j2@xmTo>ajr#y zy|1T4HaJj*!kZEMR(~_EFS8SAaa@Nvyt8I(dX|asp$LZ2om?=64fh=>bp$m=LbAZp zDbxlzREredu7+Kh1443L?0rf{KpJ_krlFaSWA;;^g-!lE!Z&oTca$tRJ(g+YTX@~g zuo01SWk~S6shSRjokKT}Q4+}ktqzPYg{Q`?ha zq3&jCfC8GtNUI|7g+T+%W?@+WlL$i~02Kr!Bm`;-0)ARpE24^`7u97_|L~CVJiV4@ zr+$`_#fjficD{)Q^I@wXJmhH)1cOJJZ+=h{uuUjrrbT_N@u!p~d<3CDg4ywacRE1W z1cGHAAeWX>bzHUrY8V=?TAu!)4?RXq*@ZnF@!Z;ZfmU%|SNgP*$Jf za>%q14MG6vy#v11nSB#A#lKDvAOfipA|E~k^}HS-23s8+5n=fo zBpu_qJC<^yL`*%3+;5Atr97ea(=Xe_3|kuh8z7u%6i{G;kg@C8YS-?~f$cYsRg=p7 zuGIBo)h^}M$q!$-J2_q5M?Y%JR+GDblj^_m{LN#x_I)_EkvddM9jYb{wJJ0}bN6@P zZnHwWVul664LS8?*`7z6UvuTP@Y|N2KSUd;O?Iu5DEi|dilN+$7IC{ozh+yATx}>T z6ZC1eq@*yz(3?fL`HgKJAJCPTFwTG5g8x`Ej^Uo)9cd*9XGzjXWg&kvsb?BL0bgQsc-Pi^cuMG5ieL*Lb(@Y+{p)}cH8LPHXT-+?OjB;$Vu_$}qGj`&_eIb3W@5}4*< zm(m-yJ{NkVN6Piwf4n3C{#*h&~%Gl<|=WJ{z{ltlP&> z)Y}lyBNVO2bfm}a7^~tRIkAJNdS?)J^6;*keVsh@{pqP6o|!pqlN-W67*5d>Q!Qr* zO5z*~R&l5tzi7fZvG|;C3_@s&V0@D}%D-v;j{PIFlJRr~Q6jM_%bU_jwdHqT>RM-i zn^N~W``eU;s?EPmX+VdHdp>SE`4O*OU{r-l_HOM%!Ca8T@;6 O`GD1b`IuJ5)&Bz?1>rXU diff --git a/Modules/urllib3/util/__pycache__/url.cpython-311.pyc b/Modules/urllib3/util/__pycache__/url.cpython-311.pyc deleted file mode 100644 index 1297ca348d0181b43bbdb8ad61512c255208ebfc..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 17754 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 diff --git a/Modules/urllib3/util/__pycache__/util.cpython-311.pyc b/Modules/urllib3/util/__pycache__/util.cpython-311.pyc deleted file mode 100644 index a011f7563f384c781c29db2f146de1ac661e2254..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2149 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 JyqRzr{TClRD-i$y diff --git a/Modules/urllib3/util/connection.py b/Modules/urllib3/util/connection.py deleted file mode 100644 index 5c7da73..0000000 --- a/Modules/urllib3/util/connection.py +++ /dev/null @@ -1,137 +0,0 @@ -from __future__ import annotations - -import socket -import typing - -from ..exceptions import LocationParseError -from .timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT - -_TYPE_SOCKET_OPTIONS = typing.Sequence[typing.Tuple[int, int, typing.Union[int, bytes]]] - -if typing.TYPE_CHECKING: - from .._base_connection import BaseHTTPConnection - - -def is_connection_dropped(conn: BaseHTTPConnection) -> bool: # Platform-specific - """ - Returns True if the connection is dropped and should be closed. - :param conn: :class:`urllib3.connection.HTTPConnection` object. - """ - return not conn.is_connected - - -# This function is copied from socket.py in the Python 2.7 standard -# library test suite. Added to its signature is only `socket_options`. -# One additional modification is that we avoid binding to IPv6 servers -# discovered in DNS if the system doesn't have IPv6 functionality. -def create_connection( - address: tuple[str, int], - timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, - source_address: tuple[str, int] | None = None, - socket_options: _TYPE_SOCKET_OPTIONS | None = None, -) -> socket.socket: - """Connect to *address* and return the socket object. - - Convenience function. Connect to *address* (a 2-tuple ``(host, - port)``) and return the socket object. Passing the optional - *timeout* parameter will set the timeout on the socket instance - before attempting to connect. If no *timeout* is supplied, the - global default timeout setting returned by :func:`socket.getdefaulttimeout` - is used. If *source_address* is set it must be a tuple of (host, port) - for the socket to bind as a source address before making the connection. - An host of '' or port 0 tells the OS to use the default. - """ - - host, port = address - if host.startswith("["): - host = host.strip("[]") - err = None - - # Using the value from allowed_gai_family() in the context of getaddrinfo lets - # us select whether to work with IPv4 DNS records, IPv6 records, or both. - # The original create_connection function always returns all records. - family = allowed_gai_family() - - try: - host.encode("idna") - except UnicodeError: - raise LocationParseError(f"'{host}', label empty or too long") from None - - for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM): - af, socktype, proto, canonname, sa = res - sock = None - try: - sock = socket.socket(af, socktype, proto) - - # If provided, set socket level options before connecting. - _set_socket_options(sock, socket_options) - - if timeout is not _DEFAULT_TIMEOUT: - sock.settimeout(timeout) - if source_address: - sock.bind(source_address) - sock.connect(sa) - # Break explicitly a reference cycle - err = None - return sock - - except OSError as _: - err = _ - if sock is not None: - sock.close() - - if err is not None: - try: - raise err - finally: - # Break explicitly a reference cycle - err = None - else: - raise OSError("getaddrinfo returns an empty list") - - -def _set_socket_options( - sock: socket.socket, options: _TYPE_SOCKET_OPTIONS | None -) -> None: - if options is None: - return - - for opt in options: - sock.setsockopt(*opt) - - -def allowed_gai_family() -> socket.AddressFamily: - """This function is designed to work in the context of - getaddrinfo, where family=socket.AF_UNSPEC is the default and - will perform a DNS search for both IPv6 and IPv4 records.""" - - family = socket.AF_INET - if HAS_IPV6: - family = socket.AF_UNSPEC - return family - - -def _has_ipv6(host: str) -> bool: - """Returns True if the system can bind an IPv6 address.""" - sock = None - has_ipv6 = False - - if socket.has_ipv6: - # has_ipv6 returns true if cPython was compiled with IPv6 support. - # It does not tell us if the system has IPv6 support enabled. To - # determine that we must bind to an IPv6 address. - # https://github.com/urllib3/urllib3/pull/611 - # https://bugs.python.org/issue658327 - try: - sock = socket.socket(socket.AF_INET6) - sock.bind((host, 0)) - has_ipv6 = True - except Exception: - pass - - if sock: - sock.close() - return has_ipv6 - - -HAS_IPV6 = _has_ipv6("::1") diff --git a/Modules/urllib3/util/proxy.py b/Modules/urllib3/util/proxy.py deleted file mode 100644 index 908fc66..0000000 --- a/Modules/urllib3/util/proxy.py +++ /dev/null @@ -1,43 +0,0 @@ -from __future__ import annotations - -import typing - -from .url import Url - -if typing.TYPE_CHECKING: - from ..connection import ProxyConfig - - -def connection_requires_http_tunnel( - proxy_url: Url | None = None, - proxy_config: ProxyConfig | None = None, - destination_scheme: str | None = None, -) -> bool: - """ - Returns True if the connection requires an HTTP CONNECT through the proxy. - - :param URL proxy_url: - URL of the proxy. - :param ProxyConfig proxy_config: - Proxy configuration from poolmanager.py - :param str destination_scheme: - The scheme of the destination. (i.e https, http, etc) - """ - # If we're not using a proxy, no way to use a tunnel. - if proxy_url is None: - return False - - # HTTP destinations never require tunneling, we always forward. - if destination_scheme == "http": - return False - - # Support for forwarding with HTTPS proxies and HTTPS destinations. - if ( - proxy_url.scheme == "https" - and proxy_config - and proxy_config.use_forwarding_for_https - ): - return False - - # Otherwise always use a tunnel. - return True diff --git a/Modules/urllib3/util/request.py b/Modules/urllib3/util/request.py deleted file mode 100644 index e6905ff..0000000 --- a/Modules/urllib3/util/request.py +++ /dev/null @@ -1,256 +0,0 @@ -from __future__ import annotations - -import io -import typing -from base64 import b64encode -from enum import Enum - -from ..exceptions import UnrewindableBodyError -from .util import to_bytes - -if typing.TYPE_CHECKING: - from typing import Final - -# Pass as a value within ``headers`` to skip -# emitting some HTTP headers that are added automatically. -# The only headers that are supported are ``Accept-Encoding``, -# ``Host``, and ``User-Agent``. -SKIP_HEADER = "@@@SKIP_HEADER@@@" -SKIPPABLE_HEADERS = frozenset(["accept-encoding", "host", "user-agent"]) - -ACCEPT_ENCODING = "gzip,deflate" -try: - try: - import brotlicffi as _unused_module_brotli # type: ignore[import] # noqa: F401 - except ImportError: - import brotli as _unused_module_brotli # type: ignore[import] # noqa: F401 -except ImportError: - pass -else: - ACCEPT_ENCODING += ",br" -try: - import zstandard as _unused_module_zstd # type: ignore[import] # noqa: F401 -except ImportError: - pass -else: - ACCEPT_ENCODING += ",zstd" - - -class _TYPE_FAILEDTELL(Enum): - token = 0 - - -_FAILEDTELL: Final[_TYPE_FAILEDTELL] = _TYPE_FAILEDTELL.token - -_TYPE_BODY_POSITION = typing.Union[int, _TYPE_FAILEDTELL] - -# When sending a request with these methods we aren't expecting -# a body so don't need to set an explicit 'Content-Length: 0' -# The reason we do this in the negative instead of tracking methods -# which 'should' have a body is because unknown methods should be -# treated as if they were 'POST' which *does* expect a body. -_METHODS_NOT_EXPECTING_BODY = {"GET", "HEAD", "DELETE", "TRACE", "OPTIONS", "CONNECT"} - - -def make_headers( - keep_alive: bool | None = None, - accept_encoding: bool | list[str] | str | None = None, - user_agent: str | None = None, - basic_auth: str | None = None, - proxy_basic_auth: str | None = None, - disable_cache: bool | None = None, -) -> dict[str, str]: - """ - Shortcuts for generating request headers. - - :param keep_alive: - If ``True``, adds 'connection: keep-alive' header. - - :param accept_encoding: - Can be a boolean, list, or string. - ``True`` translates to 'gzip,deflate'. If either the ``brotli`` or - ``brotlicffi`` package is installed 'gzip,deflate,br' is used instead. - List will get joined by comma. - String will be used as provided. - - :param user_agent: - String representing the user-agent you want, such as - "python-urllib3/0.6" - - :param basic_auth: - Colon-separated username:password string for 'authorization: basic ...' - auth header. - - :param proxy_basic_auth: - Colon-separated username:password string for 'proxy-authorization: basic ...' - auth header. - - :param disable_cache: - If ``True``, adds 'cache-control: no-cache' header. - - Example: - - .. code-block:: python - - import urllib3 - - print(urllib3.util.make_headers(keep_alive=True, user_agent="Batman/1.0")) - # {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'} - print(urllib3.util.make_headers(accept_encoding=True)) - # {'accept-encoding': 'gzip,deflate'} - """ - headers: dict[str, str] = {} - if accept_encoding: - if isinstance(accept_encoding, str): - pass - elif isinstance(accept_encoding, list): - accept_encoding = ",".join(accept_encoding) - else: - accept_encoding = ACCEPT_ENCODING - headers["accept-encoding"] = accept_encoding - - if user_agent: - headers["user-agent"] = user_agent - - if keep_alive: - headers["connection"] = "keep-alive" - - if basic_auth: - headers[ - "authorization" - ] = f"Basic {b64encode(basic_auth.encode('latin-1')).decode()}" - - if proxy_basic_auth: - headers[ - "proxy-authorization" - ] = f"Basic {b64encode(proxy_basic_auth.encode('latin-1')).decode()}" - - if disable_cache: - headers["cache-control"] = "no-cache" - - return headers - - -def set_file_position( - body: typing.Any, pos: _TYPE_BODY_POSITION | None -) -> _TYPE_BODY_POSITION | None: - """ - If a position is provided, move file to that point. - Otherwise, we'll attempt to record a position for future use. - """ - if pos is not None: - rewind_body(body, pos) - elif getattr(body, "tell", None) is not None: - try: - pos = body.tell() - except OSError: - # This differentiates from None, allowing us to catch - # a failed `tell()` later when trying to rewind the body. - pos = _FAILEDTELL - - return pos - - -def rewind_body(body: typing.IO[typing.AnyStr], body_pos: _TYPE_BODY_POSITION) -> None: - """ - Attempt to rewind body to a certain position. - Primarily used for request redirects and retries. - - :param body: - File-like object that supports seek. - - :param int pos: - Position to seek to in file. - """ - body_seek = getattr(body, "seek", None) - if body_seek is not None and isinstance(body_pos, int): - try: - body_seek(body_pos) - except OSError as e: - raise UnrewindableBodyError( - "An error occurred when rewinding request body for redirect/retry." - ) from e - elif body_pos is _FAILEDTELL: - raise UnrewindableBodyError( - "Unable to record file position for rewinding " - "request body during a redirect/retry." - ) - else: - raise ValueError( - f"body_pos must be of type integer, instead it was {type(body_pos)}." - ) - - -class ChunksAndContentLength(typing.NamedTuple): - chunks: typing.Iterable[bytes] | None - content_length: int | None - - -def body_to_chunks( - body: typing.Any | None, method: str, blocksize: int -) -> ChunksAndContentLength: - """Takes the HTTP request method, body, and blocksize and - transforms them into an iterable of chunks to pass to - socket.sendall() and an optional 'Content-Length' header. - - A 'Content-Length' of 'None' indicates the length of the body - can't be determined so should use 'Transfer-Encoding: chunked' - for framing instead. - """ - - chunks: typing.Iterable[bytes] | None - content_length: int | None - - # No body, we need to make a recommendation on 'Content-Length' - # based on whether that request method is expected to have - # a body or not. - if body is None: - chunks = None - if method.upper() not in _METHODS_NOT_EXPECTING_BODY: - content_length = 0 - else: - content_length = None - - # Bytes or strings become bytes - elif isinstance(body, (str, bytes)): - chunks = (to_bytes(body),) - content_length = len(chunks[0]) - - # File-like object, TODO: use seek() and tell() for length? - elif hasattr(body, "read"): - - def chunk_readable() -> typing.Iterable[bytes]: - nonlocal body, blocksize - encode = isinstance(body, io.TextIOBase) - while True: - datablock = body.read(blocksize) - if not datablock: - break - if encode: - datablock = datablock.encode("iso-8859-1") - yield datablock - - chunks = chunk_readable() - content_length = None - - # Otherwise we need to start checking via duck-typing. - else: - try: - # Check if the body implements the buffer API. - mv = memoryview(body) - except TypeError: - try: - # Check if the body is an iterable - chunks = iter(body) - content_length = None - except TypeError: - raise TypeError( - f"'body' must be a bytes-like object, file-like " - f"object, or iterable. Instead was {body!r}" - ) from None - else: - # Since it implements the buffer API can be passed directly to socket.sendall() - chunks = (body,) - content_length = mv.nbytes - - return ChunksAndContentLength(chunks=chunks, content_length=content_length) diff --git a/Modules/urllib3/util/response.py b/Modules/urllib3/util/response.py deleted file mode 100644 index 0f45786..0000000 --- a/Modules/urllib3/util/response.py +++ /dev/null @@ -1,101 +0,0 @@ -from __future__ import annotations - -import http.client as httplib -from email.errors import MultipartInvariantViolationDefect, StartBoundaryNotFoundDefect - -from ..exceptions import HeaderParsingError - - -def is_fp_closed(obj: object) -> bool: - """ - Checks whether a given file-like object is closed. - - :param obj: - The file-like object to check. - """ - - try: - # Check `isclosed()` first, in case Python3 doesn't set `closed`. - # GH Issue #928 - return obj.isclosed() # type: ignore[no-any-return, attr-defined] - except AttributeError: - pass - - try: - # Check via the official file-like-object way. - return obj.closed # type: ignore[no-any-return, attr-defined] - except AttributeError: - pass - - try: - # Check if the object is a container for another file-like object that - # gets released on exhaustion (e.g. HTTPResponse). - return obj.fp is None # type: ignore[attr-defined] - except AttributeError: - pass - - raise ValueError("Unable to determine whether fp is closed.") - - -def assert_header_parsing(headers: httplib.HTTPMessage) -> None: - """ - Asserts whether all headers have been successfully parsed. - Extracts encountered errors from the result of parsing headers. - - Only works on Python 3. - - :param http.client.HTTPMessage headers: Headers to verify. - - :raises urllib3.exceptions.HeaderParsingError: - If parsing errors are found. - """ - - # This will fail silently if we pass in the wrong kind of parameter. - # To make debugging easier add an explicit check. - if not isinstance(headers, httplib.HTTPMessage): - raise TypeError(f"expected httplib.Message, got {type(headers)}.") - - unparsed_data = None - - # get_payload is actually email.message.Message.get_payload; - # we're only interested in the result if it's not a multipart message - if not headers.is_multipart(): - payload = headers.get_payload() - - if isinstance(payload, (bytes, str)): - unparsed_data = payload - - # httplib is assuming a response body is available - # when parsing headers even when httplib only sends - # header data to parse_headers() This results in - # defects on multipart responses in particular. - # See: https://github.com/urllib3/urllib3/issues/800 - - # So we ignore the following defects: - # - StartBoundaryNotFoundDefect: - # The claimed start boundary was never found. - # - MultipartInvariantViolationDefect: - # A message claimed to be a multipart but no subparts were found. - defects = [ - defect - for defect in headers.defects - if not isinstance( - defect, (StartBoundaryNotFoundDefect, MultipartInvariantViolationDefect) - ) - ] - - if defects or unparsed_data: - raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data) - - -def is_response_to_head(response: httplib.HTTPResponse) -> bool: - """ - Checks whether the request of a response has been a HEAD-request. - - :param http.client.HTTPResponse response: - Response to check if the originating request - used 'HEAD' as a method. - """ - # FIXME: Can we do this somehow without accessing private httplib _method? - method_str = response._method # type: str # type: ignore[attr-defined] - return method_str.upper() == "HEAD" diff --git a/Modules/urllib3/util/retry.py b/Modules/urllib3/util/retry.py deleted file mode 100644 index 7572bfd..0000000 --- a/Modules/urllib3/util/retry.py +++ /dev/null @@ -1,529 +0,0 @@ -from __future__ import annotations - -import email -import logging -import random -import re -import time -import typing -from itertools import takewhile -from types import TracebackType - -from ..exceptions import ( - ConnectTimeoutError, - InvalidHeader, - MaxRetryError, - ProtocolError, - ProxyError, - ReadTimeoutError, - ResponseError, -) -from .util import reraise - -if typing.TYPE_CHECKING: - from ..connectionpool import ConnectionPool - from ..response import BaseHTTPResponse - -log = logging.getLogger(__name__) - - -# Data structure for representing the metadata of requests that result in a retry. -class RequestHistory(typing.NamedTuple): - method: str | None - url: str | None - error: Exception | None - status: int | None - redirect_location: str | None - - -class Retry: - """Retry configuration. - - Each retry attempt will create a new Retry object with updated values, so - they can be safely reused. - - Retries can be defined as a default for a pool: - - .. code-block:: python - - retries = Retry(connect=5, read=2, redirect=5) - http = PoolManager(retries=retries) - response = http.request("GET", "https://example.com/") - - Or per-request (which overrides the default for the pool): - - .. code-block:: python - - response = http.request("GET", "https://example.com/", retries=Retry(10)) - - Retries can be disabled by passing ``False``: - - .. code-block:: python - - response = http.request("GET", "https://example.com/", retries=False) - - Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless - retries are disabled, in which case the causing exception will be raised. - - :param int total: - Total number of retries to allow. Takes precedence over other counts. - - Set to ``None`` to remove this constraint and fall back on other - counts. - - Set to ``0`` to fail on the first retry. - - Set to ``False`` to disable and imply ``raise_on_redirect=False``. - - :param int connect: - How many connection-related errors to retry on. - - These are errors raised before the request is sent to the remote server, - which we assume has not triggered the server to process the request. - - Set to ``0`` to fail on the first retry of this type. - - :param int read: - How many times to retry on read errors. - - These errors are raised after the request was sent to the server, so the - request may have side-effects. - - Set to ``0`` to fail on the first retry of this type. - - :param int redirect: - How many redirects to perform. Limit this to avoid infinite redirect - loops. - - A redirect is a HTTP response with a status code 301, 302, 303, 307 or - 308. - - Set to ``0`` to fail on the first retry of this type. - - Set to ``False`` to disable and imply ``raise_on_redirect=False``. - - :param int status: - How many times to retry on bad status codes. - - These are retries made on responses, where status code matches - ``status_forcelist``. - - Set to ``0`` to fail on the first retry of this type. - - :param int other: - How many times to retry on other errors. - - Other errors are errors that are not connect, read, redirect or status errors. - These errors might be raised after the request was sent to the server, so the - request might have side-effects. - - Set to ``0`` to fail on the first retry of this type. - - If ``total`` is not set, it's a good idea to set this to 0 to account - for unexpected edge cases and avoid infinite retry loops. - - :param Collection allowed_methods: - Set of uppercased HTTP method verbs that we should retry on. - - By default, we only retry on methods which are considered to be - idempotent (multiple requests with the same parameters end with the - same state). See :attr:`Retry.DEFAULT_ALLOWED_METHODS`. - - Set to a ``None`` value to retry on any verb. - - :param Collection status_forcelist: - A set of integer HTTP status codes that we should force a retry on. - A retry is initiated if the request method is in ``allowed_methods`` - and the response status code is in ``status_forcelist``. - - By default, this is disabled with ``None``. - - :param float backoff_factor: - A backoff factor to apply between attempts after the second try - (most errors are resolved immediately by a second try without a - delay). urllib3 will sleep for:: - - {backoff factor} * (2 ** ({number of previous retries})) - - seconds. If `backoff_jitter` is non-zero, this sleep is extended by:: - - random.uniform(0, {backoff jitter}) - - seconds. For example, if the backoff_factor is 0.1, then :func:`Retry.sleep` will - sleep for [0.0s, 0.2s, 0.4s, 0.8s, ...] between retries. No backoff will ever - be longer than `backoff_max`. - - By default, backoff is disabled (factor set to 0). - - :param bool raise_on_redirect: Whether, if the number of redirects is - exhausted, to raise a MaxRetryError, or to return a response with a - response code in the 3xx range. - - :param bool raise_on_status: Similar meaning to ``raise_on_redirect``: - whether we should raise an exception, or return a response, - if status falls in ``status_forcelist`` range and retries have - been exhausted. - - :param tuple history: The history of the request encountered during - each call to :meth:`~Retry.increment`. The list is in the order - the requests occurred. Each list item is of class :class:`RequestHistory`. - - :param bool respect_retry_after_header: - Whether to respect Retry-After header on status codes defined as - :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not. - - :param Collection remove_headers_on_redirect: - Sequence of headers to remove from the request when a response - indicating a redirect is returned before firing off the redirected - request. - """ - - #: Default methods to be used for ``allowed_methods`` - DEFAULT_ALLOWED_METHODS = frozenset( - ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"] - ) - - #: Default status codes to be used for ``status_forcelist`` - RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503]) - - #: Default headers to be used for ``remove_headers_on_redirect`` - DEFAULT_REMOVE_HEADERS_ON_REDIRECT = frozenset(["Cookie", "Authorization"]) - - #: Default maximum backoff time. - DEFAULT_BACKOFF_MAX = 120 - - # Backward compatibility; assigned outside of the class. - DEFAULT: typing.ClassVar[Retry] - - def __init__( - self, - total: bool | int | None = 10, - connect: int | None = None, - read: int | None = None, - redirect: bool | int | None = None, - status: int | None = None, - other: int | None = None, - allowed_methods: typing.Collection[str] | None = DEFAULT_ALLOWED_METHODS, - status_forcelist: typing.Collection[int] | None = None, - backoff_factor: float = 0, - backoff_max: float = DEFAULT_BACKOFF_MAX, - raise_on_redirect: bool = True, - raise_on_status: bool = True, - history: tuple[RequestHistory, ...] | None = None, - respect_retry_after_header: bool = True, - remove_headers_on_redirect: typing.Collection[ - str - ] = DEFAULT_REMOVE_HEADERS_ON_REDIRECT, - backoff_jitter: float = 0.0, - ) -> None: - self.total = total - self.connect = connect - self.read = read - self.status = status - self.other = other - - if redirect is False or total is False: - redirect = 0 - raise_on_redirect = False - - self.redirect = redirect - self.status_forcelist = status_forcelist or set() - self.allowed_methods = allowed_methods - self.backoff_factor = backoff_factor - self.backoff_max = backoff_max - self.raise_on_redirect = raise_on_redirect - self.raise_on_status = raise_on_status - self.history = history or () - self.respect_retry_after_header = respect_retry_after_header - self.remove_headers_on_redirect = frozenset( - h.lower() for h in remove_headers_on_redirect - ) - self.backoff_jitter = backoff_jitter - - def new(self, **kw: typing.Any) -> Retry: - params = dict( - total=self.total, - connect=self.connect, - read=self.read, - redirect=self.redirect, - status=self.status, - other=self.other, - allowed_methods=self.allowed_methods, - status_forcelist=self.status_forcelist, - backoff_factor=self.backoff_factor, - backoff_max=self.backoff_max, - raise_on_redirect=self.raise_on_redirect, - raise_on_status=self.raise_on_status, - history=self.history, - remove_headers_on_redirect=self.remove_headers_on_redirect, - respect_retry_after_header=self.respect_retry_after_header, - backoff_jitter=self.backoff_jitter, - ) - - params.update(kw) - return type(self)(**params) # type: ignore[arg-type] - - @classmethod - def from_int( - cls, - retries: Retry | bool | int | None, - redirect: bool | int | None = True, - default: Retry | bool | int | None = None, - ) -> Retry: - """Backwards-compatibility for the old retries format.""" - if retries is None: - retries = default if default is not None else cls.DEFAULT - - if isinstance(retries, Retry): - return retries - - redirect = bool(redirect) and None - new_retries = cls(retries, redirect=redirect) - log.debug("Converted retries value: %r -> %r", retries, new_retries) - return new_retries - - def get_backoff_time(self) -> float: - """Formula for computing the current backoff - - :rtype: float - """ - # We want to consider only the last consecutive errors sequence (Ignore redirects). - consecutive_errors_len = len( - list( - takewhile(lambda x: x.redirect_location is None, reversed(self.history)) - ) - ) - if consecutive_errors_len <= 1: - return 0 - - backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1)) - if self.backoff_jitter != 0.0: - backoff_value += random.random() * self.backoff_jitter - return float(max(0, min(self.backoff_max, backoff_value))) - - def parse_retry_after(self, retry_after: str) -> float: - seconds: float - # Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4 - if re.match(r"^\s*[0-9]+\s*$", retry_after): - seconds = int(retry_after) - else: - retry_date_tuple = email.utils.parsedate_tz(retry_after) - if retry_date_tuple is None: - raise InvalidHeader(f"Invalid Retry-After header: {retry_after}") - - retry_date = email.utils.mktime_tz(retry_date_tuple) - seconds = retry_date - time.time() - - seconds = max(seconds, 0) - - return seconds - - def get_retry_after(self, response: BaseHTTPResponse) -> float | None: - """Get the value of Retry-After in seconds.""" - - retry_after = response.headers.get("Retry-After") - - if retry_after is None: - return None - - return self.parse_retry_after(retry_after) - - def sleep_for_retry(self, response: BaseHTTPResponse) -> bool: - retry_after = self.get_retry_after(response) - if retry_after: - time.sleep(retry_after) - return True - - return False - - def _sleep_backoff(self) -> None: - backoff = self.get_backoff_time() - if backoff <= 0: - return - time.sleep(backoff) - - def sleep(self, response: BaseHTTPResponse | None = None) -> None: - """Sleep between retry attempts. - - This method will respect a server's ``Retry-After`` response header - and sleep the duration of the time requested. If that is not present, it - will use an exponential backoff. By default, the backoff factor is 0 and - this method will return immediately. - """ - - if self.respect_retry_after_header and response: - slept = self.sleep_for_retry(response) - if slept: - return - - self._sleep_backoff() - - def _is_connection_error(self, err: Exception) -> bool: - """Errors when we're fairly sure that the server did not receive the - request, so it should be safe to retry. - """ - if isinstance(err, ProxyError): - err = err.original_error - return isinstance(err, ConnectTimeoutError) - - def _is_read_error(self, err: Exception) -> bool: - """Errors that occur after the request has been started, so we should - assume that the server began processing it. - """ - return isinstance(err, (ReadTimeoutError, ProtocolError)) - - def _is_method_retryable(self, method: str) -> bool: - """Checks if a given HTTP method should be retried upon, depending if - it is included in the allowed_methods - """ - if self.allowed_methods and method.upper() not in self.allowed_methods: - return False - return True - - def is_retry( - self, method: str, status_code: int, has_retry_after: bool = False - ) -> bool: - """Is this method/status code retryable? (Based on allowlists and control - variables such as the number of total retries to allow, whether to - respect the Retry-After header, whether this header is present, and - whether the returned status code is on the list of status codes to - be retried upon on the presence of the aforementioned header) - """ - if not self._is_method_retryable(method): - return False - - if self.status_forcelist and status_code in self.status_forcelist: - return True - - return bool( - self.total - and self.respect_retry_after_header - and has_retry_after - and (status_code in self.RETRY_AFTER_STATUS_CODES) - ) - - def is_exhausted(self) -> bool: - """Are we out of retries?""" - retry_counts = [ - x - for x in ( - self.total, - self.connect, - self.read, - self.redirect, - self.status, - self.other, - ) - if x - ] - if not retry_counts: - return False - - return min(retry_counts) < 0 - - def increment( - self, - method: str | None = None, - url: str | None = None, - response: BaseHTTPResponse | None = None, - error: Exception | None = None, - _pool: ConnectionPool | None = None, - _stacktrace: TracebackType | None = None, - ) -> Retry: - """Return a new Retry object with incremented retry counters. - - :param response: A response object, or None, if the server did not - return a response. - :type response: :class:`~urllib3.response.BaseHTTPResponse` - :param Exception error: An error encountered during the request, or - None if the response was received successfully. - - :return: A new ``Retry`` object. - """ - if self.total is False and error: - # Disabled, indicate to re-raise the error. - raise reraise(type(error), error, _stacktrace) - - total = self.total - if total is not None: - total -= 1 - - connect = self.connect - read = self.read - redirect = self.redirect - status_count = self.status - other = self.other - cause = "unknown" - status = None - redirect_location = None - - if error and self._is_connection_error(error): - # Connect retry? - if connect is False: - raise reraise(type(error), error, _stacktrace) - elif connect is not None: - connect -= 1 - - elif error and self._is_read_error(error): - # Read retry? - if read is False or method is None or not self._is_method_retryable(method): - raise reraise(type(error), error, _stacktrace) - elif read is not None: - read -= 1 - - elif error: - # Other retry? - if other is not None: - other -= 1 - - elif response and response.get_redirect_location(): - # Redirect retry? - if redirect is not None: - redirect -= 1 - cause = "too many redirects" - response_redirect_location = response.get_redirect_location() - if response_redirect_location: - redirect_location = response_redirect_location - status = response.status - - else: - # Incrementing because of a server error like a 500 in - # status_forcelist and the given method is in the allowed_methods - cause = ResponseError.GENERIC_ERROR - if response and response.status: - if status_count is not None: - status_count -= 1 - cause = ResponseError.SPECIFIC_ERROR.format(status_code=response.status) - status = response.status - - history = self.history + ( - RequestHistory(method, url, error, status, redirect_location), - ) - - new_retry = self.new( - total=total, - connect=connect, - read=read, - redirect=redirect, - status=status_count, - other=other, - history=history, - ) - - if new_retry.is_exhausted(): - reason = error or ResponseError(cause) - raise MaxRetryError(_pool, url, reason) from reason # type: ignore[arg-type] - - log.debug("Incremented Retry for (url='%s'): %r", url, new_retry) - - return new_retry - - def __repr__(self) -> str: - return ( - f"{type(self).__name__}(total={self.total}, connect={self.connect}, " - f"read={self.read}, redirect={self.redirect}, status={self.status})" - ) - - -# For backwards compatibility (equivalent to pre-v1.9): -Retry.DEFAULT = Retry(3) diff --git a/Modules/urllib3/util/ssl_.py b/Modules/urllib3/util/ssl_.py deleted file mode 100644 index e0a7c04..0000000 --- a/Modules/urllib3/util/ssl_.py +++ /dev/null @@ -1,514 +0,0 @@ -from __future__ import annotations - -import hmac -import os -import socket -import sys -import typing -import warnings -from binascii import unhexlify -from hashlib import md5, sha1, sha256 - -from ..exceptions import ProxySchemeUnsupported, SSLError -from .url import _BRACELESS_IPV6_ADDRZ_RE, _IPV4_RE - -SSLContext = None -SSLTransport = None -HAS_NEVER_CHECK_COMMON_NAME = False -IS_PYOPENSSL = False -ALPN_PROTOCOLS = ["http/1.1"] - -_TYPE_VERSION_INFO = typing.Tuple[int, int, int, str, int] - -# Maps the length of a digest to a possible hash function producing this digest -HASHFUNC_MAP = {32: md5, 40: sha1, 64: sha256} - - -def _is_bpo_43522_fixed( - implementation_name: str, - version_info: _TYPE_VERSION_INFO, - pypy_version_info: _TYPE_VERSION_INFO | None, -) -> bool: - """Return True for CPython 3.8.9+, 3.9.3+ or 3.10+ and PyPy 7.3.8+ where - setting SSLContext.hostname_checks_common_name to False works. - - Outside of CPython and PyPy we don't know which implementations work - or not so we conservatively use our hostname matching as we know that works - on all implementations. - - https://github.com/urllib3/urllib3/issues/2192#issuecomment-821832963 - https://foss.heptapod.net/pypy/pypy/-/issues/3539 - """ - if implementation_name == "pypy": - # https://foss.heptapod.net/pypy/pypy/-/issues/3129 - return pypy_version_info >= (7, 3, 8) # type: ignore[operator] - elif implementation_name == "cpython": - major_minor = version_info[:2] - micro = version_info[2] - return ( - (major_minor == (3, 8) and micro >= 9) - or (major_minor == (3, 9) and micro >= 3) - or major_minor >= (3, 10) - ) - else: # Defensive: - return False - - -def _is_has_never_check_common_name_reliable( - openssl_version: str, - openssl_version_number: int, - implementation_name: str, - version_info: _TYPE_VERSION_INFO, - pypy_version_info: _TYPE_VERSION_INFO | None, -) -> bool: - # As of May 2023, all released versions of LibreSSL fail to reject certificates with - # only common names, see https://github.com/urllib3/urllib3/pull/3024 - is_openssl = openssl_version.startswith("OpenSSL ") - # Before fixing OpenSSL issue #14579, the SSL_new() API was not copying hostflags - # like X509_CHECK_FLAG_NEVER_CHECK_SUBJECT, which tripped up CPython. - # https://github.com/openssl/openssl/issues/14579 - # This was released in OpenSSL 1.1.1l+ (>=0x101010cf) - is_openssl_issue_14579_fixed = openssl_version_number >= 0x101010CF - - return is_openssl and ( - is_openssl_issue_14579_fixed - or _is_bpo_43522_fixed(implementation_name, version_info, pypy_version_info) - ) - - -if typing.TYPE_CHECKING: - from ssl import VerifyMode - from typing import Literal, TypedDict - - from .ssltransport import SSLTransport as SSLTransportType - - class _TYPE_PEER_CERT_RET_DICT(TypedDict, total=False): - subjectAltName: tuple[tuple[str, str], ...] - subject: tuple[tuple[tuple[str, str], ...], ...] - serialNumber: str - - -# Mapping from 'ssl.PROTOCOL_TLSX' to 'TLSVersion.X' -_SSL_VERSION_TO_TLS_VERSION: dict[int, int] = {} - -try: # Do we have ssl at all? - import ssl - from ssl import ( # type: ignore[assignment] - CERT_REQUIRED, - HAS_NEVER_CHECK_COMMON_NAME, - OP_NO_COMPRESSION, - OP_NO_TICKET, - OPENSSL_VERSION, - OPENSSL_VERSION_NUMBER, - PROTOCOL_TLS, - PROTOCOL_TLS_CLIENT, - OP_NO_SSLv2, - OP_NO_SSLv3, - SSLContext, - TLSVersion, - ) - - PROTOCOL_SSLv23 = PROTOCOL_TLS - - # Setting SSLContext.hostname_checks_common_name = False didn't work before CPython - # 3.8.9, 3.9.3, and 3.10 (but OK on PyPy) or OpenSSL 1.1.1l+ - if HAS_NEVER_CHECK_COMMON_NAME and not _is_has_never_check_common_name_reliable( - OPENSSL_VERSION, - OPENSSL_VERSION_NUMBER, - sys.implementation.name, - sys.version_info, - sys.pypy_version_info if sys.implementation.name == "pypy" else None, # type: ignore[attr-defined] - ): - HAS_NEVER_CHECK_COMMON_NAME = False - - # Need to be careful here in case old TLS versions get - # removed in future 'ssl' module implementations. - for attr in ("TLSv1", "TLSv1_1", "TLSv1_2"): - try: - _SSL_VERSION_TO_TLS_VERSION[getattr(ssl, f"PROTOCOL_{attr}")] = getattr( - TLSVersion, attr - ) - except AttributeError: # Defensive: - continue - - from .ssltransport import SSLTransport # type: ignore[assignment] -except ImportError: - OP_NO_COMPRESSION = 0x20000 # type: ignore[assignment] - OP_NO_TICKET = 0x4000 # type: ignore[assignment] - OP_NO_SSLv2 = 0x1000000 # type: ignore[assignment] - OP_NO_SSLv3 = 0x2000000 # type: ignore[assignment] - PROTOCOL_SSLv23 = PROTOCOL_TLS = 2 # type: ignore[assignment] - PROTOCOL_TLS_CLIENT = 16 # type: ignore[assignment] - - -_TYPE_PEER_CERT_RET = typing.Union["_TYPE_PEER_CERT_RET_DICT", bytes, None] - - -def assert_fingerprint(cert: bytes | None, fingerprint: str) -> None: - """ - Checks if given fingerprint matches the supplied certificate. - - :param cert: - Certificate as bytes object. - :param fingerprint: - Fingerprint as string of hexdigits, can be interspersed by colons. - """ - - if cert is None: - raise SSLError("No certificate for the peer.") - - fingerprint = fingerprint.replace(":", "").lower() - digest_length = len(fingerprint) - hashfunc = HASHFUNC_MAP.get(digest_length) - if not hashfunc: - raise SSLError(f"Fingerprint of invalid length: {fingerprint}") - - # We need encode() here for py32; works on py2 and p33. - fingerprint_bytes = unhexlify(fingerprint.encode()) - - cert_digest = hashfunc(cert).digest() - - if not hmac.compare_digest(cert_digest, fingerprint_bytes): - raise SSLError( - f'Fingerprints did not match. Expected "{fingerprint}", got "{cert_digest.hex()}"' - ) - - -def resolve_cert_reqs(candidate: None | int | str) -> VerifyMode: - """ - Resolves the argument to a numeric constant, which can be passed to - the wrap_socket function/method from the ssl module. - Defaults to :data:`ssl.CERT_REQUIRED`. - If given a string it is assumed to be the name of the constant in the - :mod:`ssl` module or its abbreviation. - (So you can specify `REQUIRED` instead of `CERT_REQUIRED`. - If it's neither `None` nor a string we assume it is already the numeric - constant which can directly be passed to wrap_socket. - """ - if candidate is None: - return CERT_REQUIRED - - if isinstance(candidate, str): - res = getattr(ssl, candidate, None) - if res is None: - res = getattr(ssl, "CERT_" + candidate) - return res # type: ignore[no-any-return] - - return candidate # type: ignore[return-value] - - -def resolve_ssl_version(candidate: None | int | str) -> int: - """ - like resolve_cert_reqs - """ - if candidate is None: - return PROTOCOL_TLS - - if isinstance(candidate, str): - res = getattr(ssl, candidate, None) - if res is None: - res = getattr(ssl, "PROTOCOL_" + candidate) - return typing.cast(int, res) - - return candidate - - -def create_urllib3_context( - ssl_version: int | None = None, - cert_reqs: int | None = None, - options: int | None = None, - ciphers: str | None = None, - ssl_minimum_version: int | None = None, - ssl_maximum_version: int | None = None, -) -> ssl.SSLContext: - """Creates and configures an :class:`ssl.SSLContext` instance for use with urllib3. - - :param ssl_version: - The desired protocol version to use. This will default to - PROTOCOL_SSLv23 which will negotiate the highest protocol that both - the server and your installation of OpenSSL support. - - This parameter is deprecated instead use 'ssl_minimum_version'. - :param ssl_minimum_version: - The minimum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value. - :param ssl_maximum_version: - The maximum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value. - Not recommended to set to anything other than 'ssl.TLSVersion.MAXIMUM_SUPPORTED' which is the - default value. - :param cert_reqs: - Whether to require the certificate verification. This defaults to - ``ssl.CERT_REQUIRED``. - :param options: - Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``, - ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``, and ``ssl.OP_NO_TICKET``. - :param ciphers: - Which cipher suites to allow the server to select. Defaults to either system configured - ciphers if OpenSSL 1.1.1+, otherwise uses a secure default set of ciphers. - :returns: - Constructed SSLContext object with specified options - :rtype: SSLContext - """ - if SSLContext is None: - raise TypeError("Can't create an SSLContext object without an ssl module") - - # This means 'ssl_version' was specified as an exact value. - if ssl_version not in (None, PROTOCOL_TLS, PROTOCOL_TLS_CLIENT): - # Disallow setting 'ssl_version' and 'ssl_minimum|maximum_version' - # to avoid conflicts. - if ssl_minimum_version is not None or ssl_maximum_version is not None: - raise ValueError( - "Can't specify both 'ssl_version' and either " - "'ssl_minimum_version' or 'ssl_maximum_version'" - ) - - # 'ssl_version' is deprecated and will be removed in the future. - else: - # Use 'ssl_minimum_version' and 'ssl_maximum_version' instead. - ssl_minimum_version = _SSL_VERSION_TO_TLS_VERSION.get( - ssl_version, TLSVersion.MINIMUM_SUPPORTED - ) - ssl_maximum_version = _SSL_VERSION_TO_TLS_VERSION.get( - ssl_version, TLSVersion.MAXIMUM_SUPPORTED - ) - - # This warning message is pushing users to use 'ssl_minimum_version' - # instead of both min/max. Best practice is to only set the minimum version and - # keep the maximum version to be it's default value: 'TLSVersion.MAXIMUM_SUPPORTED' - warnings.warn( - "'ssl_version' option is deprecated and will be " - "removed in urllib3 v2.1.0. Instead use 'ssl_minimum_version'", - category=DeprecationWarning, - stacklevel=2, - ) - - # PROTOCOL_TLS is deprecated in Python 3.10 so we always use PROTOCOL_TLS_CLIENT - context = SSLContext(PROTOCOL_TLS_CLIENT) - - if ssl_minimum_version is not None: - context.minimum_version = ssl_minimum_version - else: # Python <3.10 defaults to 'MINIMUM_SUPPORTED' so explicitly set TLSv1.2 here - context.minimum_version = TLSVersion.TLSv1_2 - - if ssl_maximum_version is not None: - context.maximum_version = ssl_maximum_version - - # Unless we're given ciphers defer to either system ciphers in - # the case of OpenSSL 1.1.1+ or use our own secure default ciphers. - if ciphers: - context.set_ciphers(ciphers) - - # Setting the default here, as we may have no ssl module on import - cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs - - if options is None: - options = 0 - # SSLv2 is easily broken and is considered harmful and dangerous - options |= OP_NO_SSLv2 - # SSLv3 has several problems and is now dangerous - options |= OP_NO_SSLv3 - # Disable compression to prevent CRIME attacks for OpenSSL 1.0+ - # (issue #309) - options |= OP_NO_COMPRESSION - # TLSv1.2 only. Unless set explicitly, do not request tickets. - # This may save some bandwidth on wire, and although the ticket is encrypted, - # there is a risk associated with it being on wire, - # if the server is not rotating its ticketing keys properly. - options |= OP_NO_TICKET - - context.options |= options - - # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is - # necessary for conditional client cert authentication with TLS 1.3. - # The attribute is None for OpenSSL <= 1.1.0 or does not exist in older - # versions of Python. We only enable if certificate verification is enabled to work - # around Python issue #37428 - # See: https://bugs.python.org/issue37428 - if ( - cert_reqs == ssl.CERT_REQUIRED - and getattr(context, "post_handshake_auth", None) is not None - ): - context.post_handshake_auth = True - - # The order of the below lines setting verify_mode and check_hostname - # matter due to safe-guards SSLContext has to prevent an SSLContext with - # check_hostname=True, verify_mode=NONE/OPTIONAL. - # We always set 'check_hostname=False' for pyOpenSSL so we rely on our own - # 'ssl.match_hostname()' implementation. - if cert_reqs == ssl.CERT_REQUIRED and not IS_PYOPENSSL: - context.verify_mode = cert_reqs - context.check_hostname = True - else: - context.check_hostname = False - context.verify_mode = cert_reqs - - try: - context.hostname_checks_common_name = False - except AttributeError: # Defensive: for CPython < 3.8.9 and 3.9.3; for PyPy < 7.3.8 - pass - - # Enable logging of TLS session keys via defacto standard environment variable - # 'SSLKEYLOGFILE', if the feature is available (Python 3.8+). Skip empty values. - if hasattr(context, "keylog_filename"): - sslkeylogfile = os.environ.get("SSLKEYLOGFILE") - if sslkeylogfile: - context.keylog_filename = sslkeylogfile - - return context - - -@typing.overload -def ssl_wrap_socket( - sock: socket.socket, - keyfile: str | None = ..., - certfile: str | None = ..., - cert_reqs: int | None = ..., - ca_certs: str | None = ..., - server_hostname: str | None = ..., - ssl_version: int | None = ..., - ciphers: str | None = ..., - ssl_context: ssl.SSLContext | None = ..., - ca_cert_dir: str | None = ..., - key_password: str | None = ..., - ca_cert_data: None | str | bytes = ..., - tls_in_tls: Literal[False] = ..., -) -> ssl.SSLSocket: - ... - - -@typing.overload -def ssl_wrap_socket( - sock: socket.socket, - keyfile: str | None = ..., - certfile: str | None = ..., - cert_reqs: int | None = ..., - ca_certs: str | None = ..., - server_hostname: str | None = ..., - ssl_version: int | None = ..., - ciphers: str | None = ..., - ssl_context: ssl.SSLContext | None = ..., - ca_cert_dir: str | None = ..., - key_password: str | None = ..., - ca_cert_data: None | str | bytes = ..., - tls_in_tls: bool = ..., -) -> ssl.SSLSocket | SSLTransportType: - ... - - -def ssl_wrap_socket( - sock: socket.socket, - keyfile: str | None = None, - certfile: str | None = None, - cert_reqs: int | None = None, - ca_certs: str | None = None, - server_hostname: str | None = None, - ssl_version: int | None = None, - ciphers: str | None = None, - ssl_context: ssl.SSLContext | None = None, - ca_cert_dir: str | None = None, - key_password: str | None = None, - ca_cert_data: None | str | bytes = None, - tls_in_tls: bool = False, -) -> ssl.SSLSocket | SSLTransportType: - """ - All arguments except for server_hostname, ssl_context, tls_in_tls, ca_cert_data and - ca_cert_dir have the same meaning as they do when using - :func:`ssl.create_default_context`, :meth:`ssl.SSLContext.load_cert_chain`, - :meth:`ssl.SSLContext.set_ciphers` and :meth:`ssl.SSLContext.wrap_socket`. - - :param server_hostname: - When SNI is supported, the expected hostname of the certificate - :param ssl_context: - A pre-made :class:`SSLContext` object. If none is provided, one will - be created using :func:`create_urllib3_context`. - :param ciphers: - A string of ciphers we wish the client to support. - :param ca_cert_dir: - A directory containing CA certificates in multiple separate files, as - supported by OpenSSL's -CApath flag or the capath argument to - SSLContext.load_verify_locations(). - :param key_password: - Optional password if the keyfile is encrypted. - :param ca_cert_data: - Optional string containing CA certificates in PEM format suitable for - passing as the cadata parameter to SSLContext.load_verify_locations() - :param tls_in_tls: - Use SSLTransport to wrap the existing socket. - """ - context = ssl_context - if context is None: - # Note: This branch of code and all the variables in it are only used in tests. - # We should consider deprecating and removing this code. - context = create_urllib3_context(ssl_version, cert_reqs, ciphers=ciphers) - - if ca_certs or ca_cert_dir or ca_cert_data: - try: - context.load_verify_locations(ca_certs, ca_cert_dir, ca_cert_data) - except OSError as e: - raise SSLError(e) from e - - elif ssl_context is None and hasattr(context, "load_default_certs"): - # try to load OS default certs; works well on Windows. - context.load_default_certs() - - # Attempt to detect if we get the goofy behavior of the - # keyfile being encrypted and OpenSSL asking for the - # passphrase via the terminal and instead error out. - if keyfile and key_password is None and _is_key_file_encrypted(keyfile): - raise SSLError("Client private key is encrypted, password is required") - - if certfile: - if key_password is None: - context.load_cert_chain(certfile, keyfile) - else: - context.load_cert_chain(certfile, keyfile, key_password) - - try: - context.set_alpn_protocols(ALPN_PROTOCOLS) - except NotImplementedError: # Defensive: in CI, we always have set_alpn_protocols - pass - - ssl_sock = _ssl_wrap_socket_impl(sock, context, tls_in_tls, server_hostname) - return ssl_sock - - -def is_ipaddress(hostname: str | bytes) -> bool: - """Detects whether the hostname given is an IPv4 or IPv6 address. - Also detects IPv6 addresses with Zone IDs. - - :param str hostname: Hostname to examine. - :return: True if the hostname is an IP address, False otherwise. - """ - if isinstance(hostname, bytes): - # IDN A-label bytes are ASCII compatible. - hostname = hostname.decode("ascii") - return bool(_IPV4_RE.match(hostname) or _BRACELESS_IPV6_ADDRZ_RE.match(hostname)) - - -def _is_key_file_encrypted(key_file: str) -> bool: - """Detects if a key file is encrypted or not.""" - with open(key_file) as f: - for line in f: - # Look for Proc-Type: 4,ENCRYPTED - if "ENCRYPTED" in line: - return True - - return False - - -def _ssl_wrap_socket_impl( - sock: socket.socket, - ssl_context: ssl.SSLContext, - tls_in_tls: bool, - server_hostname: str | None = None, -) -> ssl.SSLSocket | SSLTransportType: - if tls_in_tls: - if not SSLTransport: - # Import error, ssl is not available. - raise ProxySchemeUnsupported( - "TLS in TLS requires support for the 'ssl' module" - ) - - SSLTransport._validate_ssl_context_for_tls_in_tls(ssl_context) - return SSLTransport(sock, ssl_context, server_hostname) - - return ssl_context.wrap_socket(sock, server_hostname=server_hostname) diff --git a/Modules/urllib3/util/ssl_match_hostname.py b/Modules/urllib3/util/ssl_match_hostname.py deleted file mode 100644 index 453cfd4..0000000 --- a/Modules/urllib3/util/ssl_match_hostname.py +++ /dev/null @@ -1,159 +0,0 @@ -"""The match_hostname() function from Python 3.5, essential when using SSL.""" - -# Note: This file is under the PSF license as the code comes from the python -# stdlib. http://docs.python.org/3/license.html -# It is modified to remove commonName support. - -from __future__ import annotations - -import ipaddress -import re -import typing -from ipaddress import IPv4Address, IPv6Address - -if typing.TYPE_CHECKING: - from .ssl_ import _TYPE_PEER_CERT_RET_DICT - -__version__ = "3.5.0.1" - - -class CertificateError(ValueError): - pass - - -def _dnsname_match( - dn: typing.Any, hostname: str, max_wildcards: int = 1 -) -> typing.Match[str] | None | bool: - """Matching according to RFC 6125, section 6.4.3 - - http://tools.ietf.org/html/rfc6125#section-6.4.3 - """ - pats = [] - if not dn: - return False - - # Ported from python3-syntax: - # leftmost, *remainder = dn.split(r'.') - parts = dn.split(r".") - leftmost = parts[0] - remainder = parts[1:] - - wildcards = leftmost.count("*") - if wildcards > max_wildcards: - # Issue #17980: avoid denials of service by refusing more - # than one wildcard per fragment. A survey of established - # policy among SSL implementations showed it to be a - # reasonable choice. - raise CertificateError( - "too many wildcards in certificate DNS name: " + repr(dn) - ) - - # speed up common case w/o wildcards - if not wildcards: - return bool(dn.lower() == hostname.lower()) - - # RFC 6125, section 6.4.3, subitem 1. - # The client SHOULD NOT attempt to match a presented identifier in which - # the wildcard character comprises a label other than the left-most label. - if leftmost == "*": - # When '*' is a fragment by itself, it matches a non-empty dotless - # fragment. - pats.append("[^.]+") - elif leftmost.startswith("xn--") or hostname.startswith("xn--"): - # RFC 6125, section 6.4.3, subitem 3. - # The client SHOULD NOT attempt to match a presented identifier - # where the wildcard character is embedded within an A-label or - # U-label of an internationalized domain name. - pats.append(re.escape(leftmost)) - else: - # Otherwise, '*' matches any dotless string, e.g. www* - pats.append(re.escape(leftmost).replace(r"\*", "[^.]*")) - - # add the remaining fragments, ignore any wildcards - for frag in remainder: - pats.append(re.escape(frag)) - - pat = re.compile(r"\A" + r"\.".join(pats) + r"\Z", re.IGNORECASE) - return pat.match(hostname) - - -def _ipaddress_match(ipname: str, host_ip: IPv4Address | IPv6Address) -> bool: - """Exact matching of IP addresses. - - RFC 9110 section 4.3.5: "A reference identity of IP-ID contains the decoded - bytes of the IP address. An IP version 4 address is 4 octets, and an IP - version 6 address is 16 octets. [...] A reference identity of type IP-ID - matches if the address is identical to an iPAddress value of the - subjectAltName extension of the certificate." - """ - # OpenSSL may add a trailing newline to a subjectAltName's IP address - # Divergence from upstream: ipaddress can't handle byte str - ip = ipaddress.ip_address(ipname.rstrip()) - return bool(ip.packed == host_ip.packed) - - -def match_hostname( - cert: _TYPE_PEER_CERT_RET_DICT | None, - hostname: str, - hostname_checks_common_name: bool = False, -) -> None: - """Verify that *cert* (in decoded format as returned by - SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125 - rules are followed, but IP addresses are not accepted for *hostname*. - - CertificateError is raised on failure. On success, the function - returns nothing. - """ - if not cert: - raise ValueError( - "empty or no certificate, match_hostname needs a " - "SSL socket or SSL context with either " - "CERT_OPTIONAL or CERT_REQUIRED" - ) - try: - # Divergence from upstream: ipaddress can't handle byte str - # - # The ipaddress module shipped with Python < 3.9 does not support - # scoped IPv6 addresses so we unconditionally strip the Zone IDs for - # now. Once we drop support for Python 3.9 we can remove this branch. - if "%" in hostname: - host_ip = ipaddress.ip_address(hostname[: hostname.rfind("%")]) - else: - host_ip = ipaddress.ip_address(hostname) - - except ValueError: - # Not an IP address (common case) - host_ip = None - dnsnames = [] - san: tuple[tuple[str, str], ...] = cert.get("subjectAltName", ()) - key: str - value: str - for key, value in san: - if key == "DNS": - if host_ip is None and _dnsname_match(value, hostname): - return - dnsnames.append(value) - elif key == "IP Address": - if host_ip is not None and _ipaddress_match(value, host_ip): - return - dnsnames.append(value) - - # We only check 'commonName' if it's enabled and we're not verifying - # an IP address. IP addresses aren't valid within 'commonName'. - if hostname_checks_common_name and host_ip is None and not dnsnames: - for sub in cert.get("subject", ()): - for key, value in sub: - if key == "commonName": - if _dnsname_match(value, hostname): - return - dnsnames.append(value) - - if len(dnsnames) > 1: - raise CertificateError( - "hostname %r " - "doesn't match either of %s" % (hostname, ", ".join(map(repr, dnsnames))) - ) - elif len(dnsnames) == 1: - raise CertificateError(f"hostname {hostname!r} doesn't match {dnsnames[0]!r}") - else: - raise CertificateError("no appropriate subjectAltName fields were found") diff --git a/Modules/urllib3/util/ssltransport.py b/Modules/urllib3/util/ssltransport.py deleted file mode 100644 index fa9f2b3..0000000 --- a/Modules/urllib3/util/ssltransport.py +++ /dev/null @@ -1,280 +0,0 @@ -from __future__ import annotations - -import io -import socket -import ssl -import typing - -from ..exceptions import ProxySchemeUnsupported - -if typing.TYPE_CHECKING: - from typing import Literal - - from .ssl_ import _TYPE_PEER_CERT_RET, _TYPE_PEER_CERT_RET_DICT - - -_SelfT = typing.TypeVar("_SelfT", bound="SSLTransport") -_WriteBuffer = typing.Union[bytearray, memoryview] -_ReturnValue = typing.TypeVar("_ReturnValue") - -SSL_BLOCKSIZE = 16384 - - -class SSLTransport: - """ - The SSLTransport wraps an existing socket and establishes an SSL connection. - - Contrary to Python's implementation of SSLSocket, it allows you to chain - multiple TLS connections together. It's particularly useful if you need to - implement TLS within TLS. - - The class supports most of the socket API operations. - """ - - @staticmethod - def _validate_ssl_context_for_tls_in_tls(ssl_context: ssl.SSLContext) -> None: - """ - Raises a ProxySchemeUnsupported if the provided ssl_context can't be used - for TLS in TLS. - - The only requirement is that the ssl_context provides the 'wrap_bio' - methods. - """ - - if not hasattr(ssl_context, "wrap_bio"): - raise ProxySchemeUnsupported( - "TLS in TLS requires SSLContext.wrap_bio() which isn't " - "available on non-native SSLContext" - ) - - def __init__( - self, - socket: socket.socket, - ssl_context: ssl.SSLContext, - server_hostname: str | None = None, - suppress_ragged_eofs: bool = True, - ) -> None: - """ - Create an SSLTransport around socket using the provided ssl_context. - """ - self.incoming = ssl.MemoryBIO() - self.outgoing = ssl.MemoryBIO() - - self.suppress_ragged_eofs = suppress_ragged_eofs - self.socket = socket - - self.sslobj = ssl_context.wrap_bio( - self.incoming, self.outgoing, server_hostname=server_hostname - ) - - # Perform initial handshake. - self._ssl_io_loop(self.sslobj.do_handshake) - - def __enter__(self: _SelfT) -> _SelfT: - return self - - def __exit__(self, *_: typing.Any) -> None: - self.close() - - def fileno(self) -> int: - return self.socket.fileno() - - def read(self, len: int = 1024, buffer: typing.Any | None = None) -> int | bytes: - return self._wrap_ssl_read(len, buffer) - - def recv(self, buflen: int = 1024, flags: int = 0) -> int | bytes: - if flags != 0: - raise ValueError("non-zero flags not allowed in calls to recv") - return self._wrap_ssl_read(buflen) - - def recv_into( - self, - buffer: _WriteBuffer, - nbytes: int | None = None, - flags: int = 0, - ) -> None | int | bytes: - if flags != 0: - raise ValueError("non-zero flags not allowed in calls to recv_into") - if nbytes is None: - nbytes = len(buffer) - return self.read(nbytes, buffer) - - def sendall(self, data: bytes, flags: int = 0) -> None: - if flags != 0: - raise ValueError("non-zero flags not allowed in calls to sendall") - count = 0 - with memoryview(data) as view, view.cast("B") as byte_view: - amount = len(byte_view) - while count < amount: - v = self.send(byte_view[count:]) - count += v - - def send(self, data: bytes, flags: int = 0) -> int: - if flags != 0: - raise ValueError("non-zero flags not allowed in calls to send") - return self._ssl_io_loop(self.sslobj.write, data) - - def makefile( - self, - mode: str, - buffering: int | None = None, - *, - encoding: str | None = None, - errors: str | None = None, - newline: str | None = None, - ) -> typing.BinaryIO | typing.TextIO | socket.SocketIO: - """ - Python's httpclient uses makefile and buffered io when reading HTTP - messages and we need to support it. - - This is unfortunately a copy and paste of socket.py makefile with small - changes to point to the socket directly. - """ - if not set(mode) <= {"r", "w", "b"}: - raise ValueError(f"invalid mode {mode!r} (only r, w, b allowed)") - - writing = "w" in mode - reading = "r" in mode or not writing - assert reading or writing - binary = "b" in mode - rawmode = "" - if reading: - rawmode += "r" - if writing: - rawmode += "w" - raw = socket.SocketIO(self, rawmode) # type: ignore[arg-type] - self.socket._io_refs += 1 # type: ignore[attr-defined] - if buffering is None: - buffering = -1 - if buffering < 0: - buffering = io.DEFAULT_BUFFER_SIZE - if buffering == 0: - if not binary: - raise ValueError("unbuffered streams must be binary") - return raw - buffer: typing.BinaryIO - if reading and writing: - buffer = io.BufferedRWPair(raw, raw, buffering) # type: ignore[assignment] - elif reading: - buffer = io.BufferedReader(raw, buffering) - else: - assert writing - buffer = io.BufferedWriter(raw, buffering) - if binary: - return buffer - text = io.TextIOWrapper(buffer, encoding, errors, newline) - text.mode = mode # type: ignore[misc] - return text - - def unwrap(self) -> None: - self._ssl_io_loop(self.sslobj.unwrap) - - def close(self) -> None: - self.socket.close() - - @typing.overload - def getpeercert( - self, binary_form: Literal[False] = ... - ) -> _TYPE_PEER_CERT_RET_DICT | None: - ... - - @typing.overload - def getpeercert(self, binary_form: Literal[True]) -> bytes | None: - ... - - def getpeercert(self, binary_form: bool = False) -> _TYPE_PEER_CERT_RET: - return self.sslobj.getpeercert(binary_form) # type: ignore[return-value] - - def version(self) -> str | None: - return self.sslobj.version() - - def cipher(self) -> tuple[str, str, int] | None: - return self.sslobj.cipher() - - def selected_alpn_protocol(self) -> str | None: - return self.sslobj.selected_alpn_protocol() - - def selected_npn_protocol(self) -> str | None: - return self.sslobj.selected_npn_protocol() - - def shared_ciphers(self) -> list[tuple[str, str, int]] | None: - return self.sslobj.shared_ciphers() - - def compression(self) -> str | None: - return self.sslobj.compression() - - def settimeout(self, value: float | None) -> None: - self.socket.settimeout(value) - - def gettimeout(self) -> float | None: - return self.socket.gettimeout() - - def _decref_socketios(self) -> None: - self.socket._decref_socketios() # type: ignore[attr-defined] - - def _wrap_ssl_read(self, len: int, buffer: bytearray | None = None) -> int | bytes: - try: - return self._ssl_io_loop(self.sslobj.read, len, buffer) - except ssl.SSLError as e: - if e.errno == ssl.SSL_ERROR_EOF and self.suppress_ragged_eofs: - return 0 # eof, return 0. - else: - raise - - # func is sslobj.do_handshake or sslobj.unwrap - @typing.overload - def _ssl_io_loop(self, func: typing.Callable[[], None]) -> None: - ... - - # func is sslobj.write, arg1 is data - @typing.overload - def _ssl_io_loop(self, func: typing.Callable[[bytes], int], arg1: bytes) -> int: - ... - - # func is sslobj.read, arg1 is len, arg2 is buffer - @typing.overload - def _ssl_io_loop( - self, - func: typing.Callable[[int, bytearray | None], bytes], - arg1: int, - arg2: bytearray | None, - ) -> bytes: - ... - - def _ssl_io_loop( - self, - func: typing.Callable[..., _ReturnValue], - arg1: None | bytes | int = None, - arg2: bytearray | None = None, - ) -> _ReturnValue: - """Performs an I/O loop between incoming/outgoing and the socket.""" - should_loop = True - ret = None - - while should_loop: - errno = None - try: - if arg1 is None and arg2 is None: - ret = func() - elif arg2 is None: - ret = func(arg1) - else: - ret = func(arg1, arg2) - except ssl.SSLError as e: - if e.errno not in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE): - # WANT_READ, and WANT_WRITE are expected, others are not. - raise e - errno = e.errno - - buf = self.outgoing.read() - self.socket.sendall(buf) - - if errno is None: - should_loop = False - elif errno == ssl.SSL_ERROR_WANT_READ: - buf = self.socket.recv(SSL_BLOCKSIZE) - if buf: - self.incoming.write(buf) - else: - self.incoming.write_eof() - return typing.cast(_ReturnValue, ret) diff --git a/Modules/urllib3/util/timeout.py b/Modules/urllib3/util/timeout.py deleted file mode 100644 index f044625..0000000 --- a/Modules/urllib3/util/timeout.py +++ /dev/null @@ -1,279 +0,0 @@ -from __future__ import annotations - -import time -import typing -from enum import Enum -from socket import getdefaulttimeout - -from ..exceptions import TimeoutStateError - -if typing.TYPE_CHECKING: - from typing import Final - - -class _TYPE_DEFAULT(Enum): - # This value should never be passed to socket.settimeout() so for safety we use a -1. - # socket.settimout() raises a ValueError for negative values. - token = -1 - - -_DEFAULT_TIMEOUT: Final[_TYPE_DEFAULT] = _TYPE_DEFAULT.token - -_TYPE_TIMEOUT = typing.Optional[typing.Union[float, _TYPE_DEFAULT]] - - -class Timeout: - """Timeout configuration. - - Timeouts can be defined as a default for a pool: - - .. code-block:: python - - import urllib3 - - timeout = urllib3.util.Timeout(connect=2.0, read=7.0) - - http = urllib3.PoolManager(timeout=timeout) - - resp = http.request("GET", "https://example.com/") - - print(resp.status) - - Or per-request (which overrides the default for the pool): - - .. code-block:: python - - response = http.request("GET", "https://example.com/", timeout=Timeout(10)) - - Timeouts can be disabled by setting all the parameters to ``None``: - - .. code-block:: python - - no_timeout = Timeout(connect=None, read=None) - response = http.request("GET", "https://example.com/", timeout=no_timeout) - - - :param total: - This combines the connect and read timeouts into one; the read timeout - will be set to the time leftover from the connect attempt. In the - event that both a connect timeout and a total are specified, or a read - timeout and a total are specified, the shorter timeout will be applied. - - Defaults to None. - - :type total: int, float, or None - - :param connect: - The maximum amount of time (in seconds) to wait for a connection - attempt to a server to succeed. Omitting the parameter will default the - connect timeout to the system default, probably `the global default - timeout in socket.py - `_. - None will set an infinite timeout for connection attempts. - - :type connect: int, float, or None - - :param read: - The maximum amount of time (in seconds) to wait between consecutive - read operations for a response from the server. Omitting the parameter - will default the read timeout to the system default, probably `the - global default timeout in socket.py - `_. - None will set an infinite timeout. - - :type read: int, float, or None - - .. note:: - - Many factors can affect the total amount of time for urllib3 to return - an HTTP response. - - For example, Python's DNS resolver does not obey the timeout specified - on the socket. Other factors that can affect total request time include - high CPU load, high swap, the program running at a low priority level, - or other behaviors. - - In addition, the read and total timeouts only measure the time between - read operations on the socket connecting the client and the server, - not the total amount of time for the request to return a complete - response. For most requests, the timeout is raised because the server - has not sent the first byte in the specified time. This is not always - the case; if a server streams one byte every fifteen seconds, a timeout - of 20 seconds will not trigger, even though the request will take - several minutes to complete. - - If your goal is to cut off any request after a set amount of wall clock - time, consider having a second "watcher" thread to cut off a slow - request. - """ - - #: A sentinel object representing the default timeout value - DEFAULT_TIMEOUT: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT - - def __init__( - self, - total: _TYPE_TIMEOUT = None, - connect: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, - read: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, - ) -> None: - self._connect = self._validate_timeout(connect, "connect") - self._read = self._validate_timeout(read, "read") - self.total = self._validate_timeout(total, "total") - self._start_connect: float | None = None - - def __repr__(self) -> str: - return f"{type(self).__name__}(connect={self._connect!r}, read={self._read!r}, total={self.total!r})" - - # __str__ provided for backwards compatibility - __str__ = __repr__ - - @staticmethod - def resolve_default_timeout(timeout: _TYPE_TIMEOUT) -> float | None: - return getdefaulttimeout() if timeout is _DEFAULT_TIMEOUT else timeout - - @classmethod - def _validate_timeout(cls, value: _TYPE_TIMEOUT, name: str) -> _TYPE_TIMEOUT: - """Check that a timeout attribute is valid. - - :param value: The timeout value to validate - :param name: The name of the timeout attribute to validate. This is - used to specify in error messages. - :return: The validated and casted version of the given value. - :raises ValueError: If it is a numeric value less than or equal to - zero, or the type is not an integer, float, or None. - """ - if value is None or value is _DEFAULT_TIMEOUT: - return value - - if isinstance(value, bool): - raise ValueError( - "Timeout cannot be a boolean value. It must " - "be an int, float or None." - ) - try: - float(value) - except (TypeError, ValueError): - raise ValueError( - "Timeout value %s was %s, but it must be an " - "int, float or None." % (name, value) - ) from None - - try: - if value <= 0: - raise ValueError( - "Attempted to set %s timeout to %s, but the " - "timeout cannot be set to a value less " - "than or equal to 0." % (name, value) - ) - except TypeError: - raise ValueError( - "Timeout value %s was %s, but it must be an " - "int, float or None." % (name, value) - ) from None - - return value - - @classmethod - def from_float(cls, timeout: _TYPE_TIMEOUT) -> Timeout: - """Create a new Timeout from a legacy timeout value. - - The timeout value used by httplib.py sets the same timeout on the - connect(), and recv() socket requests. This creates a :class:`Timeout` - object that sets the individual timeouts to the ``timeout`` value - passed to this function. - - :param timeout: The legacy timeout value. - :type timeout: integer, float, :attr:`urllib3.util.Timeout.DEFAULT_TIMEOUT`, or None - :return: Timeout object - :rtype: :class:`Timeout` - """ - return Timeout(read=timeout, connect=timeout) - - def clone(self) -> Timeout: - """Create a copy of the timeout object - - Timeout properties are stored per-pool but each request needs a fresh - Timeout object to ensure each one has its own start/stop configured. - - :return: a copy of the timeout object - :rtype: :class:`Timeout` - """ - # We can't use copy.deepcopy because that will also create a new object - # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to - # detect the user default. - return Timeout(connect=self._connect, read=self._read, total=self.total) - - def start_connect(self) -> float: - """Start the timeout clock, used during a connect() attempt - - :raises urllib3.exceptions.TimeoutStateError: if you attempt - to start a timer that has been started already. - """ - if self._start_connect is not None: - raise TimeoutStateError("Timeout timer has already been started.") - self._start_connect = time.monotonic() - return self._start_connect - - def get_connect_duration(self) -> float: - """Gets the time elapsed since the call to :meth:`start_connect`. - - :return: Elapsed time in seconds. - :rtype: float - :raises urllib3.exceptions.TimeoutStateError: if you attempt - to get duration for a timer that hasn't been started. - """ - if self._start_connect is None: - raise TimeoutStateError( - "Can't get connect duration for timer that has not started." - ) - return time.monotonic() - self._start_connect - - @property - def connect_timeout(self) -> _TYPE_TIMEOUT: - """Get the value to use when setting a connection timeout. - - This will be a positive float or integer, the value None - (never timeout), or the default system timeout. - - :return: Connect timeout. - :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None - """ - if self.total is None: - return self._connect - - if self._connect is None or self._connect is _DEFAULT_TIMEOUT: - return self.total - - return min(self._connect, self.total) # type: ignore[type-var] - - @property - def read_timeout(self) -> float | None: - """Get the value for the read timeout. - - This assumes some time has elapsed in the connection timeout and - computes the read timeout appropriately. - - If self.total is set, the read timeout is dependent on the amount of - time taken by the connect timeout. If the connection time has not been - established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be - raised. - - :return: Value to use for the read timeout. - :rtype: int, float or None - :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect` - has not yet been called on this object. - """ - if ( - self.total is not None - and self.total is not _DEFAULT_TIMEOUT - and self._read is not None - and self._read is not _DEFAULT_TIMEOUT - ): - # In case the connect timeout has not yet been established. - if self._start_connect is None: - return self._read - return max(0, min(self.total - self.get_connect_duration(), self._read)) - elif self.total is not None and self.total is not _DEFAULT_TIMEOUT: - return max(0, self.total - self.get_connect_duration()) - else: - return self.resolve_default_timeout(self._read) diff --git a/Modules/urllib3/util/url.py b/Modules/urllib3/util/url.py deleted file mode 100644 index d53ea93..0000000 --- a/Modules/urllib3/util/url.py +++ /dev/null @@ -1,471 +0,0 @@ -from __future__ import annotations - -import re -import typing - -from ..exceptions import LocationParseError -from .util import to_str - -# We only want to normalize urls with an HTTP(S) scheme. -# urllib3 infers URLs without a scheme (None) to be http. -_NORMALIZABLE_SCHEMES = ("http", "https", None) - -# Almost all of these patterns were derived from the -# 'rfc3986' module: https://github.com/python-hyper/rfc3986 -_PERCENT_RE = re.compile(r"%[a-fA-F0-9]{2}") -_SCHEME_RE = re.compile(r"^(?:[a-zA-Z][a-zA-Z0-9+-]*:|/)") -_URI_RE = re.compile( - r"^(?:([a-zA-Z][a-zA-Z0-9+.-]*):)?" - r"(?://([^\\/?#]*))?" - r"([^?#]*)" - r"(?:\?([^#]*))?" - r"(?:#(.*))?$", - re.UNICODE | re.DOTALL, -) - -_IPV4_PAT = r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}" -_HEX_PAT = "[0-9A-Fa-f]{1,4}" -_LS32_PAT = "(?:{hex}:{hex}|{ipv4})".format(hex=_HEX_PAT, ipv4=_IPV4_PAT) -_subs = {"hex": _HEX_PAT, "ls32": _LS32_PAT} -_variations = [ - # 6( h16 ":" ) ls32 - "(?:%(hex)s:){6}%(ls32)s", - # "::" 5( h16 ":" ) ls32 - "::(?:%(hex)s:){5}%(ls32)s", - # [ h16 ] "::" 4( h16 ":" ) ls32 - "(?:%(hex)s)?::(?:%(hex)s:){4}%(ls32)s", - # [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 - "(?:(?:%(hex)s:)?%(hex)s)?::(?:%(hex)s:){3}%(ls32)s", - # [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 - "(?:(?:%(hex)s:){0,2}%(hex)s)?::(?:%(hex)s:){2}%(ls32)s", - # [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32 - "(?:(?:%(hex)s:){0,3}%(hex)s)?::%(hex)s:%(ls32)s", - # [ *4( h16 ":" ) h16 ] "::" ls32 - "(?:(?:%(hex)s:){0,4}%(hex)s)?::%(ls32)s", - # [ *5( h16 ":" ) h16 ] "::" h16 - "(?:(?:%(hex)s:){0,5}%(hex)s)?::%(hex)s", - # [ *6( h16 ":" ) h16 ] "::" - "(?:(?:%(hex)s:){0,6}%(hex)s)?::", -] - -_UNRESERVED_PAT = r"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._\-~" -_IPV6_PAT = "(?:" + "|".join([x % _subs for x in _variations]) + ")" -_ZONE_ID_PAT = "(?:%25|%)(?:[" + _UNRESERVED_PAT + "]|%[a-fA-F0-9]{2})+" -_IPV6_ADDRZ_PAT = r"\[" + _IPV6_PAT + r"(?:" + _ZONE_ID_PAT + r")?\]" -_REG_NAME_PAT = r"(?:[^\[\]%:/?#]|%[a-fA-F0-9]{2})*" -_TARGET_RE = re.compile(r"^(/[^?#]*)(?:\?([^#]*))?(?:#.*)?$") - -_IPV4_RE = re.compile("^" + _IPV4_PAT + "$") -_IPV6_RE = re.compile("^" + _IPV6_PAT + "$") -_IPV6_ADDRZ_RE = re.compile("^" + _IPV6_ADDRZ_PAT + "$") -_BRACELESS_IPV6_ADDRZ_RE = re.compile("^" + _IPV6_ADDRZ_PAT[2:-2] + "$") -_ZONE_ID_RE = re.compile("(" + _ZONE_ID_PAT + r")\]$") - -_HOST_PORT_PAT = ("^(%s|%s|%s)(?::0*?(|0|[1-9][0-9]{0,4}))?$") % ( - _REG_NAME_PAT, - _IPV4_PAT, - _IPV6_ADDRZ_PAT, -) -_HOST_PORT_RE = re.compile(_HOST_PORT_PAT, re.UNICODE | re.DOTALL) - -_UNRESERVED_CHARS = set( - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-~" -) -_SUB_DELIM_CHARS = set("!$&'()*+,;=") -_USERINFO_CHARS = _UNRESERVED_CHARS | _SUB_DELIM_CHARS | {":"} -_PATH_CHARS = _USERINFO_CHARS | {"@", "/"} -_QUERY_CHARS = _FRAGMENT_CHARS = _PATH_CHARS | {"?"} - - -class Url( - typing.NamedTuple( - "Url", - [ - ("scheme", typing.Optional[str]), - ("auth", typing.Optional[str]), - ("host", typing.Optional[str]), - ("port", typing.Optional[int]), - ("path", typing.Optional[str]), - ("query", typing.Optional[str]), - ("fragment", typing.Optional[str]), - ], - ) -): - """ - Data structure for representing an HTTP URL. Used as a return value for - :func:`parse_url`. Both the scheme and host are normalized as they are - both case-insensitive according to RFC 3986. - """ - - def __new__( # type: ignore[no-untyped-def] - cls, - scheme: str | None = None, - auth: str | None = None, - host: str | None = None, - port: int | None = None, - path: str | None = None, - query: str | None = None, - fragment: str | None = None, - ): - if path and not path.startswith("/"): - path = "/" + path - if scheme is not None: - scheme = scheme.lower() - return super().__new__(cls, scheme, auth, host, port, path, query, fragment) - - @property - def hostname(self) -> str | None: - """For backwards-compatibility with urlparse. We're nice like that.""" - return self.host - - @property - def request_uri(self) -> str: - """Absolute path including the query string.""" - uri = self.path or "/" - - if self.query is not None: - uri += "?" + self.query - - return uri - - @property - def authority(self) -> str | None: - """ - Authority component as defined in RFC 3986 3.2. - This includes userinfo (auth), host and port. - - i.e. - userinfo@host:port - """ - userinfo = self.auth - netloc = self.netloc - if netloc is None or userinfo is None: - return netloc - else: - return f"{userinfo}@{netloc}" - - @property - def netloc(self) -> str | None: - """ - Network location including host and port. - - If you need the equivalent of urllib.parse's ``netloc``, - use the ``authority`` property instead. - """ - if self.host is None: - return None - if self.port: - return f"{self.host}:{self.port}" - return self.host - - @property - def url(self) -> str: - """ - Convert self into a url - - This function should more or less round-trip with :func:`.parse_url`. The - returned url may not be exactly the same as the url inputted to - :func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls - with a blank port will have : removed). - - Example: - - .. code-block:: python - - import urllib3 - - U = urllib3.util.parse_url("https://google.com/mail/") - - print(U.url) - # "https://google.com/mail/" - - print( urllib3.util.Url("https", "username:password", - "host.com", 80, "/path", "query", "fragment" - ).url - ) - # "https://username:password@host.com:80/path?query#fragment" - """ - scheme, auth, host, port, path, query, fragment = self - url = "" - - # We use "is not None" we want things to happen with empty strings (or 0 port) - if scheme is not None: - url += scheme + "://" - if auth is not None: - url += auth + "@" - if host is not None: - url += host - if port is not None: - url += ":" + str(port) - if path is not None: - url += path - if query is not None: - url += "?" + query - if fragment is not None: - url += "#" + fragment - - return url - - def __str__(self) -> str: - return self.url - - -@typing.overload -def _encode_invalid_chars( - component: str, allowed_chars: typing.Container[str] -) -> str: # Abstract - ... - - -@typing.overload -def _encode_invalid_chars( - component: None, allowed_chars: typing.Container[str] -) -> None: # Abstract - ... - - -def _encode_invalid_chars( - component: str | None, allowed_chars: typing.Container[str] -) -> str | None: - """Percent-encodes a URI component without reapplying - onto an already percent-encoded component. - """ - if component is None: - return component - - component = to_str(component) - - # Normalize existing percent-encoded bytes. - # Try to see if the component we're encoding is already percent-encoded - # so we can skip all '%' characters but still encode all others. - component, percent_encodings = _PERCENT_RE.subn( - lambda match: match.group(0).upper(), component - ) - - uri_bytes = component.encode("utf-8", "surrogatepass") - is_percent_encoded = percent_encodings == uri_bytes.count(b"%") - encoded_component = bytearray() - - for i in range(0, len(uri_bytes)): - # Will return a single character bytestring - byte = uri_bytes[i : i + 1] - byte_ord = ord(byte) - if (is_percent_encoded and byte == b"%") or ( - byte_ord < 128 and byte.decode() in allowed_chars - ): - encoded_component += byte - continue - encoded_component.extend(b"%" + (hex(byte_ord)[2:].encode().zfill(2).upper())) - - return encoded_component.decode() - - -def _remove_path_dot_segments(path: str) -> str: - # See http://tools.ietf.org/html/rfc3986#section-5.2.4 for pseudo-code - segments = path.split("/") # Turn the path into a list of segments - output = [] # Initialize the variable to use to store output - - for segment in segments: - # '.' is the current directory, so ignore it, it is superfluous - if segment == ".": - continue - # Anything other than '..', should be appended to the output - if segment != "..": - output.append(segment) - # In this case segment == '..', if we can, we should pop the last - # element - elif output: - output.pop() - - # If the path starts with '/' and the output is empty or the first string - # is non-empty - if path.startswith("/") and (not output or output[0]): - output.insert(0, "") - - # If the path starts with '/.' or '/..' ensure we add one more empty - # string to add a trailing '/' - if path.endswith(("/.", "/..")): - output.append("") - - return "/".join(output) - - -@typing.overload -def _normalize_host(host: None, scheme: str | None) -> None: - ... - - -@typing.overload -def _normalize_host(host: str, scheme: str | None) -> str: - ... - - -def _normalize_host(host: str | None, scheme: str | None) -> str | None: - if host: - if scheme in _NORMALIZABLE_SCHEMES: - is_ipv6 = _IPV6_ADDRZ_RE.match(host) - if is_ipv6: - # IPv6 hosts of the form 'a::b%zone' are encoded in a URL as - # such per RFC 6874: 'a::b%25zone'. Unquote the ZoneID - # separator as necessary to return a valid RFC 4007 scoped IP. - match = _ZONE_ID_RE.search(host) - if match: - start, end = match.span(1) - zone_id = host[start:end] - - if zone_id.startswith("%25") and zone_id != "%25": - zone_id = zone_id[3:] - else: - zone_id = zone_id[1:] - zone_id = _encode_invalid_chars(zone_id, _UNRESERVED_CHARS) - return f"{host[:start].lower()}%{zone_id}{host[end:]}" - else: - return host.lower() - elif not _IPV4_RE.match(host): - return to_str( - b".".join([_idna_encode(label) for label in host.split(".")]), - "ascii", - ) - return host - - -def _idna_encode(name: str) -> bytes: - if not name.isascii(): - try: - import idna - except ImportError: - raise LocationParseError( - "Unable to parse URL without the 'idna' module" - ) from None - - try: - return idna.encode(name.lower(), strict=True, std3_rules=True) - except idna.IDNAError: - raise LocationParseError( - f"Name '{name}' is not a valid IDNA label" - ) from None - - return name.lower().encode("ascii") - - -def _encode_target(target: str) -> str: - """Percent-encodes a request target so that there are no invalid characters - - Pre-condition for this function is that 'target' must start with '/'. - If that is the case then _TARGET_RE will always produce a match. - """ - match = _TARGET_RE.match(target) - if not match: # Defensive: - raise LocationParseError(f"{target!r} is not a valid request URI") - - path, query = match.groups() - encoded_target = _encode_invalid_chars(path, _PATH_CHARS) - if query is not None: - query = _encode_invalid_chars(query, _QUERY_CHARS) - encoded_target += "?" + query - return encoded_target - - -def parse_url(url: str) -> Url: - """ - Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is - performed to parse incomplete urls. Fields not provided will be None. - This parser is RFC 3986 and RFC 6874 compliant. - - The parser logic and helper functions are based heavily on - work done in the ``rfc3986`` module. - - :param str url: URL to parse into a :class:`.Url` namedtuple. - - Partly backwards-compatible with :mod:`urllib.parse`. - - Example: - - .. code-block:: python - - import urllib3 - - print( urllib3.util.parse_url('http://google.com/mail/')) - # Url(scheme='http', host='google.com', port=None, path='/mail/', ...) - - print( urllib3.util.parse_url('google.com:80')) - # Url(scheme=None, host='google.com', port=80, path=None, ...) - - print( urllib3.util.parse_url('/foo?bar')) - # Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...) - """ - if not url: - # Empty - return Url() - - source_url = url - if not _SCHEME_RE.search(url): - url = "//" + url - - scheme: str | None - authority: str | None - auth: str | None - host: str | None - port: str | None - port_int: int | None - path: str | None - query: str | None - fragment: str | None - - try: - scheme, authority, path, query, fragment = _URI_RE.match(url).groups() # type: ignore[union-attr] - normalize_uri = scheme is None or scheme.lower() in _NORMALIZABLE_SCHEMES - - if scheme: - scheme = scheme.lower() - - if authority: - auth, _, host_port = authority.rpartition("@") - auth = auth or None - host, port = _HOST_PORT_RE.match(host_port).groups() # type: ignore[union-attr] - if auth and normalize_uri: - auth = _encode_invalid_chars(auth, _USERINFO_CHARS) - if port == "": - port = None - else: - auth, host, port = None, None, None - - if port is not None: - port_int = int(port) - if not (0 <= port_int <= 65535): - raise LocationParseError(url) - else: - port_int = None - - host = _normalize_host(host, scheme) - - if normalize_uri and path: - path = _remove_path_dot_segments(path) - path = _encode_invalid_chars(path, _PATH_CHARS) - if normalize_uri and query: - query = _encode_invalid_chars(query, _QUERY_CHARS) - if normalize_uri and fragment: - fragment = _encode_invalid_chars(fragment, _FRAGMENT_CHARS) - - except (ValueError, AttributeError) as e: - raise LocationParseError(source_url) from e - - # For the sake of backwards compatibility we put empty - # string values for path if there are any defined values - # beyond the path in the URL. - # TODO: Remove this when we break backwards compatibility. - if not path: - if query is not None or fragment is not None: - path = "" - else: - path = None - - return Url( - scheme=scheme, - auth=auth, - host=host, - port=port_int, - path=path, - query=query, - fragment=fragment, - ) diff --git a/Modules/urllib3/util/util.py b/Modules/urllib3/util/util.py deleted file mode 100644 index 35c77e4..0000000 --- a/Modules/urllib3/util/util.py +++ /dev/null @@ -1,42 +0,0 @@ -from __future__ import annotations - -import typing -from types import TracebackType - - -def to_bytes( - x: str | bytes, encoding: str | None = None, errors: str | None = None -) -> bytes: - if isinstance(x, bytes): - return x - elif not isinstance(x, str): - raise TypeError(f"not expecting type {type(x).__name__}") - if encoding or errors: - return x.encode(encoding or "utf-8", errors=errors or "strict") - return x.encode() - - -def to_str( - x: str | bytes, encoding: str | None = None, errors: str | None = None -) -> str: - if isinstance(x, str): - return x - elif not isinstance(x, bytes): - raise TypeError(f"not expecting type {type(x).__name__}") - if encoding or errors: - return x.decode(encoding or "utf-8", errors=errors or "strict") - return x.decode() - - -def reraise( - tp: type[BaseException] | None, - value: BaseException, - tb: TracebackType | None = None, -) -> typing.NoReturn: - try: - if value.__traceback__ is not tb: - raise value.with_traceback(tb) - raise value - finally: - value = None # type: ignore[assignment] - tb = None diff --git a/Modules/urllib3/util/wait.py b/Modules/urllib3/util/wait.py deleted file mode 100644 index aeca0c7..0000000 --- a/Modules/urllib3/util/wait.py +++ /dev/null @@ -1,124 +0,0 @@ -from __future__ import annotations - -import select -import socket -from functools import partial - -__all__ = ["wait_for_read", "wait_for_write"] - - -# How should we wait on sockets? -# -# There are two types of APIs you can use for waiting on sockets: the fancy -# modern stateful APIs like epoll/kqueue, and the older stateless APIs like -# select/poll. The stateful APIs are more efficient when you have a lots of -# sockets to keep track of, because you can set them up once and then use them -# lots of times. But we only ever want to wait on a single socket at a time -# and don't want to keep track of state, so the stateless APIs are actually -# more efficient. So we want to use select() or poll(). -# -# Now, how do we choose between select() and poll()? On traditional Unixes, -# select() has a strange calling convention that makes it slow, or fail -# altogether, for high-numbered file descriptors. The point of poll() is to fix -# that, so on Unixes, we prefer poll(). -# -# On Windows, there is no poll() (or at least Python doesn't provide a wrapper -# for it), but that's OK, because on Windows, select() doesn't have this -# strange calling convention; plain select() works fine. -# -# So: on Windows we use select(), and everywhere else we use poll(). We also -# fall back to select() in case poll() is somehow broken or missing. - - -def select_wait_for_socket( - sock: socket.socket, - read: bool = False, - write: bool = False, - timeout: float | None = None, -) -> bool: - if not read and not write: - raise RuntimeError("must specify at least one of read=True, write=True") - rcheck = [] - wcheck = [] - if read: - rcheck.append(sock) - if write: - wcheck.append(sock) - # When doing a non-blocking connect, most systems signal success by - # marking the socket writable. Windows, though, signals success by marked - # it as "exceptional". We paper over the difference by checking the write - # sockets for both conditions. (The stdlib selectors module does the same - # thing.) - fn = partial(select.select, rcheck, wcheck, wcheck) - rready, wready, xready = fn(timeout) - return bool(rready or wready or xready) - - -def poll_wait_for_socket( - sock: socket.socket, - read: bool = False, - write: bool = False, - timeout: float | None = None, -) -> bool: - if not read and not write: - raise RuntimeError("must specify at least one of read=True, write=True") - mask = 0 - if read: - mask |= select.POLLIN - if write: - mask |= select.POLLOUT - poll_obj = select.poll() - poll_obj.register(sock, mask) - - # For some reason, poll() takes timeout in milliseconds - def do_poll(t: float | None) -> list[tuple[int, int]]: - if t is not None: - t *= 1000 - return poll_obj.poll(t) - - return bool(do_poll(timeout)) - - -def _have_working_poll() -> bool: - # Apparently some systems have a select.poll that fails as soon as you try - # to use it, either due to strange configuration or broken monkeypatching - # from libraries like eventlet/greenlet. - try: - poll_obj = select.poll() - poll_obj.poll(0) - except (AttributeError, OSError): - return False - else: - return True - - -def wait_for_socket( - sock: socket.socket, - read: bool = False, - write: bool = False, - timeout: float | None = None, -) -> bool: - # We delay choosing which implementation to use until the first time we're - # called. We could do it at import time, but then we might make the wrong - # decision if someone goes wild with monkeypatching select.poll after - # we're imported. - global wait_for_socket - if _have_working_poll(): - wait_for_socket = poll_wait_for_socket - elif hasattr(select, "select"): - wait_for_socket = select_wait_for_socket - return wait_for_socket(sock, read, write, timeout) - - -def wait_for_read(sock: socket.socket, timeout: float | None = None) -> bool: - """Waits for reading to be available on a given socket. - Returns True if the socket is readable, or False if the timeout expired. - """ - return wait_for_socket(sock, read=True, timeout=timeout) - - -def wait_for_write(sock: socket.socket, timeout: float | None = None) -> bool: - """Waits for writing to be available on a given socket. - Returns True if the socket is readable, or False if the timeout expired. - """ - return wait_for_socket(sock, write=True, timeout=timeout) diff --git a/Modules/vdf/LICENSE b/Modules/vdf/LICENSE deleted file mode 100644 index ee59795..0000000 --- a/Modules/vdf/LICENSE +++ /dev/null @@ -1,19 +0,0 @@ -Copyright (c) 2015 Rossen Georgiev - -Permission is hereby granted, free of charge, to any person obtaining a copy of -this software and associated documentation files (the "Software"), to deal in -the Software without restriction, including without limitation the rights to -use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -of the Software, and to permit persons to whom the Software is furnished to do -so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/Modules/vdf/__init__.py b/Modules/vdf/__init__.py deleted file mode 100644 index 8b64d5d..0000000 --- a/Modules/vdf/__init__.py +++ /dev/null @@ -1,519 +0,0 @@ -""" -Module for deserializing/serializing to and from VDF -""" -__version__ = "3.4" -__author__ = "Rossen Georgiev" - -import re -import sys -import struct -from binascii import crc32 -from io import BytesIO -from io import StringIO as unicodeIO - -try: - from collections.abc import Mapping -except: - from collections import Mapping - -# Py2 & Py3 compatibility -if sys.version_info[0] >= 3: - string_type = str - int_type = int - BOMS = '\ufffe\ufeff' - - def strip_bom(line): - return line.lstrip(BOMS) -else: - from StringIO import StringIO as strIO - string_type = basestring - int_type = long - BOMS = '\xef\xbb\xbf\xff\xfe\xfe\xff' - BOMS_UNICODE = '\\ufffe\\ufeff'.decode('unicode-escape') - - def strip_bom(line): - return line.lstrip(BOMS if isinstance(line, str) else BOMS_UNICODE) - -# string escaping -_unescape_char_map = { - r"\n": "\n", - r"\t": "\t", - r"\v": "\v", - r"\b": "\b", - r"\r": "\r", - r"\f": "\f", - r"\a": "\a", - r"\\": "\\", - r"\?": "?", - r"\"": "\"", - r"\'": "\'", -} -_escape_char_map = {v: k for k, v in _unescape_char_map.items()} - -def _re_escape_match(m): - return _escape_char_map[m.group()] - -def _re_unescape_match(m): - return _unescape_char_map[m.group()] - -def _escape(text): - return re.sub(r"[\n\t\v\b\r\f\a\\\?\"']", _re_escape_match, text) - -def _unescape(text): - return re.sub(r"(\\n|\\t|\\v|\\b|\\r|\\f|\\a|\\\\|\\\?|\\\"|\\')", _re_unescape_match, text) - -# parsing and dumping for KV1 -def parse(fp, mapper=dict, merge_duplicate_keys=True, escaped=True): - """ - Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a VDF) - to a Python object. - - ``mapper`` specifies the Python object used after deserializetion. ``dict` is - used by default. Alternatively, ``collections.OrderedDict`` can be used if you - wish to preserve key order. Or any object that acts like a ``dict``. - - ``merge_duplicate_keys`` when ``True`` will merge multiple KeyValue lists with the - same key into one instead of overwriting. You can se this to ``False`` if you are - using ``VDFDict`` and need to preserve the duplicates. - """ - if not issubclass(mapper, Mapping): - raise TypeError("Expected mapper to be subclass of dict, got %s" % type(mapper)) - if not hasattr(fp, 'readline'): - raise TypeError("Expected fp to be a file-like object supporting line iteration") - - stack = [mapper()] - expect_bracket = False - - re_keyvalue = re.compile(r'^("(?P(?:\\.|[^\\"])*)"|(?P#?[a-z0-9\-\_\\\?$%<>]+))' - r'([ \t]*(' - r'"(?P(?:\\.|[^\\"])*)(?P")?' - r'|(?P(?:(? ])+)' - r'|(?P{[ \t]*)(?P})?' - r'))?', - flags=re.I) - - for lineno, line in enumerate(fp, 1): - if lineno == 1: - line = strip_bom(line) - - line = line.lstrip() - - # skip empty and comment lines - if line == "" or line[0] == '/': - continue - - # one level deeper - if line[0] == "{": - expect_bracket = False - continue - - if expect_bracket: - raise SyntaxError("vdf.parse: expected openning bracket", - (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 1, line)) - - # one level back - if line[0] == "}": - if len(stack) > 1: - stack.pop() - continue - - raise SyntaxError("vdf.parse: one too many closing parenthasis", - (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 0, line)) - - # parse keyvalue pairs - while True: - match = re_keyvalue.match(line) - - if not match: - try: - line += next(fp) - continue - except StopIteration: - raise SyntaxError("vdf.parse: unexpected EOF (open key quote?)", - (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 0, line)) - - key = match.group('key') if match.group('qkey') is None else match.group('qkey') - val = match.group('qval') - if val is None: - val = match.group('val') - if val is not None: - val = val.rstrip() - if val == "": - val = None - - if escaped: - key = _unescape(key) - - # we have a key with value in parenthesis, so we make a new dict obj (level deeper) - if val is None: - if merge_duplicate_keys and key in stack[-1]: - _m = stack[-1][key] - # we've descended a level deeper, if value is str, we have to overwrite it to mapper - if not isinstance(_m, mapper): - _m = stack[-1][key] = mapper() - else: - _m = mapper() - stack[-1][key] = _m - - if match.group('eblock') is None: - # only expect a bracket if it's not already closed or on the same line - stack.append(_m) - if match.group('sblock') is None: - expect_bracket = True - - # we've matched a simple keyvalue pair, map it to the last dict obj in the stack - else: - # if the value is line consume one more line and try to match again, - # until we get the KeyValue pair - if match.group('vq_end') is None and match.group('qval') is not None: - try: - line += next(fp) - continue - except StopIteration: - raise SyntaxError("vdf.parse: unexpected EOF (open quote for value?)", - (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 0, line)) - - stack[-1][key] = _unescape(val) if escaped else val - - # exit the loop - break - - if len(stack) != 1: - raise SyntaxError("vdf.parse: unclosed parenthasis or quotes (EOF)", - (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 0, line)) - - return stack.pop() - - -def loads(s, **kwargs): - """ - Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON - document) to a Python object. - """ - if not isinstance(s, string_type): - raise TypeError("Expected s to be a str, got %s" % type(s)) - - try: - fp = unicodeIO(s) - except TypeError: - fp = strIO(s) - - return parse(fp, **kwargs) - - -def load(fp, **kwargs): - """ - Deserialize ``fp`` (a ``.readline()``-supporting file-like object containing - a JSON document) to a Python object. - """ - return parse(fp, **kwargs) - - -def dumps(obj, pretty=False, escaped=True): - """ - Serialize ``obj`` to a VDF formatted ``str``. - """ - if not isinstance(obj, Mapping): - raise TypeError("Expected data to be an instance of``dict``") - if not isinstance(pretty, bool): - raise TypeError("Expected pretty to be of type bool") - if not isinstance(escaped, bool): - raise TypeError("Expected escaped to be of type bool") - - return ''.join(_dump_gen(obj, pretty, escaped)) - - -def dump(obj, fp, pretty=False, escaped=True): - """ - Serialize ``obj`` as a VDF formatted stream to ``fp`` (a - ``.write()``-supporting file-like object). - """ - if not isinstance(obj, Mapping): - raise TypeError("Expected data to be an instance of``dict``") - if not hasattr(fp, 'write'): - raise TypeError("Expected fp to have write() method") - if not isinstance(pretty, bool): - raise TypeError("Expected pretty to be of type bool") - if not isinstance(escaped, bool): - raise TypeError("Expected escaped to be of type bool") - - for chunk in _dump_gen(obj, pretty, escaped): - fp.write(chunk) - - -def _dump_gen(data, pretty=False, escaped=True, level=0): - indent = "\t" - line_indent = "" - - if pretty: - line_indent = indent * level - - for key, value in data.items(): - if escaped and isinstance(key, string_type): - key = _escape(key) - - if isinstance(value, Mapping): - yield '%s"%s"\n%s{\n' % (line_indent, key, line_indent) - for chunk in _dump_gen(value, pretty, escaped, level+1): - yield chunk - yield "%s}\n" % line_indent - else: - if escaped and isinstance(value, string_type): - value = _escape(value) - - yield '%s"%s" "%s"\n' % (line_indent, key, value) - - -# binary VDF -class BASE_INT(int_type): - def __repr__(self): - return "%s(%d)" % (self.__class__.__name__, self) - -class UINT_64(BASE_INT): - pass - -class INT_64(BASE_INT): - pass - -class POINTER(BASE_INT): - pass - -class COLOR(BASE_INT): - pass - -BIN_NONE = b'\x00' -BIN_STRING = b'\x01' -BIN_INT32 = b'\x02' -BIN_FLOAT32 = b'\x03' -BIN_POINTER = b'\x04' -BIN_WIDESTRING = b'\x05' -BIN_COLOR = b'\x06' -BIN_UINT64 = b'\x07' -BIN_END = b'\x08' -BIN_INT64 = b'\x0A' -BIN_END_ALT = b'\x0B' - -def binary_loads(b, mapper=dict, merge_duplicate_keys=True, alt_format=False, raise_on_remaining=True): - """ - Deserialize ``b`` (``bytes`` containing a VDF in "binary form") - to a Python object. - - ``mapper`` specifies the Python object used after deserializetion. ``dict` is - used by default. Alternatively, ``collections.OrderedDict`` can be used if you - wish to preserve key order. Or any object that acts like a ``dict``. - - ``merge_duplicate_keys`` when ``True`` will merge multiple KeyValue lists with the - same key into one instead of overwriting. You can se this to ``False`` if you are - using ``VDFDict`` and need to preserve the duplicates. - """ - if not isinstance(b, bytes): - raise TypeError("Expected s to be bytes, got %s" % type(b)) - - return binary_load(BytesIO(b), mapper, merge_duplicate_keys, alt_format, raise_on_remaining) - -def binary_load(fp, mapper=dict, merge_duplicate_keys=True, alt_format=False, raise_on_remaining=False): - """ - Deserialize ``fp`` (a ``.read()``-supporting file-like object containing - binary VDF) to a Python object. - - ``mapper`` specifies the Python object used after deserializetion. ``dict` is - used by default. Alternatively, ``collections.OrderedDict`` can be used if you - wish to preserve key order. Or any object that acts like a ``dict``. - - ``merge_duplicate_keys`` when ``True`` will merge multiple KeyValue lists with the - same key into one instead of overwriting. You can se this to ``False`` if you are - using ``VDFDict`` and need to preserve the duplicates. - """ - if not hasattr(fp, 'read') or not hasattr(fp, 'tell') or not hasattr(fp, 'seek'): - raise TypeError("Expected fp to be a file-like object with tell()/seek() and read() returning bytes") - if not issubclass(mapper, Mapping): - raise TypeError("Expected mapper to be subclass of dict, got %s" % type(mapper)) - - # helpers - int32 = struct.Struct(' 1: - stack.pop() - continue - break - - key = read_string(fp) - - if t == BIN_NONE: - if merge_duplicate_keys and key in stack[-1]: - _m = stack[-1][key] - else: - _m = mapper() - stack[-1][key] = _m - stack.append(_m) - elif t == BIN_STRING: - stack[-1][key] = read_string(fp) - elif t == BIN_WIDESTRING: - stack[-1][key] = read_string(fp, wide=True) - elif t in (BIN_INT32, BIN_POINTER, BIN_COLOR): - val = int32.unpack(fp.read(int32.size))[0] - - if t == BIN_POINTER: - val = POINTER(val) - elif t == BIN_COLOR: - val = COLOR(val) - - stack[-1][key] = val - elif t == BIN_UINT64: - stack[-1][key] = UINT_64(uint64.unpack(fp.read(int64.size))[0]) - elif t == BIN_INT64: - stack[-1][key] = INT_64(int64.unpack(fp.read(int64.size))[0]) - elif t == BIN_FLOAT32: - stack[-1][key] = float32.unpack(fp.read(float32.size))[0] - else: - raise SyntaxError("Unknown data type at offset %d: %s" % (fp.tell() - 1, repr(t))) - - if len(stack) != 1: - raise SyntaxError("Reached EOF, but Binary VDF is incomplete") - if raise_on_remaining and fp.read(1) != b'': - fp.seek(-1, 1) - raise SyntaxError("Binary VDF ended at offset %d, but there is more data remaining" % (fp.tell() - 1)) - - return stack.pop() - -def binary_dumps(obj, alt_format=False): - """ - Serialize ``obj`` to a binary VDF formatted ``bytes``. - """ - buf = BytesIO() - binary_dump(obj, buf, alt_format) - return buf.getvalue() - -def binary_dump(obj, fp, alt_format=False): - """ - Serialize ``obj`` to a binary VDF formatted ``bytes`` and write it to ``fp`` filelike object - """ - if not isinstance(obj, Mapping): - raise TypeError("Expected obj to be type of Mapping") - if not hasattr(fp, 'write'): - raise TypeError("Expected fp to have write() method") - - for chunk in _binary_dump_gen(obj, alt_format=alt_format): - fp.write(chunk) - -def _binary_dump_gen(obj, level=0, alt_format=False): - if level == 0 and len(obj) == 0: - return - - int32 = struct.Struct('c3YnP4|=5C=){zQIc*NQ$~B(UK@qqDV@zWXjfMiJ}C8Xn=wU0(1kEEC`%1 zS!V`PamJ8VTESjvjif9`j-7<@#A{{8nJC93o|$B)Tie-Su*)s(&Zu@hTU$eyk}8+} z?0(;C9Ni#gOG##HYbOugAG+W1z5BiIdi^z%DUSm8&54g(rv@nM@9-tfPkIie*0su30WSC6RSU+vXQX-Bj)1VA zF3U&}lQ&Y#7+#@9N_@xRR-bZ5N?EUQ#^|zgNvdV^IJ4Uy#u%CMk<+n z#KaUZg^YzMVv3m(rj#jT%9#qLlBv3B7^z~aU!h!8@#=IM>Hk~s@=nHMfRewD)G#%G zy_Ts3SjW@>v@%wJ^{xh{o~d^$nTA*Bkw&Hw{F<01fX&Pxvj+Uuz<&$;w=hFYEBv=A zs67;8dxc`!Tt#mwAy>FXH)11U?GV=CvgL%ek+8K8*100AorJA}u=Oj#I!M?C2-~0-8xY-YBPY+-svx|tm#&ybonLtRx& zFVtge>b)7>``~>WvxnIU|J&hz7yS1ydzpUt-+}Sm3T8Jv_c8;}GJTBdFlE~p+LHI2 zpPBKxtZqMRWn2Ll>v4EJA&+ljo#fdX^jjT1#_DGMQ`TbxLwO8v-Ua1^fbJDjLkly0q~FC z|MP$Rv+p}ILkYYv4DW|q0NkL$R2=?Sx*$xkw383V!_?dKuuYNFcmt62bW+uS@VUcp z(@B-r<8uWtE9)csx-7aUKPV0nAZ}{GwMcUcPv%i_fzV*XD`{DP0^!*?G zIsCpKGLFu;-EJ2^m)jjO&-gq}KjT{K3OF6pE?J{tTarfe!NX@X8pcVvFcnm#pDF4s zXwG*sP0DJ6h%x1SnxHQI3^8SM|1ibsA*46GoRCyR6-N52J|&z57>_m z@7sNFV35UCQtSp6>rC2*fCda`0g!2=+uQCi@9*XtpAj0L;i{g!)fMado|n(xFXZp% zbonK`+DG*0Bf9Sq-SCKRu^B>&Q6JnvxX-~o4mS(8 z8*T^Oqj2}Z-2iustW~jnNUK)D!wt#hbuVftSx=Jhb#D7GFV*px{{ z=lUc)nWWDJFqzeAB{h7M*TZ<6L8pIex|eN+fK6}*Y5~kqT+vSPdhJN;g*YAE6@4k= zMd~Lj5Mm_-+6fOgs35?!gLxvIMQQJx#WcH~r#nuOEU=3M%I-YlVC_?m>7;ss_0LSh zl%c029R(3tS32&LBj`NCwnH|X;SQ7ln4=aARk2-f?0J39Yx{2Q6AWuO)tdiHb+FiH zU~c2I$kc*ug)*@=EFGEiq$`pZtV1TQSc^`G^9;sI*PZI>o}2d|QEqSTP(bJ2~nb4UV209Uo;!-J_1t(b2xqhL%$} znpm7fGvlP0aRCduUJgntqfPY&+XaQ#jx{I;fc;>a-@;ise$m-`PsJMs1;Zex8vG}$ z#QN6JQD1m;Gzj-OxX0mU;daCAfO~WlK_7w!04+9~l3fo)Wj7$e_GdQ&kk(C~=_M97 zf?f>9(VMB=;4k)^;7;0k!_>fLA!}=xfq%bYpKxC_5pe{(L zB@qpDqBf0?qQbO%{R_c5Dfjsj9mEwe<-!!Bkgu(Qd>M9SZfXVQ0jaYT(F8rKVpOy0 zAl4`4&SutUMja#+sTgoJQ`UDi@_c7C!NPQEs0YPp<>3QVRC%g~tZv#_U0BO#C&_-m z<_C);>2&h)LQGv;l7BX)ybc(T(TNxXMtIg|mm(%Fl@mSRpA%w8g#h(DtDb)$tY+5- z%d&Ye#$Xl=*2%<}!_-+*I>uStV2C6A1Y;pf@nH?aI=4#R3SXjgN|2u_!SP^S8W*&l zO5O_4R%G0$RwJxQ@-?z#tHgzvtHyn7t5wMBHP-<%4R^a0E^L&?q^ZZ^tdz%`Q!s_IYTs**jbD`$ z|IA}!=8T9h9)7af6{Y9@^XJa5>VLxdl{=aY@*4Z-uwk_xjwi27f7#K$4(f~c|fCE2QvJx%Q`j|7#p*;I`ARL!XxmfBw%a|2J8G`b>CvXON{%IClAC<704Y1I2U!pW zz#FL)l-v=tI-J3P)$5sbL7h{D8_QPL#ZI{F%*?dc<8%aFc0h$Kd;Sav4#vigurn@v z^LV}1DU4~If;xDnK_ao=b>W!9JL3Y(0lVJ+osZ~skLZh`CJ?N2PCM9uYn#=TZfgIu z%SUG3I1BO@S1_sa!N3TqdYS{hkLcM@yCe|~lAzxY-2GhMo281pjjNyPMa6}dx zIKy-%g9nGKt(X&;1uxC`gRVYXQiZKOoKymYXK0P262Qm*8(dN&)+(tHE1cAbZ5P@g zDbA`H5adJ@2e@V+n-I#A($xl86cigqn55LWERj?JYbzAgW~)HaOM29?8f-`XkqgtV zL6-Hiz&XNWQVSJ!1VJc+tXEQt@(37iNqS#W@AA#SG=zC7N@IvD$8h)pEO9T37_<|v zAf`>~?RGMA(kynDJv|T%z}-XFkY)q{ zAj}w_pG9_nJ%*qk!2o8euulchAJ_kk6Ga4SGTc}OLNR{e8j$vL)UPWkV`(}eDBY@xaW`kWzWxg`0^Kd^Krp^oYNg&G+3e=qaohVAQ&1j_J|n! zIBz~7m``xJ6HBI|$gxYu=Z{C8of}M)RL%`QuoPcwTc*^tO}{o$O>5rlS~h8lY@bj7 zeuZFe|E~+EiiUVY+`*T(3gxZK)Dc>3`Gmkr#)u}WN*D^GFI?Up*}hm*9XoQR?^<7E zU`doXUYebsji{D2l(8VX@$$CFwpek@akDJG`}NvbZNgYAhS2lfQRn5}NN=L1Au6@?J$ZUU&oY%|Cg^DWWMmqPQQ*sjZe5cz{dLCFpMRs9viHAB>pC@6n`S?&Lg zv+CAc62*1DEN;GE+#F~4;&!39Jug;9Ew77O3<%$GEtONp6i7 z>Rsi-dIN-dmjF~Ex=%m-6dJ(R`7OiO4GTkj>vo}aJJ-59+I*w^YJ1GZTbcw*6K84q zsN`>|{;G;QdXnEaD(oAL>`qw9NEA13X%;Na;E`{MTuhW!-I%;O8E@uGTZPirs4`Jh z8tqF|*1Xa7dfRIqH#?%c6J?dL@v9f27ZSA%G38QzDRx8iVrgAmdBu0l7ga)U7Zd@i zqLyV!TiAMM_rm78mhWukI(pzrRMf`Un-%d*H*2H)52~8u<9F8ZRU3q=4Opx0L}%9> z_uFUQJ;Rl6i78@7;~Q_DhzDLf{pnIgU99xA@|)$+{zP+2bTHO%ZC}iJWf+?N#`de* zV=wbXtwK>NSG0bqxZ=ivs|Vs1XnUc!i7ReOlvUrjc=clZ8NRGTDC^+Lx)QdvG4rR( zMhfD}Q!gC-;N*KJ@0IeK_X?Z$a+{ApmzJ<}qP+UHDt_oIx;J$&KVquCEw_HUSOv30 z0fADuSZm|jPA#@?T-dm9?(Vsd6hAWxdr$Fwr}*~MLi=fM%*~zgaFc$nZ5q0?j>Rqo z2$in@s6=#Pmv(LE>UZC+xU=aiwQttOYwsze>gf12eXQ|{`4bIgvOLh{MK*si^hzlD z!k4}<_k~4s1y{L$vAQwde@C;Rxoi2bTG%?wuOH^C4+_->xffpKPQZW~PFbESR{Xqp`*6P6nGr(5 z5{BCW%8nlXJ%AiJ81);&pX(O0DBUAWV(f1xNfAtqRA57 zK=vyLk0_Rv5CF5_*ElSr7S2!$SM;3ttyD0}+1`MWgK4>T3K8k9e%rvb{wB}!Sz zxJ0#Z?zoioCms62D*fr624cPynUBsiS>0+I8(S+OnpY6iS-y=RbXc*2t)JhyHd^cs z1?dC!ER;BabZSb+1KLGUA+l58^D_)Wjgi<5tF;Z0RS!9p5Gn0YZj0{^8(`+-9%XvsPNGH+Z7QZ7fHBgdnV&($0}iYLaiLb}bU;*uGkE(?`2>%(+dAy<~j z%L6l99qJ|>csQlHM%Ep8CKwQ8dIB$p1T|2j$eX2@`4rFAmYJrEBj`x;UcM}E?{}x! z*+&hTxWE(#gBMb~|c~CG9a=O7qLkUo^Og2U@A!2)Y^A5qhgVXK62otx0yrD@j05wFb`$&Wxyt!8} z_j0=4C4=eJ?#tcRx5f^~*W790i#7^H8+pSf!LW%_Z4$Li(muvnPDZxxcRR8(nhw;; zJgt^RHZK%1{Wi?%cW`DCm!qx8k^AS&3*{5zQOn0O;K6k;<-!!`mX-4HKR}%-n^lGB zxMT*WfN1 zzgRyMEU6|*B=bj6lYdkz844=_GCGvk{K;Aq3mSX8|yRX9=DFnInqxC7q@klr0XZ=N9kcAhuX35GhH z2CL1J-)6WK0g9K+-=3cl@kn& zGaBK3cointeu{?egF%&{VpbidS#?+yR)(Ni;Ejqyw3Y5H@OmfX4MXisq6XB=YC&<( z6vWA!a$${>V3Thlpoox8NsWAngZfd5NBj7x!fptw|254h!y14p@~pn4IY!-}bBIGN zZWCcJnhQbc-hw6Poy@WWb0ftEULgXDuHIas}7a@57HPbjbh!f3k z$h<=ED~wPNL+F3N4@_`Og>yp*OYz+PC9MgEWpkpmIyQ5~7cnfAR^B*!_3RbzHSaQI zQuh*YDKDao98DN35LaJ!Jrr-eeUUHQB$RC;9*dR=;EFn~bwqYQfE~tl>%}x_s@L}> zn%Boq#!oIZlHbJz_;HrqoH2DRg3M#{oiz(BcQ@ZF{BAd2v0JFv4OmUp1Vq)q5Jy3B zfWHLfv!A!LaK`MFVt-q1ZHv3UagwjvDpYO7lr4+pb#e7;=9}iIdP!D$=%1RBc=s;3~KB`CB>NR#L}dn~ES$=GpC2#9$DF zeMYU1)O(9V>dW|qz=)YN!oytVx2&Mm+o17R05LtLa>AW)nU+OW zzO-erC6d~s(4O`!UBhoHNkQ355R1KxAg4_8=!c*HFg`?^ylj~gD&5?Gm_NpNiu^UH z?Abp?^f_5Z(GNipWXb*szL7RUucydE`}{%3W$@7Os+n9xvSDFcWJw+z!-3JdG zd`uSCFbf0~@+{EnA$X-AO`a75DhX5(s3uTDpq4-#fq4WPoNC07av3h@>)`PeT+nA( z?BvKLKF?xDPKn7EdvU`7>klaNJDGChNOWukl95nLa*@M0a;Rft<7f{Hk6G^1DpFq_ zpS5A!<8!bV2)okodo?1_Q2sMhBd#JjA|oavIT9Jiq?-6jWJU&Y?AVF$K?QThrcTo1 z>?l03rvN1L9NwT^WQ3Cz*5L`b?0z5Y3R9x)I+t8FO7I0(qzhYNf(H)51CY%`1>(3> zk|l~iOQ`g~PKAYoYiSuD$PGCHGv8xt?t9BN?lN`(Y(K{ZY>BzXT+04!LQS z@^BEIV`s+}4CGu+)|EN$=PM*H}aRCA@Qh_;Ze(Eo;mWERo5N~=O?l1%O#&5 zXZ@E;j%uXqmjqv~&6oBu@$~W)Z&n8{^Qx9k z=CC<84GM$8d2xySI$QQ|&gmK`eH2PqosE$yAzD?fsLg6Q%`ZTDmA*_&&lJ2{ zDDRI|aoh(S)-(o?*EL9{VgAV@;AmJY3+O{ zk)#x z-I}%%MD(D}CAUTD z-vV)qv_!@7SYXGjVvjv;zU7|aV@xTWJ0OKMTiWaslMiWt#C->D(Sa~Vnt#dDw8(1v zAgqT^u$BX@UFH~uLaah-=ct1|Ph2S>#tE_%8IHDmC<9%g;!DXwe{aY4|DhdUQiTdc zJYnMnbxgqJnhYJvXmvizK2J1HgjB6II63K>Y_*XSlZXu-L1i?l$E7TNI>kRGo(Srs5p1@Z-t!NnzHG?YB$K=Q0$G(H-RnE(gz4iOVz5Y!}7!i5(g zmM)AwI?RP&#F`=}v%-ayQj!%EgfhIi(2_iLkf$Cc!i+w5!3rxFDy;mnLPA7nAWbQ3 z(b(=Q9Fw#3&T4!oq{Ob2)SaQ(vd7{vFh+S<08W})sN^c6}5U4G6iuMU${pfZFT)}Nt5H%8AH$=aV z330#@+4UpMOwhe{!{rkS$319(PGW%SyoZ6)Z{suWq!Nq+lNzxsM2ZbIgsuRX3kOhIB#N?A z+8!|fb1-(X_#vx=m+kBU6I8JN?Inf+sThY~00s5~01;?W8`l-}^F_OdpryzT_a`I&2Hu9)LNu3=-mK3>02$QNu{c!Ae-3%YJj*A1~P zCD9{MXY>dbe94f%OzHI76D3tQPF+0(HdQ4ZLPwI` z$rcO;QxMbkL_z5d(^XS!f-hJj6s+OM^(lyMA*iD6jhfeM;^!Cie8o1QVp~*$KQIJY z$}fqS0!HYQAFVGL&`>|tln+>yPI%8aTq(%v)(H>S=^GRf4Vggc12Frt*^MH$VKU^v z4g-f1{NXqWKrCvGNSz<)dc2OQamLXbs#&$?)4?xex1({&r*l-S;f-9;Z9^r42MzDXaP7q^O*184#OhVbIpglPg(B@nV5ayj7iIAaCF z+z#vbOwigd3iwdl3a02DA6njeT|rlRpfTAe`Q`QAC-NR40i)ktioMGd?^d zPdW{DR!_)9q}4>8EaFBH{+2Exn->#`?@`R06m;mo!CjCASwYBxg1hxJOO_E^fv5)_ z#Y&^Zi+vNpZA`3&Qvy&j%?$i+=_0T2r*(s{4E)*eVMIGd%-?5NyM7^-~z)Fs@KkRs{OvbG)HeFw~;H!$;qqxHG=6 zhF`N)ScB>(@cE0fk1QV@<98hqb{!FYh^>W}H%|%XDNZ*fT5CM1%`uo_nTqD0i#74a zI>A^sH@FC|r(#{a$tswvb3=TtByGSyhjgUUD!*Q|4lcnR4?w zu5{=1iRi@pC+7}6FcpH)YUYYNc~hHU0t@CQwVnQizzCf%7^C_34RxHM?sKeu6UM?z zgG=U$$YiYHl7HSGQ7##b*L9b7M0OKBXc;|hSl`~mWF&3J*nr^0b#=c-!v#R4c>DIO?&y8eL~H?+~n=|#r>nE>5bE`pT5)otvz4gv#{qo2l$R% zLdPz?reCP(zqdiC8I&d@Hr@UA#(z5T!-*ewe(d269sa@8FOHtzMo#iaM}?!K+~6s` z_7rb9Em%%-#?z~r&JObCA;CPv>4p+ov`Sa|>DV|P)sH(~JA3o&o!$3q*KxJ$(0T%Q zPDOOrCG)&FVkUOCCpo+0mv;AkyPLP45$tEUNiT2r@|9D(*(aENoX)poD3I9K64FRU zoU37$;}-Vt3;?-y>MiieN*reuQkgKZ=b`2HJV4AT;<%-(aB@tr@zJ53g!O!krJK0d z<(TqhG)|&P4ji{fk~*1I7obs0QU^ymh-me!s%DzXD zBPLi)=pZYTE@(+(f&~d${hdt9vm1iN*|4w{$GOx8-&5vfXaJLPVIB0o4#Qy1>*cF8 zF(-qsB&5yB=KobrStRtxekujhd zB(@^pZAzCmJr*Pa6Rk8A84+Y$i1|a^ujkZ#O%_*9-8+J<*|5j-zUDV*{oMX<%jOd7 zkUS%wopMq=Rqj_$SZ_{^B=~Y_lo#BX#+Yt7Uu#ZkNeNb@mS~_-{izS)2Yymc^b4=( zft0`U$=WK_Q;PYsvK7ZDTXAw{7wiJ^6&rLY3eav#^iZJP-j*(Dy7t7x(=<%v11yq& z?7IlQf#916{uDr{8Bc-ZNn+sRX97VyBc47(08Dz?&O;PCEMltn5PTbx79aJc4zz%L z05@`!GT3TGj{OH1?S}~d00FLvtQ!CvMg}nhNY;p4U_W|8{V4V)2$0+&{5JdV;VG#i z3_9}L?B5{xDT0qM1de3`ugr4jaSg#$^i={sozwvkPcZ#82K*I*zeMmO1V08~%M+=D zIrMlF!F>e(0fB(v7YOu;X66LU$r7Tpn#wh)z&|D}j zAdA;uor+E+bmoZWK@O|?G>q_4X~hlCRnL{lYm>`VgSsDBS%jj2D{|z{TibaZA!uC~QqOdrw&6IV+WSH1f$n2$Cgs{^O|c+2yG<$2Ede2(#JwZ0z?)>g(2 zU+KL43~y=YjHzp}!gi;5p=9BuZh4YxE=0thT z8^+g-@fZ2>wLJv$*+ht-!9?vTZDXQTeZmwM`@$^ z;%~9ADmHk#n=fn^3Zec=46Nr0ve$!j+*G+aqgA|6Qh+1pC=^hzG;+q&#Ty&R2-^7m zk-N>`KKY%Kd^I#WNDg*!#$8Jlja**WAGbtWzEQ=gx}+D8zW!w0nmwh8pO&`oRjQp* z!Veb!e1E8dd4wN{WPmx6YC{-hMzstv(ry*gC<#_6;fWtRV>D8X^5uUNu%iA)#-LG* zhM{F?AXb)vTD3$u#3HbKGNvsTBbse8Iw0y)fEjMl0aKReXacH{uuXEaP4W?#3==KU z6k8qEWBvP&{a!)*&&)z|_+uP54-sJhhs^tYAUp9e)-#}S0`WO+{2wDn87fGJfDXVp z8JL+m!s3PwhM9TC@arCf_(cx(2jIp23<1t1VrdDs_8xrBh_aKqGzvLuoy?bBj?>l=6z#mZ zLoj!6x{e2ivKSq!k2S;^ZmMJFxR&i7sW`)Pyx}>)@EoUlPL%aPu`({R`1~92LdAAG z6C{0*^0c^|yqjaSDW}k8X{oY0_uGuK3PvSeYR+Qs5yz-OeGD@{%QF%xpGHVzHQPQ* zRzns5>EY6pb$9Cc8>$M#K4eM^$2iKrPZ9`Nt|Bx5%}R03(zpIfdr(1>{8Gwkc$HV)phZlAz`YW%Uh!KbL5wx z^5)1dL7C>rFF{pu@+(1=a`G!dHF5F_bi{O1Le;{pxKKxoL5K2%LGn~V<4ClnKb5_76s@f{XaW7M6Nnfpi$CVno623Jg z0|j~58*)&-mfpNf$-x*+Rn{&HU?&Yj0am~cE&U99vS$SdAocN Date: Wed, 21 Feb 2024 00:39:07 -0600 Subject: [PATCH 03/15] build: update deps - Set stage for removing modules directory - Export requirements.txt for backward compatibility - Bump version --- poetry.lock | 1325 +++++++++++++++++++++++++++++++++++++++++----- pyproject.toml | 24 +- requirements.txt | 8 + 3 files changed, 1217 insertions(+), 140 deletions(-) create mode 100644 requirements.txt diff --git a/poetry.lock b/poetry.lock index 21ee69a..f68a671 100644 --- a/poetry.lock +++ b/poetry.lock @@ -18,6 +18,112 @@ six = ">=1.12.0" astroid = ["astroid (>=1,<2)", "astroid (>=2,<4)"] test = ["astroid (>=1,<2)", "astroid (>=2,<4)", "pytest"] +[[package]] +name = "attrs" +version = "23.2.0" +description = "Classes Without Boilerplate" +optional = false +python-versions = ">=3.7" +files = [ + {file = "attrs-23.2.0-py3-none-any.whl", hash = "sha256:99b87a485a5820b23b879f04c2305b44b951b502fd64be915879d77a7e8fc6f1"}, + {file = "attrs-23.2.0.tar.gz", hash = "sha256:935dc3b529c262f6cf76e50877d35a4bd3c1de194fd41f47a2b7ae8f19971f30"}, +] + +[package.extras] +cov = ["attrs[tests]", "coverage[toml] (>=5.3)"] +dev = ["attrs[tests]", "pre-commit"] +docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier", "zope-interface"] +tests = ["attrs[tests-no-zope]", "zope-interface"] +tests-mypy = ["mypy (>=1.6)", "pytest-mypy-plugins"] +tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "pytest (>=4.3.0)", "pytest-xdist[psutil]"] + +[[package]] +name = "black" +version = "24.2.0" +description = "The uncompromising code formatter." +optional = false +python-versions = ">=3.8" +files = [ + {file = "black-24.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6981eae48b3b33399c8757036c7f5d48a535b962a7c2310d19361edeef64ce29"}, + {file = "black-24.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d533d5e3259720fdbc1b37444491b024003e012c5173f7d06825a77508085430"}, + {file = "black-24.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:61a0391772490ddfb8a693c067df1ef5227257e72b0e4108482b8d41b5aee13f"}, + {file = "black-24.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:992e451b04667116680cb88f63449267c13e1ad134f30087dec8527242e9862a"}, + {file = "black-24.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:163baf4ef40e6897a2a9b83890e59141cc8c2a98f2dda5080dc15c00ee1e62cd"}, + {file = "black-24.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e37c99f89929af50ffaf912454b3e3b47fd64109659026b678c091a4cd450fb2"}, + {file = "black-24.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4f9de21bafcba9683853f6c96c2d515e364aee631b178eaa5145fc1c61a3cc92"}, + {file = "black-24.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:9db528bccb9e8e20c08e716b3b09c6bdd64da0dd129b11e160bf082d4642ac23"}, + {file = "black-24.2.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d84f29eb3ee44859052073b7636533ec995bd0f64e2fb43aeceefc70090e752b"}, + {file = "black-24.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1e08fb9a15c914b81dd734ddd7fb10513016e5ce7e6704bdd5e1251ceee51ac9"}, + {file = "black-24.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:810d445ae6069ce64030c78ff6127cd9cd178a9ac3361435708b907d8a04c693"}, + {file = "black-24.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:ba15742a13de85e9b8f3239c8f807723991fbfae24bad92d34a2b12e81904982"}, + {file = "black-24.2.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:7e53a8c630f71db01b28cd9602a1ada68c937cbf2c333e6ed041390d6968faf4"}, + {file = "black-24.2.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:93601c2deb321b4bad8f95df408e3fb3943d85012dddb6121336b8e24a0d1218"}, + {file = "black-24.2.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0057f800de6acc4407fe75bb147b0c2b5cbb7c3ed110d3e5999cd01184d53b0"}, + {file = "black-24.2.0-cp38-cp38-win_amd64.whl", hash = "sha256:faf2ee02e6612577ba0181f4347bcbcf591eb122f7841ae5ba233d12c39dcb4d"}, + {file = "black-24.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:057c3dc602eaa6fdc451069bd027a1b2635028b575a6c3acfd63193ced20d9c8"}, + {file = "black-24.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:08654d0797e65f2423f850fc8e16a0ce50925f9337fb4a4a176a7aa4026e63f8"}, + {file = "black-24.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca610d29415ee1a30a3f30fab7a8f4144e9d34c89a235d81292a1edb2b55f540"}, + {file = "black-24.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:4dd76e9468d5536abd40ffbc7a247f83b2324f0c050556d9c371c2b9a9a95e31"}, + {file = "black-24.2.0-py3-none-any.whl", hash = "sha256:e8a6ae970537e67830776488bca52000eaa37fa63b9988e8c487458d9cd5ace6"}, + {file = "black-24.2.0.tar.gz", hash = "sha256:bce4f25c27c3435e4dace4815bcb2008b87e167e3bf4ee47ccdc5ce906eb4894"}, +] + +[package.dependencies] +click = ">=8.0.0" +mypy-extensions = ">=0.4.3" +packaging = ">=22.0" +pathspec = ">=0.9.0" +platformdirs = ">=2" + +[package.extras] +colorama = ["colorama (>=0.4.3)"] +d = ["aiohttp (>=3.7.4)", "aiohttp (>=3.7.4,!=3.9.0)"] +jupyter = ["ipython (>=7.8.0)", "tokenize-rt (>=3.2.0)"] +uvloop = ["uvloop (>=0.15.2)"] + +[[package]] +name = "build" +version = "1.0.3" +description = "A simple, correct Python build frontend" +optional = false +python-versions = ">= 3.7" +files = [ + {file = "build-1.0.3-py3-none-any.whl", hash = "sha256:589bf99a67df7c9cf07ec0ac0e5e2ea5d4b37ac63301c4986d1acb126aa83f8f"}, + {file = "build-1.0.3.tar.gz", hash = "sha256:538aab1b64f9828977f84bc63ae570b060a8ed1be419e7870b8b4fc5e6ea553b"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "os_name == \"nt\""} +packaging = ">=19.0" +pyproject_hooks = "*" + +[package.extras] +docs = ["furo (>=2023.08.17)", "sphinx (>=7.0,<8.0)", "sphinx-argparse-cli (>=1.5)", "sphinx-autodoc-typehints (>=1.10)", "sphinx-issues (>=3.0.0)"] +test = ["filelock (>=3)", "pytest (>=6.2.4)", "pytest-cov (>=2.12)", "pytest-mock (>=2)", "pytest-rerunfailures (>=9.1)", "pytest-xdist (>=1.34)", "setuptools (>=42.0.0)", "setuptools (>=56.0.0)", "setuptools (>=56.0.0)", "setuptools (>=67.8.0)", "wheel (>=0.36.0)"] +typing = ["importlib-metadata (>=5.1)", "mypy (>=1.5.0,<1.6.0)", "tomli", "typing-extensions (>=3.7.4.3)"] +virtualenv = ["virtualenv (>=20.0.35)"] + +[[package]] +name = "cachecontrol" +version = "0.13.1" +description = "httplib2 caching for requests" +optional = false +python-versions = ">=3.7" +files = [ + {file = "cachecontrol-0.13.1-py3-none-any.whl", hash = "sha256:95dedbec849f46dda3137866dc28b9d133fc9af55f5b805ab1291833e4457aa4"}, + {file = "cachecontrol-0.13.1.tar.gz", hash = "sha256:f012366b79d2243a6118309ce73151bf52a38d4a5dac8ea57f09bd29087e506b"}, +] + +[package.dependencies] +filelock = {version = ">=3.8.0", optional = true, markers = "extra == \"filecache\""} +msgpack = ">=0.5.2" +requests = ">=2.16.0" + +[package.extras] +dev = ["CacheControl[filecache,redis]", "black", "build", "cherrypy", "mypy", "pytest", "pytest-cov", "sphinx", "tox", "types-redis", "types-requests"] +filecache = ["filelock (>=3.8.0)"] +redis = ["redis (>=2.10.5)"] + [[package]] name = "certifi" version = "2024.2.2" @@ -29,6 +135,70 @@ files = [ {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"}, ] +[[package]] +name = "cffi" +version = "1.16.0" +description = "Foreign Function Interface for Python calling C code." +optional = false +python-versions = ">=3.8" +files = [ + {file = "cffi-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6b3d6606d369fc1da4fd8c357d026317fbb9c9b75d36dc16e90e84c26854b088"}, + {file = "cffi-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ac0f5edd2360eea2f1daa9e26a41db02dd4b0451b48f7c318e217ee092a213e9"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e61e3e4fa664a8588aa25c883eab612a188c725755afff6289454d6362b9673"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a72e8961a86d19bdb45851d8f1f08b041ea37d2bd8d4fd19903bc3083d80c896"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b50bf3f55561dac5438f8e70bfcdfd74543fd60df5fa5f62d94e5867deca684"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7651c50c8c5ef7bdb41108b7b8c5a83013bfaa8a935590c5d74627c047a583c7"}, + {file = "cffi-1.16.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4108df7fe9b707191e55f33efbcb2d81928e10cea45527879a4749cbe472614"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:32c68ef735dbe5857c810328cb2481e24722a59a2003018885514d4c09af9743"}, + {file = "cffi-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:673739cb539f8cdaa07d92d02efa93c9ccf87e345b9a0b556e3ecc666718468d"}, + {file = "cffi-1.16.0-cp310-cp310-win32.whl", hash = "sha256:9f90389693731ff1f659e55c7d1640e2ec43ff725cc61b04b2f9c6d8d017df6a"}, + {file = "cffi-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:e6024675e67af929088fda399b2094574609396b1decb609c55fa58b028a32a1"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b84834d0cf97e7d27dd5b7f3aca7b6e9263c56308ab9dc8aae9784abb774d404"}, + {file = "cffi-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1b8ebc27c014c59692bb2664c7d13ce7a6e9a629be20e54e7271fa696ff2b417"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee07e47c12890ef248766a6e55bd38ebfb2bb8edd4142d56db91b21ea68b7627"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8a9d3ebe49f084ad71f9269834ceccbf398253c9fac910c4fd7053ff1386936"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e70f54f1796669ef691ca07d046cd81a29cb4deb1e5f942003f401c0c4a2695d"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5bf44d66cdf9e893637896c7faa22298baebcd18d1ddb6d2626a6e39793a1d56"}, + {file = "cffi-1.16.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7b78010e7b97fef4bee1e896df8a4bbb6712b7f05b7ef630f9d1da00f6444d2e"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:c6a164aa47843fb1b01e941d385aab7215563bb8816d80ff3a363a9f8448a8dc"}, + {file = "cffi-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e09f3ff613345df5e8c3667da1d918f9149bd623cd9070c983c013792a9a62eb"}, + {file = "cffi-1.16.0-cp311-cp311-win32.whl", hash = "sha256:2c56b361916f390cd758a57f2e16233eb4f64bcbeee88a4881ea90fca14dc6ab"}, + {file = "cffi-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:db8e577c19c0fda0beb7e0d4e09e0ba74b1e4c092e0e40bfa12fe05b6f6d75ba"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fa3a0128b152627161ce47201262d3140edb5a5c3da88d73a1b790a959126956"}, + {file = "cffi-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:68e7c44931cc171c54ccb702482e9fc723192e88d25a0e133edd7aff8fcd1f6e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:abd808f9c129ba2beda4cfc53bde801e5bcf9d6e0f22f095e45327c038bfe68e"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88e2b3c14bdb32e440be531ade29d3c50a1a59cd4e51b1dd8b0865c54ea5d2e2"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcc8eb6d5902bb1cf6dc4f187ee3ea80a1eba0a89aba40a5cb20a5087d961357"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7be2d771cdba2942e13215c4e340bfd76398e9227ad10402a8767ab1865d2e6"}, + {file = "cffi-1.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e715596e683d2ce000574bae5d07bd522c781a822866c20495e52520564f0969"}, + {file = "cffi-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2d92b25dbf6cae33f65005baf472d2c245c050b1ce709cc4588cdcdd5495b520"}, + {file = "cffi-1.16.0-cp312-cp312-win32.whl", hash = "sha256:b2ca4e77f9f47c55c194982e10f058db063937845bb2b7a86c84a6cfe0aefa8b"}, + {file = "cffi-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:68678abf380b42ce21a5f2abde8efee05c114c2fdb2e9eef2efdb0257fba1235"}, + {file = "cffi-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:0c9ef6ff37e974b73c25eecc13952c55bceed9112be2d9d938ded8e856138bcc"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a09582f178759ee8128d9270cd1344154fd473bb77d94ce0aeb2a93ebf0feaf0"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e760191dd42581e023a68b758769e2da259b5d52e3103c6060ddc02c9edb8d7b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:80876338e19c951fdfed6198e70bc88f1c9758b94578d5a7c4c91a87af3cf31c"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6a14b17d7e17fa0d207ac08642c8820f84f25ce17a442fd15e27ea18d67c59b"}, + {file = "cffi-1.16.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6602bc8dc6f3a9e02b6c22c4fc1e47aa50f8f8e6d3f78a5e16ac33ef5fefa324"}, + {file = "cffi-1.16.0-cp38-cp38-win32.whl", hash = "sha256:131fd094d1065b19540c3d72594260f118b231090295d8c34e19a7bbcf2e860a"}, + {file = "cffi-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:31d13b0f99e0836b7ff893d37af07366ebc90b678b6664c955b54561fc36ef36"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:582215a0e9adbe0e379761260553ba11c58943e4bbe9c36430c4ca6ac74b15ed"}, + {file = "cffi-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b29ebffcf550f9da55bec9e02ad430c992a87e5f512cd63388abb76f1036d8d2"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dc9b18bf40cc75f66f40a7379f6a9513244fe33c0e8aa72e2d56b0196a7ef872"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cb4a35b3642fc5c005a6755a5d17c6c8b6bcb6981baf81cea8bfbc8903e8ba8"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b86851a328eedc692acf81fb05444bdf1891747c25af7529e39ddafaf68a4f3f"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c0f31130ebc2d37cdd8e44605fb5fa7ad59049298b3f745c74fa74c62fbfcfc4"}, + {file = "cffi-1.16.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f8e709127c6c77446a8c0a8c8bf3c8ee706a06cd44b1e827c3e6a2ee6b8c098"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:748dcd1e3d3d7cd5443ef03ce8685043294ad6bd7c02a38d1bd367cfd968e000"}, + {file = "cffi-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:8895613bcc094d4a1b2dbe179d88d7fb4a15cee43c052e8885783fac397d91fe"}, + {file = "cffi-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed86a35631f7bfbb28e108dd96773b9d5a6ce4811cf6ea468bb6a359b256b1e4"}, + {file = "cffi-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:3686dffb02459559c74dd3d81748269ffb0eb027c39a6fc99502de37d501faa8"}, + {file = "cffi-1.16.0.tar.gz", hash = "sha256:bcb3ef43e58665bbda2fb198698fcae6776483e0c4a631aa5647806c25e02cc0"}, +] + +[package.dependencies] +pycparser = "*" + [[package]] name = "charset-normalizer" version = "3.3.2" @@ -128,6 +298,35 @@ files = [ {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"}, ] +[[package]] +name = "cleo" +version = "2.1.0" +description = "Cleo allows you to create beautiful and testable command-line interfaces." +optional = false +python-versions = ">=3.7,<4.0" +files = [ + {file = "cleo-2.1.0-py3-none-any.whl", hash = "sha256:4a31bd4dd45695a64ee3c4758f583f134267c2bc518d8ae9a29cf237d009b07e"}, + {file = "cleo-2.1.0.tar.gz", hash = "sha256:0b2c880b5d13660a7ea651001fb4acb527696c01f15c9ee650f377aa543fd523"}, +] + +[package.dependencies] +crashtest = ">=0.4.1,<0.5.0" +rapidfuzz = ">=3.0.0,<4.0.0" + +[[package]] +name = "click" +version = "8.1.7" +description = "Composable command line interface toolkit" +optional = false +python-versions = ">=3.7" +files = [ + {file = "click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28"}, + {file = "click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de"}, +] + +[package.dependencies] +colorama = {version = "*", markers = "platform_system == \"Windows\""} + [[package]] name = "colorama" version = "0.4.6" @@ -139,84 +338,135 @@ files = [ {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"}, ] -[[package]] -name = "commonmark" -version = "0.9.1" -description = "Python parser for the CommonMark Markdown spec" -optional = false -python-versions = "*" -files = [ - {file = "commonmark-0.9.1-py2.py3-none-any.whl", hash = "sha256:da2f38c92590f83de410ba1a3cbceafbc74fee9def35f9251ba9a971d6d66fd9"}, - {file = "commonmark-0.9.1.tar.gz", hash = "sha256:452f9dc859be7f06631ddcb328b6919c67984aca654e5fefb3914d54691aed60"}, -] - -[package.extras] -test = ["flake8 (==3.7.8)", "hypothesis (==3.55.3)"] - [[package]] name = "coverage" -version = "7.4.1" +version = "7.4.2" description = "Code coverage measurement for Python" optional = false python-versions = ">=3.8" files = [ - {file = "coverage-7.4.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:077d366e724f24fc02dbfe9d946534357fda71af9764ff99d73c3c596001bbd7"}, - {file = "coverage-7.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:0193657651f5399d433c92f8ae264aff31fc1d066deee4b831549526433f3f61"}, - {file = "coverage-7.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d17bbc946f52ca67adf72a5ee783cd7cd3477f8f8796f59b4974a9b59cacc9ee"}, - {file = "coverage-7.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a3277f5fa7483c927fe3a7b017b39351610265308f5267ac6d4c2b64cc1d8d25"}, - {file = "coverage-7.4.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6dceb61d40cbfcf45f51e59933c784a50846dc03211054bd76b421a713dcdf19"}, - {file = "coverage-7.4.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:6008adeca04a445ea6ef31b2cbaf1d01d02986047606f7da266629afee982630"}, - {file = "coverage-7.4.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:c61f66d93d712f6e03369b6a7769233bfda880b12f417eefdd4f16d1deb2fc4c"}, - {file = "coverage-7.4.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b9bb62fac84d5f2ff523304e59e5c439955fb3b7f44e3d7b2085184db74d733b"}, - {file = "coverage-7.4.1-cp310-cp310-win32.whl", hash = "sha256:f86f368e1c7ce897bf2457b9eb61169a44e2ef797099fb5728482b8d69f3f016"}, - {file = "coverage-7.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:869b5046d41abfea3e381dd143407b0d29b8282a904a19cb908fa24d090cc018"}, - {file = "coverage-7.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b8ffb498a83d7e0305968289441914154fb0ef5d8b3157df02a90c6695978295"}, - {file = "coverage-7.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3cacfaefe6089d477264001f90f55b7881ba615953414999c46cc9713ff93c8c"}, - {file = "coverage-7.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d6850e6e36e332d5511a48a251790ddc545e16e8beaf046c03985c69ccb2676"}, - {file = "coverage-7.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:18e961aa13b6d47f758cc5879383d27b5b3f3dcd9ce8cdbfdc2571fe86feb4dd"}, - {file = "coverage-7.4.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dfd1e1b9f0898817babf840b77ce9fe655ecbe8b1b327983df485b30df8cc011"}, - {file = "coverage-7.4.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:6b00e21f86598b6330f0019b40fb397e705135040dbedc2ca9a93c7441178e74"}, - {file = "coverage-7.4.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:536d609c6963c50055bab766d9951b6c394759190d03311f3e9fcf194ca909e1"}, - {file = "coverage-7.4.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7ac8f8eb153724f84885a1374999b7e45734bf93a87d8df1e7ce2146860edef6"}, - {file = "coverage-7.4.1-cp311-cp311-win32.whl", hash = "sha256:f3771b23bb3675a06f5d885c3630b1d01ea6cac9e84a01aaf5508706dba546c5"}, - {file = "coverage-7.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:9d2f9d4cc2a53b38cabc2d6d80f7f9b7e3da26b2f53d48f05876fef7956b6968"}, - {file = "coverage-7.4.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f68ef3660677e6624c8cace943e4765545f8191313a07288a53d3da188bd8581"}, - {file = "coverage-7.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23b27b8a698e749b61809fb637eb98ebf0e505710ec46a8aa6f1be7dc0dc43a6"}, - {file = "coverage-7.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e3424c554391dc9ef4a92ad28665756566a28fecf47308f91841f6c49288e66"}, - {file = "coverage-7.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e0860a348bf7004c812c8368d1fc7f77fe8e4c095d661a579196a9533778e156"}, - {file = "coverage-7.4.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fe558371c1bdf3b8fa03e097c523fb9645b8730399c14fe7721ee9c9e2a545d3"}, - {file = "coverage-7.4.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3468cc8720402af37b6c6e7e2a9cdb9f6c16c728638a2ebc768ba1ef6f26c3a1"}, - {file = "coverage-7.4.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:02f2edb575d62172aa28fe00efe821ae31f25dc3d589055b3fb64d51e52e4ab1"}, - {file = "coverage-7.4.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:ca6e61dc52f601d1d224526360cdeab0d0712ec104a2ce6cc5ccef6ed9a233bc"}, - {file = "coverage-7.4.1-cp312-cp312-win32.whl", hash = "sha256:ca7b26a5e456a843b9b6683eada193fc1f65c761b3a473941efe5a291f604c74"}, - {file = "coverage-7.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:85ccc5fa54c2ed64bd91ed3b4a627b9cce04646a659512a051fa82a92c04a448"}, - {file = "coverage-7.4.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:8bdb0285a0202888d19ec6b6d23d5990410decb932b709f2b0dfe216d031d218"}, - {file = "coverage-7.4.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:918440dea04521f499721c039863ef95433314b1db00ff826a02580c1f503e45"}, - {file = "coverage-7.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:379d4c7abad5afbe9d88cc31ea8ca262296480a86af945b08214eb1a556a3e4d"}, - {file = "coverage-7.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b094116f0b6155e36a304ff912f89bbb5067157aff5f94060ff20bbabdc8da06"}, - {file = "coverage-7.4.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2f5968608b1fe2a1d00d01ad1017ee27efd99b3437e08b83ded9b7af3f6f766"}, - {file = "coverage-7.4.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:10e88e7f41e6197ea0429ae18f21ff521d4f4490aa33048f6c6f94c6045a6a75"}, - {file = "coverage-7.4.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a4a3907011d39dbc3e37bdc5df0a8c93853c369039b59efa33a7b6669de04c60"}, - {file = "coverage-7.4.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:6d224f0c4c9c98290a6990259073f496fcec1b5cc613eecbd22786d398ded3ad"}, - {file = "coverage-7.4.1-cp38-cp38-win32.whl", hash = "sha256:23f5881362dcb0e1a92b84b3c2809bdc90db892332daab81ad8f642d8ed55042"}, - {file = "coverage-7.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:a07f61fc452c43cd5328b392e52555f7d1952400a1ad09086c4a8addccbd138d"}, - {file = "coverage-7.4.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8e738a492b6221f8dcf281b67129510835461132b03024830ac0e554311a5c54"}, - {file = "coverage-7.4.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:46342fed0fff72efcda77040b14728049200cbba1279e0bf1188f1f2078c1d70"}, - {file = "coverage-7.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9641e21670c68c7e57d2053ddf6c443e4f0a6e18e547e86af3fad0795414a628"}, - {file = "coverage-7.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aeb2c2688ed93b027eb0d26aa188ada34acb22dceea256d76390eea135083950"}, - {file = "coverage-7.4.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d12c923757de24e4e2110cf8832d83a886a4cf215c6e61ed506006872b43a6d1"}, - {file = "coverage-7.4.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0491275c3b9971cdbd28a4595c2cb5838f08036bca31765bad5e17edf900b2c7"}, - {file = "coverage-7.4.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:8dfc5e195bbef80aabd81596ef52a1277ee7143fe419efc3c4d8ba2754671756"}, - {file = "coverage-7.4.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:1a78b656a4d12b0490ca72651fe4d9f5e07e3c6461063a9b6265ee45eb2bdd35"}, - {file = "coverage-7.4.1-cp39-cp39-win32.whl", hash = "sha256:f90515974b39f4dea2f27c0959688621b46d96d5a626cf9c53dbc653a895c05c"}, - {file = "coverage-7.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:64e723ca82a84053dd7bfcc986bdb34af8d9da83c521c19d6b472bc6880e191a"}, - {file = "coverage-7.4.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:32a8d985462e37cfdab611a6f95b09d7c091d07668fdc26e47a725ee575fe166"}, - {file = "coverage-7.4.1.tar.gz", hash = "sha256:1ed4b95480952b1a26d863e546fa5094564aa0065e1e5f0d4d0041f293251d04"}, + {file = "coverage-7.4.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:bf54c3e089179d9d23900e3efc86d46e4431188d9a657f345410eecdd0151f50"}, + {file = "coverage-7.4.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fe6e43c8b510719b48af7db9631b5fbac910ade4bd90e6378c85ac5ac706382c"}, + {file = "coverage-7.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b98c89db1b150d851a7840142d60d01d07677a18f0f46836e691c38134ed18b"}, + {file = "coverage-7.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c5f9683be6a5b19cd776ee4e2f2ffb411424819c69afab6b2db3a0a364ec6642"}, + {file = "coverage-7.4.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78cdcbf7b9cb83fe047ee09298e25b1cd1636824067166dc97ad0543b079d22f"}, + {file = "coverage-7.4.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:2599972b21911111114100d362aea9e70a88b258400672626efa2b9e2179609c"}, + {file = "coverage-7.4.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:ef00d31b7569ed3cb2036f26565f1984b9fc08541731ce01012b02a4c238bf03"}, + {file = "coverage-7.4.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:20a875bfd8c282985c4720c32aa05056f77a68e6d8bbc5fe8632c5860ee0b49b"}, + {file = "coverage-7.4.2-cp310-cp310-win32.whl", hash = "sha256:b3f2b1eb229f23c82898eedfc3296137cf1f16bb145ceab3edfd17cbde273fb7"}, + {file = "coverage-7.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:7df95fdd1432a5d2675ce630fef5f239939e2b3610fe2f2b5bf21fa505256fa3"}, + {file = "coverage-7.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a8ddbd158e069dded57738ea69b9744525181e99974c899b39f75b2b29a624e2"}, + {file = "coverage-7.4.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:81a5fb41b0d24447a47543b749adc34d45a2cf77b48ca74e5bf3de60a7bd9edc"}, + {file = "coverage-7.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2412e98e70f16243be41d20836abd5f3f32edef07cbf8f407f1b6e1ceae783ac"}, + {file = "coverage-7.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ddb79414c15c6f03f56cc68fa06994f047cf20207c31b5dad3f6bab54a0f66ef"}, + {file = "coverage-7.4.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cf89ab85027427d351f1de918aff4b43f4eb5f33aff6835ed30322a86ac29c9e"}, + {file = "coverage-7.4.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a178b7b1ac0f1530bb28d2e51f88c0bab3e5949835851a60dda80bff6052510c"}, + {file = "coverage-7.4.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:06fe398145a2e91edaf1ab4eee66149c6776c6b25b136f4a86fcbbb09512fd10"}, + {file = "coverage-7.4.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:18cac867950943fe93d6cd56a67eb7dcd2d4a781a40f4c1e25d6f1ed98721a55"}, + {file = "coverage-7.4.2-cp311-cp311-win32.whl", hash = "sha256:f72cdd2586f9a769570d4b5714a3837b3a59a53b096bb954f1811f6a0afad305"}, + {file = "coverage-7.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:d779a48fac416387dd5673fc5b2d6bd903ed903faaa3247dc1865c65eaa5a93e"}, + {file = "coverage-7.4.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:adbdfcda2469d188d79771d5696dc54fab98a16d2ef7e0875013b5f56a251047"}, + {file = "coverage-7.4.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ac4bab32f396b03ebecfcf2971668da9275b3bb5f81b3b6ba96622f4ef3f6e17"}, + {file = "coverage-7.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:006d220ba2e1a45f1de083d5022d4955abb0aedd78904cd5a779b955b019ec73"}, + {file = "coverage-7.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3733545eb294e5ad274abe131d1e7e7de4ba17a144505c12feca48803fea5f64"}, + {file = "coverage-7.4.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42a9e754aa250fe61f0f99986399cec086d7e7a01dd82fd863a20af34cbce962"}, + {file = "coverage-7.4.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2ed37e16cf35c8d6e0b430254574b8edd242a367a1b1531bd1adc99c6a5e00fe"}, + {file = "coverage-7.4.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:b953275d4edfab6cc0ed7139fa773dfb89e81fee1569a932f6020ce7c6da0e8f"}, + {file = "coverage-7.4.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:32b4ab7e6c924f945cbae5392832e93e4ceb81483fd6dc4aa8fb1a97b9d3e0e1"}, + {file = "coverage-7.4.2-cp312-cp312-win32.whl", hash = "sha256:f5df76c58977bc35a49515b2fbba84a1d952ff0ec784a4070334dfbec28a2def"}, + {file = "coverage-7.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:34423abbaad70fea9d0164add189eabaea679068ebdf693baa5c02d03e7db244"}, + {file = "coverage-7.4.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:5b11f9c6587668e495cc7365f85c93bed34c3a81f9f08b0920b87a89acc13469"}, + {file = "coverage-7.4.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:51593a1f05c39332f623d64d910445fdec3d2ac2d96b37ce7f331882d5678ddf"}, + {file = "coverage-7.4.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69f1665165ba2fe7614e2f0c1aed71e14d83510bf67e2ee13df467d1c08bf1e8"}, + {file = "coverage-7.4.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3c8bbb95a699c80a167478478efe5e09ad31680931ec280bf2087905e3b95ec"}, + {file = "coverage-7.4.2-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:175f56572f25e1e1201d2b3e07b71ca4d201bf0b9cb8fad3f1dfae6a4188de86"}, + {file = "coverage-7.4.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:8562ca91e8c40864942615b1d0b12289d3e745e6b2da901d133f52f2d510a1e3"}, + {file = "coverage-7.4.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:d9a1ef0f173e1a19738f154fb3644f90d0ada56fe6c9b422f992b04266c55d5a"}, + {file = "coverage-7.4.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:f40ac873045db4fd98a6f40387d242bde2708a3f8167bd967ccd43ad46394ba2"}, + {file = "coverage-7.4.2-cp38-cp38-win32.whl", hash = "sha256:d1b750a8409bec61caa7824bfd64a8074b6d2d420433f64c161a8335796c7c6b"}, + {file = "coverage-7.4.2-cp38-cp38-win_amd64.whl", hash = "sha256:b4ae777bebaed89e3a7e80c4a03fac434a98a8abb5251b2a957d38fe3fd30088"}, + {file = "coverage-7.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3ff7f92ae5a456101ca8f48387fd3c56eb96353588e686286f50633a611afc95"}, + {file = "coverage-7.4.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:861d75402269ffda0b33af94694b8e0703563116b04c681b1832903fac8fd647"}, + {file = "coverage-7.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3507427d83fa961cbd73f11140f4a5ce84208d31756f7238d6257b2d3d868405"}, + {file = "coverage-7.4.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bf711d517e21fb5bc429f5c4308fbc430a8585ff2a43e88540264ae87871e36a"}, + {file = "coverage-7.4.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c00e54f0bd258ab25e7f731ca1d5144b0bf7bec0051abccd2bdcff65fa3262c9"}, + {file = "coverage-7.4.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:f8e845d894e39fb53834da826078f6dc1a933b32b1478cf437007367efaf6f6a"}, + {file = "coverage-7.4.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:840456cb1067dc350af9080298c7c2cfdddcedc1cb1e0b30dceecdaf7be1a2d3"}, + {file = "coverage-7.4.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c11ca2df2206a4e3e4c4567f52594637392ed05d7c7fb73b4ea1c658ba560265"}, + {file = "coverage-7.4.2-cp39-cp39-win32.whl", hash = "sha256:3ff5bdb08d8938d336ce4088ca1a1e4b6c8cd3bef8bb3a4c0eb2f37406e49643"}, + {file = "coverage-7.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:ac9e95cefcf044c98d4e2c829cd0669918585755dd9a92e28a1a7012322d0a95"}, + {file = "coverage-7.4.2-pp38.pp39.pp310-none-any.whl", hash = "sha256:f593a4a90118d99014517c2679e04a4ef5aee2d81aa05c26c734d271065efcb6"}, + {file = "coverage-7.4.2.tar.gz", hash = "sha256:1a5ee18e3a8d766075ce9314ed1cb695414bae67df6a4b0805f5137d93d6f1cb"}, ] [package.extras] toml = ["tomli"] +[[package]] +name = "crashtest" +version = "0.4.1" +description = "Manage Python errors with ease" +optional = false +python-versions = ">=3.7,<4.0" +files = [ + {file = "crashtest-0.4.1-py3-none-any.whl", hash = "sha256:8d23eac5fa660409f57472e3851dab7ac18aba459a8d19cbbba86d3d5aecd2a5"}, + {file = "crashtest-0.4.1.tar.gz", hash = "sha256:80d7b1f316ebfbd429f648076d6275c877ba30ba48979de4191714a75266f0ce"}, +] + +[[package]] +name = "cryptography" +version = "42.0.4" +description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers." +optional = false +python-versions = ">=3.7" +files = [ + {file = "cryptography-42.0.4-cp37-abi3-macosx_10_12_universal2.whl", hash = "sha256:ffc73996c4fca3d2b6c1c8c12bfd3ad00def8621da24f547626bf06441400449"}, + {file = "cryptography-42.0.4-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:db4b65b02f59035037fde0998974d84244a64c3265bdef32a827ab9b63d61b18"}, + {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad9c385ba8ee025bb0d856714f71d7840020fe176ae0229de618f14dae7a6e2"}, + {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69b22ab6506a3fe483d67d1ed878e1602bdd5912a134e6202c1ec672233241c1"}, + {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:e09469a2cec88fb7b078e16d4adec594414397e8879a4341c6ace96013463d5b"}, + {file = "cryptography-42.0.4-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:3e970a2119507d0b104f0a8e281521ad28fc26f2820687b3436b8c9a5fcf20d1"}, + {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:e53dc41cda40b248ebc40b83b31516487f7db95ab8ceac1f042626bc43a2f992"}, + {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:c3a5cbc620e1e17009f30dd34cb0d85c987afd21c41a74352d1719be33380885"}, + {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6bfadd884e7280df24d26f2186e4e07556a05d37393b0f220a840b083dc6a824"}, + {file = "cryptography-42.0.4-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:01911714117642a3f1792c7f376db572aadadbafcd8d75bb527166009c9f1d1b"}, + {file = "cryptography-42.0.4-cp37-abi3-win32.whl", hash = "sha256:fb0cef872d8193e487fc6bdb08559c3aa41b659a7d9be48b2e10747f47863925"}, + {file = "cryptography-42.0.4-cp37-abi3-win_amd64.whl", hash = "sha256:c1f25b252d2c87088abc8bbc4f1ecbf7c919e05508a7e8628e6875c40bc70923"}, + {file = "cryptography-42.0.4-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:15a1fb843c48b4a604663fa30af60818cd28f895572386e5f9b8a665874c26e7"}, + {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1327f280c824ff7885bdeef8578f74690e9079267c1c8bd7dc5cc5aa065ae52"}, + {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ffb03d419edcab93b4b19c22ee80c007fb2d708429cecebf1dd3258956a563a"}, + {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:1df6fcbf60560d2113b5ed90f072dc0b108d64750d4cbd46a21ec882c7aefce9"}, + {file = "cryptography-42.0.4-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:44a64043f743485925d3bcac548d05df0f9bb445c5fcca6681889c7c3ab12764"}, + {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:3c6048f217533d89f2f8f4f0fe3044bf0b2090453b7b73d0b77db47b80af8dff"}, + {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:6d0fbe73728c44ca3a241eff9aefe6496ab2656d6e7a4ea2459865f2e8613257"}, + {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:887623fe0d70f48ab3f5e4dbf234986b1329a64c066d719432d0698522749929"}, + {file = "cryptography-42.0.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ce8613beaffc7c14f091497346ef117c1798c202b01153a8cc7b8e2ebaaf41c0"}, + {file = "cryptography-42.0.4-cp39-abi3-win32.whl", hash = "sha256:810bcf151caefc03e51a3d61e53335cd5c7316c0a105cc695f0959f2c638b129"}, + {file = "cryptography-42.0.4-cp39-abi3-win_amd64.whl", hash = "sha256:a0298bdc6e98ca21382afe914c642620370ce0470a01e1bef6dd9b5354c36854"}, + {file = "cryptography-42.0.4-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5f8907fcf57392cd917892ae83708761c6ff3c37a8e835d7246ff0ad251d9298"}, + {file = "cryptography-42.0.4-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:12d341bd42cdb7d4937b0cabbdf2a94f949413ac4504904d0cdbdce4a22cbf88"}, + {file = "cryptography-42.0.4-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1cdcdbd117681c88d717437ada72bdd5be9de117f96e3f4d50dab3f59fd9ab20"}, + {file = "cryptography-42.0.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0e89f7b84f421c56e7ff69f11c441ebda73b8a8e6488d322ef71746224c20fce"}, + {file = "cryptography-42.0.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f1e85a178384bf19e36779d91ff35c7617c885da487d689b05c1366f9933ad74"}, + {file = "cryptography-42.0.4-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:d2a27aca5597c8a71abbe10209184e1a8e91c1fd470b5070a2ea60cafec35bcd"}, + {file = "cryptography-42.0.4-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4e36685cb634af55e0677d435d425043967ac2f3790ec652b2b88ad03b85c27b"}, + {file = "cryptography-42.0.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:f47be41843200f7faec0683ad751e5ef11b9a56a220d57f300376cd8aba81660"}, + {file = "cryptography-42.0.4.tar.gz", hash = "sha256:831a4b37accef30cccd34fcb916a5d7b5be3cbbe27268a02832c3e450aea39cb"}, +] + +[package.dependencies] +cffi = {version = ">=1.12", markers = "platform_python_implementation != \"PyPy\""} + +[package.extras] +docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=1.1.1)"] +docstest = ["pyenchant (>=1.6.11)", "readme-renderer", "sphinxcontrib-spelling (>=4.0.1)"] +nox = ["nox"] +pep8test = ["check-sdist", "click", "mypy", "ruff"] +sdist = ["build"] +ssh = ["bcrypt (>=3.1.5)"] +test = ["certifi", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] +test-randomorder = ["pytest-randomly"] + [[package]] name = "decorator" version = "5.1.1" @@ -228,6 +478,104 @@ files = [ {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, ] +[[package]] +name = "distlib" +version = "0.3.8" +description = "Distribution utilities" +optional = false +python-versions = "*" +files = [ + {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"}, + {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"}, +] + +[[package]] +name = "dulwich" +version = "0.21.7" +description = "Python Git Library" +optional = false +python-versions = ">=3.7" +files = [ + {file = "dulwich-0.21.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d4c0110798099bb7d36a110090f2688050703065448895c4f53ade808d889dd3"}, + {file = "dulwich-0.21.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2bc12697f0918bee324c18836053644035362bb3983dc1b210318f2fed1d7132"}, + {file = "dulwich-0.21.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:471305af74790827fcbafe330fc2e8bdcee4fb56ca1177c8c481b1c8f806c4a4"}, + {file = "dulwich-0.21.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d54c9d0e845be26f65f954dff13a1cd3f2b9739820c19064257b8fd7435ab263"}, + {file = "dulwich-0.21.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:12d61334a575474e707614f2e93d6ed4cdae9eb47214f9277076d9e5615171d3"}, + {file = "dulwich-0.21.7-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e274cebaf345f0b1e3b70197f2651de92b652386b68020cfd3bf61bc30f6eaaa"}, + {file = "dulwich-0.21.7-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:817822f970e196e757ae01281ecbf21369383285b9f4a83496312204cf889b8c"}, + {file = "dulwich-0.21.7-cp310-cp310-win32.whl", hash = "sha256:7836da3f4110ce684dcd53489015fb7fa94ed33c5276e3318b8b1cbcb5b71e08"}, + {file = "dulwich-0.21.7-cp310-cp310-win_amd64.whl", hash = "sha256:4a043b90958cec866b4edc6aef5fe3c2c96a664d0b357e1682a46f6c477273c4"}, + {file = "dulwich-0.21.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:ce8db196e79c1f381469410d26fb1d8b89c6b87a4e7f00ff418c22a35121405c"}, + {file = "dulwich-0.21.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:62bfb26bdce869cd40be443dfd93143caea7089b165d2dcc33de40f6ac9d812a"}, + {file = "dulwich-0.21.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c01a735b9a171dcb634a97a3cec1b174cfbfa8e840156870384b633da0460f18"}, + {file = "dulwich-0.21.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fa4d14767cf7a49c9231c2e52cb2a3e90d0c83f843eb6a2ca2b5d81d254cf6b9"}, + {file = "dulwich-0.21.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7bca4b86e96d6ef18c5bc39828ea349efb5be2f9b1f6ac9863f90589bac1084d"}, + {file = "dulwich-0.21.7-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a7b5624b02ef808cdc62dabd47eb10cd4ac15e8ac6df9e2e88b6ac6b40133673"}, + {file = "dulwich-0.21.7-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c3a539b4696a42fbdb7412cb7b66a4d4d332761299d3613d90a642923c7560e1"}, + {file = "dulwich-0.21.7-cp311-cp311-win32.whl", hash = "sha256:675a612ce913081beb0f37b286891e795d905691dfccfb9bf73721dca6757cde"}, + {file = "dulwich-0.21.7-cp311-cp311-win_amd64.whl", hash = "sha256:460ba74bdb19f8d498786ae7776745875059b1178066208c0fd509792d7f7bfc"}, + {file = "dulwich-0.21.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4c51058ec4c0b45dc5189225b9e0c671b96ca9713c1daf71d622c13b0ab07681"}, + {file = "dulwich-0.21.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:4bc4c5366eaf26dda3fdffe160a3b515666ed27c2419f1d483da285ac1411de0"}, + {file = "dulwich-0.21.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a0650ec77d89cb947e3e4bbd4841c96f74e52b4650830112c3057a8ca891dc2f"}, + {file = "dulwich-0.21.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f18f0a311fb7734b033a3101292b932158cade54b74d1c44db519e42825e5a2"}, + {file = "dulwich-0.21.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c589468e5c0cd84e97eb7ec209ab005a2cb69399e8c5861c3edfe38989ac3a8"}, + {file = "dulwich-0.21.7-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d62446797163317a397a10080c6397ffaaca51a7804c0120b334f8165736c56a"}, + {file = "dulwich-0.21.7-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e84cc606b1f581733df4350ca4070e6a8b30be3662bbb81a590b177d0c996c91"}, + {file = "dulwich-0.21.7-cp312-cp312-win32.whl", hash = "sha256:c3d1685f320907a52c40fd5890627945c51f3a5fa4bcfe10edb24fec79caadec"}, + {file = "dulwich-0.21.7-cp312-cp312-win_amd64.whl", hash = "sha256:6bd69921fdd813b7469a3c77bc75c1783cc1d8d72ab15a406598e5a3ba1a1503"}, + {file = "dulwich-0.21.7-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:7d8ab29c660125db52106775caa1f8f7f77a69ed1fe8bc4b42bdf115731a25bf"}, + {file = "dulwich-0.21.7-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0d2e4485b98695bf95350ce9d38b1bb0aaac2c34ad00a0df789aa33c934469b"}, + {file = "dulwich-0.21.7-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e138d516baa6b5bafbe8f030eccc544d0d486d6819b82387fc0e285e62ef5261"}, + {file = "dulwich-0.21.7-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:f34bf9b9fa9308376263fd9ac43143c7c09da9bc75037bb75c6c2423a151b92c"}, + {file = "dulwich-0.21.7-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:2e2c66888207b71cd1daa2acb06d3984a6bc13787b837397a64117aa9fc5936a"}, + {file = "dulwich-0.21.7-cp37-cp37m-win32.whl", hash = "sha256:10893105c6566fc95bc2a67b61df7cc1e8f9126d02a1df6a8b2b82eb59db8ab9"}, + {file = "dulwich-0.21.7-cp37-cp37m-win_amd64.whl", hash = "sha256:460b3849d5c3d3818a80743b4f7a0094c893c559f678e56a02fff570b49a644a"}, + {file = "dulwich-0.21.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:74700e4c7d532877355743336c36f51b414d01e92ba7d304c4f8d9a5946dbc81"}, + {file = "dulwich-0.21.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:c92e72c43c9e9e936b01a57167e0ea77d3fd2d82416edf9489faa87278a1cdf7"}, + {file = "dulwich-0.21.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d097e963eb6b9fa53266146471531ad9c6765bf390849230311514546ed64db2"}, + {file = "dulwich-0.21.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:808e8b9cc0aa9ac74870b49db4f9f39a52fb61694573f84b9c0613c928d4caf8"}, + {file = "dulwich-0.21.7-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1957b65f96e36c301e419d7adaadcff47647c30eb072468901bb683b1000bc5"}, + {file = "dulwich-0.21.7-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:4b09bc3a64fb70132ec14326ecbe6e0555381108caff3496898962c4136a48c6"}, + {file = "dulwich-0.21.7-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d5882e70b74ac3c736a42d3fdd4f5f2e6570637f59ad5d3e684760290b58f041"}, + {file = "dulwich-0.21.7-cp38-cp38-win32.whl", hash = "sha256:29bb5c1d70eba155ded41ed8a62be2f72edbb3c77b08f65b89c03976292f6d1b"}, + {file = "dulwich-0.21.7-cp38-cp38-win_amd64.whl", hash = "sha256:25c3ab8fb2e201ad2031ddd32e4c68b7c03cb34b24a5ff477b7a7dcef86372f5"}, + {file = "dulwich-0.21.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:8929c37986c83deb4eb500c766ee28b6670285b512402647ee02a857320e377c"}, + {file = "dulwich-0.21.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:cc1e11be527ac06316539b57a7688bcb1b6a3e53933bc2f844397bc50734e9ae"}, + {file = "dulwich-0.21.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0fc3078a1ba04c588fabb0969d3530efd5cd1ce2cf248eefb6baf7cbc15fc285"}, + {file = "dulwich-0.21.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40dcbd29ba30ba2c5bfbab07a61a5f20095541d5ac66d813056c122244df4ac0"}, + {file = "dulwich-0.21.7-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8869fc8ec3dda743e03d06d698ad489b3705775fe62825e00fa95aa158097fc0"}, + {file = "dulwich-0.21.7-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d96ca5e0dde49376fbcb44f10eddb6c30284a87bd03bb577c59bb0a1f63903fa"}, + {file = "dulwich-0.21.7-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:e0064363bd5e814359657ae32517fa8001e8573d9d040bd997908d488ab886ed"}, + {file = "dulwich-0.21.7-cp39-cp39-win32.whl", hash = "sha256:869eb7be48243e695673b07905d18b73d1054a85e1f6e298fe63ba2843bb2ca1"}, + {file = "dulwich-0.21.7-cp39-cp39-win_amd64.whl", hash = "sha256:404b8edeb3c3a86c47c0a498699fc064c93fa1f8bab2ffe919e8ab03eafaaad3"}, + {file = "dulwich-0.21.7-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:e598d743c6c0548ebcd2baf94aa9c8bfacb787ea671eeeb5828cfbd7d56b552f"}, + {file = "dulwich-0.21.7-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4a2d76c96426e791556836ef43542b639def81be4f1d6d4322cd886c115eae1"}, + {file = "dulwich-0.21.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6c88acb60a1f4d31bd6d13bfba465853b3df940ee4a0f2a3d6c7a0778c705b7"}, + {file = "dulwich-0.21.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ecd315847dea406a4decfa39d388a2521e4e31acde3bd9c2609c989e817c6d62"}, + {file = "dulwich-0.21.7-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:d05d3c781bc74e2c2a2a8f4e4e2ed693540fbe88e6ac36df81deac574a6dad99"}, + {file = "dulwich-0.21.7-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6de6f8de4a453fdbae8062a6faa652255d22a3d8bce0cd6d2d6701305c75f2b3"}, + {file = "dulwich-0.21.7-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e25953c7acbbe4e19650d0225af1c0c0e6882f8bddd2056f75c1cc2b109b88ad"}, + {file = "dulwich-0.21.7-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:4637cbd8ed1012f67e1068aaed19fcc8b649bcf3e9e26649826a303298c89b9d"}, + {file = "dulwich-0.21.7-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:858842b30ad6486aacaa607d60bab9c9a29e7c59dc2d9cb77ae5a94053878c08"}, + {file = "dulwich-0.21.7-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:739b191f61e1c4ce18ac7d520e7a7cbda00e182c3489552408237200ce8411ad"}, + {file = "dulwich-0.21.7-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:274c18ec3599a92a9b67abaf110e4f181a4f779ee1aaab9e23a72e89d71b2bd9"}, + {file = "dulwich-0.21.7-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:2590e9b431efa94fc356ae33b38f5e64f1834ec3a94a6ac3a64283b206d07aa3"}, + {file = "dulwich-0.21.7-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:ed60d1f610ef6437586f7768254c2a93820ccbd4cfdac7d182cf2d6e615969bb"}, + {file = "dulwich-0.21.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8278835e168dd097089f9e53088c7a69c6ca0841aef580d9603eafe9aea8c358"}, + {file = "dulwich-0.21.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ffc27fb063f740712e02b4d2f826aee8bbed737ed799962fef625e2ce56e2d29"}, + {file = "dulwich-0.21.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:61e3451bd3d3844f2dca53f131982553be4d1b1e1ebd9db701843dd76c4dba31"}, + {file = "dulwich-0.21.7.tar.gz", hash = "sha256:a9e9c66833cea580c3ac12927e4b9711985d76afca98da971405d414de60e968"}, +] + +[package.dependencies] +urllib3 = ">=1.25" + +[package.extras] +fastimport = ["fastimport"] +https = ["urllib3 (>=1.24.1)"] +paramiko = ["paramiko"] +pgp = ["gpg"] + [[package]] name = "execnet" version = "2.0.2" @@ -256,6 +604,87 @@ files = [ [package.extras] tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich"] +[[package]] +name = "fastjsonschema" +version = "2.19.1" +description = "Fastest Python implementation of JSON schema" +optional = false +python-versions = "*" +files = [ + {file = "fastjsonschema-2.19.1-py3-none-any.whl", hash = "sha256:3672b47bc94178c9f23dbb654bf47440155d4db9df5f7bc47643315f9c405cd0"}, + {file = "fastjsonschema-2.19.1.tar.gz", hash = "sha256:e3126a94bdc4623d3de4485f8d468a12f02a67921315ddc87836d6e456dc789d"}, +] + +[package.extras] +devel = ["colorama", "json-spec", "jsonschema", "pylint", "pytest", "pytest-benchmark", "pytest-cache", "validictory"] + +[[package]] +name = "filelock" +version = "3.13.1" +description = "A platform independent file lock." +optional = false +python-versions = ">=3.8" +files = [ + {file = "filelock-3.13.1-py3-none-any.whl", hash = "sha256:57dbda9b35157b05fb3e58ee91448612eb674172fab98ee235ccb0b5bee19a1c"}, + {file = "filelock-3.13.1.tar.gz", hash = "sha256:521f5f56c50f8426f5e03ad3b281b490a87ef15bc6c526f168290f0c7148d44e"}, +] + +[package.extras] +docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.24)"] +testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)"] +typing = ["typing-extensions (>=4.8)"] + +[[package]] +name = "hypothesis" +version = "6.98.9" +description = "A library for property-based testing" +optional = false +python-versions = ">=3.8" +files = [ + {file = "hypothesis-6.98.9-py3-none-any.whl", hash = "sha256:b161d8b7c92ce065ae6e6b9fc644ea6aeb9c7cfe027e2655e4f9ada9d50b0d62"}, + {file = "hypothesis-6.98.9.tar.gz", hash = "sha256:25a6ef40512893618118ba6b6d18d13611ba756e07fa1f0bdd78c64baa6ec874"}, +] + +[package.dependencies] +attrs = ">=22.2.0" +black = {version = ">=19.10b0", optional = true, markers = "extra == \"cli\""} +click = {version = ">=7.0", optional = true, markers = "extra == \"cli\""} +rich = {version = ">=9.0.0", optional = true, markers = "extra == \"cli\""} +sortedcontainers = ">=2.1.0,<3.0.0" + +[package.extras] +all = ["backports.zoneinfo (>=0.2.1)", "black (>=19.10b0)", "click (>=7.0)", "django (>=3.2)", "dpcontracts (>=0.4)", "lark (>=0.10.1)", "libcst (>=0.3.16)", "numpy (>=1.17.3)", "pandas (>=1.1)", "pytest (>=4.6)", "python-dateutil (>=1.4)", "pytz (>=2014.1)", "redis (>=3.0.0)", "rich (>=9.0.0)", "tzdata (>=2024.1)"] +cli = ["black (>=19.10b0)", "click (>=7.0)", "rich (>=9.0.0)"] +codemods = ["libcst (>=0.3.16)"] +dateutil = ["python-dateutil (>=1.4)"] +django = ["django (>=3.2)"] +dpcontracts = ["dpcontracts (>=0.4)"] +ghostwriter = ["black (>=19.10b0)"] +lark = ["lark (>=0.10.1)"] +numpy = ["numpy (>=1.17.3)"] +pandas = ["pandas (>=1.1)"] +pytest = ["pytest (>=4.6)"] +pytz = ["pytz (>=2014.1)"] +redis = ["redis (>=3.0.0)"] +zoneinfo = ["backports.zoneinfo (>=0.2.1)", "tzdata (>=2024.1)"] + +[[package]] +name = "icecream" +version = "2.1.3" +description = "Never use print() to debug again; inspect variables, expressions, and program execution with a single, simple function call." +optional = false +python-versions = "*" +files = [ + {file = "icecream-2.1.3-py2.py3-none-any.whl", hash = "sha256:757aec31ad4488b949bc4f499d18e6e5973c40cc4d4fc607229e78cfaec94c34"}, + {file = "icecream-2.1.3.tar.gz", hash = "sha256:0aa4a7c3374ec36153a1d08f81e3080e83d8ac1eefd97d2f4fe9544e8f9b49de"}, +] + +[package.dependencies] +asttokens = ">=2.0.1" +colorama = ">=0.3.9" +executing = ">=0.3.1" +pygments = ">=2.2.0" + [[package]] name = "idna" version = "3.6" @@ -267,6 +696,25 @@ files = [ {file = "idna-3.6.tar.gz", hash = "sha256:9ecdbbd083b06798ae1e86adcbfe8ab1479cf864e4ee30fe4e46a003d12491ca"}, ] +[[package]] +name = "importlib-metadata" +version = "7.0.1" +description = "Read metadata from Python packages" +optional = false +python-versions = ">=3.8" +files = [ + {file = "importlib_metadata-7.0.1-py3-none-any.whl", hash = "sha256:4805911c3a4ec7c3966410053e9ec6a1fecd629117df5adee56dfc9432a1081e"}, + {file = "importlib_metadata-7.0.1.tar.gz", hash = "sha256:f238736bb06590ae52ac1fab06a3a9ef1d8dce2b7a35b5ab329371d6c8f5d2cc"}, +] + +[package.dependencies] +zipp = ">=0.5" + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] +perf = ["ipython"] +testing = ["flufl.flake8", "importlib-resources (>=1.3)", "packaging", "pyfakefs", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-perf (>=0.9.2)", "pytest-ruff"] + [[package]] name = "iniconfig" version = "2.0.0" @@ -278,6 +726,17 @@ files = [ {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"}, ] +[[package]] +name = "installer" +version = "0.7.0" +description = "A library for installing Python wheels." +optional = false +python-versions = ">=3.7" +files = [ + {file = "installer-0.7.0-py3-none-any.whl", hash = "sha256:05d1933f0a5ba7d8d6296bb6d5018e7c94fa473ceb10cf198a92ccea19c27b53"}, + {file = "installer-0.7.0.tar.gz", hash = "sha256:a26d3e3116289bb08216e0d0f7d925fcef0b0194eedfa0c944bcaaa106c4b631"}, +] + [[package]] name = "ipython" version = "8.21.0" @@ -313,6 +772,24 @@ qtconsole = ["qtconsole"] test = ["pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "testpath"] test-extra = ["curio", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "pickleshare", "pytest (<8)", "pytest-asyncio (<0.22)", "testpath", "trio"] +[[package]] +name = "jaraco-classes" +version = "3.3.1" +description = "Utility functions for Python class constructs" +optional = false +python-versions = ">=3.8" +files = [ + {file = "jaraco.classes-3.3.1-py3-none-any.whl", hash = "sha256:86b534de565381f6b3c1c830d13f931d7be1a75f0081c57dff615578676e2206"}, + {file = "jaraco.classes-3.3.1.tar.gz", hash = "sha256:cb28a5ebda8bc47d8c8015307d93163464f9f2b91ab4006e09ff0ce07e8bfb30"}, +] + +[package.dependencies] +more-itertools = "*" + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy", "pytest-ruff (>=0.2.1)"] + [[package]] name = "jedi" version = "0.19.1" @@ -332,6 +809,68 @@ docs = ["Jinja2 (==2.11.3)", "MarkupSafe (==1.1.1)", "Pygments (==2.8.1)", "alab qa = ["flake8 (==5.0.4)", "mypy (==0.971)", "types-setuptools (==67.2.0.1)"] testing = ["Django", "attrs", "colorama", "docopt", "pytest (<7.0.0)"] +[[package]] +name = "jeepney" +version = "0.8.0" +description = "Low-level, pure Python DBus protocol wrapper." +optional = false +python-versions = ">=3.7" +files = [ + {file = "jeepney-0.8.0-py3-none-any.whl", hash = "sha256:c0a454ad016ca575060802ee4d590dd912e35c122fa04e70306de3d076cce755"}, + {file = "jeepney-0.8.0.tar.gz", hash = "sha256:5efe48d255973902f6badc3ce55e2aa6c5c3b3bc642059ef3a91247bcfcc5806"}, +] + +[package.extras] +test = ["async-timeout", "pytest", "pytest-asyncio (>=0.17)", "pytest-trio", "testpath", "trio"] +trio = ["async_generator", "trio"] + +[[package]] +name = "keyring" +version = "24.3.0" +description = "Store and access your passwords safely." +optional = false +python-versions = ">=3.8" +files = [ + {file = "keyring-24.3.0-py3-none-any.whl", hash = "sha256:4446d35d636e6a10b8bce7caa66913dd9eca5fd222ca03a3d42c38608ac30836"}, + {file = "keyring-24.3.0.tar.gz", hash = "sha256:e730ecffd309658a08ee82535a3b5ec4b4c8669a9be11efb66249d8e0aeb9a25"}, +] + +[package.dependencies] +importlib-metadata = {version = ">=4.11.4", markers = "python_version < \"3.12\""} +"jaraco.classes" = "*" +jeepney = {version = ">=0.4.2", markers = "sys_platform == \"linux\""} +pywin32-ctypes = {version = ">=0.2.0", markers = "sys_platform == \"win32\""} +SecretStorage = {version = ">=3.2", markers = "sys_platform == \"linux\""} + +[package.extras] +completion = ["shtab (>=1.1.0)"] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-mypy (>=0.9.1)", "pytest-ruff"] + +[[package]] +name = "markdown-it-py" +version = "3.0.0" +description = "Python port of markdown-it. Markdown parsing, done right!" +optional = false +python-versions = ">=3.8" +files = [ + {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, + {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, +] + +[package.dependencies] +mdurl = ">=0.1,<1.0" + +[package.extras] +benchmarking = ["psutil", "pytest", "pytest-benchmark"] +code-style = ["pre-commit (>=3.0,<4.0)"] +compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"] +linkify = ["linkify-it-py (>=1,<3)"] +plugins = ["mdit-py-plugins"] +profiling = ["gprof2dot"] +rtd = ["jupyter_sphinx", "mdit-py-plugins", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"] +testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] + [[package]] name = "matplotlib-inline" version = "0.1.6" @@ -346,6 +885,104 @@ files = [ [package.dependencies] traitlets = "*" +[[package]] +name = "mdurl" +version = "0.1.2" +description = "Markdown URL utilities" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + +[[package]] +name = "more-itertools" +version = "10.2.0" +description = "More routines for operating on iterables, beyond itertools" +optional = false +python-versions = ">=3.8" +files = [ + {file = "more-itertools-10.2.0.tar.gz", hash = "sha256:8fccb480c43d3e99a00087634c06dd02b0d50fbf088b380de5a41a015ec239e1"}, + {file = "more_itertools-10.2.0-py3-none-any.whl", hash = "sha256:686b06abe565edfab151cb8fd385a05651e1fdf8f0a14191e4439283421f8684"}, +] + +[[package]] +name = "msgpack" +version = "1.0.7" +description = "MessagePack serializer" +optional = false +python-versions = ">=3.8" +files = [ + {file = "msgpack-1.0.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:04ad6069c86e531682f9e1e71b71c1c3937d6014a7c3e9edd2aa81ad58842862"}, + {file = "msgpack-1.0.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cca1b62fe70d761a282496b96a5e51c44c213e410a964bdffe0928e611368329"}, + {file = "msgpack-1.0.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e50ebce52f41370707f1e21a59514e3375e3edd6e1832f5e5235237db933c98b"}, + {file = "msgpack-1.0.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4a7b4f35de6a304b5533c238bee86b670b75b03d31b7797929caa7a624b5dda6"}, + {file = "msgpack-1.0.7-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28efb066cde83c479dfe5a48141a53bc7e5f13f785b92ddde336c716663039ee"}, + {file = "msgpack-1.0.7-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4cb14ce54d9b857be9591ac364cb08dc2d6a5c4318c1182cb1d02274029d590d"}, + {file = "msgpack-1.0.7-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b573a43ef7c368ba4ea06050a957c2a7550f729c31f11dd616d2ac4aba99888d"}, + {file = "msgpack-1.0.7-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:ccf9a39706b604d884d2cb1e27fe973bc55f2890c52f38df742bc1d79ab9f5e1"}, + {file = "msgpack-1.0.7-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:cb70766519500281815dfd7a87d3a178acf7ce95390544b8c90587d76b227681"}, + {file = "msgpack-1.0.7-cp310-cp310-win32.whl", hash = "sha256:b610ff0f24e9f11c9ae653c67ff8cc03c075131401b3e5ef4b82570d1728f8a9"}, + {file = "msgpack-1.0.7-cp310-cp310-win_amd64.whl", hash = "sha256:a40821a89dc373d6427e2b44b572efc36a2778d3f543299e2f24eb1a5de65415"}, + {file = "msgpack-1.0.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:576eb384292b139821c41995523654ad82d1916da6a60cff129c715a6223ea84"}, + {file = "msgpack-1.0.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:730076207cb816138cf1af7f7237b208340a2c5e749707457d70705715c93b93"}, + {file = "msgpack-1.0.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:85765fdf4b27eb5086f05ac0491090fc76f4f2b28e09d9350c31aac25a5aaff8"}, + {file = "msgpack-1.0.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3476fae43db72bd11f29a5147ae2f3cb22e2f1a91d575ef130d2bf49afd21c46"}, + {file = "msgpack-1.0.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d4c80667de2e36970ebf74f42d1088cc9ee7ef5f4e8c35eee1b40eafd33ca5b"}, + {file = "msgpack-1.0.7-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5b0bf0effb196ed76b7ad883848143427a73c355ae8e569fa538365064188b8e"}, + {file = "msgpack-1.0.7-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:f9a7c509542db4eceed3dcf21ee5267ab565a83555c9b88a8109dcecc4709002"}, + {file = "msgpack-1.0.7-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:84b0daf226913133f899ea9b30618722d45feffa67e4fe867b0b5ae83a34060c"}, + {file = "msgpack-1.0.7-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ec79ff6159dffcc30853b2ad612ed572af86c92b5168aa3fc01a67b0fa40665e"}, + {file = "msgpack-1.0.7-cp311-cp311-win32.whl", hash = "sha256:3e7bf4442b310ff154b7bb9d81eb2c016b7d597e364f97d72b1acc3817a0fdc1"}, + {file = "msgpack-1.0.7-cp311-cp311-win_amd64.whl", hash = "sha256:3f0c8c6dfa6605ab8ff0611995ee30d4f9fcff89966cf562733b4008a3d60d82"}, + {file = "msgpack-1.0.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:f0936e08e0003f66bfd97e74ee530427707297b0d0361247e9b4f59ab78ddc8b"}, + {file = "msgpack-1.0.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:98bbd754a422a0b123c66a4c341de0474cad4a5c10c164ceed6ea090f3563db4"}, + {file = "msgpack-1.0.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b291f0ee7961a597cbbcc77709374087fa2a9afe7bdb6a40dbbd9b127e79afee"}, + {file = "msgpack-1.0.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ebbbba226f0a108a7366bf4b59bf0f30a12fd5e75100c630267d94d7f0ad20e5"}, + {file = "msgpack-1.0.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e2d69948e4132813b8d1131f29f9101bc2c915f26089a6d632001a5c1349672"}, + {file = "msgpack-1.0.7-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bdf38ba2d393c7911ae989c3bbba510ebbcdf4ecbdbfec36272abe350c454075"}, + {file = "msgpack-1.0.7-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:993584fc821c58d5993521bfdcd31a4adf025c7d745bbd4d12ccfecf695af5ba"}, + {file = "msgpack-1.0.7-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:52700dc63a4676669b341ba33520f4d6e43d3ca58d422e22ba66d1736b0a6e4c"}, + {file = "msgpack-1.0.7-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e45ae4927759289c30ccba8d9fdce62bb414977ba158286b5ddaf8df2cddb5c5"}, + {file = "msgpack-1.0.7-cp312-cp312-win32.whl", hash = "sha256:27dcd6f46a21c18fa5e5deed92a43d4554e3df8d8ca5a47bf0615d6a5f39dbc9"}, + {file = "msgpack-1.0.7-cp312-cp312-win_amd64.whl", hash = "sha256:7687e22a31e976a0e7fc99c2f4d11ca45eff652a81eb8c8085e9609298916dcf"}, + {file = "msgpack-1.0.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5b6ccc0c85916998d788b295765ea0e9cb9aac7e4a8ed71d12e7d8ac31c23c95"}, + {file = "msgpack-1.0.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:235a31ec7db685f5c82233bddf9858748b89b8119bf4538d514536c485c15fe0"}, + {file = "msgpack-1.0.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cab3db8bab4b7e635c1c97270d7a4b2a90c070b33cbc00c99ef3f9be03d3e1f7"}, + {file = "msgpack-1.0.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bfdd914e55e0d2c9e1526de210f6fe8ffe9705f2b1dfcc4aecc92a4cb4b533d"}, + {file = "msgpack-1.0.7-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:36e17c4592231a7dbd2ed09027823ab295d2791b3b1efb2aee874b10548b7524"}, + {file = "msgpack-1.0.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:38949d30b11ae5f95c3c91917ee7a6b239f5ec276f271f28638dec9156f82cfc"}, + {file = "msgpack-1.0.7-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:ff1d0899f104f3921d94579a5638847f783c9b04f2d5f229392ca77fba5b82fc"}, + {file = "msgpack-1.0.7-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:dc43f1ec66eb8440567186ae2f8c447d91e0372d793dfe8c222aec857b81a8cf"}, + {file = "msgpack-1.0.7-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:dd632777ff3beaaf629f1ab4396caf7ba0bdd075d948a69460d13d44357aca4c"}, + {file = "msgpack-1.0.7-cp38-cp38-win32.whl", hash = "sha256:4e71bc4416de195d6e9b4ee93ad3f2f6b2ce11d042b4d7a7ee00bbe0358bd0c2"}, + {file = "msgpack-1.0.7-cp38-cp38-win_amd64.whl", hash = "sha256:8f5b234f567cf76ee489502ceb7165c2a5cecec081db2b37e35332b537f8157c"}, + {file = "msgpack-1.0.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:bfef2bb6ef068827bbd021017a107194956918ab43ce4d6dc945ffa13efbc25f"}, + {file = "msgpack-1.0.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:484ae3240666ad34cfa31eea7b8c6cd2f1fdaae21d73ce2974211df099a95d81"}, + {file = "msgpack-1.0.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3967e4ad1aa9da62fd53e346ed17d7b2e922cba5ab93bdd46febcac39be636fc"}, + {file = "msgpack-1.0.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8dd178c4c80706546702c59529ffc005681bd6dc2ea234c450661b205445a34d"}, + {file = "msgpack-1.0.7-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6ffbc252eb0d229aeb2f9ad051200668fc3a9aaa8994e49f0cb2ffe2b7867e7"}, + {file = "msgpack-1.0.7-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:822ea70dc4018c7e6223f13affd1c5c30c0f5c12ac1f96cd8e9949acddb48a61"}, + {file = "msgpack-1.0.7-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:384d779f0d6f1b110eae74cb0659d9aa6ff35aaf547b3955abf2ab4c901c4819"}, + {file = "msgpack-1.0.7-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f64e376cd20d3f030190e8c32e1c64582eba56ac6dc7d5b0b49a9d44021b52fd"}, + {file = "msgpack-1.0.7-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5ed82f5a7af3697b1c4786053736f24a0efd0a1b8a130d4c7bfee4b9ded0f08f"}, + {file = "msgpack-1.0.7-cp39-cp39-win32.whl", hash = "sha256:f26a07a6e877c76a88e3cecac8531908d980d3d5067ff69213653649ec0f60ad"}, + {file = "msgpack-1.0.7-cp39-cp39-win_amd64.whl", hash = "sha256:1dc93e8e4653bdb5910aed79f11e165c85732067614f180f70534f056da97db3"}, + {file = "msgpack-1.0.7.tar.gz", hash = "sha256:572efc93db7a4d27e404501975ca6d2d9775705c2d922390d878fcf768d92c87"}, +] + +[[package]] +name = "mypy-extensions" +version = "1.0.0" +description = "Type system extensions for programs checked with the mypy type checker." +optional = false +python-versions = ">=3.5" +files = [ + {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"}, + {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"}, +] + [[package]] name = "packaging" version = "23.2" @@ -372,6 +1009,17 @@ files = [ qa = ["flake8 (==3.8.3)", "mypy (==0.782)"] testing = ["docopt", "pytest (<6.0.0)"] +[[package]] +name = "pathspec" +version = "0.12.1" +description = "Utility library for gitignore style pattern matching of file paths." +optional = false +python-versions = ">=3.8" +files = [ + {file = "pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08"}, + {file = "pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712"}, +] + [[package]] name = "pexpect" version = "4.9.0" @@ -386,6 +1034,35 @@ files = [ [package.dependencies] ptyprocess = ">=0.5" +[[package]] +name = "pkginfo" +version = "1.9.6" +description = "Query metadata from sdists / bdists / installed packages." +optional = false +python-versions = ">=3.6" +files = [ + {file = "pkginfo-1.9.6-py3-none-any.whl", hash = "sha256:4b7a555a6d5a22169fcc9cf7bfd78d296b0361adad412a346c1226849af5e546"}, + {file = "pkginfo-1.9.6.tar.gz", hash = "sha256:8fd5896e8718a4372f0ea9cc9d96f6417c9b986e23a4d116dda26b62cc29d046"}, +] + +[package.extras] +testing = ["pytest", "pytest-cov"] + +[[package]] +name = "platformdirs" +version = "3.11.0" +description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"." +optional = false +python-versions = ">=3.7" +files = [ + {file = "platformdirs-3.11.0-py3-none-any.whl", hash = "sha256:e9d171d00af68be50e9202731309c4e658fd8bc76f55c11c7dd760d023bda68e"}, + {file = "platformdirs-3.11.0.tar.gz", hash = "sha256:cf8ee52a3afdb965072dcc652433e0c7e3e40cf5ea1477cd4b3b1d2eb75495b3"}, +] + +[package.extras] +docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.1)", "sphinx-autodoc-typehints (>=1.24)"] +test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4)", "pytest-cov (>=4.1)", "pytest-mock (>=3.11.1)"] + [[package]] name = "pluggy" version = "1.4.0" @@ -401,6 +1078,67 @@ files = [ dev = ["pre-commit", "tox"] testing = ["pytest", "pytest-benchmark"] +[[package]] +name = "poetry" +version = "1.7.1" +description = "Python dependency management and packaging made easy." +optional = false +python-versions = ">=3.8,<4.0" +files = [ + {file = "poetry-1.7.1-py3-none-any.whl", hash = "sha256:03d3807a0fb3bc1028cc3707dfd646aae629d58e476f7e7f062437680741c561"}, + {file = "poetry-1.7.1.tar.gz", hash = "sha256:b348a70e7d67ad9c0bd3d0ea255bc6df84c24cf4b16f8d104adb30b425d6ff32"}, +] + +[package.dependencies] +build = ">=1.0.3,<2.0.0" +cachecontrol = {version = ">=0.13.0,<0.14.0", extras = ["filecache"]} +cleo = ">=2.1.0,<3.0.0" +crashtest = ">=0.4.1,<0.5.0" +dulwich = ">=0.21.2,<0.22.0" +fastjsonschema = ">=2.18.0,<3.0.0" +installer = ">=0.7.0,<0.8.0" +keyring = ">=24.0.0,<25.0.0" +packaging = ">=20.5" +pexpect = ">=4.7.0,<5.0.0" +pkginfo = ">=1.9.4,<2.0.0" +platformdirs = ">=3.0.0,<4.0.0" +poetry-core = "1.8.1" +poetry-plugin-export = ">=1.6.0,<2.0.0" +pyproject-hooks = ">=1.0.0,<2.0.0" +requests = ">=2.26,<3.0" +requests-toolbelt = ">=0.9.1,<2" +shellingham = ">=1.5,<2.0" +tomlkit = ">=0.11.4,<1.0.0" +trove-classifiers = ">=2022.5.19" +virtualenv = ">=20.23.0,<21.0.0" +xattr = {version = ">=0.10.0,<0.11.0", markers = "sys_platform == \"darwin\""} + +[[package]] +name = "poetry-core" +version = "1.8.1" +description = "Poetry PEP 517 Build Backend" +optional = false +python-versions = ">=3.8,<4.0" +files = [ + {file = "poetry_core-1.8.1-py3-none-any.whl", hash = "sha256:194832b24f3283e01c5402eae71a6aae850ecdfe53f50a979c76bf7aa5010ffa"}, + {file = "poetry_core-1.8.1.tar.gz", hash = "sha256:67a76c671da2a70e55047cddda83566035b701f7e463b32a2abfeac6e2a16376"}, +] + +[[package]] +name = "poetry-plugin-export" +version = "1.6.0" +description = "Poetry plugin to export the dependencies to various formats" +optional = false +python-versions = ">=3.8,<4.0" +files = [ + {file = "poetry_plugin_export-1.6.0-py3-none-any.whl", hash = "sha256:2dce6204c9318f1f6509a11a03921fb3f461b201840b59f1c237b6ab454dabcf"}, + {file = "poetry_plugin_export-1.6.0.tar.gz", hash = "sha256:091939434984267a91abf2f916a26b00cff4eee8da63ec2a24ba4b17cf969a59"}, +] + +[package.dependencies] +poetry = ">=1.6.0,<2.0.0" +poetry-core = ">=1.7.0,<2.0.0" + [[package]] name = "prompt-toolkit" version = "3.0.43" @@ -441,14 +1179,14 @@ files = [ tests = ["pytest"] [[package]] -name = "py" -version = "1.11.0" -description = "library with cross-python path, ini-parsing, io, code, log facilities" +name = "pycparser" +version = "2.21" +description = "C parser in Python" optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" files = [ - {file = "py-1.11.0-py2.py3-none-any.whl", hash = "sha256:607c53218732647dff4acdfcd50cb62615cedf612e72d1724fb1a0cc6405b378"}, - {file = "py-1.11.0.tar.gz", hash = "sha256:51c75c4126074b472f746a24399ad32f6053d1b34b68d2fa41e558e6f4a98719"}, + {file = "pycparser-2.21-py2.py3-none-any.whl", hash = "sha256:8ee45429555515e1f6b185e78100aea234072576aa43ab53aefcae078162fca9"}, + {file = "pycparser-2.21.tar.gz", hash = "sha256:e644fdec12f7872f86c58ff790da456218b10f863970249516d60a5eaca77206"}, ] [[package]] @@ -466,6 +1204,17 @@ files = [ plugins = ["importlib-metadata"] windows-terminal = ["colorama (>=0.4.6)"] +[[package]] +name = "pyproject-hooks" +version = "1.0.0" +description = "Wrappers to call pyproject.toml-based build backend hooks." +optional = false +python-versions = ">=3.7" +files = [ + {file = "pyproject_hooks-1.0.0-py3-none-any.whl", hash = "sha256:283c11acd6b928d2f6a7c73fa0d01cb2bdc5f07c57a2eeb6e83d5e56b97976f8"}, + {file = "pyproject_hooks-1.0.0.tar.gz", hash = "sha256:f271b298b97f5955d53fb12b72c1fb1948c22c1a6b70b315c54cedaca0264ef5"}, +] + [[package]] name = "pytest" version = "7.4.4" @@ -488,19 +1237,20 @@ testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "no [[package]] name = "pytest-asyncio" -version = "0.19.0" +version = "0.21.1" description = "Pytest support for asyncio" optional = false python-versions = ">=3.7" files = [ - {file = "pytest-asyncio-0.19.0.tar.gz", hash = "sha256:ac4ebf3b6207259750bc32f4c1d8fcd7e79739edbc67ad0c58dd150b1d072fed"}, - {file = "pytest_asyncio-0.19.0-py3-none-any.whl", hash = "sha256:7a97e37cfe1ed296e2e84941384bdd37c376453912d397ed39293e0916f521fa"}, + {file = "pytest-asyncio-0.21.1.tar.gz", hash = "sha256:40a7eae6dded22c7b604986855ea48400ab15b069ae38116e8c01238e9eeb64d"}, + {file = "pytest_asyncio-0.21.1-py3-none-any.whl", hash = "sha256:8666c1c8ac02631d7c51ba282e0c69a8a452b211ffedf2599099845da5c5c37b"}, ] [package.dependencies] -pytest = ">=6.1.0" +pytest = ">=7.0.0" [package.extras] +docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1.0)"] testing = ["coverage (>=6.2)", "flaky (>=3.5.0)", "hypothesis (>=5.7.1)", "mypy (>=0.931)", "pytest-trio (>=0.7.0)"] [[package]] @@ -536,41 +1286,162 @@ files = [ pytest = ">=3.6" [[package]] -name = "pytest-forked" -version = "1.6.0" -description = "run tests in isolated forked subprocesses" +name = "pytest-xdist" +version = "3.5.0" +description = "pytest xdist plugin for distributed testing, most importantly across multiple CPUs" optional = false python-versions = ">=3.7" files = [ - {file = "pytest-forked-1.6.0.tar.gz", hash = "sha256:4dafd46a9a600f65d822b8f605133ecf5b3e1941ebb3588e943b4e3eb71a5a3f"}, - {file = "pytest_forked-1.6.0-py3-none-any.whl", hash = "sha256:810958f66a91afb1a1e2ae83089d8dc1cd2437ac96b12963042fbb9fb4d16af0"}, -] - -[package.dependencies] -py = "*" -pytest = ">=3.10" - -[[package]] -name = "pytest-xdist" -version = "2.5.0" -description = "pytest xdist plugin for distributed testing and loop-on-failing modes" -optional = false -python-versions = ">=3.6" -files = [ - {file = "pytest-xdist-2.5.0.tar.gz", hash = "sha256:4580deca3ff04ddb2ac53eba39d76cb5dd5edeac050cb6fbc768b0dd712b4edf"}, - {file = "pytest_xdist-2.5.0-py3-none-any.whl", hash = "sha256:6fe5c74fec98906deb8f2d2b616b5c782022744978e7bd4695d39c8f42d0ce65"}, + {file = "pytest-xdist-3.5.0.tar.gz", hash = "sha256:cbb36f3d67e0c478baa57fa4edc8843887e0f6cfc42d677530a36d7472b32d8a"}, + {file = "pytest_xdist-3.5.0-py3-none-any.whl", hash = "sha256:d075629c7e00b611df89f490a5063944bee7a4362a5ff11c7cc7824a03dfce24"}, ] [package.dependencies] execnet = ">=1.1" pytest = ">=6.2.0" -pytest-forked = "*" [package.extras] psutil = ["psutil (>=3.0)"] setproctitle = ["setproctitle"] testing = ["filelock"] +[[package]] +name = "python-decouple" +version = "3.8" +description = "Strict separation of settings from code." +optional = false +python-versions = "*" +files = [ + {file = "python-decouple-3.8.tar.gz", hash = "sha256:ba6e2657d4f376ecc46f77a3a615e058d93ba5e465c01bbe57289bfb7cce680f"}, + {file = "python_decouple-3.8-py3-none-any.whl", hash = "sha256:d0d45340815b25f4de59c974b855bb38d03151d81b037d9e3f463b0c9f8cbd66"}, +] + +[[package]] +name = "python-steamgriddb" +version = "1.0.5" +description = "A Python wrapper for SteamGridDB's API" +optional = false +python-versions = "*" +files = [ + {file = "python-steamgriddb-1.0.5.tar.gz", hash = "sha256:036db7bb09865da73b40b68cf04fb9675cd18b4908275092d91f37bf16245069"}, +] + +[package.dependencies] +requests = "*" + +[[package]] +name = "pywin32-ctypes" +version = "0.2.2" +description = "A (partial) reimplementation of pywin32 using ctypes/cffi" +optional = false +python-versions = ">=3.6" +files = [ + {file = "pywin32-ctypes-0.2.2.tar.gz", hash = "sha256:3426e063bdd5fd4df74a14fa3cf80a0b42845a87e1d1e81f6549f9daec593a60"}, + {file = "pywin32_ctypes-0.2.2-py3-none-any.whl", hash = "sha256:bf490a1a709baf35d688fe0ecf980ed4de11d2b3e37b51e5442587a75d9957e7"}, +] + +[[package]] +name = "rapidfuzz" +version = "3.6.1" +description = "rapid fuzzy string matching" +optional = false +python-versions = ">=3.8" +files = [ + {file = "rapidfuzz-3.6.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ac434fc71edda30d45db4a92ba5e7a42c7405e1a54cb4ec01d03cc668c6dcd40"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2a791168e119cfddf4b5a40470620c872812042f0621e6a293983a2d52372db0"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5a2f3e9df346145c2be94e4d9eeffb82fab0cbfee85bd4a06810e834fe7c03fa"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23de71e7f05518b0bbeef55d67b5dbce3bcd3e2c81e7e533051a2e9401354eb0"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d056e342989248d2bdd67f1955bb7c3b0ecfa239d8f67a8dfe6477b30872c607"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:01835d02acd5d95c1071e1da1bb27fe213c84a013b899aba96380ca9962364bc"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ed0f712e0bb5fea327e92aec8a937afd07ba8de4c529735d82e4c4124c10d5a0"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:96cd19934f76a1264e8ecfed9d9f5291fde04ecb667faef5f33bdbfd95fe2d1f"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:e06c4242a1354cf9d48ee01f6f4e6e19c511d50bb1e8d7d20bcadbb83a2aea90"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:d73dcfe789d37c6c8b108bf1e203e027714a239e50ad55572ced3c004424ed3b"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:06e98ff000e2619e7cfe552d086815671ed09b6899408c2c1b5103658261f6f3"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:08b6fb47dd889c69fbc0b915d782aaed43e025df6979b6b7f92084ba55edd526"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a1788ebb5f5b655a15777e654ea433d198f593230277e74d51a2a1e29a986283"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-win32.whl", hash = "sha256:c65f92881753aa1098c77818e2b04a95048f30edbe9c3094dc3707d67df4598b"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:4243a9c35667a349788461aae6471efde8d8800175b7db5148a6ab929628047f"}, + {file = "rapidfuzz-3.6.1-cp310-cp310-win_arm64.whl", hash = "sha256:f59d19078cc332dbdf3b7b210852ba1f5db8c0a2cd8cc4c0ed84cc00c76e6802"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fbc07e2e4ac696497c5f66ec35c21ddab3fc7a406640bffed64c26ab2f7ce6d6"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:40cced1a8852652813f30fb5d4b8f9b237112a0bbaeebb0f4cc3611502556764"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82300e5f8945d601c2daaaac139d5524d7c1fdf719aa799a9439927739917460"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:edf97c321fd641fea2793abce0e48fa4f91f3c202092672f8b5b4e781960b891"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7420e801b00dee4a344ae2ee10e837d603461eb180e41d063699fb7efe08faf0"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:060bd7277dc794279fa95522af355034a29c90b42adcb7aa1da358fc839cdb11"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b7e3375e4f2bfec77f907680328e4cd16cc64e137c84b1886d547ab340ba6928"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a490cd645ef9d8524090551016f05f052e416c8adb2d8b85d35c9baa9d0428ab"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:2e03038bfa66d2d7cffa05d81c2f18fd6acbb25e7e3c068d52bb7469e07ff382"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:2b19795b26b979c845dba407fe79d66975d520947b74a8ab6cee1d22686f7967"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:064c1d66c40b3a0f488db1f319a6e75616b2e5fe5430a59f93a9a5e40a656d15"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:3c772d04fb0ebeece3109d91f6122b1503023086a9591a0b63d6ee7326bd73d9"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:841eafba6913c4dfd53045835545ba01a41e9644e60920c65b89c8f7e60c00a9"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-win32.whl", hash = "sha256:266dd630f12696ea7119f31d8b8e4959ef45ee2cbedae54417d71ae6f47b9848"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:d79aec8aeee02ab55d0ddb33cea3ecd7b69813a48e423c966a26d7aab025cdfe"}, + {file = "rapidfuzz-3.6.1-cp311-cp311-win_arm64.whl", hash = "sha256:484759b5dbc5559e76fefaa9170147d1254468f555fd9649aea3bad46162a88b"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b2ef4c0fd3256e357b70591ffb9e8ed1d439fb1f481ba03016e751a55261d7c1"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:588c4b20fa2fae79d60a4e438cf7133d6773915df3cc0a7f1351da19eb90f720"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7142ee354e9c06e29a2636b9bbcb592bb00600a88f02aa5e70e4f230347b373e"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1dfc557c0454ad22382373ec1b7df530b4bbd974335efe97a04caec936f2956a"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:03f73b381bdeccb331a12c3c60f1e41943931461cdb52987f2ecf46bfc22f50d"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6b0ccc2ec1781c7e5370d96aef0573dd1f97335343e4982bdb3a44c133e27786"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da3e8c9f7e64bb17faefda085ff6862ecb3ad8b79b0f618a6cf4452028aa2222"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fde9b14302a31af7bdafbf5cfbb100201ba21519be2b9dedcf4f1048e4fbe65d"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:c1a23eee225dfb21c07f25c9fcf23eb055d0056b48e740fe241cbb4b22284379"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:e49b9575d16c56c696bc7b06a06bf0c3d4ef01e89137b3ddd4e2ce709af9fe06"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:0a9fc714b8c290261669f22808913aad49553b686115ad0ee999d1cb3df0cd66"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:a3ee4f8f076aa92184e80308fc1a079ac356b99c39408fa422bbd00145be9854"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f056ba42fd2f32e06b2c2ba2443594873cfccc0c90c8b6327904fc2ddf6d5799"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-win32.whl", hash = "sha256:5d82b9651e3d34b23e4e8e201ecd3477c2baa17b638979deeabbb585bcb8ba74"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:dad55a514868dae4543ca48c4e1fc0fac704ead038dafedf8f1fc0cc263746c1"}, + {file = "rapidfuzz-3.6.1-cp312-cp312-win_arm64.whl", hash = "sha256:3c84294f4470fcabd7830795d754d808133329e0a81d62fcc2e65886164be83b"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:e19d519386e9db4a5335a4b29f25b8183a1c3f78cecb4c9c3112e7f86470e37f"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:01eb03cd880a294d1bf1a583fdd00b87169b9cc9c9f52587411506658c864d73"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:be368573255f8fbb0125a78330a1a40c65e9ba3c5ad129a426ff4289099bfb41"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b3e5af946f419c30f5cb98b69d40997fe8580efe78fc83c2f0f25b60d0e56efb"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f382f7ffe384ce34345e1c0b2065451267d3453cadde78946fbd99a59f0cc23c"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be156f51f3a4f369e758505ed4ae64ea88900dcb2f89d5aabb5752676d3f3d7e"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1936d134b6c513fbe934aeb668b0fee1ffd4729a3c9d8d373f3e404fbb0ce8a0"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:12ff8eaf4a9399eb2bebd838f16e2d1ded0955230283b07376d68947bbc2d33d"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:ae598a172e3a95df3383634589660d6b170cc1336fe7578115c584a99e0ba64d"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:cd4ba4c18b149da11e7f1b3584813159f189dc20833709de5f3df8b1342a9759"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:0402f1629e91a4b2e4aee68043a30191e5e1b7cd2aa8dacf50b1a1bcf6b7d3ab"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:1e12319c6b304cd4c32d5db00b7a1e36bdc66179c44c5707f6faa5a889a317c0"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:0bbfae35ce4de4c574b386c43c78a0be176eeddfdae148cb2136f4605bebab89"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-win32.whl", hash = "sha256:7fec74c234d3097612ea80f2a80c60720eec34947066d33d34dc07a3092e8105"}, + {file = "rapidfuzz-3.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:a553cc1a80d97459d587529cc43a4c7c5ecf835f572b671107692fe9eddf3e24"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:757dfd7392ec6346bd004f8826afb3bf01d18a723c97cbe9958c733ab1a51791"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:2963f4a3f763870a16ee076796be31a4a0958fbae133dbc43fc55c3968564cf5"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:d2f0274595cc5b2b929c80d4e71b35041104b577e118cf789b3fe0a77b37a4c5"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f211e366e026de110a4246801d43a907cd1a10948082f47e8a4e6da76fef52"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a59472b43879012b90989603aa5a6937a869a72723b1bf2ff1a0d1edee2cc8e6"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a03863714fa6936f90caa7b4b50ea59ea32bb498cc91f74dc25485b3f8fccfe9"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5dd95b6b7bfb1584f806db89e1e0c8dbb9d25a30a4683880c195cc7f197eaf0c"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7183157edf0c982c0b8592686535c8b3e107f13904b36d85219c77be5cefd0d8"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:ad9d74ef7c619b5b0577e909582a1928d93e07d271af18ba43e428dc3512c2a1"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:b53137d81e770c82189e07a8f32722d9e4260f13a0aec9914029206ead38cac3"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:49b9ed2472394d306d5dc967a7de48b0aab599016aa4477127b20c2ed982dbf9"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:dec307b57ec2d5054d77d03ee4f654afcd2c18aee00c48014cb70bfed79597d6"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4381023fa1ff32fd5076f5d8321249a9aa62128eb3f21d7ee6a55373e672b261"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-win32.whl", hash = "sha256:8d7a072f10ee57c8413c8ab9593086d42aaff6ee65df4aa6663eecdb7c398dca"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:ebcfb5bfd0a733514352cfc94224faad8791e576a80ffe2fd40b2177bf0e7198"}, + {file = "rapidfuzz-3.6.1-cp39-cp39-win_arm64.whl", hash = "sha256:1c47d592e447738744905c18dda47ed155620204714e6df20eb1941bb1ba315e"}, + {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:eef8b346ab331bec12bbc83ac75641249e6167fab3d84d8f5ca37fd8e6c7a08c"}, + {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:53251e256017e2b87f7000aee0353ba42392c442ae0bafd0f6b948593d3f68c6"}, + {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6dede83a6b903e3ebcd7e8137e7ff46907ce9316e9d7e7f917d7e7cdc570ee05"}, + {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4da90e4c2b444d0a171d7444ea10152e07e95972bb40b834a13bdd6de1110c"}, + {file = "rapidfuzz-3.6.1-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:ca3dfcf74f2b6962f411c33dd95b0adf3901266e770da6281bc96bb5a8b20de9"}, + {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:bcc957c0a8bde8007f1a8a413a632a1a409890f31f73fe764ef4eac55f59ca87"}, + {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:692c9a50bea7a8537442834f9bc6b7d29d8729a5b6379df17c31b6ab4df948c2"}, + {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:76c23ceaea27e790ddd35ef88b84cf9d721806ca366199a76fd47cfc0457a81b"}, + {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2b155e67fff215c09f130555002e42f7517d0ea72cbd58050abb83cb7c880cec"}, + {file = "rapidfuzz-3.6.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:3028ee8ecc48250607fa8a0adce37b56275ec3b1acaccd84aee1f68487c8557b"}, + {file = "rapidfuzz-3.6.1.tar.gz", hash = "sha256:35660bee3ce1204872574fa041c7ad7ec5175b3053a4cb6e181463fc07013de7"}, +] + +[package.extras] +full = ["numpy"] + [[package]] name = "requests" version = "2.31.0" @@ -593,47 +1464,87 @@ socks = ["PySocks (>=1.5.6,!=1.5.7)"] use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] [[package]] -name = "rich" -version = "12.6.0" -description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +name = "requests-toolbelt" +version = "1.0.0" +description = "A utility belt for advanced users of python-requests" optional = false -python-versions = ">=3.6.3,<4.0.0" +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" files = [ - {file = "rich-12.6.0-py3-none-any.whl", hash = "sha256:a4eb26484f2c82589bd9a17c73d32a010b1e29d89f1604cd9bf3a2097b81bb5e"}, - {file = "rich-12.6.0.tar.gz", hash = "sha256:ba3a3775974105c221d31141f2c116f4fd65c5ceb0698657a11e9f295ec93fd0"}, + {file = "requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6"}, + {file = "requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06"}, ] [package.dependencies] -commonmark = ">=0.9.0,<0.10.0" -pygments = ">=2.6.0,<3.0.0" +requests = ">=2.0.1,<3.0.0" + +[[package]] +name = "rich" +version = "13.7.0" +description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" +optional = false +python-versions = ">=3.7.0" +files = [ + {file = "rich-13.7.0-py3-none-any.whl", hash = "sha256:6da14c108c4866ee9520bbffa71f6fe3962e193b7da68720583850cd4548e235"}, + {file = "rich-13.7.0.tar.gz", hash = "sha256:5cb5123b5cf9ee70584244246816e9114227e0b98ad9176eede6ad54bf5403fa"}, +] + +[package.dependencies] +markdown-it-py = ">=2.2.0" +pygments = ">=2.13.0,<3.0.0" [package.extras] -jupyter = ["ipywidgets (>=7.5.1,<8.0.0)"] +jupyter = ["ipywidgets (>=7.5.1,<9)"] [[package]] name = "ruff" -version = "0.0.269" -description = "An extremely fast Python linter, written in Rust." +version = "0.1.15" +description = "An extremely fast Python linter and code formatter, written in Rust." optional = false python-versions = ">=3.7" files = [ - {file = "ruff-0.0.269-py3-none-macosx_10_7_x86_64.whl", hash = "sha256:3569bcdee679045c09c0161fabc057599759c49219a08d9a4aad2cc3982ccba3"}, - {file = "ruff-0.0.269-py3-none-macosx_10_9_x86_64.macosx_11_0_arm64.macosx_10_9_universal2.whl", hash = "sha256:56347da63757a56cbce7d4b3d6044ca4f1941cd1bbff3714f7554360c3361f83"}, - {file = "ruff-0.0.269-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6da8ee25ef2f0cc6cc8e6e20942c1d44d25a36dce35070d7184655bc14f63f63"}, - {file = "ruff-0.0.269-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd81b8e681b9eaa6cf15484f3985bd8bd97c3d114e95bff3e8ea283bf8865062"}, - {file = "ruff-0.0.269-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1f19f59ca3c28742955241fb452f3346241ddbd34e72ac5cb3d84fadebcf6bc8"}, - {file = "ruff-0.0.269-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:f062059b8289a4fab7f6064601b811d447c2f9d3d432a17f689efe4d68988450"}, - {file = "ruff-0.0.269-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f5dc7aac52c58e82510217e3c7efd80765c134c097c2815d59e40face0d1fe6"}, - {file = "ruff-0.0.269-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e131b4dbe798c391090c6407641d6ab12c0fa1bb952379dde45e5000e208dabb"}, - {file = "ruff-0.0.269-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a374434e588e06550df0f8dcb74777290f285678de991fda4e1063c367ab2eb2"}, - {file = "ruff-0.0.269-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:cec2f4b84a14b87f1b121488649eb5b4eaa06467a2387373f750da74bdcb5679"}, - {file = "ruff-0.0.269-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:374b161753a247904aec7a32d45e165302b76b6e83d22d099bf3ff7c232c888f"}, - {file = "ruff-0.0.269-py3-none-musllinux_1_2_i686.whl", hash = "sha256:9ca0a1ddb1d835b5f742db9711c6cf59f213a1ad0088cb1e924a005fd399e7d8"}, - {file = "ruff-0.0.269-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5a20658f0b97d207c7841c13d528f36d666bf445b00b01139f28a8ccb80093bb"}, - {file = "ruff-0.0.269-py3-none-win32.whl", hash = "sha256:03ff42bc91ceca58e0f0f072cb3f9286a9208f609812753474e799a997cdad1a"}, - {file = "ruff-0.0.269-py3-none-win_amd64.whl", hash = "sha256:f3b59ccff57b21ef0967ea8021fd187ec14c528ec65507d8bcbe035912050776"}, - {file = "ruff-0.0.269-py3-none-win_arm64.whl", hash = "sha256:bbeb857b1e508a4487bdb02ca1e6d41dd8d5ac5335a5246e25de8a3dff38c1ff"}, - {file = "ruff-0.0.269.tar.gz", hash = "sha256:11ddcfbab32cf5c420ea9dd5531170ace5a3e59c16d9251c7bd2581f7b16f602"}, + {file = "ruff-0.1.15-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:5fe8d54df166ecc24106db7dd6a68d44852d14eb0729ea4672bb4d96c320b7df"}, + {file = "ruff-0.1.15-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:6f0bfbb53c4b4de117ac4d6ddfd33aa5fc31beeaa21d23c45c6dd249faf9126f"}, + {file = "ruff-0.1.15-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e0d432aec35bfc0d800d4f70eba26e23a352386be3a6cf157083d18f6f5881c8"}, + {file = "ruff-0.1.15-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9405fa9ac0e97f35aaddf185a1be194a589424b8713e3b97b762336ec79ff807"}, + {file = "ruff-0.1.15-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c66ec24fe36841636e814b8f90f572a8c0cb0e54d8b5c2d0e300d28a0d7bffec"}, + {file = "ruff-0.1.15-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:6f8ad828f01e8dd32cc58bc28375150171d198491fc901f6f98d2a39ba8e3ff5"}, + {file = "ruff-0.1.15-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86811954eec63e9ea162af0ffa9f8d09088bab51b7438e8b6488b9401863c25e"}, + {file = "ruff-0.1.15-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fd4025ac5e87d9b80e1f300207eb2fd099ff8200fa2320d7dc066a3f4622dc6b"}, + {file = "ruff-0.1.15-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b17b93c02cdb6aeb696effecea1095ac93f3884a49a554a9afa76bb125c114c1"}, + {file = "ruff-0.1.15-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:ddb87643be40f034e97e97f5bc2ef7ce39de20e34608f3f829db727a93fb82c5"}, + {file = "ruff-0.1.15-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:abf4822129ed3a5ce54383d5f0e964e7fef74a41e48eb1dfad404151efc130a2"}, + {file = "ruff-0.1.15-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6c629cf64bacfd136c07c78ac10a54578ec9d1bd2a9d395efbee0935868bf852"}, + {file = "ruff-0.1.15-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:1bab866aafb53da39c2cadfb8e1c4550ac5340bb40300083eb8967ba25481447"}, + {file = "ruff-0.1.15-py3-none-win32.whl", hash = "sha256:2417e1cb6e2068389b07e6fa74c306b2810fe3ee3476d5b8a96616633f40d14f"}, + {file = "ruff-0.1.15-py3-none-win_amd64.whl", hash = "sha256:3837ac73d869efc4182d9036b1405ef4c73d9b1f88da2413875e34e0d6919587"}, + {file = "ruff-0.1.15-py3-none-win_arm64.whl", hash = "sha256:9a933dfb1c14ec7a33cceb1e49ec4a16b51ce3c20fd42663198746efc0427360"}, + {file = "ruff-0.1.15.tar.gz", hash = "sha256:f6dfa8c1b21c913c326919056c390966648b680966febcb796cc9d1aaab8564e"}, +] + +[[package]] +name = "secretstorage" +version = "3.3.3" +description = "Python bindings to FreeDesktop.org Secret Service API" +optional = false +python-versions = ">=3.6" +files = [ + {file = "SecretStorage-3.3.3-py3-none-any.whl", hash = "sha256:f356e6628222568e3af06f2eba8df495efa13b3b63081dafd4f7d9a7b7bc9f99"}, + {file = "SecretStorage-3.3.3.tar.gz", hash = "sha256:2403533ef369eca6d2ba81718576c5e0f564d5cca1b58f73a8b23e7d4eeebd77"}, +] + +[package.dependencies] +cryptography = ">=2.0" +jeepney = ">=0.6" + +[[package]] +name = "shellingham" +version = "1.5.4" +description = "Tool to Detect Surrounding Shell" +optional = false +python-versions = ">=3.7" +files = [ + {file = "shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"}, + {file = "shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de"}, ] [[package]] @@ -647,6 +1558,17 @@ files = [ {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"}, ] +[[package]] +name = "sortedcontainers" +version = "2.4.0" +description = "Sorted Containers -- Sorted List, Sorted Dict, Sorted Set" +optional = false +python-versions = "*" +files = [ + {file = "sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0"}, + {file = "sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88"}, +] + [[package]] name = "stack-data" version = "0.6.3" @@ -666,6 +1588,17 @@ pure-eval = "*" [package.extras] tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] +[[package]] +name = "tomlkit" +version = "0.12.3" +description = "Style preserving TOML library" +optional = false +python-versions = ">=3.7" +files = [ + {file = "tomlkit-0.12.3-py3-none-any.whl", hash = "sha256:b0a645a9156dc7cb5d3a1f0d4bab66db287fcb8e0430bdd4664a095ea16414ba"}, + {file = "tomlkit-0.12.3.tar.gz", hash = "sha256:75baf5012d06501f07bee5bf8e801b9f343e7aac5a92581f20f80ce632e6b5a4"}, +] + [[package]] name = "traitlets" version = "5.14.1" @@ -681,15 +1614,26 @@ files = [ docs = ["myst-parser", "pydata-sphinx-theme", "sphinx"] test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0,<7.5)", "pytest-mock", "pytest-mypy-testing"] +[[package]] +name = "trove-classifiers" +version = "2024.1.31" +description = "Canonical source for classifiers on PyPI (pypi.org)." +optional = false +python-versions = "*" +files = [ + {file = "trove-classifiers-2024.1.31.tar.gz", hash = "sha256:bfdfe60bbf64985c524416afb637ecc79c558e0beb4b7f52b0039e01044b0229"}, + {file = "trove_classifiers-2024.1.31-py3-none-any.whl", hash = "sha256:854aba3358f3cf10e5c0916aa533f5a39e27aadd8ade26a54cdc2a93257e39c4"}, +] + [[package]] name = "urllib3" -version = "2.2.0" +version = "2.2.1" description = "HTTP library with thread-safe connection pooling, file post, and more." optional = false python-versions = ">=3.8" files = [ - {file = "urllib3-2.2.0-py3-none-any.whl", hash = "sha256:ce3711610ddce217e6d113a2732fafad960a03fd0318c91faa79481e35c11224"}, - {file = "urllib3-2.2.0.tar.gz", hash = "sha256:051d961ad0c62a94e50ecf1af379c3aba230c66c710493493560c0c223c49f20"}, + {file = "urllib3-2.2.1-py3-none-any.whl", hash = "sha256:450b20ec296a467077128bff42b73080516e71b56ff59a60a02bef2232c4fa9d"}, + {file = "urllib3-2.2.1.tar.gz", hash = "sha256:d0570876c61ab9e520d776c38acbbb5b05a776d3f9ff98a5c8fd5162a444cf19"}, ] [package.extras] @@ -709,6 +1653,26 @@ files = [ {file = "vdf-3.4.tar.gz", hash = "sha256:fd5419f41e07a1009e5ffd027c7dcbe43d1f7e8ef453aeaa90d9d04b807de2af"}, ] +[[package]] +name = "virtualenv" +version = "20.25.0" +description = "Virtual Python Environment builder" +optional = false +python-versions = ">=3.7" +files = [ + {file = "virtualenv-20.25.0-py3-none-any.whl", hash = "sha256:4238949c5ffe6876362d9c0180fc6c3a824a7b12b80604eeb8085f2ed7460de3"}, + {file = "virtualenv-20.25.0.tar.gz", hash = "sha256:bf51c0d9c7dd63ea8e44086fa1e4fb1093a31e963b86959257378aef020e1f1b"}, +] + +[package.dependencies] +distlib = ">=0.3.7,<1" +filelock = ">=3.12.2,<4" +platformdirs = ">=3.9.1,<5" + +[package.extras] +docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] +test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"] + [[package]] name = "wcwidth" version = "0.2.13" @@ -720,7 +1684,106 @@ files = [ {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, ] +[[package]] +name = "xattr" +version = "0.10.1" +description = "Python wrapper for extended filesystem attributes" +optional = false +python-versions = "*" +files = [ + {file = "xattr-0.10.1-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:16a660a883e703b311d1bbbcafc74fa877585ec081cd96e8dd9302c028408ab1"}, + {file = "xattr-0.10.1-cp27-cp27m-manylinux1_i686.whl", hash = "sha256:1e2973e72faa87ca29d61c23b58c3c89fe102d1b68e091848b0e21a104123503"}, + {file = "xattr-0.10.1-cp27-cp27m-manylinux1_x86_64.whl", hash = "sha256:13279fe8f7982e3cdb0e088d5cb340ce9cbe5ef92504b1fd80a0d3591d662f68"}, + {file = "xattr-0.10.1-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:1dc9b9f580ef4b8ac5e2c04c16b4d5086a611889ac14ecb2e7e87170623a0b75"}, + {file = "xattr-0.10.1-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:485539262c2b1f5acd6b6ea56e0da2bc281a51f74335c351ea609c23d82c9a79"}, + {file = "xattr-0.10.1-cp27-cp27mu-manylinux1_i686.whl", hash = "sha256:295b3ab335fcd06ca0a9114439b34120968732e3f5e9d16f456d5ec4fa47a0a2"}, + {file = "xattr-0.10.1-cp27-cp27mu-manylinux1_x86_64.whl", hash = "sha256:a126eb38e14a2f273d584a692fe36cff760395bf7fc061ef059224efdb4eb62c"}, + {file = "xattr-0.10.1-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:b0e919c24f5b74428afa91507b15e7d2ef63aba98e704ad13d33bed1288dca81"}, + {file = "xattr-0.10.1-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:e31d062cfe1aaeab6ba3db6bd255f012d105271018e647645941d6609376af18"}, + {file = "xattr-0.10.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:209fb84c09b41c2e4cf16dd2f481bb4a6e2e81f659a47a60091b9bcb2e388840"}, + {file = "xattr-0.10.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c4120090dac33eddffc27e487f9c8f16b29ff3f3f8bcb2251b2c6c3f974ca1e1"}, + {file = "xattr-0.10.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3e739d624491267ec5bb740f4eada93491de429d38d2fcdfb97b25efe1288eca"}, + {file = "xattr-0.10.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2677d40b95636f3482bdaf64ed9138fb4d8376fb7933f434614744780e46e42d"}, + {file = "xattr-0.10.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40039f1532c4456fd0f4c54e9d4e01eb8201248c321c6c6856262d87e9a99593"}, + {file = "xattr-0.10.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:148466e5bb168aba98f80850cf976e931469a3c6eb11e9880d9f6f8b1e66bd06"}, + {file = "xattr-0.10.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0aedf55b116beb6427e6f7958ccd80a8cbc80e82f87a4cd975ccb61a8d27b2ee"}, + {file = "xattr-0.10.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:c3024a9ff157247c8190dd0eb54db4a64277f21361b2f756319d9d3cf20e475f"}, + {file = "xattr-0.10.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:f1be6e733e9698f645dbb98565bb8df9b75e80e15a21eb52787d7d96800e823b"}, + {file = "xattr-0.10.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7880c8a54c18bc091a4ce0adc5c6d81da1c748aec2fe7ac586d204d6ec7eca5b"}, + {file = "xattr-0.10.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:89c93b42c3ba8aedbc29da759f152731196c2492a2154371c0aae3ef8ba8301b"}, + {file = "xattr-0.10.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6b905e808df61b677eb972f915f8a751960284358b520d0601c8cbc476ba2df6"}, + {file = "xattr-0.10.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1ef954d0655f93a34d07d0cc7e02765ec779ff0b59dc898ee08c6326ad614d5"}, + {file = "xattr-0.10.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:199b20301b6acc9022661412346714ce764d322068ef387c4de38062474db76c"}, + {file = "xattr-0.10.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec0956a8ab0f0d3f9011ba480f1e1271b703d11542375ef73eb8695a6bd4b78b"}, + {file = "xattr-0.10.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ffcb57ca1be338d69edad93cf59aac7c6bb4dbb92fd7bf8d456c69ea42f7e6d2"}, + {file = "xattr-0.10.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:1f0563196ee54756fe2047627d316977dc77d11acd7a07970336e1a711e934db"}, + {file = "xattr-0.10.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc354f086f926a1c7f04886f97880fed1a26d20e3bc338d0d965fd161dbdb8ab"}, + {file = "xattr-0.10.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:c0cd2d02ef2fb45ecf2b0da066a58472d54682c6d4f0452dfe7ae2f3a76a42ea"}, + {file = "xattr-0.10.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:49626096ddd72dcc1654aadd84b103577d8424f26524a48d199847b5d55612d0"}, + {file = "xattr-0.10.1-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ceaa26bef8fcb17eb59d92a7481c2d15d20211e217772fb43c08c859b01afc6a"}, + {file = "xattr-0.10.1-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e8c014c371391f28f8cd27d73ea59f42b30772cd640b5a2538ad4f440fd9190b"}, + {file = "xattr-0.10.1-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:46c32cd605673606b9388a313b0050ee7877a0640d7561eea243ace4fa2cc5a6"}, + {file = "xattr-0.10.1-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:772b22c4ff791fe5816a7c2a1c9fcba83f9ab9bea138eb44d4d70f34676232b4"}, + {file = "xattr-0.10.1-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:183ad611a2d70b5a3f5f7aadef0fcef604ea33dcf508228765fd4ddac2c7321d"}, + {file = "xattr-0.10.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:8068df3ebdfa9411e58d5ae4a05d807ec5994645bb01af66ec9f6da718b65c5b"}, + {file = "xattr-0.10.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5bc40570155beb85e963ae45300a530223d9822edfdf09991b880e69625ba38a"}, + {file = "xattr-0.10.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:436e1aaf23c07e15bed63115f1712d2097e207214fc6bcde147c1efede37e2c5"}, + {file = "xattr-0.10.1-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7298455ccf3a922d403339781b10299b858bb5ec76435445f2da46fb768e31a5"}, + {file = "xattr-0.10.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:986c2305c6c1a08f78611eb38ef9f1f47682774ce954efb5a4f3715e8da00d5f"}, + {file = "xattr-0.10.1-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:5dc6099e76e33fa3082a905fe59df766b196534c705cf7a2e3ad9bed2b8a180e"}, + {file = "xattr-0.10.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:042ad818cda6013162c0bfd3816f6b74b7700e73c908cde6768da824686885f8"}, + {file = "xattr-0.10.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:9d4c306828a45b41b76ca17adc26ac3dc00a80e01a5ba85d71df2a3e948828f2"}, + {file = "xattr-0.10.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a606280b0c9071ef52572434ecd3648407b20df3d27af02c6592e84486b05894"}, + {file = "xattr-0.10.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:5b49d591cf34cda2079fd7a5cb2a7a1519f54dc2e62abe3e0720036f6ed41a85"}, + {file = "xattr-0.10.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6b8705ac6791426559c1a5c2b88bb2f0e83dc5616a09b4500899bfff6a929302"}, + {file = "xattr-0.10.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a5ea974930e876bc5c146f54ac0f85bb39b7b5de2b6fc63f90364712ae368ebe"}, + {file = "xattr-0.10.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f55a2dd73a12a1ae5113c5d9cd4b4ab6bf7950f4d76d0a1a0c0c4264d50da61d"}, + {file = "xattr-0.10.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:475c38da0d3614cc5564467c4efece1e38bd0705a4dbecf8deeb0564a86fb010"}, + {file = "xattr-0.10.1-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:925284a4a28e369459b2b7481ea22840eed3e0573a4a4c06b6b0614ecd27d0a7"}, + {file = "xattr-0.10.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:aa32f1b45fed9122bed911de0fcc654da349e1f04fa4a9c8ef9b53e1cc98b91e"}, + {file = "xattr-0.10.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c5d3d0e728bace64b74c475eb4da6148cd172b2d23021a1dcd055d92f17619ac"}, + {file = "xattr-0.10.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:8faaacf311e2b5cc67c030c999167a78a9906073e6abf08eaa8cf05b0416515c"}, + {file = "xattr-0.10.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cc6b8d5ca452674e1a96e246a3d2db5f477aecbc7c945c73f890f56323e75203"}, + {file = "xattr-0.10.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3725746a6502f40f72ef27e0c7bfc31052a239503ff3eefa807d6b02a249be22"}, + {file = "xattr-0.10.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:789bd406d1aad6735e97b20c6d6a1701e1c0661136be9be862e6a04564da771f"}, + {file = "xattr-0.10.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a9a7a807ab538210ff8532220d8fc5e2d51c212681f63dbd4e7ede32543b070f"}, + {file = "xattr-0.10.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:3e5825b5fc99ecdd493b0cc09ec35391e7a451394fdf623a88b24726011c950d"}, + {file = "xattr-0.10.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:80638d1ce7189dc52f26c234cee3522f060fadab6a8bc3562fe0ddcbe11ba5a4"}, + {file = "xattr-0.10.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3ff0dbe4a6ce2ce065c6de08f415bcb270ecfd7bf1655a633ddeac695ce8b250"}, + {file = "xattr-0.10.1-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5267e5f9435c840d2674194150b511bef929fa7d3bc942a4a75b9eddef18d8d8"}, + {file = "xattr-0.10.1-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b27dfc13b193cb290d5d9e62f806bb9a99b00cd73bb6370d556116ad7bb5dc12"}, + {file = "xattr-0.10.1-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:636ebdde0277bce4d12d2ef2550885804834418fee0eb456b69be928e604ecc4"}, + {file = "xattr-0.10.1-pp37-pypy37_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d60c27922ec80310b45574351f71e0dd3a139c5295e8f8b19d19c0010196544f"}, + {file = "xattr-0.10.1-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:b34df5aad035d0343bd740a95ca30db99b776e2630dca9cc1ba8e682c9cc25ea"}, + {file = "xattr-0.10.1-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f24a7c04ff666d0fe905dfee0a84bc899d624aeb6dccd1ea86b5c347f15c20c1"}, + {file = "xattr-0.10.1-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a3878e1aff8eca64badad8f6d896cb98c52984b1e9cd9668a3ab70294d1ef92d"}, + {file = "xattr-0.10.1-pp38-pypy38_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4abef557028c551d59cf2fb3bf63f2a0c89f00d77e54c1c15282ecdd56943496"}, + {file = "xattr-0.10.1-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:0e14bd5965d3db173d6983abdc1241c22219385c22df8b0eb8f1846c15ce1fee"}, + {file = "xattr-0.10.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f9be588a4b6043b03777d50654c6079af3da60cc37527dbb80d36ec98842b1e"}, + {file = "xattr-0.10.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b7bc4ae264aa679aacf964abf3ea88e147eb4a22aea6af8c6d03ebdebd64cfd6"}, + {file = "xattr-0.10.1-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:827b5a97673b9997067fde383a7f7dc67342403093b94ea3c24ae0f4f1fec649"}, + {file = "xattr-0.10.1.tar.gz", hash = "sha256:c12e7d81ffaa0605b3ac8c22c2994a8e18a9cf1c59287a1b7722a2289c952ec5"}, +] + +[package.dependencies] +cffi = ">=1.0" + +[[package]] +name = "zipp" +version = "3.17.0" +description = "Backport of pathlib-compatible object wrapper for zip files" +optional = false +python-versions = ">=3.8" +files = [ + {file = "zipp-3.17.0-py3-none-any.whl", hash = "sha256:0e923e726174922dce09c53c59ad483ff7bbb8e572e00c7f7c46b88556409f31"}, + {file = "zipp-3.17.0.tar.gz", hash = "sha256:84e64a1c28cf7e91ed2078bb8cc8c259cb19b76942096c8d7b84947690cabaf0"}, +] + +[package.extras] +docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-lint"] +testing = ["big-O", "jaraco.functools", "jaraco.itertools", "more-itertools", "pytest (>=6)", "pytest-black (>=0.3.7)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-ignore-flaky", "pytest-mypy (>=0.9.1)", "pytest-ruff"] + [metadata] lock-version = "2.0" -python-versions = "^3.11" -content-hash = "666b8caeb9d4f59459e1a4d29a744549ceb5fea29b953540873124ced9b838a2" +python-versions = ">=3.11,<3.13" +content-hash = "44d712eb09108b4fad723b0f3d091a4e14dc1d4db5b4d6cc6b2abd198eedee15" diff --git a/pyproject.toml b/pyproject.toml index cb0c2d0..758b664 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "non-steam-launchers" -version = "2.99.1" +version = "3.8.0" description = "" authors = [ "moraroy <88516395+moraroy@users.noreply.github.com>", @@ -10,19 +10,25 @@ license = "MIT" readme = "README.md" [tool.poetry.dependencies] -python = "^3.11" +python = ">=3.11,<3.13" +python-decouple = "^3.8" +python-steamgriddb = "^1.0.5" requests = "^2.31.0" vdf = "^3.4" [tool.poetry.group.dev.dependencies] -ipython = "^8.4.0" -pytest = "^7.1.3" -pytest-asyncio = "^0.19.0" -pytest-cov = "^4.0.0" +coverage = "^7.3.2" +hypothesis = {extras = ["cli"], version = "^6.88.4"} +icecream = "^2.1.3" +ipython = "^8.17.2" +poetry-plugin-export = "^1.6.0" +pytest = "^7.4.3" +pytest-asyncio = "^0.21.1" +pytest-cov = "^4.1.0" pytest-datafiles = "^3.0.0" -pytest-xdist = "^2.5.0" -rich = "^12.6.0" -ruff = "^0.0.269" +pytest-xdist = "^3.4.0" +rich = "^13.6.0" +ruff = "^0.1.5" [tool.ruff] # Enable pycodestyle (`E`) and Pyflakes (`F`) codes by default. diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..c06f3fb --- /dev/null +++ b/requirements.txt @@ -0,0 +1,8 @@ +certifi==2024.2.2 ; python_version >= "3.11" and python_version < "3.13" +charset-normalizer==3.3.2 ; python_version >= "3.11" and python_version < "3.13" +idna==3.6 ; python_version >= "3.11" and python_version < "3.13" +python-decouple==3.8 ; python_version >= "3.11" and python_version < "3.13" +python-steamgriddb==1.0.5 ; python_version >= "3.11" and python_version < "3.13" +requests==2.31.0 ; python_version >= "3.11" and python_version < "3.13" +urllib3==2.2.1 ; python_version >= "3.11" and python_version < "3.13" +vdf==3.4 ; python_version >= "3.11" and python_version < "3.13" From 6204392c3dfdceca21a17d1285b93b6a0cc759ed Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 00:44:29 -0600 Subject: [PATCH 04/15] refactor: split config into file - Lots of LOC that make the main script hard to read - Remove `main.py` as that can come later --- _config.py => config.py | 87 +++++++++- main.py | 375 ---------------------------------------- 2 files changed, 78 insertions(+), 384 deletions(-) rename _config.py => config.py (59%) delete mode 100644 main.py diff --git a/_config.py b/config.py similarity index 59% rename from _config.py rename to config.py index 7f93ee8..21622c8 100644 --- a/_config.py +++ b/config.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 +from decouple import config from pathlib import Path # paths @@ -48,19 +49,87 @@ chromedirectory = "/usr/bin/flatpak" # Define a dictionary of original folder names folder_names = { + 'Amazon Games': 'AmazonGamesLauncher', + 'Battle.net': 'Battle.netLauncher', + 'DMM Games': 'DMMGameLauncher', + 'EA App': 'TheEAappLauncher', 'Epic Games': 'EpicGamesLauncher', 'Gog Galaxy': 'GogGalaxyLauncher', - 'Ubisoft Connect': 'UplayLauncher', - 'Origin': 'OriginLauncher', - 'Battle.net': 'Battle.netLauncher', - 'EA App': 'TheEAappLauncher', - 'Amazon Games': 'AmazonGamesLauncher', - 'itch.io': 'itchioLauncher', - 'Legacy Games': 'LegacyGamesLauncher', 'Humble Bundle': 'HumbleGamesLauncher', 'IndieGala Client': 'IndieGalaLauncher', - 'Rockstar Games Launcher': 'RockstarGamesLauncher', + 'itch.io': 'itchioLauncher', + 'Legacy Games': 'LegacyGamesLauncher', 'Minecraft: Java Edition': 'MinecraftLauncher', + 'Origin': 'OriginLauncher', 'Playstation Plus': 'PlaystationPlusLauncher', - 'DMM Games': 'DMMGameLauncher', + 'Rockstar Games Launcher': 'RockstarGamesLauncher', + 'Ubisoft Connect': 'UplayLauncher', + 'VK Play': 'VKPlayLauncher', +} + +# Variables from NonSteamLaunchers.sh +steamid3 = config('steamid3', default='') +logged_in_home = config('logged_in_home') +compat_tool_name = config('compat_tool_name') +controller_config_path = config('controller_config_path') +python_version = config('python_version') +#Scanner Variables +epic_games_launcher = config('epic_games_launcher') +ubisoft_connect_launcher = config('ubisoft_connect_launcher') +ea_app_launcher = config('ea_app_launcher') +gog_galaxy_launcher = config('gog_galaxy_launcher') +bnet_launcher = config('bnet_launcher') +amazon_launcher = config('amazon_launcher') + +# Variables of the Launchers +# Define the path of the Launchers +epicshortcutdirectory = config('epicshortcutdirectory') +gogshortcutdirectory = config('gogshortcutdirectory') +uplayshortcutdirectory = config('uplayshortcutdirectory') +battlenetshortcutdirectory = config('battlenetshortcutdirectory') +eaappshortcutdirectory = config('eaappshortcutdirectory') +amazonshortcutdirectory = config('amazonshortcutdirectory') +itchioshortcutdirectory = config('itchioshortcutdirectory') +legacyshortcutdirectory = config('legacyshortcutdirectory') +humbleshortcutdirectory = config('humbleshortcutdirectory') +indieshortcutdirectory = config('indieshortcutdirectory') +rockstarshortcutdirectory = config('rockstarshortcutdirectory') +glyphshortcutdirectory = config('glyphshortcutdirectory') +minecraftshortcutdirectory = config('minecraftshortcutdirectory') +psplusshortcutdirectory = config('psplusshortcutdirectory') +vkplayhortcutdirectory = config('vkplayhortcutdirectory') + +# Streaming +chromedirectory = config('chromedirectory') +websites_str = config('custom_websites_str') +custom_websites = websites_str.split(', ') if websites_str else [] + +# Define your mapping +flavor_mapping = { + "Blizzard Arcade Collection": "RTRO", + "Call of Duty: Black Ops - Cold War": "ZEUS", + "Call of Duty: Black Ops 4": "VIPR", + "Call of Duty: Modern Warfare III": "SPOT", + "Call of Duty: Modern Warfare": "ODIN", + "Call of Duty: MW 2 Campaign Remastered": "LAZR", + "Call of Duty: Vanguard": "FORE", + "Call of Duty": "AUKS", + "Crash Bandicoot 4: It's About Time": "WLBY", + "Diablo II: Resurrected": "OSI", + "Diablo III": "D3", + "Diablo Immortal (PC)": "ANBS", + "Diablo IV": "Fen", + "Diablo": "D1", + "Hearthstone": "WTCG", + "Heroes of the Storm": "Hero", + "Overwatch 2": "Pro", + "Overwatch": "Pro", + "StarCraft 2": "S2", + "StarCraft": "S1", + "Warcraft Arclight Rumble": "GRY", + "Warcraft II: Battle.net Edition": "W2", + "Warcraft III: Reforged": "W3", + "Warcraft: Orcs & Humans": "W1", + "World of Warcraft Classic": "WoWC", + "World of Warcraft": "WoW", } diff --git a/main.py b/main.py deleted file mode 100644 index d9a4a27..0000000 --- a/main.py +++ /dev/null @@ -1,375 +0,0 @@ -#!/usr/bin/env python3 - -import binascii -import _config -import os -import re -import shutil -import sys -import vdf -from _config import folder_names -from pathlib import Path - -# Append the path to the vdf module to the system path -python_version = f"{sys.version_info.major}.{sys.version_info.minor}" -sys.path.insert(0, os.path.expanduser( - f"~/Downloads/NonSteamLaunchersInstallation/lib/python{python_version}/site-packages") -) -print(sys.path) - -# $HOME -logged_in_home = str(Path.home()) - -# TODO: test in holoiso -# Define the path of the shortcuts.vdf file -userdata_parent = Path(logged_in_home) / '.steam/root/userdata' -userdata_folder = userdata_folder.glob('*') -shortcuts_vdf_path = None -for file in userdata_folder: - if file.name == 'shortcuts.vdf': - shortcuts_vdf_path = file - break - -# TODO: ^^ -# Load the shortcuts.vdf file -with open(shortcuts_vdf_path, 'rb') as f: - shortcuts = vdf.binary_load(f) - -# Check if the 'shortcuts' key exists in the dictionary -if 'shortcuts' not in shortcuts: - # Create an empty 'shortcuts' entry - shortcuts['shortcuts'] = {} - -# Check the format of the 'shortcuts' entry -if isinstance(shortcuts['shortcuts'], dict): - # The 'shortcuts' entry is a dictionary - for key, value in shortcuts['shortcuts'].items(): - # Check the type of the value - if not isinstance(value, (str, int, dict)): - pass - -# Define the path of the Launchers -# ! Moved to config.py - -# Streaming -chromedirectory = '$chromedirectory' -websites_str = '$custom_websites_str' -custom_websites = websites_str.split(', ') - -app_ids = [] - - -def get_steam_shortcut_id(exe, appname): - unique_id = ''.join([exe, appname]) - id_int = binascii.crc32(str.encode(unique_id)) | 0x80000000 - return id_int - - -app_id_to_name = {} - - -def create_new_entry(shortcutdirectory, appname, launchoptions, startingdir): - if shortcutdirectory != '' and launchoptions != '': - exe = f'"{shortcutdirectory}"' - if shortcutdirectory != chromedirectory: - appid = get_steam_shortcut_id(exe, appname) - app_ids.append(appid) - app_id_to_name[appid] = appname - else: - appid = None - - # Create a new entry for the Steam shortcut - new_entry = { - 'appid': f'{str(appid)}' if appid is not None else '', - 'appname': appname, - 'exe': shortcutdirectory, - 'StartDir': startingdir, - 'icon': '', - 'ShortcutPath': '', - 'LaunchOptions': launchoptions, - 'IsHidden': 0, - 'AllowDesktopConfig': 1, - 'AllowOverlay': 1, - 'OpenVR': 0, - 'Devkit': 0, - 'DevkitGameID': '', - 'LastPlayTime': 0, - 'tags': { - '0': 'favorite' - } - } - - # Add the new entry to the shortcuts dictionary - entry_exists = False - if type(shortcuts['shortcuts']) == list: - for entry in shortcuts['shortcuts']: - entry.setdefault('appname', '') - entry.setdefault('exe', '') - if entry['appname'] == new_entry['appname'] and entry['exe'] == new_entry['exe']: - entry_exists = True - break - if not entry_exists: - shortcuts['shortcuts'].append(new_entry) - elif type(shortcuts['shortcuts']) == dict: - for key in shortcuts['shortcuts'].keys(): - shortcuts['shortcuts'][key].setdefault('appname', '') - shortcuts['shortcuts'][key].setdefault('exe', '') - if shortcuts['shortcuts'][key]['appname'] == new_entry['appname'] and shortcuts['shortcuts'][key]['exe'] == new_entry['exe']: - entry_exists = True - break - if not entry_exists: - # Check if the shortcuts['shortcuts'] dictionary is empty - if not shortcuts['shortcuts']: - max_key = -1 - else: - # Find the highest key value - max_key = max(int(key) for key in shortcuts['shortcuts'].keys()) - # Add the new entry with a key value one higher than the current maximum - shortcuts['shortcuts'][str(max_key + 1)] = new_entry - - -# TODO: extract logic from shell script and move either here or config.py -create_new_entry('$epicshortcutdirectory', 'Epic Games', '$epiclaunchoptions', '$epicstartingdir') -create_new_entry('$gogshortcutdirectory', 'Gog Galaxy', '$goglaunchoptions', '$gogstartingdir') -create_new_entry('$uplayshortcutdirectory', 'Ubisoft Connect', '$uplaylaunchoptions', '$uplaystartingdir') -create_new_entry('$originshortcutdirectory', 'Origin', '$originlaunchoptions', '$originstartingdir') -create_new_entry('$battlenetshortcutdirectory', 'Battle.net', '$battlenetlaunchoptions', '$battlenetstartingdir') -create_new_entry('$eaappshortcutdirectory', 'EA App', '$eaapplaunchoptions', '$eaappstartingdir') -create_new_entry('$amazonshortcutdirectory', 'Amazon Games', '$amazonlaunchoptions', '$amazonstartingdir') -create_new_entry('$itchioshortcutdirectory', 'itch.io', '$itchiolaunchoptions', '$itchiostartingdir') -create_new_entry('$legacyshortcutdirectory', 'Legacy Games', '$legacylaunchoptions', '$legacystartingdir') -create_new_entry('$humbleshortcutdirectory', 'Humble Bundle', '$humblelaunchoptions', '$humblestartingdir') -create_new_entry('$indieshortcutdirectory', 'IndieGala Client', '$indielaunchoptions', '$indiestartingdir') -create_new_entry('$rockstarshortcutdirectory', 'Rockstar Games Launcher', '$rockstarlaunchoptions', '$rockstarstartingdir') -create_new_entry('$glyphshortcutdirectory', 'Glyph', '$glyphlaunchoptions', '$glyphstartingdir') -create_new_entry('$minecraftshortcutdirectory', 'Minecraft: Java Edition', '$minecraftlaunchoptions', '$minecraftstartingdir') -create_new_entry('$psplusshortcutdirectory', 'Playstation Plus', '$pspluslaunchoptions', '$psplusstartingdir') -create_new_entry('$dmmshortcutdirectory', 'DMM Games', '$dmmlaunchoptions', '$dmmstartingdir') -create_new_entry('$chromedirectory', 'Xbox Games Pass', '$xboxchromelaunchoptions', '$chrome_startdir') -create_new_entry('$chromedirectory', 'GeForce Now', '$geforcechromelaunchoptions', '$chrome_startdir') -create_new_entry('$chromedirectory', 'Netflix', '$netlfixchromelaunchoptions', '$chrome_startdir') -create_new_entry('$chromedirectory', 'Hulu', '$huluchromelaunchoptions', '$chrome_startdir') -create_new_entry('$chromedirectory', 'Disney+', '$disneychromelaunchoptions', '$chrome_startdir') -create_new_entry('$chromedirectory', 'Amazon Prime Video', '$amazonchromelaunchoptions', '$chrome_startdir') -create_new_entry('$chromedirectory', 'Youtube', '$youtubechromelaunchoptions', '$chrome_startdir') -create_new_entry('$chromedirectory', 'Amazon Luna', '$lunachromelaunchoptions', '$chrome_startdir') - -# Iterate over each custom website -for custom_website in custom_websites: - # Check if the custom website is not an empty string - if custom_website: - # Remove any leading or trailing spaces from the custom website URL - custom_website = custom_website.strip() - - # Remove the 'http://' or 'https://' prefix and the 'www.' prefix, if present - clean_website = custom_website.replace( - 'http://', '').replace('https://', '').replace('www.', '') - - # Define a regular expression pattern to extract the game name from the URL - pattern = r'/games/([\w-]+)' - - # Use the regex to search for the game name in the custom website URL - match = re.search(pattern, custom_website) - - # Check if a match was found - if match: - # Extract the game name from the match object - game_name = match.group(1) - - # Replace hyphens with spaces - game_name = game_name.replace('-', ' ') - - # Capitalize the first letter of each word in the game name - game_name = game_name.title() - else: - # Use the entire URL as the entry name - game_name = clean_website - - # Define the launch options for this website - chromelaunch_options = f"""run - --branch=stable - --arch=x86_64 - --command=/app/bin/chrome - --file-forwarding com.google.Chrome @@u @@ - - -window-size=1280,800 - --force-device-scale-factor=1.00 - --device-scale-factor=1.00 - --kiosk https://{clean_website}/ - --chrome-kiosk-type=fullscreen - --no-first-run - --enable-features=OverlayScrollbar""" - - # Call the create_new_entry function for this website - create_new_entry('$chromedirectory', game_name, chromelaunch_options, '$chrome_startdir') - -print(f'app_id_to_name: {app_id_to_name}') - -# Save the updated shortcuts dictionary to the shortcuts.vdf file -with open('$shortcuts_vdf_path', 'wb') as f: - vdf.binary_dump(shortcuts, f) - -# Writes to the config.vdf File - -excluded_appids = [] - -# Update the config.vdf file -with open(config_vdf_path, 'r') as f: - config = vdf.load(f) - -# Check if the CompatToolMapping key exists -if 'CompatToolMapping' not in config['InstallConfigStore']['Software']['Valve']['Steam']: - # Create the CompatToolMapping key and set its value to an empty dictionary - config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'] = {} - -for app_id in app_ids: - # Check if the app_id is in the list of excluded appids - if app_id not in excluded_appids: - # Update the CompatToolMapping for this app_id - if str(app_id) in config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping']: - config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)]['name'] = '$compat_tool_name' - config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)]['config'] = '' - config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)]['priority'] = '250' - else: - config['InstallConfigStore']['Software']['Valve']['Steam']['CompatToolMapping'][str(app_id)] = {'name': '$compat_tool_name', 'config': '', 'priority': '250'} - -# Save the updated config dictionary to the config.vdf file -with open('$config_vdf_path', 'w') as f: - vdf.dump(config, f) - -# Load the configset_controller_neptune.vdf file -with open('$controller_config_path', 'r') as f: - config = vdf.load(f) - -# Add new entries for the games -for app_id in app_ids: - config['controller_config'][str(app_id)] = { - 'workshop': 'workshop_id' - } - -# TODO: convert to function -# Add new entries for the installed launchers and games -config['controller_config']['epic games'] = { - 'workshop': '2800178806' -} -config['controller_config']['gog galaxy'] = { - 'workshop': '2877189386' -} -config['controller_config']['ubisoft connect'] = { - 'workshop': '2804140248' -} -config['controller_config']['amazon games'] = { - 'workshop': '2871935783' -} -config['controller_config']['battlenet'] = { - 'workshop': '2887894308' -} -config['controller_config']['Origin'] = { - 'workshop': '2856043168' -} -config['controller_config']['rockstar games launcher'] = { - 'workshop': '1892570391' -} -config['controller_config']['indiegala'] = { - 'template': 'controller_neptune_webbrowser.vdf' -} -config['controller_config']['legacy games'] = { - 'template': 'controller_neptune_webbrowser.vdf' -} -config['controller_config']['ea app'] = { - 'workshop': '2899822740' -} -config['controller_config']['itchio'] = { - 'workshop': '2845891813' -} -config['controller_config']['humble games collection'] = { - 'workshop': '2883791560' -} -config['controller_config']['minecraft java edition'] = { - 'workshop': '2980553929' -} -config['controller_config']['playstation plus'] = { - 'workshop': 'controller_neptune_webbrowser.vdf' -} -config['controller_config']['glyph'] = { - 'template': 'controller_neptune_webbrowser.vdf' -} -config['controller_config']['dmm games'] = { - 'template': 'controller_neptune_webbrowser.vdf' -} -config['controller_config']['amazon prime video'] = { - 'workshop': '2970669392' -} -config['controller_config']['hulu'] = { - 'workshop': '2970669392' -} -config['controller_config']['netflix'] = { - 'workshop': '2970669392' -} -config['controller_config']['disney+'] = { - 'workshop': '2970669392' -} -config['controller_config']['youtube'] = { - 'workshop': '2970669392' -} -config['controller_config']['geforce now'] = { - 'template': 'controller_neptune_gamepad+mouse.vdf' -} -config['controller_config']['amazon luna'] = { - 'template': 'controller_neptune_gamepad+mouse.vdf' -} - -# Save the updated config dictionary to the configset_controller_neptune.vdf file -with open('$controller_config_path', 'w') as f: - vdf.dump(config, f) - -# Define the path to the compatdata directory -compatdata_dir = '${logged_in_home}/.local/share/Steam/steamapps/compatdata' - -# Iterate over each launcher in the folder_names dictionary -for launcher_name, folder in folder_names.items(): - # Define the current path of the folder - current_path = os.path.join(compatdata_dir, folder) - - # Check if the folder exists - if os.path.exists(current_path): - print(f'{launcher_name}: {folder} exists') - # Get the app ID for this launcher from the app_id_to_name dictionary - appid = next(key for key, value in app_id_to_name.items() if value == launcher_name) - - # Define the new path of the folder - new_path = os.path.join(compatdata_dir, str(appid)) - - # Rename the folder - os.rename(current_path, new_path) - - # Define the path of the symbolic link - symlink_path = os.path.join(compatdata_dir, folder) - - # Create a symbolic link to the renamed folder - os.symlink(new_path, symlink_path) - else: - print(f'{launcher_name}: {folder} does not exist') - -# Check if the NonSteamLaunchers folder exists -if os.path.exists(os.path.join(compatdata_dir, 'NonSteamLaunchers')): - # Get the first app ID from the app_ids list - first_app_id = app_ids[0] - - # Define the current path of the NonSteamLaunchers folder - current_path = os.path.join(compatdata_dir, 'NonSteamLaunchers') - - # Check if NonSteamLaunchers is already a symbolic link - if os.path.islink(current_path): - print('NonSteamLaunchers is already a symbolic link') - else: - # Define the new path of the NonSteamLaunchers folder - new_path = os.path.join(compatdata_dir, str(first_app_id)) - - # Move the NonSteamLaunchers folder to the new path - shutil.move(current_path, new_path) - - # Define the path of the symbolic link - symlink_path = os.path.join(compatdata_dir, 'NonSteamLaunchers') - - # Create a symbolic link to the renamed NonSteamLaunchers folder - os.symlink(new_path, symlink_path) From 84d147468e93912bf4f2865e55faa68853230e8f Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 00:45:59 -0600 Subject: [PATCH 05/15] ci: add automatic semver Will need to supply personal access token as repo secret `RELEASE_PLEASE_TOKEN` --- .github/workflows/release-please.yml | 25 +++++++++++++++++++++++++ .release-please-manifest.json | 3 +++ release-please-config.json | 13 +++++++++++++ 3 files changed, 41 insertions(+) create mode 100644 .github/workflows/release-please.yml create mode 100644 .release-please-manifest.json create mode 100644 release-please-config.json diff --git a/.github/workflows/release-please.yml b/.github/workflows/release-please.yml new file mode 100644 index 0000000..61be601 --- /dev/null +++ b/.github/workflows/release-please.yml @@ -0,0 +1,25 @@ +name: Release Please + +on: + push: + branches: + - 'main' + +permissions: + contents: write + pull-requests: write + +jobs: + release-please: + runs-on: ubuntu-latest + + steps: + - name: Release with release-please + uses: google-github-actions/release-please-action@v4 + with: + # PAT with write access to the repository + token: ${{ secrets.RELEASE_PLEASE_TOKEN }} + # optional. customize path to release-please-config.json + config-file: release-please-config.json + # optional. customize path to .release-please-manifest.json + manifest-file: .release-please-manifest.json diff --git a/.release-please-manifest.json b/.release-please-manifest.json new file mode 100644 index 0000000..573f090 --- /dev/null +++ b/.release-please-manifest.json @@ -0,0 +1,3 @@ +{ + ".": "3.8.0" +} diff --git a/release-please-config.json b/release-please-config.json new file mode 100644 index 0000000..624fd83 --- /dev/null +++ b/release-please-config.json @@ -0,0 +1,13 @@ +{ + "packages": { + ".": { + "changelog-path": "CHANGELOG.md", + "release-type": "python", + "bump-minor-pre-major": false, + "bump-patch-for-minor-pre-major": false, + "draft": false, + "prerelease": false + } + }, + "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json" +} \ No newline at end of file From 57e24bdb77f9a04508aac29d7020e9c562081b4a Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 00:46:54 -0600 Subject: [PATCH 06/15] chore: vscode extension recommendations Nudge contributors to use vscode extensions already present in devcontainer --- .vscode/extensions.json | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) create mode 100644 .vscode/extensions.json diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000..7e5c33f --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,18 @@ +{ + "recommendations": [ + "aaron-bond.better-comments", + "codezombiech.gitignore", + "eamodio.gitlens", + "EditorConfig.EditorConfig", + "GitHub.copilot-chat", + "GitHub.copilot", + "mads-hartmann.bash-ide-vscode", + "ms-azuretools.vscode-docker", + "ms-python.python", + "ms-vscode.atom-keybindings", + "ms-vsliveshare.vsliveshare", + "redhat.vscode-yaml", + "timonwong.shellcheck", + "yzhang.markdown-all-in-one" + ] +} From d4bf5ed0261b4b71acb5c796351497082a16dd79 Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 00:48:48 -0600 Subject: [PATCH 07/15] ci: add pre-commit hooks ruff foremost among them. Otherwise better code quality with minimal annoyances locally --- .pre-commit-config.yaml | 43 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 .pre-commit-config.yaml diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..8c59274 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,43 @@ +fail_fast: true + +repos: + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.2.2 + hooks: + - id: ruff + args: [--fix, --exit-non-zero-on-fix] + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v4.5.0 + hooks: + - id: check-yaml + - id: check-added-large-files + args: ['--maxkb=1024'] + - id: check-docstring-first + exclude: | + (?x)^( + hello.py + )$ + - id: check-executables-have-shebangs + - id: check-merge-conflict + - id: check-shebang-scripts-are-executable + - id: check-symlinks + - id: check-toml + - id: check-yaml + args: [--unsafe] + - id: debug-statements + - id: destroyed-symlinks + - id: detect-private-key + - id: end-of-file-fixer + - id: fix-byte-order-marker + - id: mixed-line-ending + - id: pretty-format-json + # https://pre-commit.com/#regular-expressions + exclude: | + (?x)^( + .devcontainer/devcontainer.json| + .vscode/launch.json| + .vscode/settings.json| + .vscode/extensions.json + )$ + args: ['--autofix', '--indent=2', '--no-sort-keys'] + - id: requirements-txt-fixer From b8f72f2dd1a542d08225e9ffbdebd1187262e468 Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 00:49:12 -0600 Subject: [PATCH 08/15] docs: formatting and pre-commit hooks --- README.md | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/README.md b/README.md index 2e5b130..bc20034 100644 --- a/README.md +++ b/README.md @@ -170,6 +170,36 @@ source .venv/bin/activate python -m pip install -r requirements.txt ``` +### Pre-commit hooks + +Pre-commit hooks are installed via `pre-commit` and are run automatically on `git commit`. + +Most importantly, `ruff` is used to lint all python code. + +* Install [pre-commit](https://pre-commit.com/#install) +* Install pre-commit hooks + ```bash + pre-commit install + ``` +* Trigger pre-commit hooks automatically on `git commit` + ```bash + git add . + git commit -m "commit message" + ``` + +### Formatting + +> **TL;DR**: The [Ruff formatter](https://astral.sh/blog/the-ruff-formatter) is an extremely fast Python formatter, written in Rust. It’s over 30x faster than Black and 100x faster than YAPF, formatting large-scale Python projects in milliseconds — all while achieving >99.9% Black compatibility. + +* While it runs automatically on commits, it can also be run manually + ```bash + # check for errors + ruff check . + + # fix (some) errors automatically + ruff check . --fix + ``` + ### Additional tooling Additional tooling includes but is not limited to: From 8ead8b0299ebeabdb2aa7607d1154009f121662e Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 00:50:22 -0600 Subject: [PATCH 09/15] Revert "chore: remove modules" This reverts commit f6c291dd3da7026329374a97ec008f2693c6a664. --- Modules/requests/__init__.py | 180 +++ .../__pycache__/__init__.cpython-311.pyc | Bin 0 -> 6262 bytes .../__pycache__/__version__.cpython-311.pyc | Bin 0 -> 548 bytes .../_internal_utils.cpython-311.pyc | Bin 0 -> 2112 bytes .../__pycache__/adapters.cpython-311.pyc | Bin 0 -> 23104 bytes .../requests/__pycache__/api.cpython-311.pyc | Bin 0 -> 7465 bytes .../requests/__pycache__/auth.cpython-311.pyc | Bin 0 -> 14592 bytes .../__pycache__/certs.cpython-311.pyc | Bin 0 -> 682 bytes .../__pycache__/compat.cpython-311.pyc | Bin 0 -> 2066 bytes .../__pycache__/cookies.cpython-311.pyc | Bin 0 -> 27072 bytes .../__pycache__/exceptions.cpython-311.pyc | Bin 0 -> 8474 bytes .../__pycache__/hooks.cpython-311.pyc | Bin 0 -> 1212 bytes .../__pycache__/models.cpython-311.pyc | Bin 0 -> 38662 bytes .../__pycache__/packages.cpython-311.pyc | Bin 0 -> 1296 bytes .../__pycache__/sessions.cpython-311.pyc | Bin 0 -> 29655 bytes .../__pycache__/status_codes.cpython-311.pyc | Bin 0 -> 6199 bytes .../__pycache__/structures.cpython-311.pyc | Bin 0 -> 6184 bytes .../__pycache__/utils.cpython-311.pyc | Bin 0 -> 40206 bytes Modules/requests/__version__.py | 14 + Modules/requests/_internal_utils.py | 50 + Modules/requests/adapters.py | 538 ++++++++ Modules/requests/api.py | 157 +++ Modules/requests/auth.py | 315 +++++ Modules/requests/certs.py | 17 + Modules/requests/compat.py | 79 ++ Modules/requests/cookies.py | 561 ++++++++ Modules/requests/exceptions.py | 141 ++ Modules/requests/help.py | 134 ++ Modules/requests/hooks.py | 33 + Modules/requests/models.py | 1034 ++++++++++++++ Modules/requests/packages.py | 28 + Modules/requests/sessions.py | 833 ++++++++++++ Modules/requests/status_codes.py | 128 ++ Modules/requests/structures.py | 99 ++ Modules/requests/utils.py | 1094 +++++++++++++++ Modules/urllib3/__init__.py | 149 +++ .../__pycache__/__init__.cpython-311.pyc | Bin 0 -> 5338 bytes .../_base_connection.cpython-311.pyc | Bin 0 -> 7123 bytes .../__pycache__/_collections.cpython-311.pyc | Bin 0 -> 26027 bytes .../_request_methods.cpython-311.pyc | Bin 0 -> 8528 bytes .../__pycache__/_version.cpython-311.pyc | Bin 0 -> 247 bytes .../__pycache__/connection.cpython-311.pyc | Bin 0 -> 33075 bytes .../connectionpool.cpython-311.pyc | Bin 0 -> 41191 bytes .../__pycache__/exceptions.cpython-311.pyc | Bin 0 -> 19213 bytes .../__pycache__/fields.cpython-311.pyc | Bin 0 -> 13005 bytes .../__pycache__/filepost.cpython-311.pyc | Bin 0 -> 3858 bytes .../__pycache__/poolmanager.cpython-311.pyc | Bin 0 -> 25554 bytes .../__pycache__/response.cpython-311.pyc | Bin 0 -> 49583 bytes Modules/urllib3/_base_connection.py | 172 +++ Modules/urllib3/_collections.py | 483 +++++++ Modules/urllib3/_request_methods.py | 217 +++ Modules/urllib3/_version.py | 4 + Modules/urllib3/connection.py | 905 +++++++++++++ Modules/urllib3/connectionpool.py | 1182 +++++++++++++++++ Modules/urllib3/contrib/__init__.py | 0 .../__pycache__/__init__.cpython-311.pyc | Bin 0 -> 168 bytes .../contrib/__pycache__/socks.cpython-311.pyc | Bin 0 -> 8724 bytes Modules/urllib3/contrib/pyopenssl.py | 548 ++++++++ Modules/urllib3/contrib/socks.py | 230 ++++ Modules/urllib3/exceptions.py | 318 +++++ Modules/urllib3/fields.py | 345 +++++ Modules/urllib3/filepost.py | 89 ++ Modules/urllib3/poolmanager.py | 638 +++++++++ Modules/urllib3/py.typed | 2 + Modules/urllib3/response.py | 1130 ++++++++++++++++ Modules/urllib3/util/__init__.py | 42 + .../util/__pycache__/__init__.cpython-311.pyc | Bin 0 -> 1201 bytes .../__pycache__/connection.cpython-311.pyc | Bin 0 -> 5053 bytes .../util/__pycache__/proxy.cpython-311.pyc | Bin 0 -> 1259 bytes .../util/__pycache__/request.cpython-311.pyc | Bin 0 -> 8875 bytes .../util/__pycache__/response.cpython-311.pyc | Bin 0 -> 3333 bytes .../util/__pycache__/retry.cpython-311.pyc | Bin 0 -> 21043 bytes .../util/__pycache__/ssl_.cpython-311.pyc | Bin 0 -> 17407 bytes .../ssl_match_hostname.cpython-311.pyc | Bin 0 -> 6228 bytes .../__pycache__/ssltransport.cpython-311.pyc | Bin 0 -> 14605 bytes .../util/__pycache__/timeout.cpython-311.pyc | Bin 0 -> 12218 bytes .../util/__pycache__/url.cpython-311.pyc | Bin 0 -> 17754 bytes .../util/__pycache__/util.cpython-311.pyc | Bin 0 -> 2149 bytes .../util/__pycache__/wait.cpython-311.pyc | Bin 0 -> 3720 bytes Modules/urllib3/util/connection.py | 137 ++ Modules/urllib3/util/proxy.py | 43 + Modules/urllib3/util/request.py | 256 ++++ Modules/urllib3/util/response.py | 101 ++ Modules/urllib3/util/retry.py | 529 ++++++++ Modules/urllib3/util/ssl_.py | 514 +++++++ Modules/urllib3/util/ssl_match_hostname.py | 159 +++ Modules/urllib3/util/ssltransport.py | 280 ++++ Modules/urllib3/util/timeout.py | 279 ++++ Modules/urllib3/util/url.py | 471 +++++++ Modules/urllib3/util/util.py | 42 + Modules/urllib3/util/wait.py | 124 ++ Modules/vdf/LICENSE | 19 + Modules/vdf/__init__.py | 519 ++++++++ .../vdf/__pycache__/__init__.cpython-311.pyc | Bin 0 -> 25255 bytes 94 files changed, 15362 insertions(+) create mode 100644 Modules/requests/__init__.py create mode 100644 Modules/requests/__pycache__/__init__.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/__version__.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/_internal_utils.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/adapters.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/api.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/auth.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/certs.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/compat.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/cookies.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/exceptions.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/hooks.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/models.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/packages.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/sessions.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/status_codes.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/structures.cpython-311.pyc create mode 100644 Modules/requests/__pycache__/utils.cpython-311.pyc create mode 100644 Modules/requests/__version__.py create mode 100644 Modules/requests/_internal_utils.py create mode 100644 Modules/requests/adapters.py create mode 100644 Modules/requests/api.py create mode 100644 Modules/requests/auth.py create mode 100644 Modules/requests/certs.py create mode 100644 Modules/requests/compat.py create mode 100644 Modules/requests/cookies.py create mode 100644 Modules/requests/exceptions.py create mode 100644 Modules/requests/help.py create mode 100644 Modules/requests/hooks.py create mode 100644 Modules/requests/models.py create mode 100644 Modules/requests/packages.py create mode 100644 Modules/requests/sessions.py create mode 100644 Modules/requests/status_codes.py create mode 100644 Modules/requests/structures.py create mode 100644 Modules/requests/utils.py create mode 100644 Modules/urllib3/__init__.py create mode 100644 Modules/urllib3/__pycache__/__init__.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/_base_connection.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/_collections.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/_request_methods.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/_version.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/connection.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/connectionpool.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/exceptions.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/fields.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/filepost.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/poolmanager.cpython-311.pyc create mode 100644 Modules/urllib3/__pycache__/response.cpython-311.pyc create mode 100644 Modules/urllib3/_base_connection.py create mode 100644 Modules/urllib3/_collections.py create mode 100644 Modules/urllib3/_request_methods.py create mode 100644 Modules/urllib3/_version.py create mode 100644 Modules/urllib3/connection.py create mode 100644 Modules/urllib3/connectionpool.py create mode 100644 Modules/urllib3/contrib/__init__.py create mode 100644 Modules/urllib3/contrib/__pycache__/__init__.cpython-311.pyc create mode 100644 Modules/urllib3/contrib/__pycache__/socks.cpython-311.pyc create mode 100644 Modules/urllib3/contrib/pyopenssl.py create mode 100644 Modules/urllib3/contrib/socks.py create mode 100644 Modules/urllib3/exceptions.py create mode 100644 Modules/urllib3/fields.py create mode 100644 Modules/urllib3/filepost.py create mode 100644 Modules/urllib3/poolmanager.py create mode 100644 Modules/urllib3/py.typed create mode 100644 Modules/urllib3/response.py create mode 100644 Modules/urllib3/util/__init__.py create mode 100644 Modules/urllib3/util/__pycache__/__init__.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/connection.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/proxy.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/request.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/response.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/retry.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/ssl_.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/ssl_match_hostname.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/ssltransport.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/timeout.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/url.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/util.cpython-311.pyc create mode 100644 Modules/urllib3/util/__pycache__/wait.cpython-311.pyc create mode 100644 Modules/urllib3/util/connection.py create mode 100644 Modules/urllib3/util/proxy.py create mode 100644 Modules/urllib3/util/request.py create mode 100644 Modules/urllib3/util/response.py create mode 100644 Modules/urllib3/util/retry.py create mode 100644 Modules/urllib3/util/ssl_.py create mode 100644 Modules/urllib3/util/ssl_match_hostname.py create mode 100644 Modules/urllib3/util/ssltransport.py create mode 100644 Modules/urllib3/util/timeout.py create mode 100644 Modules/urllib3/util/url.py create mode 100644 Modules/urllib3/util/util.py create mode 100644 Modules/urllib3/util/wait.py create mode 100644 Modules/vdf/LICENSE create mode 100644 Modules/vdf/__init__.py create mode 100644 Modules/vdf/__pycache__/__init__.cpython-311.pyc diff --git a/Modules/requests/__init__.py b/Modules/requests/__init__.py new file mode 100644 index 0000000..300a16c --- /dev/null +++ b/Modules/requests/__init__.py @@ -0,0 +1,180 @@ +# __ +# /__) _ _ _ _ _/ _ +# / ( (- (/ (/ (- _) / _) +# / + +""" +Requests HTTP Library +~~~~~~~~~~~~~~~~~~~~~ + +Requests is an HTTP library, written in Python, for human beings. +Basic GET usage: + + >>> import requests + >>> r = requests.get('https://www.python.org') + >>> r.status_code + 200 + >>> b'Python is a programming language' in r.content + True + +... or POST: + + >>> payload = dict(key1='value1', key2='value2') + >>> r = requests.post('https://httpbin.org/post', data=payload) + >>> print(r.text) + { + ... + "form": { + "key1": "value1", + "key2": "value2" + }, + ... + } + +The other HTTP methods are supported - see `requests.api`. Full documentation +is at . + +:copyright: (c) 2017 by Kenneth Reitz. +:license: Apache 2.0, see LICENSE for more details. +""" + +import warnings + +import urllib3 + +from .exceptions import RequestsDependencyWarning + +try: + from charset_normalizer import __version__ as charset_normalizer_version +except ImportError: + charset_normalizer_version = None + +try: + from chardet import __version__ as chardet_version +except ImportError: + chardet_version = None + + +def check_compatibility(urllib3_version, chardet_version, charset_normalizer_version): + urllib3_version = urllib3_version.split(".") + assert urllib3_version != ["dev"] # Verify urllib3 isn't installed from git. + + # Sometimes, urllib3 only reports its version as 16.1. + if len(urllib3_version) == 2: + urllib3_version.append("0") + + # Check urllib3 for compatibility. + major, minor, patch = urllib3_version # noqa: F811 + major, minor, patch = int(major), int(minor), int(patch) + # urllib3 >= 1.21.1 + assert major >= 1 + if major == 1: + assert minor >= 21 + + # Check charset_normalizer for compatibility. + if chardet_version: + major, minor, patch = chardet_version.split(".")[:3] + major, minor, patch = int(major), int(minor), int(patch) + # chardet_version >= 3.0.2, < 6.0.0 + assert (3, 0, 2) <= (major, minor, patch) < (6, 0, 0) + elif charset_normalizer_version: + major, minor, patch = charset_normalizer_version.split(".")[:3] + major, minor, patch = int(major), int(minor), int(patch) + # charset_normalizer >= 2.0.0 < 4.0.0 + assert (2, 0, 0) <= (major, minor, patch) < (4, 0, 0) + else: + raise Exception("You need either charset_normalizer or chardet installed") + + +def _check_cryptography(cryptography_version): + # cryptography < 1.3.4 + try: + cryptography_version = list(map(int, cryptography_version.split("."))) + except ValueError: + return + + if cryptography_version < [1, 3, 4]: + warning = "Old version of cryptography ({}) may cause slowdown.".format( + cryptography_version + ) + warnings.warn(warning, RequestsDependencyWarning) + + +# Check imported dependencies for compatibility. +try: + check_compatibility( + urllib3.__version__, chardet_version, charset_normalizer_version + ) +except (AssertionError, ValueError): + warnings.warn( + "urllib3 ({}) or chardet ({})/charset_normalizer ({}) doesn't match a supported " + "version!".format( + urllib3.__version__, chardet_version, charset_normalizer_version + ), + RequestsDependencyWarning, + ) + +# Attempt to enable urllib3's fallback for SNI support +# if the standard library doesn't support SNI or the +# 'ssl' library isn't available. +try: + try: + import ssl + except ImportError: + ssl = None + + if not getattr(ssl, "HAS_SNI", False): + from urllib3.contrib import pyopenssl + + pyopenssl.inject_into_urllib3() + + # Check cryptography version + from cryptography import __version__ as cryptography_version + + _check_cryptography(cryptography_version) +except ImportError: + pass + +# urllib3's DependencyWarnings should be silenced. +from urllib3.exceptions import DependencyWarning + +warnings.simplefilter("ignore", DependencyWarning) + +# Set default logging handler to avoid "No handler found" warnings. +import logging +from logging import NullHandler + +from . import packages, utils +from .__version__ import ( + __author__, + __author_email__, + __build__, + __cake__, + __copyright__, + __description__, + __license__, + __title__, + __url__, + __version__, +) +from .api import delete, get, head, options, patch, post, put, request +from .exceptions import ( + ConnectionError, + ConnectTimeout, + FileModeWarning, + HTTPError, + JSONDecodeError, + ReadTimeout, + RequestException, + Timeout, + TooManyRedirects, + URLRequired, +) +from .models import PreparedRequest, Request, Response +from .sessions import Session, session +from .status_codes import codes + +logging.getLogger(__name__).addHandler(NullHandler()) + +# FileModeWarnings go off per the default. +warnings.simplefilter("default", FileModeWarning, append=True) diff --git a/Modules/requests/__pycache__/__init__.cpython-311.pyc b/Modules/requests/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4d95750823499161d1db30b840299593d0c6f31d GIT binary patch literal 6262 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 literal 0 HcmV?d00001 diff --git a/Modules/requests/__pycache__/adapters.cpython-311.pyc b/Modules/requests/__pycache__/adapters.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..03d8a4e3bec4c79ad28cdb71487adff67b45dff6 GIT binary patch literal 23104 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

Y}E;{K5gJQNI6q*CxuHLkS& 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 literal 0 HcmV?d00001 diff --git a/Modules/requests/__pycache__/api.cpython-311.pyc b/Modules/requests/__pycache__/api.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f77c3fcbf98fd5438ed2edb36e634f1400beafd3 GIT binary patch literal 7465 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 SoIAsni}y*+7mvs%^!k4VEqS^C literal 0 HcmV?d00001 diff --git a/Modules/requests/__pycache__/certs.cpython-311.pyc b/Modules/requests/__pycache__/certs.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..89b279a693231b2a420d1acbead0b33cfc75c498 GIT binary patch literal 682 zcmY*XL2DE-6i#MlZH@M*usyv?sSC>t-bD~m5b7SZr(TA1@@6;eOtK~!bv?)m3M+UN z{09{&{+HrO_9S}I+d^+WnaoZ>U-H6xZ{GXzzP$Oov%`p&-|wd4D<$Mta4se3jPnC; zd?JDz5kW;%(KAD>PrsH%7 zr8dCfK&s{?2x*;>$BmO(K^w2R@>qhQdM=GtH7Yl3K?|;+m~b`5_Hs`_D!HjE;YH~9 z)&QLD82cM6&baZksyXXA6oGI@lKlyNuL% zCx;xxYxMEn%t+t&z<-oFbVCigrv3+MV zpu6U}M+mdFkNvTZDW&Txj3#Rmj+=z;o{|2)`$v3j`RZHTKa2a{ldFpd%f02^`~465 UZ$@uNi*~JJlI;4=Cj6p*0d$nmN&o-= literal 0 HcmV?d00001 diff --git a/Modules/requests/__pycache__/compat.cpython-311.pyc b/Modules/requests/__pycache__/compat.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..173fbf490b049f9e03256db1acef0caf68c1be97 GIT binary patch literal 2066 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 literal 0 HcmV?d00001 diff --git a/Modules/requests/__pycache__/hooks.cpython-311.pyc b/Modules/requests/__pycache__/hooks.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..24b4d1fd278d3cd58711f5721322b3aa44b6e1f6 GIT binary patch literal 1212 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�JLDuP;?nAGeg3wZA?>w^wk?N(J51jzcx-nSnqFO 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 literal 0 HcmV?d00001 diff --git a/Modules/requests/__pycache__/sessions.cpython-311.pyc b/Modules/requests/__pycache__/sessions.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4147462b28e58fd73ae52b5dc5e3d3f6cf8f21a8 GIT binary patch literal 29655 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 M>2lMo{^(Tof0LL>@&Et; literal 0 HcmV?d00001 diff --git a/Modules/requests/__pycache__/structures.cpython-311.pyc b/Modules/requests/__pycache__/structures.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..56925ddf07d71ba245937e9999d7329603331360 GIT binary patch literal 6184 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 z%0A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 literal 0 HcmV?d00001 diff --git a/Modules/urllib3/__pycache__/exceptions.cpython-311.pyc b/Modules/urllib3/__pycache__/exceptions.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5a27bfc98a0b9c15a5a5b6912b06290434befb97 GIT binary patch literal 19213 zcmc&*Yit}xa-P|pC6{lCq$$yQjh-YeYAIQkY*DiOpeRbVM9HM&vw4@SmODdot$pxj zb|sM~UzEUznZ!w$OAhA6=R^q(J}b_{36S9OD+lC9fcyx?2L)jkIKV;R9|rP+0tMut zKgn0sGqdxeWG07XcBZzstEaoVx~jXny7q@HEsYYcZ+4CAclS!tzta!rsuKx$tvMk{ z?@OAb$$6 zdV%ZHdr`0d%|6EV1N)TT7kIOuaR-1K2=V+W#vKGM6~Y~0+#qm=Lbw6O9R}`c{a}ci z6l0G7`;49nP&3H5qre>t;SMqGS>T=vaqckVjsrKOcL(ZxnsFz9JE=b%z#U=S^T3@7 z;htgK3&6b?!X0JYOTfJx!X0DWFmR_sv^>kW5#Y|~s(vsqPR}uR6xg$&9v)}hIpAK= zyYz;@n@PsL3hem^>=0uw06P|{_XOiE0(VJ2sUHf|`#fV`19lwL`sa;PjGF-Na;Vl9 z7Iufl{4jBsc4SjcgqFcG&3{$X?n*gHl*6}+ru9uDZtWYQc zsWx2lS_k0!k}gfknuJ+d#*9pK#;Xlf$%tW;jD+@||X^p3PY0l*z=RbW@(J!}zsS8%P+$_zeceZ@OftI*qKU zW-~mPH*y%uqMA|X@KUO((3g=!qt*I?kjrY^EF0B2LoZj1VpSO{K>%&?h(rksy@cQL z+7uGsmEV_c$+x65VfZS0%6^2LPwae2x)XDgp2RKr0~igrVjoB!#y^6veqswOT7U^L zA>ECQEyRY@{Q}u-Ia|!$i^4ZWl|L?(@(l)=vpNUy<6z=cEictPcO6q+?GCX>wNFq%eSny16J|? zQ`lc8ctnHEj54-TY8!#=0C!^|y^qrMMl0o0T}C^BO$3O6Mn6Ec#pZEV&*wo^FY=hu z7X_!uj4}x9B*fPMz*^_Cq8zuBVG0AU{kgg#MASv>A#%iucd)XeJC z!0ObZHTl%3wc0$cf3u>SWuZ~eMQD`EdJ_|4rmW6puInlUu9VGX%9t>(jGs4CHD*`i znArrgNj_^F&ysjL7o}M|CXryZiv91@>Q?+Ch}esB8JgXUX1s$zIF3#psd1`8364 z#a>_nnnHTxYLzBU$4PUH!zkDvW4#f5>qCY|by#Q@HV5c-)aGd_OfqDv%^l^A_Ji3^ z6>H~FtL>TcySW7MW6vJlSBdmes#Kd_a`p3sJIa>d3%<4rIxoTE7%DL%W7DBF0XL5N{rIn

ONQZLJC9fR<^e&NCuzrv+ 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 Yb$RA*)Z@hGuzBDYnf18%9DIZ2$lO literal 0 HcmV?d00001 diff --git a/Modules/urllib3/__pycache__/fields.cpython-311.pyc b/Modules/urllib3/__pycache__/fields.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4c11f871c83a9b3db0ed9cba97406159abc02d9 GIT binary patch literal 13005 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 UUv~4@-mT$dmjBH*rEJ^(8#J8arvLx| literal 0 HcmV?d00001 diff --git a/Modules/urllib3/__pycache__/filepost.cpython-311.pyc b/Modules/urllib3/__pycache__/filepost.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c58f064b8441b28bcf631a74af61ceb778a4bdf8 GIT binary patch literal 3858 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 literal 0 HcmV?d00001 diff --git a/Modules/urllib3/__pycache__/response.cpython-311.pyc b/Modules/urllib3/__pycache__/response.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..464effe19ed0fd6041e18e98e880d3e64be4e1ce GIT binary patch literal 49583 zcmeIbdvqIDdM8+g7XcC^KmvTfz=uSU6knpA)RQ75>q)sK+HTW!QxFT3D3Kt$09qnV z*|Os#w1=~%6(yp3)f1-IoyckTv@+?QcruxZ?auaO_UxPh+{zG(bGW1IL?`PrI~!`{ z&N$jLXZQErTUDq6KwIv~?B;LBe$V^e-^tI<6>xpqe>U{&9YOf_^rBrZ z{vbYj)hY~0;hvb$}_&hCyO2fODC<*>VR$jR=mAs4&n z4&}0Y-cTOy)^Ybl{!l(k(>7i(;TiI>XFHw?hl<# z>(JJTwxKrWS1{f_(J|C9(K*yP(KXaHv2AGEME6kl#P*@>6FY`>Oza%mIk9VK*Tn9j z-7LOme9uJBP|w8Pp}p+gJHBsX|ImI>2)QmF(CQ(((HDi|u8D&~2U)D5@k0~6L%pJa zwsc%Rti=oUnd?8)ZxNmnB;T8YAF+`vLy>HFT7Pl_IPx?W?C) zNI60(GQK(%Dt*0xg;yfHDkJ=Os6q{|MtDs|_zCuHEy4mBVJD?lsqszQ&?y#Y6XI-6 zE7@rl(u9yLA?xJWH~1^Z~cruZ5ESx!Ekso8jOxjh9d)b zFBq8&M?=@56TxusVo0VK#|8(VJ{^ig@QznEy`Bw4rtks1=S0UQLX*?cS>Ly|ywKUU z=cU%>7u&U`W{XUt{Ieo*XuRSB+jMkn9QWMe!RMboGJN<<|MPe&pk$AQf>KEC9~+4_ zTa)g?!AR)bxl>1Ec~a)#eUssEXoSj|%%}KAu8oAI=(RaFS$23*ni-gk9*ah&#>X!7 zO-@XqRu{%Y$-Ms1$fOkF>A2W;JjvtX5yTn~MMGziakA)m_~qdEnACS^I(+3+D10$` zDVeYO@scI;pOz=1lOvPkJTWhQH^}SHeTuY}K}lFTAt~w9D$#67y2m2Jqf^5pl0F>XUrTe`KZ432!eT?dPDp`9QZ&?`p^K!sc|QeO-N#`^MNI4i-g8U_`J=-9=M$V?;}nvgoCBO$qCS{_G#c6VqE)jltDyr-F_kheri)ZU}1yb@74*rJy0^YrX2Y^F4+L@>X)%;0%0VW33?9lTQOV^z?xx_1tVvI){hD!HLlDFec0J z#H2JmPS5V);crg|$9ag{O5b+Uw>)K55;;J=Cky&RqvOG7NF95u!b#h}BxZKjJ~_)0 zm&7??7*G6?EO^snN9~%wAY8^M<(GL}BEC%vkpvXPIxxtpg=Wqj9vzb-(P2!wqF2 zXR3gg^_~RA@*;2mQ?Ex=43gqsc4%LjzR%Ho^8|ApjpK!Cvq8%k#}De8!m%V%$ww^D zV+=I_cQn>V!xXi9vt{6Dvs2!SGRX(YVRMxxqr4wZ(jFo>BoqFVbe-<~=J0cej}M+} zwz74FEe}a|Y6OO)2=zxGz!w{q*lc;)kV{3UX%l$>2ZPSz!*q9*C48mxC+~ZF3$M{@ zJ6>y{n>cwHl=jieV*uIF8zJ6G)Otb zymk6-Js&xI@x>RB2GsNqT6-IWPa1mq3ap>jl=q32Pj@--{8Q1@muvrNt_{!GmzeGN z7}Loxjh6Mnjv)OqFDd5)1`M!fv(BY8IDK(o3-hc$t&COof(rkaLI}9S+Dl>6L&C2L-$7iJVjTk30?M zhW>{}w>Pf~W+&HgN2i&ct)jh-Kt@)FXGU3!;9tMgCKMl4z{>z0M4%%Updwa)1RGXj zd(!*V?AVkF56%G@4Kb`yrs@6}tzZMq>2*%Jj~+jJZgBYYk<*8doK5DR89a96ton8? z=|1;d@2OK~o*VA(9qdhSkCRAHCTAS~k!m=p_DJ~rH%=w|#Wzl~ryHkkoZ^+E_@>IK z3#<6(Yr(!eLq$2Hr@l1}N*g>d&&5YkJlqzHm{w{9mP88GuFLu=KMSvnbq}fW%d}GJ zD=k(qeJy2>(K7Iv7aug|uvLmJPjVkT_%LV9M-VOP7>=;MN&|>&IL`VFHPr!O1fN9+ zX#zsVK;N=V%Rs!TC+^>?`1cYFTr1hElyu`MZytZV_3J42dN?L%sJGPrfstlzDf2`H zBr-s+D1E11DVTSKwIRXNh{p(L<}Bv+JjZwjbCjaqg3EgQY3b5E9m*0+y>1Dg2E-$r zRJ|_i&<_v~w6U?I*R9#hYJ_ET<~TZp%f z5n}+n1asxXk^sOrkSLUsWJkP@3Kd)#}Dt4{p?TY2?`X~x#%~!VMd$;FSPt0At zZt=JdiR%_ueo4aXTa4bCSuJf{DQ&&mA201vO1t9Tu0`vj^@}xt@1AubC%+`+Bw$RLL8a^< z1LCz*_6U*te^A|9EPPVj>o{C%{j}Nw*R;&hbYsgLfw5m0_R2@`b#|azXzUXPaTh4= zQ{)hE9FQ4Brh`@aIEAFa&To((bMO$M;gy0F>lTZBI}jj~&xwoJa`ZD=M>Zk~vfImG@AiLqT-kak?(J2)y)o_g zz!#DMO8 zIX5J4C=!*veA3eNW4%1Y63&hhn)~ZX`VsT$@zf!h81vci7&mZTlnjO>Am#syH=@H*U zO5=NEC)m<)u!|zY1$m|6rWPgnS1~72{(8&EuVnWJZl>coNJqy_()z)nCuw*v$3Z{n zVRM#c!xF1|KLKevXEo!g<~N2{>d6^u?ap4id#_01vW}VRAL1bsAEsrOCUdhZg=;0P zp~+GCIrz#K$suBw^En*Bsi{y{O4=?@j)hIgRxUB#hNpsZG{U~jif9=JSqjnm0Le%G zIULZ^9C4{klvXT8z-_zJyjsz|Qqg`l8n4){RBVrx@0dT4C@Q(te5;KXUZ9IC0^gB)c3``{ff6g=Ivk45rCj&&t=^y_)Bl^zPWqpMBLY;_?lwwCf0_g z)t$y5oA+Tne0>xNc)M{#(<;I)&^LxL2H1c(mEv=~0c;;Dy=7pw3T+(>OF>x*P|pO$ zB7reoV1k}YF+FJB$c1nq?rEmyZ^DUCh8mVki}GxtvGW)p_W+l>W79(+EMYbDR^7jJCovsaoRo3-AAoW81RAFX5(nm0d)Jm z@yU_kc;o;cw5WfAY$99W+z?{rr}*z)@Vi@=zx_K`zjyVwX5OEPS9B>AU3wrJ`H#h| zD1<$NF&0g_wBkjyCE?qYsBuX+1drL`tcCh1#chIvWq}poqaA;|_Ye1e9EtBesq8(8 zeBJf%8m8=Av~DZPf09?AHSZYJI+BeH^7*ZsLvd}<9Kj7 zBE*)tB2%5%I`=bt5vhd3dA+YL1;OTB^=w}8Y>s=jD4s1b=N4XxIz-CO* zZaBaI3(J=p@3hAYo0UQ^okiDX=FDR`_ut-kbKf$A5StX=rulyGA3Q#l`8NPiLxV?_ z$WNg-q8QnEe^XA zk_$Lq(SDi$M7j%!Db>Q{IIMO*5Q*##?_tU?X`@9eRU^}|#gOI0R>1=;S98M4g6uJ^ zA!$rr65vS|#43o=*Xm_nQ9xPSv=Bjf-H$JGBNnDT-Yvx@&DLyt&Q$U%LSRCi|A3-H{U=cnfis%ZXAaEunUW++v9^~Z3a!Qx_mydpDU}?Y*Kd(HVSE=Mx z#%z_We@Bq3eyLDMd_?qW8tl(!iWxSkfZ+gk$s@TK?DtA}xaUZ2-~fe5?_pBO_{MZ- zI&^q?bQJJ54~d=*0m#p^g+@omM#cz)GR2L+1r{Th!NtKzfOt~l2yj55A#q`N2c<2| z0ibq)2sClV1EZ7Ut%kyA3#Q4?VOhn6t z19Vx2dQKoXF*%JwO^)(%wW}q%1PoIBJaTDr8VJFK5HN%BaU?z+0kRSRBpL^9Fd3Md zj&5n@pPiWoN)x;`HZeUBm|*orWT+w$J}N zIWs1U zZEWB{cY@kHI|r>ieIV;7$p49iRWaOJ>rSP0A2`ZN>j9Dg zB`PX$%bmv`n_NljSU75`C!ta(r})T=2Q!S<0GcTOHwa5F6#=}^N^7mYM-YZ{rRDro3&4GbLl zA0mJG3OQ8qq!pEs37s>dUr8&b*sMRJ>hS$rib@L>s_k?y)-ohL9F5AqhAfiyt1?tDlewI0#r)Z%a$?bkvgmXOT(4#-%db=H zoY7EpGnkN^Y2k@YdG1B=?Va;G8NWPHSbPf#I#yTbT2W1`wliMTr4)6=++B(M zg2lqOpP7GVt*9zi-5xLMP>MQY?vDFKzWJQB0`J1*x5gL7A*w7WUJ~EFGJhpeR=)Jq zdwKK66Oa#{T=h4t_?zPXX2st;e`Kw)W@(xvilh%zwzO}>(-iYGC0aV}<=!j5m#ehw z{pgvG_k7&*agVZpVCm#yE@YawT{m4zEphKA#k(oy-IVb9Z{@9eH?Md%FTWD^b}QcQ zn713gi@CRQm&W4WCVGIN^1k}%rnontcmpwSK#MdU_qMP|Zr|cu+}$w$)O|4D_5wX8 zA!_k@o!}|qby;r|yuNql-ky8w)rD7M&T2M@I2Q?uJPl|}`5ibQI*1fwt9%N?!k7A) z#o)g66xW$XfXHu9q(kJqOU^BFzE4gX1@ad8k@FY$kA&ge(Ervg1w?_66R_B;NYH3> zoT9ygs1Kv#u-F3>&*(U->^1Ac1`Y>jRDcou>lapQy2M8b4678{`V9CPlK4F^u0pog z9U-e^y~q>=@os1DHtikp?1<+G<%FE6HD=U;jT(*+v_bbFb)=CO$_?2J;XJimq(&k3 z%ep$is2U;xVo1(A7U{55`le$jU+R;}fh-quj1 z3Kd-jw}xNRQ&J#H43Bh7s?YHEBgNxVLxz8GsMwI=2~y@yD^oGHiky^ANiA>Mhe~Ms z3Eodj15z8_OWE5Qgtp_YOnO@CKh}mGlj12kzCV`%c_zq_ff< z+-s$C(q7yH(xCK=bPy@k!RHWs>d^|lxHm9i-m@SsfTWUM`B_b!-zxtyT0{O7ILRD| z>*)^2ze;|@$8WZeVf%+L)=o|bIo;%JhcjCloyNNPLUd*-^n$LJ|I*e#dwcs!$>RPa zeP{Zip>^c!*)wN{`%d+qJ9p$92*4c9AdDn)K&{AQp@{qghBB7I5-t zSY<{gZ5Nn4qb^+rMhIPyZ7=}^Ji}Irq^Oz32=~Vt) z4&Dd?v5OG`I#dSq)@!kxr^PYeF+Z*5+AZs|*ci_|E3P|13=4D4WdqkB6lrspHP{*l0IqN*u`R=FEUBv7|cuB z!CU~Z>lOOksquxIb2-{Xvpriz@{cKiW?s?}m50$}Ntf1L5k{1$=n-yQ&GiuC&X#Z3 zey!A4{~B>_2tO|o+$D<_zx!%DuU*M&ClskWQCSbIjZ^cd9#l5pZHiZJQ!2NSN1~*P z5u&A}w(r*7YPQbX6lZ0kv6=35i7n7qRGj4r9_xN7ed8wlt7^5dZlw^is~z{`cwvuH z*t1%AXr=H_yzsD6czE7%pY_?@qdz+JyQe<##kcNPw(duN#r+2q|ABc|BG13%isjYe z2Mug0&;1Tkjm)3NAM4A4#p@7bjGk7AC$pJ&Ol3d5UR`*5MbX z5$zyIO>-3)(8BpWU23T5hXkESh_g@7G3Pj!2mBH_B#m*_5V%fPFOd`{I(bm#%phhD z=T${|0)z5&^wLb~0}@Zr4li2$0SN+Qqr`u?I0-IODiUAq^?Ye)kZ^?YxY(AifR;>q z;QV=l5a-WRN_w$)0xW)b(v*(zL)NPNOYE7;EC9=tvt_6VNvHPlQ6P>qo05fRkMtiu zd!%o0_}pOc;4^@Me5x_zFio0}ECzOuiN#xPSW9bmbH*6Y8t)_xcuMky0L4DHcVX{R zqf*fs%cCC&SNE;@8diJ_%Md|#C_W+p5+48jG+!d>@u6w>(15^Dc#;iZsV!3JOc#bz z&lYD?fOuQap}gv5tp|q9T6~n}szARtJYy;q4Ng`n;u4z&b#|Uh`oM*3PKS|DPGMZ}?U8|CByi%~nE{mpN`qo>66{N2@{LSK zq7dX#u*#y915?2WPZ0?~_DgB@kcwK*c_WtAPR(_m*rbdv$mM{>EQrxM5sF@#l)zjB z!#6mF97AJ>EeFm&6CR_v(a%0(wD5V78lS%m%&478V+=8*N?RSdY#EbvwC6mV#QW&0 z1Lsp?e%3x69c|mKl21to$F9H`q=*Cxf>I=t8D*o;EaQT_U!ZZ^j84Hg_6uJB!py3t zcEwY>oWn(D^R_jQf8iDIr%anCOvB{wWbh`fKn6jBr{T=)@V$gG$^=~az)WpaT%s~dA?D>E7>6*y%opQ#`S;WPP5 z7`Z?nG%6u&tz?)2IJxP4qedt8x5~+-?N21=VLg?-lLk=~;#0m}GbdigGr#0g}@})v8=_#sI0UyZmRGa9>-~ec0YAC*+On*awkW0hfK41rl+~KBiO;aW13?W=L?7pZ z)2b|%C1qm=@GeSvX$>ba`kaQs5 zCT2@BI++K&M%AXl0|d_@cxd08wd)ruE|xgfJ9=^D2T0GX zw3f7yur15NM&5543hd4(@PB!G%Kx6qV`@V;<;yvaA!)Wcqa}^O3x?w5W)=^j`t=L7 zUpj7(MB&CkpR+CsXDwVR_}7qqYBRNIA^E#0Os)i|8K%(^&a$GV0)OMbc0ugSQ~(sv z)0Z~p|K7&g(*Q^3i;p@H=U1_yy=Bk_+z2^>{uA2o2h@h_%C10SrgyK4NSTHiyKcNV zNALRd0zFX@HLwcO5v#Wh3=GK%I>I(5;+wtm!l)?O-vnzU`|c_!P2`io6rkP56<;f7 z%3b|$cFgYA$$)dAXxsD@L$);XH9%O|*oA2*zk!SZ=p*wO@=OX3dhAshN;;E4{sXiR zS9~yyS86FRA;m|;{{3}PRT}GhQf|XrmK6ATS@==)lkq5^P_|81C}Z4-q_^+Pz~GUA z!C{qENBfW&ze0o+5EM;aNp5gzdj>wU+cE|v-wDr=KH0#s&~?jx2ZJ%vi;uqmbP{aU zMJeZg83^dI+gER1eRl>MC;Fk28!M&Xx?LzPx&745r`|n&>-c@<1z)zTLsNut5E%XR z$4FNGn4CxCFl`XxI;hG^Nv%tWo4`~KUCa&GWn(&%+`E)4ewBG2tT9RxP_{~ zoqem7tt*wSv8@L_w!|y@l*+!<%Hu1Q$K#bJmCBPbXBqAP+8@gcB!IzgR~mN5JoH-& zY>l<;j|UDYfdf!5&R@h|qR<~J+Y&3J-@3)rRIJhNSGTQJcdt};-|LH4?^ddJuiFvn zAvNmf4W3jtsWMa`6nn_}|# z9FeU<)sp#4g-sjzCcsIg6I)|O(GWnHERiy!fDb}ieO(YBIxveMxu!9*ETFG9a@|++ z9@1Bk>msuTfuis$e6E4?<@FT^`zntzfv!&IZLp$Pv8I?;Kb=LYrA_y=)z2O+OodAJ zIs2>wTJmWr&Dq|tNRI2aS8Z2CeYd5RP)b-LaHYOaJ(+W1!c(r9oijV2uS}d&<76PI zXcPSiT^Q)3kao}1B&pYqL8oRW!1~ZkF9Ne-*W=+nL?PY^f&VRh@@ja}e#Y}?CIuE^ zc|@kCrY2?Ba|r}Tf&XRw0vw!BbKojSUsC4@N$rF3L)43{f3ruLL~ zOc4i#)mO`&z$RkqPe%iz!7)-00=3Ia78r}R4}g96FDT91=VQPTGP%y^|~$ zHVtBICug`Djc0xx844j5eU z_@La0*_vOpR#FeUE5-XBTCJs+pK!o;EG(j(0A=$h*KN73V#Hp!P8JoqXb05w)zXfY zQZlztxeaJ9DeG9V@jRvChLEACA{PrPMyP zT6=n>_H?}Vj8c0h=B`>R!uC?Juqn~J=b=?B?78nPe3)bN6=1>e6;N4<*Il;!Vr&Ne zV%?79>0ThX%dsf9S`u#WV!u)P8+SL)_k*CC&x@3y=6AOA+J#T-xrd9bpLlx3!(QvB zUOQe);Eomqwq%eNt(jvZZ#OO;8=)xXMa1-lzKkGg{Ysli@CTS@TO4Mu=o9HE+3iue zIU4lR*q4)G%pYi~@zG51-oSQYnq4DNnBy6r(Nnt+qS-{7i&F>z2Uk|ZVC_Uv(ve{K zF+68$Gog-Y`2HIjYqXmgV=b3hd$dc!bzCH_-u_iz>x!@SZeQHjsrWkYZU6E9)$XG! z-ACiy$CU14ao@3+`&hzLG#_ClN{Sa`VhEckVH*9ckNznhsE?L$&%BI_d-|em?j`8r z7yv=~79xW_5N+y$K8_@OS^QtNko@?|VgR*y6;VJy{}pablS9*BCUuFV4c4Wm%%l;N zo`cwi5S`2-L(qa&sohT@0j3c4&dl30-}Nnh^5{gA$qHQ7IxYG(xta{RO#Mp-> z%Oow@fGnyxuE5LN+Pm62+XKfTI6~6}f+K_k2TZA}Ne4I!dwix{rq=twl5|oQ7l{D^ zS!{6R$~ZL6$H5nIUJc5mFcV4I=qXv$ua*ZAfaiD+U*FUCKgrxwMY7OqslfZxgFCl+K3kEo8tP$WQjk#-*j%9X=Cfbj zn<@j@wtO+}X;(b$F=soQg{BFJr1>KFB@D^zW6?Gi9-Yj>^dav@RAQ1)bDdIsV150p z<47bOd?X!c8sbuCGRb(r-%$31Z}RM~&3iap^75MekkVvg-*@QgN93@ld-U{sBgQb@}|CBsPnN;)mAMpHv8b}F(jmB!i64yW1Vkm|$DFejL zk{M#JA&{&DF>c(y!wWCyeR^W4{so>sunr6y{lJ+u(gTXg>cyhhQ*_G!R}6!KR~-eD zry*U2Gnzj^`3S%;kjnF==F{pGi#K_bd54b(SD1fUnJ*e zaFRL4&oKE7H`8;N{0RY0dWMG$Mm=FL&_x?BdDKG`>t9hUCk!4;h2-cAuiKwd0QCfP zXF^fn_VT|aAJ*D`Nly%tenwCKft>$H&R>)BH{|?ZA3sfBv1Iuo53dn&4-VEKh zyA+w6Dg;LU7P#9D!(XCwdyM~V{sh~Tk#LqR4K5vxJL`#xX4^5y>)EAaac3iWm377V z&sKcDr}yLSf6^1%GZ3?t$82!v7q<;)NmVazet+w7ZQR)j6~OyyV%6Bq+a9ai7I$ug zFEFcf;&UPZK;5QwUkzFL*vL5~=GuXYo1HSjQIKY7@u3xdZ+?^eI`YVvmf5NJs&9bu zzd4j8Rj=mj`05l`sfaCL=Z>LN)nElU^56Ux*bSsas5unFulW`TN5vE3y46ZHB(pdL zLS=1Ya|>*}t-Bl)CyV3fan^I}6d{XKki{BhHVc(m{R-{G#mI0sSJAdCv$HS94%2vM z$M2wqF*`*$qe%bhw_~=(KLx_W`TY!NI zCRZKY*p;4=jxio;{hRr)wZ@bcVQ=j?vo8$AOzDKQIYT+o3ICH)Q-;3_Dv4X5IG77n z#b(^|ps?7AyE~LGoq_6Nx{_l7R207f?yUWhPKQQU>+ zBIK|eDf&=CQeyO@B&VdFjFgK}0#a@)LA-sqmm=1F+{^HO0QYj_brAOor2QVVW76aW2HzN?ZM^dh=Egs-_bKN4qgqU=&)AYK7wu8;b^-NzdFx& zA4F*Ce3J9$NzdRs6jvfFYm%j_XgViZCF}rilc00Xb!_-<>htHBw!ry-w%l`ym2h>C zr_e`$B$6e^3d91(Ba`6An9EBgd3pva1*C|B49F?~ETqa{dN)M^J=o6JbAD{{JWGii zs@=*62+}{e1b!=RK@X4sk5Lx18;XdkAj~rdU{jSgje)eFOc>kz8dH6s%~mYIQ5gs( zwpCqGoAt;wsPKW=Mc#l^5$s@-kv?|1!%UaV7**=#c1ratn_Ar=*25A+JB6raH3pbz zhdr^j*j9PHS5SGT{h<*`>euKOX`1OPp+1mLPBWv`YVp;K%#5}y`LHx0XrOHk2L2bd z63g=fL_*Z()NZVuh-1~n8qmN=YeM_e9(;4=lh|)C77mW<=BHEnKZpK8k{||+12S+` zrachYm>nDi%g1{g+ux#SI+XS0P?+st1b+|KCB~SRDy^uUnLC}ZqLnJPgMaRRl7kXu6nYuhUv;xZZIFCdOcoM zsoZw5Ro+hVXWGw_3$+_eds-|99E6Cn+BY!%59s1^14@o|MQ zG1Y9n7FDMmk|o(YBw3&-vU2??M&w}k&oqp)Gl6T0!Wk(Sz4(7yJ}xjz(tI|pJ|{PPPttny8|C0@KCKYlSiXBAlh7YO`1gWk6j zZv?W~#RMgKs&jb=b82C8qTCSmX>Vk{GU`vgMN3l8qiKu>Ifv=G=p~qQAzh+%*fp1n zH(jqgssmigAzfEoO^KK&>|%BCXm8*{5-px_%@vrrjmS^$o9L!gbaOu-mR{RAhumls z8AWQ5m!bBlH0E+XOcOjK9lhqH<)i&$mzpM>%%Vu0(r@Nl*@(J=L3x@X&Bd^yF^#2G zK7=6NQ0(R zGLLCC@NK;Ec?!tYwx*3nVPJ$AG*`E&dHEe_s=L|PjwMi;D%LT~H{dY>vAKu~R;np$ zCWuL^dkqCpEoD-slz{yzl3E zh&^BP>nE0?-yiwmj^!8Q{%wkX8}m$*S3?o&gqBd{Ci=4ML0-|~_N9_|UO<6(79UqZ zB18&XpwF6GDQ7&?ZCVXB{(;g(56kK3&23wces7_~!F@D7?10edSFsd3o zMPtEVA^H+72&1+}LAHs)^Xz*~ z(%fvB{WBdqIE$r$q2|(9WQ5T8V3-gKb#61953j2JvTAgIp=7!zur?J8t2ho##b?5_ z=4e(5*as$Pp86VoTU0M;_CnQ{@FWX_p$ zoV`VGMkaufF$joXHCt*dQhQ2^>svGg`VfPJw^mmnB%SXZfBX1bCl^l6v%fFayyf5B z_5D*nX^VLd(Xc2?IfzUaYiRBiLS7mn$oGc7OjxSkWBo|nV`XeZ6Mt8qJTD?@mdOKO zezA$84}7@3(MSyscpOn zX~lw08NTAJnAU(vCngj-*C!1GY2MeUcr;$g>?w@V+&LEaY*IX%V$MyOrTo$+Y8Gez zcYQ*ixj;MzHsiw66Bj@eXogonGBM*S5Z#eAH!@p-jW?j~M}u;E;B;^Xf;qA&!^k*2 zJ&KsJ;DXj=M%s*|M-L&#J?GDBM3S~Lm^c`qnu5}K&Jmym0#paXO#(rbfoWjr#49h? zmQee}tssE7!O@V^oSN+z!?fizeKe39cYHi;%#znD)Y7yTaAgd?;sMjRo;9*e!U2=C z+XfFd7)dx{9*o&>^>jrhvb6R3ZHyh{$}hRfxIiyc4jEUvbqg%{u!aG)mF-Q)z_Z(& z_{yD-R+ANqH2WEn;|eQ@Tx2xHjy;nWQdu$sT_|T+vs;od11cz1*^I}|UAKk(09!Q5 z)e8U#GC;|4-G-y*92!WXcb5T=F|30xLq&;LS*Za#TcFOHHjX?G%&u&p_;g_s+`v9Fp-v3EL2Z-j5mi|c1V89? zV%HH1hPI1>g-4oQlk$ZzNdnIXOaYjM48SgACnApoy4$d70y_o%!QIFxM-Mk(1m>X$rV-5sdP;n>6%V(COX$y+3ezngn)~&pWuXY`>P~!s z3H}b`FnX=%U~SrddZQYr?0Q!VyCqJ^LaDPwzV#c}?-YyEEbQslke zcXsPud}W|*vFyx|+1+VPMV(1}U2K3NlbqP+4rUW$x=_op(Gdx3*%WD3O$2`SKO(6y z!b?As@buZA!b#eW9qH|Fc5|}m`;-^$k%f7l$&1MxRquiAl4bfTGEEIw>6x68mnbeZ z4-?I5x@((}x_Vk)II5Wx$>GBdXSneP_C>ljo4gI5rXj?}cKju3v@qf@^`gx!@4vXZ zX~)W@9kHE9`>t5lVEGB~YTPEP)8BxCDx86?MN^`JKx5s_#@U zI!KSLVyX9L&teaqNp$p!FMjS4{Lsh~^9>G&phXA$0ddQ(;fii074t{eoiO{oR$R8^ zzf&16-lP<7nm;;!6z3T+B{(`2fo#CSNfeh*2)+R3S4s&u1$WWnP%N(&zvb?`n_~?- z@mpc;y>5Qzejl~}>Cu&*v$3ADES3A7;`#gtu_`_hd&>^j3!m1z4|iEV?G(w~-<0JZWUqf^wCkembKFNVI*<^50s%3t(>6t1;G02VV|$ zD#{@MEn@w#OD3!O`rDJ3GGd0C2wzQoufIL<_j-*(`&~k1cSx+&Q6vLTG{~9}> zt^f*gbYD;85^P7Qr3g-q8Hn;TVIT@)QSkQp)+$B>0GO%d`$a{_gBaJUJL^&+99az1z6*6M0pw-n`{6k$AS(a!(Ac;Evs&YFJ? z46>99hFfV9omY2ndu-2%c*#knS9+U-$i8F<&cbiJwF{QtpG2hFIglkLuvy_iZ;AW2D*mk~GScvZ$Rc~b`HgqCE3JoDTTiaEo{YDi zR$5OpUs&o|WhV3E-Uh|n5Yv7HeW3$la=uuv{rgb5RMF6Gk-ZpWziM*}|3K^y2n)G~ zYpuUg+GhP>J|6yXckedqC)@mZ{M6w;Tw(pR!cNb%c0~P?KyS~{3M*4O%T9Mb#`reV zoe|3kf!i>IRK`K7o}6-v6k(x5Y<|fadh}Xy{OdVJuSvYkh|B8`z zysS%!%%I>ptbT!J5?@EDB>NSbc!K;4-b;+26eUjE0CU|AKRek4ye@_~jqC)@In4BhD7=bN{^K*LlHPj;-|8UNn3uVh;Jb;hlNl5}O7=}U z>00k$)ApzA-=yc%>keyVj4CAIh3HKm{DyANaOnGDKXQv z%#44S*?|}xV_Fu$K=-z`3+x#-OvsE0E#!fh$ASSIR86oYf&-cLRIY?4uhREq>;lWK z1ja4S4+sZ{sWeJLEpyDALOaM#{S0aqe0PjRA}|luv290JcLRGy zqzT%;)YY|P+m0Q3_H=fpm;qD{^+VKV(n-QL7+ZPb#E$-G1wh=t=aM!P1w(J;f&$mtD3ZTbADzw!C4AR zx{se5e){<{PahdTfpE0KOeE=6ji`Z81jpe$#FD>5QLQk)%=yW8$nPJ)f!MQ|o=F!s z=^DWo(P3C{=2kfK@x*ta4`VbSn5-ewBjZ0uXxX7Yz{R1tlZ2Wy+S8b-n)f4u;1wu2 zh}A06)rU?q{U!X>^RD~(-gRq*Ye2+#%S(H14lfP^48iE+x>YFIlxS&JS`L2PywY+q z)^ZZ()xst}0$NXDvt*Ofxc%PMmBs_H#sh1`rMHIOeeu?dp!5oa>iYT9iK61g)@9#a z@q1;mB)Kc4u*iGMcvN0Tx4Y0g|mJL#7L zPZ$Z}BeK+B20b^}$x3O|mi}QT-ACssWfw}A7rGq+s2xkB7_n&#W?UIdsVLcCoL78( zFtvQk19R5MDbuoS%SZ?w=A0RoW!K`#Tk$>BpIxtSGQQ~mt-{D4MGRfSW{hp75(!+> zpV?Ow!g&os7tBIjwQw4OWOE|5g;nll=AQMmP0AN(tXtLGvmV!2j@PSMI(nVHG#vn7 z82Q!X&SAeh_PX!V*FS5g@4Zs9ZHeRcp^tZYw$J=`l?Dccq++xBxPOgG>4E6w{pl9U7I;uV8R#bC@oxZaj3 z1~1G*R;14j#WNN)^O>;yjUsoVQ9#DP@SWR>1z>*VY3Tl(qj^8EQ!;?6zo>ucny}%B+y;A0EE{Tsd%!o>IZY+OF~6&U{`$h zJ?l^zvj9y-J}FKd%3y^el?^%*IualLck14JeFeeZd|mwsystE+CWwD1=dY71jEJV% zK0Eg+6G4Bn_RtNqUzoGW=f6f@{Cz7w`tu&jZ)m3{8h@&g${rjd|oq*p@ zLjRfxWH(YK=b~7?ot~2uSAoJy5@cMH&;iy{Oleg21fVz0EW~Mg(C5!HrIGXJO=gtN z!}Oc}xvJL;T+WDt2Li`HBuq?$Sq5yIpa@A*fGbnM39*BOYBUg;3XP26lrRYrVAyFQ z(gsql$dxhZ9H(dq0s$K84n&u*-f$DCzv9>o=(7T$N1CjFq#e#Acv@yenILaET0<`| zgD9%1OJ+UH^*2`uCFZ)|zmSeL<@;57+7w4^P*aP4Svewf)Em`O7uGZVod~r(<1I26 z4yAdbF3G;2s`^iP(UtlPjRLdxT8EK!O#Nk=&W0PGp&r87E%0XQ`&=?6TG4UCQNPCa~L?vwJ`q{AOOb&{0(kgNs$l}nY0GE`SuI+#J0M% z($l}7(A(tPf@36m_}338sE(Zf1Sjd%6eg+i8I%qqqSAC3sFueu=Oh0;vI8o!U2x^| z<2d5ZDron?j$MKzadnV$Db=0x1NX82{9vN0ZvONG4^#+ovLrW>c(-rG(-HG@fap+4 zTUE;v)_Cc51)J==+o3J<&Z}>~x-=5^)I(Qd-gdvNaw)o$7b`n(*LwHczw3-`+5eIM z-Z$s-5ffC4tL(ehrGBNVGhWuEly%+v#!A`FSQ(BTD4jn^Mc7NaK?@$&QAB2c`_bY3EbKiIN z-L>5fe>4%VJf&2^W-o9U#T{66H?FuFpbN{yd*(vyIX&VC>Q+vmu80e$s`?<9PBKhQs5A3?ZIs$~+~@Gh5Xo zSkXXK+c-vpW|um}qLRA-84;3snQ9i=SQWrB9fFzhExF7j(KFCo=6Jw$SPJqiT*mx_4ZYcs1M2EV^E82MiQKv~4k@9Kx4gcDfedKF}WM1vr8U1-?Cq^d6x&fGs8Z z%A+k$Ts10nRwvDTzPpAJ#nPyWSC9=$filxmF@$5)<%ClvK>PZDc@TN4r+iXX$ruEO z5dpG?W;T?}AUuONY?lzT4hi&vV;x}NX*Z6&40!oc*%H1HUM{S;cH$H%UOG#;0F zIGC;(#->KP?x}oq$<3I&`XQ6V zJmcE|oLo<&MCA)cH2aN=0FKC?QN)x|VhUpY6#|SzHHS%c@HHE$l>ZW5vpy3c%}r`9 z66hgIq^fkRktpeX*z@YDUFu)0+O<-(D_*rnslwUG@B(aEE#0zGy5+9#qi@AZx5P_N zDW#`k?hStrO6sALzB^vBRVksxKfm@T)_eWR_G9tR<4Wi8KkZ%VJRR#ijdX9%+?-iH z_fgH_OuY1%QhIFBhT~m`dsd4Ro)=HhA5=U_8=fRNq^SQmXUw=}(lcs}jXZdu!xzCH zu?!6IgIh8bK53Sc;#V4PQuF?h+K<*Wrdgg%5f%}6cGL%EMqDI-#Z@mFQ!dcovM=A} zWuCFUD1COZ@AbDQ{+=z(lt82|N}OT!N-@x~r!<$QO$flD?u_Az`#CbH^K-50NB;g`&_<4y-&V$G9P${ zIKGwXs-H&@`6p@9k3~*fw>aqgXEYqH<2$AYPCe;zm96=TZ|#8;TSd$I~gSWo9G#k%vQSu=ax5J7XRNZ&4`Wjb!jd9;*#kV=;-mJyD7SG?J z9pxe+_0i0P08jL)#Avo#aFSBO|f1u|!g67&r@64^mz*#sN zh0Q23jt-SfS>SZ<5u9)hQ`3NEY)CLok@KjfJV}EleO!=d+PL5a`WcOjXYn1D3EH** zp72^xIcXjioluHS#M~z`y4B$-VBK$$ygVo>2aQtL2{lAAod<_BLijP%8A`FpQ+)J3 zGBtPj>-`(bSkf?XxohLjM|UCp6z?wrSwM;+SVmapmEQf@(oA=Bw%mzN*xaI1D^gSN zJT)~7OK)%TOk0(ixw<$tH*ImjG^8as<_@fROP6eSoXbr(uTAl`K-`vJm%)*Tz1Ms? zpcjYD?Y@2B=7G4c0rNKIhCvYoAQj{9OJ*6@MBZqBN4ltn0DUkAmDCZ(KH7W@ZEMc8 zO5=N&hV=O4BqFjwt{xr>eC{jv#Oth+=Wx0!X@6lJ&@r|+cZzXWCS|=SLdd09#Qo>C%7zHs>S>Z&-AdMEk%aYKpx~ah-Fq&fy)$Qg*?g z_neF;I@LWW!OUxj>zKcTNL;i0ujz?4JEONrZlAPKETj58PJNo50%-^H1x#Ac6*p$< zOnsj%%Ku6|zlb!!yJCCCa0C~SZLlk@%D+gPSIITYekLA zgLk*bi#nB}PVjx)J?lA$NZMS~HJ{jvd#i*`syYw5ttQPZl$wvfday!31PCN-y3uD^ zTJ`aVxcY?{I%CDm=71>MN}_VZ;+!>w^u0xdIb&q$sfPcRF^|`GfjMHxQ`O`m5w~8Z z>@1-yf-6Hhb0VFBYs?oKTbA%!X}Pgd$p?PH+`giOU)2(@gBmoVU0Y(z7 zx@%Y5wU}$}dc|E2v^7yv&!<)*zi?qVmcQlhIoOXqxYBkw)^->wDSC2NuK9_?YU=My z-m}JQy6HofG!oB;o#0z%R`MHS`PfRI?K46LHp*U21!hz4d~>zBbEUfTp8vR9vYn z0d$c55A-}BdEG$PY%Uqor!jC<<-KV-D^zE8nbVh>FlF?xC)wgB3fPngwa;{89ax&6 zJ%ZHq+FZt>!LJ(yU-k{#1^)zUn5^}6APVgqzTk*q7>drWy`QnH;YiHo07!$)H56h=?n>^;4yxwJ)8T({H3u~UN`N_NVQRRV2oH-_Up5=A+`Pg<;*F2U<}m2nLVcOY6U$(TBPdHpkT41?VL>6Kx>jLIb}S-wgR!<^^n ziOG5&Q@m-sYFjUL-aLoiI4GG;)RW|w5hr7_*ew+MX%eNHV&@74MP`k+W>@Dr zCNVB0t>`Bi`3df=m|a`4%B>vKx$bF|f@ib+G8R=sU2-nO{6L-BURyd+XycWK|V zL>^K~pOeF04UU&7=q|hx^VHL4K2wy9KPz!TXiWP@npeEdac`^QZH;+bi7#_-Ik@6$ ziusyIi?*z4wX9{OtmSTZysSeh>sYiyI`ErYzq1vAciaEe4lJp%>7ih$#NJdmi#a5K zCN6MceWId{PDH_(C_dx`U0Zg51D>3)RJvNxwo=g+ujo)JIu>&hK00#U_=!V6Nw&m_ zHlt3ruHAZNwX}7mv^8GZrj)j+dcKyziu)*`uXJhG&4Y^vQJ{5*koi~88`L+?kglEL zO>g4$bK(=WRF+0(T7ag{4IM)9BefWzpET|~T5SEaDIe}n#l9TeepYNdTAuT>DiN-U ztA$a{$s?LiX7U`6L7e>)9W0z>_UgFi%`<0DfyIIS24pjj_!$w{Y8+A3O0b52jWGpV ziH1$|Sgt9aYLSh9tV$!nx?t=Q?IT3uHs(ozh=p(gtX>kM?2<84$oQfDRqA+H{R0@| z`j@C)26HhE&snbtxJgBh{eSBz?a!PWQf! zjalVSS`S`cjnCTb1mq%FFJs)~^3I{*z*#s+Jc050m*nvZIpgFIWv|hZ|ByU>3l6le zi60Y5iq|4(w4-x)7z$kS@Nk-FQuBU+#>yk4!NE?VCNS?v6qnzA;pPkXY>O|%i+3o+ zJFq{{wTU^P^gRA0`~0i(uO`ZCXsiA5Gx73PrMz{~ktiv@ed*?XjlQXpKLT*U=V6R|9MDX0O4#B|{_z1_uY|f;-q;FEbN%M5JtN?~?J*?opKABZt|x z`+a(1_y~KdML){{a_Y#bC+FW%6os4ydTk`dpWKZO^Q5++WahAl=CQ8x;2tIsbv2|40sP?UC!~i8ULO9UdgV zZRF4rX4qiB^z%sXflr??ioy^)k}GmyQ745mY>=UP49g=FjW5%c6z^ByB=c2^gCj5} zG&~IZBs<_6!M|{bZA@ZzpqWG4HzWTU6Bw2SwZC;sjonEG|}-S3EXRL2uBYm57;lK-MuEq;jm*unH}#=J8W{8ohcFK2NSctOv~e zU!n<>n)w0peHwhx;n8UrFb+YqZ>1RjfSmWp`7?6<4V+{S%;CT?^~Iz`4$05aOmuKP zNq&;deu_iKO-Do5qGW)aR)A!lfzFf(5+;3FtN^pw3R%W6?C->#RZ>BT0pX(S36CVCCCVyAq5qY<0FUgPiAb0+g`v1F_mN{oGF>F z8o=hbIoC5Ix;dGfvWzWPv6zF;KYe7l@7R&Plg9_1lB>y&tYE2%i)6l0t|3o4+UFEH z8Cu%ic$bf%wdDXk?I!0WIo}|MM8|T7oGEfhzlWKg<*Fj2L&4Ru+UThT&SU33ZhQWK z{NEu_{BSxa1_(gEC?pCHYp<7&`}_I6Sk_D_Je_lO)bku z63)DN>wMp0`C`$n@>pfpz3obOU%aqiDePY@Jh@VMGG2IEDLfr_4k*rnhgQob2Z-uT z4)6)=jvGWsI|OI(;?%M{$=y&iwPV4)-8FW1^Dd$>rR;a7+56*8U0Z#^X6 z&r?B%M5|a#MM`%bk{=Xcv;cP{C7J0gwm&4_&r?DB1Y2&*TD)#6u%oh>&Qifc^8Gv& zR4>?^F{^LgRzzQ9I*Z|l None: + ... + + def set_tunnel( + self, + host: str, + port: int | None = None, + headers: typing.Mapping[str, str] | None = None, + scheme: str = "http", + ) -> None: + ... + + def connect(self) -> None: + ... + + def request( + self, + method: str, + url: str, + body: _TYPE_BODY | None = None, + headers: typing.Mapping[str, str] | None = None, + # We know *at least* botocore is depending on the order of the + # first 3 parameters so to be safe we only mark the later ones + # as keyword-only to ensure we have space to extend. + *, + chunked: bool = False, + preload_content: bool = True, + decode_content: bool = True, + enforce_content_length: bool = True, + ) -> None: + ... + + def getresponse(self) -> BaseHTTPResponse: + ... + + def close(self) -> None: + ... + + @property + def is_closed(self) -> bool: + """Whether the connection either is brand new or has been previously closed. + If this property is True then both ``is_connected`` and ``has_connected_to_proxy`` + properties must be False. + """ + + @property + def is_connected(self) -> bool: + """Whether the connection is actively connected to any origin (proxy or target)""" + + @property + def has_connected_to_proxy(self) -> bool: + """Whether the connection has successfully connected to its proxy. + This returns False if no proxy is in use. Used to determine whether + errors are coming from the proxy layer or from tunnelling to the target origin. + """ + + class BaseHTTPSConnection(BaseHTTPConnection, Protocol): + default_port: typing.ClassVar[int] + default_socket_options: typing.ClassVar[_TYPE_SOCKET_OPTIONS] + + # Certificate verification methods + cert_reqs: int | str | None + assert_hostname: None | str | Literal[False] + assert_fingerprint: str | None + ssl_context: ssl.SSLContext | None + + # Trusted CAs + ca_certs: str | None + ca_cert_dir: str | None + ca_cert_data: None | str | bytes + + # TLS version + ssl_minimum_version: int | None + ssl_maximum_version: int | None + ssl_version: int | str | None # Deprecated + + # Client certificates + cert_file: str | None + key_file: str | None + key_password: str | None + + def __init__( + self, + host: str, + port: int | None = None, + *, + timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, + source_address: tuple[str, int] | None = None, + blocksize: int = 16384, + socket_options: _TYPE_SOCKET_OPTIONS | None = ..., + proxy: Url | None = None, + proxy_config: ProxyConfig | None = None, + cert_reqs: int | str | None = None, + assert_hostname: None | str | Literal[False] = None, + assert_fingerprint: str | None = None, + server_hostname: str | None = None, + ssl_context: ssl.SSLContext | None = None, + ca_certs: str | None = None, + ca_cert_dir: str | None = None, + ca_cert_data: None | str | bytes = None, + ssl_minimum_version: int | None = None, + ssl_maximum_version: int | None = None, + ssl_version: int | str | None = None, # Deprecated + cert_file: str | None = None, + key_file: str | None = None, + key_password: str | None = None, + ) -> None: + ... diff --git a/Modules/urllib3/_collections.py b/Modules/urllib3/_collections.py new file mode 100644 index 0000000..55b0324 --- /dev/null +++ b/Modules/urllib3/_collections.py @@ -0,0 +1,483 @@ +from __future__ import annotations + +import typing +from collections import OrderedDict +from enum import Enum, auto +from threading import RLock + +if typing.TYPE_CHECKING: + # We can only import Protocol if TYPE_CHECKING because it's a development + # dependency, and is not available at runtime. + from typing import Protocol + + from typing_extensions import Self + + class HasGettableStringKeys(Protocol): + def keys(self) -> typing.Iterator[str]: + ... + + def __getitem__(self, key: str) -> str: + ... + + +__all__ = ["RecentlyUsedContainer", "HTTPHeaderDict"] + + +# Key type +_KT = typing.TypeVar("_KT") +# Value type +_VT = typing.TypeVar("_VT") +# Default type +_DT = typing.TypeVar("_DT") + +ValidHTTPHeaderSource = typing.Union[ + "HTTPHeaderDict", + typing.Mapping[str, str], + typing.Iterable[typing.Tuple[str, str]], + "HasGettableStringKeys", +] + + +class _Sentinel(Enum): + not_passed = auto() + + +def ensure_can_construct_http_header_dict( + potential: object, +) -> ValidHTTPHeaderSource | None: + if isinstance(potential, HTTPHeaderDict): + return potential + elif isinstance(potential, typing.Mapping): + # Full runtime checking of the contents of a Mapping is expensive, so for the + # purposes of typechecking, we assume that any Mapping is the right shape. + return typing.cast(typing.Mapping[str, str], potential) + elif isinstance(potential, typing.Iterable): + # Similarly to Mapping, full runtime checking of the contents of an Iterable is + # expensive, so for the purposes of typechecking, we assume that any Iterable + # is the right shape. + return typing.cast(typing.Iterable[typing.Tuple[str, str]], potential) + elif hasattr(potential, "keys") and hasattr(potential, "__getitem__"): + return typing.cast("HasGettableStringKeys", potential) + else: + return None + + +class RecentlyUsedContainer(typing.Generic[_KT, _VT], typing.MutableMapping[_KT, _VT]): + """ + Provides a thread-safe dict-like container which maintains up to + ``maxsize`` keys while throwing away the least-recently-used keys beyond + ``maxsize``. + + :param maxsize: + Maximum number of recent elements to retain. + + :param dispose_func: + Every time an item is evicted from the container, + ``dispose_func(value)`` is called. Callback which will get called + """ + + _container: typing.OrderedDict[_KT, _VT] + _maxsize: int + dispose_func: typing.Callable[[_VT], None] | None + lock: RLock + + def __init__( + self, + maxsize: int = 10, + dispose_func: typing.Callable[[_VT], None] | None = None, + ) -> None: + super().__init__() + self._maxsize = maxsize + self.dispose_func = dispose_func + self._container = OrderedDict() + self.lock = RLock() + + def __getitem__(self, key: _KT) -> _VT: + # Re-insert the item, moving it to the end of the eviction line. + with self.lock: + item = self._container.pop(key) + self._container[key] = item + return item + + def __setitem__(self, key: _KT, value: _VT) -> None: + evicted_item = None + with self.lock: + # Possibly evict the existing value of 'key' + try: + # If the key exists, we'll overwrite it, which won't change the + # size of the pool. Because accessing a key should move it to + # the end of the eviction line, we pop it out first. + evicted_item = key, self._container.pop(key) + self._container[key] = value + except KeyError: + # When the key does not exist, we insert the value first so that + # evicting works in all cases, including when self._maxsize is 0 + self._container[key] = value + if len(self._container) > self._maxsize: + # If we didn't evict an existing value, and we've hit our maximum + # size, then we have to evict the least recently used item from + # the beginning of the container. + evicted_item = self._container.popitem(last=False) + + # After releasing the lock on the pool, dispose of any evicted value. + if evicted_item is not None and self.dispose_func: + _, evicted_value = evicted_item + self.dispose_func(evicted_value) + + def __delitem__(self, key: _KT) -> None: + with self.lock: + value = self._container.pop(key) + + if self.dispose_func: + self.dispose_func(value) + + def __len__(self) -> int: + with self.lock: + return len(self._container) + + def __iter__(self) -> typing.NoReturn: + raise NotImplementedError( + "Iteration over this class is unlikely to be threadsafe." + ) + + def clear(self) -> None: + with self.lock: + # Copy pointers to all values, then wipe the mapping + values = list(self._container.values()) + self._container.clear() + + if self.dispose_func: + for value in values: + self.dispose_func(value) + + def keys(self) -> set[_KT]: # type: ignore[override] + with self.lock: + return set(self._container.keys()) + + +class HTTPHeaderDictItemView(typing.Set[typing.Tuple[str, str]]): + """ + HTTPHeaderDict is unusual for a Mapping[str, str] in that it has two modes of + address. + + If we directly try to get an item with a particular name, we will get a string + back that is the concatenated version of all the values: + + >>> d['X-Header-Name'] + 'Value1, Value2, Value3' + + However, if we iterate over an HTTPHeaderDict's items, we will optionally combine + these values based on whether combine=True was called when building up the dictionary + + >>> d = HTTPHeaderDict({"A": "1", "B": "foo"}) + >>> d.add("A", "2", combine=True) + >>> d.add("B", "bar") + >>> list(d.items()) + [ + ('A', '1, 2'), + ('B', 'foo'), + ('B', 'bar'), + ] + + This class conforms to the interface required by the MutableMapping ABC while + also giving us the nonstandard iteration behavior we want; items with duplicate + keys, ordered by time of first insertion. + """ + + _headers: HTTPHeaderDict + + def __init__(self, headers: HTTPHeaderDict) -> None: + self._headers = headers + + def __len__(self) -> int: + return len(list(self._headers.iteritems())) + + def __iter__(self) -> typing.Iterator[tuple[str, str]]: + return self._headers.iteritems() + + def __contains__(self, item: object) -> bool: + if isinstance(item, tuple) and len(item) == 2: + passed_key, passed_val = item + if isinstance(passed_key, str) and isinstance(passed_val, str): + return self._headers._has_value_for_header(passed_key, passed_val) + return False + + +class HTTPHeaderDict(typing.MutableMapping[str, str]): + """ + :param headers: + An iterable of field-value pairs. Must not contain multiple field names + when compared case-insensitively. + + :param kwargs: + Additional field-value pairs to pass in to ``dict.update``. + + A ``dict`` like container for storing HTTP Headers. + + Field names are stored and compared case-insensitively in compliance with + RFC 7230. Iteration provides the first case-sensitive key seen for each + case-insensitive pair. + + Using ``__setitem__`` syntax overwrites fields that compare equal + case-insensitively in order to maintain ``dict``'s api. For fields that + compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add`` + in a loop. + + If multiple fields that are equal case-insensitively are passed to the + constructor or ``.update``, the behavior is undefined and some will be + lost. + + >>> headers = HTTPHeaderDict() + >>> headers.add('Set-Cookie', 'foo=bar') + >>> headers.add('set-cookie', 'baz=quxx') + >>> headers['content-length'] = '7' + >>> headers['SET-cookie'] + 'foo=bar, baz=quxx' + >>> headers['Content-Length'] + '7' + """ + + _container: typing.MutableMapping[str, list[str]] + + def __init__(self, headers: ValidHTTPHeaderSource | None = None, **kwargs: str): + super().__init__() + self._container = {} # 'dict' is insert-ordered + if headers is not None: + if isinstance(headers, HTTPHeaderDict): + self._copy_from(headers) + else: + self.extend(headers) + if kwargs: + self.extend(kwargs) + + def __setitem__(self, key: str, val: str) -> None: + # avoid a bytes/str comparison by decoding before httplib + if isinstance(key, bytes): + key = key.decode("latin-1") + self._container[key.lower()] = [key, val] + + def __getitem__(self, key: str) -> str: + val = self._container[key.lower()] + return ", ".join(val[1:]) + + def __delitem__(self, key: str) -> None: + del self._container[key.lower()] + + def __contains__(self, key: object) -> bool: + if isinstance(key, str): + return key.lower() in self._container + return False + + def setdefault(self, key: str, default: str = "") -> str: + return super().setdefault(key, default) + + def __eq__(self, other: object) -> bool: + maybe_constructable = ensure_can_construct_http_header_dict(other) + if maybe_constructable is None: + return False + else: + other_as_http_header_dict = type(self)(maybe_constructable) + + return {k.lower(): v for k, v in self.itermerged()} == { + k.lower(): v for k, v in other_as_http_header_dict.itermerged() + } + + def __ne__(self, other: object) -> bool: + return not self.__eq__(other) + + def __len__(self) -> int: + return len(self._container) + + def __iter__(self) -> typing.Iterator[str]: + # Only provide the originally cased names + for vals in self._container.values(): + yield vals[0] + + def discard(self, key: str) -> None: + try: + del self[key] + except KeyError: + pass + + def add(self, key: str, val: str, *, combine: bool = False) -> None: + """Adds a (name, value) pair, doesn't overwrite the value if it already + exists. + + If this is called with combine=True, instead of adding a new header value + as a distinct item during iteration, this will instead append the value to + any existing header value with a comma. If no existing header value exists + for the key, then the value will simply be added, ignoring the combine parameter. + + >>> headers = HTTPHeaderDict(foo='bar') + >>> headers.add('Foo', 'baz') + >>> headers['foo'] + 'bar, baz' + >>> list(headers.items()) + [('foo', 'bar'), ('foo', 'baz')] + >>> headers.add('foo', 'quz', combine=True) + >>> list(headers.items()) + [('foo', 'bar, baz, quz')] + """ + # avoid a bytes/str comparison by decoding before httplib + if isinstance(key, bytes): + key = key.decode("latin-1") + key_lower = key.lower() + new_vals = [key, val] + # Keep the common case aka no item present as fast as possible + vals = self._container.setdefault(key_lower, new_vals) + if new_vals is not vals: + # if there are values here, then there is at least the initial + # key/value pair + assert len(vals) >= 2 + if combine: + vals[-1] = vals[-1] + ", " + val + else: + vals.append(val) + + def extend(self, *args: ValidHTTPHeaderSource, **kwargs: str) -> None: + """Generic import function for any type of header-like object. + Adapted version of MutableMapping.update in order to insert items + with self.add instead of self.__setitem__ + """ + if len(args) > 1: + raise TypeError( + f"extend() takes at most 1 positional arguments ({len(args)} given)" + ) + other = args[0] if len(args) >= 1 else () + + if isinstance(other, HTTPHeaderDict): + for key, val in other.iteritems(): + self.add(key, val) + elif isinstance(other, typing.Mapping): + for key, val in other.items(): + self.add(key, val) + elif isinstance(other, typing.Iterable): + other = typing.cast(typing.Iterable[typing.Tuple[str, str]], other) + for key, value in other: + self.add(key, value) + elif hasattr(other, "keys") and hasattr(other, "__getitem__"): + # THIS IS NOT A TYPESAFE BRANCH + # In this branch, the object has a `keys` attr but is not a Mapping or any of + # the other types indicated in the method signature. We do some stuff with + # it as though it partially implements the Mapping interface, but we're not + # doing that stuff safely AT ALL. + for key in other.keys(): + self.add(key, other[key]) + + for key, value in kwargs.items(): + self.add(key, value) + + @typing.overload + def getlist(self, key: str) -> list[str]: + ... + + @typing.overload + def getlist(self, key: str, default: _DT) -> list[str] | _DT: + ... + + def getlist( + self, key: str, default: _Sentinel | _DT = _Sentinel.not_passed + ) -> list[str] | _DT: + """Returns a list of all the values for the named field. Returns an + empty list if the key doesn't exist.""" + try: + vals = self._container[key.lower()] + except KeyError: + if default is _Sentinel.not_passed: + # _DT is unbound; empty list is instance of List[str] + return [] + # _DT is bound; default is instance of _DT + return default + else: + # _DT may or may not be bound; vals[1:] is instance of List[str], which + # meets our external interface requirement of `Union[List[str], _DT]`. + return vals[1:] + + def _prepare_for_method_change(self) -> Self: + """ + Remove content-specific header fields before changing the request + method to GET or HEAD according to RFC 9110, Section 15.4. + """ + content_specific_headers = [ + "Content-Encoding", + "Content-Language", + "Content-Location", + "Content-Type", + "Content-Length", + "Digest", + "Last-Modified", + ] + for header in content_specific_headers: + self.discard(header) + return self + + # Backwards compatibility for httplib + getheaders = getlist + getallmatchingheaders = getlist + iget = getlist + + # Backwards compatibility for http.cookiejar + get_all = getlist + + def __repr__(self) -> str: + return f"{type(self).__name__}({dict(self.itermerged())})" + + def _copy_from(self, other: HTTPHeaderDict) -> None: + for key in other: + val = other.getlist(key) + self._container[key.lower()] = [key, *val] + + def copy(self) -> HTTPHeaderDict: + clone = type(self)() + clone._copy_from(self) + return clone + + def iteritems(self) -> typing.Iterator[tuple[str, str]]: + """Iterate over all header lines, including duplicate ones.""" + for key in self: + vals = self._container[key.lower()] + for val in vals[1:]: + yield vals[0], val + + def itermerged(self) -> typing.Iterator[tuple[str, str]]: + """Iterate over all headers, merging duplicate ones together.""" + for key in self: + val = self._container[key.lower()] + yield val[0], ", ".join(val[1:]) + + def items(self) -> HTTPHeaderDictItemView: # type: ignore[override] + return HTTPHeaderDictItemView(self) + + def _has_value_for_header(self, header_name: str, potential_value: str) -> bool: + if header_name in self: + return potential_value in self._container[header_name.lower()][1:] + return False + + def __ior__(self, other: object) -> HTTPHeaderDict: + # Supports extending a header dict in-place using operator |= + # combining items with add instead of __setitem__ + maybe_constructable = ensure_can_construct_http_header_dict(other) + if maybe_constructable is None: + return NotImplemented + self.extend(maybe_constructable) + return self + + def __or__(self, other: object) -> HTTPHeaderDict: + # Supports merging header dicts using operator | + # combining items with add instead of __setitem__ + maybe_constructable = ensure_can_construct_http_header_dict(other) + if maybe_constructable is None: + return NotImplemented + result = self.copy() + result.extend(maybe_constructable) + return result + + def __ror__(self, other: object) -> HTTPHeaderDict: + # Supports merging header dicts using operator | when other is on left side + # combining items with add instead of __setitem__ + maybe_constructable = ensure_can_construct_http_header_dict(other) + if maybe_constructable is None: + return NotImplemented + result = type(self)(maybe_constructable) + result.extend(self) + return result diff --git a/Modules/urllib3/_request_methods.py b/Modules/urllib3/_request_methods.py new file mode 100644 index 0000000..1d0f346 --- /dev/null +++ b/Modules/urllib3/_request_methods.py @@ -0,0 +1,217 @@ +from __future__ import annotations + +import json as _json +import typing +from urllib.parse import urlencode + +from ._base_connection import _TYPE_BODY +from ._collections import HTTPHeaderDict +from .filepost import _TYPE_FIELDS, encode_multipart_formdata +from .response import BaseHTTPResponse + +__all__ = ["RequestMethods"] + +_TYPE_ENCODE_URL_FIELDS = typing.Union[ + typing.Sequence[typing.Tuple[str, typing.Union[str, bytes]]], + typing.Mapping[str, typing.Union[str, bytes]], +] + + +class RequestMethods: + """ + Convenience mixin for classes who implement a :meth:`urlopen` method, such + as :class:`urllib3.HTTPConnectionPool` and + :class:`urllib3.PoolManager`. + + Provides behavior for making common types of HTTP request methods and + decides which type of request field encoding to use. + + Specifically, + + :meth:`.request_encode_url` is for sending requests whose fields are + encoded in the URL (such as GET, HEAD, DELETE). + + :meth:`.request_encode_body` is for sending requests whose fields are + encoded in the *body* of the request using multipart or www-form-urlencoded + (such as for POST, PUT, PATCH). + + :meth:`.request` is for making any kind of request, it will look up the + appropriate encoding format and use one of the above two methods to make + the request. + + Initializer parameters: + + :param headers: + Headers to include with all requests, unless other headers are given + explicitly. + """ + + _encode_url_methods = {"DELETE", "GET", "HEAD", "OPTIONS"} + + def __init__(self, headers: typing.Mapping[str, str] | None = None) -> None: + self.headers = headers or {} + + def urlopen( + self, + method: str, + url: str, + body: _TYPE_BODY | None = None, + headers: typing.Mapping[str, str] | None = None, + encode_multipart: bool = True, + multipart_boundary: str | None = None, + **kw: typing.Any, + ) -> BaseHTTPResponse: # Abstract + raise NotImplementedError( + "Classes extending RequestMethods must implement " + "their own ``urlopen`` method." + ) + + def request( + self, + method: str, + url: str, + body: _TYPE_BODY | None = None, + fields: _TYPE_FIELDS | None = None, + headers: typing.Mapping[str, str] | None = None, + json: typing.Any | None = None, + **urlopen_kw: typing.Any, + ) -> BaseHTTPResponse: + """ + Make a request using :meth:`urlopen` with the appropriate encoding of + ``fields`` based on the ``method`` used. + + This is a convenience method that requires the least amount of manual + effort. It can be used in most situations, while still having the + option to drop down to more specific methods when necessary, such as + :meth:`request_encode_url`, :meth:`request_encode_body`, + or even the lowest level :meth:`urlopen`. + """ + method = method.upper() + + if json is not None and body is not None: + raise TypeError( + "request got values for both 'body' and 'json' parameters which are mutually exclusive" + ) + + if json is not None: + if headers is None: + headers = self.headers.copy() # type: ignore + if not ("content-type" in map(str.lower, headers.keys())): + headers["Content-Type"] = "application/json" # type: ignore + + body = _json.dumps(json, separators=(",", ":"), ensure_ascii=False).encode( + "utf-8" + ) + + if body is not None: + urlopen_kw["body"] = body + + if method in self._encode_url_methods: + return self.request_encode_url( + method, + url, + fields=fields, # type: ignore[arg-type] + headers=headers, + **urlopen_kw, + ) + else: + return self.request_encode_body( + method, url, fields=fields, headers=headers, **urlopen_kw + ) + + def request_encode_url( + self, + method: str, + url: str, + fields: _TYPE_ENCODE_URL_FIELDS | None = None, + headers: typing.Mapping[str, str] | None = None, + **urlopen_kw: str, + ) -> BaseHTTPResponse: + """ + Make a request using :meth:`urlopen` with the ``fields`` encoded in + the url. This is useful for request methods like GET, HEAD, DELETE, etc. + """ + if headers is None: + headers = self.headers + + extra_kw: dict[str, typing.Any] = {"headers": headers} + extra_kw.update(urlopen_kw) + + if fields: + url += "?" + urlencode(fields) + + return self.urlopen(method, url, **extra_kw) + + def request_encode_body( + self, + method: str, + url: str, + fields: _TYPE_FIELDS | None = None, + headers: typing.Mapping[str, str] | None = None, + encode_multipart: bool = True, + multipart_boundary: str | None = None, + **urlopen_kw: str, + ) -> BaseHTTPResponse: + """ + Make a request using :meth:`urlopen` with the ``fields`` encoded in + the body. This is useful for request methods like POST, PUT, PATCH, etc. + + When ``encode_multipart=True`` (default), then + :func:`urllib3.encode_multipart_formdata` is used to encode + the payload with the appropriate content type. Otherwise + :func:`urllib.parse.urlencode` is used with the + 'application/x-www-form-urlencoded' content type. + + Multipart encoding must be used when posting files, and it's reasonably + safe to use it in other times too. However, it may break request + signing, such as with OAuth. + + Supports an optional ``fields`` parameter of key/value strings AND + key/filetuple. A filetuple is a (filename, data, MIME type) tuple where + the MIME type is optional. For example:: + + fields = { + 'foo': 'bar', + 'fakefile': ('foofile.txt', 'contents of foofile'), + 'realfile': ('barfile.txt', open('realfile').read()), + 'typedfile': ('bazfile.bin', open('bazfile').read(), + 'image/jpeg'), + 'nonamefile': 'contents of nonamefile field', + } + + When uploading a file, providing a filename (the first parameter of the + tuple) is optional but recommended to best mimic behavior of browsers. + + Note that if ``headers`` are supplied, the 'Content-Type' header will + be overwritten because it depends on the dynamic random boundary string + which is used to compose the body of the request. The random boundary + string can be explicitly set with the ``multipart_boundary`` parameter. + """ + if headers is None: + headers = self.headers + + extra_kw: dict[str, typing.Any] = {"headers": HTTPHeaderDict(headers)} + body: bytes | str + + if fields: + if "body" in urlopen_kw: + raise TypeError( + "request got values for both 'fields' and 'body', can only specify one." + ) + + if encode_multipart: + body, content_type = encode_multipart_formdata( + fields, boundary=multipart_boundary + ) + else: + body, content_type = ( + urlencode(fields), # type: ignore[arg-type] + "application/x-www-form-urlencoded", + ) + + extra_kw["body"] = body + extra_kw["headers"].setdefault("Content-Type", content_type) + + extra_kw.update(urlopen_kw) + + return self.urlopen(method, url, **extra_kw) diff --git a/Modules/urllib3/_version.py b/Modules/urllib3/_version.py new file mode 100644 index 0000000..409ba3f --- /dev/null +++ b/Modules/urllib3/_version.py @@ -0,0 +1,4 @@ +# This file is protected via CODEOWNERS +from __future__ import annotations + +__version__ = "2.1.0" diff --git a/Modules/urllib3/connection.py b/Modules/urllib3/connection.py new file mode 100644 index 0000000..38a2fd6 --- /dev/null +++ b/Modules/urllib3/connection.py @@ -0,0 +1,905 @@ +from __future__ import annotations + +import datetime +import logging +import os +import re +import socket +import sys +import typing +import warnings +from http.client import HTTPConnection as _HTTPConnection +from http.client import HTTPException as HTTPException # noqa: F401 +from http.client import ResponseNotReady +from socket import timeout as SocketTimeout + +if typing.TYPE_CHECKING: + from typing import Literal + + from .response import HTTPResponse + from .util.ssl_ import _TYPE_PEER_CERT_RET_DICT + from .util.ssltransport import SSLTransport + +from ._collections import HTTPHeaderDict +from .util.response import assert_header_parsing +from .util.timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT, Timeout +from .util.util import to_str +from .util.wait import wait_for_read + +try: # Compiled with SSL? + import ssl + + BaseSSLError = ssl.SSLError +except (ImportError, AttributeError): + ssl = None # type: ignore[assignment] + + class BaseSSLError(BaseException): # type: ignore[no-redef] + pass + + +from ._base_connection import _TYPE_BODY +from ._base_connection import ProxyConfig as ProxyConfig +from ._base_connection import _ResponseOptions as _ResponseOptions +from ._version import __version__ +from .exceptions import ( + ConnectTimeoutError, + HeaderParsingError, + NameResolutionError, + NewConnectionError, + ProxyError, + SystemTimeWarning, +) +from .util import SKIP_HEADER, SKIPPABLE_HEADERS, connection, ssl_ +from .util.request import body_to_chunks +from .util.ssl_ import assert_fingerprint as _assert_fingerprint +from .util.ssl_ import ( + create_urllib3_context, + is_ipaddress, + resolve_cert_reqs, + resolve_ssl_version, + ssl_wrap_socket, +) +from .util.ssl_match_hostname import CertificateError, match_hostname +from .util.url import Url + +# Not a no-op, we're adding this to the namespace so it can be imported. +ConnectionError = ConnectionError +BrokenPipeError = BrokenPipeError + + +log = logging.getLogger(__name__) + +port_by_scheme = {"http": 80, "https": 443} + +# When it comes time to update this value as a part of regular maintenance +# (ie test_recent_date is failing) update it to ~6 months before the current date. +RECENT_DATE = datetime.date(2022, 1, 1) + +_CONTAINS_CONTROL_CHAR_RE = re.compile(r"[^-!#$%&'*+.^_`|~0-9a-zA-Z]") + +_HAS_SYS_AUDIT = hasattr(sys, "audit") + + +class HTTPConnection(_HTTPConnection): + """ + Based on :class:`http.client.HTTPConnection` but provides an extra constructor + backwards-compatibility layer between older and newer Pythons. + + Additional keyword parameters are used to configure attributes of the connection. + Accepted parameters include: + + - ``source_address``: Set the source address for the current connection. + - ``socket_options``: Set specific options on the underlying socket. If not specified, then + defaults are loaded from ``HTTPConnection.default_socket_options`` which includes disabling + Nagle's algorithm (sets TCP_NODELAY to 1) unless the connection is behind a proxy. + + For example, if you wish to enable TCP Keep Alive in addition to the defaults, + you might pass: + + .. code-block:: python + + HTTPConnection.default_socket_options + [ + (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1), + ] + + Or you may want to disable the defaults by passing an empty list (e.g., ``[]``). + """ + + default_port: typing.ClassVar[int] = port_by_scheme["http"] # type: ignore[misc] + + #: Disable Nagle's algorithm by default. + #: ``[(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]`` + default_socket_options: typing.ClassVar[connection._TYPE_SOCKET_OPTIONS] = [ + (socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) + ] + + #: Whether this connection verifies the host's certificate. + is_verified: bool = False + + #: Whether this proxy connection verified the proxy host's certificate. + # If no proxy is currently connected to the value will be ``None``. + proxy_is_verified: bool | None = None + + blocksize: int + source_address: tuple[str, int] | None + socket_options: connection._TYPE_SOCKET_OPTIONS | None + + _has_connected_to_proxy: bool + _response_options: _ResponseOptions | None + _tunnel_host: str | None + _tunnel_port: int | None + _tunnel_scheme: str | None + + def __init__( + self, + host: str, + port: int | None = None, + *, + timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, + source_address: tuple[str, int] | None = None, + blocksize: int = 16384, + socket_options: None + | (connection._TYPE_SOCKET_OPTIONS) = default_socket_options, + proxy: Url | None = None, + proxy_config: ProxyConfig | None = None, + ) -> None: + super().__init__( + host=host, + port=port, + timeout=Timeout.resolve_default_timeout(timeout), + source_address=source_address, + blocksize=blocksize, + ) + self.socket_options = socket_options + self.proxy = proxy + self.proxy_config = proxy_config + + self._has_connected_to_proxy = False + self._response_options = None + self._tunnel_host: str | None = None + self._tunnel_port: int | None = None + self._tunnel_scheme: str | None = None + + # https://github.com/python/mypy/issues/4125 + # Mypy treats this as LSP violation, which is considered a bug. + # If `host` is made a property it violates LSP, because a writeable attribute is overridden with a read-only one. + # However, there is also a `host` setter so LSP is not violated. + # Potentially, a `@host.deleter` might be needed depending on how this issue will be fixed. + @property + def host(self) -> str: + """ + Getter method to remove any trailing dots that indicate the hostname is an FQDN. + + In general, SSL certificates don't include the trailing dot indicating a + fully-qualified domain name, and thus, they don't validate properly when + checked against a domain name that includes the dot. In addition, some + servers may not expect to receive the trailing dot when provided. + + However, the hostname with trailing dot is critical to DNS resolution; doing a + lookup with the trailing dot will properly only resolve the appropriate FQDN, + whereas a lookup without a trailing dot will search the system's search domain + list. Thus, it's important to keep the original host around for use only in + those cases where it's appropriate (i.e., when doing DNS lookup to establish the + actual TCP connection across which we're going to send HTTP requests). + """ + return self._dns_host.rstrip(".") + + @host.setter + def host(self, value: str) -> None: + """ + Setter for the `host` property. + + We assume that only urllib3 uses the _dns_host attribute; httplib itself + only uses `host`, and it seems reasonable that other libraries follow suit. + """ + self._dns_host = value + + def _new_conn(self) -> socket.socket: + """Establish a socket connection and set nodelay settings on it. + + :return: New socket connection. + """ + try: + sock = connection.create_connection( + (self._dns_host, self.port), + self.timeout, + source_address=self.source_address, + socket_options=self.socket_options, + ) + except socket.gaierror as e: + raise NameResolutionError(self.host, self, e) from e + except SocketTimeout as e: + raise ConnectTimeoutError( + self, + f"Connection to {self.host} timed out. (connect timeout={self.timeout})", + ) from e + + except OSError as e: + raise NewConnectionError( + self, f"Failed to establish a new connection: {e}" + ) from e + + # Audit hooks are only available in Python 3.8+ + if _HAS_SYS_AUDIT: + sys.audit("http.client.connect", self, self.host, self.port) + + return sock + + def set_tunnel( + self, + host: str, + port: int | None = None, + headers: typing.Mapping[str, str] | None = None, + scheme: str = "http", + ) -> None: + if scheme not in ("http", "https"): + raise ValueError( + f"Invalid proxy scheme for tunneling: {scheme!r}, must be either 'http' or 'https'" + ) + super().set_tunnel(host, port=port, headers=headers) + self._tunnel_scheme = scheme + + def connect(self) -> None: + self.sock = self._new_conn() + if self._tunnel_host: + # If we're tunneling it means we're connected to our proxy. + self._has_connected_to_proxy = True + + # TODO: Fix tunnel so it doesn't depend on self.sock state. + self._tunnel() # type: ignore[attr-defined] + + # If there's a proxy to be connected to we are fully connected. + # This is set twice (once above and here) due to forwarding proxies + # not using tunnelling. + self._has_connected_to_proxy = bool(self.proxy) + + @property + def is_closed(self) -> bool: + return self.sock is None + + @property + def is_connected(self) -> bool: + if self.sock is None: + return False + return not wait_for_read(self.sock, timeout=0.0) + + @property + def has_connected_to_proxy(self) -> bool: + return self._has_connected_to_proxy + + def close(self) -> None: + try: + super().close() + finally: + # Reset all stateful properties so connection + # can be re-used without leaking prior configs. + self.sock = None + self.is_verified = False + self.proxy_is_verified = None + self._has_connected_to_proxy = False + self._response_options = None + self._tunnel_host = None + self._tunnel_port = None + self._tunnel_scheme = None + + def putrequest( + self, + method: str, + url: str, + skip_host: bool = False, + skip_accept_encoding: bool = False, + ) -> None: + """""" + # Empty docstring because the indentation of CPython's implementation + # is broken but we don't want this method in our documentation. + match = _CONTAINS_CONTROL_CHAR_RE.search(method) + if match: + raise ValueError( + f"Method cannot contain non-token characters {method!r} (found at least {match.group()!r})" + ) + + return super().putrequest( + method, url, skip_host=skip_host, skip_accept_encoding=skip_accept_encoding + ) + + def putheader(self, header: str, *values: str) -> None: + """""" + if not any(isinstance(v, str) and v == SKIP_HEADER for v in values): + super().putheader(header, *values) + elif to_str(header.lower()) not in SKIPPABLE_HEADERS: + skippable_headers = "', '".join( + [str.title(header) for header in sorted(SKIPPABLE_HEADERS)] + ) + raise ValueError( + f"urllib3.util.SKIP_HEADER only supports '{skippable_headers}'" + ) + + # `request` method's signature intentionally violates LSP. + # urllib3's API is different from `http.client.HTTPConnection` and the subclassing is only incidental. + def request( # type: ignore[override] + self, + method: str, + url: str, + body: _TYPE_BODY | None = None, + headers: typing.Mapping[str, str] | None = None, + *, + chunked: bool = False, + preload_content: bool = True, + decode_content: bool = True, + enforce_content_length: bool = True, + ) -> None: + # Update the inner socket's timeout value to send the request. + # This only triggers if the connection is re-used. + if self.sock is not None: + self.sock.settimeout(self.timeout) + + # Store these values to be fed into the HTTPResponse + # object later. TODO: Remove this in favor of a real + # HTTP lifecycle mechanism. + + # We have to store these before we call .request() + # because sometimes we can still salvage a response + # off the wire even if we aren't able to completely + # send the request body. + self._response_options = _ResponseOptions( + request_method=method, + request_url=url, + preload_content=preload_content, + decode_content=decode_content, + enforce_content_length=enforce_content_length, + ) + + if headers is None: + headers = {} + header_keys = frozenset(to_str(k.lower()) for k in headers) + skip_accept_encoding = "accept-encoding" in header_keys + skip_host = "host" in header_keys + self.putrequest( + method, url, skip_accept_encoding=skip_accept_encoding, skip_host=skip_host + ) + + # Transform the body into an iterable of sendall()-able chunks + # and detect if an explicit Content-Length is doable. + chunks_and_cl = body_to_chunks(body, method=method, blocksize=self.blocksize) + chunks = chunks_and_cl.chunks + content_length = chunks_and_cl.content_length + + # When chunked is explicit set to 'True' we respect that. + if chunked: + if "transfer-encoding" not in header_keys: + self.putheader("Transfer-Encoding", "chunked") + else: + # Detect whether a framing mechanism is already in use. If so + # we respect that value, otherwise we pick chunked vs content-length + # depending on the type of 'body'. + if "content-length" in header_keys: + chunked = False + elif "transfer-encoding" in header_keys: + chunked = True + + # Otherwise we go off the recommendation of 'body_to_chunks()'. + else: + chunked = False + if content_length is None: + if chunks is not None: + chunked = True + self.putheader("Transfer-Encoding", "chunked") + else: + self.putheader("Content-Length", str(content_length)) + + # Now that framing headers are out of the way we send all the other headers. + if "user-agent" not in header_keys: + self.putheader("User-Agent", _get_default_user_agent()) + for header, value in headers.items(): + self.putheader(header, value) + self.endheaders() + + # If we're given a body we start sending that in chunks. + if chunks is not None: + for chunk in chunks: + # Sending empty chunks isn't allowed for TE: chunked + # as it indicates the end of the body. + if not chunk: + continue + if isinstance(chunk, str): + chunk = chunk.encode("utf-8") + if chunked: + self.send(b"%x\r\n%b\r\n" % (len(chunk), chunk)) + else: + self.send(chunk) + + # Regardless of whether we have a body or not, if we're in + # chunked mode we want to send an explicit empty chunk. + if chunked: + self.send(b"0\r\n\r\n") + + def request_chunked( + self, + method: str, + url: str, + body: _TYPE_BODY | None = None, + headers: typing.Mapping[str, str] | None = None, + ) -> None: + """ + Alternative to the common request method, which sends the + body with chunked encoding and not as one block + """ + warnings.warn( + "HTTPConnection.request_chunked() is deprecated and will be removed " + "in urllib3 v2.1.0. Instead use HTTPConnection.request(..., chunked=True).", + category=DeprecationWarning, + stacklevel=2, + ) + self.request(method, url, body=body, headers=headers, chunked=True) + + def getresponse( # type: ignore[override] + self, + ) -> HTTPResponse: + """ + Get the response from the server. + + If the HTTPConnection is in the correct state, returns an instance of HTTPResponse or of whatever object is returned by the response_class variable. + + If a request has not been sent or if a previous response has not be handled, ResponseNotReady is raised. If the HTTP response indicates that the connection should be closed, then it will be closed before the response is returned. When the connection is closed, the underlying socket is closed. + """ + # Raise the same error as http.client.HTTPConnection + if self._response_options is None: + raise ResponseNotReady() + + # Reset this attribute for being used again. + resp_options = self._response_options + self._response_options = None + + # Since the connection's timeout value may have been updated + # we need to set the timeout on the socket. + self.sock.settimeout(self.timeout) + + # This is needed here to avoid circular import errors + from .response import HTTPResponse + + # Get the response from http.client.HTTPConnection + httplib_response = super().getresponse() + + try: + assert_header_parsing(httplib_response.msg) + except (HeaderParsingError, TypeError) as hpe: + log.warning( + "Failed to parse headers (url=%s): %s", + _url_from_connection(self, resp_options.request_url), + hpe, + exc_info=True, + ) + + headers = HTTPHeaderDict(httplib_response.msg.items()) + + response = HTTPResponse( + body=httplib_response, + headers=headers, + status=httplib_response.status, + version=httplib_response.version, + reason=httplib_response.reason, + preload_content=resp_options.preload_content, + decode_content=resp_options.decode_content, + original_response=httplib_response, + enforce_content_length=resp_options.enforce_content_length, + request_method=resp_options.request_method, + request_url=resp_options.request_url, + ) + return response + + +class HTTPSConnection(HTTPConnection): + """ + Many of the parameters to this constructor are passed to the underlying SSL + socket by means of :py:func:`urllib3.util.ssl_wrap_socket`. + """ + + default_port = port_by_scheme["https"] # type: ignore[misc] + + cert_reqs: int | str | None = None + ca_certs: str | None = None + ca_cert_dir: str | None = None + ca_cert_data: None | str | bytes = None + ssl_version: int | str | None = None + ssl_minimum_version: int | None = None + ssl_maximum_version: int | None = None + assert_fingerprint: str | None = None + + def __init__( + self, + host: str, + port: int | None = None, + *, + timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, + source_address: tuple[str, int] | None = None, + blocksize: int = 16384, + socket_options: None + | (connection._TYPE_SOCKET_OPTIONS) = HTTPConnection.default_socket_options, + proxy: Url | None = None, + proxy_config: ProxyConfig | None = None, + cert_reqs: int | str | None = None, + assert_hostname: None | str | Literal[False] = None, + assert_fingerprint: str | None = None, + server_hostname: str | None = None, + ssl_context: ssl.SSLContext | None = None, + ca_certs: str | None = None, + ca_cert_dir: str | None = None, + ca_cert_data: None | str | bytes = None, + ssl_minimum_version: int | None = None, + ssl_maximum_version: int | None = None, + ssl_version: int | str | None = None, # Deprecated + cert_file: str | None = None, + key_file: str | None = None, + key_password: str | None = None, + ) -> None: + super().__init__( + host, + port=port, + timeout=timeout, + source_address=source_address, + blocksize=blocksize, + socket_options=socket_options, + proxy=proxy, + proxy_config=proxy_config, + ) + + self.key_file = key_file + self.cert_file = cert_file + self.key_password = key_password + self.ssl_context = ssl_context + self.server_hostname = server_hostname + self.assert_hostname = assert_hostname + self.assert_fingerprint = assert_fingerprint + self.ssl_version = ssl_version + self.ssl_minimum_version = ssl_minimum_version + self.ssl_maximum_version = ssl_maximum_version + self.ca_certs = ca_certs and os.path.expanduser(ca_certs) + self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir) + self.ca_cert_data = ca_cert_data + + # cert_reqs depends on ssl_context so calculate last. + if cert_reqs is None: + if self.ssl_context is not None: + cert_reqs = self.ssl_context.verify_mode + else: + cert_reqs = resolve_cert_reqs(None) + self.cert_reqs = cert_reqs + + def set_cert( + self, + key_file: str | None = None, + cert_file: str | None = None, + cert_reqs: int | str | None = None, + key_password: str | None = None, + ca_certs: str | None = None, + assert_hostname: None | str | Literal[False] = None, + assert_fingerprint: str | None = None, + ca_cert_dir: str | None = None, + ca_cert_data: None | str | bytes = None, + ) -> None: + """ + This method should only be called once, before the connection is used. + """ + warnings.warn( + "HTTPSConnection.set_cert() is deprecated and will be removed " + "in urllib3 v2.1.0. Instead provide the parameters to the " + "HTTPSConnection constructor.", + category=DeprecationWarning, + stacklevel=2, + ) + + # If cert_reqs is not provided we'll assume CERT_REQUIRED unless we also + # have an SSLContext object in which case we'll use its verify_mode. + if cert_reqs is None: + if self.ssl_context is not None: + cert_reqs = self.ssl_context.verify_mode + else: + cert_reqs = resolve_cert_reqs(None) + + self.key_file = key_file + self.cert_file = cert_file + self.cert_reqs = cert_reqs + self.key_password = key_password + self.assert_hostname = assert_hostname + self.assert_fingerprint = assert_fingerprint + self.ca_certs = ca_certs and os.path.expanduser(ca_certs) + self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir) + self.ca_cert_data = ca_cert_data + + def connect(self) -> None: + sock: socket.socket | ssl.SSLSocket + self.sock = sock = self._new_conn() + server_hostname: str = self.host + tls_in_tls = False + + # Do we need to establish a tunnel? + if self._tunnel_host is not None: + # We're tunneling to an HTTPS origin so need to do TLS-in-TLS. + if self._tunnel_scheme == "https": + self.sock = sock = self._connect_tls_proxy(self.host, sock) + tls_in_tls = True + + # If we're tunneling it means we're connected to our proxy. + self._has_connected_to_proxy = True + + self._tunnel() # type: ignore[attr-defined] + # Override the host with the one we're requesting data from. + server_hostname = self._tunnel_host + + if self.server_hostname is not None: + server_hostname = self.server_hostname + + is_time_off = datetime.date.today() < RECENT_DATE + if is_time_off: + warnings.warn( + ( + f"System time is way off (before {RECENT_DATE}). This will probably " + "lead to SSL verification errors" + ), + SystemTimeWarning, + ) + + sock_and_verified = _ssl_wrap_socket_and_match_hostname( + sock=sock, + cert_reqs=self.cert_reqs, + ssl_version=self.ssl_version, + ssl_minimum_version=self.ssl_minimum_version, + ssl_maximum_version=self.ssl_maximum_version, + ca_certs=self.ca_certs, + ca_cert_dir=self.ca_cert_dir, + ca_cert_data=self.ca_cert_data, + cert_file=self.cert_file, + key_file=self.key_file, + key_password=self.key_password, + server_hostname=server_hostname, + ssl_context=self.ssl_context, + tls_in_tls=tls_in_tls, + assert_hostname=self.assert_hostname, + assert_fingerprint=self.assert_fingerprint, + ) + self.sock = sock_and_verified.socket + self.is_verified = sock_and_verified.is_verified + + # If there's a proxy to be connected to we are fully connected. + # This is set twice (once above and here) due to forwarding proxies + # not using tunnelling. + self._has_connected_to_proxy = bool(self.proxy) + + def _connect_tls_proxy(self, hostname: str, sock: socket.socket) -> ssl.SSLSocket: + """ + Establish a TLS connection to the proxy using the provided SSL context. + """ + # `_connect_tls_proxy` is called when self._tunnel_host is truthy. + proxy_config = typing.cast(ProxyConfig, self.proxy_config) + ssl_context = proxy_config.ssl_context + sock_and_verified = _ssl_wrap_socket_and_match_hostname( + sock, + cert_reqs=self.cert_reqs, + ssl_version=self.ssl_version, + ssl_minimum_version=self.ssl_minimum_version, + ssl_maximum_version=self.ssl_maximum_version, + ca_certs=self.ca_certs, + ca_cert_dir=self.ca_cert_dir, + ca_cert_data=self.ca_cert_data, + server_hostname=hostname, + ssl_context=ssl_context, + assert_hostname=proxy_config.assert_hostname, + assert_fingerprint=proxy_config.assert_fingerprint, + # Features that aren't implemented for proxies yet: + cert_file=None, + key_file=None, + key_password=None, + tls_in_tls=False, + ) + self.proxy_is_verified = sock_and_verified.is_verified + return sock_and_verified.socket # type: ignore[return-value] + + +class _WrappedAndVerifiedSocket(typing.NamedTuple): + """ + Wrapped socket and whether the connection is + verified after the TLS handshake + """ + + socket: ssl.SSLSocket | SSLTransport + is_verified: bool + + +def _ssl_wrap_socket_and_match_hostname( + sock: socket.socket, + *, + cert_reqs: None | str | int, + ssl_version: None | str | int, + ssl_minimum_version: int | None, + ssl_maximum_version: int | None, + cert_file: str | None, + key_file: str | None, + key_password: str | None, + ca_certs: str | None, + ca_cert_dir: str | None, + ca_cert_data: None | str | bytes, + assert_hostname: None | str | Literal[False], + assert_fingerprint: str | None, + server_hostname: str | None, + ssl_context: ssl.SSLContext | None, + tls_in_tls: bool = False, +) -> _WrappedAndVerifiedSocket: + """Logic for constructing an SSLContext from all TLS parameters, passing + that down into ssl_wrap_socket, and then doing certificate verification + either via hostname or fingerprint. This function exists to guarantee + that both proxies and targets have the same behavior when connecting via TLS. + """ + default_ssl_context = False + if ssl_context is None: + default_ssl_context = True + context = create_urllib3_context( + ssl_version=resolve_ssl_version(ssl_version), + ssl_minimum_version=ssl_minimum_version, + ssl_maximum_version=ssl_maximum_version, + cert_reqs=resolve_cert_reqs(cert_reqs), + ) + else: + context = ssl_context + + context.verify_mode = resolve_cert_reqs(cert_reqs) + + # In some cases, we want to verify hostnames ourselves + if ( + # `ssl` can't verify fingerprints or alternate hostnames + assert_fingerprint + or assert_hostname + # assert_hostname can be set to False to disable hostname checking + or assert_hostname is False + # We still support OpenSSL 1.0.2, which prevents us from verifying + # hostnames easily: https://github.com/pyca/pyopenssl/pull/933 + or ssl_.IS_PYOPENSSL + or not ssl_.HAS_NEVER_CHECK_COMMON_NAME + ): + context.check_hostname = False + + # Try to load OS default certs if none are given. We need to do the hasattr() check + # for custom pyOpenSSL SSLContext objects because they don't support + # load_default_certs(). + if ( + not ca_certs + and not ca_cert_dir + and not ca_cert_data + and default_ssl_context + and hasattr(context, "load_default_certs") + ): + context.load_default_certs() + + # Ensure that IPv6 addresses are in the proper format and don't have a + # scope ID. Python's SSL module fails to recognize scoped IPv6 addresses + # and interprets them as DNS hostnames. + if server_hostname is not None: + normalized = server_hostname.strip("[]") + if "%" in normalized: + normalized = normalized[: normalized.rfind("%")] + if is_ipaddress(normalized): + server_hostname = normalized + + ssl_sock = ssl_wrap_socket( + sock=sock, + keyfile=key_file, + certfile=cert_file, + key_password=key_password, + ca_certs=ca_certs, + ca_cert_dir=ca_cert_dir, + ca_cert_data=ca_cert_data, + server_hostname=server_hostname, + ssl_context=context, + tls_in_tls=tls_in_tls, + ) + + try: + if assert_fingerprint: + _assert_fingerprint( + ssl_sock.getpeercert(binary_form=True), assert_fingerprint + ) + elif ( + context.verify_mode != ssl.CERT_NONE + and not context.check_hostname + and assert_hostname is not False + ): + cert: _TYPE_PEER_CERT_RET_DICT = ssl_sock.getpeercert() # type: ignore[assignment] + + # Need to signal to our match_hostname whether to use 'commonName' or not. + # If we're using our own constructed SSLContext we explicitly set 'False' + # because PyPy hard-codes 'True' from SSLContext.hostname_checks_common_name. + if default_ssl_context: + hostname_checks_common_name = False + else: + hostname_checks_common_name = ( + getattr(context, "hostname_checks_common_name", False) or False + ) + + _match_hostname( + cert, + assert_hostname or server_hostname, # type: ignore[arg-type] + hostname_checks_common_name, + ) + + return _WrappedAndVerifiedSocket( + socket=ssl_sock, + is_verified=context.verify_mode == ssl.CERT_REQUIRED + or bool(assert_fingerprint), + ) + except BaseException: + ssl_sock.close() + raise + + +def _match_hostname( + cert: _TYPE_PEER_CERT_RET_DICT | None, + asserted_hostname: str, + hostname_checks_common_name: bool = False, +) -> None: + # Our upstream implementation of ssl.match_hostname() + # only applies this normalization to IP addresses so it doesn't + # match DNS SANs so we do the same thing! + stripped_hostname = asserted_hostname.strip("[]") + if is_ipaddress(stripped_hostname): + asserted_hostname = stripped_hostname + + try: + match_hostname(cert, asserted_hostname, hostname_checks_common_name) + except CertificateError as e: + log.warning( + "Certificate did not match expected hostname: %s. Certificate: %s", + asserted_hostname, + cert, + ) + # Add cert to exception and reraise so client code can inspect + # the cert when catching the exception, if they want to + e._peer_cert = cert # type: ignore[attr-defined] + raise + + +def _wrap_proxy_error(err: Exception, proxy_scheme: str | None) -> ProxyError: + # Look for the phrase 'wrong version number', if found + # then we should warn the user that we're very sure that + # this proxy is HTTP-only and they have a configuration issue. + error_normalized = " ".join(re.split("[^a-z]", str(err).lower())) + is_likely_http_proxy = ( + "wrong version number" in error_normalized + or "unknown protocol" in error_normalized + ) + http_proxy_warning = ( + ". Your proxy appears to only use HTTP and not HTTPS, " + "try changing your proxy URL to be HTTP. See: " + "https://urllib3.readthedocs.io/en/latest/advanced-usage.html" + "#https-proxy-error-http-proxy" + ) + new_err = ProxyError( + f"Unable to connect to proxy" + f"{http_proxy_warning if is_likely_http_proxy and proxy_scheme == 'https' else ''}", + err, + ) + new_err.__cause__ = err + return new_err + + +def _get_default_user_agent() -> str: + return f"python-urllib3/{__version__}" + + +class DummyConnection: + """Used to detect a failed ConnectionCls import.""" + + +if not ssl: + HTTPSConnection = DummyConnection # type: ignore[misc, assignment] # noqa: F811 + + +VerifiedHTTPSConnection = HTTPSConnection + + +def _url_from_connection( + conn: HTTPConnection | HTTPSConnection, path: str | None = None +) -> str: + """Returns the URL from a given connection. This is mainly used for testing and logging.""" + + scheme = "https" if isinstance(conn, HTTPSConnection) else "http" + + return Url(scheme=scheme, host=conn.host, port=conn.port, path=path).url diff --git a/Modules/urllib3/connectionpool.py b/Modules/urllib3/connectionpool.py new file mode 100644 index 0000000..70048b7 --- /dev/null +++ b/Modules/urllib3/connectionpool.py @@ -0,0 +1,1182 @@ +from __future__ import annotations + +import errno +import logging +import queue +import sys +import typing +import warnings +import weakref +from socket import timeout as SocketTimeout +from types import TracebackType + +from ._base_connection import _TYPE_BODY +from ._collections import HTTPHeaderDict +from ._request_methods import RequestMethods +from .connection import ( + BaseSSLError, + BrokenPipeError, + DummyConnection, + HTTPConnection, + HTTPException, + HTTPSConnection, + ProxyConfig, + _wrap_proxy_error, +) +from .connection import port_by_scheme as port_by_scheme +from .exceptions import ( + ClosedPoolError, + EmptyPoolError, + FullPoolError, + HostChangedError, + InsecureRequestWarning, + LocationValueError, + MaxRetryError, + NewConnectionError, + ProtocolError, + ProxyError, + ReadTimeoutError, + SSLError, + TimeoutError, +) +from .response import BaseHTTPResponse +from .util.connection import is_connection_dropped +from .util.proxy import connection_requires_http_tunnel +from .util.request import _TYPE_BODY_POSITION, set_file_position +from .util.retry import Retry +from .util.ssl_match_hostname import CertificateError +from .util.timeout import _DEFAULT_TIMEOUT, _TYPE_DEFAULT, Timeout +from .util.url import Url, _encode_target +from .util.url import _normalize_host as normalize_host +from .util.url import parse_url +from .util.util import to_str + +if typing.TYPE_CHECKING: + import ssl + from typing import Literal + + from ._base_connection import BaseHTTPConnection, BaseHTTPSConnection + +log = logging.getLogger(__name__) + +_TYPE_TIMEOUT = typing.Union[Timeout, float, _TYPE_DEFAULT, None] + +_SelfT = typing.TypeVar("_SelfT") + + +# Pool objects +class ConnectionPool: + """ + Base class for all connection pools, such as + :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`. + + .. note:: + ConnectionPool.urlopen() does not normalize or percent-encode target URIs + which is useful if your target server doesn't support percent-encoded + target URIs. + """ + + scheme: str | None = None + QueueCls = queue.LifoQueue + + def __init__(self, host: str, port: int | None = None) -> None: + if not host: + raise LocationValueError("No host specified.") + + self.host = _normalize_host(host, scheme=self.scheme) + self.port = port + + # This property uses 'normalize_host()' (not '_normalize_host()') + # to avoid removing square braces around IPv6 addresses. + # This value is sent to `HTTPConnection.set_tunnel()` if called + # because square braces are required for HTTP CONNECT tunneling. + self._tunnel_host = normalize_host(host, scheme=self.scheme).lower() + + def __str__(self) -> str: + return f"{type(self).__name__}(host={self.host!r}, port={self.port!r})" + + def __enter__(self: _SelfT) -> _SelfT: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> Literal[False]: + self.close() + # Return False to re-raise any potential exceptions + return False + + def close(self) -> None: + """ + Close all pooled connections and disable the pool. + """ + + +# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252 +_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK} + + +class HTTPConnectionPool(ConnectionPool, RequestMethods): + """ + Thread-safe connection pool for one host. + + :param host: + Host used for this HTTP Connection (e.g. "localhost"), passed into + :class:`http.client.HTTPConnection`. + + :param port: + Port used for this HTTP Connection (None is equivalent to 80), passed + into :class:`http.client.HTTPConnection`. + + :param timeout: + Socket timeout in seconds for each individual connection. This can + be a float or integer, which sets the timeout for the HTTP request, + or an instance of :class:`urllib3.util.Timeout` which gives you more + fine-grained control over request timeouts. After the constructor has + been parsed, this is always a `urllib3.util.Timeout` object. + + :param maxsize: + Number of connections to save that can be reused. More than 1 is useful + in multithreaded situations. If ``block`` is set to False, more + connections will be created but they will not be saved once they've + been used. + + :param block: + If set to True, no more than ``maxsize`` connections will be used at + a time. When no free connections are available, the call will block + until a connection has been released. This is a useful side effect for + particular multithreaded situations where one does not want to use more + than maxsize connections per host to prevent flooding. + + :param headers: + Headers to include with all requests, unless other headers are given + explicitly. + + :param retries: + Retry configuration to use by default with requests in this pool. + + :param _proxy: + Parsed proxy URL, should not be used directly, instead, see + :class:`urllib3.ProxyManager` + + :param _proxy_headers: + A dictionary with proxy headers, should not be used directly, + instead, see :class:`urllib3.ProxyManager` + + :param \\**conn_kw: + Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`, + :class:`urllib3.connection.HTTPSConnection` instances. + """ + + scheme = "http" + ConnectionCls: ( + type[BaseHTTPConnection] | type[BaseHTTPSConnection] + ) = HTTPConnection + + def __init__( + self, + host: str, + port: int | None = None, + timeout: _TYPE_TIMEOUT | None = _DEFAULT_TIMEOUT, + maxsize: int = 1, + block: bool = False, + headers: typing.Mapping[str, str] | None = None, + retries: Retry | bool | int | None = None, + _proxy: Url | None = None, + _proxy_headers: typing.Mapping[str, str] | None = None, + _proxy_config: ProxyConfig | None = None, + **conn_kw: typing.Any, + ): + ConnectionPool.__init__(self, host, port) + RequestMethods.__init__(self, headers) + + if not isinstance(timeout, Timeout): + timeout = Timeout.from_float(timeout) + + if retries is None: + retries = Retry.DEFAULT + + self.timeout = timeout + self.retries = retries + + self.pool: queue.LifoQueue[typing.Any] | None = self.QueueCls(maxsize) + self.block = block + + self.proxy = _proxy + self.proxy_headers = _proxy_headers or {} + self.proxy_config = _proxy_config + + # Fill the queue up so that doing get() on it will block properly + for _ in range(maxsize): + self.pool.put(None) + + # These are mostly for testing and debugging purposes. + self.num_connections = 0 + self.num_requests = 0 + self.conn_kw = conn_kw + + if self.proxy: + # Enable Nagle's algorithm for proxies, to avoid packet fragmentation. + # We cannot know if the user has added default socket options, so we cannot replace the + # list. + self.conn_kw.setdefault("socket_options", []) + + self.conn_kw["proxy"] = self.proxy + self.conn_kw["proxy_config"] = self.proxy_config + + # Do not pass 'self' as callback to 'finalize'. + # Then the 'finalize' would keep an endless living (leak) to self. + # By just passing a reference to the pool allows the garbage collector + # to free self if nobody else has a reference to it. + pool = self.pool + + # Close all the HTTPConnections in the pool before the + # HTTPConnectionPool object is garbage collected. + weakref.finalize(self, _close_pool_connections, pool) + + def _new_conn(self) -> BaseHTTPConnection: + """ + Return a fresh :class:`HTTPConnection`. + """ + self.num_connections += 1 + log.debug( + "Starting new HTTP connection (%d): %s:%s", + self.num_connections, + self.host, + self.port or "80", + ) + + conn = self.ConnectionCls( + host=self.host, + port=self.port, + timeout=self.timeout.connect_timeout, + **self.conn_kw, + ) + return conn + + def _get_conn(self, timeout: float | None = None) -> BaseHTTPConnection: + """ + Get a connection. Will return a pooled connection if one is available. + + If no connections are available and :prop:`.block` is ``False``, then a + fresh connection is returned. + + :param timeout: + Seconds to wait before giving up and raising + :class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and + :prop:`.block` is ``True``. + """ + conn = None + + if self.pool is None: + raise ClosedPoolError(self, "Pool is closed.") + + try: + conn = self.pool.get(block=self.block, timeout=timeout) + + except AttributeError: # self.pool is None + raise ClosedPoolError(self, "Pool is closed.") from None # Defensive: + + except queue.Empty: + if self.block: + raise EmptyPoolError( + self, + "Pool is empty and a new connection can't be opened due to blocking mode.", + ) from None + pass # Oh well, we'll create a new connection then + + # If this is a persistent connection, check if it got disconnected + if conn and is_connection_dropped(conn): + log.debug("Resetting dropped connection: %s", self.host) + conn.close() + + return conn or self._new_conn() + + def _put_conn(self, conn: BaseHTTPConnection | None) -> None: + """ + Put a connection back into the pool. + + :param conn: + Connection object for the current host and port as returned by + :meth:`._new_conn` or :meth:`._get_conn`. + + If the pool is already full, the connection is closed and discarded + because we exceeded maxsize. If connections are discarded frequently, + then maxsize should be increased. + + If the pool is closed, then the connection will be closed and discarded. + """ + if self.pool is not None: + try: + self.pool.put(conn, block=False) + return # Everything is dandy, done. + except AttributeError: + # self.pool is None. + pass + except queue.Full: + # Connection never got put back into the pool, close it. + if conn: + conn.close() + + if self.block: + # This should never happen if you got the conn from self._get_conn + raise FullPoolError( + self, + "Pool reached maximum size and no more connections are allowed.", + ) from None + + log.warning( + "Connection pool is full, discarding connection: %s. Connection pool size: %s", + self.host, + self.pool.qsize(), + ) + + # Connection never got put back into the pool, close it. + if conn: + conn.close() + + def _validate_conn(self, conn: BaseHTTPConnection) -> None: + """ + Called right before a request is made, after the socket is created. + """ + + def _prepare_proxy(self, conn: BaseHTTPConnection) -> None: + # Nothing to do for HTTP connections. + pass + + def _get_timeout(self, timeout: _TYPE_TIMEOUT) -> Timeout: + """Helper that always returns a :class:`urllib3.util.Timeout`""" + if timeout is _DEFAULT_TIMEOUT: + return self.timeout.clone() + + if isinstance(timeout, Timeout): + return timeout.clone() + else: + # User passed us an int/float. This is for backwards compatibility, + # can be removed later + return Timeout.from_float(timeout) + + def _raise_timeout( + self, + err: BaseSSLError | OSError | SocketTimeout, + url: str, + timeout_value: _TYPE_TIMEOUT | None, + ) -> None: + """Is the error actually a timeout? Will raise a ReadTimeout or pass""" + + if isinstance(err, SocketTimeout): + raise ReadTimeoutError( + self, url, f"Read timed out. (read timeout={timeout_value})" + ) from err + + # See the above comment about EAGAIN in Python 3. + if hasattr(err, "errno") and err.errno in _blocking_errnos: + raise ReadTimeoutError( + self, url, f"Read timed out. (read timeout={timeout_value})" + ) from err + + def _make_request( + self, + conn: BaseHTTPConnection, + method: str, + url: str, + body: _TYPE_BODY | None = None, + headers: typing.Mapping[str, str] | None = None, + retries: Retry | None = None, + timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, + chunked: bool = False, + response_conn: BaseHTTPConnection | None = None, + preload_content: bool = True, + decode_content: bool = True, + enforce_content_length: bool = True, + ) -> BaseHTTPResponse: + """ + Perform a request on a given urllib connection object taken from our + pool. + + :param conn: + a connection from one of our connection pools + + :param method: + HTTP request method (such as GET, POST, PUT, etc.) + + :param url: + The URL to perform the request on. + + :param body: + Data to send in the request body, either :class:`str`, :class:`bytes`, + an iterable of :class:`str`/:class:`bytes`, or a file-like object. + + :param headers: + Dictionary of custom headers to send, such as User-Agent, + If-None-Match, etc. If None, pool headers are used. If provided, + these headers completely replace any pool-specific headers. + + :param retries: + Configure the number of retries to allow before raising a + :class:`~urllib3.exceptions.MaxRetryError` exception. + + Pass ``None`` to retry until you receive a response. Pass a + :class:`~urllib3.util.retry.Retry` object for fine-grained control + over different types of retries. + Pass an integer number to retry connection errors that many times, + but no other types of errors. Pass zero to never retry. + + If ``False``, then retries are disabled and any exception is raised + immediately. Also, instead of raising a MaxRetryError on redirects, + the redirect response will be returned. + + :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int. + + :param timeout: + If specified, overrides the default timeout for this one + request. It may be a float (in seconds) or an instance of + :class:`urllib3.util.Timeout`. + + :param chunked: + If True, urllib3 will send the body using chunked transfer + encoding. Otherwise, urllib3 will send the body using the standard + content-length form. Defaults to False. + + :param response_conn: + Set this to ``None`` if you will handle releasing the connection or + set the connection to have the response release it. + + :param preload_content: + If True, the response's body will be preloaded during construction. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + + :param enforce_content_length: + Enforce content length checking. Body returned by server must match + value of Content-Length header, if present. Otherwise, raise error. + """ + self.num_requests += 1 + + timeout_obj = self._get_timeout(timeout) + timeout_obj.start_connect() + conn.timeout = Timeout.resolve_default_timeout(timeout_obj.connect_timeout) + + try: + # Trigger any extra validation we need to do. + try: + self._validate_conn(conn) + except (SocketTimeout, BaseSSLError) as e: + self._raise_timeout(err=e, url=url, timeout_value=conn.timeout) + raise + + # _validate_conn() starts the connection to an HTTPS proxy + # so we need to wrap errors with 'ProxyError' here too. + except ( + OSError, + NewConnectionError, + TimeoutError, + BaseSSLError, + CertificateError, + SSLError, + ) as e: + new_e: Exception = e + if isinstance(e, (BaseSSLError, CertificateError)): + new_e = SSLError(e) + # If the connection didn't successfully connect to it's proxy + # then there + if isinstance( + new_e, (OSError, NewConnectionError, TimeoutError, SSLError) + ) and (conn and conn.proxy and not conn.has_connected_to_proxy): + new_e = _wrap_proxy_error(new_e, conn.proxy.scheme) + raise new_e + + # conn.request() calls http.client.*.request, not the method in + # urllib3.request. It also calls makefile (recv) on the socket. + try: + conn.request( + method, + url, + body=body, + headers=headers, + chunked=chunked, + preload_content=preload_content, + decode_content=decode_content, + enforce_content_length=enforce_content_length, + ) + + # We are swallowing BrokenPipeError (errno.EPIPE) since the server is + # legitimately able to close the connection after sending a valid response. + # With this behaviour, the received response is still readable. + except BrokenPipeError: + pass + except OSError as e: + # MacOS/Linux + # EPROTOTYPE is needed on macOS + # https://erickt.github.io/blog/2014/11/19/adventures-in-debugging-a-potential-osx-kernel-bug/ + if e.errno != errno.EPROTOTYPE: + raise + + # Reset the timeout for the recv() on the socket + read_timeout = timeout_obj.read_timeout + + if not conn.is_closed: + # In Python 3 socket.py will catch EAGAIN and return None when you + # try and read into the file pointer created by http.client, which + # instead raises a BadStatusLine exception. Instead of catching + # the exception and assuming all BadStatusLine exceptions are read + # timeouts, check for a zero timeout before making the request. + if read_timeout == 0: + raise ReadTimeoutError( + self, url, f"Read timed out. (read timeout={read_timeout})" + ) + conn.timeout = read_timeout + + # Receive the response from the server + try: + response = conn.getresponse() + except (BaseSSLError, OSError) as e: + self._raise_timeout(err=e, url=url, timeout_value=read_timeout) + raise + + # Set properties that are used by the pooling layer. + response.retries = retries + response._connection = response_conn # type: ignore[attr-defined] + response._pool = self # type: ignore[attr-defined] + + log.debug( + '%s://%s:%s "%s %s %s" %s %s', + self.scheme, + self.host, + self.port, + method, + url, + # HTTP version + conn._http_vsn_str, # type: ignore[attr-defined] + response.status, + response.length_remaining, # type: ignore[attr-defined] + ) + + return response + + def close(self) -> None: + """ + Close all pooled connections and disable the pool. + """ + if self.pool is None: + return + # Disable access to the pool + old_pool, self.pool = self.pool, None + + # Close all the HTTPConnections in the pool. + _close_pool_connections(old_pool) + + def is_same_host(self, url: str) -> bool: + """ + Check if the given ``url`` is a member of the same host as this + connection pool. + """ + if url.startswith("/"): + return True + + # TODO: Add optional support for socket.gethostbyname checking. + scheme, _, host, port, *_ = parse_url(url) + scheme = scheme or "http" + if host is not None: + host = _normalize_host(host, scheme=scheme) + + # Use explicit default port for comparison when none is given + if self.port and not port: + port = port_by_scheme.get(scheme) + elif not self.port and port == port_by_scheme.get(scheme): + port = None + + return (scheme, host, port) == (self.scheme, self.host, self.port) + + def urlopen( # type: ignore[override] + self, + method: str, + url: str, + body: _TYPE_BODY | None = None, + headers: typing.Mapping[str, str] | None = None, + retries: Retry | bool | int | None = None, + redirect: bool = True, + assert_same_host: bool = True, + timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, + pool_timeout: int | None = None, + release_conn: bool | None = None, + chunked: bool = False, + body_pos: _TYPE_BODY_POSITION | None = None, + preload_content: bool = True, + decode_content: bool = True, + **response_kw: typing.Any, + ) -> BaseHTTPResponse: + """ + Get a connection from the pool and perform an HTTP request. This is the + lowest level call for making a request, so you'll need to specify all + the raw details. + + .. note:: + + More commonly, it's appropriate to use a convenience method + such as :meth:`request`. + + .. note:: + + `release_conn` will only behave as expected if + `preload_content=False` because we want to make + `preload_content=False` the default behaviour someday soon without + breaking backwards compatibility. + + :param method: + HTTP request method (such as GET, POST, PUT, etc.) + + :param url: + The URL to perform the request on. + + :param body: + Data to send in the request body, either :class:`str`, :class:`bytes`, + an iterable of :class:`str`/:class:`bytes`, or a file-like object. + + :param headers: + Dictionary of custom headers to send, such as User-Agent, + If-None-Match, etc. If None, pool headers are used. If provided, + these headers completely replace any pool-specific headers. + + :param retries: + Configure the number of retries to allow before raising a + :class:`~urllib3.exceptions.MaxRetryError` exception. + + Pass ``None`` to retry until you receive a response. Pass a + :class:`~urllib3.util.retry.Retry` object for fine-grained control + over different types of retries. + Pass an integer number to retry connection errors that many times, + but no other types of errors. Pass zero to never retry. + + If ``False``, then retries are disabled and any exception is raised + immediately. Also, instead of raising a MaxRetryError on redirects, + the redirect response will be returned. + + :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int. + + :param redirect: + If True, automatically handle redirects (status codes 301, 302, + 303, 307, 308). Each redirect counts as a retry. Disabling retries + will disable redirect, too. + + :param assert_same_host: + If ``True``, will make sure that the host of the pool requests is + consistent else will raise HostChangedError. When ``False``, you can + use the pool on an HTTP proxy and request foreign hosts. + + :param timeout: + If specified, overrides the default timeout for this one + request. It may be a float (in seconds) or an instance of + :class:`urllib3.util.Timeout`. + + :param pool_timeout: + If set and the pool is set to block=True, then this method will + block for ``pool_timeout`` seconds and raise EmptyPoolError if no + connection is available within the time period. + + :param bool preload_content: + If True, the response's body will be preloaded into memory. + + :param bool decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + + :param release_conn: + If False, then the urlopen call will not release the connection + back into the pool once a response is received (but will release if + you read the entire contents of the response such as when + `preload_content=True`). This is useful if you're not preloading + the response's content immediately. You will need to call + ``r.release_conn()`` on the response ``r`` to return the connection + back into the pool. If None, it takes the value of ``preload_content`` + which defaults to ``True``. + + :param bool chunked: + If True, urllib3 will send the body using chunked transfer + encoding. Otherwise, urllib3 will send the body using the standard + content-length form. Defaults to False. + + :param int body_pos: + Position to seek to in file-like body in the event of a retry or + redirect. Typically this won't need to be set because urllib3 will + auto-populate the value when needed. + """ + parsed_url = parse_url(url) + destination_scheme = parsed_url.scheme + + if headers is None: + headers = self.headers + + if not isinstance(retries, Retry): + retries = Retry.from_int(retries, redirect=redirect, default=self.retries) + + if release_conn is None: + release_conn = preload_content + + # Check host + if assert_same_host and not self.is_same_host(url): + raise HostChangedError(self, url, retries) + + # Ensure that the URL we're connecting to is properly encoded + if url.startswith("/"): + url = to_str(_encode_target(url)) + else: + url = to_str(parsed_url.url) + + conn = None + + # Track whether `conn` needs to be released before + # returning/raising/recursing. Update this variable if necessary, and + # leave `release_conn` constant throughout the function. That way, if + # the function recurses, the original value of `release_conn` will be + # passed down into the recursive call, and its value will be respected. + # + # See issue #651 [1] for details. + # + # [1] + release_this_conn = release_conn + + http_tunnel_required = connection_requires_http_tunnel( + self.proxy, self.proxy_config, destination_scheme + ) + + # Merge the proxy headers. Only done when not using HTTP CONNECT. We + # have to copy the headers dict so we can safely change it without those + # changes being reflected in anyone else's copy. + if not http_tunnel_required: + headers = headers.copy() # type: ignore[attr-defined] + headers.update(self.proxy_headers) # type: ignore[union-attr] + + # Must keep the exception bound to a separate variable or else Python 3 + # complains about UnboundLocalError. + err = None + + # Keep track of whether we cleanly exited the except block. This + # ensures we do proper cleanup in finally. + clean_exit = False + + # Rewind body position, if needed. Record current position + # for future rewinds in the event of a redirect/retry. + body_pos = set_file_position(body, body_pos) + + try: + # Request a connection from the queue. + timeout_obj = self._get_timeout(timeout) + conn = self._get_conn(timeout=pool_timeout) + + conn.timeout = timeout_obj.connect_timeout # type: ignore[assignment] + + # Is this a closed/new connection that requires CONNECT tunnelling? + if self.proxy is not None and http_tunnel_required and conn.is_closed: + try: + self._prepare_proxy(conn) + except (BaseSSLError, OSError, SocketTimeout) as e: + self._raise_timeout( + err=e, url=self.proxy.url, timeout_value=conn.timeout + ) + raise + + # If we're going to release the connection in ``finally:``, then + # the response doesn't need to know about the connection. Otherwise + # it will also try to release it and we'll have a double-release + # mess. + response_conn = conn if not release_conn else None + + # Make the request on the HTTPConnection object + response = self._make_request( + conn, + method, + url, + timeout=timeout_obj, + body=body, + headers=headers, + chunked=chunked, + retries=retries, + response_conn=response_conn, + preload_content=preload_content, + decode_content=decode_content, + **response_kw, + ) + + # Everything went great! + clean_exit = True + + except EmptyPoolError: + # Didn't get a connection from the pool, no need to clean up + clean_exit = True + release_this_conn = False + raise + + except ( + TimeoutError, + HTTPException, + OSError, + ProtocolError, + BaseSSLError, + SSLError, + CertificateError, + ProxyError, + ) as e: + # Discard the connection for these exceptions. It will be + # replaced during the next _get_conn() call. + clean_exit = False + new_e: Exception = e + if isinstance(e, (BaseSSLError, CertificateError)): + new_e = SSLError(e) + if isinstance( + new_e, + ( + OSError, + NewConnectionError, + TimeoutError, + SSLError, + HTTPException, + ), + ) and (conn and conn.proxy and not conn.has_connected_to_proxy): + new_e = _wrap_proxy_error(new_e, conn.proxy.scheme) + elif isinstance(new_e, (OSError, HTTPException)): + new_e = ProtocolError("Connection aborted.", new_e) + + retries = retries.increment( + method, url, error=new_e, _pool=self, _stacktrace=sys.exc_info()[2] + ) + retries.sleep() + + # Keep track of the error for the retry warning. + err = e + + finally: + if not clean_exit: + # We hit some kind of exception, handled or otherwise. We need + # to throw the connection away unless explicitly told not to. + # Close the connection, set the variable to None, and make sure + # we put the None back in the pool to avoid leaking it. + if conn: + conn.close() + conn = None + release_this_conn = True + + if release_this_conn: + # Put the connection back to be reused. If the connection is + # expired then it will be None, which will get replaced with a + # fresh connection during _get_conn. + self._put_conn(conn) + + if not conn: + # Try again + log.warning( + "Retrying (%r) after connection broken by '%r': %s", retries, err, url + ) + return self.urlopen( + method, + url, + body, + headers, + retries, + redirect, + assert_same_host, + timeout=timeout, + pool_timeout=pool_timeout, + release_conn=release_conn, + chunked=chunked, + body_pos=body_pos, + preload_content=preload_content, + decode_content=decode_content, + **response_kw, + ) + + # Handle redirect? + redirect_location = redirect and response.get_redirect_location() + if redirect_location: + if response.status == 303: + # Change the method according to RFC 9110, Section 15.4.4. + method = "GET" + # And lose the body not to transfer anything sensitive. + body = None + headers = HTTPHeaderDict(headers)._prepare_for_method_change() + + try: + retries = retries.increment(method, url, response=response, _pool=self) + except MaxRetryError: + if retries.raise_on_redirect: + response.drain_conn() + raise + return response + + response.drain_conn() + retries.sleep_for_retry(response) + log.debug("Redirecting %s -> %s", url, redirect_location) + return self.urlopen( + method, + redirect_location, + body, + headers, + retries=retries, + redirect=redirect, + assert_same_host=assert_same_host, + timeout=timeout, + pool_timeout=pool_timeout, + release_conn=release_conn, + chunked=chunked, + body_pos=body_pos, + preload_content=preload_content, + decode_content=decode_content, + **response_kw, + ) + + # Check if we should retry the HTTP response. + has_retry_after = bool(response.headers.get("Retry-After")) + if retries.is_retry(method, response.status, has_retry_after): + try: + retries = retries.increment(method, url, response=response, _pool=self) + except MaxRetryError: + if retries.raise_on_status: + response.drain_conn() + raise + return response + + response.drain_conn() + retries.sleep(response) + log.debug("Retry: %s", url) + return self.urlopen( + method, + url, + body, + headers, + retries=retries, + redirect=redirect, + assert_same_host=assert_same_host, + timeout=timeout, + pool_timeout=pool_timeout, + release_conn=release_conn, + chunked=chunked, + body_pos=body_pos, + preload_content=preload_content, + decode_content=decode_content, + **response_kw, + ) + + return response + + +class HTTPSConnectionPool(HTTPConnectionPool): + """ + Same as :class:`.HTTPConnectionPool`, but HTTPS. + + :class:`.HTTPSConnection` uses one of ``assert_fingerprint``, + ``assert_hostname`` and ``host`` in this order to verify connections. + If ``assert_hostname`` is False, no verification is done. + + The ``key_file``, ``cert_file``, ``cert_reqs``, ``ca_certs``, + ``ca_cert_dir``, ``ssl_version``, ``key_password`` are only used if :mod:`ssl` + is available and are fed into :meth:`urllib3.util.ssl_wrap_socket` to upgrade + the connection socket into an SSL socket. + """ + + scheme = "https" + ConnectionCls: type[BaseHTTPSConnection] = HTTPSConnection + + def __init__( + self, + host: str, + port: int | None = None, + timeout: _TYPE_TIMEOUT | None = _DEFAULT_TIMEOUT, + maxsize: int = 1, + block: bool = False, + headers: typing.Mapping[str, str] | None = None, + retries: Retry | bool | int | None = None, + _proxy: Url | None = None, + _proxy_headers: typing.Mapping[str, str] | None = None, + key_file: str | None = None, + cert_file: str | None = None, + cert_reqs: int | str | None = None, + key_password: str | None = None, + ca_certs: str | None = None, + ssl_version: int | str | None = None, + ssl_minimum_version: ssl.TLSVersion | None = None, + ssl_maximum_version: ssl.TLSVersion | None = None, + assert_hostname: str | Literal[False] | None = None, + assert_fingerprint: str | None = None, + ca_cert_dir: str | None = None, + **conn_kw: typing.Any, + ) -> None: + super().__init__( + host, + port, + timeout, + maxsize, + block, + headers, + retries, + _proxy, + _proxy_headers, + **conn_kw, + ) + + self.key_file = key_file + self.cert_file = cert_file + self.cert_reqs = cert_reqs + self.key_password = key_password + self.ca_certs = ca_certs + self.ca_cert_dir = ca_cert_dir + self.ssl_version = ssl_version + self.ssl_minimum_version = ssl_minimum_version + self.ssl_maximum_version = ssl_maximum_version + self.assert_hostname = assert_hostname + self.assert_fingerprint = assert_fingerprint + + def _prepare_proxy(self, conn: HTTPSConnection) -> None: # type: ignore[override] + """Establishes a tunnel connection through HTTP CONNECT.""" + if self.proxy and self.proxy.scheme == "https": + tunnel_scheme = "https" + else: + tunnel_scheme = "http" + + conn.set_tunnel( + scheme=tunnel_scheme, + host=self._tunnel_host, + port=self.port, + headers=self.proxy_headers, + ) + conn.connect() + + def _new_conn(self) -> BaseHTTPSConnection: + """ + Return a fresh :class:`urllib3.connection.HTTPConnection`. + """ + self.num_connections += 1 + log.debug( + "Starting new HTTPS connection (%d): %s:%s", + self.num_connections, + self.host, + self.port or "443", + ) + + if not self.ConnectionCls or self.ConnectionCls is DummyConnection: # type: ignore[comparison-overlap] + raise ImportError( + "Can't connect to HTTPS URL because the SSL module is not available." + ) + + actual_host: str = self.host + actual_port = self.port + if self.proxy is not None and self.proxy.host is not None: + actual_host = self.proxy.host + actual_port = self.proxy.port + + return self.ConnectionCls( + host=actual_host, + port=actual_port, + timeout=self.timeout.connect_timeout, + cert_file=self.cert_file, + key_file=self.key_file, + key_password=self.key_password, + cert_reqs=self.cert_reqs, + ca_certs=self.ca_certs, + ca_cert_dir=self.ca_cert_dir, + assert_hostname=self.assert_hostname, + assert_fingerprint=self.assert_fingerprint, + ssl_version=self.ssl_version, + ssl_minimum_version=self.ssl_minimum_version, + ssl_maximum_version=self.ssl_maximum_version, + **self.conn_kw, + ) + + def _validate_conn(self, conn: BaseHTTPConnection) -> None: + """ + Called right before a request is made, after the socket is created. + """ + super()._validate_conn(conn) + + # Force connect early to allow us to validate the connection. + if conn.is_closed: + conn.connect() + + if not conn.is_verified: + warnings.warn( + ( + f"Unverified HTTPS request is being made to host '{conn.host}'. " + "Adding certificate verification is strongly advised. See: " + "https://urllib3.readthedocs.io/en/latest/advanced-usage.html" + "#tls-warnings" + ), + InsecureRequestWarning, + ) + + +def connection_from_url(url: str, **kw: typing.Any) -> HTTPConnectionPool: + """ + Given a url, return an :class:`.ConnectionPool` instance of its host. + + This is a shortcut for not having to parse out the scheme, host, and port + of the url before creating an :class:`.ConnectionPool` instance. + + :param url: + Absolute URL string that must include the scheme. Port is optional. + + :param \\**kw: + Passes additional parameters to the constructor of the appropriate + :class:`.ConnectionPool`. Useful for specifying things like + timeout, maxsize, headers, etc. + + Example:: + + >>> conn = connection_from_url('http://google.com/') + >>> r = conn.request('GET', '/') + """ + scheme, _, host, port, *_ = parse_url(url) + scheme = scheme or "http" + port = port or port_by_scheme.get(scheme, 80) + if scheme == "https": + return HTTPSConnectionPool(host, port=port, **kw) # type: ignore[arg-type] + else: + return HTTPConnectionPool(host, port=port, **kw) # type: ignore[arg-type] + + +@typing.overload +def _normalize_host(host: None, scheme: str | None) -> None: + ... + + +@typing.overload +def _normalize_host(host: str, scheme: str | None) -> str: + ... + + +def _normalize_host(host: str | None, scheme: str | None) -> str | None: + """ + Normalize hosts for comparisons and use with sockets. + """ + + host = normalize_host(host, scheme) + + # httplib doesn't like it when we include brackets in IPv6 addresses + # Specifically, if we include brackets but also pass the port then + # httplib crazily doubles up the square brackets on the Host header. + # Instead, we need to make sure we never pass ``None`` as the port. + # However, for backward compatibility reasons we can't actually + # *assert* that. See http://bugs.python.org/issue28539 + if host and host.startswith("[") and host.endswith("]"): + host = host[1:-1] + return host + + +def _url_from_pool( + pool: HTTPConnectionPool | HTTPSConnectionPool, path: str | None = None +) -> str: + """Returns the URL from a given connection pool. This is mainly used for testing and logging.""" + return Url(scheme=pool.scheme, host=pool.host, port=pool.port, path=path).url + + +def _close_pool_connections(pool: queue.LifoQueue[typing.Any]) -> None: + """Drains a queue of connections and closes each one.""" + try: + while True: + conn = pool.get(block=False) + if conn: + conn.close() + except queue.Empty: + pass # Done. diff --git a/Modules/urllib3/contrib/__init__.py b/Modules/urllib3/contrib/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/Modules/urllib3/contrib/__pycache__/__init__.cpython-311.pyc b/Modules/urllib3/contrib/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b6009f62ce5fb8e849c024ea44340899924f1ba GIT binary patch literal 168 zcmZ3^%ge<81cf3&sUZ3>h=2h`DC095kTIPhg&~+hlhJP_LlF~@{~09t%UVApKQ~oB zB{ex)UoSa7FD)}&zqqovBsDihzqB~DNWZiwCnqz>SRW`?Qk0pbA0MBYmst`YuUAm{ li^C>2KczG$)vkyYXcow}Vtyd;ftit!@dE>lC}IYR0RYw=CsqIe literal 0 HcmV?d00001 diff --git a/Modules/urllib3/contrib/__pycache__/socks.cpython-311.pyc b/Modules/urllib3/contrib/__pycache__/socks.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f9e7cc59ef935fbef9e5084d0a943c2c36a1ab78 GIT binary patch literal 8724 zcmb_CS!^3emeuU$EsEkHiMp(gb=b5eD)BK%G`1&-kJw2pE0&$a%mx(AZdtUOO}V;d zSpqfDWDKk_@b2bg77;KWz`$lbS!95jkNsHeSCZKQ_G3RNkANW>Fd$$tANiwU8wmWh z?^Pc>B&{)v?QT9*)vM#xd#~P6_HRO=0DuvB(#q++uUilBuH+>Q}Cv}9B~oZecfkID|uw^0~aA* z!_QiQd`cF{ZT<>b*O@l|UhwZh<)k$)|)0t?AZ6I2~qnztUESq$7oBI?Cz+ zSSyx}72@eQs|S_#LPxrTm0Og~LL!}TDDFyksUeGEH}v4sT~~-I)KL&p{DtmxH&Xr< zky`H%DJ*wC;DKiNnNPZh;o1Nfkz1Q^y$lxxTuknj!w&=)2|sIOAH&80+b&0%M($y_ z4#0KF(I#9!!zBRMC3iI8M2Vj!$?oiDZbAZ==JJ|YC`t>8Ear-;p3SS8I8TeW@>;&A zW))Fen4d3FU7Rgaar(l^ccu}0J1=YEEG-tq#k@Y3R|5-FQSw(0r^NdCtf87Y?#PJs zcS78sRYm!>E~~hPSe&&G$q_NDN&&XYQJAVI%4+s15SG_rwFNb&Gm`T9(ugR-x-u1k zT0N^M;?&Y~F?T}~fk?Xv=+Xk#&X7tG28c5=8upu+!S!i26#xdv*1qzEc||VBzyn;z z-nhob%`U(qG^<{dkz8xH;;fw27pSbI#B;isRkUKj*)lFRTU3S)aa7I~ z3&3khmPEZME@+Nu7C0SgYlT|z$stgJU!h~hA zFjWDLiikV_C1Tq>Qd608Q@4&V&eV0&OxZZxIWkc@11XbXM{D|nGmMA;f5Z+&{dyWK z_`yyzSyV8VupQ3K0Arb)fIE1Kt>cC?G_WqPmq4vQ}Ed8tPG5|8%wo4Ge_FdW>8nY*1@?C(zs-Dkfbs2bL84pJ6U%6eT z&TPA=DksK|*~>KT{d+X{NzMpnRX8im0%?=qquYbV$SHXq&x)E``XEbHP{QT!%oAo? zXHZ4kD4|&Lp!aP5mN7If8t|kzk8*@VF4;4JB_9{Hc{!J#h3zT|*jCG!rbO`!oWep8 z4pd%+lU-objDR-C;+(F}YhV#@(R%jMrKywFDJ!Z*80*uu2IvxP>@rm>Dn_iS8#Y4Mm^JW{ zIsa)&i`0lt%8RuLSsQX3hn&x<*=sU|s((I9H5sijRxT~g%hIWQPS2SR*@Tv7=bpR^ z^)HA_(i}uQuFDY7$h_n_2CWhgCBZ4Vos!2Xd0EK^{rs#H0IwW0Vwp=(mG=?kN+F>if7~4T=eu+k4I0NUQpj`&ATK86jjxzf;gpP{PU1r~g z(A`*0lm+}YghYiE>~ibs+pBN?41TL`Q_)^$XZei)`fuwbC~;|CYFQ(*oaDdLk`|

iDA$=ng}2R(=;-pXge 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 literal 0 HcmV?d00001 diff --git a/Modules/urllib3/contrib/pyopenssl.py b/Modules/urllib3/contrib/pyopenssl.py new file mode 100644 index 0000000..3987d63 --- /dev/null +++ b/Modules/urllib3/contrib/pyopenssl.py @@ -0,0 +1,548 @@ +""" +Module for using pyOpenSSL as a TLS backend. This module was relevant before +the standard library ``ssl`` module supported SNI, but now that we've dropped +support for Python 2.7 all relevant Python versions support SNI so +**this module is no longer recommended**. + +This needs the following packages installed: + +* `pyOpenSSL`_ (tested with 16.0.0) +* `cryptography`_ (minimum 1.3.4, from pyopenssl) +* `idna`_ (minimum 2.0) + +However, pyOpenSSL depends on cryptography, so while we use all three directly here we +end up having relatively few packages required. + +You can install them with the following command: + +.. code-block:: bash + + $ python -m pip install pyopenssl cryptography idna + +To activate certificate checking, call +:func:`~urllib3.contrib.pyopenssl.inject_into_urllib3` from your Python code +before you begin making HTTP requests. This can be done in a ``sitecustomize`` +module, or at any other time before your application begins using ``urllib3``, +like this: + +.. code-block:: python + + try: + import urllib3.contrib.pyopenssl + urllib3.contrib.pyopenssl.inject_into_urllib3() + except ImportError: + pass + +.. _pyopenssl: https://www.pyopenssl.org +.. _cryptography: https://cryptography.io +.. _idna: https://github.com/kjd/idna +""" + +from __future__ import annotations + +import OpenSSL.SSL # type: ignore[import] +from cryptography import x509 + +try: + from cryptography.x509 import UnsupportedExtension # type: ignore[attr-defined] +except ImportError: + # UnsupportedExtension is gone in cryptography >= 2.1.0 + class UnsupportedExtension(Exception): # type: ignore[no-redef] + pass + + +import logging +import ssl +import typing +from io import BytesIO +from socket import socket as socket_cls +from socket import timeout + +from .. import util + +if typing.TYPE_CHECKING: + from OpenSSL.crypto import X509 # type: ignore[import] + + +__all__ = ["inject_into_urllib3", "extract_from_urllib3"] + +# Map from urllib3 to PyOpenSSL compatible parameter-values. +_openssl_versions = { + util.ssl_.PROTOCOL_TLS: OpenSSL.SSL.SSLv23_METHOD, # type: ignore[attr-defined] + util.ssl_.PROTOCOL_TLS_CLIENT: OpenSSL.SSL.SSLv23_METHOD, # type: ignore[attr-defined] + ssl.PROTOCOL_TLSv1: OpenSSL.SSL.TLSv1_METHOD, +} + +if hasattr(ssl, "PROTOCOL_TLSv1_1") and hasattr(OpenSSL.SSL, "TLSv1_1_METHOD"): + _openssl_versions[ssl.PROTOCOL_TLSv1_1] = OpenSSL.SSL.TLSv1_1_METHOD + +if hasattr(ssl, "PROTOCOL_TLSv1_2") and hasattr(OpenSSL.SSL, "TLSv1_2_METHOD"): + _openssl_versions[ssl.PROTOCOL_TLSv1_2] = OpenSSL.SSL.TLSv1_2_METHOD + + +_stdlib_to_openssl_verify = { + ssl.CERT_NONE: OpenSSL.SSL.VERIFY_NONE, + ssl.CERT_OPTIONAL: OpenSSL.SSL.VERIFY_PEER, + ssl.CERT_REQUIRED: OpenSSL.SSL.VERIFY_PEER + + OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT, +} +_openssl_to_stdlib_verify = {v: k for k, v in _stdlib_to_openssl_verify.items()} + +# The SSLvX values are the most likely to be missing in the future +# but we check them all just to be sure. +_OP_NO_SSLv2_OR_SSLv3: int = getattr(OpenSSL.SSL, "OP_NO_SSLv2", 0) | getattr( + OpenSSL.SSL, "OP_NO_SSLv3", 0 +) +_OP_NO_TLSv1: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1", 0) +_OP_NO_TLSv1_1: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1_1", 0) +_OP_NO_TLSv1_2: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1_2", 0) +_OP_NO_TLSv1_3: int = getattr(OpenSSL.SSL, "OP_NO_TLSv1_3", 0) + +_openssl_to_ssl_minimum_version: dict[int, int] = { + ssl.TLSVersion.MINIMUM_SUPPORTED: _OP_NO_SSLv2_OR_SSLv3, + ssl.TLSVersion.TLSv1: _OP_NO_SSLv2_OR_SSLv3, + ssl.TLSVersion.TLSv1_1: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1, + ssl.TLSVersion.TLSv1_2: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1 | _OP_NO_TLSv1_1, + ssl.TLSVersion.TLSv1_3: ( + _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1 | _OP_NO_TLSv1_1 | _OP_NO_TLSv1_2 + ), + ssl.TLSVersion.MAXIMUM_SUPPORTED: ( + _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1 | _OP_NO_TLSv1_1 | _OP_NO_TLSv1_2 + ), +} +_openssl_to_ssl_maximum_version: dict[int, int] = { + ssl.TLSVersion.MINIMUM_SUPPORTED: ( + _OP_NO_SSLv2_OR_SSLv3 + | _OP_NO_TLSv1 + | _OP_NO_TLSv1_1 + | _OP_NO_TLSv1_2 + | _OP_NO_TLSv1_3 + ), + ssl.TLSVersion.TLSv1: ( + _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1_1 | _OP_NO_TLSv1_2 | _OP_NO_TLSv1_3 + ), + ssl.TLSVersion.TLSv1_1: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1_2 | _OP_NO_TLSv1_3, + ssl.TLSVersion.TLSv1_2: _OP_NO_SSLv2_OR_SSLv3 | _OP_NO_TLSv1_3, + ssl.TLSVersion.TLSv1_3: _OP_NO_SSLv2_OR_SSLv3, + ssl.TLSVersion.MAXIMUM_SUPPORTED: _OP_NO_SSLv2_OR_SSLv3, +} + +# OpenSSL will only write 16K at a time +SSL_WRITE_BLOCKSIZE = 16384 + +orig_util_SSLContext = util.ssl_.SSLContext + + +log = logging.getLogger(__name__) + + +def inject_into_urllib3() -> None: + "Monkey-patch urllib3 with PyOpenSSL-backed SSL-support." + + _validate_dependencies_met() + + util.SSLContext = PyOpenSSLContext # type: ignore[assignment] + util.ssl_.SSLContext = PyOpenSSLContext # type: ignore[assignment] + util.IS_PYOPENSSL = True + util.ssl_.IS_PYOPENSSL = True + + +def extract_from_urllib3() -> None: + "Undo monkey-patching by :func:`inject_into_urllib3`." + + util.SSLContext = orig_util_SSLContext + util.ssl_.SSLContext = orig_util_SSLContext + util.IS_PYOPENSSL = False + util.ssl_.IS_PYOPENSSL = False + + +def _validate_dependencies_met() -> None: + """ + Verifies that PyOpenSSL's package-level dependencies have been met. + Throws `ImportError` if they are not met. + """ + # Method added in `cryptography==1.1`; not available in older versions + from cryptography.x509.extensions import Extensions + + if getattr(Extensions, "get_extension_for_class", None) is None: + raise ImportError( + "'cryptography' module missing required functionality. " + "Try upgrading to v1.3.4 or newer." + ) + + # pyOpenSSL 0.14 and above use cryptography for OpenSSL bindings. The _x509 + # attribute is only present on those versions. + from OpenSSL.crypto import X509 + + x509 = X509() + if getattr(x509, "_x509", None) is None: + raise ImportError( + "'pyOpenSSL' module missing required functionality. " + "Try upgrading to v0.14 or newer." + ) + + +def _dnsname_to_stdlib(name: str) -> str | None: + """ + Converts a dNSName SubjectAlternativeName field to the form used by the + standard library on the given Python version. + + Cryptography produces a dNSName as a unicode string that was idna-decoded + from ASCII bytes. We need to idna-encode that string to get it back, and + then on Python 3 we also need to convert to unicode via UTF-8 (the stdlib + uses PyUnicode_FromStringAndSize on it, which decodes via UTF-8). + + If the name cannot be idna-encoded then we return None signalling that + the name given should be skipped. + """ + + def idna_encode(name: str) -> bytes | None: + """ + Borrowed wholesale from the Python Cryptography Project. It turns out + that we can't just safely call `idna.encode`: it can explode for + wildcard names. This avoids that problem. + """ + import idna + + try: + for prefix in ["*.", "."]: + if name.startswith(prefix): + name = name[len(prefix) :] + return prefix.encode("ascii") + idna.encode(name) + return idna.encode(name) + except idna.core.IDNAError: + return None + + # Don't send IPv6 addresses through the IDNA encoder. + if ":" in name: + return name + + encoded_name = idna_encode(name) + if encoded_name is None: + return None + return encoded_name.decode("utf-8") + + +def get_subj_alt_name(peer_cert: X509) -> list[tuple[str, str]]: + """ + Given an PyOpenSSL certificate, provides all the subject alternative names. + """ + cert = peer_cert.to_cryptography() + + # We want to find the SAN extension. Ask Cryptography to locate it (it's + # faster than looping in Python) + try: + ext = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value + except x509.ExtensionNotFound: + # No such extension, return the empty list. + return [] + except ( + x509.DuplicateExtension, + UnsupportedExtension, + x509.UnsupportedGeneralNameType, + UnicodeError, + ) as e: + # A problem has been found with the quality of the certificate. Assume + # no SAN field is present. + log.warning( + "A problem was encountered with the certificate that prevented " + "urllib3 from finding the SubjectAlternativeName field. This can " + "affect certificate validation. The error was %s", + e, + ) + return [] + + # We want to return dNSName and iPAddress fields. We need to cast the IPs + # back to strings because the match_hostname function wants them as + # strings. + # Sadly the DNS names need to be idna encoded and then, on Python 3, UTF-8 + # decoded. This is pretty frustrating, but that's what the standard library + # does with certificates, and so we need to attempt to do the same. + # We also want to skip over names which cannot be idna encoded. + names = [ + ("DNS", name) + for name in map(_dnsname_to_stdlib, ext.get_values_for_type(x509.DNSName)) + if name is not None + ] + names.extend( + ("IP Address", str(name)) for name in ext.get_values_for_type(x509.IPAddress) + ) + + return names + + +class WrappedSocket: + """API-compatibility wrapper for Python OpenSSL's Connection-class.""" + + def __init__( + self, + connection: OpenSSL.SSL.Connection, + socket: socket_cls, + suppress_ragged_eofs: bool = True, + ) -> None: + self.connection = connection + self.socket = socket + self.suppress_ragged_eofs = suppress_ragged_eofs + self._io_refs = 0 + self._closed = False + + def fileno(self) -> int: + return self.socket.fileno() + + # Copy-pasted from Python 3.5 source code + def _decref_socketios(self) -> None: + if self._io_refs > 0: + self._io_refs -= 1 + if self._closed: + self.close() + + def recv(self, *args: typing.Any, **kwargs: typing.Any) -> bytes: + try: + data = self.connection.recv(*args, **kwargs) + except OpenSSL.SSL.SysCallError as e: + if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"): + return b"" + else: + raise OSError(e.args[0], str(e)) from e + except OpenSSL.SSL.ZeroReturnError: + if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN: + return b"" + else: + raise + except OpenSSL.SSL.WantReadError as e: + if not util.wait_for_read(self.socket, self.socket.gettimeout()): + raise timeout("The read operation timed out") from e + else: + return self.recv(*args, **kwargs) + + # TLS 1.3 post-handshake authentication + except OpenSSL.SSL.Error as e: + raise ssl.SSLError(f"read error: {e!r}") from e + else: + return data # type: ignore[no-any-return] + + def recv_into(self, *args: typing.Any, **kwargs: typing.Any) -> int: + try: + return self.connection.recv_into(*args, **kwargs) # type: ignore[no-any-return] + except OpenSSL.SSL.SysCallError as e: + if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"): + return 0 + else: + raise OSError(e.args[0], str(e)) from e + except OpenSSL.SSL.ZeroReturnError: + if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN: + return 0 + else: + raise + except OpenSSL.SSL.WantReadError as e: + if not util.wait_for_read(self.socket, self.socket.gettimeout()): + raise timeout("The read operation timed out") from e + else: + return self.recv_into(*args, **kwargs) + + # TLS 1.3 post-handshake authentication + except OpenSSL.SSL.Error as e: + raise ssl.SSLError(f"read error: {e!r}") from e + + def settimeout(self, timeout: float) -> None: + return self.socket.settimeout(timeout) + + def _send_until_done(self, data: bytes) -> int: + while True: + try: + return self.connection.send(data) # type: ignore[no-any-return] + except OpenSSL.SSL.WantWriteError as e: + if not util.wait_for_write(self.socket, self.socket.gettimeout()): + raise timeout() from e + continue + except OpenSSL.SSL.SysCallError as e: + raise OSError(e.args[0], str(e)) from e + + def sendall(self, data: bytes) -> None: + total_sent = 0 + while total_sent < len(data): + sent = self._send_until_done( + data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE] + ) + total_sent += sent + + def shutdown(self) -> None: + # FIXME rethrow compatible exceptions should we ever use this + self.connection.shutdown() + + def close(self) -> None: + self._closed = True + if self._io_refs <= 0: + self._real_close() + + def _real_close(self) -> None: + try: + return self.connection.close() # type: ignore[no-any-return] + except OpenSSL.SSL.Error: + return + + def getpeercert( + self, binary_form: bool = False + ) -> dict[str, list[typing.Any]] | None: + x509 = self.connection.get_peer_certificate() + + if not x509: + return x509 # type: ignore[no-any-return] + + if binary_form: + return OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, x509) # type: ignore[no-any-return] + + return { + "subject": ((("commonName", x509.get_subject().CN),),), # type: ignore[dict-item] + "subjectAltName": get_subj_alt_name(x509), + } + + def version(self) -> str: + return self.connection.get_protocol_version_name() # type: ignore[no-any-return] + + +WrappedSocket.makefile = socket_cls.makefile # type: ignore[attr-defined] + + +class PyOpenSSLContext: + """ + I am a wrapper class for the PyOpenSSL ``Context`` object. I am responsible + for translating the interface of the standard library ``SSLContext`` object + to calls into PyOpenSSL. + """ + + def __init__(self, protocol: int) -> None: + self.protocol = _openssl_versions[protocol] + self._ctx = OpenSSL.SSL.Context(self.protocol) + self._options = 0 + self.check_hostname = False + self._minimum_version: int = ssl.TLSVersion.MINIMUM_SUPPORTED + self._maximum_version: int = ssl.TLSVersion.MAXIMUM_SUPPORTED + + @property + def options(self) -> int: + return self._options + + @options.setter + def options(self, value: int) -> None: + self._options = value + self._set_ctx_options() + + @property + def verify_mode(self) -> int: + return _openssl_to_stdlib_verify[self._ctx.get_verify_mode()] + + @verify_mode.setter + def verify_mode(self, value: ssl.VerifyMode) -> None: + self._ctx.set_verify(_stdlib_to_openssl_verify[value], _verify_callback) + + def set_default_verify_paths(self) -> None: + self._ctx.set_default_verify_paths() + + def set_ciphers(self, ciphers: bytes | str) -> None: + if isinstance(ciphers, str): + ciphers = ciphers.encode("utf-8") + self._ctx.set_cipher_list(ciphers) + + def load_verify_locations( + self, + cafile: str | None = None, + capath: str | None = None, + cadata: bytes | None = None, + ) -> None: + if cafile is not None: + cafile = cafile.encode("utf-8") # type: ignore[assignment] + if capath is not None: + capath = capath.encode("utf-8") # type: ignore[assignment] + try: + self._ctx.load_verify_locations(cafile, capath) + if cadata is not None: + self._ctx.load_verify_locations(BytesIO(cadata)) + except OpenSSL.SSL.Error as e: + raise ssl.SSLError(f"unable to load trusted certificates: {e!r}") from e + + def load_cert_chain( + self, + certfile: str, + keyfile: str | None = None, + password: str | None = None, + ) -> None: + try: + self._ctx.use_certificate_chain_file(certfile) + if password is not None: + if not isinstance(password, bytes): + password = password.encode("utf-8") # type: ignore[assignment] + self._ctx.set_passwd_cb(lambda *_: password) + self._ctx.use_privatekey_file(keyfile or certfile) + except OpenSSL.SSL.Error as e: + raise ssl.SSLError(f"Unable to load certificate chain: {e!r}") from e + + def set_alpn_protocols(self, protocols: list[bytes | str]) -> None: + protocols = [util.util.to_bytes(p, "ascii") for p in protocols] + return self._ctx.set_alpn_protos(protocols) # type: ignore[no-any-return] + + def wrap_socket( + self, + sock: socket_cls, + server_side: bool = False, + do_handshake_on_connect: bool = True, + suppress_ragged_eofs: bool = True, + server_hostname: bytes | str | None = None, + ) -> WrappedSocket: + cnx = OpenSSL.SSL.Connection(self._ctx, sock) + + # If server_hostname is an IP, don't use it for SNI, per RFC6066 Section 3 + if server_hostname and not util.ssl_.is_ipaddress(server_hostname): + if isinstance(server_hostname, str): + server_hostname = server_hostname.encode("utf-8") + cnx.set_tlsext_host_name(server_hostname) + + cnx.set_connect_state() + + while True: + try: + cnx.do_handshake() + except OpenSSL.SSL.WantReadError as e: + if not util.wait_for_read(sock, sock.gettimeout()): + raise timeout("select timed out") from e + continue + except OpenSSL.SSL.Error as e: + raise ssl.SSLError(f"bad handshake: {e!r}") from e + break + + return WrappedSocket(cnx, sock) + + def _set_ctx_options(self) -> None: + self._ctx.set_options( + self._options + | _openssl_to_ssl_minimum_version[self._minimum_version] + | _openssl_to_ssl_maximum_version[self._maximum_version] + ) + + @property + def minimum_version(self) -> int: + return self._minimum_version + + @minimum_version.setter + def minimum_version(self, minimum_version: int) -> None: + self._minimum_version = minimum_version + self._set_ctx_options() + + @property + def maximum_version(self) -> int: + return self._maximum_version + + @maximum_version.setter + def maximum_version(self, maximum_version: int) -> None: + self._maximum_version = maximum_version + self._set_ctx_options() + + +def _verify_callback( + cnx: OpenSSL.SSL.Connection, + x509: X509, + err_no: int, + err_depth: int, + return_code: int, +) -> bool: + return err_no == 0 diff --git a/Modules/urllib3/contrib/socks.py b/Modules/urllib3/contrib/socks.py new file mode 100644 index 0000000..6c3bb76 --- /dev/null +++ b/Modules/urllib3/contrib/socks.py @@ -0,0 +1,230 @@ +""" +This module contains provisional support for SOCKS proxies from within +urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and +SOCKS5. To enable its functionality, either install PySocks or install this +module with the ``socks`` extra. + +The SOCKS implementation supports the full range of urllib3 features. It also +supports the following SOCKS features: + +- SOCKS4A (``proxy_url='socks4a://...``) +- SOCKS4 (``proxy_url='socks4://...``) +- SOCKS5 with remote DNS (``proxy_url='socks5h://...``) +- SOCKS5 with local DNS (``proxy_url='socks5://...``) +- Usernames and passwords for the SOCKS proxy + +.. note:: + It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in + your ``proxy_url`` to ensure that DNS resolution is done from the remote + server instead of client-side when connecting to a domain name. + +SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5 +supports IPv4, IPv6, and domain names. + +When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url`` +will be sent as the ``userid`` section of the SOCKS request: + +.. code-block:: python + + proxy_url="socks4a://@proxy-host" + +When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion +of the ``proxy_url`` will be sent as the username/password to authenticate +with the proxy: + +.. code-block:: python + + proxy_url="socks5h://:@proxy-host" + +""" + +from __future__ import annotations + +try: + import socks # type: ignore[import] +except ImportError: + import warnings + + from ..exceptions import DependencyWarning + + warnings.warn( + ( + "SOCKS support in urllib3 requires the installation of optional " + "dependencies: specifically, PySocks. For more information, see " + "https://urllib3.readthedocs.io/en/latest/contrib.html#socks-proxies" + ), + DependencyWarning, + ) + raise + +import typing +from socket import timeout as SocketTimeout + +from ..connection import HTTPConnection, HTTPSConnection +from ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool +from ..exceptions import ConnectTimeoutError, NewConnectionError +from ..poolmanager import PoolManager +from ..util.url import parse_url + +try: + import ssl +except ImportError: + ssl = None # type: ignore[assignment] + +from typing import TypedDict + + +class _TYPE_SOCKS_OPTIONS(TypedDict): + socks_version: int + proxy_host: str | None + proxy_port: str | None + username: str | None + password: str | None + rdns: bool + + +class SOCKSConnection(HTTPConnection): + """ + A plain-text HTTP connection that connects via a SOCKS proxy. + """ + + def __init__( + self, + _socks_options: _TYPE_SOCKS_OPTIONS, + *args: typing.Any, + **kwargs: typing.Any, + ) -> None: + self._socks_options = _socks_options + super().__init__(*args, **kwargs) + + def _new_conn(self) -> socks.socksocket: + """ + Establish a new connection via the SOCKS proxy. + """ + extra_kw: dict[str, typing.Any] = {} + if self.source_address: + extra_kw["source_address"] = self.source_address + + if self.socket_options: + extra_kw["socket_options"] = self.socket_options + + try: + conn = socks.create_connection( + (self.host, self.port), + proxy_type=self._socks_options["socks_version"], + proxy_addr=self._socks_options["proxy_host"], + proxy_port=self._socks_options["proxy_port"], + proxy_username=self._socks_options["username"], + proxy_password=self._socks_options["password"], + proxy_rdns=self._socks_options["rdns"], + timeout=self.timeout, + **extra_kw, + ) + + except SocketTimeout as e: + raise ConnectTimeoutError( + self, + f"Connection to {self.host} timed out. (connect timeout={self.timeout})", + ) from e + + except socks.ProxyError as e: + # This is fragile as hell, but it seems to be the only way to raise + # useful errors here. + if e.socket_err: + error = e.socket_err + if isinstance(error, SocketTimeout): + raise ConnectTimeoutError( + self, + f"Connection to {self.host} timed out. (connect timeout={self.timeout})", + ) from e + else: + # Adding `from e` messes with coverage somehow, so it's omitted. + # See #2386. + raise NewConnectionError( + self, f"Failed to establish a new connection: {error}" + ) + else: + raise NewConnectionError( + self, f"Failed to establish a new connection: {e}" + ) from e + + except OSError as e: # Defensive: PySocks should catch all these. + raise NewConnectionError( + self, f"Failed to establish a new connection: {e}" + ) from e + + return conn + + +# We don't need to duplicate the Verified/Unverified distinction from +# urllib3/connection.py here because the HTTPSConnection will already have been +# correctly set to either the Verified or Unverified form by that module. This +# means the SOCKSHTTPSConnection will automatically be the correct type. +class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection): + pass + + +class SOCKSHTTPConnectionPool(HTTPConnectionPool): + ConnectionCls = SOCKSConnection + + +class SOCKSHTTPSConnectionPool(HTTPSConnectionPool): + ConnectionCls = SOCKSHTTPSConnection + + +class SOCKSProxyManager(PoolManager): + """ + A version of the urllib3 ProxyManager that routes connections via the + defined SOCKS proxy. + """ + + pool_classes_by_scheme = { + "http": SOCKSHTTPConnectionPool, + "https": SOCKSHTTPSConnectionPool, + } + + def __init__( + self, + proxy_url: str, + username: str | None = None, + password: str | None = None, + num_pools: int = 10, + headers: typing.Mapping[str, str] | None = None, + **connection_pool_kw: typing.Any, + ): + parsed = parse_url(proxy_url) + + if username is None and password is None and parsed.auth is not None: + split = parsed.auth.split(":") + if len(split) == 2: + username, password = split + if parsed.scheme == "socks5": + socks_version = socks.PROXY_TYPE_SOCKS5 + rdns = False + elif parsed.scheme == "socks5h": + socks_version = socks.PROXY_TYPE_SOCKS5 + rdns = True + elif parsed.scheme == "socks4": + socks_version = socks.PROXY_TYPE_SOCKS4 + rdns = False + elif parsed.scheme == "socks4a": + socks_version = socks.PROXY_TYPE_SOCKS4 + rdns = True + else: + raise ValueError(f"Unable to determine SOCKS version from {proxy_url}") + + self.proxy_url = proxy_url + + socks_options = { + "socks_version": socks_version, + "proxy_host": parsed.host, + "proxy_port": parsed.port, + "username": username, + "password": password, + "rdns": rdns, + } + connection_pool_kw["_socks_options"] = socks_options + + super().__init__(num_pools, headers, **connection_pool_kw) + + self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme diff --git a/Modules/urllib3/exceptions.py b/Modules/urllib3/exceptions.py new file mode 100644 index 0000000..5bb9236 --- /dev/null +++ b/Modules/urllib3/exceptions.py @@ -0,0 +1,318 @@ +from __future__ import annotations + +import socket +import typing +import warnings +from email.errors import MessageDefect +from http.client import IncompleteRead as httplib_IncompleteRead + +if typing.TYPE_CHECKING: + from .connection import HTTPConnection + from .connectionpool import ConnectionPool + from .response import HTTPResponse + from .util.retry import Retry + +# Base Exceptions + + +class HTTPError(Exception): + """Base exception used by this module.""" + + +class HTTPWarning(Warning): + """Base warning used by this module.""" + + +_TYPE_REDUCE_RESULT = typing.Tuple[ + typing.Callable[..., object], typing.Tuple[object, ...] +] + + +class PoolError(HTTPError): + """Base exception for errors caused within a pool.""" + + def __init__(self, pool: ConnectionPool, message: str) -> None: + self.pool = pool + super().__init__(f"{pool}: {message}") + + def __reduce__(self) -> _TYPE_REDUCE_RESULT: + # For pickling purposes. + return self.__class__, (None, None) + + +class RequestError(PoolError): + """Base exception for PoolErrors that have associated URLs.""" + + def __init__(self, pool: ConnectionPool, url: str, message: str) -> None: + self.url = url + super().__init__(pool, message) + + def __reduce__(self) -> _TYPE_REDUCE_RESULT: + # For pickling purposes. + return self.__class__, (None, self.url, None) + + +class SSLError(HTTPError): + """Raised when SSL certificate fails in an HTTPS connection.""" + + +class ProxyError(HTTPError): + """Raised when the connection to a proxy fails.""" + + # The original error is also available as __cause__. + original_error: Exception + + def __init__(self, message: str, error: Exception) -> None: + super().__init__(message, error) + self.original_error = error + + +class DecodeError(HTTPError): + """Raised when automatic decoding based on Content-Type fails.""" + + +class ProtocolError(HTTPError): + """Raised when something unexpected happens mid-request/response.""" + + +#: Renamed to ProtocolError but aliased for backwards compatibility. +ConnectionError = ProtocolError + + +# Leaf Exceptions + + +class MaxRetryError(RequestError): + """Raised when the maximum number of retries is exceeded. + + :param pool: The connection pool + :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool` + :param str url: The requested Url + :param reason: The underlying error + :type reason: :class:`Exception` + + """ + + def __init__( + self, pool: ConnectionPool, url: str, reason: Exception | None = None + ) -> None: + self.reason = reason + + message = f"Max retries exceeded with url: {url} (Caused by {reason!r})" + + super().__init__(pool, url, message) + + +class HostChangedError(RequestError): + """Raised when an existing pool gets a request for a foreign host.""" + + def __init__( + self, pool: ConnectionPool, url: str, retries: Retry | int = 3 + ) -> None: + message = f"Tried to open a foreign host with url: {url}" + super().__init__(pool, url, message) + self.retries = retries + + +class TimeoutStateError(HTTPError): + """Raised when passing an invalid state to a timeout""" + + +class TimeoutError(HTTPError): + """Raised when a socket timeout error occurs. + + Catching this error will catch both :exc:`ReadTimeoutErrors + ` and :exc:`ConnectTimeoutErrors `. + """ + + +class ReadTimeoutError(TimeoutError, RequestError): + """Raised when a socket timeout occurs while receiving data from a server""" + + +# This timeout error does not have a URL attached and needs to inherit from the +# base HTTPError +class ConnectTimeoutError(TimeoutError): + """Raised when a socket timeout occurs while connecting to a server""" + + +class NewConnectionError(ConnectTimeoutError, HTTPError): + """Raised when we fail to establish a new connection. Usually ECONNREFUSED.""" + + def __init__(self, conn: HTTPConnection, message: str) -> None: + self.conn = conn + super().__init__(f"{conn}: {message}") + + @property + def pool(self) -> HTTPConnection: + warnings.warn( + "The 'pool' property is deprecated and will be removed " + "in urllib3 v2.1.0. Use 'conn' instead.", + DeprecationWarning, + stacklevel=2, + ) + + return self.conn + + +class NameResolutionError(NewConnectionError): + """Raised when host name resolution fails.""" + + def __init__(self, host: str, conn: HTTPConnection, reason: socket.gaierror): + message = f"Failed to resolve '{host}' ({reason})" + super().__init__(conn, message) + + +class EmptyPoolError(PoolError): + """Raised when a pool runs out of connections and no more are allowed.""" + + +class FullPoolError(PoolError): + """Raised when we try to add a connection to a full pool in blocking mode.""" + + +class ClosedPoolError(PoolError): + """Raised when a request enters a pool after the pool has been closed.""" + + +class LocationValueError(ValueError, HTTPError): + """Raised when there is something wrong with a given URL input.""" + + +class LocationParseError(LocationValueError): + """Raised when get_host or similar fails to parse the URL input.""" + + def __init__(self, location: str) -> None: + message = f"Failed to parse: {location}" + super().__init__(message) + + self.location = location + + +class URLSchemeUnknown(LocationValueError): + """Raised when a URL input has an unsupported scheme.""" + + def __init__(self, scheme: str): + message = f"Not supported URL scheme {scheme}" + super().__init__(message) + + self.scheme = scheme + + +class ResponseError(HTTPError): + """Used as a container for an error reason supplied in a MaxRetryError.""" + + GENERIC_ERROR = "too many error responses" + SPECIFIC_ERROR = "too many {status_code} error responses" + + +class SecurityWarning(HTTPWarning): + """Warned when performing security reducing actions""" + + +class InsecureRequestWarning(SecurityWarning): + """Warned when making an unverified HTTPS request.""" + + +class NotOpenSSLWarning(SecurityWarning): + """Warned when using unsupported SSL library""" + + +class SystemTimeWarning(SecurityWarning): + """Warned when system time is suspected to be wrong""" + + +class InsecurePlatformWarning(SecurityWarning): + """Warned when certain TLS/SSL configuration is not available on a platform.""" + + +class DependencyWarning(HTTPWarning): + """ + Warned when an attempt is made to import a module with missing optional + dependencies. + """ + + +class ResponseNotChunked(ProtocolError, ValueError): + """Response needs to be chunked in order to read it as chunks.""" + + +class BodyNotHttplibCompatible(HTTPError): + """ + Body should be :class:`http.client.HTTPResponse` like + (have an fp attribute which returns raw chunks) for read_chunked(). + """ + + +class IncompleteRead(HTTPError, httplib_IncompleteRead): + """ + Response length doesn't match expected Content-Length + + Subclass of :class:`http.client.IncompleteRead` to allow int value + for ``partial`` to avoid creating large objects on streamed reads. + """ + + def __init__(self, partial: int, expected: int) -> None: + self.partial = partial # type: ignore[assignment] + self.expected = expected + + def __repr__(self) -> str: + return "IncompleteRead(%i bytes read, %i more expected)" % ( + self.partial, # type: ignore[str-format] + self.expected, + ) + + +class InvalidChunkLength(HTTPError, httplib_IncompleteRead): + """Invalid chunk length in a chunked response.""" + + def __init__(self, response: HTTPResponse, length: bytes) -> None: + self.partial: int = response.tell() # type: ignore[assignment] + self.expected: int | None = response.length_remaining + self.response = response + self.length = length + + def __repr__(self) -> str: + return "InvalidChunkLength(got length %r, %i bytes read)" % ( + self.length, + self.partial, + ) + + +class InvalidHeader(HTTPError): + """The header provided was somehow invalid.""" + + +class ProxySchemeUnknown(AssertionError, URLSchemeUnknown): + """ProxyManager does not support the supplied scheme""" + + # TODO(t-8ch): Stop inheriting from AssertionError in v2.0. + + def __init__(self, scheme: str | None) -> None: + # 'localhost' is here because our URL parser parses + # localhost:8080 -> scheme=localhost, remove if we fix this. + if scheme == "localhost": + scheme = None + if scheme is None: + message = "Proxy URL had no scheme, should start with http:// or https://" + else: + message = f"Proxy URL had unsupported scheme {scheme}, should use http:// or https://" + super().__init__(message) + + +class ProxySchemeUnsupported(ValueError): + """Fetching HTTPS resources through HTTPS proxies is unsupported""" + + +class HeaderParsingError(HTTPError): + """Raised by assert_header_parsing, but we convert it to a log.warning statement.""" + + def __init__( + self, defects: list[MessageDefect], unparsed_data: bytes | str | None + ) -> None: + message = f"{defects or 'Unknown'}, unparsed data: {unparsed_data!r}" + super().__init__(message) + + +class UnrewindableBodyError(HTTPError): + """urllib3 encountered an error when trying to rewind a body""" diff --git a/Modules/urllib3/fields.py b/Modules/urllib3/fields.py new file mode 100644 index 0000000..51d898e --- /dev/null +++ b/Modules/urllib3/fields.py @@ -0,0 +1,345 @@ +from __future__ import annotations + +import email.utils +import mimetypes +import typing + +_TYPE_FIELD_VALUE = typing.Union[str, bytes] +_TYPE_FIELD_VALUE_TUPLE = typing.Union[ + _TYPE_FIELD_VALUE, + typing.Tuple[str, _TYPE_FIELD_VALUE], + typing.Tuple[str, _TYPE_FIELD_VALUE, str], +] + + +def guess_content_type( + filename: str | None, default: str = "application/octet-stream" +) -> str: + """ + Guess the "Content-Type" of a file. + + :param filename: + The filename to guess the "Content-Type" of using :mod:`mimetypes`. + :param default: + If no "Content-Type" can be guessed, default to `default`. + """ + if filename: + return mimetypes.guess_type(filename)[0] or default + return default + + +def format_header_param_rfc2231(name: str, value: _TYPE_FIELD_VALUE) -> str: + """ + Helper function to format and quote a single header parameter using the + strategy defined in RFC 2231. + + Particularly useful for header parameters which might contain + non-ASCII values, like file names. This follows + `RFC 2388 Section 4.4 `_. + + :param name: + The name of the parameter, a string expected to be ASCII only. + :param value: + The value of the parameter, provided as ``bytes`` or `str``. + :returns: + An RFC-2231-formatted unicode string. + + .. deprecated:: 2.0.0 + Will be removed in urllib3 v2.1.0. This is not valid for + ``multipart/form-data`` header parameters. + """ + import warnings + + warnings.warn( + "'format_header_param_rfc2231' is deprecated and will be " + "removed in urllib3 v2.1.0. This is not valid for " + "multipart/form-data header parameters.", + DeprecationWarning, + stacklevel=2, + ) + + if isinstance(value, bytes): + value = value.decode("utf-8") + + if not any(ch in value for ch in '"\\\r\n'): + result = f'{name}="{value}"' + try: + result.encode("ascii") + except (UnicodeEncodeError, UnicodeDecodeError): + pass + else: + return result + + value = email.utils.encode_rfc2231(value, "utf-8") + value = f"{name}*={value}" + + return value + + +def format_multipart_header_param(name: str, value: _TYPE_FIELD_VALUE) -> str: + """ + Format and quote a single multipart header parameter. + + This follows the `WHATWG HTML Standard`_ as of 2021/06/10, matching + the behavior of current browser and curl versions. Values are + assumed to be UTF-8. The ``\\n``, ``\\r``, and ``"`` characters are + percent encoded. + + .. _WHATWG HTML Standard: + https://html.spec.whatwg.org/multipage/ + form-control-infrastructure.html#multipart-form-data + + :param name: + The name of the parameter, an ASCII-only ``str``. + :param value: + The value of the parameter, a ``str`` or UTF-8 encoded + ``bytes``. + :returns: + A string ``name="value"`` with the escaped value. + + .. versionchanged:: 2.0.0 + Matches the WHATWG HTML Standard as of 2021/06/10. Control + characters are no longer percent encoded. + + .. versionchanged:: 2.0.0 + Renamed from ``format_header_param_html5`` and + ``format_header_param``. The old names will be removed in + urllib3 v2.1.0. + """ + if isinstance(value, bytes): + value = value.decode("utf-8") + + # percent encode \n \r " + value = value.translate({10: "%0A", 13: "%0D", 34: "%22"}) + return f'{name}="{value}"' + + +def format_header_param_html5(name: str, value: _TYPE_FIELD_VALUE) -> str: + """ + .. deprecated:: 2.0.0 + Renamed to :func:`format_multipart_header_param`. Will be + removed in urllib3 v2.1.0. + """ + import warnings + + warnings.warn( + "'format_header_param_html5' has been renamed to " + "'format_multipart_header_param'. The old name will be " + "removed in urllib3 v2.1.0.", + DeprecationWarning, + stacklevel=2, + ) + return format_multipart_header_param(name, value) + + +def format_header_param(name: str, value: _TYPE_FIELD_VALUE) -> str: + """ + .. deprecated:: 2.0.0 + Renamed to :func:`format_multipart_header_param`. Will be + removed in urllib3 v2.1.0. + """ + import warnings + + warnings.warn( + "'format_header_param' has been renamed to " + "'format_multipart_header_param'. The old name will be " + "removed in urllib3 v2.1.0.", + DeprecationWarning, + stacklevel=2, + ) + return format_multipart_header_param(name, value) + + +class RequestField: + """ + A data container for request body parameters. + + :param name: + The name of this request field. Must be unicode. + :param data: + The data/value body. + :param filename: + An optional filename of the request field. Must be unicode. + :param headers: + An optional dict-like object of headers to initially use for the field. + + .. versionchanged:: 2.0.0 + The ``header_formatter`` parameter is deprecated and will + be removed in urllib3 v2.1.0. + """ + + def __init__( + self, + name: str, + data: _TYPE_FIELD_VALUE, + filename: str | None = None, + headers: typing.Mapping[str, str] | None = None, + header_formatter: typing.Callable[[str, _TYPE_FIELD_VALUE], str] | None = None, + ): + self._name = name + self._filename = filename + self.data = data + self.headers: dict[str, str | None] = {} + if headers: + self.headers = dict(headers) + + if header_formatter is not None: + import warnings + + warnings.warn( + "The 'header_formatter' parameter is deprecated and " + "will be removed in urllib3 v2.1.0.", + DeprecationWarning, + stacklevel=2, + ) + self.header_formatter = header_formatter + else: + self.header_formatter = format_multipart_header_param + + @classmethod + def from_tuples( + cls, + fieldname: str, + value: _TYPE_FIELD_VALUE_TUPLE, + header_formatter: typing.Callable[[str, _TYPE_FIELD_VALUE], str] | None = None, + ) -> RequestField: + """ + A :class:`~urllib3.fields.RequestField` factory from old-style tuple parameters. + + Supports constructing :class:`~urllib3.fields.RequestField` from + parameter of key/value strings AND key/filetuple. A filetuple is a + (filename, data, MIME type) tuple where the MIME type is optional. + For example:: + + 'foo': 'bar', + 'fakefile': ('foofile.txt', 'contents of foofile'), + 'realfile': ('barfile.txt', open('realfile').read()), + 'typedfile': ('bazfile.bin', open('bazfile').read(), 'image/jpeg'), + 'nonamefile': 'contents of nonamefile field', + + Field names and filenames must be unicode. + """ + filename: str | None + content_type: str | None + data: _TYPE_FIELD_VALUE + + if isinstance(value, tuple): + if len(value) == 3: + filename, data, content_type = typing.cast( + typing.Tuple[str, _TYPE_FIELD_VALUE, str], value + ) + else: + filename, data = typing.cast( + typing.Tuple[str, _TYPE_FIELD_VALUE], value + ) + content_type = guess_content_type(filename) + else: + filename = None + content_type = None + data = value + + request_param = cls( + fieldname, data, filename=filename, header_formatter=header_formatter + ) + request_param.make_multipart(content_type=content_type) + + return request_param + + def _render_part(self, name: str, value: _TYPE_FIELD_VALUE) -> str: + """ + Override this method to change how each multipart header + parameter is formatted. By default, this calls + :func:`format_multipart_header_param`. + + :param name: + The name of the parameter, an ASCII-only ``str``. + :param value: + The value of the parameter, a ``str`` or UTF-8 encoded + ``bytes``. + + :meta public: + """ + return self.header_formatter(name, value) + + def _render_parts( + self, + header_parts: ( + dict[str, _TYPE_FIELD_VALUE | None] + | typing.Sequence[tuple[str, _TYPE_FIELD_VALUE | None]] + ), + ) -> str: + """ + Helper function to format and quote a single header. + + Useful for single headers that are composed of multiple items. E.g., + 'Content-Disposition' fields. + + :param header_parts: + A sequence of (k, v) tuples or a :class:`dict` of (k, v) to format + as `k1="v1"; k2="v2"; ...`. + """ + iterable: typing.Iterable[tuple[str, _TYPE_FIELD_VALUE | None]] + + parts = [] + if isinstance(header_parts, dict): + iterable = header_parts.items() + else: + iterable = header_parts + + for name, value in iterable: + if value is not None: + parts.append(self._render_part(name, value)) + + return "; ".join(parts) + + def render_headers(self) -> str: + """ + Renders the headers for this request field. + """ + lines = [] + + sort_keys = ["Content-Disposition", "Content-Type", "Content-Location"] + for sort_key in sort_keys: + if self.headers.get(sort_key, False): + lines.append(f"{sort_key}: {self.headers[sort_key]}") + + for header_name, header_value in self.headers.items(): + if header_name not in sort_keys: + if header_value: + lines.append(f"{header_name}: {header_value}") + + lines.append("\r\n") + return "\r\n".join(lines) + + def make_multipart( + self, + content_disposition: str | None = None, + content_type: str | None = None, + content_location: str | None = None, + ) -> None: + """ + Makes this request field into a multipart request field. + + This method overrides "Content-Disposition", "Content-Type" and + "Content-Location" headers to the request parameter. + + :param content_disposition: + The 'Content-Disposition' of the request body. Defaults to 'form-data' + :param content_type: + The 'Content-Type' of the request body. + :param content_location: + The 'Content-Location' of the request body. + + """ + content_disposition = (content_disposition or "form-data") + "; ".join( + [ + "", + self._render_parts( + (("name", self._name), ("filename", self._filename)) + ), + ] + ) + + self.headers["Content-Disposition"] = content_disposition + self.headers["Content-Type"] = content_type + self.headers["Content-Location"] = content_location diff --git a/Modules/urllib3/filepost.py b/Modules/urllib3/filepost.py new file mode 100644 index 0000000..1c90a21 --- /dev/null +++ b/Modules/urllib3/filepost.py @@ -0,0 +1,89 @@ +from __future__ import annotations + +import binascii +import codecs +import os +import typing +from io import BytesIO + +from .fields import _TYPE_FIELD_VALUE_TUPLE, RequestField + +writer = codecs.lookup("utf-8")[3] + +_TYPE_FIELDS_SEQUENCE = typing.Sequence[ + typing.Union[typing.Tuple[str, _TYPE_FIELD_VALUE_TUPLE], RequestField] +] +_TYPE_FIELDS = typing.Union[ + _TYPE_FIELDS_SEQUENCE, + typing.Mapping[str, _TYPE_FIELD_VALUE_TUPLE], +] + + +def choose_boundary() -> str: + """ + Our embarrassingly-simple replacement for mimetools.choose_boundary. + """ + return binascii.hexlify(os.urandom(16)).decode() + + +def iter_field_objects(fields: _TYPE_FIELDS) -> typing.Iterable[RequestField]: + """ + Iterate over fields. + + Supports list of (k, v) tuples and dicts, and lists of + :class:`~urllib3.fields.RequestField`. + + """ + iterable: typing.Iterable[RequestField | tuple[str, _TYPE_FIELD_VALUE_TUPLE]] + + if isinstance(fields, typing.Mapping): + iterable = fields.items() + else: + iterable = fields + + for field in iterable: + if isinstance(field, RequestField): + yield field + else: + yield RequestField.from_tuples(*field) + + +def encode_multipart_formdata( + fields: _TYPE_FIELDS, boundary: str | None = None +) -> tuple[bytes, str]: + """ + Encode a dictionary of ``fields`` using the multipart/form-data MIME format. + + :param fields: + Dictionary of fields or list of (key, :class:`~urllib3.fields.RequestField`). + Values are processed by :func:`urllib3.fields.RequestField.from_tuples`. + + :param boundary: + If not specified, then a random boundary will be generated using + :func:`urllib3.filepost.choose_boundary`. + """ + body = BytesIO() + if boundary is None: + boundary = choose_boundary() + + for field in iter_field_objects(fields): + body.write(f"--{boundary}\r\n".encode("latin-1")) + + writer(body).write(field.render_headers()) + data = field.data + + if isinstance(data, int): + data = str(data) # Backwards compatibility + + if isinstance(data, str): + writer(body).write(data) + else: + body.write(data) + + body.write(b"\r\n") + + body.write(f"--{boundary}--\r\n".encode("latin-1")) + + content_type = f"multipart/form-data; boundary={boundary}" + + return body.getvalue(), content_type diff --git a/Modules/urllib3/poolmanager.py b/Modules/urllib3/poolmanager.py new file mode 100644 index 0000000..32da0a0 --- /dev/null +++ b/Modules/urllib3/poolmanager.py @@ -0,0 +1,638 @@ +from __future__ import annotations + +import functools +import logging +import typing +import warnings +from types import TracebackType +from urllib.parse import urljoin + +from ._collections import HTTPHeaderDict, RecentlyUsedContainer +from ._request_methods import RequestMethods +from .connection import ProxyConfig +from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, port_by_scheme +from .exceptions import ( + LocationValueError, + MaxRetryError, + ProxySchemeUnknown, + URLSchemeUnknown, +) +from .response import BaseHTTPResponse +from .util.connection import _TYPE_SOCKET_OPTIONS +from .util.proxy import connection_requires_http_tunnel +from .util.retry import Retry +from .util.timeout import Timeout +from .util.url import Url, parse_url + +if typing.TYPE_CHECKING: + import ssl + from typing import Literal + +__all__ = ["PoolManager", "ProxyManager", "proxy_from_url"] + + +log = logging.getLogger(__name__) + +SSL_KEYWORDS = ( + "key_file", + "cert_file", + "cert_reqs", + "ca_certs", + "ca_cert_data", + "ssl_version", + "ssl_minimum_version", + "ssl_maximum_version", + "ca_cert_dir", + "ssl_context", + "key_password", + "server_hostname", +) +# Default value for `blocksize` - a new parameter introduced to +# http.client.HTTPConnection & http.client.HTTPSConnection in Python 3.7 +_DEFAULT_BLOCKSIZE = 16384 + +_SelfT = typing.TypeVar("_SelfT") + + +class PoolKey(typing.NamedTuple): + """ + All known keyword arguments that could be provided to the pool manager, its + pools, or the underlying connections. + + All custom key schemes should include the fields in this key at a minimum. + """ + + key_scheme: str + key_host: str + key_port: int | None + key_timeout: Timeout | float | int | None + key_retries: Retry | bool | int | None + key_block: bool | None + key_source_address: tuple[str, int] | None + key_key_file: str | None + key_key_password: str | None + key_cert_file: str | None + key_cert_reqs: str | None + key_ca_certs: str | None + key_ca_cert_data: str | bytes | None + key_ssl_version: int | str | None + key_ssl_minimum_version: ssl.TLSVersion | None + key_ssl_maximum_version: ssl.TLSVersion | None + key_ca_cert_dir: str | None + key_ssl_context: ssl.SSLContext | None + key_maxsize: int | None + key_headers: frozenset[tuple[str, str]] | None + key__proxy: Url | None + key__proxy_headers: frozenset[tuple[str, str]] | None + key__proxy_config: ProxyConfig | None + key_socket_options: _TYPE_SOCKET_OPTIONS | None + key__socks_options: frozenset[tuple[str, str]] | None + key_assert_hostname: bool | str | None + key_assert_fingerprint: str | None + key_server_hostname: str | None + key_blocksize: int | None + + +def _default_key_normalizer( + key_class: type[PoolKey], request_context: dict[str, typing.Any] +) -> PoolKey: + """ + Create a pool key out of a request context dictionary. + + According to RFC 3986, both the scheme and host are case-insensitive. + Therefore, this function normalizes both before constructing the pool + key for an HTTPS request. If you wish to change this behaviour, provide + alternate callables to ``key_fn_by_scheme``. + + :param key_class: + The class to use when constructing the key. This should be a namedtuple + with the ``scheme`` and ``host`` keys at a minimum. + :type key_class: namedtuple + :param request_context: + A dictionary-like object that contain the context for a request. + :type request_context: dict + + :return: A namedtuple that can be used as a connection pool key. + :rtype: PoolKey + """ + # Since we mutate the dictionary, make a copy first + context = request_context.copy() + context["scheme"] = context["scheme"].lower() + context["host"] = context["host"].lower() + + # These are both dictionaries and need to be transformed into frozensets + for key in ("headers", "_proxy_headers", "_socks_options"): + if key in context and context[key] is not None: + context[key] = frozenset(context[key].items()) + + # The socket_options key may be a list and needs to be transformed into a + # tuple. + socket_opts = context.get("socket_options") + if socket_opts is not None: + context["socket_options"] = tuple(socket_opts) + + # Map the kwargs to the names in the namedtuple - this is necessary since + # namedtuples can't have fields starting with '_'. + for key in list(context.keys()): + context["key_" + key] = context.pop(key) + + # Default to ``None`` for keys missing from the context + for field in key_class._fields: + if field not in context: + context[field] = None + + # Default key_blocksize to _DEFAULT_BLOCKSIZE if missing from the context + if context.get("key_blocksize") is None: + context["key_blocksize"] = _DEFAULT_BLOCKSIZE + + return key_class(**context) + + +#: A dictionary that maps a scheme to a callable that creates a pool key. +#: This can be used to alter the way pool keys are constructed, if desired. +#: Each PoolManager makes a copy of this dictionary so they can be configured +#: globally here, or individually on the instance. +key_fn_by_scheme = { + "http": functools.partial(_default_key_normalizer, PoolKey), + "https": functools.partial(_default_key_normalizer, PoolKey), +} + +pool_classes_by_scheme = {"http": HTTPConnectionPool, "https": HTTPSConnectionPool} + + +class PoolManager(RequestMethods): + """ + Allows for arbitrary requests while transparently keeping track of + necessary connection pools for you. + + :param num_pools: + Number of connection pools to cache before discarding the least + recently used pool. + + :param headers: + Headers to include with all requests, unless other headers are given + explicitly. + + :param \\**connection_pool_kw: + Additional parameters are used to create fresh + :class:`urllib3.connectionpool.ConnectionPool` instances. + + Example: + + .. code-block:: python + + import urllib3 + + http = urllib3.PoolManager(num_pools=2) + + resp1 = http.request("GET", "https://google.com/") + resp2 = http.request("GET", "https://google.com/mail") + resp3 = http.request("GET", "https://yahoo.com/") + + print(len(http.pools)) + # 2 + + """ + + proxy: Url | None = None + proxy_config: ProxyConfig | None = None + + def __init__( + self, + num_pools: int = 10, + headers: typing.Mapping[str, str] | None = None, + **connection_pool_kw: typing.Any, + ) -> None: + super().__init__(headers) + self.connection_pool_kw = connection_pool_kw + + self.pools: RecentlyUsedContainer[PoolKey, HTTPConnectionPool] + self.pools = RecentlyUsedContainer(num_pools) + + # Locally set the pool classes and keys so other PoolManagers can + # override them. + self.pool_classes_by_scheme = pool_classes_by_scheme + self.key_fn_by_scheme = key_fn_by_scheme.copy() + + def __enter__(self: _SelfT) -> _SelfT: + return self + + def __exit__( + self, + exc_type: type[BaseException] | None, + exc_val: BaseException | None, + exc_tb: TracebackType | None, + ) -> Literal[False]: + self.clear() + # Return False to re-raise any potential exceptions + return False + + def _new_pool( + self, + scheme: str, + host: str, + port: int, + request_context: dict[str, typing.Any] | None = None, + ) -> HTTPConnectionPool: + """ + Create a new :class:`urllib3.connectionpool.ConnectionPool` based on host, port, scheme, and + any additional pool keyword arguments. + + If ``request_context`` is provided, it is provided as keyword arguments + to the pool class used. This method is used to actually create the + connection pools handed out by :meth:`connection_from_url` and + companion methods. It is intended to be overridden for customization. + """ + pool_cls: type[HTTPConnectionPool] = self.pool_classes_by_scheme[scheme] + if request_context is None: + request_context = self.connection_pool_kw.copy() + + # Default blocksize to _DEFAULT_BLOCKSIZE if missing or explicitly + # set to 'None' in the request_context. + if request_context.get("blocksize") is None: + request_context["blocksize"] = _DEFAULT_BLOCKSIZE + + # Although the context has everything necessary to create the pool, + # this function has historically only used the scheme, host, and port + # in the positional args. When an API change is acceptable these can + # be removed. + for key in ("scheme", "host", "port"): + request_context.pop(key, None) + + if scheme == "http": + for kw in SSL_KEYWORDS: + request_context.pop(kw, None) + + return pool_cls(host, port, **request_context) + + def clear(self) -> None: + """ + Empty our store of pools and direct them all to close. + + This will not affect in-flight connections, but they will not be + re-used after completion. + """ + self.pools.clear() + + def connection_from_host( + self, + host: str | None, + port: int | None = None, + scheme: str | None = "http", + pool_kwargs: dict[str, typing.Any] | None = None, + ) -> HTTPConnectionPool: + """ + Get a :class:`urllib3.connectionpool.ConnectionPool` based on the host, port, and scheme. + + If ``port`` isn't given, it will be derived from the ``scheme`` using + ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is + provided, it is merged with the instance's ``connection_pool_kw`` + variable and used to create the new connection pool, if one is + needed. + """ + + if not host: + raise LocationValueError("No host specified.") + + request_context = self._merge_pool_kwargs(pool_kwargs) + request_context["scheme"] = scheme or "http" + if not port: + port = port_by_scheme.get(request_context["scheme"].lower(), 80) + request_context["port"] = port + request_context["host"] = host + + return self.connection_from_context(request_context) + + def connection_from_context( + self, request_context: dict[str, typing.Any] + ) -> HTTPConnectionPool: + """ + Get a :class:`urllib3.connectionpool.ConnectionPool` based on the request context. + + ``request_context`` must at least contain the ``scheme`` key and its + value must be a key in ``key_fn_by_scheme`` instance variable. + """ + if "strict" in request_context: + warnings.warn( + "The 'strict' parameter is no longer needed on Python 3+. " + "This will raise an error in urllib3 v2.1.0.", + DeprecationWarning, + ) + request_context.pop("strict") + + scheme = request_context["scheme"].lower() + pool_key_constructor = self.key_fn_by_scheme.get(scheme) + if not pool_key_constructor: + raise URLSchemeUnknown(scheme) + pool_key = pool_key_constructor(request_context) + + return self.connection_from_pool_key(pool_key, request_context=request_context) + + def connection_from_pool_key( + self, pool_key: PoolKey, request_context: dict[str, typing.Any] + ) -> HTTPConnectionPool: + """ + Get a :class:`urllib3.connectionpool.ConnectionPool` based on the provided pool key. + + ``pool_key`` should be a namedtuple that only contains immutable + objects. At a minimum it must have the ``scheme``, ``host``, and + ``port`` fields. + """ + with self.pools.lock: + # If the scheme, host, or port doesn't match existing open + # connections, open a new ConnectionPool. + pool = self.pools.get(pool_key) + if pool: + return pool + + # Make a fresh ConnectionPool of the desired type + scheme = request_context["scheme"] + host = request_context["host"] + port = request_context["port"] + pool = self._new_pool(scheme, host, port, request_context=request_context) + self.pools[pool_key] = pool + + return pool + + def connection_from_url( + self, url: str, pool_kwargs: dict[str, typing.Any] | None = None + ) -> HTTPConnectionPool: + """ + Similar to :func:`urllib3.connectionpool.connection_from_url`. + + If ``pool_kwargs`` is not provided and a new pool needs to be + constructed, ``self.connection_pool_kw`` is used to initialize + the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs`` + is provided, it is used instead. Note that if a new pool does not + need to be created for the request, the provided ``pool_kwargs`` are + not used. + """ + u = parse_url(url) + return self.connection_from_host( + u.host, port=u.port, scheme=u.scheme, pool_kwargs=pool_kwargs + ) + + def _merge_pool_kwargs( + self, override: dict[str, typing.Any] | None + ) -> dict[str, typing.Any]: + """ + Merge a dictionary of override values for self.connection_pool_kw. + + This does not modify self.connection_pool_kw and returns a new dict. + Any keys in the override dictionary with a value of ``None`` are + removed from the merged dictionary. + """ + base_pool_kwargs = self.connection_pool_kw.copy() + if override: + for key, value in override.items(): + if value is None: + try: + del base_pool_kwargs[key] + except KeyError: + pass + else: + base_pool_kwargs[key] = value + return base_pool_kwargs + + def _proxy_requires_url_absolute_form(self, parsed_url: Url) -> bool: + """ + Indicates if the proxy requires the complete destination URL in the + request. Normally this is only needed when not using an HTTP CONNECT + tunnel. + """ + if self.proxy is None: + return False + + return not connection_requires_http_tunnel( + self.proxy, self.proxy_config, parsed_url.scheme + ) + + def urlopen( # type: ignore[override] + self, method: str, url: str, redirect: bool = True, **kw: typing.Any + ) -> BaseHTTPResponse: + """ + Same as :meth:`urllib3.HTTPConnectionPool.urlopen` + with custom cross-host redirect logic and only sends the request-uri + portion of the ``url``. + + The given ``url`` parameter must be absolute, such that an appropriate + :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it. + """ + u = parse_url(url) + + if u.scheme is None: + warnings.warn( + "URLs without a scheme (ie 'https://') are deprecated and will raise an error " + "in a future version of urllib3. To avoid this DeprecationWarning ensure all URLs " + "start with 'https://' or 'http://'. Read more in this issue: " + "https://github.com/urllib3/urllib3/issues/2920", + category=DeprecationWarning, + stacklevel=2, + ) + + conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme) + + kw["assert_same_host"] = False + kw["redirect"] = False + + if "headers" not in kw: + kw["headers"] = self.headers + + if self._proxy_requires_url_absolute_form(u): + response = conn.urlopen(method, url, **kw) + else: + response = conn.urlopen(method, u.request_uri, **kw) + + redirect_location = redirect and response.get_redirect_location() + if not redirect_location: + return response + + # Support relative URLs for redirecting. + redirect_location = urljoin(url, redirect_location) + + if response.status == 303: + # Change the method according to RFC 9110, Section 15.4.4. + method = "GET" + # And lose the body not to transfer anything sensitive. + kw["body"] = None + kw["headers"] = HTTPHeaderDict(kw["headers"])._prepare_for_method_change() + + retries = kw.get("retries") + if not isinstance(retries, Retry): + retries = Retry.from_int(retries, redirect=redirect) + + # Strip headers marked as unsafe to forward to the redirected location. + # Check remove_headers_on_redirect to avoid a potential network call within + # conn.is_same_host() which may use socket.gethostbyname() in the future. + if retries.remove_headers_on_redirect and not conn.is_same_host( + redirect_location + ): + new_headers = kw["headers"].copy() + for header in kw["headers"]: + if header.lower() in retries.remove_headers_on_redirect: + new_headers.pop(header, None) + kw["headers"] = new_headers + + try: + retries = retries.increment(method, url, response=response, _pool=conn) + except MaxRetryError: + if retries.raise_on_redirect: + response.drain_conn() + raise + return response + + kw["retries"] = retries + kw["redirect"] = redirect + + log.info("Redirecting %s -> %s", url, redirect_location) + + response.drain_conn() + return self.urlopen(method, redirect_location, **kw) + + +class ProxyManager(PoolManager): + """ + Behaves just like :class:`PoolManager`, but sends all requests through + the defined proxy, using the CONNECT method for HTTPS URLs. + + :param proxy_url: + The URL of the proxy to be used. + + :param proxy_headers: + A dictionary containing headers that will be sent to the proxy. In case + of HTTP they are being sent with each request, while in the + HTTPS/CONNECT case they are sent only once. Could be used for proxy + authentication. + + :param proxy_ssl_context: + The proxy SSL context is used to establish the TLS connection to the + proxy when using HTTPS proxies. + + :param use_forwarding_for_https: + (Defaults to False) If set to True will forward requests to the HTTPS + proxy to be made on behalf of the client instead of creating a TLS + tunnel via the CONNECT method. **Enabling this flag means that request + and response headers and content will be visible from the HTTPS proxy** + whereas tunneling keeps request and response headers and content + private. IP address, target hostname, SNI, and port are always visible + to an HTTPS proxy even when this flag is disabled. + + :param proxy_assert_hostname: + The hostname of the certificate to verify against. + + :param proxy_assert_fingerprint: + The fingerprint of the certificate to verify against. + + Example: + + .. code-block:: python + + import urllib3 + + proxy = urllib3.ProxyManager("https://localhost:3128/") + + resp1 = proxy.request("GET", "https://google.com/") + resp2 = proxy.request("GET", "https://httpbin.org/") + + print(len(proxy.pools)) + # 1 + + resp3 = proxy.request("GET", "https://httpbin.org/") + resp4 = proxy.request("GET", "https://twitter.com/") + + print(len(proxy.pools)) + # 3 + + """ + + def __init__( + self, + proxy_url: str, + num_pools: int = 10, + headers: typing.Mapping[str, str] | None = None, + proxy_headers: typing.Mapping[str, str] | None = None, + proxy_ssl_context: ssl.SSLContext | None = None, + use_forwarding_for_https: bool = False, + proxy_assert_hostname: None | str | Literal[False] = None, + proxy_assert_fingerprint: str | None = None, + **connection_pool_kw: typing.Any, + ) -> None: + if isinstance(proxy_url, HTTPConnectionPool): + str_proxy_url = f"{proxy_url.scheme}://{proxy_url.host}:{proxy_url.port}" + else: + str_proxy_url = proxy_url + proxy = parse_url(str_proxy_url) + + if proxy.scheme not in ("http", "https"): + raise ProxySchemeUnknown(proxy.scheme) + + if not proxy.port: + port = port_by_scheme.get(proxy.scheme, 80) + proxy = proxy._replace(port=port) + + self.proxy = proxy + self.proxy_headers = proxy_headers or {} + self.proxy_ssl_context = proxy_ssl_context + self.proxy_config = ProxyConfig( + proxy_ssl_context, + use_forwarding_for_https, + proxy_assert_hostname, + proxy_assert_fingerprint, + ) + + connection_pool_kw["_proxy"] = self.proxy + connection_pool_kw["_proxy_headers"] = self.proxy_headers + connection_pool_kw["_proxy_config"] = self.proxy_config + + super().__init__(num_pools, headers, **connection_pool_kw) + + def connection_from_host( + self, + host: str | None, + port: int | None = None, + scheme: str | None = "http", + pool_kwargs: dict[str, typing.Any] | None = None, + ) -> HTTPConnectionPool: + if scheme == "https": + return super().connection_from_host( + host, port, scheme, pool_kwargs=pool_kwargs + ) + + return super().connection_from_host( + self.proxy.host, self.proxy.port, self.proxy.scheme, pool_kwargs=pool_kwargs # type: ignore[union-attr] + ) + + def _set_proxy_headers( + self, url: str, headers: typing.Mapping[str, str] | None = None + ) -> typing.Mapping[str, str]: + """ + Sets headers needed by proxies: specifically, the Accept and Host + headers. Only sets headers not provided by the user. + """ + headers_ = {"Accept": "*/*"} + + netloc = parse_url(url).netloc + if netloc: + headers_["Host"] = netloc + + if headers: + headers_.update(headers) + return headers_ + + def urlopen( # type: ignore[override] + self, method: str, url: str, redirect: bool = True, **kw: typing.Any + ) -> BaseHTTPResponse: + "Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute." + u = parse_url(url) + if not connection_requires_http_tunnel(self.proxy, self.proxy_config, u.scheme): + # For connections using HTTP CONNECT, httplib sets the necessary + # headers on the CONNECT to the proxy. If we're not using CONNECT, + # we'll definitely need to set 'Host' at the very least. + headers = kw.get("headers", self.headers) + kw["headers"] = self._set_proxy_headers(url, headers) + + return super().urlopen(method, url, redirect=redirect, **kw) + + +def proxy_from_url(url: str, **kw: typing.Any) -> ProxyManager: + return ProxyManager(proxy_url=url, **kw) diff --git a/Modules/urllib3/py.typed b/Modules/urllib3/py.typed new file mode 100644 index 0000000..5f3ea3d --- /dev/null +++ b/Modules/urllib3/py.typed @@ -0,0 +1,2 @@ +# Instruct type checkers to look for inline type annotations in this package. +# See PEP 561. diff --git a/Modules/urllib3/response.py b/Modules/urllib3/response.py new file mode 100644 index 0000000..37936f9 --- /dev/null +++ b/Modules/urllib3/response.py @@ -0,0 +1,1130 @@ +from __future__ import annotations + +import collections +import io +import json as _json +import logging +import re +import sys +import typing +import warnings +import zlib +from contextlib import contextmanager +from http.client import HTTPMessage as _HttplibHTTPMessage +from http.client import HTTPResponse as _HttplibHTTPResponse +from socket import timeout as SocketTimeout + +try: + try: + import brotlicffi as brotli # type: ignore[import] + except ImportError: + import brotli # type: ignore[import] +except ImportError: + brotli = None + +try: + import zstandard as zstd # type: ignore[import] + + # The package 'zstandard' added the 'eof' property starting + # in v0.18.0 which we require to ensure a complete and + # valid zstd stream was fed into the ZstdDecoder. + # See: https://github.com/urllib3/urllib3/pull/2624 + _zstd_version = _zstd_version = tuple( + map(int, re.search(r"^([0-9]+)\.([0-9]+)", zstd.__version__).groups()) # type: ignore[union-attr] + ) + if _zstd_version < (0, 18): # Defensive: + zstd = None + +except (AttributeError, ImportError, ValueError): # Defensive: + zstd = None + +from . import util +from ._base_connection import _TYPE_BODY +from ._collections import HTTPHeaderDict +from .connection import BaseSSLError, HTTPConnection, HTTPException +from .exceptions import ( + BodyNotHttplibCompatible, + DecodeError, + HTTPError, + IncompleteRead, + InvalidChunkLength, + InvalidHeader, + ProtocolError, + ReadTimeoutError, + ResponseNotChunked, + SSLError, +) +from .util.response import is_fp_closed, is_response_to_head +from .util.retry import Retry + +if typing.TYPE_CHECKING: + from typing import Literal + + from .connectionpool import HTTPConnectionPool + +log = logging.getLogger(__name__) + + +class ContentDecoder: + def decompress(self, data: bytes) -> bytes: + raise NotImplementedError() + + def flush(self) -> bytes: + raise NotImplementedError() + + +class DeflateDecoder(ContentDecoder): + def __init__(self) -> None: + self._first_try = True + self._data = b"" + self._obj = zlib.decompressobj() + + def decompress(self, data: bytes) -> bytes: + if not data: + return data + + if not self._first_try: + return self._obj.decompress(data) + + self._data += data + try: + decompressed = self._obj.decompress(data) + if decompressed: + self._first_try = False + self._data = None # type: ignore[assignment] + return decompressed + except zlib.error: + self._first_try = False + self._obj = zlib.decompressobj(-zlib.MAX_WBITS) + try: + return self.decompress(self._data) + finally: + self._data = None # type: ignore[assignment] + + def flush(self) -> bytes: + return self._obj.flush() + + +class GzipDecoderState: + FIRST_MEMBER = 0 + OTHER_MEMBERS = 1 + SWALLOW_DATA = 2 + + +class GzipDecoder(ContentDecoder): + def __init__(self) -> None: + self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS) + self._state = GzipDecoderState.FIRST_MEMBER + + def decompress(self, data: bytes) -> bytes: + ret = bytearray() + if self._state == GzipDecoderState.SWALLOW_DATA or not data: + return bytes(ret) + while True: + try: + ret += self._obj.decompress(data) + except zlib.error: + previous_state = self._state + # Ignore data after the first error + self._state = GzipDecoderState.SWALLOW_DATA + if previous_state == GzipDecoderState.OTHER_MEMBERS: + # Allow trailing garbage acceptable in other gzip clients + return bytes(ret) + raise + data = self._obj.unused_data + if not data: + return bytes(ret) + self._state = GzipDecoderState.OTHER_MEMBERS + self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS) + + def flush(self) -> bytes: + return self._obj.flush() + + +if brotli is not None: + + class BrotliDecoder(ContentDecoder): + # Supports both 'brotlipy' and 'Brotli' packages + # since they share an import name. The top branches + # are for 'brotlipy' and bottom branches for 'Brotli' + def __init__(self) -> None: + self._obj = brotli.Decompressor() + if hasattr(self._obj, "decompress"): + setattr(self, "decompress", self._obj.decompress) + else: + setattr(self, "decompress", self._obj.process) + + def flush(self) -> bytes: + if hasattr(self._obj, "flush"): + return self._obj.flush() # type: ignore[no-any-return] + return b"" + + +if zstd is not None: + + class ZstdDecoder(ContentDecoder): + def __init__(self) -> None: + self._obj = zstd.ZstdDecompressor().decompressobj() + + def decompress(self, data: bytes) -> bytes: + if not data: + return b"" + data_parts = [self._obj.decompress(data)] + while self._obj.eof and self._obj.unused_data: + unused_data = self._obj.unused_data + self._obj = zstd.ZstdDecompressor().decompressobj() + data_parts.append(self._obj.decompress(unused_data)) + return b"".join(data_parts) + + def flush(self) -> bytes: + ret = self._obj.flush() # note: this is a no-op + if not self._obj.eof: + raise DecodeError("Zstandard data is incomplete") + return ret # type: ignore[no-any-return] + + +class MultiDecoder(ContentDecoder): + """ + From RFC7231: + If one or more encodings have been applied to a representation, the + sender that applied the encodings MUST generate a Content-Encoding + header field that lists the content codings in the order in which + they were applied. + """ + + def __init__(self, modes: str) -> None: + self._decoders = [_get_decoder(m.strip()) for m in modes.split(",")] + + def flush(self) -> bytes: + return self._decoders[0].flush() + + def decompress(self, data: bytes) -> bytes: + for d in reversed(self._decoders): + data = d.decompress(data) + return data + + +def _get_decoder(mode: str) -> ContentDecoder: + if "," in mode: + return MultiDecoder(mode) + + # According to RFC 9110 section 8.4.1.3, recipients should + # consider x-gzip equivalent to gzip + if mode in ("gzip", "x-gzip"): + return GzipDecoder() + + if brotli is not None and mode == "br": + return BrotliDecoder() + + if zstd is not None and mode == "zstd": + return ZstdDecoder() + + return DeflateDecoder() + + +class BytesQueueBuffer: + """Memory-efficient bytes buffer + + To return decoded data in read() and still follow the BufferedIOBase API, we need a + buffer to always return the correct amount of bytes. + + This buffer should be filled using calls to put() + + Our maximum memory usage is determined by the sum of the size of: + + * self.buffer, which contains the full data + * the largest chunk that we will copy in get() + + The worst case scenario is a single chunk, in which case we'll make a full copy of + the data inside get(). + """ + + def __init__(self) -> None: + self.buffer: typing.Deque[bytes] = collections.deque() + self._size: int = 0 + + def __len__(self) -> int: + return self._size + + def put(self, data: bytes) -> None: + self.buffer.append(data) + self._size += len(data) + + def get(self, n: int) -> bytes: + if n == 0: + return b"" + elif not self.buffer: + raise RuntimeError("buffer is empty") + elif n < 0: + raise ValueError("n should be > 0") + + fetched = 0 + ret = io.BytesIO() + while fetched < n: + remaining = n - fetched + chunk = self.buffer.popleft() + chunk_length = len(chunk) + if remaining < chunk_length: + left_chunk, right_chunk = chunk[:remaining], chunk[remaining:] + ret.write(left_chunk) + self.buffer.appendleft(right_chunk) + self._size -= remaining + break + else: + ret.write(chunk) + self._size -= chunk_length + fetched += chunk_length + + if not self.buffer: + break + + return ret.getvalue() + + +class BaseHTTPResponse(io.IOBase): + CONTENT_DECODERS = ["gzip", "x-gzip", "deflate"] + if brotli is not None: + CONTENT_DECODERS += ["br"] + if zstd is not None: + CONTENT_DECODERS += ["zstd"] + REDIRECT_STATUSES = [301, 302, 303, 307, 308] + + DECODER_ERROR_CLASSES: tuple[type[Exception], ...] = (IOError, zlib.error) + if brotli is not None: + DECODER_ERROR_CLASSES += (brotli.error,) + + if zstd is not None: + DECODER_ERROR_CLASSES += (zstd.ZstdError,) + + def __init__( + self, + *, + headers: typing.Mapping[str, str] | typing.Mapping[bytes, bytes] | None = None, + status: int, + version: int, + reason: str | None, + decode_content: bool, + request_url: str | None, + retries: Retry | None = None, + ) -> None: + if isinstance(headers, HTTPHeaderDict): + self.headers = headers + else: + self.headers = HTTPHeaderDict(headers) # type: ignore[arg-type] + self.status = status + self.version = version + self.reason = reason + self.decode_content = decode_content + self._has_decoded_content = False + self._request_url: str | None = request_url + self.retries = retries + + self.chunked = False + tr_enc = self.headers.get("transfer-encoding", "").lower() + # Don't incur the penalty of creating a list and then discarding it + encodings = (enc.strip() for enc in tr_enc.split(",")) + if "chunked" in encodings: + self.chunked = True + + self._decoder: ContentDecoder | None = None + + def get_redirect_location(self) -> str | None | Literal[False]: + """ + Should we redirect and where to? + + :returns: Truthy redirect location string if we got a redirect status + code and valid location. ``None`` if redirect status and no + location. ``False`` if not a redirect status code. + """ + if self.status in self.REDIRECT_STATUSES: + return self.headers.get("location") + return False + + @property + def data(self) -> bytes: + raise NotImplementedError() + + def json(self) -> typing.Any: + """ + Parses the body of the HTTP response as JSON. + + To use a custom JSON decoder pass the result of :attr:`HTTPResponse.data` to the decoder. + + This method can raise either `UnicodeDecodeError` or `json.JSONDecodeError`. + + Read more :ref:`here `. + """ + data = self.data.decode("utf-8") + return _json.loads(data) + + @property + def url(self) -> str | None: + raise NotImplementedError() + + @url.setter + def url(self, url: str | None) -> None: + raise NotImplementedError() + + @property + def connection(self) -> HTTPConnection | None: + raise NotImplementedError() + + @property + def retries(self) -> Retry | None: + return self._retries + + @retries.setter + def retries(self, retries: Retry | None) -> None: + # Override the request_url if retries has a redirect location. + if retries is not None and retries.history: + self.url = retries.history[-1].redirect_location + self._retries = retries + + def stream( + self, amt: int | None = 2**16, decode_content: bool | None = None + ) -> typing.Iterator[bytes]: + raise NotImplementedError() + + def read( + self, + amt: int | None = None, + decode_content: bool | None = None, + cache_content: bool = False, + ) -> bytes: + raise NotImplementedError() + + def read_chunked( + self, + amt: int | None = None, + decode_content: bool | None = None, + ) -> typing.Iterator[bytes]: + raise NotImplementedError() + + def release_conn(self) -> None: + raise NotImplementedError() + + def drain_conn(self) -> None: + raise NotImplementedError() + + def close(self) -> None: + raise NotImplementedError() + + def _init_decoder(self) -> None: + """ + Set-up the _decoder attribute if necessary. + """ + # Note: content-encoding value should be case-insensitive, per RFC 7230 + # Section 3.2 + content_encoding = self.headers.get("content-encoding", "").lower() + if self._decoder is None: + if content_encoding in self.CONTENT_DECODERS: + self._decoder = _get_decoder(content_encoding) + elif "," in content_encoding: + encodings = [ + e.strip() + for e in content_encoding.split(",") + if e.strip() in self.CONTENT_DECODERS + ] + if encodings: + self._decoder = _get_decoder(content_encoding) + + def _decode( + self, data: bytes, decode_content: bool | None, flush_decoder: bool + ) -> bytes: + """ + Decode the data passed in and potentially flush the decoder. + """ + if not decode_content: + if self._has_decoded_content: + raise RuntimeError( + "Calling read(decode_content=False) is not supported after " + "read(decode_content=True) was called." + ) + return data + + try: + if self._decoder: + data = self._decoder.decompress(data) + self._has_decoded_content = True + except self.DECODER_ERROR_CLASSES as e: + content_encoding = self.headers.get("content-encoding", "").lower() + raise DecodeError( + "Received response with content-encoding: %s, but " + "failed to decode it." % content_encoding, + e, + ) from e + if flush_decoder: + data += self._flush_decoder() + + return data + + def _flush_decoder(self) -> bytes: + """ + Flushes the decoder. Should only be called if the decoder is actually + being used. + """ + if self._decoder: + return self._decoder.decompress(b"") + self._decoder.flush() + return b"" + + # Compatibility methods for `io` module + def readinto(self, b: bytearray) -> int: + temp = self.read(len(b)) + if len(temp) == 0: + return 0 + else: + b[: len(temp)] = temp + return len(temp) + + # Compatibility methods for http.client.HTTPResponse + def getheaders(self) -> HTTPHeaderDict: + warnings.warn( + "HTTPResponse.getheaders() is deprecated and will be removed " + "in urllib3 v2.1.0. Instead access HTTPResponse.headers directly.", + category=DeprecationWarning, + stacklevel=2, + ) + return self.headers + + def getheader(self, name: str, default: str | None = None) -> str | None: + warnings.warn( + "HTTPResponse.getheader() is deprecated and will be removed " + "in urllib3 v2.1.0. Instead use HTTPResponse.headers.get(name, default).", + category=DeprecationWarning, + stacklevel=2, + ) + return self.headers.get(name, default) + + # Compatibility method for http.cookiejar + def info(self) -> HTTPHeaderDict: + return self.headers + + def geturl(self) -> str | None: + return self.url + + +class HTTPResponse(BaseHTTPResponse): + """ + HTTP Response container. + + Backwards-compatible with :class:`http.client.HTTPResponse` but the response ``body`` is + loaded and decoded on-demand when the ``data`` property is accessed. This + class is also compatible with the Python standard library's :mod:`io` + module, and can hence be treated as a readable object in the context of that + framework. + + Extra parameters for behaviour not present in :class:`http.client.HTTPResponse`: + + :param preload_content: + If True, the response's body will be preloaded during construction. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + + :param original_response: + When this HTTPResponse wrapper is generated from an :class:`http.client.HTTPResponse` + object, it's convenient to include the original for debug purposes. It's + otherwise unused. + + :param retries: + The retries contains the last :class:`~urllib3.util.retry.Retry` that + was used during the request. + + :param enforce_content_length: + Enforce content length checking. Body returned by server must match + value of Content-Length header, if present. Otherwise, raise error. + """ + + def __init__( + self, + body: _TYPE_BODY = "", + headers: typing.Mapping[str, str] | typing.Mapping[bytes, bytes] | None = None, + status: int = 0, + version: int = 0, + reason: str | None = None, + preload_content: bool = True, + decode_content: bool = True, + original_response: _HttplibHTTPResponse | None = None, + pool: HTTPConnectionPool | None = None, + connection: HTTPConnection | None = None, + msg: _HttplibHTTPMessage | None = None, + retries: Retry | None = None, + enforce_content_length: bool = True, + request_method: str | None = None, + request_url: str | None = None, + auto_close: bool = True, + ) -> None: + super().__init__( + headers=headers, + status=status, + version=version, + reason=reason, + decode_content=decode_content, + request_url=request_url, + retries=retries, + ) + + self.enforce_content_length = enforce_content_length + self.auto_close = auto_close + + self._body = None + self._fp: _HttplibHTTPResponse | None = None + self._original_response = original_response + self._fp_bytes_read = 0 + self.msg = msg + + if body and isinstance(body, (str, bytes)): + self._body = body + + self._pool = pool + self._connection = connection + + if hasattr(body, "read"): + self._fp = body # type: ignore[assignment] + + # Are we using the chunked-style of transfer encoding? + self.chunk_left: int | None = None + + # Determine length of response + self.length_remaining = self._init_length(request_method) + + # Used to return the correct amount of bytes for partial read()s + self._decoded_buffer = BytesQueueBuffer() + + # If requested, preload the body. + if preload_content and not self._body: + self._body = self.read(decode_content=decode_content) + + def release_conn(self) -> None: + if not self._pool or not self._connection: + return None + + self._pool._put_conn(self._connection) + self._connection = None + + def drain_conn(self) -> None: + """ + Read and discard any remaining HTTP response data in the response connection. + + Unread data in the HTTPResponse connection blocks the connection from being released back to the pool. + """ + try: + self.read() + except (HTTPError, OSError, BaseSSLError, HTTPException): + pass + + @property + def data(self) -> bytes: + # For backwards-compat with earlier urllib3 0.4 and earlier. + if self._body: + return self._body # type: ignore[return-value] + + if self._fp: + return self.read(cache_content=True) + + return None # type: ignore[return-value] + + @property + def connection(self) -> HTTPConnection | None: + return self._connection + + def isclosed(self) -> bool: + return is_fp_closed(self._fp) + + def tell(self) -> int: + """ + Obtain the number of bytes pulled over the wire so far. May differ from + the amount of content returned by :meth:``urllib3.response.HTTPResponse.read`` + if bytes are encoded on the wire (e.g, compressed). + """ + return self._fp_bytes_read + + def _init_length(self, request_method: str | None) -> int | None: + """ + Set initial length value for Response content if available. + """ + length: int | None + content_length: str | None = self.headers.get("content-length") + + if content_length is not None: + if self.chunked: + # This Response will fail with an IncompleteRead if it can't be + # received as chunked. This method falls back to attempt reading + # the response before raising an exception. + log.warning( + "Received response with both Content-Length and " + "Transfer-Encoding set. This is expressly forbidden " + "by RFC 7230 sec 3.3.2. Ignoring Content-Length and " + "attempting to process response as Transfer-Encoding: " + "chunked." + ) + return None + + try: + # RFC 7230 section 3.3.2 specifies multiple content lengths can + # be sent in a single Content-Length header + # (e.g. Content-Length: 42, 42). This line ensures the values + # are all valid ints and that as long as the `set` length is 1, + # all values are the same. Otherwise, the header is invalid. + lengths = {int(val) for val in content_length.split(",")} + if len(lengths) > 1: + raise InvalidHeader( + "Content-Length contained multiple " + "unmatching values (%s)" % content_length + ) + length = lengths.pop() + except ValueError: + length = None + else: + if length < 0: + length = None + + else: # if content_length is None + length = None + + # Convert status to int for comparison + # In some cases, httplib returns a status of "_UNKNOWN" + try: + status = int(self.status) + except ValueError: + status = 0 + + # Check for responses that shouldn't include a body + if status in (204, 304) or 100 <= status < 200 or request_method == "HEAD": + length = 0 + + return length + + @contextmanager + def _error_catcher(self) -> typing.Generator[None, None, None]: + """ + Catch low-level python exceptions, instead re-raising urllib3 + variants, so that low-level exceptions are not leaked in the + high-level api. + + On exit, release the connection back to the pool. + """ + clean_exit = False + + try: + try: + yield + + except SocketTimeout as e: + # FIXME: Ideally we'd like to include the url in the ReadTimeoutError but + # there is yet no clean way to get at it from this context. + raise ReadTimeoutError(self._pool, None, "Read timed out.") from e # type: ignore[arg-type] + + except BaseSSLError as e: + # FIXME: Is there a better way to differentiate between SSLErrors? + if "read operation timed out" not in str(e): + # SSL errors related to framing/MAC get wrapped and reraised here + raise SSLError(e) from e + + raise ReadTimeoutError(self._pool, None, "Read timed out.") from e # type: ignore[arg-type] + + except (HTTPException, OSError) as e: + # This includes IncompleteRead. + raise ProtocolError(f"Connection broken: {e!r}", e) from e + + # If no exception is thrown, we should avoid cleaning up + # unnecessarily. + clean_exit = True + finally: + # If we didn't terminate cleanly, we need to throw away our + # connection. + if not clean_exit: + # The response may not be closed but we're not going to use it + # anymore so close it now to ensure that the connection is + # released back to the pool. + if self._original_response: + self._original_response.close() + + # Closing the response may not actually be sufficient to close + # everything, so if we have a hold of the connection close that + # too. + if self._connection: + self._connection.close() + + # If we hold the original response but it's closed now, we should + # return the connection back to the pool. + if self._original_response and self._original_response.isclosed(): + self.release_conn() + + def _fp_read(self, amt: int | None = None) -> bytes: + """ + Read a response with the thought that reading the number of bytes + larger than can fit in a 32-bit int at a time via SSL in some + known cases leads to an overflow error that has to be prevented + if `amt` or `self.length_remaining` indicate that a problem may + happen. + + The known cases: + * 3.8 <= CPython < 3.9.7 because of a bug + https://github.com/urllib3/urllib3/issues/2513#issuecomment-1152559900. + * urllib3 injected with pyOpenSSL-backed SSL-support. + * CPython < 3.10 only when `amt` does not fit 32-bit int. + """ + assert self._fp + c_int_max = 2**31 - 1 + if ( + (amt and amt > c_int_max) + or (self.length_remaining and self.length_remaining > c_int_max) + ) and (util.IS_PYOPENSSL or sys.version_info < (3, 10)): + buffer = io.BytesIO() + # Besides `max_chunk_amt` being a maximum chunk size, it + # affects memory overhead of reading a response by this + # method in CPython. + # `c_int_max` equal to 2 GiB - 1 byte is the actual maximum + # chunk size that does not lead to an overflow error, but + # 256 MiB is a compromise. + max_chunk_amt = 2**28 + while amt is None or amt != 0: + if amt is not None: + chunk_amt = min(amt, max_chunk_amt) + amt -= chunk_amt + else: + chunk_amt = max_chunk_amt + data = self._fp.read(chunk_amt) + if not data: + break + buffer.write(data) + del data # to reduce peak memory usage by `max_chunk_amt`. + return buffer.getvalue() + else: + # StringIO doesn't like amt=None + return self._fp.read(amt) if amt is not None else self._fp.read() + + def _raw_read( + self, + amt: int | None = None, + ) -> bytes: + """ + Reads `amt` of bytes from the socket. + """ + if self._fp is None: + return None # type: ignore[return-value] + + fp_closed = getattr(self._fp, "closed", False) + + with self._error_catcher(): + data = self._fp_read(amt) if not fp_closed else b"" + if amt is not None and amt != 0 and not data: + # Platform-specific: Buggy versions of Python. + # Close the connection when no data is returned + # + # This is redundant to what httplib/http.client _should_ + # already do. However, versions of python released before + # December 15, 2012 (http://bugs.python.org/issue16298) do + # not properly close the connection in all cases. There is + # no harm in redundantly calling close. + self._fp.close() + if ( + self.enforce_content_length + and self.length_remaining is not None + and self.length_remaining != 0 + ): + # This is an edge case that httplib failed to cover due + # to concerns of backward compatibility. We're + # addressing it here to make sure IncompleteRead is + # raised during streaming, so all calls with incorrect + # Content-Length are caught. + raise IncompleteRead(self._fp_bytes_read, self.length_remaining) + + if data: + self._fp_bytes_read += len(data) + if self.length_remaining is not None: + self.length_remaining -= len(data) + return data + + def read( + self, + amt: int | None = None, + decode_content: bool | None = None, + cache_content: bool = False, + ) -> bytes: + """ + Similar to :meth:`http.client.HTTPResponse.read`, but with two additional + parameters: ``decode_content`` and ``cache_content``. + + :param amt: + How much of the content to read. If specified, caching is skipped + because it doesn't make sense to cache partial content as the full + response. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + + :param cache_content: + If True, will save the returned data such that the same result is + returned despite of the state of the underlying file object. This + is useful if you want the ``.data`` property to continue working + after having ``.read()`` the file object. (Overridden if ``amt`` is + set.) + """ + self._init_decoder() + if decode_content is None: + decode_content = self.decode_content + + if amt is not None: + cache_content = False + + if len(self._decoded_buffer) >= amt: + return self._decoded_buffer.get(amt) + + data = self._raw_read(amt) + + flush_decoder = amt is None or (amt != 0 and not data) + + if not data and len(self._decoded_buffer) == 0: + return data + + if amt is None: + data = self._decode(data, decode_content, flush_decoder) + if cache_content: + self._body = data + else: + # do not waste memory on buffer when not decoding + if not decode_content: + if self._has_decoded_content: + raise RuntimeError( + "Calling read(decode_content=False) is not supported after " + "read(decode_content=True) was called." + ) + return data + + decoded_data = self._decode(data, decode_content, flush_decoder) + self._decoded_buffer.put(decoded_data) + + while len(self._decoded_buffer) < amt and data: + # TODO make sure to initially read enough data to get past the headers + # For example, the GZ file header takes 10 bytes, we don't want to read + # it one byte at a time + data = self._raw_read(amt) + decoded_data = self._decode(data, decode_content, flush_decoder) + self._decoded_buffer.put(decoded_data) + data = self._decoded_buffer.get(amt) + + return data + + def stream( + self, amt: int | None = 2**16, decode_content: bool | None = None + ) -> typing.Generator[bytes, None, None]: + """ + A generator wrapper for the read() method. A call will block until + ``amt`` bytes have been read from the connection or until the + connection is closed. + + :param amt: + How much of the content to read. The generator will return up to + much data per iteration, but may return less. This is particularly + likely when using compressed data. However, the empty string will + never be returned. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + """ + if self.chunked and self.supports_chunked_reads(): + yield from self.read_chunked(amt, decode_content=decode_content) + else: + while not is_fp_closed(self._fp) or len(self._decoded_buffer) > 0: + data = self.read(amt=amt, decode_content=decode_content) + + if data: + yield data + + # Overrides from io.IOBase + def readable(self) -> bool: + return True + + def close(self) -> None: + if not self.closed and self._fp: + self._fp.close() + + if self._connection: + self._connection.close() + + if not self.auto_close: + io.IOBase.close(self) + + @property + def closed(self) -> bool: + if not self.auto_close: + return io.IOBase.closed.__get__(self) # type: ignore[no-any-return] + elif self._fp is None: + return True + elif hasattr(self._fp, "isclosed"): + return self._fp.isclosed() + elif hasattr(self._fp, "closed"): + return self._fp.closed + else: + return True + + def fileno(self) -> int: + if self._fp is None: + raise OSError("HTTPResponse has no file to get a fileno from") + elif hasattr(self._fp, "fileno"): + return self._fp.fileno() + else: + raise OSError( + "The file-like object this HTTPResponse is wrapped " + "around has no file descriptor" + ) + + def flush(self) -> None: + if ( + self._fp is not None + and hasattr(self._fp, "flush") + and not getattr(self._fp, "closed", False) + ): + return self._fp.flush() + + def supports_chunked_reads(self) -> bool: + """ + Checks if the underlying file-like object looks like a + :class:`http.client.HTTPResponse` object. We do this by testing for + the fp attribute. If it is present we assume it returns raw chunks as + processed by read_chunked(). + """ + return hasattr(self._fp, "fp") + + def _update_chunk_length(self) -> None: + # First, we'll figure out length of a chunk and then + # we'll try to read it from socket. + if self.chunk_left is not None: + return None + line = self._fp.fp.readline() # type: ignore[union-attr] + line = line.split(b";", 1)[0] + try: + self.chunk_left = int(line, 16) + except ValueError: + # Invalid chunked protocol response, abort. + self.close() + raise InvalidChunkLength(self, line) from None + + def _handle_chunk(self, amt: int | None) -> bytes: + returned_chunk = None + if amt is None: + chunk = self._fp._safe_read(self.chunk_left) # type: ignore[union-attr] + returned_chunk = chunk + self._fp._safe_read(2) # type: ignore[union-attr] # Toss the CRLF at the end of the chunk. + self.chunk_left = None + elif self.chunk_left is not None and amt < self.chunk_left: + value = self._fp._safe_read(amt) # type: ignore[union-attr] + self.chunk_left = self.chunk_left - amt + returned_chunk = value + elif amt == self.chunk_left: + value = self._fp._safe_read(amt) # type: ignore[union-attr] + self._fp._safe_read(2) # type: ignore[union-attr] # Toss the CRLF at the end of the chunk. + self.chunk_left = None + returned_chunk = value + else: # amt > self.chunk_left + returned_chunk = self._fp._safe_read(self.chunk_left) # type: ignore[union-attr] + self._fp._safe_read(2) # type: ignore[union-attr] # Toss the CRLF at the end of the chunk. + self.chunk_left = None + return returned_chunk # type: ignore[no-any-return] + + def read_chunked( + self, amt: int | None = None, decode_content: bool | None = None + ) -> typing.Generator[bytes, None, None]: + """ + Similar to :meth:`HTTPResponse.read`, but with an additional + parameter: ``decode_content``. + + :param amt: + How much of the content to read. If specified, caching is skipped + because it doesn't make sense to cache partial content as the full + response. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + """ + self._init_decoder() + # FIXME: Rewrite this method and make it a class with a better structured logic. + if not self.chunked: + raise ResponseNotChunked( + "Response is not chunked. " + "Header 'transfer-encoding: chunked' is missing." + ) + if not self.supports_chunked_reads(): + raise BodyNotHttplibCompatible( + "Body should be http.client.HTTPResponse like. " + "It should have have an fp attribute which returns raw chunks." + ) + + with self._error_catcher(): + # Don't bother reading the body of a HEAD request. + if self._original_response and is_response_to_head(self._original_response): + self._original_response.close() + return None + + # If a response is already read and closed + # then return immediately. + if self._fp.fp is None: # type: ignore[union-attr] + return None + + while True: + self._update_chunk_length() + if self.chunk_left == 0: + break + chunk = self._handle_chunk(amt) + decoded = self._decode( + chunk, decode_content=decode_content, flush_decoder=False + ) + if decoded: + yield decoded + + if decode_content: + # On CPython and PyPy, we should never need to flush the + # decoder. However, on Jython we *might* need to, so + # lets defensively do it anyway. + decoded = self._flush_decoder() + if decoded: # Platform-specific: Jython. + yield decoded + + # Chunk content ends with \r\n: discard it. + while self._fp is not None: + line = self._fp.fp.readline() + if not line: + # Some sites may not end with '\r\n'. + break + if line == b"\r\n": + break + + # We read everything; close the "file". + if self._original_response: + self._original_response.close() + + @property + def url(self) -> str | None: + """ + Returns the URL that was the source of this response. + If the request that generated this response redirected, this method + will return the final redirect location. + """ + return self._request_url + + @url.setter + def url(self, url: str) -> None: + self._request_url = url + + def __iter__(self) -> typing.Iterator[bytes]: + buffer: list[bytes] = [] + for chunk in self.stream(decode_content=True): + if b"\n" in chunk: + chunks = chunk.split(b"\n") + yield b"".join(buffer) + chunks[0] + b"\n" + for x in chunks[1:-1]: + yield x + b"\n" + if chunks[-1]: + buffer = [chunks[-1]] + else: + buffer = [] + else: + buffer.append(chunk) + if buffer: + yield b"".join(buffer) diff --git a/Modules/urllib3/util/__init__.py b/Modules/urllib3/util/__init__.py new file mode 100644 index 0000000..5341260 --- /dev/null +++ b/Modules/urllib3/util/__init__.py @@ -0,0 +1,42 @@ +# For backwards compatibility, provide imports that used to be here. +from __future__ import annotations + +from .connection import is_connection_dropped +from .request import SKIP_HEADER, SKIPPABLE_HEADERS, make_headers +from .response import is_fp_closed +from .retry import Retry +from .ssl_ import ( + ALPN_PROTOCOLS, + IS_PYOPENSSL, + SSLContext, + assert_fingerprint, + create_urllib3_context, + resolve_cert_reqs, + resolve_ssl_version, + ssl_wrap_socket, +) +from .timeout import Timeout +from .url import Url, parse_url +from .wait import wait_for_read, wait_for_write + +__all__ = ( + "IS_PYOPENSSL", + "SSLContext", + "ALPN_PROTOCOLS", + "Retry", + "Timeout", + "Url", + "assert_fingerprint", + "create_urllib3_context", + "is_connection_dropped", + "is_fp_closed", + "parse_url", + "make_headers", + "resolve_cert_reqs", + "resolve_ssl_version", + "ssl_wrap_socket", + "wait_for_read", + "wait_for_write", + "SKIP_HEADER", + "SKIPPABLE_HEADERS", +) diff --git a/Modules/urllib3/util/__pycache__/__init__.cpython-311.pyc b/Modules/urllib3/util/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1f13a32a899ea2b449e1aafffa69b5f4a1cc488c GIT binary patch literal 1201 zcmcJNzi-n(6vxkT5+`wfG(VcQv;_&o;DLHzVL(WsM4}>UqNEJmax(FywR&f}cjuOF z{1@yji2o*IbWo44FaeE4FmWY-y|7oLNoQVBujHJNAoaGEoh~=94XKuET(>*l&B5u)VD~P zR$zrzVU^Zkjjq8pT8DMofDPJ&P1=I3^t}REr)}6y{UX_*n{bnE!L2kdkw0A@mQyk&!RZSzGF&z^xh5aZL_=}JYk8{ifngro7W-$vwA=_hyJ%Lfe2njyF)LPSb z>kRXVoMSZB6%3zo*}PA2PSCkhr3R8U9b7OkMm!pyVxg2-M*+oABAkpgKQbbVvB!A& z1(m5>c!5$7G1b%aW%W;Z!2*GuCM&DGv5JPRp|1&RYP2+}8a0iaMp0v3qoA>-QP*f_ zv^6#~@*0-Hq4QXl5Sk<+VHhE%?jDe(=ly_2PQX(8khg3wQJqy7fBuiTS}V%Nvx zQ+H2Ep9IG)zvKc_-%XS@_wFp+L(^Z>+&h+0lTP;`JW?*x=YV%Cd$jrh2MGF|aQ?T>5&A^lCLpB5M^dXyP OTXyEFrGM<1+S6~=c13*v literal 0 HcmV?d00001 diff --git a/Modules/urllib3/util/__pycache__/connection.cpython-311.pyc b/Modules/urllib3/util/__pycache__/connection.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..820c9b658baa690cdfc39aa9761c5a1dbfa9f521 GIT binary patch literal 5053 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 literal 0 HcmV?d00001 diff --git a/Modules/urllib3/util/__pycache__/retry.cpython-311.pyc b/Modules/urllib3/util/__pycache__/retry.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6daca3c579bc4ac583e494752ac8bc99e81e42c3 GIT binary patch literal 21043 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%0A7E`mPPR+eVPZ9yyXgcZ`A;zsLi^Y#l+`C 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 literal 0 HcmV?d00001 diff --git a/Modules/urllib3/util/__pycache__/ssltransport.cpython-311.pyc b/Modules/urllib3/util/__pycache__/ssltransport.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc4375a53ef0609808c86dfbbc60cc92ea926a46 GIT binary patch literal 14605 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 literal 0 HcmV?d00001 diff --git a/Modules/urllib3/util/__pycache__/timeout.cpython-311.pyc b/Modules/urllib3/util/__pycache__/timeout.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3ccbb6b03ddcc02e20cb993d2b7268edf64da0a8 GIT binary patch literal 12218 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 O`GD1b`IuJ5)&Bz?1>rXU literal 0 HcmV?d00001 diff --git a/Modules/urllib3/util/__pycache__/url.cpython-311.pyc b/Modules/urllib3/util/__pycache__/url.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1297ca348d0181b43bbdb8ad61512c255208ebfc GIT binary patch literal 17754 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 literal 0 HcmV?d00001 diff --git a/Modules/urllib3/util/__pycache__/util.cpython-311.pyc b/Modules/urllib3/util/__pycache__/util.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a011f7563f384c781c29db2f146de1ac661e2254 GIT binary patch literal 2149 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 JyqRzr{TClRD-i$y literal 0 HcmV?d00001 diff --git a/Modules/urllib3/util/connection.py b/Modules/urllib3/util/connection.py new file mode 100644 index 0000000..5c7da73 --- /dev/null +++ b/Modules/urllib3/util/connection.py @@ -0,0 +1,137 @@ +from __future__ import annotations + +import socket +import typing + +from ..exceptions import LocationParseError +from .timeout import _DEFAULT_TIMEOUT, _TYPE_TIMEOUT + +_TYPE_SOCKET_OPTIONS = typing.Sequence[typing.Tuple[int, int, typing.Union[int, bytes]]] + +if typing.TYPE_CHECKING: + from .._base_connection import BaseHTTPConnection + + +def is_connection_dropped(conn: BaseHTTPConnection) -> bool: # Platform-specific + """ + Returns True if the connection is dropped and should be closed. + :param conn: :class:`urllib3.connection.HTTPConnection` object. + """ + return not conn.is_connected + + +# This function is copied from socket.py in the Python 2.7 standard +# library test suite. Added to its signature is only `socket_options`. +# One additional modification is that we avoid binding to IPv6 servers +# discovered in DNS if the system doesn't have IPv6 functionality. +def create_connection( + address: tuple[str, int], + timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, + source_address: tuple[str, int] | None = None, + socket_options: _TYPE_SOCKET_OPTIONS | None = None, +) -> socket.socket: + """Connect to *address* and return the socket object. + + Convenience function. Connect to *address* (a 2-tuple ``(host, + port)``) and return the socket object. Passing the optional + *timeout* parameter will set the timeout on the socket instance + before attempting to connect. If no *timeout* is supplied, the + global default timeout setting returned by :func:`socket.getdefaulttimeout` + is used. If *source_address* is set it must be a tuple of (host, port) + for the socket to bind as a source address before making the connection. + An host of '' or port 0 tells the OS to use the default. + """ + + host, port = address + if host.startswith("["): + host = host.strip("[]") + err = None + + # Using the value from allowed_gai_family() in the context of getaddrinfo lets + # us select whether to work with IPv4 DNS records, IPv6 records, or both. + # The original create_connection function always returns all records. + family = allowed_gai_family() + + try: + host.encode("idna") + except UnicodeError: + raise LocationParseError(f"'{host}', label empty or too long") from None + + for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM): + af, socktype, proto, canonname, sa = res + sock = None + try: + sock = socket.socket(af, socktype, proto) + + # If provided, set socket level options before connecting. + _set_socket_options(sock, socket_options) + + if timeout is not _DEFAULT_TIMEOUT: + sock.settimeout(timeout) + if source_address: + sock.bind(source_address) + sock.connect(sa) + # Break explicitly a reference cycle + err = None + return sock + + except OSError as _: + err = _ + if sock is not None: + sock.close() + + if err is not None: + try: + raise err + finally: + # Break explicitly a reference cycle + err = None + else: + raise OSError("getaddrinfo returns an empty list") + + +def _set_socket_options( + sock: socket.socket, options: _TYPE_SOCKET_OPTIONS | None +) -> None: + if options is None: + return + + for opt in options: + sock.setsockopt(*opt) + + +def allowed_gai_family() -> socket.AddressFamily: + """This function is designed to work in the context of + getaddrinfo, where family=socket.AF_UNSPEC is the default and + will perform a DNS search for both IPv6 and IPv4 records.""" + + family = socket.AF_INET + if HAS_IPV6: + family = socket.AF_UNSPEC + return family + + +def _has_ipv6(host: str) -> bool: + """Returns True if the system can bind an IPv6 address.""" + sock = None + has_ipv6 = False + + if socket.has_ipv6: + # has_ipv6 returns true if cPython was compiled with IPv6 support. + # It does not tell us if the system has IPv6 support enabled. To + # determine that we must bind to an IPv6 address. + # https://github.com/urllib3/urllib3/pull/611 + # https://bugs.python.org/issue658327 + try: + sock = socket.socket(socket.AF_INET6) + sock.bind((host, 0)) + has_ipv6 = True + except Exception: + pass + + if sock: + sock.close() + return has_ipv6 + + +HAS_IPV6 = _has_ipv6("::1") diff --git a/Modules/urllib3/util/proxy.py b/Modules/urllib3/util/proxy.py new file mode 100644 index 0000000..908fc66 --- /dev/null +++ b/Modules/urllib3/util/proxy.py @@ -0,0 +1,43 @@ +from __future__ import annotations + +import typing + +from .url import Url + +if typing.TYPE_CHECKING: + from ..connection import ProxyConfig + + +def connection_requires_http_tunnel( + proxy_url: Url | None = None, + proxy_config: ProxyConfig | None = None, + destination_scheme: str | None = None, +) -> bool: + """ + Returns True if the connection requires an HTTP CONNECT through the proxy. + + :param URL proxy_url: + URL of the proxy. + :param ProxyConfig proxy_config: + Proxy configuration from poolmanager.py + :param str destination_scheme: + The scheme of the destination. (i.e https, http, etc) + """ + # If we're not using a proxy, no way to use a tunnel. + if proxy_url is None: + return False + + # HTTP destinations never require tunneling, we always forward. + if destination_scheme == "http": + return False + + # Support for forwarding with HTTPS proxies and HTTPS destinations. + if ( + proxy_url.scheme == "https" + and proxy_config + and proxy_config.use_forwarding_for_https + ): + return False + + # Otherwise always use a tunnel. + return True diff --git a/Modules/urllib3/util/request.py b/Modules/urllib3/util/request.py new file mode 100644 index 0000000..e6905ff --- /dev/null +++ b/Modules/urllib3/util/request.py @@ -0,0 +1,256 @@ +from __future__ import annotations + +import io +import typing +from base64 import b64encode +from enum import Enum + +from ..exceptions import UnrewindableBodyError +from .util import to_bytes + +if typing.TYPE_CHECKING: + from typing import Final + +# Pass as a value within ``headers`` to skip +# emitting some HTTP headers that are added automatically. +# The only headers that are supported are ``Accept-Encoding``, +# ``Host``, and ``User-Agent``. +SKIP_HEADER = "@@@SKIP_HEADER@@@" +SKIPPABLE_HEADERS = frozenset(["accept-encoding", "host", "user-agent"]) + +ACCEPT_ENCODING = "gzip,deflate" +try: + try: + import brotlicffi as _unused_module_brotli # type: ignore[import] # noqa: F401 + except ImportError: + import brotli as _unused_module_brotli # type: ignore[import] # noqa: F401 +except ImportError: + pass +else: + ACCEPT_ENCODING += ",br" +try: + import zstandard as _unused_module_zstd # type: ignore[import] # noqa: F401 +except ImportError: + pass +else: + ACCEPT_ENCODING += ",zstd" + + +class _TYPE_FAILEDTELL(Enum): + token = 0 + + +_FAILEDTELL: Final[_TYPE_FAILEDTELL] = _TYPE_FAILEDTELL.token + +_TYPE_BODY_POSITION = typing.Union[int, _TYPE_FAILEDTELL] + +# When sending a request with these methods we aren't expecting +# a body so don't need to set an explicit 'Content-Length: 0' +# The reason we do this in the negative instead of tracking methods +# which 'should' have a body is because unknown methods should be +# treated as if they were 'POST' which *does* expect a body. +_METHODS_NOT_EXPECTING_BODY = {"GET", "HEAD", "DELETE", "TRACE", "OPTIONS", "CONNECT"} + + +def make_headers( + keep_alive: bool | None = None, + accept_encoding: bool | list[str] | str | None = None, + user_agent: str | None = None, + basic_auth: str | None = None, + proxy_basic_auth: str | None = None, + disable_cache: bool | None = None, +) -> dict[str, str]: + """ + Shortcuts for generating request headers. + + :param keep_alive: + If ``True``, adds 'connection: keep-alive' header. + + :param accept_encoding: + Can be a boolean, list, or string. + ``True`` translates to 'gzip,deflate'. If either the ``brotli`` or + ``brotlicffi`` package is installed 'gzip,deflate,br' is used instead. + List will get joined by comma. + String will be used as provided. + + :param user_agent: + String representing the user-agent you want, such as + "python-urllib3/0.6" + + :param basic_auth: + Colon-separated username:password string for 'authorization: basic ...' + auth header. + + :param proxy_basic_auth: + Colon-separated username:password string for 'proxy-authorization: basic ...' + auth header. + + :param disable_cache: + If ``True``, adds 'cache-control: no-cache' header. + + Example: + + .. code-block:: python + + import urllib3 + + print(urllib3.util.make_headers(keep_alive=True, user_agent="Batman/1.0")) + # {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'} + print(urllib3.util.make_headers(accept_encoding=True)) + # {'accept-encoding': 'gzip,deflate'} + """ + headers: dict[str, str] = {} + if accept_encoding: + if isinstance(accept_encoding, str): + pass + elif isinstance(accept_encoding, list): + accept_encoding = ",".join(accept_encoding) + else: + accept_encoding = ACCEPT_ENCODING + headers["accept-encoding"] = accept_encoding + + if user_agent: + headers["user-agent"] = user_agent + + if keep_alive: + headers["connection"] = "keep-alive" + + if basic_auth: + headers[ + "authorization" + ] = f"Basic {b64encode(basic_auth.encode('latin-1')).decode()}" + + if proxy_basic_auth: + headers[ + "proxy-authorization" + ] = f"Basic {b64encode(proxy_basic_auth.encode('latin-1')).decode()}" + + if disable_cache: + headers["cache-control"] = "no-cache" + + return headers + + +def set_file_position( + body: typing.Any, pos: _TYPE_BODY_POSITION | None +) -> _TYPE_BODY_POSITION | None: + """ + If a position is provided, move file to that point. + Otherwise, we'll attempt to record a position for future use. + """ + if pos is not None: + rewind_body(body, pos) + elif getattr(body, "tell", None) is not None: + try: + pos = body.tell() + except OSError: + # This differentiates from None, allowing us to catch + # a failed `tell()` later when trying to rewind the body. + pos = _FAILEDTELL + + return pos + + +def rewind_body(body: typing.IO[typing.AnyStr], body_pos: _TYPE_BODY_POSITION) -> None: + """ + Attempt to rewind body to a certain position. + Primarily used for request redirects and retries. + + :param body: + File-like object that supports seek. + + :param int pos: + Position to seek to in file. + """ + body_seek = getattr(body, "seek", None) + if body_seek is not None and isinstance(body_pos, int): + try: + body_seek(body_pos) + except OSError as e: + raise UnrewindableBodyError( + "An error occurred when rewinding request body for redirect/retry." + ) from e + elif body_pos is _FAILEDTELL: + raise UnrewindableBodyError( + "Unable to record file position for rewinding " + "request body during a redirect/retry." + ) + else: + raise ValueError( + f"body_pos must be of type integer, instead it was {type(body_pos)}." + ) + + +class ChunksAndContentLength(typing.NamedTuple): + chunks: typing.Iterable[bytes] | None + content_length: int | None + + +def body_to_chunks( + body: typing.Any | None, method: str, blocksize: int +) -> ChunksAndContentLength: + """Takes the HTTP request method, body, and blocksize and + transforms them into an iterable of chunks to pass to + socket.sendall() and an optional 'Content-Length' header. + + A 'Content-Length' of 'None' indicates the length of the body + can't be determined so should use 'Transfer-Encoding: chunked' + for framing instead. + """ + + chunks: typing.Iterable[bytes] | None + content_length: int | None + + # No body, we need to make a recommendation on 'Content-Length' + # based on whether that request method is expected to have + # a body or not. + if body is None: + chunks = None + if method.upper() not in _METHODS_NOT_EXPECTING_BODY: + content_length = 0 + else: + content_length = None + + # Bytes or strings become bytes + elif isinstance(body, (str, bytes)): + chunks = (to_bytes(body),) + content_length = len(chunks[0]) + + # File-like object, TODO: use seek() and tell() for length? + elif hasattr(body, "read"): + + def chunk_readable() -> typing.Iterable[bytes]: + nonlocal body, blocksize + encode = isinstance(body, io.TextIOBase) + while True: + datablock = body.read(blocksize) + if not datablock: + break + if encode: + datablock = datablock.encode("iso-8859-1") + yield datablock + + chunks = chunk_readable() + content_length = None + + # Otherwise we need to start checking via duck-typing. + else: + try: + # Check if the body implements the buffer API. + mv = memoryview(body) + except TypeError: + try: + # Check if the body is an iterable + chunks = iter(body) + content_length = None + except TypeError: + raise TypeError( + f"'body' must be a bytes-like object, file-like " + f"object, or iterable. Instead was {body!r}" + ) from None + else: + # Since it implements the buffer API can be passed directly to socket.sendall() + chunks = (body,) + content_length = mv.nbytes + + return ChunksAndContentLength(chunks=chunks, content_length=content_length) diff --git a/Modules/urllib3/util/response.py b/Modules/urllib3/util/response.py new file mode 100644 index 0000000..0f45786 --- /dev/null +++ b/Modules/urllib3/util/response.py @@ -0,0 +1,101 @@ +from __future__ import annotations + +import http.client as httplib +from email.errors import MultipartInvariantViolationDefect, StartBoundaryNotFoundDefect + +from ..exceptions import HeaderParsingError + + +def is_fp_closed(obj: object) -> bool: + """ + Checks whether a given file-like object is closed. + + :param obj: + The file-like object to check. + """ + + try: + # Check `isclosed()` first, in case Python3 doesn't set `closed`. + # GH Issue #928 + return obj.isclosed() # type: ignore[no-any-return, attr-defined] + except AttributeError: + pass + + try: + # Check via the official file-like-object way. + return obj.closed # type: ignore[no-any-return, attr-defined] + except AttributeError: + pass + + try: + # Check if the object is a container for another file-like object that + # gets released on exhaustion (e.g. HTTPResponse). + return obj.fp is None # type: ignore[attr-defined] + except AttributeError: + pass + + raise ValueError("Unable to determine whether fp is closed.") + + +def assert_header_parsing(headers: httplib.HTTPMessage) -> None: + """ + Asserts whether all headers have been successfully parsed. + Extracts encountered errors from the result of parsing headers. + + Only works on Python 3. + + :param http.client.HTTPMessage headers: Headers to verify. + + :raises urllib3.exceptions.HeaderParsingError: + If parsing errors are found. + """ + + # This will fail silently if we pass in the wrong kind of parameter. + # To make debugging easier add an explicit check. + if not isinstance(headers, httplib.HTTPMessage): + raise TypeError(f"expected httplib.Message, got {type(headers)}.") + + unparsed_data = None + + # get_payload is actually email.message.Message.get_payload; + # we're only interested in the result if it's not a multipart message + if not headers.is_multipart(): + payload = headers.get_payload() + + if isinstance(payload, (bytes, str)): + unparsed_data = payload + + # httplib is assuming a response body is available + # when parsing headers even when httplib only sends + # header data to parse_headers() This results in + # defects on multipart responses in particular. + # See: https://github.com/urllib3/urllib3/issues/800 + + # So we ignore the following defects: + # - StartBoundaryNotFoundDefect: + # The claimed start boundary was never found. + # - MultipartInvariantViolationDefect: + # A message claimed to be a multipart but no subparts were found. + defects = [ + defect + for defect in headers.defects + if not isinstance( + defect, (StartBoundaryNotFoundDefect, MultipartInvariantViolationDefect) + ) + ] + + if defects or unparsed_data: + raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data) + + +def is_response_to_head(response: httplib.HTTPResponse) -> bool: + """ + Checks whether the request of a response has been a HEAD-request. + + :param http.client.HTTPResponse response: + Response to check if the originating request + used 'HEAD' as a method. + """ + # FIXME: Can we do this somehow without accessing private httplib _method? + method_str = response._method # type: str # type: ignore[attr-defined] + return method_str.upper() == "HEAD" diff --git a/Modules/urllib3/util/retry.py b/Modules/urllib3/util/retry.py new file mode 100644 index 0000000..7572bfd --- /dev/null +++ b/Modules/urllib3/util/retry.py @@ -0,0 +1,529 @@ +from __future__ import annotations + +import email +import logging +import random +import re +import time +import typing +from itertools import takewhile +from types import TracebackType + +from ..exceptions import ( + ConnectTimeoutError, + InvalidHeader, + MaxRetryError, + ProtocolError, + ProxyError, + ReadTimeoutError, + ResponseError, +) +from .util import reraise + +if typing.TYPE_CHECKING: + from ..connectionpool import ConnectionPool + from ..response import BaseHTTPResponse + +log = logging.getLogger(__name__) + + +# Data structure for representing the metadata of requests that result in a retry. +class RequestHistory(typing.NamedTuple): + method: str | None + url: str | None + error: Exception | None + status: int | None + redirect_location: str | None + + +class Retry: + """Retry configuration. + + Each retry attempt will create a new Retry object with updated values, so + they can be safely reused. + + Retries can be defined as a default for a pool: + + .. code-block:: python + + retries = Retry(connect=5, read=2, redirect=5) + http = PoolManager(retries=retries) + response = http.request("GET", "https://example.com/") + + Or per-request (which overrides the default for the pool): + + .. code-block:: python + + response = http.request("GET", "https://example.com/", retries=Retry(10)) + + Retries can be disabled by passing ``False``: + + .. code-block:: python + + response = http.request("GET", "https://example.com/", retries=False) + + Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless + retries are disabled, in which case the causing exception will be raised. + + :param int total: + Total number of retries to allow. Takes precedence over other counts. + + Set to ``None`` to remove this constraint and fall back on other + counts. + + Set to ``0`` to fail on the first retry. + + Set to ``False`` to disable and imply ``raise_on_redirect=False``. + + :param int connect: + How many connection-related errors to retry on. + + These are errors raised before the request is sent to the remote server, + which we assume has not triggered the server to process the request. + + Set to ``0`` to fail on the first retry of this type. + + :param int read: + How many times to retry on read errors. + + These errors are raised after the request was sent to the server, so the + request may have side-effects. + + Set to ``0`` to fail on the first retry of this type. + + :param int redirect: + How many redirects to perform. Limit this to avoid infinite redirect + loops. + + A redirect is a HTTP response with a status code 301, 302, 303, 307 or + 308. + + Set to ``0`` to fail on the first retry of this type. + + Set to ``False`` to disable and imply ``raise_on_redirect=False``. + + :param int status: + How many times to retry on bad status codes. + + These are retries made on responses, where status code matches + ``status_forcelist``. + + Set to ``0`` to fail on the first retry of this type. + + :param int other: + How many times to retry on other errors. + + Other errors are errors that are not connect, read, redirect or status errors. + These errors might be raised after the request was sent to the server, so the + request might have side-effects. + + Set to ``0`` to fail on the first retry of this type. + + If ``total`` is not set, it's a good idea to set this to 0 to account + for unexpected edge cases and avoid infinite retry loops. + + :param Collection allowed_methods: + Set of uppercased HTTP method verbs that we should retry on. + + By default, we only retry on methods which are considered to be + idempotent (multiple requests with the same parameters end with the + same state). See :attr:`Retry.DEFAULT_ALLOWED_METHODS`. + + Set to a ``None`` value to retry on any verb. + + :param Collection status_forcelist: + A set of integer HTTP status codes that we should force a retry on. + A retry is initiated if the request method is in ``allowed_methods`` + and the response status code is in ``status_forcelist``. + + By default, this is disabled with ``None``. + + :param float backoff_factor: + A backoff factor to apply between attempts after the second try + (most errors are resolved immediately by a second try without a + delay). urllib3 will sleep for:: + + {backoff factor} * (2 ** ({number of previous retries})) + + seconds. If `backoff_jitter` is non-zero, this sleep is extended by:: + + random.uniform(0, {backoff jitter}) + + seconds. For example, if the backoff_factor is 0.1, then :func:`Retry.sleep` will + sleep for [0.0s, 0.2s, 0.4s, 0.8s, ...] between retries. No backoff will ever + be longer than `backoff_max`. + + By default, backoff is disabled (factor set to 0). + + :param bool raise_on_redirect: Whether, if the number of redirects is + exhausted, to raise a MaxRetryError, or to return a response with a + response code in the 3xx range. + + :param bool raise_on_status: Similar meaning to ``raise_on_redirect``: + whether we should raise an exception, or return a response, + if status falls in ``status_forcelist`` range and retries have + been exhausted. + + :param tuple history: The history of the request encountered during + each call to :meth:`~Retry.increment`. The list is in the order + the requests occurred. Each list item is of class :class:`RequestHistory`. + + :param bool respect_retry_after_header: + Whether to respect Retry-After header on status codes defined as + :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not. + + :param Collection remove_headers_on_redirect: + Sequence of headers to remove from the request when a response + indicating a redirect is returned before firing off the redirected + request. + """ + + #: Default methods to be used for ``allowed_methods`` + DEFAULT_ALLOWED_METHODS = frozenset( + ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"] + ) + + #: Default status codes to be used for ``status_forcelist`` + RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503]) + + #: Default headers to be used for ``remove_headers_on_redirect`` + DEFAULT_REMOVE_HEADERS_ON_REDIRECT = frozenset(["Cookie", "Authorization"]) + + #: Default maximum backoff time. + DEFAULT_BACKOFF_MAX = 120 + + # Backward compatibility; assigned outside of the class. + DEFAULT: typing.ClassVar[Retry] + + def __init__( + self, + total: bool | int | None = 10, + connect: int | None = None, + read: int | None = None, + redirect: bool | int | None = None, + status: int | None = None, + other: int | None = None, + allowed_methods: typing.Collection[str] | None = DEFAULT_ALLOWED_METHODS, + status_forcelist: typing.Collection[int] | None = None, + backoff_factor: float = 0, + backoff_max: float = DEFAULT_BACKOFF_MAX, + raise_on_redirect: bool = True, + raise_on_status: bool = True, + history: tuple[RequestHistory, ...] | None = None, + respect_retry_after_header: bool = True, + remove_headers_on_redirect: typing.Collection[ + str + ] = DEFAULT_REMOVE_HEADERS_ON_REDIRECT, + backoff_jitter: float = 0.0, + ) -> None: + self.total = total + self.connect = connect + self.read = read + self.status = status + self.other = other + + if redirect is False or total is False: + redirect = 0 + raise_on_redirect = False + + self.redirect = redirect + self.status_forcelist = status_forcelist or set() + self.allowed_methods = allowed_methods + self.backoff_factor = backoff_factor + self.backoff_max = backoff_max + self.raise_on_redirect = raise_on_redirect + self.raise_on_status = raise_on_status + self.history = history or () + self.respect_retry_after_header = respect_retry_after_header + self.remove_headers_on_redirect = frozenset( + h.lower() for h in remove_headers_on_redirect + ) + self.backoff_jitter = backoff_jitter + + def new(self, **kw: typing.Any) -> Retry: + params = dict( + total=self.total, + connect=self.connect, + read=self.read, + redirect=self.redirect, + status=self.status, + other=self.other, + allowed_methods=self.allowed_methods, + status_forcelist=self.status_forcelist, + backoff_factor=self.backoff_factor, + backoff_max=self.backoff_max, + raise_on_redirect=self.raise_on_redirect, + raise_on_status=self.raise_on_status, + history=self.history, + remove_headers_on_redirect=self.remove_headers_on_redirect, + respect_retry_after_header=self.respect_retry_after_header, + backoff_jitter=self.backoff_jitter, + ) + + params.update(kw) + return type(self)(**params) # type: ignore[arg-type] + + @classmethod + def from_int( + cls, + retries: Retry | bool | int | None, + redirect: bool | int | None = True, + default: Retry | bool | int | None = None, + ) -> Retry: + """Backwards-compatibility for the old retries format.""" + if retries is None: + retries = default if default is not None else cls.DEFAULT + + if isinstance(retries, Retry): + return retries + + redirect = bool(redirect) and None + new_retries = cls(retries, redirect=redirect) + log.debug("Converted retries value: %r -> %r", retries, new_retries) + return new_retries + + def get_backoff_time(self) -> float: + """Formula for computing the current backoff + + :rtype: float + """ + # We want to consider only the last consecutive errors sequence (Ignore redirects). + consecutive_errors_len = len( + list( + takewhile(lambda x: x.redirect_location is None, reversed(self.history)) + ) + ) + if consecutive_errors_len <= 1: + return 0 + + backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1)) + if self.backoff_jitter != 0.0: + backoff_value += random.random() * self.backoff_jitter + return float(max(0, min(self.backoff_max, backoff_value))) + + def parse_retry_after(self, retry_after: str) -> float: + seconds: float + # Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4 + if re.match(r"^\s*[0-9]+\s*$", retry_after): + seconds = int(retry_after) + else: + retry_date_tuple = email.utils.parsedate_tz(retry_after) + if retry_date_tuple is None: + raise InvalidHeader(f"Invalid Retry-After header: {retry_after}") + + retry_date = email.utils.mktime_tz(retry_date_tuple) + seconds = retry_date - time.time() + + seconds = max(seconds, 0) + + return seconds + + def get_retry_after(self, response: BaseHTTPResponse) -> float | None: + """Get the value of Retry-After in seconds.""" + + retry_after = response.headers.get("Retry-After") + + if retry_after is None: + return None + + return self.parse_retry_after(retry_after) + + def sleep_for_retry(self, response: BaseHTTPResponse) -> bool: + retry_after = self.get_retry_after(response) + if retry_after: + time.sleep(retry_after) + return True + + return False + + def _sleep_backoff(self) -> None: + backoff = self.get_backoff_time() + if backoff <= 0: + return + time.sleep(backoff) + + def sleep(self, response: BaseHTTPResponse | None = None) -> None: + """Sleep between retry attempts. + + This method will respect a server's ``Retry-After`` response header + and sleep the duration of the time requested. If that is not present, it + will use an exponential backoff. By default, the backoff factor is 0 and + this method will return immediately. + """ + + if self.respect_retry_after_header and response: + slept = self.sleep_for_retry(response) + if slept: + return + + self._sleep_backoff() + + def _is_connection_error(self, err: Exception) -> bool: + """Errors when we're fairly sure that the server did not receive the + request, so it should be safe to retry. + """ + if isinstance(err, ProxyError): + err = err.original_error + return isinstance(err, ConnectTimeoutError) + + def _is_read_error(self, err: Exception) -> bool: + """Errors that occur after the request has been started, so we should + assume that the server began processing it. + """ + return isinstance(err, (ReadTimeoutError, ProtocolError)) + + def _is_method_retryable(self, method: str) -> bool: + """Checks if a given HTTP method should be retried upon, depending if + it is included in the allowed_methods + """ + if self.allowed_methods and method.upper() not in self.allowed_methods: + return False + return True + + def is_retry( + self, method: str, status_code: int, has_retry_after: bool = False + ) -> bool: + """Is this method/status code retryable? (Based on allowlists and control + variables such as the number of total retries to allow, whether to + respect the Retry-After header, whether this header is present, and + whether the returned status code is on the list of status codes to + be retried upon on the presence of the aforementioned header) + """ + if not self._is_method_retryable(method): + return False + + if self.status_forcelist and status_code in self.status_forcelist: + return True + + return bool( + self.total + and self.respect_retry_after_header + and has_retry_after + and (status_code in self.RETRY_AFTER_STATUS_CODES) + ) + + def is_exhausted(self) -> bool: + """Are we out of retries?""" + retry_counts = [ + x + for x in ( + self.total, + self.connect, + self.read, + self.redirect, + self.status, + self.other, + ) + if x + ] + if not retry_counts: + return False + + return min(retry_counts) < 0 + + def increment( + self, + method: str | None = None, + url: str | None = None, + response: BaseHTTPResponse | None = None, + error: Exception | None = None, + _pool: ConnectionPool | None = None, + _stacktrace: TracebackType | None = None, + ) -> Retry: + """Return a new Retry object with incremented retry counters. + + :param response: A response object, or None, if the server did not + return a response. + :type response: :class:`~urllib3.response.BaseHTTPResponse` + :param Exception error: An error encountered during the request, or + None if the response was received successfully. + + :return: A new ``Retry`` object. + """ + if self.total is False and error: + # Disabled, indicate to re-raise the error. + raise reraise(type(error), error, _stacktrace) + + total = self.total + if total is not None: + total -= 1 + + connect = self.connect + read = self.read + redirect = self.redirect + status_count = self.status + other = self.other + cause = "unknown" + status = None + redirect_location = None + + if error and self._is_connection_error(error): + # Connect retry? + if connect is False: + raise reraise(type(error), error, _stacktrace) + elif connect is not None: + connect -= 1 + + elif error and self._is_read_error(error): + # Read retry? + if read is False or method is None or not self._is_method_retryable(method): + raise reraise(type(error), error, _stacktrace) + elif read is not None: + read -= 1 + + elif error: + # Other retry? + if other is not None: + other -= 1 + + elif response and response.get_redirect_location(): + # Redirect retry? + if redirect is not None: + redirect -= 1 + cause = "too many redirects" + response_redirect_location = response.get_redirect_location() + if response_redirect_location: + redirect_location = response_redirect_location + status = response.status + + else: + # Incrementing because of a server error like a 500 in + # status_forcelist and the given method is in the allowed_methods + cause = ResponseError.GENERIC_ERROR + if response and response.status: + if status_count is not None: + status_count -= 1 + cause = ResponseError.SPECIFIC_ERROR.format(status_code=response.status) + status = response.status + + history = self.history + ( + RequestHistory(method, url, error, status, redirect_location), + ) + + new_retry = self.new( + total=total, + connect=connect, + read=read, + redirect=redirect, + status=status_count, + other=other, + history=history, + ) + + if new_retry.is_exhausted(): + reason = error or ResponseError(cause) + raise MaxRetryError(_pool, url, reason) from reason # type: ignore[arg-type] + + log.debug("Incremented Retry for (url='%s'): %r", url, new_retry) + + return new_retry + + def __repr__(self) -> str: + return ( + f"{type(self).__name__}(total={self.total}, connect={self.connect}, " + f"read={self.read}, redirect={self.redirect}, status={self.status})" + ) + + +# For backwards compatibility (equivalent to pre-v1.9): +Retry.DEFAULT = Retry(3) diff --git a/Modules/urllib3/util/ssl_.py b/Modules/urllib3/util/ssl_.py new file mode 100644 index 0000000..e0a7c04 --- /dev/null +++ b/Modules/urllib3/util/ssl_.py @@ -0,0 +1,514 @@ +from __future__ import annotations + +import hmac +import os +import socket +import sys +import typing +import warnings +from binascii import unhexlify +from hashlib import md5, sha1, sha256 + +from ..exceptions import ProxySchemeUnsupported, SSLError +from .url import _BRACELESS_IPV6_ADDRZ_RE, _IPV4_RE + +SSLContext = None +SSLTransport = None +HAS_NEVER_CHECK_COMMON_NAME = False +IS_PYOPENSSL = False +ALPN_PROTOCOLS = ["http/1.1"] + +_TYPE_VERSION_INFO = typing.Tuple[int, int, int, str, int] + +# Maps the length of a digest to a possible hash function producing this digest +HASHFUNC_MAP = {32: md5, 40: sha1, 64: sha256} + + +def _is_bpo_43522_fixed( + implementation_name: str, + version_info: _TYPE_VERSION_INFO, + pypy_version_info: _TYPE_VERSION_INFO | None, +) -> bool: + """Return True for CPython 3.8.9+, 3.9.3+ or 3.10+ and PyPy 7.3.8+ where + setting SSLContext.hostname_checks_common_name to False works. + + Outside of CPython and PyPy we don't know which implementations work + or not so we conservatively use our hostname matching as we know that works + on all implementations. + + https://github.com/urllib3/urllib3/issues/2192#issuecomment-821832963 + https://foss.heptapod.net/pypy/pypy/-/issues/3539 + """ + if implementation_name == "pypy": + # https://foss.heptapod.net/pypy/pypy/-/issues/3129 + return pypy_version_info >= (7, 3, 8) # type: ignore[operator] + elif implementation_name == "cpython": + major_minor = version_info[:2] + micro = version_info[2] + return ( + (major_minor == (3, 8) and micro >= 9) + or (major_minor == (3, 9) and micro >= 3) + or major_minor >= (3, 10) + ) + else: # Defensive: + return False + + +def _is_has_never_check_common_name_reliable( + openssl_version: str, + openssl_version_number: int, + implementation_name: str, + version_info: _TYPE_VERSION_INFO, + pypy_version_info: _TYPE_VERSION_INFO | None, +) -> bool: + # As of May 2023, all released versions of LibreSSL fail to reject certificates with + # only common names, see https://github.com/urllib3/urllib3/pull/3024 + is_openssl = openssl_version.startswith("OpenSSL ") + # Before fixing OpenSSL issue #14579, the SSL_new() API was not copying hostflags + # like X509_CHECK_FLAG_NEVER_CHECK_SUBJECT, which tripped up CPython. + # https://github.com/openssl/openssl/issues/14579 + # This was released in OpenSSL 1.1.1l+ (>=0x101010cf) + is_openssl_issue_14579_fixed = openssl_version_number >= 0x101010CF + + return is_openssl and ( + is_openssl_issue_14579_fixed + or _is_bpo_43522_fixed(implementation_name, version_info, pypy_version_info) + ) + + +if typing.TYPE_CHECKING: + from ssl import VerifyMode + from typing import Literal, TypedDict + + from .ssltransport import SSLTransport as SSLTransportType + + class _TYPE_PEER_CERT_RET_DICT(TypedDict, total=False): + subjectAltName: tuple[tuple[str, str], ...] + subject: tuple[tuple[tuple[str, str], ...], ...] + serialNumber: str + + +# Mapping from 'ssl.PROTOCOL_TLSX' to 'TLSVersion.X' +_SSL_VERSION_TO_TLS_VERSION: dict[int, int] = {} + +try: # Do we have ssl at all? + import ssl + from ssl import ( # type: ignore[assignment] + CERT_REQUIRED, + HAS_NEVER_CHECK_COMMON_NAME, + OP_NO_COMPRESSION, + OP_NO_TICKET, + OPENSSL_VERSION, + OPENSSL_VERSION_NUMBER, + PROTOCOL_TLS, + PROTOCOL_TLS_CLIENT, + OP_NO_SSLv2, + OP_NO_SSLv3, + SSLContext, + TLSVersion, + ) + + PROTOCOL_SSLv23 = PROTOCOL_TLS + + # Setting SSLContext.hostname_checks_common_name = False didn't work before CPython + # 3.8.9, 3.9.3, and 3.10 (but OK on PyPy) or OpenSSL 1.1.1l+ + if HAS_NEVER_CHECK_COMMON_NAME and not _is_has_never_check_common_name_reliable( + OPENSSL_VERSION, + OPENSSL_VERSION_NUMBER, + sys.implementation.name, + sys.version_info, + sys.pypy_version_info if sys.implementation.name == "pypy" else None, # type: ignore[attr-defined] + ): + HAS_NEVER_CHECK_COMMON_NAME = False + + # Need to be careful here in case old TLS versions get + # removed in future 'ssl' module implementations. + for attr in ("TLSv1", "TLSv1_1", "TLSv1_2"): + try: + _SSL_VERSION_TO_TLS_VERSION[getattr(ssl, f"PROTOCOL_{attr}")] = getattr( + TLSVersion, attr + ) + except AttributeError: # Defensive: + continue + + from .ssltransport import SSLTransport # type: ignore[assignment] +except ImportError: + OP_NO_COMPRESSION = 0x20000 # type: ignore[assignment] + OP_NO_TICKET = 0x4000 # type: ignore[assignment] + OP_NO_SSLv2 = 0x1000000 # type: ignore[assignment] + OP_NO_SSLv3 = 0x2000000 # type: ignore[assignment] + PROTOCOL_SSLv23 = PROTOCOL_TLS = 2 # type: ignore[assignment] + PROTOCOL_TLS_CLIENT = 16 # type: ignore[assignment] + + +_TYPE_PEER_CERT_RET = typing.Union["_TYPE_PEER_CERT_RET_DICT", bytes, None] + + +def assert_fingerprint(cert: bytes | None, fingerprint: str) -> None: + """ + Checks if given fingerprint matches the supplied certificate. + + :param cert: + Certificate as bytes object. + :param fingerprint: + Fingerprint as string of hexdigits, can be interspersed by colons. + """ + + if cert is None: + raise SSLError("No certificate for the peer.") + + fingerprint = fingerprint.replace(":", "").lower() + digest_length = len(fingerprint) + hashfunc = HASHFUNC_MAP.get(digest_length) + if not hashfunc: + raise SSLError(f"Fingerprint of invalid length: {fingerprint}") + + # We need encode() here for py32; works on py2 and p33. + fingerprint_bytes = unhexlify(fingerprint.encode()) + + cert_digest = hashfunc(cert).digest() + + if not hmac.compare_digest(cert_digest, fingerprint_bytes): + raise SSLError( + f'Fingerprints did not match. Expected "{fingerprint}", got "{cert_digest.hex()}"' + ) + + +def resolve_cert_reqs(candidate: None | int | str) -> VerifyMode: + """ + Resolves the argument to a numeric constant, which can be passed to + the wrap_socket function/method from the ssl module. + Defaults to :data:`ssl.CERT_REQUIRED`. + If given a string it is assumed to be the name of the constant in the + :mod:`ssl` module or its abbreviation. + (So you can specify `REQUIRED` instead of `CERT_REQUIRED`. + If it's neither `None` nor a string we assume it is already the numeric + constant which can directly be passed to wrap_socket. + """ + if candidate is None: + return CERT_REQUIRED + + if isinstance(candidate, str): + res = getattr(ssl, candidate, None) + if res is None: + res = getattr(ssl, "CERT_" + candidate) + return res # type: ignore[no-any-return] + + return candidate # type: ignore[return-value] + + +def resolve_ssl_version(candidate: None | int | str) -> int: + """ + like resolve_cert_reqs + """ + if candidate is None: + return PROTOCOL_TLS + + if isinstance(candidate, str): + res = getattr(ssl, candidate, None) + if res is None: + res = getattr(ssl, "PROTOCOL_" + candidate) + return typing.cast(int, res) + + return candidate + + +def create_urllib3_context( + ssl_version: int | None = None, + cert_reqs: int | None = None, + options: int | None = None, + ciphers: str | None = None, + ssl_minimum_version: int | None = None, + ssl_maximum_version: int | None = None, +) -> ssl.SSLContext: + """Creates and configures an :class:`ssl.SSLContext` instance for use with urllib3. + + :param ssl_version: + The desired protocol version to use. This will default to + PROTOCOL_SSLv23 which will negotiate the highest protocol that both + the server and your installation of OpenSSL support. + + This parameter is deprecated instead use 'ssl_minimum_version'. + :param ssl_minimum_version: + The minimum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value. + :param ssl_maximum_version: + The maximum version of TLS to be used. Use the 'ssl.TLSVersion' enum for specifying the value. + Not recommended to set to anything other than 'ssl.TLSVersion.MAXIMUM_SUPPORTED' which is the + default value. + :param cert_reqs: + Whether to require the certificate verification. This defaults to + ``ssl.CERT_REQUIRED``. + :param options: + Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``, + ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``, and ``ssl.OP_NO_TICKET``. + :param ciphers: + Which cipher suites to allow the server to select. Defaults to either system configured + ciphers if OpenSSL 1.1.1+, otherwise uses a secure default set of ciphers. + :returns: + Constructed SSLContext object with specified options + :rtype: SSLContext + """ + if SSLContext is None: + raise TypeError("Can't create an SSLContext object without an ssl module") + + # This means 'ssl_version' was specified as an exact value. + if ssl_version not in (None, PROTOCOL_TLS, PROTOCOL_TLS_CLIENT): + # Disallow setting 'ssl_version' and 'ssl_minimum|maximum_version' + # to avoid conflicts. + if ssl_minimum_version is not None or ssl_maximum_version is not None: + raise ValueError( + "Can't specify both 'ssl_version' and either " + "'ssl_minimum_version' or 'ssl_maximum_version'" + ) + + # 'ssl_version' is deprecated and will be removed in the future. + else: + # Use 'ssl_minimum_version' and 'ssl_maximum_version' instead. + ssl_minimum_version = _SSL_VERSION_TO_TLS_VERSION.get( + ssl_version, TLSVersion.MINIMUM_SUPPORTED + ) + ssl_maximum_version = _SSL_VERSION_TO_TLS_VERSION.get( + ssl_version, TLSVersion.MAXIMUM_SUPPORTED + ) + + # This warning message is pushing users to use 'ssl_minimum_version' + # instead of both min/max. Best practice is to only set the minimum version and + # keep the maximum version to be it's default value: 'TLSVersion.MAXIMUM_SUPPORTED' + warnings.warn( + "'ssl_version' option is deprecated and will be " + "removed in urllib3 v2.1.0. Instead use 'ssl_minimum_version'", + category=DeprecationWarning, + stacklevel=2, + ) + + # PROTOCOL_TLS is deprecated in Python 3.10 so we always use PROTOCOL_TLS_CLIENT + context = SSLContext(PROTOCOL_TLS_CLIENT) + + if ssl_minimum_version is not None: + context.minimum_version = ssl_minimum_version + else: # Python <3.10 defaults to 'MINIMUM_SUPPORTED' so explicitly set TLSv1.2 here + context.minimum_version = TLSVersion.TLSv1_2 + + if ssl_maximum_version is not None: + context.maximum_version = ssl_maximum_version + + # Unless we're given ciphers defer to either system ciphers in + # the case of OpenSSL 1.1.1+ or use our own secure default ciphers. + if ciphers: + context.set_ciphers(ciphers) + + # Setting the default here, as we may have no ssl module on import + cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs + + if options is None: + options = 0 + # SSLv2 is easily broken and is considered harmful and dangerous + options |= OP_NO_SSLv2 + # SSLv3 has several problems and is now dangerous + options |= OP_NO_SSLv3 + # Disable compression to prevent CRIME attacks for OpenSSL 1.0+ + # (issue #309) + options |= OP_NO_COMPRESSION + # TLSv1.2 only. Unless set explicitly, do not request tickets. + # This may save some bandwidth on wire, and although the ticket is encrypted, + # there is a risk associated with it being on wire, + # if the server is not rotating its ticketing keys properly. + options |= OP_NO_TICKET + + context.options |= options + + # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is + # necessary for conditional client cert authentication with TLS 1.3. + # The attribute is None for OpenSSL <= 1.1.0 or does not exist in older + # versions of Python. We only enable if certificate verification is enabled to work + # around Python issue #37428 + # See: https://bugs.python.org/issue37428 + if ( + cert_reqs == ssl.CERT_REQUIRED + and getattr(context, "post_handshake_auth", None) is not None + ): + context.post_handshake_auth = True + + # The order of the below lines setting verify_mode and check_hostname + # matter due to safe-guards SSLContext has to prevent an SSLContext with + # check_hostname=True, verify_mode=NONE/OPTIONAL. + # We always set 'check_hostname=False' for pyOpenSSL so we rely on our own + # 'ssl.match_hostname()' implementation. + if cert_reqs == ssl.CERT_REQUIRED and not IS_PYOPENSSL: + context.verify_mode = cert_reqs + context.check_hostname = True + else: + context.check_hostname = False + context.verify_mode = cert_reqs + + try: + context.hostname_checks_common_name = False + except AttributeError: # Defensive: for CPython < 3.8.9 and 3.9.3; for PyPy < 7.3.8 + pass + + # Enable logging of TLS session keys via defacto standard environment variable + # 'SSLKEYLOGFILE', if the feature is available (Python 3.8+). Skip empty values. + if hasattr(context, "keylog_filename"): + sslkeylogfile = os.environ.get("SSLKEYLOGFILE") + if sslkeylogfile: + context.keylog_filename = sslkeylogfile + + return context + + +@typing.overload +def ssl_wrap_socket( + sock: socket.socket, + keyfile: str | None = ..., + certfile: str | None = ..., + cert_reqs: int | None = ..., + ca_certs: str | None = ..., + server_hostname: str | None = ..., + ssl_version: int | None = ..., + ciphers: str | None = ..., + ssl_context: ssl.SSLContext | None = ..., + ca_cert_dir: str | None = ..., + key_password: str | None = ..., + ca_cert_data: None | str | bytes = ..., + tls_in_tls: Literal[False] = ..., +) -> ssl.SSLSocket: + ... + + +@typing.overload +def ssl_wrap_socket( + sock: socket.socket, + keyfile: str | None = ..., + certfile: str | None = ..., + cert_reqs: int | None = ..., + ca_certs: str | None = ..., + server_hostname: str | None = ..., + ssl_version: int | None = ..., + ciphers: str | None = ..., + ssl_context: ssl.SSLContext | None = ..., + ca_cert_dir: str | None = ..., + key_password: str | None = ..., + ca_cert_data: None | str | bytes = ..., + tls_in_tls: bool = ..., +) -> ssl.SSLSocket | SSLTransportType: + ... + + +def ssl_wrap_socket( + sock: socket.socket, + keyfile: str | None = None, + certfile: str | None = None, + cert_reqs: int | None = None, + ca_certs: str | None = None, + server_hostname: str | None = None, + ssl_version: int | None = None, + ciphers: str | None = None, + ssl_context: ssl.SSLContext | None = None, + ca_cert_dir: str | None = None, + key_password: str | None = None, + ca_cert_data: None | str | bytes = None, + tls_in_tls: bool = False, +) -> ssl.SSLSocket | SSLTransportType: + """ + All arguments except for server_hostname, ssl_context, tls_in_tls, ca_cert_data and + ca_cert_dir have the same meaning as they do when using + :func:`ssl.create_default_context`, :meth:`ssl.SSLContext.load_cert_chain`, + :meth:`ssl.SSLContext.set_ciphers` and :meth:`ssl.SSLContext.wrap_socket`. + + :param server_hostname: + When SNI is supported, the expected hostname of the certificate + :param ssl_context: + A pre-made :class:`SSLContext` object. If none is provided, one will + be created using :func:`create_urllib3_context`. + :param ciphers: + A string of ciphers we wish the client to support. + :param ca_cert_dir: + A directory containing CA certificates in multiple separate files, as + supported by OpenSSL's -CApath flag or the capath argument to + SSLContext.load_verify_locations(). + :param key_password: + Optional password if the keyfile is encrypted. + :param ca_cert_data: + Optional string containing CA certificates in PEM format suitable for + passing as the cadata parameter to SSLContext.load_verify_locations() + :param tls_in_tls: + Use SSLTransport to wrap the existing socket. + """ + context = ssl_context + if context is None: + # Note: This branch of code and all the variables in it are only used in tests. + # We should consider deprecating and removing this code. + context = create_urllib3_context(ssl_version, cert_reqs, ciphers=ciphers) + + if ca_certs or ca_cert_dir or ca_cert_data: + try: + context.load_verify_locations(ca_certs, ca_cert_dir, ca_cert_data) + except OSError as e: + raise SSLError(e) from e + + elif ssl_context is None and hasattr(context, "load_default_certs"): + # try to load OS default certs; works well on Windows. + context.load_default_certs() + + # Attempt to detect if we get the goofy behavior of the + # keyfile being encrypted and OpenSSL asking for the + # passphrase via the terminal and instead error out. + if keyfile and key_password is None and _is_key_file_encrypted(keyfile): + raise SSLError("Client private key is encrypted, password is required") + + if certfile: + if key_password is None: + context.load_cert_chain(certfile, keyfile) + else: + context.load_cert_chain(certfile, keyfile, key_password) + + try: + context.set_alpn_protocols(ALPN_PROTOCOLS) + except NotImplementedError: # Defensive: in CI, we always have set_alpn_protocols + pass + + ssl_sock = _ssl_wrap_socket_impl(sock, context, tls_in_tls, server_hostname) + return ssl_sock + + +def is_ipaddress(hostname: str | bytes) -> bool: + """Detects whether the hostname given is an IPv4 or IPv6 address. + Also detects IPv6 addresses with Zone IDs. + + :param str hostname: Hostname to examine. + :return: True if the hostname is an IP address, False otherwise. + """ + if isinstance(hostname, bytes): + # IDN A-label bytes are ASCII compatible. + hostname = hostname.decode("ascii") + return bool(_IPV4_RE.match(hostname) or _BRACELESS_IPV6_ADDRZ_RE.match(hostname)) + + +def _is_key_file_encrypted(key_file: str) -> bool: + """Detects if a key file is encrypted or not.""" + with open(key_file) as f: + for line in f: + # Look for Proc-Type: 4,ENCRYPTED + if "ENCRYPTED" in line: + return True + + return False + + +def _ssl_wrap_socket_impl( + sock: socket.socket, + ssl_context: ssl.SSLContext, + tls_in_tls: bool, + server_hostname: str | None = None, +) -> ssl.SSLSocket | SSLTransportType: + if tls_in_tls: + if not SSLTransport: + # Import error, ssl is not available. + raise ProxySchemeUnsupported( + "TLS in TLS requires support for the 'ssl' module" + ) + + SSLTransport._validate_ssl_context_for_tls_in_tls(ssl_context) + return SSLTransport(sock, ssl_context, server_hostname) + + return ssl_context.wrap_socket(sock, server_hostname=server_hostname) diff --git a/Modules/urllib3/util/ssl_match_hostname.py b/Modules/urllib3/util/ssl_match_hostname.py new file mode 100644 index 0000000..453cfd4 --- /dev/null +++ b/Modules/urllib3/util/ssl_match_hostname.py @@ -0,0 +1,159 @@ +"""The match_hostname() function from Python 3.5, essential when using SSL.""" + +# Note: This file is under the PSF license as the code comes from the python +# stdlib. http://docs.python.org/3/license.html +# It is modified to remove commonName support. + +from __future__ import annotations + +import ipaddress +import re +import typing +from ipaddress import IPv4Address, IPv6Address + +if typing.TYPE_CHECKING: + from .ssl_ import _TYPE_PEER_CERT_RET_DICT + +__version__ = "3.5.0.1" + + +class CertificateError(ValueError): + pass + + +def _dnsname_match( + dn: typing.Any, hostname: str, max_wildcards: int = 1 +) -> typing.Match[str] | None | bool: + """Matching according to RFC 6125, section 6.4.3 + + http://tools.ietf.org/html/rfc6125#section-6.4.3 + """ + pats = [] + if not dn: + return False + + # Ported from python3-syntax: + # leftmost, *remainder = dn.split(r'.') + parts = dn.split(r".") + leftmost = parts[0] + remainder = parts[1:] + + wildcards = leftmost.count("*") + if wildcards > max_wildcards: + # Issue #17980: avoid denials of service by refusing more + # than one wildcard per fragment. A survey of established + # policy among SSL implementations showed it to be a + # reasonable choice. + raise CertificateError( + "too many wildcards in certificate DNS name: " + repr(dn) + ) + + # speed up common case w/o wildcards + if not wildcards: + return bool(dn.lower() == hostname.lower()) + + # RFC 6125, section 6.4.3, subitem 1. + # The client SHOULD NOT attempt to match a presented identifier in which + # the wildcard character comprises a label other than the left-most label. + if leftmost == "*": + # When '*' is a fragment by itself, it matches a non-empty dotless + # fragment. + pats.append("[^.]+") + elif leftmost.startswith("xn--") or hostname.startswith("xn--"): + # RFC 6125, section 6.4.3, subitem 3. + # The client SHOULD NOT attempt to match a presented identifier + # where the wildcard character is embedded within an A-label or + # U-label of an internationalized domain name. + pats.append(re.escape(leftmost)) + else: + # Otherwise, '*' matches any dotless string, e.g. www* + pats.append(re.escape(leftmost).replace(r"\*", "[^.]*")) + + # add the remaining fragments, ignore any wildcards + for frag in remainder: + pats.append(re.escape(frag)) + + pat = re.compile(r"\A" + r"\.".join(pats) + r"\Z", re.IGNORECASE) + return pat.match(hostname) + + +def _ipaddress_match(ipname: str, host_ip: IPv4Address | IPv6Address) -> bool: + """Exact matching of IP addresses. + + RFC 9110 section 4.3.5: "A reference identity of IP-ID contains the decoded + bytes of the IP address. An IP version 4 address is 4 octets, and an IP + version 6 address is 16 octets. [...] A reference identity of type IP-ID + matches if the address is identical to an iPAddress value of the + subjectAltName extension of the certificate." + """ + # OpenSSL may add a trailing newline to a subjectAltName's IP address + # Divergence from upstream: ipaddress can't handle byte str + ip = ipaddress.ip_address(ipname.rstrip()) + return bool(ip.packed == host_ip.packed) + + +def match_hostname( + cert: _TYPE_PEER_CERT_RET_DICT | None, + hostname: str, + hostname_checks_common_name: bool = False, +) -> None: + """Verify that *cert* (in decoded format as returned by + SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125 + rules are followed, but IP addresses are not accepted for *hostname*. + + CertificateError is raised on failure. On success, the function + returns nothing. + """ + if not cert: + raise ValueError( + "empty or no certificate, match_hostname needs a " + "SSL socket or SSL context with either " + "CERT_OPTIONAL or CERT_REQUIRED" + ) + try: + # Divergence from upstream: ipaddress can't handle byte str + # + # The ipaddress module shipped with Python < 3.9 does not support + # scoped IPv6 addresses so we unconditionally strip the Zone IDs for + # now. Once we drop support for Python 3.9 we can remove this branch. + if "%" in hostname: + host_ip = ipaddress.ip_address(hostname[: hostname.rfind("%")]) + else: + host_ip = ipaddress.ip_address(hostname) + + except ValueError: + # Not an IP address (common case) + host_ip = None + dnsnames = [] + san: tuple[tuple[str, str], ...] = cert.get("subjectAltName", ()) + key: str + value: str + for key, value in san: + if key == "DNS": + if host_ip is None and _dnsname_match(value, hostname): + return + dnsnames.append(value) + elif key == "IP Address": + if host_ip is not None and _ipaddress_match(value, host_ip): + return + dnsnames.append(value) + + # We only check 'commonName' if it's enabled and we're not verifying + # an IP address. IP addresses aren't valid within 'commonName'. + if hostname_checks_common_name and host_ip is None and not dnsnames: + for sub in cert.get("subject", ()): + for key, value in sub: + if key == "commonName": + if _dnsname_match(value, hostname): + return + dnsnames.append(value) + + if len(dnsnames) > 1: + raise CertificateError( + "hostname %r " + "doesn't match either of %s" % (hostname, ", ".join(map(repr, dnsnames))) + ) + elif len(dnsnames) == 1: + raise CertificateError(f"hostname {hostname!r} doesn't match {dnsnames[0]!r}") + else: + raise CertificateError("no appropriate subjectAltName fields were found") diff --git a/Modules/urllib3/util/ssltransport.py b/Modules/urllib3/util/ssltransport.py new file mode 100644 index 0000000..fa9f2b3 --- /dev/null +++ b/Modules/urllib3/util/ssltransport.py @@ -0,0 +1,280 @@ +from __future__ import annotations + +import io +import socket +import ssl +import typing + +from ..exceptions import ProxySchemeUnsupported + +if typing.TYPE_CHECKING: + from typing import Literal + + from .ssl_ import _TYPE_PEER_CERT_RET, _TYPE_PEER_CERT_RET_DICT + + +_SelfT = typing.TypeVar("_SelfT", bound="SSLTransport") +_WriteBuffer = typing.Union[bytearray, memoryview] +_ReturnValue = typing.TypeVar("_ReturnValue") + +SSL_BLOCKSIZE = 16384 + + +class SSLTransport: + """ + The SSLTransport wraps an existing socket and establishes an SSL connection. + + Contrary to Python's implementation of SSLSocket, it allows you to chain + multiple TLS connections together. It's particularly useful if you need to + implement TLS within TLS. + + The class supports most of the socket API operations. + """ + + @staticmethod + def _validate_ssl_context_for_tls_in_tls(ssl_context: ssl.SSLContext) -> None: + """ + Raises a ProxySchemeUnsupported if the provided ssl_context can't be used + for TLS in TLS. + + The only requirement is that the ssl_context provides the 'wrap_bio' + methods. + """ + + if not hasattr(ssl_context, "wrap_bio"): + raise ProxySchemeUnsupported( + "TLS in TLS requires SSLContext.wrap_bio() which isn't " + "available on non-native SSLContext" + ) + + def __init__( + self, + socket: socket.socket, + ssl_context: ssl.SSLContext, + server_hostname: str | None = None, + suppress_ragged_eofs: bool = True, + ) -> None: + """ + Create an SSLTransport around socket using the provided ssl_context. + """ + self.incoming = ssl.MemoryBIO() + self.outgoing = ssl.MemoryBIO() + + self.suppress_ragged_eofs = suppress_ragged_eofs + self.socket = socket + + self.sslobj = ssl_context.wrap_bio( + self.incoming, self.outgoing, server_hostname=server_hostname + ) + + # Perform initial handshake. + self._ssl_io_loop(self.sslobj.do_handshake) + + def __enter__(self: _SelfT) -> _SelfT: + return self + + def __exit__(self, *_: typing.Any) -> None: + self.close() + + def fileno(self) -> int: + return self.socket.fileno() + + def read(self, len: int = 1024, buffer: typing.Any | None = None) -> int | bytes: + return self._wrap_ssl_read(len, buffer) + + def recv(self, buflen: int = 1024, flags: int = 0) -> int | bytes: + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to recv") + return self._wrap_ssl_read(buflen) + + def recv_into( + self, + buffer: _WriteBuffer, + nbytes: int | None = None, + flags: int = 0, + ) -> None | int | bytes: + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to recv_into") + if nbytes is None: + nbytes = len(buffer) + return self.read(nbytes, buffer) + + def sendall(self, data: bytes, flags: int = 0) -> None: + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to sendall") + count = 0 + with memoryview(data) as view, view.cast("B") as byte_view: + amount = len(byte_view) + while count < amount: + v = self.send(byte_view[count:]) + count += v + + def send(self, data: bytes, flags: int = 0) -> int: + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to send") + return self._ssl_io_loop(self.sslobj.write, data) + + def makefile( + self, + mode: str, + buffering: int | None = None, + *, + encoding: str | None = None, + errors: str | None = None, + newline: str | None = None, + ) -> typing.BinaryIO | typing.TextIO | socket.SocketIO: + """ + Python's httpclient uses makefile and buffered io when reading HTTP + messages and we need to support it. + + This is unfortunately a copy and paste of socket.py makefile with small + changes to point to the socket directly. + """ + if not set(mode) <= {"r", "w", "b"}: + raise ValueError(f"invalid mode {mode!r} (only r, w, b allowed)") + + writing = "w" in mode + reading = "r" in mode or not writing + assert reading or writing + binary = "b" in mode + rawmode = "" + if reading: + rawmode += "r" + if writing: + rawmode += "w" + raw = socket.SocketIO(self, rawmode) # type: ignore[arg-type] + self.socket._io_refs += 1 # type: ignore[attr-defined] + if buffering is None: + buffering = -1 + if buffering < 0: + buffering = io.DEFAULT_BUFFER_SIZE + if buffering == 0: + if not binary: + raise ValueError("unbuffered streams must be binary") + return raw + buffer: typing.BinaryIO + if reading and writing: + buffer = io.BufferedRWPair(raw, raw, buffering) # type: ignore[assignment] + elif reading: + buffer = io.BufferedReader(raw, buffering) + else: + assert writing + buffer = io.BufferedWriter(raw, buffering) + if binary: + return buffer + text = io.TextIOWrapper(buffer, encoding, errors, newline) + text.mode = mode # type: ignore[misc] + return text + + def unwrap(self) -> None: + self._ssl_io_loop(self.sslobj.unwrap) + + def close(self) -> None: + self.socket.close() + + @typing.overload + def getpeercert( + self, binary_form: Literal[False] = ... + ) -> _TYPE_PEER_CERT_RET_DICT | None: + ... + + @typing.overload + def getpeercert(self, binary_form: Literal[True]) -> bytes | None: + ... + + def getpeercert(self, binary_form: bool = False) -> _TYPE_PEER_CERT_RET: + return self.sslobj.getpeercert(binary_form) # type: ignore[return-value] + + def version(self) -> str | None: + return self.sslobj.version() + + def cipher(self) -> tuple[str, str, int] | None: + return self.sslobj.cipher() + + def selected_alpn_protocol(self) -> str | None: + return self.sslobj.selected_alpn_protocol() + + def selected_npn_protocol(self) -> str | None: + return self.sslobj.selected_npn_protocol() + + def shared_ciphers(self) -> list[tuple[str, str, int]] | None: + return self.sslobj.shared_ciphers() + + def compression(self) -> str | None: + return self.sslobj.compression() + + def settimeout(self, value: float | None) -> None: + self.socket.settimeout(value) + + def gettimeout(self) -> float | None: + return self.socket.gettimeout() + + def _decref_socketios(self) -> None: + self.socket._decref_socketios() # type: ignore[attr-defined] + + def _wrap_ssl_read(self, len: int, buffer: bytearray | None = None) -> int | bytes: + try: + return self._ssl_io_loop(self.sslobj.read, len, buffer) + except ssl.SSLError as e: + if e.errno == ssl.SSL_ERROR_EOF and self.suppress_ragged_eofs: + return 0 # eof, return 0. + else: + raise + + # func is sslobj.do_handshake or sslobj.unwrap + @typing.overload + def _ssl_io_loop(self, func: typing.Callable[[], None]) -> None: + ... + + # func is sslobj.write, arg1 is data + @typing.overload + def _ssl_io_loop(self, func: typing.Callable[[bytes], int], arg1: bytes) -> int: + ... + + # func is sslobj.read, arg1 is len, arg2 is buffer + @typing.overload + def _ssl_io_loop( + self, + func: typing.Callable[[int, bytearray | None], bytes], + arg1: int, + arg2: bytearray | None, + ) -> bytes: + ... + + def _ssl_io_loop( + self, + func: typing.Callable[..., _ReturnValue], + arg1: None | bytes | int = None, + arg2: bytearray | None = None, + ) -> _ReturnValue: + """Performs an I/O loop between incoming/outgoing and the socket.""" + should_loop = True + ret = None + + while should_loop: + errno = None + try: + if arg1 is None and arg2 is None: + ret = func() + elif arg2 is None: + ret = func(arg1) + else: + ret = func(arg1, arg2) + except ssl.SSLError as e: + if e.errno not in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE): + # WANT_READ, and WANT_WRITE are expected, others are not. + raise e + errno = e.errno + + buf = self.outgoing.read() + self.socket.sendall(buf) + + if errno is None: + should_loop = False + elif errno == ssl.SSL_ERROR_WANT_READ: + buf = self.socket.recv(SSL_BLOCKSIZE) + if buf: + self.incoming.write(buf) + else: + self.incoming.write_eof() + return typing.cast(_ReturnValue, ret) diff --git a/Modules/urllib3/util/timeout.py b/Modules/urllib3/util/timeout.py new file mode 100644 index 0000000..f044625 --- /dev/null +++ b/Modules/urllib3/util/timeout.py @@ -0,0 +1,279 @@ +from __future__ import annotations + +import time +import typing +from enum import Enum +from socket import getdefaulttimeout + +from ..exceptions import TimeoutStateError + +if typing.TYPE_CHECKING: + from typing import Final + + +class _TYPE_DEFAULT(Enum): + # This value should never be passed to socket.settimeout() so for safety we use a -1. + # socket.settimout() raises a ValueError for negative values. + token = -1 + + +_DEFAULT_TIMEOUT: Final[_TYPE_DEFAULT] = _TYPE_DEFAULT.token + +_TYPE_TIMEOUT = typing.Optional[typing.Union[float, _TYPE_DEFAULT]] + + +class Timeout: + """Timeout configuration. + + Timeouts can be defined as a default for a pool: + + .. code-block:: python + + import urllib3 + + timeout = urllib3.util.Timeout(connect=2.0, read=7.0) + + http = urllib3.PoolManager(timeout=timeout) + + resp = http.request("GET", "https://example.com/") + + print(resp.status) + + Or per-request (which overrides the default for the pool): + + .. code-block:: python + + response = http.request("GET", "https://example.com/", timeout=Timeout(10)) + + Timeouts can be disabled by setting all the parameters to ``None``: + + .. code-block:: python + + no_timeout = Timeout(connect=None, read=None) + response = http.request("GET", "https://example.com/", timeout=no_timeout) + + + :param total: + This combines the connect and read timeouts into one; the read timeout + will be set to the time leftover from the connect attempt. In the + event that both a connect timeout and a total are specified, or a read + timeout and a total are specified, the shorter timeout will be applied. + + Defaults to None. + + :type total: int, float, or None + + :param connect: + The maximum amount of time (in seconds) to wait for a connection + attempt to a server to succeed. Omitting the parameter will default the + connect timeout to the system default, probably `the global default + timeout in socket.py + `_. + None will set an infinite timeout for connection attempts. + + :type connect: int, float, or None + + :param read: + The maximum amount of time (in seconds) to wait between consecutive + read operations for a response from the server. Omitting the parameter + will default the read timeout to the system default, probably `the + global default timeout in socket.py + `_. + None will set an infinite timeout. + + :type read: int, float, or None + + .. note:: + + Many factors can affect the total amount of time for urllib3 to return + an HTTP response. + + For example, Python's DNS resolver does not obey the timeout specified + on the socket. Other factors that can affect total request time include + high CPU load, high swap, the program running at a low priority level, + or other behaviors. + + In addition, the read and total timeouts only measure the time between + read operations on the socket connecting the client and the server, + not the total amount of time for the request to return a complete + response. For most requests, the timeout is raised because the server + has not sent the first byte in the specified time. This is not always + the case; if a server streams one byte every fifteen seconds, a timeout + of 20 seconds will not trigger, even though the request will take + several minutes to complete. + + If your goal is to cut off any request after a set amount of wall clock + time, consider having a second "watcher" thread to cut off a slow + request. + """ + + #: A sentinel object representing the default timeout value + DEFAULT_TIMEOUT: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT + + def __init__( + self, + total: _TYPE_TIMEOUT = None, + connect: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, + read: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, + ) -> None: + self._connect = self._validate_timeout(connect, "connect") + self._read = self._validate_timeout(read, "read") + self.total = self._validate_timeout(total, "total") + self._start_connect: float | None = None + + def __repr__(self) -> str: + return f"{type(self).__name__}(connect={self._connect!r}, read={self._read!r}, total={self.total!r})" + + # __str__ provided for backwards compatibility + __str__ = __repr__ + + @staticmethod + def resolve_default_timeout(timeout: _TYPE_TIMEOUT) -> float | None: + return getdefaulttimeout() if timeout is _DEFAULT_TIMEOUT else timeout + + @classmethod + def _validate_timeout(cls, value: _TYPE_TIMEOUT, name: str) -> _TYPE_TIMEOUT: + """Check that a timeout attribute is valid. + + :param value: The timeout value to validate + :param name: The name of the timeout attribute to validate. This is + used to specify in error messages. + :return: The validated and casted version of the given value. + :raises ValueError: If it is a numeric value less than or equal to + zero, or the type is not an integer, float, or None. + """ + if value is None or value is _DEFAULT_TIMEOUT: + return value + + if isinstance(value, bool): + raise ValueError( + "Timeout cannot be a boolean value. It must " + "be an int, float or None." + ) + try: + float(value) + except (TypeError, ValueError): + raise ValueError( + "Timeout value %s was %s, but it must be an " + "int, float or None." % (name, value) + ) from None + + try: + if value <= 0: + raise ValueError( + "Attempted to set %s timeout to %s, but the " + "timeout cannot be set to a value less " + "than or equal to 0." % (name, value) + ) + except TypeError: + raise ValueError( + "Timeout value %s was %s, but it must be an " + "int, float or None." % (name, value) + ) from None + + return value + + @classmethod + def from_float(cls, timeout: _TYPE_TIMEOUT) -> Timeout: + """Create a new Timeout from a legacy timeout value. + + The timeout value used by httplib.py sets the same timeout on the + connect(), and recv() socket requests. This creates a :class:`Timeout` + object that sets the individual timeouts to the ``timeout`` value + passed to this function. + + :param timeout: The legacy timeout value. + :type timeout: integer, float, :attr:`urllib3.util.Timeout.DEFAULT_TIMEOUT`, or None + :return: Timeout object + :rtype: :class:`Timeout` + """ + return Timeout(read=timeout, connect=timeout) + + def clone(self) -> Timeout: + """Create a copy of the timeout object + + Timeout properties are stored per-pool but each request needs a fresh + Timeout object to ensure each one has its own start/stop configured. + + :return: a copy of the timeout object + :rtype: :class:`Timeout` + """ + # We can't use copy.deepcopy because that will also create a new object + # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to + # detect the user default. + return Timeout(connect=self._connect, read=self._read, total=self.total) + + def start_connect(self) -> float: + """Start the timeout clock, used during a connect() attempt + + :raises urllib3.exceptions.TimeoutStateError: if you attempt + to start a timer that has been started already. + """ + if self._start_connect is not None: + raise TimeoutStateError("Timeout timer has already been started.") + self._start_connect = time.monotonic() + return self._start_connect + + def get_connect_duration(self) -> float: + """Gets the time elapsed since the call to :meth:`start_connect`. + + :return: Elapsed time in seconds. + :rtype: float + :raises urllib3.exceptions.TimeoutStateError: if you attempt + to get duration for a timer that hasn't been started. + """ + if self._start_connect is None: + raise TimeoutStateError( + "Can't get connect duration for timer that has not started." + ) + return time.monotonic() - self._start_connect + + @property + def connect_timeout(self) -> _TYPE_TIMEOUT: + """Get the value to use when setting a connection timeout. + + This will be a positive float or integer, the value None + (never timeout), or the default system timeout. + + :return: Connect timeout. + :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None + """ + if self.total is None: + return self._connect + + if self._connect is None or self._connect is _DEFAULT_TIMEOUT: + return self.total + + return min(self._connect, self.total) # type: ignore[type-var] + + @property + def read_timeout(self) -> float | None: + """Get the value for the read timeout. + + This assumes some time has elapsed in the connection timeout and + computes the read timeout appropriately. + + If self.total is set, the read timeout is dependent on the amount of + time taken by the connect timeout. If the connection time has not been + established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be + raised. + + :return: Value to use for the read timeout. + :rtype: int, float or None + :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect` + has not yet been called on this object. + """ + if ( + self.total is not None + and self.total is not _DEFAULT_TIMEOUT + and self._read is not None + and self._read is not _DEFAULT_TIMEOUT + ): + # In case the connect timeout has not yet been established. + if self._start_connect is None: + return self._read + return max(0, min(self.total - self.get_connect_duration(), self._read)) + elif self.total is not None and self.total is not _DEFAULT_TIMEOUT: + return max(0, self.total - self.get_connect_duration()) + else: + return self.resolve_default_timeout(self._read) diff --git a/Modules/urllib3/util/url.py b/Modules/urllib3/util/url.py new file mode 100644 index 0000000..d53ea93 --- /dev/null +++ b/Modules/urllib3/util/url.py @@ -0,0 +1,471 @@ +from __future__ import annotations + +import re +import typing + +from ..exceptions import LocationParseError +from .util import to_str + +# We only want to normalize urls with an HTTP(S) scheme. +# urllib3 infers URLs without a scheme (None) to be http. +_NORMALIZABLE_SCHEMES = ("http", "https", None) + +# Almost all of these patterns were derived from the +# 'rfc3986' module: https://github.com/python-hyper/rfc3986 +_PERCENT_RE = re.compile(r"%[a-fA-F0-9]{2}") +_SCHEME_RE = re.compile(r"^(?:[a-zA-Z][a-zA-Z0-9+-]*:|/)") +_URI_RE = re.compile( + r"^(?:([a-zA-Z][a-zA-Z0-9+.-]*):)?" + r"(?://([^\\/?#]*))?" + r"([^?#]*)" + r"(?:\?([^#]*))?" + r"(?:#(.*))?$", + re.UNICODE | re.DOTALL, +) + +_IPV4_PAT = r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}" +_HEX_PAT = "[0-9A-Fa-f]{1,4}" +_LS32_PAT = "(?:{hex}:{hex}|{ipv4})".format(hex=_HEX_PAT, ipv4=_IPV4_PAT) +_subs = {"hex": _HEX_PAT, "ls32": _LS32_PAT} +_variations = [ + # 6( h16 ":" ) ls32 + "(?:%(hex)s:){6}%(ls32)s", + # "::" 5( h16 ":" ) ls32 + "::(?:%(hex)s:){5}%(ls32)s", + # [ h16 ] "::" 4( h16 ":" ) ls32 + "(?:%(hex)s)?::(?:%(hex)s:){4}%(ls32)s", + # [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 + "(?:(?:%(hex)s:)?%(hex)s)?::(?:%(hex)s:){3}%(ls32)s", + # [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 + "(?:(?:%(hex)s:){0,2}%(hex)s)?::(?:%(hex)s:){2}%(ls32)s", + # [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32 + "(?:(?:%(hex)s:){0,3}%(hex)s)?::%(hex)s:%(ls32)s", + # [ *4( h16 ":" ) h16 ] "::" ls32 + "(?:(?:%(hex)s:){0,4}%(hex)s)?::%(ls32)s", + # [ *5( h16 ":" ) h16 ] "::" h16 + "(?:(?:%(hex)s:){0,5}%(hex)s)?::%(hex)s", + # [ *6( h16 ":" ) h16 ] "::" + "(?:(?:%(hex)s:){0,6}%(hex)s)?::", +] + +_UNRESERVED_PAT = r"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._\-~" +_IPV6_PAT = "(?:" + "|".join([x % _subs for x in _variations]) + ")" +_ZONE_ID_PAT = "(?:%25|%)(?:[" + _UNRESERVED_PAT + "]|%[a-fA-F0-9]{2})+" +_IPV6_ADDRZ_PAT = r"\[" + _IPV6_PAT + r"(?:" + _ZONE_ID_PAT + r")?\]" +_REG_NAME_PAT = r"(?:[^\[\]%:/?#]|%[a-fA-F0-9]{2})*" +_TARGET_RE = re.compile(r"^(/[^?#]*)(?:\?([^#]*))?(?:#.*)?$") + +_IPV4_RE = re.compile("^" + _IPV4_PAT + "$") +_IPV6_RE = re.compile("^" + _IPV6_PAT + "$") +_IPV6_ADDRZ_RE = re.compile("^" + _IPV6_ADDRZ_PAT + "$") +_BRACELESS_IPV6_ADDRZ_RE = re.compile("^" + _IPV6_ADDRZ_PAT[2:-2] + "$") +_ZONE_ID_RE = re.compile("(" + _ZONE_ID_PAT + r")\]$") + +_HOST_PORT_PAT = ("^(%s|%s|%s)(?::0*?(|0|[1-9][0-9]{0,4}))?$") % ( + _REG_NAME_PAT, + _IPV4_PAT, + _IPV6_ADDRZ_PAT, +) +_HOST_PORT_RE = re.compile(_HOST_PORT_PAT, re.UNICODE | re.DOTALL) + +_UNRESERVED_CHARS = set( + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-~" +) +_SUB_DELIM_CHARS = set("!$&'()*+,;=") +_USERINFO_CHARS = _UNRESERVED_CHARS | _SUB_DELIM_CHARS | {":"} +_PATH_CHARS = _USERINFO_CHARS | {"@", "/"} +_QUERY_CHARS = _FRAGMENT_CHARS = _PATH_CHARS | {"?"} + + +class Url( + typing.NamedTuple( + "Url", + [ + ("scheme", typing.Optional[str]), + ("auth", typing.Optional[str]), + ("host", typing.Optional[str]), + ("port", typing.Optional[int]), + ("path", typing.Optional[str]), + ("query", typing.Optional[str]), + ("fragment", typing.Optional[str]), + ], + ) +): + """ + Data structure for representing an HTTP URL. Used as a return value for + :func:`parse_url`. Both the scheme and host are normalized as they are + both case-insensitive according to RFC 3986. + """ + + def __new__( # type: ignore[no-untyped-def] + cls, + scheme: str | None = None, + auth: str | None = None, + host: str | None = None, + port: int | None = None, + path: str | None = None, + query: str | None = None, + fragment: str | None = None, + ): + if path and not path.startswith("/"): + path = "/" + path + if scheme is not None: + scheme = scheme.lower() + return super().__new__(cls, scheme, auth, host, port, path, query, fragment) + + @property + def hostname(self) -> str | None: + """For backwards-compatibility with urlparse. We're nice like that.""" + return self.host + + @property + def request_uri(self) -> str: + """Absolute path including the query string.""" + uri = self.path or "/" + + if self.query is not None: + uri += "?" + self.query + + return uri + + @property + def authority(self) -> str | None: + """ + Authority component as defined in RFC 3986 3.2. + This includes userinfo (auth), host and port. + + i.e. + userinfo@host:port + """ + userinfo = self.auth + netloc = self.netloc + if netloc is None or userinfo is None: + return netloc + else: + return f"{userinfo}@{netloc}" + + @property + def netloc(self) -> str | None: + """ + Network location including host and port. + + If you need the equivalent of urllib.parse's ``netloc``, + use the ``authority`` property instead. + """ + if self.host is None: + return None + if self.port: + return f"{self.host}:{self.port}" + return self.host + + @property + def url(self) -> str: + """ + Convert self into a url + + This function should more or less round-trip with :func:`.parse_url`. The + returned url may not be exactly the same as the url inputted to + :func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls + with a blank port will have : removed). + + Example: + + .. code-block:: python + + import urllib3 + + U = urllib3.util.parse_url("https://google.com/mail/") + + print(U.url) + # "https://google.com/mail/" + + print( urllib3.util.Url("https", "username:password", + "host.com", 80, "/path", "query", "fragment" + ).url + ) + # "https://username:password@host.com:80/path?query#fragment" + """ + scheme, auth, host, port, path, query, fragment = self + url = "" + + # We use "is not None" we want things to happen with empty strings (or 0 port) + if scheme is not None: + url += scheme + "://" + if auth is not None: + url += auth + "@" + if host is not None: + url += host + if port is not None: + url += ":" + str(port) + if path is not None: + url += path + if query is not None: + url += "?" + query + if fragment is not None: + url += "#" + fragment + + return url + + def __str__(self) -> str: + return self.url + + +@typing.overload +def _encode_invalid_chars( + component: str, allowed_chars: typing.Container[str] +) -> str: # Abstract + ... + + +@typing.overload +def _encode_invalid_chars( + component: None, allowed_chars: typing.Container[str] +) -> None: # Abstract + ... + + +def _encode_invalid_chars( + component: str | None, allowed_chars: typing.Container[str] +) -> str | None: + """Percent-encodes a URI component without reapplying + onto an already percent-encoded component. + """ + if component is None: + return component + + component = to_str(component) + + # Normalize existing percent-encoded bytes. + # Try to see if the component we're encoding is already percent-encoded + # so we can skip all '%' characters but still encode all others. + component, percent_encodings = _PERCENT_RE.subn( + lambda match: match.group(0).upper(), component + ) + + uri_bytes = component.encode("utf-8", "surrogatepass") + is_percent_encoded = percent_encodings == uri_bytes.count(b"%") + encoded_component = bytearray() + + for i in range(0, len(uri_bytes)): + # Will return a single character bytestring + byte = uri_bytes[i : i + 1] + byte_ord = ord(byte) + if (is_percent_encoded and byte == b"%") or ( + byte_ord < 128 and byte.decode() in allowed_chars + ): + encoded_component += byte + continue + encoded_component.extend(b"%" + (hex(byte_ord)[2:].encode().zfill(2).upper())) + + return encoded_component.decode() + + +def _remove_path_dot_segments(path: str) -> str: + # See http://tools.ietf.org/html/rfc3986#section-5.2.4 for pseudo-code + segments = path.split("/") # Turn the path into a list of segments + output = [] # Initialize the variable to use to store output + + for segment in segments: + # '.' is the current directory, so ignore it, it is superfluous + if segment == ".": + continue + # Anything other than '..', should be appended to the output + if segment != "..": + output.append(segment) + # In this case segment == '..', if we can, we should pop the last + # element + elif output: + output.pop() + + # If the path starts with '/' and the output is empty or the first string + # is non-empty + if path.startswith("/") and (not output or output[0]): + output.insert(0, "") + + # If the path starts with '/.' or '/..' ensure we add one more empty + # string to add a trailing '/' + if path.endswith(("/.", "/..")): + output.append("") + + return "/".join(output) + + +@typing.overload +def _normalize_host(host: None, scheme: str | None) -> None: + ... + + +@typing.overload +def _normalize_host(host: str, scheme: str | None) -> str: + ... + + +def _normalize_host(host: str | None, scheme: str | None) -> str | None: + if host: + if scheme in _NORMALIZABLE_SCHEMES: + is_ipv6 = _IPV6_ADDRZ_RE.match(host) + if is_ipv6: + # IPv6 hosts of the form 'a::b%zone' are encoded in a URL as + # such per RFC 6874: 'a::b%25zone'. Unquote the ZoneID + # separator as necessary to return a valid RFC 4007 scoped IP. + match = _ZONE_ID_RE.search(host) + if match: + start, end = match.span(1) + zone_id = host[start:end] + + if zone_id.startswith("%25") and zone_id != "%25": + zone_id = zone_id[3:] + else: + zone_id = zone_id[1:] + zone_id = _encode_invalid_chars(zone_id, _UNRESERVED_CHARS) + return f"{host[:start].lower()}%{zone_id}{host[end:]}" + else: + return host.lower() + elif not _IPV4_RE.match(host): + return to_str( + b".".join([_idna_encode(label) for label in host.split(".")]), + "ascii", + ) + return host + + +def _idna_encode(name: str) -> bytes: + if not name.isascii(): + try: + import idna + except ImportError: + raise LocationParseError( + "Unable to parse URL without the 'idna' module" + ) from None + + try: + return idna.encode(name.lower(), strict=True, std3_rules=True) + except idna.IDNAError: + raise LocationParseError( + f"Name '{name}' is not a valid IDNA label" + ) from None + + return name.lower().encode("ascii") + + +def _encode_target(target: str) -> str: + """Percent-encodes a request target so that there are no invalid characters + + Pre-condition for this function is that 'target' must start with '/'. + If that is the case then _TARGET_RE will always produce a match. + """ + match = _TARGET_RE.match(target) + if not match: # Defensive: + raise LocationParseError(f"{target!r} is not a valid request URI") + + path, query = match.groups() + encoded_target = _encode_invalid_chars(path, _PATH_CHARS) + if query is not None: + query = _encode_invalid_chars(query, _QUERY_CHARS) + encoded_target += "?" + query + return encoded_target + + +def parse_url(url: str) -> Url: + """ + Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is + performed to parse incomplete urls. Fields not provided will be None. + This parser is RFC 3986 and RFC 6874 compliant. + + The parser logic and helper functions are based heavily on + work done in the ``rfc3986`` module. + + :param str url: URL to parse into a :class:`.Url` namedtuple. + + Partly backwards-compatible with :mod:`urllib.parse`. + + Example: + + .. code-block:: python + + import urllib3 + + print( urllib3.util.parse_url('http://google.com/mail/')) + # Url(scheme='http', host='google.com', port=None, path='/mail/', ...) + + print( urllib3.util.parse_url('google.com:80')) + # Url(scheme=None, host='google.com', port=80, path=None, ...) + + print( urllib3.util.parse_url('/foo?bar')) + # Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...) + """ + if not url: + # Empty + return Url() + + source_url = url + if not _SCHEME_RE.search(url): + url = "//" + url + + scheme: str | None + authority: str | None + auth: str | None + host: str | None + port: str | None + port_int: int | None + path: str | None + query: str | None + fragment: str | None + + try: + scheme, authority, path, query, fragment = _URI_RE.match(url).groups() # type: ignore[union-attr] + normalize_uri = scheme is None or scheme.lower() in _NORMALIZABLE_SCHEMES + + if scheme: + scheme = scheme.lower() + + if authority: + auth, _, host_port = authority.rpartition("@") + auth = auth or None + host, port = _HOST_PORT_RE.match(host_port).groups() # type: ignore[union-attr] + if auth and normalize_uri: + auth = _encode_invalid_chars(auth, _USERINFO_CHARS) + if port == "": + port = None + else: + auth, host, port = None, None, None + + if port is not None: + port_int = int(port) + if not (0 <= port_int <= 65535): + raise LocationParseError(url) + else: + port_int = None + + host = _normalize_host(host, scheme) + + if normalize_uri and path: + path = _remove_path_dot_segments(path) + path = _encode_invalid_chars(path, _PATH_CHARS) + if normalize_uri and query: + query = _encode_invalid_chars(query, _QUERY_CHARS) + if normalize_uri and fragment: + fragment = _encode_invalid_chars(fragment, _FRAGMENT_CHARS) + + except (ValueError, AttributeError) as e: + raise LocationParseError(source_url) from e + + # For the sake of backwards compatibility we put empty + # string values for path if there are any defined values + # beyond the path in the URL. + # TODO: Remove this when we break backwards compatibility. + if not path: + if query is not None or fragment is not None: + path = "" + else: + path = None + + return Url( + scheme=scheme, + auth=auth, + host=host, + port=port_int, + path=path, + query=query, + fragment=fragment, + ) diff --git a/Modules/urllib3/util/util.py b/Modules/urllib3/util/util.py new file mode 100644 index 0000000..35c77e4 --- /dev/null +++ b/Modules/urllib3/util/util.py @@ -0,0 +1,42 @@ +from __future__ import annotations + +import typing +from types import TracebackType + + +def to_bytes( + x: str | bytes, encoding: str | None = None, errors: str | None = None +) -> bytes: + if isinstance(x, bytes): + return x + elif not isinstance(x, str): + raise TypeError(f"not expecting type {type(x).__name__}") + if encoding or errors: + return x.encode(encoding or "utf-8", errors=errors or "strict") + return x.encode() + + +def to_str( + x: str | bytes, encoding: str | None = None, errors: str | None = None +) -> str: + if isinstance(x, str): + return x + elif not isinstance(x, bytes): + raise TypeError(f"not expecting type {type(x).__name__}") + if encoding or errors: + return x.decode(encoding or "utf-8", errors=errors or "strict") + return x.decode() + + +def reraise( + tp: type[BaseException] | None, + value: BaseException, + tb: TracebackType | None = None, +) -> typing.NoReturn: + try: + if value.__traceback__ is not tb: + raise value.with_traceback(tb) + raise value + finally: + value = None # type: ignore[assignment] + tb = None diff --git a/Modules/urllib3/util/wait.py b/Modules/urllib3/util/wait.py new file mode 100644 index 0000000..aeca0c7 --- /dev/null +++ b/Modules/urllib3/util/wait.py @@ -0,0 +1,124 @@ +from __future__ import annotations + +import select +import socket +from functools import partial + +__all__ = ["wait_for_read", "wait_for_write"] + + +# How should we wait on sockets? +# +# There are two types of APIs you can use for waiting on sockets: the fancy +# modern stateful APIs like epoll/kqueue, and the older stateless APIs like +# select/poll. The stateful APIs are more efficient when you have a lots of +# sockets to keep track of, because you can set them up once and then use them +# lots of times. But we only ever want to wait on a single socket at a time +# and don't want to keep track of state, so the stateless APIs are actually +# more efficient. So we want to use select() or poll(). +# +# Now, how do we choose between select() and poll()? On traditional Unixes, +# select() has a strange calling convention that makes it slow, or fail +# altogether, for high-numbered file descriptors. The point of poll() is to fix +# that, so on Unixes, we prefer poll(). +# +# On Windows, there is no poll() (or at least Python doesn't provide a wrapper +# for it), but that's OK, because on Windows, select() doesn't have this +# strange calling convention; plain select() works fine. +# +# So: on Windows we use select(), and everywhere else we use poll(). We also +# fall back to select() in case poll() is somehow broken or missing. + + +def select_wait_for_socket( + sock: socket.socket, + read: bool = False, + write: bool = False, + timeout: float | None = None, +) -> bool: + if not read and not write: + raise RuntimeError("must specify at least one of read=True, write=True") + rcheck = [] + wcheck = [] + if read: + rcheck.append(sock) + if write: + wcheck.append(sock) + # When doing a non-blocking connect, most systems signal success by + # marking the socket writable. Windows, though, signals success by marked + # it as "exceptional". We paper over the difference by checking the write + # sockets for both conditions. (The stdlib selectors module does the same + # thing.) + fn = partial(select.select, rcheck, wcheck, wcheck) + rready, wready, xready = fn(timeout) + return bool(rready or wready or xready) + + +def poll_wait_for_socket( + sock: socket.socket, + read: bool = False, + write: bool = False, + timeout: float | None = None, +) -> bool: + if not read and not write: + raise RuntimeError("must specify at least one of read=True, write=True") + mask = 0 + if read: + mask |= select.POLLIN + if write: + mask |= select.POLLOUT + poll_obj = select.poll() + poll_obj.register(sock, mask) + + # For some reason, poll() takes timeout in milliseconds + def do_poll(t: float | None) -> list[tuple[int, int]]: + if t is not None: + t *= 1000 + return poll_obj.poll(t) + + return bool(do_poll(timeout)) + + +def _have_working_poll() -> bool: + # Apparently some systems have a select.poll that fails as soon as you try + # to use it, either due to strange configuration or broken monkeypatching + # from libraries like eventlet/greenlet. + try: + poll_obj = select.poll() + poll_obj.poll(0) + except (AttributeError, OSError): + return False + else: + return True + + +def wait_for_socket( + sock: socket.socket, + read: bool = False, + write: bool = False, + timeout: float | None = None, +) -> bool: + # We delay choosing which implementation to use until the first time we're + # called. We could do it at import time, but then we might make the wrong + # decision if someone goes wild with monkeypatching select.poll after + # we're imported. + global wait_for_socket + if _have_working_poll(): + wait_for_socket = poll_wait_for_socket + elif hasattr(select, "select"): + wait_for_socket = select_wait_for_socket + return wait_for_socket(sock, read, write, timeout) + + +def wait_for_read(sock: socket.socket, timeout: float | None = None) -> bool: + """Waits for reading to be available on a given socket. + Returns True if the socket is readable, or False if the timeout expired. + """ + return wait_for_socket(sock, read=True, timeout=timeout) + + +def wait_for_write(sock: socket.socket, timeout: float | None = None) -> bool: + """Waits for writing to be available on a given socket. + Returns True if the socket is readable, or False if the timeout expired. + """ + return wait_for_socket(sock, write=True, timeout=timeout) diff --git a/Modules/vdf/LICENSE b/Modules/vdf/LICENSE new file mode 100644 index 0000000..ee59795 --- /dev/null +++ b/Modules/vdf/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2015 Rossen Georgiev + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/Modules/vdf/__init__.py b/Modules/vdf/__init__.py new file mode 100644 index 0000000..8b64d5d --- /dev/null +++ b/Modules/vdf/__init__.py @@ -0,0 +1,519 @@ +""" +Module for deserializing/serializing to and from VDF +""" +__version__ = "3.4" +__author__ = "Rossen Georgiev" + +import re +import sys +import struct +from binascii import crc32 +from io import BytesIO +from io import StringIO as unicodeIO + +try: + from collections.abc import Mapping +except: + from collections import Mapping + +# Py2 & Py3 compatibility +if sys.version_info[0] >= 3: + string_type = str + int_type = int + BOMS = '\ufffe\ufeff' + + def strip_bom(line): + return line.lstrip(BOMS) +else: + from StringIO import StringIO as strIO + string_type = basestring + int_type = long + BOMS = '\xef\xbb\xbf\xff\xfe\xfe\xff' + BOMS_UNICODE = '\\ufffe\\ufeff'.decode('unicode-escape') + + def strip_bom(line): + return line.lstrip(BOMS if isinstance(line, str) else BOMS_UNICODE) + +# string escaping +_unescape_char_map = { + r"\n": "\n", + r"\t": "\t", + r"\v": "\v", + r"\b": "\b", + r"\r": "\r", + r"\f": "\f", + r"\a": "\a", + r"\\": "\\", + r"\?": "?", + r"\"": "\"", + r"\'": "\'", +} +_escape_char_map = {v: k for k, v in _unescape_char_map.items()} + +def _re_escape_match(m): + return _escape_char_map[m.group()] + +def _re_unescape_match(m): + return _unescape_char_map[m.group()] + +def _escape(text): + return re.sub(r"[\n\t\v\b\r\f\a\\\?\"']", _re_escape_match, text) + +def _unescape(text): + return re.sub(r"(\\n|\\t|\\v|\\b|\\r|\\f|\\a|\\\\|\\\?|\\\"|\\')", _re_unescape_match, text) + +# parsing and dumping for KV1 +def parse(fp, mapper=dict, merge_duplicate_keys=True, escaped=True): + """ + Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a VDF) + to a Python object. + + ``mapper`` specifies the Python object used after deserializetion. ``dict` is + used by default. Alternatively, ``collections.OrderedDict`` can be used if you + wish to preserve key order. Or any object that acts like a ``dict``. + + ``merge_duplicate_keys`` when ``True`` will merge multiple KeyValue lists with the + same key into one instead of overwriting. You can se this to ``False`` if you are + using ``VDFDict`` and need to preserve the duplicates. + """ + if not issubclass(mapper, Mapping): + raise TypeError("Expected mapper to be subclass of dict, got %s" % type(mapper)) + if not hasattr(fp, 'readline'): + raise TypeError("Expected fp to be a file-like object supporting line iteration") + + stack = [mapper()] + expect_bracket = False + + re_keyvalue = re.compile(r'^("(?P(?:\\.|[^\\"])*)"|(?P#?[a-z0-9\-\_\\\?$%<>]+))' + r'([ \t]*(' + r'"(?P(?:\\.|[^\\"])*)(?P")?' + r'|(?P(?:(? ])+)' + r'|(?P{[ \t]*)(?P})?' + r'))?', + flags=re.I) + + for lineno, line in enumerate(fp, 1): + if lineno == 1: + line = strip_bom(line) + + line = line.lstrip() + + # skip empty and comment lines + if line == "" or line[0] == '/': + continue + + # one level deeper + if line[0] == "{": + expect_bracket = False + continue + + if expect_bracket: + raise SyntaxError("vdf.parse: expected openning bracket", + (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 1, line)) + + # one level back + if line[0] == "}": + if len(stack) > 1: + stack.pop() + continue + + raise SyntaxError("vdf.parse: one too many closing parenthasis", + (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 0, line)) + + # parse keyvalue pairs + while True: + match = re_keyvalue.match(line) + + if not match: + try: + line += next(fp) + continue + except StopIteration: + raise SyntaxError("vdf.parse: unexpected EOF (open key quote?)", + (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 0, line)) + + key = match.group('key') if match.group('qkey') is None else match.group('qkey') + val = match.group('qval') + if val is None: + val = match.group('val') + if val is not None: + val = val.rstrip() + if val == "": + val = None + + if escaped: + key = _unescape(key) + + # we have a key with value in parenthesis, so we make a new dict obj (level deeper) + if val is None: + if merge_duplicate_keys and key in stack[-1]: + _m = stack[-1][key] + # we've descended a level deeper, if value is str, we have to overwrite it to mapper + if not isinstance(_m, mapper): + _m = stack[-1][key] = mapper() + else: + _m = mapper() + stack[-1][key] = _m + + if match.group('eblock') is None: + # only expect a bracket if it's not already closed or on the same line + stack.append(_m) + if match.group('sblock') is None: + expect_bracket = True + + # we've matched a simple keyvalue pair, map it to the last dict obj in the stack + else: + # if the value is line consume one more line and try to match again, + # until we get the KeyValue pair + if match.group('vq_end') is None and match.group('qval') is not None: + try: + line += next(fp) + continue + except StopIteration: + raise SyntaxError("vdf.parse: unexpected EOF (open quote for value?)", + (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 0, line)) + + stack[-1][key] = _unescape(val) if escaped else val + + # exit the loop + break + + if len(stack) != 1: + raise SyntaxError("vdf.parse: unclosed parenthasis or quotes (EOF)", + (getattr(fp, 'name', '<%s>' % fp.__class__.__name__), lineno, 0, line)) + + return stack.pop() + + +def loads(s, **kwargs): + """ + Deserialize ``s`` (a ``str`` or ``unicode`` instance containing a JSON + document) to a Python object. + """ + if not isinstance(s, string_type): + raise TypeError("Expected s to be a str, got %s" % type(s)) + + try: + fp = unicodeIO(s) + except TypeError: + fp = strIO(s) + + return parse(fp, **kwargs) + + +def load(fp, **kwargs): + """ + Deserialize ``fp`` (a ``.readline()``-supporting file-like object containing + a JSON document) to a Python object. + """ + return parse(fp, **kwargs) + + +def dumps(obj, pretty=False, escaped=True): + """ + Serialize ``obj`` to a VDF formatted ``str``. + """ + if not isinstance(obj, Mapping): + raise TypeError("Expected data to be an instance of``dict``") + if not isinstance(pretty, bool): + raise TypeError("Expected pretty to be of type bool") + if not isinstance(escaped, bool): + raise TypeError("Expected escaped to be of type bool") + + return ''.join(_dump_gen(obj, pretty, escaped)) + + +def dump(obj, fp, pretty=False, escaped=True): + """ + Serialize ``obj`` as a VDF formatted stream to ``fp`` (a + ``.write()``-supporting file-like object). + """ + if not isinstance(obj, Mapping): + raise TypeError("Expected data to be an instance of``dict``") + if not hasattr(fp, 'write'): + raise TypeError("Expected fp to have write() method") + if not isinstance(pretty, bool): + raise TypeError("Expected pretty to be of type bool") + if not isinstance(escaped, bool): + raise TypeError("Expected escaped to be of type bool") + + for chunk in _dump_gen(obj, pretty, escaped): + fp.write(chunk) + + +def _dump_gen(data, pretty=False, escaped=True, level=0): + indent = "\t" + line_indent = "" + + if pretty: + line_indent = indent * level + + for key, value in data.items(): + if escaped and isinstance(key, string_type): + key = _escape(key) + + if isinstance(value, Mapping): + yield '%s"%s"\n%s{\n' % (line_indent, key, line_indent) + for chunk in _dump_gen(value, pretty, escaped, level+1): + yield chunk + yield "%s}\n" % line_indent + else: + if escaped and isinstance(value, string_type): + value = _escape(value) + + yield '%s"%s" "%s"\n' % (line_indent, key, value) + + +# binary VDF +class BASE_INT(int_type): + def __repr__(self): + return "%s(%d)" % (self.__class__.__name__, self) + +class UINT_64(BASE_INT): + pass + +class INT_64(BASE_INT): + pass + +class POINTER(BASE_INT): + pass + +class COLOR(BASE_INT): + pass + +BIN_NONE = b'\x00' +BIN_STRING = b'\x01' +BIN_INT32 = b'\x02' +BIN_FLOAT32 = b'\x03' +BIN_POINTER = b'\x04' +BIN_WIDESTRING = b'\x05' +BIN_COLOR = b'\x06' +BIN_UINT64 = b'\x07' +BIN_END = b'\x08' +BIN_INT64 = b'\x0A' +BIN_END_ALT = b'\x0B' + +def binary_loads(b, mapper=dict, merge_duplicate_keys=True, alt_format=False, raise_on_remaining=True): + """ + Deserialize ``b`` (``bytes`` containing a VDF in "binary form") + to a Python object. + + ``mapper`` specifies the Python object used after deserializetion. ``dict` is + used by default. Alternatively, ``collections.OrderedDict`` can be used if you + wish to preserve key order. Or any object that acts like a ``dict``. + + ``merge_duplicate_keys`` when ``True`` will merge multiple KeyValue lists with the + same key into one instead of overwriting. You can se this to ``False`` if you are + using ``VDFDict`` and need to preserve the duplicates. + """ + if not isinstance(b, bytes): + raise TypeError("Expected s to be bytes, got %s" % type(b)) + + return binary_load(BytesIO(b), mapper, merge_duplicate_keys, alt_format, raise_on_remaining) + +def binary_load(fp, mapper=dict, merge_duplicate_keys=True, alt_format=False, raise_on_remaining=False): + """ + Deserialize ``fp`` (a ``.read()``-supporting file-like object containing + binary VDF) to a Python object. + + ``mapper`` specifies the Python object used after deserializetion. ``dict` is + used by default. Alternatively, ``collections.OrderedDict`` can be used if you + wish to preserve key order. Or any object that acts like a ``dict``. + + ``merge_duplicate_keys`` when ``True`` will merge multiple KeyValue lists with the + same key into one instead of overwriting. You can se this to ``False`` if you are + using ``VDFDict`` and need to preserve the duplicates. + """ + if not hasattr(fp, 'read') or not hasattr(fp, 'tell') or not hasattr(fp, 'seek'): + raise TypeError("Expected fp to be a file-like object with tell()/seek() and read() returning bytes") + if not issubclass(mapper, Mapping): + raise TypeError("Expected mapper to be subclass of dict, got %s" % type(mapper)) + + # helpers + int32 = struct.Struct(' 1: + stack.pop() + continue + break + + key = read_string(fp) + + if t == BIN_NONE: + if merge_duplicate_keys and key in stack[-1]: + _m = stack[-1][key] + else: + _m = mapper() + stack[-1][key] = _m + stack.append(_m) + elif t == BIN_STRING: + stack[-1][key] = read_string(fp) + elif t == BIN_WIDESTRING: + stack[-1][key] = read_string(fp, wide=True) + elif t in (BIN_INT32, BIN_POINTER, BIN_COLOR): + val = int32.unpack(fp.read(int32.size))[0] + + if t == BIN_POINTER: + val = POINTER(val) + elif t == BIN_COLOR: + val = COLOR(val) + + stack[-1][key] = val + elif t == BIN_UINT64: + stack[-1][key] = UINT_64(uint64.unpack(fp.read(int64.size))[0]) + elif t == BIN_INT64: + stack[-1][key] = INT_64(int64.unpack(fp.read(int64.size))[0]) + elif t == BIN_FLOAT32: + stack[-1][key] = float32.unpack(fp.read(float32.size))[0] + else: + raise SyntaxError("Unknown data type at offset %d: %s" % (fp.tell() - 1, repr(t))) + + if len(stack) != 1: + raise SyntaxError("Reached EOF, but Binary VDF is incomplete") + if raise_on_remaining and fp.read(1) != b'': + fp.seek(-1, 1) + raise SyntaxError("Binary VDF ended at offset %d, but there is more data remaining" % (fp.tell() - 1)) + + return stack.pop() + +def binary_dumps(obj, alt_format=False): + """ + Serialize ``obj`` to a binary VDF formatted ``bytes``. + """ + buf = BytesIO() + binary_dump(obj, buf, alt_format) + return buf.getvalue() + +def binary_dump(obj, fp, alt_format=False): + """ + Serialize ``obj`` to a binary VDF formatted ``bytes`` and write it to ``fp`` filelike object + """ + if not isinstance(obj, Mapping): + raise TypeError("Expected obj to be type of Mapping") + if not hasattr(fp, 'write'): + raise TypeError("Expected fp to have write() method") + + for chunk in _binary_dump_gen(obj, alt_format=alt_format): + fp.write(chunk) + +def _binary_dump_gen(obj, level=0, alt_format=False): + if level == 0 and len(obj) == 0: + return + + int32 = struct.Struct('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 Date: Wed, 21 Feb 2024 00:53:32 -0600 Subject: [PATCH 10/15] build: move docker to top-level directory --- .devcontainer/devcontainer.json | 2 +- .devcontainer/requirements.txt | 21 -------------------- .devcontainer/.dockerignore => .dockerignore | 0 .devcontainer/Dockerfile => Dockerfile | 0 4 files changed, 1 insertion(+), 22 deletions(-) delete mode 100644 .devcontainer/requirements.txt rename .devcontainer/.dockerignore => .dockerignore (100%) rename .devcontainer/Dockerfile => Dockerfile (100%) diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 563b16e..a9663a2 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -3,7 +3,7 @@ { "name": "Dev Environment", "build": { - "dockerfile": "Dockerfile" + "dockerfile": "../Dockerfile" }, "customizations": { "vscode": { diff --git a/.devcontainer/requirements.txt b/.devcontainer/requirements.txt deleted file mode 100644 index 613bf2c..0000000 --- a/.devcontainer/requirements.txt +++ /dev/null @@ -1,21 +0,0 @@ -asttokens==2.2.1 -backcall==0.2.0 -decorator==5.1.1 -executing==1.2.0 -ipython==8.14.0 -jedi==0.19.0 -markdown-it-py==3.0.0 -matplotlib-inline==0.1.6 -mdurl==0.1.2 -parso==0.8.3 -pexpect==4.8.0 -pickleshare==0.7.5 -prompt-toolkit==3.0.39 -ptyprocess==0.7.0 -pure-eval==0.2.2 -Pygments==2.16.1 -rich==13.5.2 -six==1.16.0 -stack-data==0.6.2 -traitlets==5.9.0 -wcwidth==0.2.6 diff --git a/.devcontainer/.dockerignore b/.dockerignore similarity index 100% rename from .devcontainer/.dockerignore rename to .dockerignore diff --git a/.devcontainer/Dockerfile b/Dockerfile similarity index 100% rename from .devcontainer/Dockerfile rename to Dockerfile From e14e3a252783190a532639b25180b96f938b9d8b Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 00:56:38 -0600 Subject: [PATCH 11/15] chore: fix eol --- release-please-config.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/release-please-config.json b/release-please-config.json index 624fd83..4ef1081 100644 --- a/release-please-config.json +++ b/release-please-config.json @@ -10,4 +10,4 @@ } }, "$schema": "https://raw.githubusercontent.com/googleapis/release-please/main/schemas/config.json" -} \ No newline at end of file +} From 7fbad806663444e47fc32da886530aa5e055fea5 Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 01:08:53 -0600 Subject: [PATCH 12/15] ci: add commitizen --- .gitignore | 131 +++ .tool-versions | 1 + package-lock.json | 2009 +++++++++++++++++++++++++++++++++++++++++++++ package.json | 10 + 4 files changed, 2151 insertions(+) create mode 100644 package-lock.json create mode 100644 package.json diff --git a/.gitignore b/.gitignore index bbd4d9f..ce754dd 100644 --- a/.gitignore +++ b/.gitignore @@ -161,3 +161,134 @@ cython_debug/ # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ + +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +lerna-debug.log* +.pnpm-debug.log* + +# Diagnostic reports (https://nodejs.org/api/report.html) +report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json + +# Runtime data +pids +*.pid +*.seed +*.pid.lock + +# Directory for instrumented libs generated by jscoverage/JSCover +lib-cov + +# Coverage directory used by tools like istanbul +coverage +*.lcov + +# nyc test coverage +.nyc_output + +# Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files) +.grunt + +# Bower dependency directory (https://bower.io/) +bower_components + +# node-waf configuration +.lock-wscript + +# Compiled binary addons (https://nodejs.org/api/addons.html) +build/Release + +# Dependency directories +node_modules/ +jspm_packages/ + +# Snowpack dependency directory (https://snowpack.dev/) +web_modules/ + +# TypeScript cache +*.tsbuildinfo + +# Optional npm cache directory +.npm + +# Optional eslint cache +.eslintcache + +# Optional stylelint cache +.stylelintcache + +# Microbundle cache +.rpt2_cache/ +.rts2_cache_cjs/ +.rts2_cache_es/ +.rts2_cache_umd/ + +# Optional REPL history +.node_repl_history + +# Output of 'npm pack' +*.tgz + +# Yarn Integrity file +.yarn-integrity + +# dotenv environment variable files +.env +.env.development.local +.env.test.local +.env.production.local +.env.local + +# parcel-bundler cache (https://parceljs.org/) +.cache +.parcel-cache + +# Next.js build output +.next +out + +# Nuxt.js build / generate output +.nuxt +dist + +# Gatsby files +.cache/ +# Comment in the public line in if your project uses Gatsby and not Next.js +# https://nextjs.org/blog/next-9-1#public-directory-support +# public + +# vuepress build output +.vuepress/dist + +# vuepress v2.x temp and cache directory +.temp +.cache + +# Docusaurus cache and generated files +.docusaurus + +# Serverless directories +.serverless/ + +# FuseBox cache +.fusebox/ + +# DynamoDB Local files +.dynamodb/ + +# TernJS port file +.tern-port + +# Stores VSCode versions used for testing VSCode extensions +.vscode-test + +# yarn v2 +.yarn/cache +.yarn/unplugged +.yarn/build-state.yml +.yarn/install-state.gz +.pnp.* diff --git a/.tool-versions b/.tool-versions index d5c9bbe..df9620e 100644 --- a/.tool-versions +++ b/.tool-versions @@ -1,2 +1,3 @@ python 3.11.6 poetry 1.7.1 +nodejs 21.4.0 diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..4e4ae59 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,2009 @@ +{ + "name": "non_steam_launchers", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "devDependencies": { + "cz-conventional-changelog": "^3.3.0" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.23.5", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.23.5.tgz", + "integrity": "sha512-CgH3s1a96LipHCmSUmYFPwY7MNx8C3avkq7i4Wl3cfa662ldtUe4VM1TPXX70pfmrlWTb6jLqTYrZyT2ZTJBgA==", + "dev": true, + "optional": true, + "dependencies": { + "@babel/highlight": "^7.23.4", + "chalk": "^2.4.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.22.20", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.22.20.tgz", + "integrity": "sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==", + "dev": true, + "optional": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight": { + "version": "7.23.4", + "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.23.4.tgz", + "integrity": "sha512-acGdbYSfp2WheJoJm/EBBBLh/ID8KDc64ISZ9DYtBmC8/Q204PZJLHyzeB5qMzJ5trcOkybd78M4x2KWsUq++A==", + "dev": true, + "optional": true, + "dependencies": { + "@babel/helper-validator-identifier": "^7.22.20", + "chalk": "^2.4.2", + "js-tokens": "^4.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@commitlint/config-validator": { + "version": "18.6.1", + "resolved": "https://registry.npmjs.org/@commitlint/config-validator/-/config-validator-18.6.1.tgz", + "integrity": "sha512-05uiToBVfPhepcQWE1ZQBR/Io3+tb3gEotZjnI4tTzzPk16NffN6YABgwFQCLmzZefbDcmwWqJWc2XT47q7Znw==", + "dev": true, + "optional": true, + "dependencies": { + "@commitlint/types": "^18.6.1", + "ajv": "^8.11.0" + }, + "engines": { + "node": ">=v18" + } + }, + "node_modules/@commitlint/execute-rule": { + "version": "18.6.1", + "resolved": "https://registry.npmjs.org/@commitlint/execute-rule/-/execute-rule-18.6.1.tgz", + "integrity": "sha512-7s37a+iWyJiGUeMFF6qBlyZciUkF8odSAnHijbD36YDctLhGKoYltdvuJ/AFfRm6cBLRtRk9cCVPdsEFtt/2rg==", + "dev": true, + "optional": true, + "engines": { + "node": ">=v18" + } + }, + "node_modules/@commitlint/load": { + "version": "18.6.1", + "resolved": "https://registry.npmjs.org/@commitlint/load/-/load-18.6.1.tgz", + "integrity": "sha512-p26x8734tSXUHoAw0ERIiHyW4RaI4Bj99D8YgUlVV9SedLf8hlWAfyIFhHRIhfPngLlCe0QYOdRKYFt8gy56TA==", + "dev": true, + "optional": true, + "dependencies": { + "@commitlint/config-validator": "^18.6.1", + "@commitlint/execute-rule": "^18.6.1", + "@commitlint/resolve-extends": "^18.6.1", + "@commitlint/types": "^18.6.1", + "chalk": "^4.1.0", + "cosmiconfig": "^8.3.6", + "cosmiconfig-typescript-loader": "^5.0.0", + "lodash.isplainobject": "^4.0.6", + "lodash.merge": "^4.6.2", + "lodash.uniq": "^4.5.0", + "resolve-from": "^5.0.0" + }, + "engines": { + "node": ">=v18" + } + }, + "node_modules/@commitlint/load/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "optional": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@commitlint/load/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "optional": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/@commitlint/load/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "optional": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@commitlint/load/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "optional": true + }, + "node_modules/@commitlint/load/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/@commitlint/load/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "optional": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@commitlint/resolve-extends": { + "version": "18.6.1", + "resolved": "https://registry.npmjs.org/@commitlint/resolve-extends/-/resolve-extends-18.6.1.tgz", + "integrity": "sha512-ifRAQtHwK+Gj3Bxj/5chhc4L2LIc3s30lpsyW67yyjsETR6ctHAHRu1FSpt0KqahK5xESqoJ92v6XxoDRtjwEQ==", + "dev": true, + "optional": true, + "dependencies": { + "@commitlint/config-validator": "^18.6.1", + "@commitlint/types": "^18.6.1", + "import-fresh": "^3.0.0", + "lodash.mergewith": "^4.6.2", + "resolve-from": "^5.0.0", + "resolve-global": "^1.0.0" + }, + "engines": { + "node": ">=v18" + } + }, + "node_modules/@commitlint/types": { + "version": "18.6.1", + "resolved": "https://registry.npmjs.org/@commitlint/types/-/types-18.6.1.tgz", + "integrity": "sha512-gwRLBLra/Dozj2OywopeuHj2ac26gjGkz2cZ+86cTJOdtWfiRRr4+e77ZDAGc6MDWxaWheI+mAV5TLWWRwqrFg==", + "dev": true, + "optional": true, + "dependencies": { + "chalk": "^4.1.0" + }, + "engines": { + "node": ">=v18" + } + }, + "node_modules/@commitlint/types/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "optional": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/@commitlint/types/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "optional": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/@commitlint/types/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "optional": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/@commitlint/types/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true, + "optional": true + }, + "node_modules/@commitlint/types/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/@commitlint/types/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "optional": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/@types/node": { + "version": "20.11.19", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.11.19.tgz", + "integrity": "sha512-7xMnVEcZFu0DikYjWOlRq7NTPETrm7teqUT2WkQjrTIkEgUyyGdWsj/Zg8bEJt5TNklzbPD1X3fqfsHw3SpapQ==", + "dev": true, + "optional": true, + "peer": true, + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/ajv": { + "version": "8.12.0", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.12.0.tgz", + "integrity": "sha512-sRu1kpcO9yLtYxBKvqfTeh9KzZEwO3STyX1HT+4CaDzC6HpTGYhIhPIzj9XuKU7KYDwnaeh5hcOwjy1QuJzBPA==", + "dev": true, + "optional": true, + "dependencies": { + "fast-deep-equal": "^3.1.1", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ansi-escapes": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-4.3.2.tgz", + "integrity": "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==", + "dev": true, + "dependencies": { + "type-fest": "^0.21.3" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "dev": true, + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/argparse": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz", + "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==", + "dev": true, + "optional": true + }, + "node_modules/at-least-node": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz", + "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==", + "dev": true, + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz", + "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==", + "dev": true + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/bl": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/bl/-/bl-4.1.0.tgz", + "integrity": "sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==", + "dev": true, + "dependencies": { + "buffer": "^5.5.0", + "inherits": "^2.0.4", + "readable-stream": "^3.4.0" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "dev": true, + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz", + "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==", + "dev": true, + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/buffer": { + "version": "5.7.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz", + "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.1.13" + } + }, + "node_modules/cachedir": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/cachedir/-/cachedir-2.3.0.tgz", + "integrity": "sha512-A+Fezp4zxnit6FanDmv9EqXNAi3vt9DWp51/71UEhXukb7QUuvtv9344h91dyAxuTLoSYJFU299qzR3tzwPAhw==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "dev": true, + "optional": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/chalk": { + "version": "2.4.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", + "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", + "dev": true, + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/chardet": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/chardet/-/chardet-0.7.0.tgz", + "integrity": "sha512-mT8iDcrh03qDGRRmoA2hmBJnxpllMR+0/0qlzjqZES6NdiWDcZkCNAk4rPFZ9Q85r27unkiNNg8ZOiwZXBHwcA==", + "dev": true + }, + "node_modules/cli-cursor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-3.1.0.tgz", + "integrity": "sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==", + "dev": true, + "dependencies": { + "restore-cursor": "^3.1.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/cli-spinners": { + "version": "2.9.2", + "resolved": "https://registry.npmjs.org/cli-spinners/-/cli-spinners-2.9.2.tgz", + "integrity": "sha512-ywqV+5MmyL4E7ybXgKys4DugZbX0FC6LnwrhjuykIjnK9k8OQacQ7axGKnjDXWNhns0xot3bZI5h55H8yo9cJg==", + "dev": true, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-width": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/cli-width/-/cli-width-3.0.0.tgz", + "integrity": "sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==", + "dev": true, + "engines": { + "node": ">= 10" + } + }, + "node_modules/clone": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/clone/-/clone-1.0.4.tgz", + "integrity": "sha512-JQHZ2QMW6l3aH/j6xCqQThY/9OH4D/9ls34cgkUBiEeocRTU04tHfKPBsUK1PqZCUQM7GiA0IIXJSuXHI64Kbg==", + "dev": true, + "engines": { + "node": ">=0.8" + } + }, + "node_modules/color-convert": { + "version": "1.9.3", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", + "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", + "dev": true, + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", + "dev": true + }, + "node_modules/commitizen": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/commitizen/-/commitizen-4.3.0.tgz", + "integrity": "sha512-H0iNtClNEhT0fotHvGV3E9tDejDeS04sN1veIebsKYGMuGscFaswRoYJKmT3eW85eIJAs0F28bG2+a/9wCOfPw==", + "dev": true, + "dependencies": { + "cachedir": "2.3.0", + "cz-conventional-changelog": "3.3.0", + "dedent": "0.7.0", + "detect-indent": "6.1.0", + "find-node-modules": "^2.1.2", + "find-root": "1.1.0", + "fs-extra": "9.1.0", + "glob": "7.2.3", + "inquirer": "8.2.5", + "is-utf8": "^0.2.1", + "lodash": "4.17.21", + "minimist": "1.2.7", + "strip-bom": "4.0.0", + "strip-json-comments": "3.1.1" + }, + "bin": { + "commitizen": "bin/commitizen", + "cz": "bin/git-cz", + "git-cz": "bin/git-cz" + }, + "engines": { + "node": ">= 12" + } + }, + "node_modules/concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==", + "dev": true + }, + "node_modules/conventional-commit-types": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/conventional-commit-types/-/conventional-commit-types-3.0.0.tgz", + "integrity": "sha512-SmmCYnOniSsAa9GqWOeLqc179lfr5TRu5b4QFDkbsrJ5TZjPJx85wtOr3zn+1dbeNiXDKGPbZ72IKbPhLXh/Lg==", + "dev": true + }, + "node_modules/cosmiconfig": { + "version": "8.3.6", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz", + "integrity": "sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==", + "dev": true, + "optional": true, + "dependencies": { + "import-fresh": "^3.3.0", + "js-yaml": "^4.1.0", + "parse-json": "^5.2.0", + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/d-fischer" + }, + "peerDependencies": { + "typescript": ">=4.9.5" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/cosmiconfig-typescript-loader": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/cosmiconfig-typescript-loader/-/cosmiconfig-typescript-loader-5.0.0.tgz", + "integrity": "sha512-+8cK7jRAReYkMwMiG+bxhcNKiHJDM6bR9FD/nGBXOWdMLuYawjF5cGrtLilJ+LGd3ZjCXnJjR5DkfWPoIVlqJA==", + "dev": true, + "optional": true, + "dependencies": { + "jiti": "^1.19.1" + }, + "engines": { + "node": ">=v16" + }, + "peerDependencies": { + "@types/node": "*", + "cosmiconfig": ">=8.2", + "typescript": ">=4" + } + }, + "node_modules/cz-conventional-changelog": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/cz-conventional-changelog/-/cz-conventional-changelog-3.3.0.tgz", + "integrity": "sha512-U466fIzU5U22eES5lTNiNbZ+d8dfcHcssH4o7QsdWaCcRs/feIPCxKYSWkYBNs5mny7MvEfwpTLWjvbm94hecw==", + "dev": true, + "dependencies": { + "chalk": "^2.4.1", + "commitizen": "^4.0.3", + "conventional-commit-types": "^3.0.0", + "lodash.map": "^4.5.1", + "longest": "^2.0.1", + "word-wrap": "^1.0.3" + }, + "engines": { + "node": ">= 10" + }, + "optionalDependencies": { + "@commitlint/load": ">6.1.1" + } + }, + "node_modules/dedent": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/dedent/-/dedent-0.7.0.tgz", + "integrity": "sha512-Q6fKUPqnAHAyhiUgFU7BUzLiv0kd8saH9al7tnu5Q/okj6dnupxyTgFIBjVzJATdfIAm9NAsvXNzjaKa+bxVyA==", + "dev": true + }, + "node_modules/defaults": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/defaults/-/defaults-1.0.4.tgz", + "integrity": "sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==", + "dev": true, + "dependencies": { + "clone": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/detect-file": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/detect-file/-/detect-file-1.0.0.tgz", + "integrity": "sha512-DtCOLG98P007x7wiiOmfI0fi3eIKyWiLTGJ2MDnVi/E04lWGbf+JzrRHMm0rgIIZJGtHpKpbVgLWHrv8xXpc3Q==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/detect-indent": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/detect-indent/-/detect-indent-6.1.0.tgz", + "integrity": "sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, + "node_modules/error-ex": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", + "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", + "dev": true, + "optional": true, + "dependencies": { + "is-arrayish": "^0.2.1" + } + }, + "node_modules/escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", + "dev": true, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/expand-tilde": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/expand-tilde/-/expand-tilde-2.0.2.tgz", + "integrity": "sha512-A5EmesHW6rfnZ9ysHQjPdJRni0SRar0tjtG5MNtm9n5TUvsYU8oozprtRD4AqHxcZWWlVuAmQo2nWKfN9oyjTw==", + "dev": true, + "dependencies": { + "homedir-polyfill": "^1.0.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/external-editor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz", + "integrity": "sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==", + "dev": true, + "dependencies": { + "chardet": "^0.7.0", + "iconv-lite": "^0.4.24", + "tmp": "^0.0.33" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz", + "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", + "dev": true, + "optional": true + }, + "node_modules/figures": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/figures/-/figures-3.2.0.tgz", + "integrity": "sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==", + "dev": true, + "dependencies": { + "escape-string-regexp": "^1.0.5" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz", + "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==", + "dev": true, + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/find-node-modules": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/find-node-modules/-/find-node-modules-2.1.3.tgz", + "integrity": "sha512-UC2I2+nx1ZuOBclWVNdcnbDR5dlrOdVb7xNjmT/lHE+LsgztWks3dG7boJ37yTS/venXw84B/mAW9uHVoC5QRg==", + "dev": true, + "dependencies": { + "findup-sync": "^4.0.0", + "merge": "^2.1.1" + } + }, + "node_modules/find-root": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/find-root/-/find-root-1.1.0.tgz", + "integrity": "sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==", + "dev": true + }, + "node_modules/findup-sync": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/findup-sync/-/findup-sync-4.0.0.tgz", + "integrity": "sha512-6jvvn/12IC4quLBL1KNokxC7wWTvYncaVUYSoxWw7YykPLuRrnv4qdHcSOywOI5RpkOVGeQRtWM8/q+G6W6qfQ==", + "dev": true, + "dependencies": { + "detect-file": "^1.0.0", + "is-glob": "^4.0.0", + "micromatch": "^4.0.2", + "resolve-dir": "^1.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/fs-extra": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz", + "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==", + "dev": true, + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==", + "dev": true + }, + "node_modules/glob": { + "version": "7.2.3", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz", + "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==", + "dev": true, + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/global-dirs": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/global-dirs/-/global-dirs-0.1.1.tgz", + "integrity": "sha512-NknMLn7F2J7aflwFOlGdNIuCDpN3VGoSoB+aap3KABFWbHVn1TCgFC+np23J8W2BiZbjfEw3BFBycSMv1AFblg==", + "dev": true, + "optional": true, + "dependencies": { + "ini": "^1.3.4" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/global-modules": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-1.0.0.tgz", + "integrity": "sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==", + "dev": true, + "dependencies": { + "global-prefix": "^1.0.1", + "is-windows": "^1.0.1", + "resolve-dir": "^1.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/global-prefix": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/global-prefix/-/global-prefix-1.0.2.tgz", + "integrity": "sha512-5lsx1NUDHtSjfg0eHlmYvZKv8/nVqX4ckFbM+FrGcQ+04KWcWFo9P5MxPZYSzUvyzmdTbI7Eix8Q4IbELDqzKg==", + "dev": true, + "dependencies": { + "expand-tilde": "^2.0.2", + "homedir-polyfill": "^1.0.1", + "ini": "^1.3.4", + "is-windows": "^1.0.1", + "which": "^1.2.14" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz", + "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==", + "dev": true + }, + "node_modules/has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", + "dev": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/homedir-polyfill": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/homedir-polyfill/-/homedir-polyfill-1.0.3.tgz", + "integrity": "sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==", + "dev": true, + "dependencies": { + "parse-passwd": "^1.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.4.24", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", + "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==", + "dev": true, + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/import-fresh": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.0.tgz", + "integrity": "sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==", + "dev": true, + "optional": true, + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-fresh/node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "dev": true, + "optional": true, + "engines": { + "node": ">=4" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==", + "dev": true, + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz", + "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==", + "dev": true + }, + "node_modules/ini": { + "version": "1.3.8", + "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz", + "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==", + "dev": true + }, + "node_modules/inquirer": { + "version": "8.2.5", + "resolved": "https://registry.npmjs.org/inquirer/-/inquirer-8.2.5.tgz", + "integrity": "sha512-QAgPDQMEgrDssk1XiwwHoOGYF9BAbUcc1+j+FhEvaOt8/cKRqyLn0U5qA6F74fGhTMGxf92pOvPBeh29jQJDTQ==", + "dev": true, + "dependencies": { + "ansi-escapes": "^4.2.1", + "chalk": "^4.1.1", + "cli-cursor": "^3.1.0", + "cli-width": "^3.0.0", + "external-editor": "^3.0.3", + "figures": "^3.0.0", + "lodash": "^4.17.21", + "mute-stream": "0.0.8", + "ora": "^5.4.1", + "run-async": "^2.4.0", + "rxjs": "^7.5.5", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0", + "through": "^2.3.6", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/inquirer/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/inquirer/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/inquirer/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/inquirer/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/inquirer/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/inquirer/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "dev": true, + "optional": true + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-2.1.1.tgz", + "integrity": "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", + "integrity": "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==", + "dev": true, + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-interactive": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-interactive/-/is-interactive-1.0.0.tgz", + "integrity": "sha512-2HvIEKRoqS62guEC+qBjpvRubdX910WCMuJTZ+I9yvqKU2/12eSL549HMwtabb4oupdj2sMP50k+XJfB/8JE6w==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz", + "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==", + "dev": true, + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-unicode-supported": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/is-unicode-supported/-/is-unicode-supported-0.1.0.tgz", + "integrity": "sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-utf8": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-utf8/-/is-utf8-0.2.1.tgz", + "integrity": "sha512-rMYPYvCzsXywIsldgLaSoPlw5PfoB/ssr7hY4pLfcodrA5M/eArza1a9VmTiNIBNMjOGr1Ow9mTyU2o69U6U9Q==", + "dev": true + }, + "node_modules/is-windows": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-windows/-/is-windows-1.0.2.tgz", + "integrity": "sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==", + "dev": true + }, + "node_modules/jiti": { + "version": "1.21.0", + "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.0.tgz", + "integrity": "sha512-gFqAIbuKyyso/3G2qhiO2OM6shY6EPP/R0+mkDbyspxKazh8BXDC5FiFsUjlczgdNz/vfra0da2y+aHrusLG/Q==", + "dev": true, + "optional": true, + "bin": { + "jiti": "bin/jiti.js" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "dev": true, + "optional": true + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.0.tgz", + "integrity": "sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==", + "dev": true, + "optional": true, + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "dev": true, + "optional": true + }, + "node_modules/json-schema-traverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz", + "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==", + "dev": true, + "optional": true + }, + "node_modules/jsonfile": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.1.0.tgz", + "integrity": "sha512-5dgndWOriYSm5cnYaJNhalLNDKOqFwyDB/rr1E9ZsGciGvKPs8R2xYGCacuf3z6K1YKDz182fd+fY3cn3pMqXQ==", + "dev": true, + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "dev": true, + "optional": true + }, + "node_modules/lodash": { + "version": "4.17.21", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.21.tgz", + "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==", + "dev": true + }, + "node_modules/lodash.isplainobject": { + "version": "4.0.6", + "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz", + "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==", + "dev": true, + "optional": true + }, + "node_modules/lodash.map": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/lodash.map/-/lodash.map-4.6.0.tgz", + "integrity": "sha512-worNHGKLDetmcEYDvh2stPCrrQRkP20E4l0iIS7F8EvzMqBBi7ltvFN5m1HvTf1P7Jk1txKhvFcmYsCr8O2F1Q==", + "dev": true + }, + "node_modules/lodash.merge": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.merge/-/lodash.merge-4.6.2.tgz", + "integrity": "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==", + "dev": true, + "optional": true + }, + "node_modules/lodash.mergewith": { + "version": "4.6.2", + "resolved": "https://registry.npmjs.org/lodash.mergewith/-/lodash.mergewith-4.6.2.tgz", + "integrity": "sha512-GK3g5RPZWTRSeLSpgP8Xhra+pnjBC56q9FZYe1d5RN3TJ35dbkGy3YqBSMbyCrlbi+CM9Z3Jk5yTL7RCsqboyQ==", + "dev": true, + "optional": true + }, + "node_modules/lodash.uniq": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz", + "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==", + "dev": true, + "optional": true + }, + "node_modules/log-symbols": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/log-symbols/-/log-symbols-4.1.0.tgz", + "integrity": "sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==", + "dev": true, + "dependencies": { + "chalk": "^4.1.0", + "is-unicode-supported": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-symbols/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/log-symbols/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/log-symbols/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/log-symbols/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/log-symbols/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/log-symbols/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/longest": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/longest/-/longest-2.0.1.tgz", + "integrity": "sha512-Ajzxb8CM6WAnFjgiloPsI3bF+WCxcvhdIG3KNA2KN962+tdBsHcuQ4k4qX/EcS/2CRkcc0iAkR956Nib6aXU/Q==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/merge": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/merge/-/merge-2.1.1.tgz", + "integrity": "sha512-jz+Cfrg9GWOZbQAnDQ4hlVnQky+341Yk5ru8bZSe6sIDTCIg8n9i/u7hSQGSVOF3C7lH6mGtqjkiT9G4wFLL0w==", + "dev": true + }, + "node_modules/micromatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", + "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "dev": true, + "dependencies": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-2.1.0.tgz", + "integrity": "sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/minimatch": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz", + "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==", + "dev": true, + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.7.tgz", + "integrity": "sha512-bzfL1YUZsP41gmu/qjrEk0Q6i2ix/cVeAhbCbqH9u3zYutS1cLg00qhrD0M2MVdCcx4Sc0UpP2eBWo9rotpq6g==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/mute-stream": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz", + "integrity": "sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==", + "dev": true + }, + "node_modules/once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==", + "dev": true, + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-5.1.2.tgz", + "integrity": "sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==", + "dev": true, + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ora": { + "version": "5.4.1", + "resolved": "https://registry.npmjs.org/ora/-/ora-5.4.1.tgz", + "integrity": "sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==", + "dev": true, + "dependencies": { + "bl": "^4.1.0", + "chalk": "^4.1.0", + "cli-cursor": "^3.1.0", + "cli-spinners": "^2.5.0", + "is-interactive": "^1.0.0", + "is-unicode-supported": "^0.1.0", + "log-symbols": "^4.1.0", + "strip-ansi": "^6.0.0", + "wcwidth": "^1.0.1" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/ora/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/ora/node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/ora/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/ora/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/ora/node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/ora/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/os-tmpdir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-tmpdir/-/os-tmpdir-1.0.2.tgz", + "integrity": "sha512-D2FR03Vir7FIu45XBY20mTb+/ZSWB00sjU9jdQXt83gDrI4Ztz5Fs7/yy74g2N5SVQY4xY1qDr4rNddwYRVX0g==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "dev": true, + "optional": true, + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse-json": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "dev": true, + "optional": true, + "dependencies": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parse-passwd": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/parse-passwd/-/parse-passwd-1.0.0.tgz", + "integrity": "sha512-1Y1A//QUXEZK7YKz+rD9WydcE1+EuPr6ZBgKecAB8tmoW6UFv0NREVJe1p+jRxtThkcbbKkfwIbWJe/IeE6m2Q==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "dev": true, + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/picomatch": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-2.3.1.tgz", + "integrity": "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==", + "dev": true, + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/punycode": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz", + "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==", + "dev": true, + "optional": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/readable-stream": { + "version": "3.6.2", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz", + "integrity": "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==", + "dev": true, + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", + "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", + "dev": true, + "optional": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve-dir": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/resolve-dir/-/resolve-dir-1.0.1.tgz", + "integrity": "sha512-R7uiTjECzvOsWSfdM0QKFNBVFcK27aHOUwdvK53BcW8zqnGdYp0Fbj82cy54+2A4P2tFM22J5kRfe1R+lM/1yg==", + "dev": true, + "dependencies": { + "expand-tilde": "^2.0.0", + "global-modules": "^1.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/resolve-from": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", + "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", + "dev": true, + "optional": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/resolve-global": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/resolve-global/-/resolve-global-1.0.0.tgz", + "integrity": "sha512-zFa12V4OLtT5XUX/Q4VLvTfBf+Ok0SPc1FNGM/z9ctUdiU618qwKpWnd0CHs3+RqROfyEg/DhuHbMWYqcgljEw==", + "dev": true, + "optional": true, + "dependencies": { + "global-dirs": "^0.1.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/restore-cursor": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-3.1.0.tgz", + "integrity": "sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==", + "dev": true, + "dependencies": { + "onetime": "^5.1.0", + "signal-exit": "^3.0.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/run-async": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/run-async/-/run-async-2.4.1.tgz", + "integrity": "sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==", + "dev": true, + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/rxjs": { + "version": "7.8.1", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.1.tgz", + "integrity": "sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==", + "dev": true, + "dependencies": { + "tslib": "^2.1.0" + } + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz", + "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ] + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz", + "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==", + "dev": true + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz", + "integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==", + "dev": true, + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-bom": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-4.0.0.tgz", + "integrity": "sha512-3xurFv5tEgii33Zi8Jtp55wEIILR9eh34FAW00PZf+JnSsTmV/ioewSgQl97JHvgjoRGwPShsWm+IdrxB35d0w==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz", + "integrity": "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==", + "dev": true, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/supports-color": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", + "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", + "dev": true, + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==", + "dev": true + }, + "node_modules/tmp": { + "version": "0.0.33", + "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.0.33.tgz", + "integrity": "sha512-jRCJlojKnZ3addtTOjdIqoRuPEKBvNXcGYqzO6zWZX8KfKEpnGY5jfggJQ3EjKuu8D4bJRr0y+cYJFmYbImXGw==", + "dev": true, + "dependencies": { + "os-tmpdir": "~1.0.2" + }, + "engines": { + "node": ">=0.6.0" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz", + "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==", + "dev": true, + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/tslib": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz", + "integrity": "sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==", + "dev": true + }, + "node_modules/type-fest": { + "version": "0.21.3", + "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.21.3.tgz", + "integrity": "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w==", + "dev": true, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/typescript": { + "version": "5.3.3", + "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.3.3.tgz", + "integrity": "sha512-pXWcraxM0uxAS+tN0AG/BF2TyqmHO014Z070UsJ+pFvYuRSq8KH8DmWpnbXe0pEPDHXZV3FcAbJkijJ5oNEnWw==", + "dev": true, + "optional": true, + "peer": true, + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/undici-types": { + "version": "5.26.5", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", + "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", + "dev": true, + "optional": true, + "peer": true + }, + "node_modules/universalify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz", + "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==", + "dev": true, + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "resolved": "https://registry.npmjs.org/uri-js/-/uri-js-4.4.1.tgz", + "integrity": "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==", + "dev": true, + "optional": true, + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==", + "dev": true + }, + "node_modules/wcwidth": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/wcwidth/-/wcwidth-1.0.1.tgz", + "integrity": "sha512-XHPEwS0q6TaxcvG85+8EYkbiCux2XtWG2mkc47Ng2A77BQu9+DqIOJldST4HgPkuea7dvKSj5VgX3P1d4rW8Tg==", + "dev": true, + "dependencies": { + "defaults": "^1.0.3" + } + }, + "node_modules/which": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz", + "integrity": "sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==", + "dev": true, + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "which": "bin/which" + } + }, + "node_modules/word-wrap": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz", + "integrity": "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/wrap-ansi/node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==", + "dev": true + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..0e958a8 --- /dev/null +++ b/package.json @@ -0,0 +1,10 @@ +{ + "devDependencies": { + "cz-conventional-changelog": "^3.3.0" + }, + "config": { + "commitizen": { + "path": "./node_modules/cz-conventional-changelog" + } + } +} From 6b4171090dca8695856c1e98330973f729547081 Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 01:18:15 -0600 Subject: [PATCH 13/15] docs: conventional commits w/commitizen + release-please --- README.md | 38 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/README.md b/README.md index bc20034..b670991 100644 --- a/README.md +++ b/README.md @@ -187,6 +187,44 @@ Most importantly, `ruff` is used to lint all python code. git commit -m "commit message" ``` +### Conventional Commits + +While not currently enforced, by using [conventional commits](https://www.conventionalcommits.org/en/v1.0.0/#summary), it's possible to automatically generate changelogs and version numbers via [release-please](https://github.com/googleapis/release-please). + +To help with that, the [commitizen](https://commitizen-tools.github.io/commitizen/) tool can be installed. + +#### Usage + +```bash +# install cz +npm install -g commitizen cz-conventional-changelog +brew install commitizen + +# make repo cz friendly +commitizen init cz-conventional-changelog --save-dev --save-exact +npm install + +# add file to commit +git add .gitignore + +# run cz +λ git cz +cz-cli@4.3.0, cz-conventional-changelog@3.3.0 + +? Select the type of change that you're committing: chore: Other changes that don't modify src or test files +? What is the scope of this change (e.g. component or file name): (press enter to skip) .gitignore +? Write a short, imperative tense description of the change (max 81 chars): + (17) update .gitignore +? Provide a longer description of the change: (press enter to skip) + +? Are there any breaking changes? No +? Does this change affect any open issues? No +[main 0a9920d] chore(.gitignore): update .gitignore + 1 file changed, 131 insertions(+) + +λ git push +``` + ### Formatting > **TL;DR**: The [Ruff formatter](https://astral.sh/blog/the-ruff-formatter) is an extremely fast Python formatter, written in Rust. It’s over 30x faster than Black and 100x faster than YAPF, formatting large-scale Python projects in milliseconds — all while achieving >99.9% Black compatibility. From 3f6a7c952665d1ec4146bd454a8ef38c1c2fbe46 Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 01:20:50 -0600 Subject: [PATCH 14/15] docs: update README.md Add pre-commit hook bypass flag to ease transition --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index b670991..6bc80a3 100644 --- a/README.md +++ b/README.md @@ -186,6 +186,11 @@ Most importantly, `ruff` is used to lint all python code. git add . git commit -m "commit message" ``` +* Bypass pre-commit hooks + * Sometimes, it's necessary to bypass pre-commit hooks. This can be done with the `--no-verify` flag. + ```bash + git commit -m "commit message" --no-verify + ``` ### Conventional Commits From 61e19bee16871aeb46a9f8ee9734ca89f5b0a82c Mon Sep 17 00:00:00 2001 From: pythoninthegrass <4097471+pythoninthegrass@users.noreply.github.com> Date: Wed, 21 Feb 2024 01:29:36 -0600 Subject: [PATCH 15/15] docs: update README.md - todo section - update asdf instructions --- README.md | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/README.md b/README.md index 6bc80a3..42c2ebe 100644 --- a/README.md +++ b/README.md @@ -203,7 +203,6 @@ To help with that, the [commitizen](https://commitizen-tools.github.io/commitize ```bash # install cz npm install -g commitizen cz-conventional-changelog -brew install commitizen # make repo cz friendly commitizen init cz-conventional-changelog --save-dev --save-exact @@ -245,30 +244,31 @@ cz-cli@4.3.0, cz-conventional-changelog@3.3.0 ### Additional tooling -Additional tooling includes but is not limited to: +#### TODO + +* Add [devbox](https://www.jetpack.io/devbox/) 👌 #### asdf * Install [asdf](https://asdf-vm.com/guide/getting-started.html#_2-download-asdf) -* Usage +* Add plugins ```bash - # add python plugin asdf plugin-add python - + asdf plugin-add poetry https://github.com/asdf-community/asdf-poetry.git + asdf plugin add nodejs https://github.com/asdf-vm/asdf-nodejs.git + ``` +* Usage + * Install local plugins in repo + ```bash + asdf install + ``` + * Install specific plugins + ```bash # install stable python asdf install python # set stable to system python asdf global python latest - - # add poetry asdf plugin - asdf plugin-add poetry https://github.com/asdf-community/asdf-poetry.git - - # install latest version via asdf - asdf install poetry - - # set latest version as default - asdf global poetry latest ``` #### shellcheck

=!C?q>8`2KaS zkaW4|w2+{&I4vZ88xNz7LgKHY(?YUS?b&j^4+hA5U$JK?XZt>Cd?C5c+o|>Xq^6q6 z6p}qP^!oZ_z`}#A(kJCk>cm3Q&`h-yk`r*#@UmrPE@o|wlC5#soU?mUWpCClTM7s3 zmM!!$h2(L*jvoQ{rAY_fRHBdsY&_QDEF^v(4|b@Kw0Za;+^$KRz5E&EY@RZL`u_)a CNT19A literal 0 HcmV?d00001 diff --git a/Modules/requests/__version__.py b/Modules/requests/__version__.py new file mode 100644 index 0000000..5063c3f --- /dev/null +++ b/Modules/requests/__version__.py @@ -0,0 +1,14 @@ +# .-. .-. .-. . . .-. .-. .-. .-. +# |( |- |.| | | |- `-. | `-. +# ' ' `-' `-`.`-' `-' `-' ' `-' + +__title__ = "requests" +__description__ = "Python HTTP for Humans." +__url__ = "https://requests.readthedocs.io" +__version__ = "2.31.0" +__build__ = 0x023100 +__author__ = "Kenneth Reitz" +__author_email__ = "me@kennethreitz.org" +__license__ = "Apache 2.0" +__copyright__ = "Copyright Kenneth Reitz" +__cake__ = "\u2728 \U0001f370 \u2728" diff --git a/Modules/requests/_internal_utils.py b/Modules/requests/_internal_utils.py new file mode 100644 index 0000000..f2cf635 --- /dev/null +++ b/Modules/requests/_internal_utils.py @@ -0,0 +1,50 @@ +""" +requests._internal_utils +~~~~~~~~~~~~~~ + +Provides utility functions that are consumed internally by Requests +which depend on extremely few external helpers (such as compat) +""" +import re + +from .compat import builtin_str + +_VALID_HEADER_NAME_RE_BYTE = re.compile(rb"^[^:\s][^:\r\n]*$") +_VALID_HEADER_NAME_RE_STR = re.compile(r"^[^:\s][^:\r\n]*$") +_VALID_HEADER_VALUE_RE_BYTE = re.compile(rb"^\S[^\r\n]*$|^$") +_VALID_HEADER_VALUE_RE_STR = re.compile(r"^\S[^\r\n]*$|^$") + +_HEADER_VALIDATORS_STR = (_VALID_HEADER_NAME_RE_STR, _VALID_HEADER_VALUE_RE_STR) +_HEADER_VALIDATORS_BYTE = (_VALID_HEADER_NAME_RE_BYTE, _VALID_HEADER_VALUE_RE_BYTE) +HEADER_VALIDATORS = { + bytes: _HEADER_VALIDATORS_BYTE, + str: _HEADER_VALIDATORS_STR, +} + + +def to_native_string(string, encoding="ascii"): + """Given a string object, regardless of type, returns a representation of + that string in the native string type, encoding and decoding where + necessary. This assumes ASCII unless told otherwise. + """ + if isinstance(string, builtin_str): + out = string + else: + out = string.decode(encoding) + + return out + + +def unicode_is_ascii(u_string): + """Determine if unicode string only contains ASCII characters. + + :param str u_string: unicode string to check. Must be unicode + and not Python 2 `str`. + :rtype: bool + """ + assert isinstance(u_string, str) + try: + u_string.encode("ascii") + return True + except UnicodeEncodeError: + return False diff --git a/Modules/requests/adapters.py b/Modules/requests/adapters.py new file mode 100644 index 0000000..78e3bb6 --- /dev/null +++ b/Modules/requests/adapters.py @@ -0,0 +1,538 @@ +""" +requests.adapters +~~~~~~~~~~~~~~~~~ + +This module contains the transport adapters that Requests uses to define +and maintain connections. +""" + +import os.path +import socket # noqa: F401 + +from urllib3.exceptions import ClosedPoolError, ConnectTimeoutError +from urllib3.exceptions import HTTPError as _HTTPError +from urllib3.exceptions import InvalidHeader as _InvalidHeader +from urllib3.exceptions import ( + LocationValueError, + MaxRetryError, + NewConnectionError, + ProtocolError, +) +from urllib3.exceptions import ProxyError as _ProxyError +from urllib3.exceptions import ReadTimeoutError, ResponseError +from urllib3.exceptions import SSLError as _SSLError +from urllib3.poolmanager import PoolManager, proxy_from_url +from urllib3.util import Timeout as TimeoutSauce +from urllib3.util import parse_url +from urllib3.util.retry import Retry + +from .auth import _basic_auth_str +from .compat import basestring, urlparse +from .cookies import extract_cookies_to_jar +from .exceptions import ( + ConnectionError, + ConnectTimeout, + InvalidHeader, + InvalidProxyURL, + InvalidSchema, + InvalidURL, + ProxyError, + ReadTimeout, + RetryError, + SSLError, +) +from .models import Response +from .structures import CaseInsensitiveDict +from .utils import ( + DEFAULT_CA_BUNDLE_PATH, + extract_zipped_paths, + get_auth_from_url, + get_encoding_from_headers, + prepend_scheme_if_needed, + select_proxy, + urldefragauth, +) + +try: + from urllib3.contrib.socks import SOCKSProxyManager +except ImportError: + + def SOCKSProxyManager(*args, **kwargs): + raise InvalidSchema("Missing dependencies for SOCKS support.") + + +DEFAULT_POOLBLOCK = False +DEFAULT_POOLSIZE = 10 +DEFAULT_RETRIES = 0 +DEFAULT_POOL_TIMEOUT = None + + +class BaseAdapter: + """The Base Transport Adapter""" + + def __init__(self): + super().__init__() + + def send( + self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None + ): + """Sends PreparedRequest object. Returns Response object. + + :param request: The :class:`PreparedRequest ` being sent. + :param stream: (optional) Whether to stream the request content. + :param timeout: (optional) How long to wait for the server to send + data before giving up, as a float, or a :ref:`(connect timeout, + read timeout) ` tuple. + :type timeout: float or tuple + :param verify: (optional) Either a boolean, in which case it controls whether we verify + the server's TLS certificate, or a string, in which case it must be a path + to a CA bundle to use + :param cert: (optional) Any user-provided SSL certificate to be trusted. + :param proxies: (optional) The proxies dictionary to apply to the request. + """ + raise NotImplementedError + + def close(self): + """Cleans up adapter specific items.""" + raise NotImplementedError + + +class HTTPAdapter(BaseAdapter): + """The built-in HTTP Adapter for urllib3. + + Provides a general-case interface for Requests sessions to contact HTTP and + HTTPS urls by implementing the Transport Adapter interface. This class will + usually be created by the :class:`Session ` class under the + covers. + + :param pool_connections: The number of urllib3 connection pools to cache. + :param pool_maxsize: The maximum number of connections to save in the pool. + :param max_retries: The maximum number of retries each connection + should attempt. Note, this applies only to failed DNS lookups, socket + connections and connection timeouts, never to requests where data has + made it to the server. By default, Requests does not retry failed + connections. If you need granular control over the conditions under + which we retry a request, import urllib3's ``Retry`` class and pass + that instead. + :param pool_block: Whether the connection pool should block for connections. + + Usage:: + + >>> import requests + >>> s = requests.Session() + >>> a = requests.adapters.HTTPAdapter(max_retries=3) + >>> s.mount('http://', a) + """ + + __attrs__ = [ + "max_retries", + "config", + "_pool_connections", + "_pool_maxsize", + "_pool_block", + ] + + def __init__( + self, + pool_connections=DEFAULT_POOLSIZE, + pool_maxsize=DEFAULT_POOLSIZE, + max_retries=DEFAULT_RETRIES, + pool_block=DEFAULT_POOLBLOCK, + ): + if max_retries == DEFAULT_RETRIES: + self.max_retries = Retry(0, read=False) + else: + self.max_retries = Retry.from_int(max_retries) + self.config = {} + self.proxy_manager = {} + + super().__init__() + + self._pool_connections = pool_connections + self._pool_maxsize = pool_maxsize + self._pool_block = pool_block + + self.init_poolmanager(pool_connections, pool_maxsize, block=pool_block) + + def __getstate__(self): + return {attr: getattr(self, attr, None) for attr in self.__attrs__} + + def __setstate__(self, state): + # Can't handle by adding 'proxy_manager' to self.__attrs__ because + # self.poolmanager uses a lambda function, which isn't pickleable. + self.proxy_manager = {} + self.config = {} + + for attr, value in state.items(): + setattr(self, attr, value) + + self.init_poolmanager( + self._pool_connections, self._pool_maxsize, block=self._pool_block + ) + + def init_poolmanager( + self, connections, maxsize, block=DEFAULT_POOLBLOCK, **pool_kwargs + ): + """Initializes a urllib3 PoolManager. + + This method should not be called from user code, and is only + exposed for use when subclassing the + :class:`HTTPAdapter `. + + :param connections: The number of urllib3 connection pools to cache. + :param maxsize: The maximum number of connections to save in the pool. + :param block: Block when no free connections are available. + :param pool_kwargs: Extra keyword arguments used to initialize the Pool Manager. + """ + # save these values for pickling + self._pool_connections = connections + self._pool_maxsize = maxsize + self._pool_block = block + + self.poolmanager = PoolManager( + num_pools=connections, + maxsize=maxsize, + block=block, + **pool_kwargs, + ) + + def proxy_manager_for(self, proxy, **proxy_kwargs): + """Return urllib3 ProxyManager for the given proxy. + + This method should not be called from user code, and is only + exposed for use when subclassing the + :class:`HTTPAdapter `. + + :param proxy: The proxy to return a urllib3 ProxyManager for. + :param proxy_kwargs: Extra keyword arguments used to configure the Proxy Manager. + :returns: ProxyManager + :rtype: urllib3.ProxyManager + """ + if proxy in self.proxy_manager: + manager = self.proxy_manager[proxy] + elif proxy.lower().startswith("socks"): + username, password = get_auth_from_url(proxy) + manager = self.proxy_manager[proxy] = SOCKSProxyManager( + proxy, + username=username, + password=password, + num_pools=self._pool_connections, + maxsize=self._pool_maxsize, + block=self._pool_block, + **proxy_kwargs, + ) + else: + proxy_headers = self.proxy_headers(proxy) + manager = self.proxy_manager[proxy] = proxy_from_url( + proxy, + proxy_headers=proxy_headers, + num_pools=self._pool_connections, + maxsize=self._pool_maxsize, + block=self._pool_block, + **proxy_kwargs, + ) + + return manager + + def cert_verify(self, conn, url, verify, cert): + """Verify a SSL certificate. This method should not be called from user + code, and is only exposed for use when subclassing the + :class:`HTTPAdapter `. + + :param conn: The urllib3 connection object associated with the cert. + :param url: The requested URL. + :param verify: Either a boolean, in which case it controls whether we verify + the server's TLS certificate, or a string, in which case it must be a path + to a CA bundle to use + :param cert: The SSL certificate to verify. + """ + if url.lower().startswith("https") and verify: + + cert_loc = None + + # Allow self-specified cert location. + if verify is not True: + cert_loc = verify + + if not cert_loc: + cert_loc = extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH) + + if not cert_loc or not os.path.exists(cert_loc): + raise OSError( + f"Could not find a suitable TLS CA certificate bundle, " + f"invalid path: {cert_loc}" + ) + + conn.cert_reqs = "CERT_REQUIRED" + + if not os.path.isdir(cert_loc): + conn.ca_certs = cert_loc + else: + conn.ca_cert_dir = cert_loc + else: + conn.cert_reqs = "CERT_NONE" + conn.ca_certs = None + conn.ca_cert_dir = None + + if cert: + if not isinstance(cert, basestring): + conn.cert_file = cert[0] + conn.key_file = cert[1] + else: + conn.cert_file = cert + conn.key_file = None + if conn.cert_file and not os.path.exists(conn.cert_file): + raise OSError( + f"Could not find the TLS certificate file, " + f"invalid path: {conn.cert_file}" + ) + if conn.key_file and not os.path.exists(conn.key_file): + raise OSError( + f"Could not find the TLS key file, invalid path: {conn.key_file}" + ) + + def build_response(self, req, resp): + """Builds a :class:`Response ` object from a urllib3 + response. This should not be called from user code, and is only exposed + for use when subclassing the + :class:`HTTPAdapter ` + + :param req: The :class:`PreparedRequest ` used to generate the response. + :param resp: The urllib3 response object. + :rtype: requests.Response + """ + response = Response() + + # Fallback to None if there's no status_code, for whatever reason. + response.status_code = getattr(resp, "status", None) + + # Make headers case-insensitive. + response.headers = CaseInsensitiveDict(getattr(resp, "headers", {})) + + # Set encoding. + response.encoding = get_encoding_from_headers(response.headers) + response.raw = resp + response.reason = response.raw.reason + + if isinstance(req.url, bytes): + response.url = req.url.decode("utf-8") + else: + response.url = req.url + + # Add new cookies from the server. + extract_cookies_to_jar(response.cookies, req, resp) + + # Give the Response some context. + response.request = req + response.connection = self + + return response + + def get_connection(self, url, proxies=None): + """Returns a urllib3 connection for the given URL. This should not be + called from user code, and is only exposed for use when subclassing the + :class:`HTTPAdapter `. + + :param url: The URL to connect to. + :param proxies: (optional) A Requests-style dictionary of proxies used on this request. + :rtype: urllib3.ConnectionPool + """ + proxy = select_proxy(url, proxies) + + if proxy: + proxy = prepend_scheme_if_needed(proxy, "http") + proxy_url = parse_url(proxy) + if not proxy_url.host: + raise InvalidProxyURL( + "Please check proxy URL. It is malformed " + "and could be missing the host." + ) + proxy_manager = self.proxy_manager_for(proxy) + conn = proxy_manager.connection_from_url(url) + else: + # Only scheme should be lower case + parsed = urlparse(url) + url = parsed.geturl() + conn = self.poolmanager.connection_from_url(url) + + return conn + + def close(self): + """Disposes of any internal state. + + Currently, this closes the PoolManager and any active ProxyManager, + which closes any pooled connections. + """ + self.poolmanager.clear() + for proxy in self.proxy_manager.values(): + proxy.clear() + + def request_url(self, request, proxies): + """Obtain the url to use when making the final request. + + If the message is being sent through a HTTP proxy, the full URL has to + be used. Otherwise, we should only use the path portion of the URL. + + This should not be called from user code, and is only exposed for use + when subclassing the + :class:`HTTPAdapter `. + + :param request: The :class:`PreparedRequest ` being sent. + :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs. + :rtype: str + """ + proxy = select_proxy(request.url, proxies) + scheme = urlparse(request.url).scheme + + is_proxied_http_request = proxy and scheme != "https" + using_socks_proxy = False + if proxy: + proxy_scheme = urlparse(proxy).scheme.lower() + using_socks_proxy = proxy_scheme.startswith("socks") + + url = request.path_url + if is_proxied_http_request and not using_socks_proxy: + url = urldefragauth(request.url) + + return url + + def add_headers(self, request, **kwargs): + """Add any headers needed by the connection. As of v2.0 this does + nothing by default, but is left for overriding by users that subclass + the :class:`HTTPAdapter `. + + This should not be called from user code, and is only exposed for use + when subclassing the + :class:`HTTPAdapter `. + + :param request: The :class:`PreparedRequest ` to add headers to. + :param kwargs: The keyword arguments from the call to send(). + """ + pass + + def proxy_headers(self, proxy): + """Returns a dictionary of the headers to add to any request sent + through a proxy. This works with urllib3 magic to ensure that they are + correctly sent to the proxy, rather than in a tunnelled request if + CONNECT is being used. + + This should not be called from user code, and is only exposed for use + when subclassing the + :class:`HTTPAdapter `. + + :param proxy: The url of the proxy being used for this request. + :rtype: dict + """ + headers = {} + username, password = get_auth_from_url(proxy) + + if username: + headers["Proxy-Authorization"] = _basic_auth_str(username, password) + + return headers + + def send( + self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None + ): + """Sends PreparedRequest object. Returns Response object. + + :param request: The :class:`PreparedRequest ` being sent. + :param stream: (optional) Whether to stream the request content. + :param timeout: (optional) How long to wait for the server to send + data before giving up, as a float, or a :ref:`(connect timeout, + read timeout) ` tuple. + :type timeout: float or tuple or urllib3 Timeout object + :param verify: (optional) Either a boolean, in which case it controls whether + we verify the server's TLS certificate, or a string, in which case it + must be a path to a CA bundle to use + :param cert: (optional) Any user-provided SSL certificate to be trusted. + :param proxies: (optional) The proxies dictionary to apply to the request. + :rtype: requests.Response + """ + + try: + conn = self.get_connection(request.url, proxies) + except LocationValueError as e: + raise InvalidURL(e, request=request) + + self.cert_verify(conn, request.url, verify, cert) + url = self.request_url(request, proxies) + self.add_headers( + request, + stream=stream, + timeout=timeout, + verify=verify, + cert=cert, + proxies=proxies, + ) + + chunked = not (request.body is None or "Content-Length" in request.headers) + + if isinstance(timeout, tuple): + try: + connect, read = timeout + timeout = TimeoutSauce(connect=connect, read=read) + except ValueError: + raise ValueError( + f"Invalid timeout {timeout}. Pass a (connect, read) timeout tuple, " + f"or a single float to set both timeouts to the same value." + ) + elif isinstance(timeout, TimeoutSauce): + pass + else: + timeout = TimeoutSauce(connect=timeout, read=timeout) + + try: + resp = conn.urlopen( + method=request.method, + url=url, + body=request.body, + headers=request.headers, + redirect=False, + assert_same_host=False, + preload_content=False, + decode_content=False, + retries=self.max_retries, + timeout=timeout, + chunked=chunked, + ) + + except (ProtocolError, OSError) as err: + raise ConnectionError(err, request=request) + + except MaxRetryError as e: + if isinstance(e.reason, ConnectTimeoutError): + # TODO: Remove this in 3.0.0: see #2811 + if not isinstance(e.reason, NewConnectionError): + raise ConnectTimeout(e, request=request) + + if isinstance(e.reason, ResponseError): + raise RetryError(e, request=request) + + if isinstance(e.reason, _ProxyError): + raise ProxyError(e, request=request) + + if isinstance(e.reason, _SSLError): + # This branch is for urllib3 v1.22 and later. + raise SSLError(e, request=request) + + raise ConnectionError(e, request=request) + + except ClosedPoolError as e: + raise ConnectionError(e, request=request) + + except _ProxyError as e: + raise ProxyError(e) + + except (_SSLError, _HTTPError) as e: + if isinstance(e, _SSLError): + # This branch is for urllib3 versions earlier than v1.22 + raise SSLError(e, request=request) + elif isinstance(e, ReadTimeoutError): + raise ReadTimeout(e, request=request) + elif isinstance(e, _InvalidHeader): + raise InvalidHeader(e, request=request) + else: + raise + + return self.build_response(request, resp) diff --git a/Modules/requests/api.py b/Modules/requests/api.py new file mode 100644 index 0000000..cd0b3ee --- /dev/null +++ b/Modules/requests/api.py @@ -0,0 +1,157 @@ +""" +requests.api +~~~~~~~~~~~~ + +This module implements the Requests API. + +:copyright: (c) 2012 by Kenneth Reitz. +:license: Apache2, see LICENSE for more details. +""" + +from . import sessions + + +def request(method, url, **kwargs): + """Constructs and sends a :class:`Request `. + + :param method: method for the new :class:`Request` object: ``GET``, ``OPTIONS``, ``HEAD``, ``POST``, ``PUT``, ``PATCH``, or ``DELETE``. + :param url: URL for the new :class:`Request` object. + :param params: (optional) Dictionary, list of tuples or bytes to send + in the query string for the :class:`Request`. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. + :param headers: (optional) Dictionary of HTTP Headers to send with the :class:`Request`. + :param cookies: (optional) Dict or CookieJar object to send with the :class:`Request`. + :param files: (optional) Dictionary of ``'name': file-like-objects`` (or ``{'name': file-tuple}``) for multipart encoding upload. + ``file-tuple`` can be a 2-tuple ``('filename', fileobj)``, 3-tuple ``('filename', fileobj, 'content_type')`` + or a 4-tuple ``('filename', fileobj, 'content_type', custom_headers)``, where ``'content-type'`` is a string + defining the content type of the given file and ``custom_headers`` a dict-like object containing additional headers + to add for the file. + :param auth: (optional) Auth tuple to enable Basic/Digest/Custom HTTP Auth. + :param timeout: (optional) How many seconds to wait for the server to send data + before giving up, as a float, or a :ref:`(connect timeout, read + timeout) ` tuple. + :type timeout: float or tuple + :param allow_redirects: (optional) Boolean. Enable/disable GET/OPTIONS/POST/PUT/PATCH/DELETE/HEAD redirection. Defaults to ``True``. + :type allow_redirects: bool + :param proxies: (optional) Dictionary mapping protocol to the URL of the proxy. + :param verify: (optional) Either a boolean, in which case it controls whether we verify + the server's TLS certificate, or a string, in which case it must be a path + to a CA bundle to use. Defaults to ``True``. + :param stream: (optional) if ``False``, the response content will be immediately downloaded. + :param cert: (optional) if String, path to ssl client cert file (.pem). If Tuple, ('cert', 'key') pair. + :return: :class:`Response ` object + :rtype: requests.Response + + Usage:: + + >>> import requests + >>> req = requests.request('GET', 'https://httpbin.org/get') + >>> req + + """ + + # By using the 'with' statement we are sure the session is closed, thus we + # avoid leaving sockets open which can trigger a ResourceWarning in some + # cases, and look like a memory leak in others. + with sessions.Session() as session: + return session.request(method=method, url=url, **kwargs) + + +def get(url, params=None, **kwargs): + r"""Sends a GET request. + + :param url: URL for the new :class:`Request` object. + :param params: (optional) Dictionary, list of tuples or bytes to send + in the query string for the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("get", url, params=params, **kwargs) + + +def options(url, **kwargs): + r"""Sends an OPTIONS request. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("options", url, **kwargs) + + +def head(url, **kwargs): + r"""Sends a HEAD request. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. If + `allow_redirects` is not provided, it will be set to `False` (as + opposed to the default :meth:`request` behavior). + :return: :class:`Response ` object + :rtype: requests.Response + """ + + kwargs.setdefault("allow_redirects", False) + return request("head", url, **kwargs) + + +def post(url, data=None, json=None, **kwargs): + r"""Sends a POST request. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("post", url, data=data, json=json, **kwargs) + + +def put(url, data=None, **kwargs): + r"""Sends a PUT request. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("put", url, data=data, **kwargs) + + +def patch(url, data=None, **kwargs): + r"""Sends a PATCH request. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) A JSON serializable Python object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("patch", url, data=data, **kwargs) + + +def delete(url, **kwargs): + r"""Sends a DELETE request. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :return: :class:`Response ` object + :rtype: requests.Response + """ + + return request("delete", url, **kwargs) diff --git a/Modules/requests/auth.py b/Modules/requests/auth.py new file mode 100644 index 0000000..9733686 --- /dev/null +++ b/Modules/requests/auth.py @@ -0,0 +1,315 @@ +""" +requests.auth +~~~~~~~~~~~~~ + +This module contains the authentication handlers for Requests. +""" + +import hashlib +import os +import re +import threading +import time +import warnings +from base64 import b64encode + +from ._internal_utils import to_native_string +from .compat import basestring, str, urlparse +from .cookies import extract_cookies_to_jar +from .utils import parse_dict_header + +CONTENT_TYPE_FORM_URLENCODED = "application/x-www-form-urlencoded" +CONTENT_TYPE_MULTI_PART = "multipart/form-data" + + +def _basic_auth_str(username, password): + """Returns a Basic Auth string.""" + + # "I want us to put a big-ol' comment on top of it that + # says that this behaviour is dumb but we need to preserve + # it because people are relying on it." + # - Lukasa + # + # These are here solely to maintain backwards compatibility + # for things like ints. This will be removed in 3.0.0. + if not isinstance(username, basestring): + warnings.warn( + "Non-string usernames will no longer be supported in Requests " + "3.0.0. Please convert the object you've passed in ({!r}) to " + "a string or bytes object in the near future to avoid " + "problems.".format(username), + category=DeprecationWarning, + ) + username = str(username) + + if not isinstance(password, basestring): + warnings.warn( + "Non-string passwords will no longer be supported in Requests " + "3.0.0. Please convert the object you've passed in ({!r}) to " + "a string or bytes object in the near future to avoid " + "problems.".format(type(password)), + category=DeprecationWarning, + ) + password = str(password) + # -- End Removal -- + + if isinstance(username, str): + username = username.encode("latin1") + + if isinstance(password, str): + password = password.encode("latin1") + + authstr = "Basic " + to_native_string( + b64encode(b":".join((username, password))).strip() + ) + + return authstr + + +class AuthBase: + """Base class that all auth implementations derive from""" + + def __call__(self, r): + raise NotImplementedError("Auth hooks must be callable.") + + +class HTTPBasicAuth(AuthBase): + """Attaches HTTP Basic Authentication to the given Request object.""" + + def __init__(self, username, password): + self.username = username + self.password = password + + def __eq__(self, other): + return all( + [ + self.username == getattr(other, "username", None), + self.password == getattr(other, "password", None), + ] + ) + + def __ne__(self, other): + return not self == other + + def __call__(self, r): + r.headers["Authorization"] = _basic_auth_str(self.username, self.password) + return r + + +class HTTPProxyAuth(HTTPBasicAuth): + """Attaches HTTP Proxy Authentication to a given Request object.""" + + def __call__(self, r): + r.headers["Proxy-Authorization"] = _basic_auth_str(self.username, self.password) + return r + + +class HTTPDigestAuth(AuthBase): + """Attaches HTTP Digest Authentication to the given Request object.""" + + def __init__(self, username, password): + self.username = username + self.password = password + # Keep state in per-thread local storage + self._thread_local = threading.local() + + def init_per_thread_state(self): + # Ensure state is initialized just once per-thread + if not hasattr(self._thread_local, "init"): + self._thread_local.init = True + self._thread_local.last_nonce = "" + self._thread_local.nonce_count = 0 + self._thread_local.chal = {} + self._thread_local.pos = None + self._thread_local.num_401_calls = None + + def build_digest_header(self, method, url): + """ + :rtype: str + """ + + realm = self._thread_local.chal["realm"] + nonce = self._thread_local.chal["nonce"] + qop = self._thread_local.chal.get("qop") + algorithm = self._thread_local.chal.get("algorithm") + opaque = self._thread_local.chal.get("opaque") + hash_utf8 = None + + if algorithm is None: + _algorithm = "MD5" + else: + _algorithm = algorithm.upper() + # lambdas assume digest modules are imported at the top level + if _algorithm == "MD5" or _algorithm == "MD5-SESS": + + def md5_utf8(x): + if isinstance(x, str): + x = x.encode("utf-8") + return hashlib.md5(x).hexdigest() + + hash_utf8 = md5_utf8 + elif _algorithm == "SHA": + + def sha_utf8(x): + if isinstance(x, str): + x = x.encode("utf-8") + return hashlib.sha1(x).hexdigest() + + hash_utf8 = sha_utf8 + elif _algorithm == "SHA-256": + + def sha256_utf8(x): + if isinstance(x, str): + x = x.encode("utf-8") + return hashlib.sha256(x).hexdigest() + + hash_utf8 = sha256_utf8 + elif _algorithm == "SHA-512": + + def sha512_utf8(x): + if isinstance(x, str): + x = x.encode("utf-8") + return hashlib.sha512(x).hexdigest() + + hash_utf8 = sha512_utf8 + + KD = lambda s, d: hash_utf8(f"{s}:{d}") # noqa:E731 + + if hash_utf8 is None: + return None + + # XXX not implemented yet + entdig = None + p_parsed = urlparse(url) + #: path is request-uri defined in RFC 2616 which should not be empty + path = p_parsed.path or "/" + if p_parsed.query: + path += f"?{p_parsed.query}" + + A1 = f"{self.username}:{realm}:{self.password}" + A2 = f"{method}:{path}" + + HA1 = hash_utf8(A1) + HA2 = hash_utf8(A2) + + if nonce == self._thread_local.last_nonce: + self._thread_local.nonce_count += 1 + else: + self._thread_local.nonce_count = 1 + ncvalue = f"{self._thread_local.nonce_count:08x}" + s = str(self._thread_local.nonce_count).encode("utf-8") + s += nonce.encode("utf-8") + s += time.ctime().encode("utf-8") + s += os.urandom(8) + + cnonce = hashlib.sha1(s).hexdigest()[:16] + if _algorithm == "MD5-SESS": + HA1 = hash_utf8(f"{HA1}:{nonce}:{cnonce}") + + if not qop: + respdig = KD(HA1, f"{nonce}:{HA2}") + elif qop == "auth" or "auth" in qop.split(","): + noncebit = f"{nonce}:{ncvalue}:{cnonce}:auth:{HA2}" + respdig = KD(HA1, noncebit) + else: + # XXX handle auth-int. + return None + + self._thread_local.last_nonce = nonce + + # XXX should the partial digests be encoded too? + base = ( + f'username="{self.username}", realm="{realm}", nonce="{nonce}", ' + f'uri="{path}", response="{respdig}"' + ) + if opaque: + base += f', opaque="{opaque}"' + if algorithm: + base += f', algorithm="{algorithm}"' + if entdig: + base += f', digest="{entdig}"' + if qop: + base += f', qop="auth", nc={ncvalue}, cnonce="{cnonce}"' + + return f"Digest {base}" + + def handle_redirect(self, r, **kwargs): + """Reset num_401_calls counter on redirects.""" + if r.is_redirect: + self._thread_local.num_401_calls = 1 + + def handle_401(self, r, **kwargs): + """ + Takes the given response and tries digest-auth, if needed. + + :rtype: requests.Response + """ + + # If response is not 4xx, do not auth + # See https://github.com/psf/requests/issues/3772 + if not 400 <= r.status_code < 500: + self._thread_local.num_401_calls = 1 + return r + + if self._thread_local.pos is not None: + # Rewind the file position indicator of the body to where + # it was to resend the request. + r.request.body.seek(self._thread_local.pos) + s_auth = r.headers.get("www-authenticate", "") + + if "digest" in s_auth.lower() and self._thread_local.num_401_calls < 2: + + self._thread_local.num_401_calls += 1 + pat = re.compile(r"digest ", flags=re.IGNORECASE) + self._thread_local.chal = parse_dict_header(pat.sub("", s_auth, count=1)) + + # Consume content and release the original connection + # to allow our new request to reuse the same one. + r.content + r.close() + prep = r.request.copy() + extract_cookies_to_jar(prep._cookies, r.request, r.raw) + prep.prepare_cookies(prep._cookies) + + prep.headers["Authorization"] = self.build_digest_header( + prep.method, prep.url + ) + _r = r.connection.send(prep, **kwargs) + _r.history.append(r) + _r.request = prep + + return _r + + self._thread_local.num_401_calls = 1 + return r + + def __call__(self, r): + # Initialize per-thread state, if needed + self.init_per_thread_state() + # If we have a saved nonce, skip the 401 + if self._thread_local.last_nonce: + r.headers["Authorization"] = self.build_digest_header(r.method, r.url) + try: + self._thread_local.pos = r.body.tell() + except AttributeError: + # In the case of HTTPDigestAuth being reused and the body of + # the previous request was a file-like object, pos has the + # file position of the previous body. Ensure it's set to + # None. + self._thread_local.pos = None + r.register_hook("response", self.handle_401) + r.register_hook("response", self.handle_redirect) + self._thread_local.num_401_calls = 1 + + return r + + def __eq__(self, other): + return all( + [ + self.username == getattr(other, "username", None), + self.password == getattr(other, "password", None), + ] + ) + + def __ne__(self, other): + return not self == other diff --git a/Modules/requests/certs.py b/Modules/requests/certs.py new file mode 100644 index 0000000..be422c3 --- /dev/null +++ b/Modules/requests/certs.py @@ -0,0 +1,17 @@ +#!/usr/bin/env python + +""" +requests.certs +~~~~~~~~~~~~~~ + +This module returns the preferred default CA certificate bundle. There is +only one — the one from the certifi package. + +If you are packaging Requests, e.g., for a Linux distribution or a managed +environment, you can change the definition of where() to return a separately +packaged CA bundle. +""" +from certifi import where + +if __name__ == "__main__": + print(where()) diff --git a/Modules/requests/compat.py b/Modules/requests/compat.py new file mode 100644 index 0000000..6776163 --- /dev/null +++ b/Modules/requests/compat.py @@ -0,0 +1,79 @@ +""" +requests.compat +~~~~~~~~~~~~~~~ + +This module previously handled import compatibility issues +between Python 2 and Python 3. It remains for backwards +compatibility until the next major version. +""" + +try: + import chardet +except ImportError: + import charset_normalizer as chardet + +import sys + +# ------- +# Pythons +# ------- + +# Syntax sugar. +_ver = sys.version_info + +#: Python 2.x? +is_py2 = _ver[0] == 2 + +#: Python 3.x? +is_py3 = _ver[0] == 3 + +# json/simplejson module import resolution +has_simplejson = False +try: + import simplejson as json + + has_simplejson = True +except ImportError: + import json + +if has_simplejson: + from simplejson import JSONDecodeError +else: + from json import JSONDecodeError + +# Keep OrderedDict for backwards compatibility. +from collections import OrderedDict +from collections.abc import Callable, Mapping, MutableMapping +from http import cookiejar as cookielib +from http.cookies import Morsel +from io import StringIO + +# -------------- +# Legacy Imports +# -------------- +from urllib.parse import ( + quote, + quote_plus, + unquote, + unquote_plus, + urldefrag, + urlencode, + urljoin, + urlparse, + urlsplit, + urlunparse, +) +from urllib.request import ( + getproxies, + getproxies_environment, + parse_http_list, + proxy_bypass, + proxy_bypass_environment, +) + +builtin_str = str +str = str +bytes = bytes +basestring = (str, bytes) +numeric_types = (int, float) +integer_types = (int,) diff --git a/Modules/requests/cookies.py b/Modules/requests/cookies.py new file mode 100644 index 0000000..bf54ab2 --- /dev/null +++ b/Modules/requests/cookies.py @@ -0,0 +1,561 @@ +""" +requests.cookies +~~~~~~~~~~~~~~~~ + +Compatibility code to be able to use `cookielib.CookieJar` with requests. + +requests.utils imports from here, so be careful with imports. +""" + +import calendar +import copy +import time + +from ._internal_utils import to_native_string +from .compat import Morsel, MutableMapping, cookielib, urlparse, urlunparse + +try: + import threading +except ImportError: + import dummy_threading as threading + + +class MockRequest: + """Wraps a `requests.Request` to mimic a `urllib2.Request`. + + The code in `cookielib.CookieJar` expects this interface in order to correctly + manage cookie policies, i.e., determine whether a cookie can be set, given the + domains of the request and the cookie. + + The original request object is read-only. The client is responsible for collecting + the new headers via `get_new_headers()` and interpreting them appropriately. You + probably want `get_cookie_header`, defined below. + """ + + def __init__(self, request): + self._r = request + self._new_headers = {} + self.type = urlparse(self._r.url).scheme + + def get_type(self): + return self.type + + def get_host(self): + return urlparse(self._r.url).netloc + + def get_origin_req_host(self): + return self.get_host() + + def get_full_url(self): + # Only return the response's URL if the user hadn't set the Host + # header + if not self._r.headers.get("Host"): + return self._r.url + # If they did set it, retrieve it and reconstruct the expected domain + host = to_native_string(self._r.headers["Host"], encoding="utf-8") + parsed = urlparse(self._r.url) + # Reconstruct the URL as we expect it + return urlunparse( + [ + parsed.scheme, + host, + parsed.path, + parsed.params, + parsed.query, + parsed.fragment, + ] + ) + + def is_unverifiable(self): + return True + + def has_header(self, name): + return name in self._r.headers or name in self._new_headers + + def get_header(self, name, default=None): + return self._r.headers.get(name, self._new_headers.get(name, default)) + + def add_header(self, key, val): + """cookielib has no legitimate use for this method; add it back if you find one.""" + raise NotImplementedError( + "Cookie headers should be added with add_unredirected_header()" + ) + + def add_unredirected_header(self, name, value): + self._new_headers[name] = value + + def get_new_headers(self): + return self._new_headers + + @property + def unverifiable(self): + return self.is_unverifiable() + + @property + def origin_req_host(self): + return self.get_origin_req_host() + + @property + def host(self): + return self.get_host() + + +class MockResponse: + """Wraps a `httplib.HTTPMessage` to mimic a `urllib.addinfourl`. + + ...what? Basically, expose the parsed HTTP headers from the server response + the way `cookielib` expects to see them. + """ + + def __init__(self, headers): + """Make a MockResponse for `cookielib` to read. + + :param headers: a httplib.HTTPMessage or analogous carrying the headers + """ + self._headers = headers + + def info(self): + return self._headers + + def getheaders(self, name): + self._headers.getheaders(name) + + +def extract_cookies_to_jar(jar, request, response): + """Extract the cookies from the response into a CookieJar. + + :param jar: cookielib.CookieJar (not necessarily a RequestsCookieJar) + :param request: our own requests.Request object + :param response: urllib3.HTTPResponse object + """ + if not (hasattr(response, "_original_response") and response._original_response): + return + # the _original_response field is the wrapped httplib.HTTPResponse object, + req = MockRequest(request) + # pull out the HTTPMessage with the headers and put it in the mock: + res = MockResponse(response._original_response.msg) + jar.extract_cookies(res, req) + + +def get_cookie_header(jar, request): + """ + Produce an appropriate Cookie header string to be sent with `request`, or None. + + :rtype: str + """ + r = MockRequest(request) + jar.add_cookie_header(r) + return r.get_new_headers().get("Cookie") + + +def remove_cookie_by_name(cookiejar, name, domain=None, path=None): + """Unsets a cookie by name, by default over all domains and paths. + + Wraps CookieJar.clear(), is O(n). + """ + clearables = [] + for cookie in cookiejar: + if cookie.name != name: + continue + if domain is not None and domain != cookie.domain: + continue + if path is not None and path != cookie.path: + continue + clearables.append((cookie.domain, cookie.path, cookie.name)) + + for domain, path, name in clearables: + cookiejar.clear(domain, path, name) + + +class CookieConflictError(RuntimeError): + """There are two cookies that meet the criteria specified in the cookie jar. + Use .get and .set and include domain and path args in order to be more specific. + """ + + +class RequestsCookieJar(cookielib.CookieJar, MutableMapping): + """Compatibility class; is a cookielib.CookieJar, but exposes a dict + interface. + + This is the CookieJar we create by default for requests and sessions that + don't specify one, since some clients may expect response.cookies and + session.cookies to support dict operations. + + Requests does not use the dict interface internally; it's just for + compatibility with external client code. All requests code should work + out of the box with externally provided instances of ``CookieJar``, e.g. + ``LWPCookieJar`` and ``FileCookieJar``. + + Unlike a regular CookieJar, this class is pickleable. + + .. warning:: dictionary operations that are normally O(1) may be O(n). + """ + + def get(self, name, default=None, domain=None, path=None): + """Dict-like get() that also supports optional domain and path args in + order to resolve naming collisions from using one cookie jar over + multiple domains. + + .. warning:: operation is O(n), not O(1). + """ + try: + return self._find_no_duplicates(name, domain, path) + except KeyError: + return default + + def set(self, name, value, **kwargs): + """Dict-like set() that also supports optional domain and path args in + order to resolve naming collisions from using one cookie jar over + multiple domains. + """ + # support client code that unsets cookies by assignment of a None value: + if value is None: + remove_cookie_by_name( + self, name, domain=kwargs.get("domain"), path=kwargs.get("path") + ) + return + + if isinstance(value, Morsel): + c = morsel_to_cookie(value) + else: + c = create_cookie(name, value, **kwargs) + self.set_cookie(c) + return c + + def iterkeys(self): + """Dict-like iterkeys() that returns an iterator of names of cookies + from the jar. + + .. seealso:: itervalues() and iteritems(). + """ + for cookie in iter(self): + yield cookie.name + + def keys(self): + """Dict-like keys() that returns a list of names of cookies from the + jar. + + .. seealso:: values() and items(). + """ + return list(self.iterkeys()) + + def itervalues(self): + """Dict-like itervalues() that returns an iterator of values of cookies + from the jar. + + .. seealso:: iterkeys() and iteritems(). + """ + for cookie in iter(self): + yield cookie.value + + def values(self): + """Dict-like values() that returns a list of values of cookies from the + jar. + + .. seealso:: keys() and items(). + """ + return list(self.itervalues()) + + def iteritems(self): + """Dict-like iteritems() that returns an iterator of name-value tuples + from the jar. + + .. seealso:: iterkeys() and itervalues(). + """ + for cookie in iter(self): + yield cookie.name, cookie.value + + def items(self): + """Dict-like items() that returns a list of name-value tuples from the + jar. Allows client-code to call ``dict(RequestsCookieJar)`` and get a + vanilla python dict of key value pairs. + + .. seealso:: keys() and values(). + """ + return list(self.iteritems()) + + def list_domains(self): + """Utility method to list all the domains in the jar.""" + domains = [] + for cookie in iter(self): + if cookie.domain not in domains: + domains.append(cookie.domain) + return domains + + def list_paths(self): + """Utility method to list all the paths in the jar.""" + paths = [] + for cookie in iter(self): + if cookie.path not in paths: + paths.append(cookie.path) + return paths + + def multiple_domains(self): + """Returns True if there are multiple domains in the jar. + Returns False otherwise. + + :rtype: bool + """ + domains = [] + for cookie in iter(self): + if cookie.domain is not None and cookie.domain in domains: + return True + domains.append(cookie.domain) + return False # there is only one domain in jar + + def get_dict(self, domain=None, path=None): + """Takes as an argument an optional domain and path and returns a plain + old Python dict of name-value pairs of cookies that meet the + requirements. + + :rtype: dict + """ + dictionary = {} + for cookie in iter(self): + if (domain is None or cookie.domain == domain) and ( + path is None or cookie.path == path + ): + dictionary[cookie.name] = cookie.value + return dictionary + + def __contains__(self, name): + try: + return super().__contains__(name) + except CookieConflictError: + return True + + def __getitem__(self, name): + """Dict-like __getitem__() for compatibility with client code. Throws + exception if there are more than one cookie with name. In that case, + use the more explicit get() method instead. + + .. warning:: operation is O(n), not O(1). + """ + return self._find_no_duplicates(name) + + def __setitem__(self, name, value): + """Dict-like __setitem__ for compatibility with client code. Throws + exception if there is already a cookie of that name in the jar. In that + case, use the more explicit set() method instead. + """ + self.set(name, value) + + def __delitem__(self, name): + """Deletes a cookie given a name. Wraps ``cookielib.CookieJar``'s + ``remove_cookie_by_name()``. + """ + remove_cookie_by_name(self, name) + + def set_cookie(self, cookie, *args, **kwargs): + if ( + hasattr(cookie.value, "startswith") + and cookie.value.startswith('"') + and cookie.value.endswith('"') + ): + cookie.value = cookie.value.replace('\\"', "") + return super().set_cookie(cookie, *args, **kwargs) + + def update(self, other): + """Updates this jar with cookies from another CookieJar or dict-like""" + if isinstance(other, cookielib.CookieJar): + for cookie in other: + self.set_cookie(copy.copy(cookie)) + else: + super().update(other) + + def _find(self, name, domain=None, path=None): + """Requests uses this method internally to get cookie values. + + If there are conflicting cookies, _find arbitrarily chooses one. + See _find_no_duplicates if you want an exception thrown if there are + conflicting cookies. + + :param name: a string containing name of cookie + :param domain: (optional) string containing domain of cookie + :param path: (optional) string containing path of cookie + :return: cookie.value + """ + for cookie in iter(self): + if cookie.name == name: + if domain is None or cookie.domain == domain: + if path is None or cookie.path == path: + return cookie.value + + raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}") + + def _find_no_duplicates(self, name, domain=None, path=None): + """Both ``__get_item__`` and ``get`` call this function: it's never + used elsewhere in Requests. + + :param name: a string containing name of cookie + :param domain: (optional) string containing domain of cookie + :param path: (optional) string containing path of cookie + :raises KeyError: if cookie is not found + :raises CookieConflictError: if there are multiple cookies + that match name and optionally domain and path + :return: cookie.value + """ + toReturn = None + for cookie in iter(self): + if cookie.name == name: + if domain is None or cookie.domain == domain: + if path is None or cookie.path == path: + if toReturn is not None: + # if there are multiple cookies that meet passed in criteria + raise CookieConflictError( + f"There are multiple cookies with name, {name!r}" + ) + # we will eventually return this as long as no cookie conflict + toReturn = cookie.value + + if toReturn: + return toReturn + raise KeyError(f"name={name!r}, domain={domain!r}, path={path!r}") + + def __getstate__(self): + """Unlike a normal CookieJar, this class is pickleable.""" + state = self.__dict__.copy() + # remove the unpickleable RLock object + state.pop("_cookies_lock") + return state + + def __setstate__(self, state): + """Unlike a normal CookieJar, this class is pickleable.""" + self.__dict__.update(state) + if "_cookies_lock" not in self.__dict__: + self._cookies_lock = threading.RLock() + + def copy(self): + """Return a copy of this RequestsCookieJar.""" + new_cj = RequestsCookieJar() + new_cj.set_policy(self.get_policy()) + new_cj.update(self) + return new_cj + + def get_policy(self): + """Return the CookiePolicy instance used.""" + return self._policy + + +def _copy_cookie_jar(jar): + if jar is None: + return None + + if hasattr(jar, "copy"): + # We're dealing with an instance of RequestsCookieJar + return jar.copy() + # We're dealing with a generic CookieJar instance + new_jar = copy.copy(jar) + new_jar.clear() + for cookie in jar: + new_jar.set_cookie(copy.copy(cookie)) + return new_jar + + +def create_cookie(name, value, **kwargs): + """Make a cookie from underspecified parameters. + + By default, the pair of `name` and `value` will be set for the domain '' + and sent on every request (this is sometimes called a "supercookie"). + """ + result = { + "version": 0, + "name": name, + "value": value, + "port": None, + "domain": "", + "path": "/", + "secure": False, + "expires": None, + "discard": True, + "comment": None, + "comment_url": None, + "rest": {"HttpOnly": None}, + "rfc2109": False, + } + + badargs = set(kwargs) - set(result) + if badargs: + raise TypeError( + f"create_cookie() got unexpected keyword arguments: {list(badargs)}" + ) + + result.update(kwargs) + result["port_specified"] = bool(result["port"]) + result["domain_specified"] = bool(result["domain"]) + result["domain_initial_dot"] = result["domain"].startswith(".") + result["path_specified"] = bool(result["path"]) + + return cookielib.Cookie(**result) + + +def morsel_to_cookie(morsel): + """Convert a Morsel object into a Cookie containing the one k/v pair.""" + + expires = None + if morsel["max-age"]: + try: + expires = int(time.time() + int(morsel["max-age"])) + except ValueError: + raise TypeError(f"max-age: {morsel['max-age']} must be integer") + elif morsel["expires"]: + time_template = "%a, %d-%b-%Y %H:%M:%S GMT" + expires = calendar.timegm(time.strptime(morsel["expires"], time_template)) + return create_cookie( + comment=morsel["comment"], + comment_url=bool(morsel["comment"]), + discard=False, + domain=morsel["domain"], + expires=expires, + name=morsel.key, + path=morsel["path"], + port=None, + rest={"HttpOnly": morsel["httponly"]}, + rfc2109=False, + secure=bool(morsel["secure"]), + value=morsel.value, + version=morsel["version"] or 0, + ) + + +def cookiejar_from_dict(cookie_dict, cookiejar=None, overwrite=True): + """Returns a CookieJar from a key/value dictionary. + + :param cookie_dict: Dict of key/values to insert into CookieJar. + :param cookiejar: (optional) A cookiejar to add the cookies to. + :param overwrite: (optional) If False, will not replace cookies + already in the jar with new ones. + :rtype: CookieJar + """ + if cookiejar is None: + cookiejar = RequestsCookieJar() + + if cookie_dict is not None: + names_from_jar = [cookie.name for cookie in cookiejar] + for name in cookie_dict: + if overwrite or (name not in names_from_jar): + cookiejar.set_cookie(create_cookie(name, cookie_dict[name])) + + return cookiejar + + +def merge_cookies(cookiejar, cookies): + """Add cookies to cookiejar and returns a merged CookieJar. + + :param cookiejar: CookieJar object to add the cookies to. + :param cookies: Dictionary or CookieJar object to be added. + :rtype: CookieJar + """ + if not isinstance(cookiejar, cookielib.CookieJar): + raise ValueError("You can only merge into CookieJar") + + if isinstance(cookies, dict): + cookiejar = cookiejar_from_dict(cookies, cookiejar=cookiejar, overwrite=False) + elif isinstance(cookies, cookielib.CookieJar): + try: + cookiejar.update(cookies) + except AttributeError: + for cookie_in_jar in cookies: + cookiejar.set_cookie(cookie_in_jar) + + return cookiejar diff --git a/Modules/requests/exceptions.py b/Modules/requests/exceptions.py new file mode 100644 index 0000000..e1cedf8 --- /dev/null +++ b/Modules/requests/exceptions.py @@ -0,0 +1,141 @@ +""" +requests.exceptions +~~~~~~~~~~~~~~~~~~~ + +This module contains the set of Requests' exceptions. +""" +from urllib3.exceptions import HTTPError as BaseHTTPError + +from .compat import JSONDecodeError as CompatJSONDecodeError + + +class RequestException(IOError): + """There was an ambiguous exception that occurred while handling your + request. + """ + + def __init__(self, *args, **kwargs): + """Initialize RequestException with `request` and `response` objects.""" + response = kwargs.pop("response", None) + self.response = response + self.request = kwargs.pop("request", None) + if response is not None and not self.request and hasattr(response, "request"): + self.request = self.response.request + super().__init__(*args, **kwargs) + + +class InvalidJSONError(RequestException): + """A JSON error occurred.""" + + +class JSONDecodeError(InvalidJSONError, CompatJSONDecodeError): + """Couldn't decode the text into json""" + + def __init__(self, *args, **kwargs): + """ + Construct the JSONDecodeError instance first with all + args. Then use it's args to construct the IOError so that + the json specific args aren't used as IOError specific args + and the error message from JSONDecodeError is preserved. + """ + CompatJSONDecodeError.__init__(self, *args) + InvalidJSONError.__init__(self, *self.args, **kwargs) + + +class HTTPError(RequestException): + """An HTTP error occurred.""" + + +class ConnectionError(RequestException): + """A Connection error occurred.""" + + +class ProxyError(ConnectionError): + """A proxy error occurred.""" + + +class SSLError(ConnectionError): + """An SSL error occurred.""" + + +class Timeout(RequestException): + """The request timed out. + + Catching this error will catch both + :exc:`~requests.exceptions.ConnectTimeout` and + :exc:`~requests.exceptions.ReadTimeout` errors. + """ + + +class ConnectTimeout(ConnectionError, Timeout): + """The request timed out while trying to connect to the remote server. + + Requests that produced this error are safe to retry. + """ + + +class ReadTimeout(Timeout): + """The server did not send any data in the allotted amount of time.""" + + +class URLRequired(RequestException): + """A valid URL is required to make a request.""" + + +class TooManyRedirects(RequestException): + """Too many redirects.""" + + +class MissingSchema(RequestException, ValueError): + """The URL scheme (e.g. http or https) is missing.""" + + +class InvalidSchema(RequestException, ValueError): + """The URL scheme provided is either invalid or unsupported.""" + + +class InvalidURL(RequestException, ValueError): + """The URL provided was somehow invalid.""" + + +class InvalidHeader(RequestException, ValueError): + """The header value provided was somehow invalid.""" + + +class InvalidProxyURL(InvalidURL): + """The proxy URL provided is invalid.""" + + +class ChunkedEncodingError(RequestException): + """The server declared chunked encoding but sent an invalid chunk.""" + + +class ContentDecodingError(RequestException, BaseHTTPError): + """Failed to decode response content.""" + + +class StreamConsumedError(RequestException, TypeError): + """The content for this response was already consumed.""" + + +class RetryError(RequestException): + """Custom retries logic failed""" + + +class UnrewindableBodyError(RequestException): + """Requests encountered an error when trying to rewind a body.""" + + +# Warnings + + +class RequestsWarning(Warning): + """Base warning for Requests.""" + + +class FileModeWarning(RequestsWarning, DeprecationWarning): + """A file was opened in text mode, but Requests determined its binary length.""" + + +class RequestsDependencyWarning(RequestsWarning): + """An imported dependency doesn't match the expected version range.""" diff --git a/Modules/requests/help.py b/Modules/requests/help.py new file mode 100644 index 0000000..8fbcd65 --- /dev/null +++ b/Modules/requests/help.py @@ -0,0 +1,134 @@ +"""Module containing bug report helper(s).""" + +import json +import platform +import ssl +import sys + +import idna +import urllib3 + +from . import __version__ as requests_version + +try: + import charset_normalizer +except ImportError: + charset_normalizer = None + +try: + import chardet +except ImportError: + chardet = None + +try: + from urllib3.contrib import pyopenssl +except ImportError: + pyopenssl = None + OpenSSL = None + cryptography = None +else: + import cryptography + import OpenSSL + + +def _implementation(): + """Return a dict with the Python implementation and version. + + Provide both the name and the version of the Python implementation + currently running. For example, on CPython 3.10.3 it will return + {'name': 'CPython', 'version': '3.10.3'}. + + This function works best on CPython and PyPy: in particular, it probably + doesn't work for Jython or IronPython. Future investigation should be done + to work out the correct shape of the code for those platforms. + """ + implementation = platform.python_implementation() + + if implementation == "CPython": + implementation_version = platform.python_version() + elif implementation == "PyPy": + implementation_version = "{}.{}.{}".format( + sys.pypy_version_info.major, + sys.pypy_version_info.minor, + sys.pypy_version_info.micro, + ) + if sys.pypy_version_info.releaselevel != "final": + implementation_version = "".join( + [implementation_version, sys.pypy_version_info.releaselevel] + ) + elif implementation == "Jython": + implementation_version = platform.python_version() # Complete Guess + elif implementation == "IronPython": + implementation_version = platform.python_version() # Complete Guess + else: + implementation_version = "Unknown" + + return {"name": implementation, "version": implementation_version} + + +def info(): + """Generate information for a bug report.""" + try: + platform_info = { + "system": platform.system(), + "release": platform.release(), + } + except OSError: + platform_info = { + "system": "Unknown", + "release": "Unknown", + } + + implementation_info = _implementation() + urllib3_info = {"version": urllib3.__version__} + charset_normalizer_info = {"version": None} + chardet_info = {"version": None} + if charset_normalizer: + charset_normalizer_info = {"version": charset_normalizer.__version__} + if chardet: + chardet_info = {"version": chardet.__version__} + + pyopenssl_info = { + "version": None, + "openssl_version": "", + } + if OpenSSL: + pyopenssl_info = { + "version": OpenSSL.__version__, + "openssl_version": f"{OpenSSL.SSL.OPENSSL_VERSION_NUMBER:x}", + } + cryptography_info = { + "version": getattr(cryptography, "__version__", ""), + } + idna_info = { + "version": getattr(idna, "__version__", ""), + } + + system_ssl = ssl.OPENSSL_VERSION_NUMBER + system_ssl_info = {"version": f"{system_ssl:x}" if system_ssl is not None else ""} + + return { + "platform": platform_info, + "implementation": implementation_info, + "system_ssl": system_ssl_info, + "using_pyopenssl": pyopenssl is not None, + "using_charset_normalizer": chardet is None, + "pyOpenSSL": pyopenssl_info, + "urllib3": urllib3_info, + "chardet": chardet_info, + "charset_normalizer": charset_normalizer_info, + "cryptography": cryptography_info, + "idna": idna_info, + "requests": { + "version": requests_version, + }, + } + + +def main(): + """Pretty-print the bug information as JSON.""" + print(json.dumps(info(), sort_keys=True, indent=2)) + + +if __name__ == "__main__": + main() diff --git a/Modules/requests/hooks.py b/Modules/requests/hooks.py new file mode 100644 index 0000000..d181ba2 --- /dev/null +++ b/Modules/requests/hooks.py @@ -0,0 +1,33 @@ +""" +requests.hooks +~~~~~~~~~~~~~~ + +This module provides the capabilities for the Requests hooks system. + +Available hooks: + +``response``: + The response generated from a Request. +""" +HOOKS = ["response"] + + +def default_hooks(): + return {event: [] for event in HOOKS} + + +# TODO: response is the only one + + +def dispatch_hook(key, hooks, hook_data, **kwargs): + """Dispatches a hook dictionary on a given piece of data.""" + hooks = hooks or {} + hooks = hooks.get(key) + if hooks: + if hasattr(hooks, "__call__"): + hooks = [hooks] + for hook in hooks: + _hook_data = hook(hook_data, **kwargs) + if _hook_data is not None: + hook_data = _hook_data + return hook_data diff --git a/Modules/requests/models.py b/Modules/requests/models.py new file mode 100644 index 0000000..617a413 --- /dev/null +++ b/Modules/requests/models.py @@ -0,0 +1,1034 @@ +""" +requests.models +~~~~~~~~~~~~~~~ + +This module contains the primary objects that power Requests. +""" + +import datetime + +# Import encoding now, to avoid implicit import later. +# Implicit import within threads may cause LookupError when standard library is in a ZIP, +# such as in Embedded Python. See https://github.com/psf/requests/issues/3578. +import encodings.idna # noqa: F401 +from io import UnsupportedOperation + +from urllib3.exceptions import ( + DecodeError, + LocationParseError, + ProtocolError, + ReadTimeoutError, + SSLError, +) +from urllib3.fields import RequestField +from urllib3.filepost import encode_multipart_formdata +from urllib3.util import parse_url + +from ._internal_utils import to_native_string, unicode_is_ascii +from .auth import HTTPBasicAuth +from .compat import ( + Callable, + JSONDecodeError, + Mapping, + basestring, + builtin_str, + chardet, + cookielib, +) +from .compat import json as complexjson +from .compat import urlencode, urlsplit, urlunparse +from .cookies import _copy_cookie_jar, cookiejar_from_dict, get_cookie_header +from .exceptions import ( + ChunkedEncodingError, + ConnectionError, + ContentDecodingError, + HTTPError, + InvalidJSONError, + InvalidURL, +) +from .exceptions import JSONDecodeError as RequestsJSONDecodeError +from .exceptions import MissingSchema +from .exceptions import SSLError as RequestsSSLError +from .exceptions import StreamConsumedError +from .hooks import default_hooks +from .status_codes import codes +from .structures import CaseInsensitiveDict +from .utils import ( + check_header_validity, + get_auth_from_url, + guess_filename, + guess_json_utf, + iter_slices, + parse_header_links, + requote_uri, + stream_decode_response_unicode, + super_len, + to_key_val_list, +) + +#: The set of HTTP status codes that indicate an automatically +#: processable redirect. +REDIRECT_STATI = ( + codes.moved, # 301 + codes.found, # 302 + codes.other, # 303 + codes.temporary_redirect, # 307 + codes.permanent_redirect, # 308 +) + +DEFAULT_REDIRECT_LIMIT = 30 +CONTENT_CHUNK_SIZE = 10 * 1024 +ITER_CHUNK_SIZE = 512 + + +class RequestEncodingMixin: + @property + def path_url(self): + """Build the path URL to use.""" + + url = [] + + p = urlsplit(self.url) + + path = p.path + if not path: + path = "/" + + url.append(path) + + query = p.query + if query: + url.append("?") + url.append(query) + + return "".join(url) + + @staticmethod + def _encode_params(data): + """Encode parameters in a piece of data. + + Will successfully encode parameters when passed as a dict or a list of + 2-tuples. Order is retained if data is a list of 2-tuples but arbitrary + if parameters are supplied as a dict. + """ + + if isinstance(data, (str, bytes)): + return data + elif hasattr(data, "read"): + return data + elif hasattr(data, "__iter__"): + result = [] + for k, vs in to_key_val_list(data): + if isinstance(vs, basestring) or not hasattr(vs, "__iter__"): + vs = [vs] + for v in vs: + if v is not None: + result.append( + ( + k.encode("utf-8") if isinstance(k, str) else k, + v.encode("utf-8") if isinstance(v, str) else v, + ) + ) + return urlencode(result, doseq=True) + else: + return data + + @staticmethod + def _encode_files(files, data): + """Build the body for a multipart/form-data request. + + Will successfully encode files when passed as a dict or a list of + tuples. Order is retained if data is a list of tuples but arbitrary + if parameters are supplied as a dict. + The tuples may be 2-tuples (filename, fileobj), 3-tuples (filename, fileobj, contentype) + or 4-tuples (filename, fileobj, contentype, custom_headers). + """ + if not files: + raise ValueError("Files must be provided.") + elif isinstance(data, basestring): + raise ValueError("Data must not be a string.") + + new_fields = [] + fields = to_key_val_list(data or {}) + files = to_key_val_list(files or {}) + + for field, val in fields: + if isinstance(val, basestring) or not hasattr(val, "__iter__"): + val = [val] + for v in val: + if v is not None: + # Don't call str() on bytestrings: in Py3 it all goes wrong. + if not isinstance(v, bytes): + v = str(v) + + new_fields.append( + ( + field.decode("utf-8") + if isinstance(field, bytes) + else field, + v.encode("utf-8") if isinstance(v, str) else v, + ) + ) + + for (k, v) in files: + # support for explicit filename + ft = None + fh = None + if isinstance(v, (tuple, list)): + if len(v) == 2: + fn, fp = v + elif len(v) == 3: + fn, fp, ft = v + else: + fn, fp, ft, fh = v + else: + fn = guess_filename(v) or k + fp = v + + if isinstance(fp, (str, bytes, bytearray)): + fdata = fp + elif hasattr(fp, "read"): + fdata = fp.read() + elif fp is None: + continue + else: + fdata = fp + + rf = RequestField(name=k, data=fdata, filename=fn, headers=fh) + rf.make_multipart(content_type=ft) + new_fields.append(rf) + + body, content_type = encode_multipart_formdata(new_fields) + + return body, content_type + + +class RequestHooksMixin: + def register_hook(self, event, hook): + """Properly register a hook.""" + + if event not in self.hooks: + raise ValueError(f'Unsupported event specified, with event name "{event}"') + + if isinstance(hook, Callable): + self.hooks[event].append(hook) + elif hasattr(hook, "__iter__"): + self.hooks[event].extend(h for h in hook if isinstance(h, Callable)) + + def deregister_hook(self, event, hook): + """Deregister a previously registered hook. + Returns True if the hook existed, False if not. + """ + + try: + self.hooks[event].remove(hook) + return True + except ValueError: + return False + + +class Request(RequestHooksMixin): + """A user-created :class:`Request ` object. + + Used to prepare a :class:`PreparedRequest `, which is sent to the server. + + :param method: HTTP method to use. + :param url: URL to send. + :param headers: dictionary of headers to send. + :param files: dictionary of {filename: fileobject} files to multipart upload. + :param data: the body to attach to the request. If a dictionary or + list of tuples ``[(key, value)]`` is provided, form-encoding will + take place. + :param json: json for the body to attach to the request (if files or data is not specified). + :param params: URL parameters to append to the URL. If a dictionary or + list of tuples ``[(key, value)]`` is provided, form-encoding will + take place. + :param auth: Auth handler or (user, pass) tuple. + :param cookies: dictionary or CookieJar of cookies to attach to this request. + :param hooks: dictionary of callback hooks, for internal usage. + + Usage:: + + >>> import requests + >>> req = requests.Request('GET', 'https://httpbin.org/get') + >>> req.prepare() + + """ + + def __init__( + self, + method=None, + url=None, + headers=None, + files=None, + data=None, + params=None, + auth=None, + cookies=None, + hooks=None, + json=None, + ): + + # Default empty dicts for dict params. + data = [] if data is None else data + files = [] if files is None else files + headers = {} if headers is None else headers + params = {} if params is None else params + hooks = {} if hooks is None else hooks + + self.hooks = default_hooks() + for (k, v) in list(hooks.items()): + self.register_hook(event=k, hook=v) + + self.method = method + self.url = url + self.headers = headers + self.files = files + self.data = data + self.json = json + self.params = params + self.auth = auth + self.cookies = cookies + + def __repr__(self): + return f"" + + def prepare(self): + """Constructs a :class:`PreparedRequest ` for transmission and returns it.""" + p = PreparedRequest() + p.prepare( + method=self.method, + url=self.url, + headers=self.headers, + files=self.files, + data=self.data, + json=self.json, + params=self.params, + auth=self.auth, + cookies=self.cookies, + hooks=self.hooks, + ) + return p + + +class PreparedRequest(RequestEncodingMixin, RequestHooksMixin): + """The fully mutable :class:`PreparedRequest ` object, + containing the exact bytes that will be sent to the server. + + Instances are generated from a :class:`Request ` object, and + should not be instantiated manually; doing so may produce undesirable + effects. + + Usage:: + + >>> import requests + >>> req = requests.Request('GET', 'https://httpbin.org/get') + >>> r = req.prepare() + >>> r + + + >>> s = requests.Session() + >>> s.send(r) + + """ + + def __init__(self): + #: HTTP verb to send to the server. + self.method = None + #: HTTP URL to send the request to. + self.url = None + #: dictionary of HTTP headers. + self.headers = None + # The `CookieJar` used to create the Cookie header will be stored here + # after prepare_cookies is called + self._cookies = None + #: request body to send to the server. + self.body = None + #: dictionary of callback hooks, for internal usage. + self.hooks = default_hooks() + #: integer denoting starting position of a readable file-like body. + self._body_position = None + + def prepare( + self, + method=None, + url=None, + headers=None, + files=None, + data=None, + params=None, + auth=None, + cookies=None, + hooks=None, + json=None, + ): + """Prepares the entire request with the given parameters.""" + + self.prepare_method(method) + self.prepare_url(url, params) + self.prepare_headers(headers) + self.prepare_cookies(cookies) + self.prepare_body(data, files, json) + self.prepare_auth(auth, url) + + # Note that prepare_auth must be last to enable authentication schemes + # such as OAuth to work on a fully prepared request. + + # This MUST go after prepare_auth. Authenticators could add a hook + self.prepare_hooks(hooks) + + def __repr__(self): + return f"" + + def copy(self): + p = PreparedRequest() + p.method = self.method + p.url = self.url + p.headers = self.headers.copy() if self.headers is not None else None + p._cookies = _copy_cookie_jar(self._cookies) + p.body = self.body + p.hooks = self.hooks + p._body_position = self._body_position + return p + + def prepare_method(self, method): + """Prepares the given HTTP method.""" + self.method = method + if self.method is not None: + self.method = to_native_string(self.method.upper()) + + @staticmethod + def _get_idna_encoded_host(host): + import idna + + try: + host = idna.encode(host, uts46=True).decode("utf-8") + except idna.IDNAError: + raise UnicodeError + return host + + def prepare_url(self, url, params): + """Prepares the given HTTP URL.""" + #: Accept objects that have string representations. + #: We're unable to blindly call unicode/str functions + #: as this will include the bytestring indicator (b'') + #: on python 3.x. + #: https://github.com/psf/requests/pull/2238 + if isinstance(url, bytes): + url = url.decode("utf8") + else: + url = str(url) + + # Remove leading whitespaces from url + url = url.lstrip() + + # Don't do any URL preparation for non-HTTP schemes like `mailto`, + # `data` etc to work around exceptions from `url_parse`, which + # handles RFC 3986 only. + if ":" in url and not url.lower().startswith("http"): + self.url = url + return + + # Support for unicode domain names and paths. + try: + scheme, auth, host, port, path, query, fragment = parse_url(url) + except LocationParseError as e: + raise InvalidURL(*e.args) + + if not scheme: + raise MissingSchema( + f"Invalid URL {url!r}: No scheme supplied. " + f"Perhaps you meant https://{url}?" + ) + + if not host: + raise InvalidURL(f"Invalid URL {url!r}: No host supplied") + + # In general, we want to try IDNA encoding the hostname if the string contains + # non-ASCII characters. This allows users to automatically get the correct IDNA + # behaviour. For strings containing only ASCII characters, we need to also verify + # it doesn't start with a wildcard (*), before allowing the unencoded hostname. + if not unicode_is_ascii(host): + try: + host = self._get_idna_encoded_host(host) + except UnicodeError: + raise InvalidURL("URL has an invalid label.") + elif host.startswith(("*", ".")): + raise InvalidURL("URL has an invalid label.") + + # Carefully reconstruct the network location + netloc = auth or "" + if netloc: + netloc += "@" + netloc += host + if port: + netloc += f":{port}" + + # Bare domains aren't valid URLs. + if not path: + path = "/" + + if isinstance(params, (str, bytes)): + params = to_native_string(params) + + enc_params = self._encode_params(params) + if enc_params: + if query: + query = f"{query}&{enc_params}" + else: + query = enc_params + + url = requote_uri(urlunparse([scheme, netloc, path, None, query, fragment])) + self.url = url + + def prepare_headers(self, headers): + """Prepares the given HTTP headers.""" + + self.headers = CaseInsensitiveDict() + if headers: + for header in headers.items(): + # Raise exception on invalid header value. + check_header_validity(header) + name, value = header + self.headers[to_native_string(name)] = value + + def prepare_body(self, data, files, json=None): + """Prepares the given HTTP body data.""" + + # Check if file, fo, generator, iterator. + # If not, run through normal process. + + # Nottin' on you. + body = None + content_type = None + + if not data and json is not None: + # urllib3 requires a bytes-like body. Python 2's json.dumps + # provides this natively, but Python 3 gives a Unicode string. + content_type = "application/json" + + try: + body = complexjson.dumps(json, allow_nan=False) + except ValueError as ve: + raise InvalidJSONError(ve, request=self) + + if not isinstance(body, bytes): + body = body.encode("utf-8") + + is_stream = all( + [ + hasattr(data, "__iter__"), + not isinstance(data, (basestring, list, tuple, Mapping)), + ] + ) + + if is_stream: + try: + length = super_len(data) + except (TypeError, AttributeError, UnsupportedOperation): + length = None + + body = data + + if getattr(body, "tell", None) is not None: + # Record the current file position before reading. + # This will allow us to rewind a file in the event + # of a redirect. + try: + self._body_position = body.tell() + except OSError: + # This differentiates from None, allowing us to catch + # a failed `tell()` later when trying to rewind the body + self._body_position = object() + + if files: + raise NotImplementedError( + "Streamed bodies and files are mutually exclusive." + ) + + if length: + self.headers["Content-Length"] = builtin_str(length) + else: + self.headers["Transfer-Encoding"] = "chunked" + else: + # Multi-part file uploads. + if files: + (body, content_type) = self._encode_files(files, data) + else: + if data: + body = self._encode_params(data) + if isinstance(data, basestring) or hasattr(data, "read"): + content_type = None + else: + content_type = "application/x-www-form-urlencoded" + + self.prepare_content_length(body) + + # Add content-type if it wasn't explicitly provided. + if content_type and ("content-type" not in self.headers): + self.headers["Content-Type"] = content_type + + self.body = body + + def prepare_content_length(self, body): + """Prepare Content-Length header based on request method and body""" + if body is not None: + length = super_len(body) + if length: + # If length exists, set it. Otherwise, we fallback + # to Transfer-Encoding: chunked. + self.headers["Content-Length"] = builtin_str(length) + elif ( + self.method not in ("GET", "HEAD") + and self.headers.get("Content-Length") is None + ): + # Set Content-Length to 0 for methods that can have a body + # but don't provide one. (i.e. not GET or HEAD) + self.headers["Content-Length"] = "0" + + def prepare_auth(self, auth, url=""): + """Prepares the given HTTP auth data.""" + + # If no Auth is explicitly provided, extract it from the URL first. + if auth is None: + url_auth = get_auth_from_url(self.url) + auth = url_auth if any(url_auth) else None + + if auth: + if isinstance(auth, tuple) and len(auth) == 2: + # special-case basic HTTP auth + auth = HTTPBasicAuth(*auth) + + # Allow auth to make its changes. + r = auth(self) + + # Update self to reflect the auth changes. + self.__dict__.update(r.__dict__) + + # Recompute Content-Length + self.prepare_content_length(self.body) + + def prepare_cookies(self, cookies): + """Prepares the given HTTP cookie data. + + This function eventually generates a ``Cookie`` header from the + given cookies using cookielib. Due to cookielib's design, the header + will not be regenerated if it already exists, meaning this function + can only be called once for the life of the + :class:`PreparedRequest ` object. Any subsequent calls + to ``prepare_cookies`` will have no actual effect, unless the "Cookie" + header is removed beforehand. + """ + if isinstance(cookies, cookielib.CookieJar): + self._cookies = cookies + else: + self._cookies = cookiejar_from_dict(cookies) + + cookie_header = get_cookie_header(self._cookies, self) + if cookie_header is not None: + self.headers["Cookie"] = cookie_header + + def prepare_hooks(self, hooks): + """Prepares the given hooks.""" + # hooks can be passed as None to the prepare method and to this + # method. To prevent iterating over None, simply use an empty list + # if hooks is False-y + hooks = hooks or [] + for event in hooks: + self.register_hook(event, hooks[event]) + + +class Response: + """The :class:`Response ` object, which contains a + server's response to an HTTP request. + """ + + __attrs__ = [ + "_content", + "status_code", + "headers", + "url", + "history", + "encoding", + "reason", + "cookies", + "elapsed", + "request", + ] + + def __init__(self): + self._content = False + self._content_consumed = False + self._next = None + + #: Integer Code of responded HTTP Status, e.g. 404 or 200. + self.status_code = None + + #: Case-insensitive Dictionary of Response Headers. + #: For example, ``headers['content-encoding']`` will return the + #: value of a ``'Content-Encoding'`` response header. + self.headers = CaseInsensitiveDict() + + #: File-like object representation of response (for advanced usage). + #: Use of ``raw`` requires that ``stream=True`` be set on the request. + #: This requirement does not apply for use internally to Requests. + self.raw = None + + #: Final URL location of Response. + self.url = None + + #: Encoding to decode with when accessing r.text. + self.encoding = None + + #: A list of :class:`Response ` objects from + #: the history of the Request. Any redirect responses will end + #: up here. The list is sorted from the oldest to the most recent request. + self.history = [] + + #: Textual reason of responded HTTP Status, e.g. "Not Found" or "OK". + self.reason = None + + #: A CookieJar of Cookies the server sent back. + self.cookies = cookiejar_from_dict({}) + + #: The amount of time elapsed between sending the request + #: and the arrival of the response (as a timedelta). + #: This property specifically measures the time taken between sending + #: the first byte of the request and finishing parsing the headers. It + #: is therefore unaffected by consuming the response content or the + #: value of the ``stream`` keyword argument. + self.elapsed = datetime.timedelta(0) + + #: The :class:`PreparedRequest ` object to which this + #: is a response. + self.request = None + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + def __getstate__(self): + # Consume everything; accessing the content attribute makes + # sure the content has been fully read. + if not self._content_consumed: + self.content + + return {attr: getattr(self, attr, None) for attr in self.__attrs__} + + def __setstate__(self, state): + for name, value in state.items(): + setattr(self, name, value) + + # pickled objects do not have .raw + setattr(self, "_content_consumed", True) + setattr(self, "raw", None) + + def __repr__(self): + return f"" + + def __bool__(self): + """Returns True if :attr:`status_code` is less than 400. + + This attribute checks if the status code of the response is between + 400 and 600 to see if there was a client error or a server error. If + the status code, is between 200 and 400, this will return True. This + is **not** a check to see if the response code is ``200 OK``. + """ + return self.ok + + def __nonzero__(self): + """Returns True if :attr:`status_code` is less than 400. + + This attribute checks if the status code of the response is between + 400 and 600 to see if there was a client error or a server error. If + the status code, is between 200 and 400, this will return True. This + is **not** a check to see if the response code is ``200 OK``. + """ + return self.ok + + def __iter__(self): + """Allows you to use a response as an iterator.""" + return self.iter_content(128) + + @property + def ok(self): + """Returns True if :attr:`status_code` is less than 400, False if not. + + This attribute checks if the status code of the response is between + 400 and 600 to see if there was a client error or a server error. If + the status code is between 200 and 400, this will return True. This + is **not** a check to see if the response code is ``200 OK``. + """ + try: + self.raise_for_status() + except HTTPError: + return False + return True + + @property + def is_redirect(self): + """True if this Response is a well-formed HTTP redirect that could have + been processed automatically (by :meth:`Session.resolve_redirects`). + """ + return "location" in self.headers and self.status_code in REDIRECT_STATI + + @property + def is_permanent_redirect(self): + """True if this Response one of the permanent versions of redirect.""" + return "location" in self.headers and self.status_code in ( + codes.moved_permanently, + codes.permanent_redirect, + ) + + @property + def next(self): + """Returns a PreparedRequest for the next request in a redirect chain, if there is one.""" + return self._next + + @property + def apparent_encoding(self): + """The apparent encoding, provided by the charset_normalizer or chardet libraries.""" + return chardet.detect(self.content)["encoding"] + + def iter_content(self, chunk_size=1, decode_unicode=False): + """Iterates over the response data. When stream=True is set on the + request, this avoids reading the content at once into memory for + large responses. The chunk size is the number of bytes it should + read into memory. This is not necessarily the length of each item + returned as decoding can take place. + + chunk_size must be of type int or None. A value of None will + function differently depending on the value of `stream`. + stream=True will read data as it arrives in whatever size the + chunks are received. If stream=False, data is returned as + a single chunk. + + If decode_unicode is True, content will be decoded using the best + available encoding based on the response. + """ + + def generate(): + # Special case for urllib3. + if hasattr(self.raw, "stream"): + try: + yield from self.raw.stream(chunk_size, decode_content=True) + except ProtocolError as e: + raise ChunkedEncodingError(e) + except DecodeError as e: + raise ContentDecodingError(e) + except ReadTimeoutError as e: + raise ConnectionError(e) + except SSLError as e: + raise RequestsSSLError(e) + else: + # Standard file-like object. + while True: + chunk = self.raw.read(chunk_size) + if not chunk: + break + yield chunk + + self._content_consumed = True + + if self._content_consumed and isinstance(self._content, bool): + raise StreamConsumedError() + elif chunk_size is not None and not isinstance(chunk_size, int): + raise TypeError( + f"chunk_size must be an int, it is instead a {type(chunk_size)}." + ) + # simulate reading small chunks of the content + reused_chunks = iter_slices(self._content, chunk_size) + + stream_chunks = generate() + + chunks = reused_chunks if self._content_consumed else stream_chunks + + if decode_unicode: + chunks = stream_decode_response_unicode(chunks, self) + + return chunks + + def iter_lines( + self, chunk_size=ITER_CHUNK_SIZE, decode_unicode=False, delimiter=None + ): + """Iterates over the response data, one line at a time. When + stream=True is set on the request, this avoids reading the + content at once into memory for large responses. + + .. note:: This method is not reentrant safe. + """ + + pending = None + + for chunk in self.iter_content( + chunk_size=chunk_size, decode_unicode=decode_unicode + ): + + if pending is not None: + chunk = pending + chunk + + if delimiter: + lines = chunk.split(delimiter) + else: + lines = chunk.splitlines() + + if lines and lines[-1] and chunk and lines[-1][-1] == chunk[-1]: + pending = lines.pop() + else: + pending = None + + yield from lines + + if pending is not None: + yield pending + + @property + def content(self): + """Content of the response, in bytes.""" + + if self._content is False: + # Read the contents. + if self._content_consumed: + raise RuntimeError("The content for this response was already consumed") + + if self.status_code == 0 or self.raw is None: + self._content = None + else: + self._content = b"".join(self.iter_content(CONTENT_CHUNK_SIZE)) or b"" + + self._content_consumed = True + # don't need to release the connection; that's been handled by urllib3 + # since we exhausted the data. + return self._content + + @property + def text(self): + """Content of the response, in unicode. + + If Response.encoding is None, encoding will be guessed using + ``charset_normalizer`` or ``chardet``. + + The encoding of the response content is determined based solely on HTTP + headers, following RFC 2616 to the letter. If you can take advantage of + non-HTTP knowledge to make a better guess at the encoding, you should + set ``r.encoding`` appropriately before accessing this property. + """ + + # Try charset from content-type + content = None + encoding = self.encoding + + if not self.content: + return "" + + # Fallback to auto-detected encoding. + if self.encoding is None: + encoding = self.apparent_encoding + + # Decode unicode from given encoding. + try: + content = str(self.content, encoding, errors="replace") + except (LookupError, TypeError): + # A LookupError is raised if the encoding was not found which could + # indicate a misspelling or similar mistake. + # + # A TypeError can be raised if encoding is None + # + # So we try blindly encoding. + content = str(self.content, errors="replace") + + return content + + def json(self, **kwargs): + r"""Returns the json-encoded content of a response, if any. + + :param \*\*kwargs: Optional arguments that ``json.loads`` takes. + :raises requests.exceptions.JSONDecodeError: If the response body does not + contain valid json. + """ + + if not self.encoding and self.content and len(self.content) > 3: + # No encoding set. JSON RFC 4627 section 3 states we should expect + # UTF-8, -16 or -32. Detect which one to use; If the detection or + # decoding fails, fall back to `self.text` (using charset_normalizer to make + # a best guess). + encoding = guess_json_utf(self.content) + if encoding is not None: + try: + return complexjson.loads(self.content.decode(encoding), **kwargs) + except UnicodeDecodeError: + # Wrong UTF codec detected; usually because it's not UTF-8 + # but some other 8-bit codec. This is an RFC violation, + # and the server didn't bother to tell us what codec *was* + # used. + pass + except JSONDecodeError as e: + raise RequestsJSONDecodeError(e.msg, e.doc, e.pos) + + try: + return complexjson.loads(self.text, **kwargs) + except JSONDecodeError as e: + # Catch JSON-related errors and raise as requests.JSONDecodeError + # This aliases json.JSONDecodeError and simplejson.JSONDecodeError + raise RequestsJSONDecodeError(e.msg, e.doc, e.pos) + + @property + def links(self): + """Returns the parsed header links of the response, if any.""" + + header = self.headers.get("link") + + resolved_links = {} + + if header: + links = parse_header_links(header) + + for link in links: + key = link.get("rel") or link.get("url") + resolved_links[key] = link + + return resolved_links + + def raise_for_status(self): + """Raises :class:`HTTPError`, if one occurred.""" + + http_error_msg = "" + if isinstance(self.reason, bytes): + # We attempt to decode utf-8 first because some servers + # choose to localize their reason strings. If the string + # isn't utf-8, we fall back to iso-8859-1 for all other + # encodings. (See PR #3538) + try: + reason = self.reason.decode("utf-8") + except UnicodeDecodeError: + reason = self.reason.decode("iso-8859-1") + else: + reason = self.reason + + if 400 <= self.status_code < 500: + http_error_msg = ( + f"{self.status_code} Client Error: {reason} for url: {self.url}" + ) + + elif 500 <= self.status_code < 600: + http_error_msg = ( + f"{self.status_code} Server Error: {reason} for url: {self.url}" + ) + + if http_error_msg: + raise HTTPError(http_error_msg, response=self) + + def close(self): + """Releases the connection back to the pool. Once this method has been + called the underlying ``raw`` object must not be accessed again. + + *Note: Should not normally need to be called explicitly.* + """ + if not self._content_consumed: + self.raw.close() + + release_conn = getattr(self.raw, "release_conn", None) + if release_conn is not None: + release_conn() diff --git a/Modules/requests/packages.py b/Modules/requests/packages.py new file mode 100644 index 0000000..77c45c9 --- /dev/null +++ b/Modules/requests/packages.py @@ -0,0 +1,28 @@ +import sys + +try: + import chardet +except ImportError: + import warnings + + import charset_normalizer as chardet + + warnings.filterwarnings("ignore", "Trying to detect", module="charset_normalizer") + +# This code exists for backwards compatibility reasons. +# I don't like it either. Just look the other way. :) + +for package in ("urllib3", "idna"): + locals()[package] = __import__(package) + # This traversal is apparently necessary such that the identities are + # preserved (requests.packages.urllib3.* is urllib3.*) + for mod in list(sys.modules): + if mod == package or mod.startswith(f"{package}."): + sys.modules[f"requests.packages.{mod}"] = sys.modules[mod] + +target = chardet.__name__ +for mod in list(sys.modules): + if mod == target or mod.startswith(f"{target}."): + target = target.replace(target, "chardet") + sys.modules[f"requests.packages.{target}"] = sys.modules[mod] +# Kinda cool, though, right? diff --git a/Modules/requests/sessions.py b/Modules/requests/sessions.py new file mode 100644 index 0000000..dbcf2a7 --- /dev/null +++ b/Modules/requests/sessions.py @@ -0,0 +1,833 @@ +""" +requests.sessions +~~~~~~~~~~~~~~~~~ + +This module provides a Session object to manage and persist settings across +requests (cookies, auth, proxies). +""" +import os +import sys +import time +from collections import OrderedDict +from datetime import timedelta + +from ._internal_utils import to_native_string +from .adapters import HTTPAdapter +from .auth import _basic_auth_str +from .compat import Mapping, cookielib, urljoin, urlparse +from .cookies import ( + RequestsCookieJar, + cookiejar_from_dict, + extract_cookies_to_jar, + merge_cookies, +) +from .exceptions import ( + ChunkedEncodingError, + ContentDecodingError, + InvalidSchema, + TooManyRedirects, +) +from .hooks import default_hooks, dispatch_hook + +# formerly defined here, reexposed here for backward compatibility +from .models import ( # noqa: F401 + DEFAULT_REDIRECT_LIMIT, + REDIRECT_STATI, + PreparedRequest, + Request, +) +from .status_codes import codes +from .structures import CaseInsensitiveDict +from .utils import ( # noqa: F401 + DEFAULT_PORTS, + default_headers, + get_auth_from_url, + get_environ_proxies, + get_netrc_auth, + requote_uri, + resolve_proxies, + rewind_body, + should_bypass_proxies, + to_key_val_list, +) + +# Preferred clock, based on which one is more accurate on a given system. +if sys.platform == "win32": + preferred_clock = time.perf_counter +else: + preferred_clock = time.time + + +def merge_setting(request_setting, session_setting, dict_class=OrderedDict): + """Determines appropriate setting for a given request, taking into account + the explicit setting on that request, and the setting in the session. If a + setting is a dictionary, they will be merged together using `dict_class` + """ + + if session_setting is None: + return request_setting + + if request_setting is None: + return session_setting + + # Bypass if not a dictionary (e.g. verify) + if not ( + isinstance(session_setting, Mapping) and isinstance(request_setting, Mapping) + ): + return request_setting + + merged_setting = dict_class(to_key_val_list(session_setting)) + merged_setting.update(to_key_val_list(request_setting)) + + # Remove keys that are set to None. Extract keys first to avoid altering + # the dictionary during iteration. + none_keys = [k for (k, v) in merged_setting.items() if v is None] + for key in none_keys: + del merged_setting[key] + + return merged_setting + + +def merge_hooks(request_hooks, session_hooks, dict_class=OrderedDict): + """Properly merges both requests and session hooks. + + This is necessary because when request_hooks == {'response': []}, the + merge breaks Session hooks entirely. + """ + if session_hooks is None or session_hooks.get("response") == []: + return request_hooks + + if request_hooks is None or request_hooks.get("response") == []: + return session_hooks + + return merge_setting(request_hooks, session_hooks, dict_class) + + +class SessionRedirectMixin: + def get_redirect_target(self, resp): + """Receives a Response. Returns a redirect URI or ``None``""" + # Due to the nature of how requests processes redirects this method will + # be called at least once upon the original response and at least twice + # on each subsequent redirect response (if any). + # If a custom mixin is used to handle this logic, it may be advantageous + # to cache the redirect location onto the response object as a private + # attribute. + if resp.is_redirect: + location = resp.headers["location"] + # Currently the underlying http module on py3 decode headers + # in latin1, but empirical evidence suggests that latin1 is very + # rarely used with non-ASCII characters in HTTP headers. + # It is more likely to get UTF8 header rather than latin1. + # This causes incorrect handling of UTF8 encoded location headers. + # To solve this, we re-encode the location in latin1. + location = location.encode("latin1") + return to_native_string(location, "utf8") + return None + + def should_strip_auth(self, old_url, new_url): + """Decide whether Authorization header should be removed when redirecting""" + old_parsed = urlparse(old_url) + new_parsed = urlparse(new_url) + if old_parsed.hostname != new_parsed.hostname: + return True + # Special case: allow http -> https redirect when using the standard + # ports. This isn't specified by RFC 7235, but is kept to avoid + # breaking backwards compatibility with older versions of requests + # that allowed any redirects on the same host. + if ( + old_parsed.scheme == "http" + and old_parsed.port in (80, None) + and new_parsed.scheme == "https" + and new_parsed.port in (443, None) + ): + return False + + # Handle default port usage corresponding to scheme. + changed_port = old_parsed.port != new_parsed.port + changed_scheme = old_parsed.scheme != new_parsed.scheme + default_port = (DEFAULT_PORTS.get(old_parsed.scheme, None), None) + if ( + not changed_scheme + and old_parsed.port in default_port + and new_parsed.port in default_port + ): + return False + + # Standard case: root URI must match + return changed_port or changed_scheme + + def resolve_redirects( + self, + resp, + req, + stream=False, + timeout=None, + verify=True, + cert=None, + proxies=None, + yield_requests=False, + **adapter_kwargs, + ): + """Receives a Response. Returns a generator of Responses or Requests.""" + + hist = [] # keep track of history + + url = self.get_redirect_target(resp) + previous_fragment = urlparse(req.url).fragment + while url: + prepared_request = req.copy() + + # Update history and keep track of redirects. + # resp.history must ignore the original request in this loop + hist.append(resp) + resp.history = hist[1:] + + try: + resp.content # Consume socket so it can be released + except (ChunkedEncodingError, ContentDecodingError, RuntimeError): + resp.raw.read(decode_content=False) + + if len(resp.history) >= self.max_redirects: + raise TooManyRedirects( + f"Exceeded {self.max_redirects} redirects.", response=resp + ) + + # Release the connection back into the pool. + resp.close() + + # Handle redirection without scheme (see: RFC 1808 Section 4) + if url.startswith("//"): + parsed_rurl = urlparse(resp.url) + url = ":".join([to_native_string(parsed_rurl.scheme), url]) + + # Normalize url case and attach previous fragment if needed (RFC 7231 7.1.2) + parsed = urlparse(url) + if parsed.fragment == "" and previous_fragment: + parsed = parsed._replace(fragment=previous_fragment) + elif parsed.fragment: + previous_fragment = parsed.fragment + url = parsed.geturl() + + # Facilitate relative 'location' headers, as allowed by RFC 7231. + # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource') + # Compliant with RFC3986, we percent encode the url. + if not parsed.netloc: + url = urljoin(resp.url, requote_uri(url)) + else: + url = requote_uri(url) + + prepared_request.url = to_native_string(url) + + self.rebuild_method(prepared_request, resp) + + # https://github.com/psf/requests/issues/1084 + if resp.status_code not in ( + codes.temporary_redirect, + codes.permanent_redirect, + ): + # https://github.com/psf/requests/issues/3490 + purged_headers = ("Content-Length", "Content-Type", "Transfer-Encoding") + for header in purged_headers: + prepared_request.headers.pop(header, None) + prepared_request.body = None + + headers = prepared_request.headers + headers.pop("Cookie", None) + + # Extract any cookies sent on the response to the cookiejar + # in the new request. Because we've mutated our copied prepared + # request, use the old one that we haven't yet touched. + extract_cookies_to_jar(prepared_request._cookies, req, resp.raw) + merge_cookies(prepared_request._cookies, self.cookies) + prepared_request.prepare_cookies(prepared_request._cookies) + + # Rebuild auth and proxy information. + proxies = self.rebuild_proxies(prepared_request, proxies) + self.rebuild_auth(prepared_request, resp) + + # A failed tell() sets `_body_position` to `object()`. This non-None + # value ensures `rewindable` will be True, allowing us to raise an + # UnrewindableBodyError, instead of hanging the connection. + rewindable = prepared_request._body_position is not None and ( + "Content-Length" in headers or "Transfer-Encoding" in headers + ) + + # Attempt to rewind consumed file-like object. + if rewindable: + rewind_body(prepared_request) + + # Override the original request. + req = prepared_request + + if yield_requests: + yield req + else: + + resp = self.send( + req, + stream=stream, + timeout=timeout, + verify=verify, + cert=cert, + proxies=proxies, + allow_redirects=False, + **adapter_kwargs, + ) + + extract_cookies_to_jar(self.cookies, prepared_request, resp.raw) + + # extract redirect url, if any, for the next loop + url = self.get_redirect_target(resp) + yield resp + + def rebuild_auth(self, prepared_request, response): + """When being redirected we may want to strip authentication from the + request to avoid leaking credentials. This method intelligently removes + and reapplies authentication where possible to avoid credential loss. + """ + headers = prepared_request.headers + url = prepared_request.url + + if "Authorization" in headers and self.should_strip_auth( + response.request.url, url + ): + # If we get redirected to a new host, we should strip out any + # authentication headers. + del headers["Authorization"] + + # .netrc might have more auth for us on our new host. + new_auth = get_netrc_auth(url) if self.trust_env else None + if new_auth is not None: + prepared_request.prepare_auth(new_auth) + + def rebuild_proxies(self, prepared_request, proxies): + """This method re-evaluates the proxy configuration by considering the + environment variables. If we are redirected to a URL covered by + NO_PROXY, we strip the proxy configuration. Otherwise, we set missing + proxy keys for this URL (in case they were stripped by a previous + redirect). + + This method also replaces the Proxy-Authorization header where + necessary. + + :rtype: dict + """ + headers = prepared_request.headers + scheme = urlparse(prepared_request.url).scheme + new_proxies = resolve_proxies(prepared_request, proxies, self.trust_env) + + if "Proxy-Authorization" in headers: + del headers["Proxy-Authorization"] + + try: + username, password = get_auth_from_url(new_proxies[scheme]) + except KeyError: + username, password = None, None + + # urllib3 handles proxy authorization for us in the standard adapter. + # Avoid appending this to TLS tunneled requests where it may be leaked. + if not scheme.startswith('https') and username and password: + headers["Proxy-Authorization"] = _basic_auth_str(username, password) + + return new_proxies + + def rebuild_method(self, prepared_request, response): + """When being redirected we may want to change the method of the request + based on certain specs or browser behavior. + """ + method = prepared_request.method + + # https://tools.ietf.org/html/rfc7231#section-6.4.4 + if response.status_code == codes.see_other and method != "HEAD": + method = "GET" + + # Do what the browsers do, despite standards... + # First, turn 302s into GETs. + if response.status_code == codes.found and method != "HEAD": + method = "GET" + + # Second, if a POST is responded to with a 301, turn it into a GET. + # This bizarre behaviour is explained in Issue 1704. + if response.status_code == codes.moved and method == "POST": + method = "GET" + + prepared_request.method = method + + +class Session(SessionRedirectMixin): + """A Requests session. + + Provides cookie persistence, connection-pooling, and configuration. + + Basic Usage:: + + >>> import requests + >>> s = requests.Session() + >>> s.get('https://httpbin.org/get') + + + Or as a context manager:: + + >>> with requests.Session() as s: + ... s.get('https://httpbin.org/get') + + """ + + __attrs__ = [ + "headers", + "cookies", + "auth", + "proxies", + "hooks", + "params", + "verify", + "cert", + "adapters", + "stream", + "trust_env", + "max_redirects", + ] + + def __init__(self): + + #: A case-insensitive dictionary of headers to be sent on each + #: :class:`Request ` sent from this + #: :class:`Session `. + self.headers = default_headers() + + #: Default Authentication tuple or object to attach to + #: :class:`Request `. + self.auth = None + + #: Dictionary mapping protocol or protocol and host to the URL of the proxy + #: (e.g. {'http': 'foo.bar:3128', 'http://host.name': 'foo.bar:4012'}) to + #: be used on each :class:`Request `. + self.proxies = {} + + #: Event-handling hooks. + self.hooks = default_hooks() + + #: Dictionary of querystring data to attach to each + #: :class:`Request `. The dictionary values may be lists for + #: representing multivalued query parameters. + self.params = {} + + #: Stream response content default. + self.stream = False + + #: SSL Verification default. + #: Defaults to `True`, requiring requests to verify the TLS certificate at the + #: remote end. + #: If verify is set to `False`, requests will accept any TLS certificate + #: presented by the server, and will ignore hostname mismatches and/or + #: expired certificates, which will make your application vulnerable to + #: man-in-the-middle (MitM) attacks. + #: Only set this to `False` for testing. + self.verify = True + + #: SSL client certificate default, if String, path to ssl client + #: cert file (.pem). If Tuple, ('cert', 'key') pair. + self.cert = None + + #: Maximum number of redirects allowed. If the request exceeds this + #: limit, a :class:`TooManyRedirects` exception is raised. + #: This defaults to requests.models.DEFAULT_REDIRECT_LIMIT, which is + #: 30. + self.max_redirects = DEFAULT_REDIRECT_LIMIT + + #: Trust environment settings for proxy configuration, default + #: authentication and similar. + self.trust_env = True + + #: A CookieJar containing all currently outstanding cookies set on this + #: session. By default it is a + #: :class:`RequestsCookieJar `, but + #: may be any other ``cookielib.CookieJar`` compatible object. + self.cookies = cookiejar_from_dict({}) + + # Default connection adapters. + self.adapters = OrderedDict() + self.mount("https://", HTTPAdapter()) + self.mount("http://", HTTPAdapter()) + + def __enter__(self): + return self + + def __exit__(self, *args): + self.close() + + def prepare_request(self, request): + """Constructs a :class:`PreparedRequest ` for + transmission and returns it. The :class:`PreparedRequest` has settings + merged from the :class:`Request ` instance and those of the + :class:`Session`. + + :param request: :class:`Request` instance to prepare with this + session's settings. + :rtype: requests.PreparedRequest + """ + cookies = request.cookies or {} + + # Bootstrap CookieJar. + if not isinstance(cookies, cookielib.CookieJar): + cookies = cookiejar_from_dict(cookies) + + # Merge with session cookies + merged_cookies = merge_cookies( + merge_cookies(RequestsCookieJar(), self.cookies), cookies + ) + + # Set environment's basic authentication if not explicitly set. + auth = request.auth + if self.trust_env and not auth and not self.auth: + auth = get_netrc_auth(request.url) + + p = PreparedRequest() + p.prepare( + method=request.method.upper(), + url=request.url, + files=request.files, + data=request.data, + json=request.json, + headers=merge_setting( + request.headers, self.headers, dict_class=CaseInsensitiveDict + ), + params=merge_setting(request.params, self.params), + auth=merge_setting(auth, self.auth), + cookies=merged_cookies, + hooks=merge_hooks(request.hooks, self.hooks), + ) + return p + + def request( + self, + method, + url, + params=None, + data=None, + headers=None, + cookies=None, + files=None, + auth=None, + timeout=None, + allow_redirects=True, + proxies=None, + hooks=None, + stream=None, + verify=None, + cert=None, + json=None, + ): + """Constructs a :class:`Request `, prepares it and sends it. + Returns :class:`Response ` object. + + :param method: method for the new :class:`Request` object. + :param url: URL for the new :class:`Request` object. + :param params: (optional) Dictionary or bytes to be sent in the query + string for the :class:`Request`. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) json to send in the body of the + :class:`Request`. + :param headers: (optional) Dictionary of HTTP Headers to send with the + :class:`Request`. + :param cookies: (optional) Dict or CookieJar object to send with the + :class:`Request`. + :param files: (optional) Dictionary of ``'filename': file-like-objects`` + for multipart encoding upload. + :param auth: (optional) Auth tuple or callable to enable + Basic/Digest/Custom HTTP Auth. + :param timeout: (optional) How long to wait for the server to send + data before giving up, as a float, or a :ref:`(connect timeout, + read timeout) ` tuple. + :type timeout: float or tuple + :param allow_redirects: (optional) Set to True by default. + :type allow_redirects: bool + :param proxies: (optional) Dictionary mapping protocol or protocol and + hostname to the URL of the proxy. + :param stream: (optional) whether to immediately download the response + content. Defaults to ``False``. + :param verify: (optional) Either a boolean, in which case it controls whether we verify + the server's TLS certificate, or a string, in which case it must be a path + to a CA bundle to use. Defaults to ``True``. When set to + ``False``, requests will accept any TLS certificate presented by + the server, and will ignore hostname mismatches and/or expired + certificates, which will make your application vulnerable to + man-in-the-middle (MitM) attacks. Setting verify to ``False`` + may be useful during local development or testing. + :param cert: (optional) if String, path to ssl client cert file (.pem). + If Tuple, ('cert', 'key') pair. + :rtype: requests.Response + """ + # Create the Request. + req = Request( + method=method.upper(), + url=url, + headers=headers, + files=files, + data=data or {}, + json=json, + params=params or {}, + auth=auth, + cookies=cookies, + hooks=hooks, + ) + prep = self.prepare_request(req) + + proxies = proxies or {} + + settings = self.merge_environment_settings( + prep.url, proxies, stream, verify, cert + ) + + # Send the request. + send_kwargs = { + "timeout": timeout, + "allow_redirects": allow_redirects, + } + send_kwargs.update(settings) + resp = self.send(prep, **send_kwargs) + + return resp + + def get(self, url, **kwargs): + r"""Sends a GET request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + kwargs.setdefault("allow_redirects", True) + return self.request("GET", url, **kwargs) + + def options(self, url, **kwargs): + r"""Sends a OPTIONS request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + kwargs.setdefault("allow_redirects", True) + return self.request("OPTIONS", url, **kwargs) + + def head(self, url, **kwargs): + r"""Sends a HEAD request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + kwargs.setdefault("allow_redirects", False) + return self.request("HEAD", url, **kwargs) + + def post(self, url, data=None, json=None, **kwargs): + r"""Sends a POST request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param json: (optional) json to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + return self.request("POST", url, data=data, json=json, **kwargs) + + def put(self, url, data=None, **kwargs): + r"""Sends a PUT request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + return self.request("PUT", url, data=data, **kwargs) + + def patch(self, url, data=None, **kwargs): + r"""Sends a PATCH request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param data: (optional) Dictionary, list of tuples, bytes, or file-like + object to send in the body of the :class:`Request`. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + return self.request("PATCH", url, data=data, **kwargs) + + def delete(self, url, **kwargs): + r"""Sends a DELETE request. Returns :class:`Response` object. + + :param url: URL for the new :class:`Request` object. + :param \*\*kwargs: Optional arguments that ``request`` takes. + :rtype: requests.Response + """ + + return self.request("DELETE", url, **kwargs) + + def send(self, request, **kwargs): + """Send a given PreparedRequest. + + :rtype: requests.Response + """ + # Set defaults that the hooks can utilize to ensure they always have + # the correct parameters to reproduce the previous request. + kwargs.setdefault("stream", self.stream) + kwargs.setdefault("verify", self.verify) + kwargs.setdefault("cert", self.cert) + if "proxies" not in kwargs: + kwargs["proxies"] = resolve_proxies(request, self.proxies, self.trust_env) + + # It's possible that users might accidentally send a Request object. + # Guard against that specific failure case. + if isinstance(request, Request): + raise ValueError("You can only send PreparedRequests.") + + # Set up variables needed for resolve_redirects and dispatching of hooks + allow_redirects = kwargs.pop("allow_redirects", True) + stream = kwargs.get("stream") + hooks = request.hooks + + # Get the appropriate adapter to use + adapter = self.get_adapter(url=request.url) + + # Start time (approximately) of the request + start = preferred_clock() + + # Send the request + r = adapter.send(request, **kwargs) + + # Total elapsed time of the request (approximately) + elapsed = preferred_clock() - start + r.elapsed = timedelta(seconds=elapsed) + + # Response manipulation hooks + r = dispatch_hook("response", hooks, r, **kwargs) + + # Persist cookies + if r.history: + + # If the hooks create history then we want those cookies too + for resp in r.history: + extract_cookies_to_jar(self.cookies, resp.request, resp.raw) + + extract_cookies_to_jar(self.cookies, request, r.raw) + + # Resolve redirects if allowed. + if allow_redirects: + # Redirect resolving generator. + gen = self.resolve_redirects(r, request, **kwargs) + history = [resp for resp in gen] + else: + history = [] + + # Shuffle things around if there's history. + if history: + # Insert the first (original) request at the start + history.insert(0, r) + # Get the last request made + r = history.pop() + r.history = history + + # If redirects aren't being followed, store the response on the Request for Response.next(). + if not allow_redirects: + try: + r._next = next( + self.resolve_redirects(r, request, yield_requests=True, **kwargs) + ) + except StopIteration: + pass + + if not stream: + r.content + + return r + + def merge_environment_settings(self, url, proxies, stream, verify, cert): + """ + Check the environment and merge it with some settings. + + :rtype: dict + """ + # Gather clues from the surrounding environment. + if self.trust_env: + # Set environment's proxies. + no_proxy = proxies.get("no_proxy") if proxies is not None else None + env_proxies = get_environ_proxies(url, no_proxy=no_proxy) + for (k, v) in env_proxies.items(): + proxies.setdefault(k, v) + + # Look for requests environment configuration + # and be compatible with cURL. + if verify is True or verify is None: + verify = ( + os.environ.get("REQUESTS_CA_BUNDLE") + or os.environ.get("CURL_CA_BUNDLE") + or verify + ) + + # Merge all the kwargs. + proxies = merge_setting(proxies, self.proxies) + stream = merge_setting(stream, self.stream) + verify = merge_setting(verify, self.verify) + cert = merge_setting(cert, self.cert) + + return {"proxies": proxies, "stream": stream, "verify": verify, "cert": cert} + + def get_adapter(self, url): + """ + Returns the appropriate connection adapter for the given URL. + + :rtype: requests.adapters.BaseAdapter + """ + for (prefix, adapter) in self.adapters.items(): + + if url.lower().startswith(prefix.lower()): + return adapter + + # Nothing matches :-/ + raise InvalidSchema(f"No connection adapters were found for {url!r}") + + def close(self): + """Closes all adapters and as such the session""" + for v in self.adapters.values(): + v.close() + + def mount(self, prefix, adapter): + """Registers a connection adapter to a prefix. + + Adapters are sorted in descending order by prefix length. + """ + self.adapters[prefix] = adapter + keys_to_move = [k for k in self.adapters if len(k) < len(prefix)] + + for key in keys_to_move: + self.adapters[key] = self.adapters.pop(key) + + def __getstate__(self): + state = {attr: getattr(self, attr, None) for attr in self.__attrs__} + return state + + def __setstate__(self, state): + for attr, value in state.items(): + setattr(self, attr, value) + + +def session(): + """ + Returns a :class:`Session` for context-management. + + .. deprecated:: 1.0.0 + + This method has been deprecated since version 1.0.0 and is only kept for + backwards compatibility. New code should use :class:`~requests.sessions.Session` + to create a session. This may be removed at a future date. + + :rtype: Session + """ + return Session() diff --git a/Modules/requests/status_codes.py b/Modules/requests/status_codes.py new file mode 100644 index 0000000..4bd072b --- /dev/null +++ b/Modules/requests/status_codes.py @@ -0,0 +1,128 @@ +r""" +The ``codes`` object defines a mapping from common names for HTTP statuses +to their numerical codes, accessible either as attributes or as dictionary +items. + +Example:: + + >>> import requests + >>> requests.codes['temporary_redirect'] + 307 + >>> requests.codes.teapot + 418 + >>> requests.codes['\o/'] + 200 + +Some codes have multiple names, and both upper- and lower-case versions of +the names are allowed. For example, ``codes.ok``, ``codes.OK``, and +``codes.okay`` all correspond to the HTTP status code 200. +""" + +from .structures import LookupDict + +_codes = { + # Informational. + 100: ("continue",), + 101: ("switching_protocols",), + 102: ("processing",), + 103: ("checkpoint",), + 122: ("uri_too_long", "request_uri_too_long"), + 200: ("ok", "okay", "all_ok", "all_okay", "all_good", "\\o/", "✓"), + 201: ("created",), + 202: ("accepted",), + 203: ("non_authoritative_info", "non_authoritative_information"), + 204: ("no_content",), + 205: ("reset_content", "reset"), + 206: ("partial_content", "partial"), + 207: ("multi_status", "multiple_status", "multi_stati", "multiple_stati"), + 208: ("already_reported",), + 226: ("im_used",), + # Redirection. + 300: ("multiple_choices",), + 301: ("moved_permanently", "moved", "\\o-"), + 302: ("found",), + 303: ("see_other", "other"), + 304: ("not_modified",), + 305: ("use_proxy",), + 306: ("switch_proxy",), + 307: ("temporary_redirect", "temporary_moved", "temporary"), + 308: ( + "permanent_redirect", + "resume_incomplete", + "resume", + ), # "resume" and "resume_incomplete" to be removed in 3.0 + # Client Error. + 400: ("bad_request", "bad"), + 401: ("unauthorized",), + 402: ("payment_required", "payment"), + 403: ("forbidden",), + 404: ("not_found", "-o-"), + 405: ("method_not_allowed", "not_allowed"), + 406: ("not_acceptable",), + 407: ("proxy_authentication_required", "proxy_auth", "proxy_authentication"), + 408: ("request_timeout", "timeout"), + 409: ("conflict",), + 410: ("gone",), + 411: ("length_required",), + 412: ("precondition_failed", "precondition"), + 413: ("request_entity_too_large",), + 414: ("request_uri_too_large",), + 415: ("unsupported_media_type", "unsupported_media", "media_type"), + 416: ( + "requested_range_not_satisfiable", + "requested_range", + "range_not_satisfiable", + ), + 417: ("expectation_failed",), + 418: ("im_a_teapot", "teapot", "i_am_a_teapot"), + 421: ("misdirected_request",), + 422: ("unprocessable_entity", "unprocessable"), + 423: ("locked",), + 424: ("failed_dependency", "dependency"), + 425: ("unordered_collection", "unordered"), + 426: ("upgrade_required", "upgrade"), + 428: ("precondition_required", "precondition"), + 429: ("too_many_requests", "too_many"), + 431: ("header_fields_too_large", "fields_too_large"), + 444: ("no_response", "none"), + 449: ("retry_with", "retry"), + 450: ("blocked_by_windows_parental_controls", "parental_controls"), + 451: ("unavailable_for_legal_reasons", "legal_reasons"), + 499: ("client_closed_request",), + # Server Error. + 500: ("internal_server_error", "server_error", "/o\\", "✗"), + 501: ("not_implemented",), + 502: ("bad_gateway",), + 503: ("service_unavailable", "unavailable"), + 504: ("gateway_timeout",), + 505: ("http_version_not_supported", "http_version"), + 506: ("variant_also_negotiates",), + 507: ("insufficient_storage",), + 509: ("bandwidth_limit_exceeded", "bandwidth"), + 510: ("not_extended",), + 511: ("network_authentication_required", "network_auth", "network_authentication"), +} + +codes = LookupDict(name="status_codes") + + +def _init(): + for code, titles in _codes.items(): + for title in titles: + setattr(codes, title, code) + if not title.startswith(("\\", "/")): + setattr(codes, title.upper(), code) + + def doc(code): + names = ", ".join(f"``{n}``" for n in _codes[code]) + return "* %d: %s" % (code, names) + + global __doc__ + __doc__ = ( + __doc__ + "\n" + "\n".join(doc(code) for code in sorted(_codes)) + if __doc__ is not None + else None + ) + + +_init() diff --git a/Modules/requests/structures.py b/Modules/requests/structures.py new file mode 100644 index 0000000..188e13e --- /dev/null +++ b/Modules/requests/structures.py @@ -0,0 +1,99 @@ +""" +requests.structures +~~~~~~~~~~~~~~~~~~~ + +Data structures that power Requests. +""" + +from collections import OrderedDict + +from .compat import Mapping, MutableMapping + + +class CaseInsensitiveDict(MutableMapping): + """A case-insensitive ``dict``-like object. + + Implements all methods and operations of + ``MutableMapping`` as well as dict's ``copy``. Also + provides ``lower_items``. + + All keys are expected to be strings. The structure remembers the + case of the last key to be set, and ``iter(instance)``, + ``keys()``, ``items()``, ``iterkeys()``, and ``iteritems()`` + will contain case-sensitive keys. However, querying and contains + testing is case insensitive:: + + cid = CaseInsensitiveDict() + cid['Accept'] = 'application/json' + cid['aCCEPT'] == 'application/json' # True + list(cid) == ['Accept'] # True + + For example, ``headers['content-encoding']`` will return the + value of a ``'Content-Encoding'`` response header, regardless + of how the header name was originally stored. + + If the constructor, ``.update``, or equality comparison + operations are given keys that have equal ``.lower()``s, the + behavior is undefined. + """ + + def __init__(self, data=None, **kwargs): + self._store = OrderedDict() + if data is None: + data = {} + self.update(data, **kwargs) + + def __setitem__(self, key, value): + # Use the lowercased key for lookups, but store the actual + # key alongside the value. + self._store[key.lower()] = (key, value) + + def __getitem__(self, key): + return self._store[key.lower()][1] + + def __delitem__(self, key): + del self._store[key.lower()] + + def __iter__(self): + return (casedkey for casedkey, mappedvalue in self._store.values()) + + def __len__(self): + return len(self._store) + + def lower_items(self): + """Like iteritems(), but with all lowercase keys.""" + return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items()) + + def __eq__(self, other): + if isinstance(other, Mapping): + other = CaseInsensitiveDict(other) + else: + return NotImplemented + # Compare insensitively + return dict(self.lower_items()) == dict(other.lower_items()) + + # Copy is required + def copy(self): + return CaseInsensitiveDict(self._store.values()) + + def __repr__(self): + return str(dict(self.items())) + + +class LookupDict(dict): + """Dictionary lookup object.""" + + def __init__(self, name=None): + self.name = name + super().__init__() + + def __repr__(self): + return f"" + + def __getitem__(self, key): + # We allow fall-through here, so values default to None + + return self.__dict__.get(key, None) + + def get(self, key, default=None): + return self.__dict__.get(key, default) diff --git a/Modules/requests/utils.py b/Modules/requests/utils.py new file mode 100644 index 0000000..a367417 --- /dev/null +++ b/Modules/requests/utils.py @@ -0,0 +1,1094 @@ +""" +requests.utils +~~~~~~~~~~~~~~ + +This module provides utility functions that are used within Requests +that are also useful for external consumption. +""" + +import codecs +import contextlib +import io +import os +import re +import socket +import struct +import sys +import tempfile +import warnings +import zipfile +from collections import OrderedDict + +from urllib3.util import make_headers, parse_url + +from . import certs +from .__version__ import __version__ + +# to_native_string is unused here, but imported here for backwards compatibility +from ._internal_utils import ( # noqa: F401 + _HEADER_VALIDATORS_BYTE, + _HEADER_VALIDATORS_STR, + HEADER_VALIDATORS, + to_native_string, +) +from .compat import ( + Mapping, + basestring, + bytes, + getproxies, + getproxies_environment, + integer_types, +) +from .compat import parse_http_list as _parse_list_header +from .compat import ( + proxy_bypass, + proxy_bypass_environment, + quote, + str, + unquote, + urlparse, + urlunparse, +) +from .cookies import cookiejar_from_dict +from .exceptions import ( + FileModeWarning, + InvalidHeader, + InvalidURL, + UnrewindableBodyError, +) +from .structures import CaseInsensitiveDict + +NETRC_FILES = (".netrc", "_netrc") + +DEFAULT_CA_BUNDLE_PATH = certs.where() + +DEFAULT_PORTS = {"http": 80, "https": 443} + +# Ensure that ', ' is used to preserve previous delimiter behavior. +DEFAULT_ACCEPT_ENCODING = ", ".join( + re.split(r",\s*", make_headers(accept_encoding=True)["accept-encoding"]) +) + + +if sys.platform == "win32": + # provide a proxy_bypass version on Windows without DNS lookups + + def proxy_bypass_registry(host): + try: + import winreg + except ImportError: + return False + + try: + internetSettings = winreg.OpenKey( + winreg.HKEY_CURRENT_USER, + r"Software\Microsoft\Windows\CurrentVersion\Internet Settings", + ) + # ProxyEnable could be REG_SZ or REG_DWORD, normalizing it + proxyEnable = int(winreg.QueryValueEx(internetSettings, "ProxyEnable")[0]) + # ProxyOverride is almost always a string + proxyOverride = winreg.QueryValueEx(internetSettings, "ProxyOverride")[0] + except (OSError, ValueError): + return False + if not proxyEnable or not proxyOverride: + return False + + # make a check value list from the registry entry: replace the + # '' string by the localhost entry and the corresponding + # canonical entry. + proxyOverride = proxyOverride.split(";") + # now check if we match one of the registry values. + for test in proxyOverride: + if test == "": + if "." not in host: + return True + test = test.replace(".", r"\.") # mask dots + test = test.replace("*", r".*") # change glob sequence + test = test.replace("?", r".") # change glob char + if re.match(test, host, re.I): + return True + return False + + def proxy_bypass(host): # noqa + """Return True, if the host should be bypassed. + + Checks proxy settings gathered from the environment, if specified, + or the registry. + """ + if getproxies_environment(): + return proxy_bypass_environment(host) + else: + return proxy_bypass_registry(host) + + +def dict_to_sequence(d): + """Returns an internal sequence dictionary update.""" + + if hasattr(d, "items"): + d = d.items() + + return d + + +def super_len(o): + total_length = None + current_position = 0 + + if hasattr(o, "__len__"): + total_length = len(o) + + elif hasattr(o, "len"): + total_length = o.len + + elif hasattr(o, "fileno"): + try: + fileno = o.fileno() + except (io.UnsupportedOperation, AttributeError): + # AttributeError is a surprising exception, seeing as how we've just checked + # that `hasattr(o, 'fileno')`. It happens for objects obtained via + # `Tarfile.extractfile()`, per issue 5229. + pass + else: + total_length = os.fstat(fileno).st_size + + # Having used fstat to determine the file length, we need to + # confirm that this file was opened up in binary mode. + if "b" not in o.mode: + warnings.warn( + ( + "Requests has determined the content-length for this " + "request using the binary size of the file: however, the " + "file has been opened in text mode (i.e. without the 'b' " + "flag in the mode). This may lead to an incorrect " + "content-length. In Requests 3.0, support will be removed " + "for files in text mode." + ), + FileModeWarning, + ) + + if hasattr(o, "tell"): + try: + current_position = o.tell() + except OSError: + # This can happen in some weird situations, such as when the file + # is actually a special file descriptor like stdin. In this + # instance, we don't know what the length is, so set it to zero and + # let requests chunk it instead. + if total_length is not None: + current_position = total_length + else: + if hasattr(o, "seek") and total_length is None: + # StringIO and BytesIO have seek but no usable fileno + try: + # seek to end of file + o.seek(0, 2) + total_length = o.tell() + + # seek back to current position to support + # partially read file-like objects + o.seek(current_position or 0) + except OSError: + total_length = 0 + + if total_length is None: + total_length = 0 + + return max(0, total_length - current_position) + + +def get_netrc_auth(url, raise_errors=False): + """Returns the Requests tuple auth for a given url from netrc.""" + + netrc_file = os.environ.get("NETRC") + if netrc_file is not None: + netrc_locations = (netrc_file,) + else: + netrc_locations = (f"~/{f}" for f in NETRC_FILES) + + try: + from netrc import NetrcParseError, netrc + + netrc_path = None + + for f in netrc_locations: + try: + loc = os.path.expanduser(f) + except KeyError: + # os.path.expanduser can fail when $HOME is undefined and + # getpwuid fails. See https://bugs.python.org/issue20164 & + # https://github.com/psf/requests/issues/1846 + return + + if os.path.exists(loc): + netrc_path = loc + break + + # Abort early if there isn't one. + if netrc_path is None: + return + + ri = urlparse(url) + + # Strip port numbers from netloc. This weird `if...encode`` dance is + # used for Python 3.2, which doesn't support unicode literals. + splitstr = b":" + if isinstance(url, str): + splitstr = splitstr.decode("ascii") + host = ri.netloc.split(splitstr)[0] + + try: + _netrc = netrc(netrc_path).authenticators(host) + if _netrc: + # Return with login / password + login_i = 0 if _netrc[0] else 1 + return (_netrc[login_i], _netrc[2]) + except (NetrcParseError, OSError): + # If there was a parsing error or a permissions issue reading the file, + # we'll just skip netrc auth unless explicitly asked to raise errors. + if raise_errors: + raise + + # App Engine hackiness. + except (ImportError, AttributeError): + pass + + +def guess_filename(obj): + """Tries to guess the filename of the given object.""" + name = getattr(obj, "name", None) + if name and isinstance(name, basestring) and name[0] != "<" and name[-1] != ">": + return os.path.basename(name) + + +def extract_zipped_paths(path): + """Replace nonexistent paths that look like they refer to a member of a zip + archive with the location of an extracted copy of the target, or else + just return the provided path unchanged. + """ + if os.path.exists(path): + # this is already a valid path, no need to do anything further + return path + + # find the first valid part of the provided path and treat that as a zip archive + # assume the rest of the path is the name of a member in the archive + archive, member = os.path.split(path) + while archive and not os.path.exists(archive): + archive, prefix = os.path.split(archive) + if not prefix: + # If we don't check for an empty prefix after the split (in other words, archive remains unchanged after the split), + # we _can_ end up in an infinite loop on a rare corner case affecting a small number of users + break + member = "/".join([prefix, member]) + + if not zipfile.is_zipfile(archive): + return path + + zip_file = zipfile.ZipFile(archive) + if member not in zip_file.namelist(): + return path + + # we have a valid zip archive and a valid member of that archive + tmp = tempfile.gettempdir() + extracted_path = os.path.join(tmp, member.split("/")[-1]) + if not os.path.exists(extracted_path): + # use read + write to avoid the creating nested folders, we only want the file, avoids mkdir racing condition + with atomic_open(extracted_path) as file_handler: + file_handler.write(zip_file.read(member)) + return extracted_path + + +@contextlib.contextmanager +def atomic_open(filename): + """Write a file to the disk in an atomic fashion""" + tmp_descriptor, tmp_name = tempfile.mkstemp(dir=os.path.dirname(filename)) + try: + with os.fdopen(tmp_descriptor, "wb") as tmp_handler: + yield tmp_handler + os.replace(tmp_name, filename) + except BaseException: + os.remove(tmp_name) + raise + + +def from_key_val_list(value): + """Take an object and test to see if it can be represented as a + dictionary. Unless it can not be represented as such, return an + OrderedDict, e.g., + + :: + + >>> from_key_val_list([('key', 'val')]) + OrderedDict([('key', 'val')]) + >>> from_key_val_list('string') + Traceback (most recent call last): + ... + ValueError: cannot encode objects that are not 2-tuples + >>> from_key_val_list({'key': 'val'}) + OrderedDict([('key', 'val')]) + + :rtype: OrderedDict + """ + if value is None: + return None + + if isinstance(value, (str, bytes, bool, int)): + raise ValueError("cannot encode objects that are not 2-tuples") + + return OrderedDict(value) + + +def to_key_val_list(value): + """Take an object and test to see if it can be represented as a + dictionary. If it can be, return a list of tuples, e.g., + + :: + + >>> to_key_val_list([('key', 'val')]) + [('key', 'val')] + >>> to_key_val_list({'key': 'val'}) + [('key', 'val')] + >>> to_key_val_list('string') + Traceback (most recent call last): + ... + ValueError: cannot encode objects that are not 2-tuples + + :rtype: list + """ + if value is None: + return None + + if isinstance(value, (str, bytes, bool, int)): + raise ValueError("cannot encode objects that are not 2-tuples") + + if isinstance(value, Mapping): + value = value.items() + + return list(value) + + +# From mitsuhiko/werkzeug (used with permission). +def parse_list_header(value): + """Parse lists as described by RFC 2068 Section 2. + + In particular, parse comma-separated lists where the elements of + the list may include quoted-strings. A quoted-string could + contain a comma. A non-quoted string could have quotes in the + middle. Quotes are removed automatically after parsing. + + It basically works like :func:`parse_set_header` just that items + may appear multiple times and case sensitivity is preserved. + + The return value is a standard :class:`list`: + + >>> parse_list_header('token, "quoted value"') + ['token', 'quoted value'] + + To create a header from the :class:`list` again, use the + :func:`dump_header` function. + + :param value: a string with a list header. + :return: :class:`list` + :rtype: list + """ + result = [] + for item in _parse_list_header(value): + if item[:1] == item[-1:] == '"': + item = unquote_header_value(item[1:-1]) + result.append(item) + return result + + +# From mitsuhiko/werkzeug (used with permission). +def parse_dict_header(value): + """Parse lists of key, value pairs as described by RFC 2068 Section 2 and + convert them into a python dict: + + >>> d = parse_dict_header('foo="is a fish", bar="as well"') + >>> type(d) is dict + True + >>> sorted(d.items()) + [('bar', 'as well'), ('foo', 'is a fish')] + + If there is no value for a key it will be `None`: + + >>> parse_dict_header('key_without_value') + {'key_without_value': None} + + To create a header from the :class:`dict` again, use the + :func:`dump_header` function. + + :param value: a string with a dict header. + :return: :class:`dict` + :rtype: dict + """ + result = {} + for item in _parse_list_header(value): + if "=" not in item: + result[item] = None + continue + name, value = item.split("=", 1) + if value[:1] == value[-1:] == '"': + value = unquote_header_value(value[1:-1]) + result[name] = value + return result + + +# From mitsuhiko/werkzeug (used with permission). +def unquote_header_value(value, is_filename=False): + r"""Unquotes a header value. (Reversal of :func:`quote_header_value`). + This does not use the real unquoting but what browsers are actually + using for quoting. + + :param value: the header value to unquote. + :rtype: str + """ + if value and value[0] == value[-1] == '"': + # this is not the real unquoting, but fixing this so that the + # RFC is met will result in bugs with internet explorer and + # probably some other browsers as well. IE for example is + # uploading files with "C:\foo\bar.txt" as filename + value = value[1:-1] + + # if this is a filename and the starting characters look like + # a UNC path, then just return the value without quotes. Using the + # replace sequence below on a UNC path has the effect of turning + # the leading double slash into a single slash and then + # _fix_ie_filename() doesn't work correctly. See #458. + if not is_filename or value[:2] != "\\\\": + return value.replace("\\\\", "\\").replace('\\"', '"') + return value + + +def dict_from_cookiejar(cj): + """Returns a key/value dictionary from a CookieJar. + + :param cj: CookieJar object to extract cookies from. + :rtype: dict + """ + + cookie_dict = {} + + for cookie in cj: + cookie_dict[cookie.name] = cookie.value + + return cookie_dict + + +def add_dict_to_cookiejar(cj, cookie_dict): + """Returns a CookieJar from a key/value dictionary. + + :param cj: CookieJar to insert cookies into. + :param cookie_dict: Dict of key/values to insert into CookieJar. + :rtype: CookieJar + """ + + return cookiejar_from_dict(cookie_dict, cj) + + +def get_encodings_from_content(content): + """Returns encodings from given content string. + + :param content: bytestring to extract encodings from. + """ + warnings.warn( + ( + "In requests 3.0, get_encodings_from_content will be removed. For " + "more information, please see the discussion on issue #2266. (This" + " warning should only appear once.)" + ), + DeprecationWarning, + ) + + charset_re = re.compile(r']', flags=re.I) + pragma_re = re.compile(r']', flags=re.I) + xml_re = re.compile(r'^<\?xml.*?encoding=["\']*(.+?)["\'>]') + + return ( + charset_re.findall(content) + + pragma_re.findall(content) + + xml_re.findall(content) + ) + + +def _parse_content_type_header(header): + """Returns content type and parameters from given header + + :param header: string + :return: tuple containing content type and dictionary of + parameters + """ + + tokens = header.split(";") + content_type, params = tokens[0].strip(), tokens[1:] + params_dict = {} + items_to_strip = "\"' " + + for param in params: + param = param.strip() + if param: + key, value = param, True + index_of_equals = param.find("=") + if index_of_equals != -1: + key = param[:index_of_equals].strip(items_to_strip) + value = param[index_of_equals + 1 :].strip(items_to_strip) + params_dict[key.lower()] = value + return content_type, params_dict + + +def get_encoding_from_headers(headers): + """Returns encodings from given HTTP Header Dict. + + :param headers: dictionary to extract encoding from. + :rtype: str + """ + + content_type = headers.get("content-type") + + if not content_type: + return None + + content_type, params = _parse_content_type_header(content_type) + + if "charset" in params: + return params["charset"].strip("'\"") + + if "text" in content_type: + return "ISO-8859-1" + + if "application/json" in content_type: + # Assume UTF-8 based on RFC 4627: https://www.ietf.org/rfc/rfc4627.txt since the charset was unset + return "utf-8" + + +def stream_decode_response_unicode(iterator, r): + """Stream decodes an iterator.""" + + if r.encoding is None: + yield from iterator + return + + decoder = codecs.getincrementaldecoder(r.encoding)(errors="replace") + for chunk in iterator: + rv = decoder.decode(chunk) + if rv: + yield rv + rv = decoder.decode(b"", final=True) + if rv: + yield rv + + +def iter_slices(string, slice_length): + """Iterate over slices of a string.""" + pos = 0 + if slice_length is None or slice_length <= 0: + slice_length = len(string) + while pos < len(string): + yield string[pos : pos + slice_length] + pos += slice_length + + +def get_unicode_from_response(r): + """Returns the requested content back in unicode. + + :param r: Response object to get unicode content from. + + Tried: + + 1. charset from content-type + 2. fall back and replace all unicode characters + + :rtype: str + """ + warnings.warn( + ( + "In requests 3.0, get_unicode_from_response will be removed. For " + "more information, please see the discussion on issue #2266. (This" + " warning should only appear once.)" + ), + DeprecationWarning, + ) + + tried_encodings = [] + + # Try charset from content-type + encoding = get_encoding_from_headers(r.headers) + + if encoding: + try: + return str(r.content, encoding) + except UnicodeError: + tried_encodings.append(encoding) + + # Fall back: + try: + return str(r.content, encoding, errors="replace") + except TypeError: + return r.content + + +# The unreserved URI characters (RFC 3986) +UNRESERVED_SET = frozenset( + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + "0123456789-._~" +) + + +def unquote_unreserved(uri): + """Un-escape any percent-escape sequences in a URI that are unreserved + characters. This leaves all reserved, illegal and non-ASCII bytes encoded. + + :rtype: str + """ + parts = uri.split("%") + for i in range(1, len(parts)): + h = parts[i][0:2] + if len(h) == 2 and h.isalnum(): + try: + c = chr(int(h, 16)) + except ValueError: + raise InvalidURL(f"Invalid percent-escape sequence: '{h}'") + + if c in UNRESERVED_SET: + parts[i] = c + parts[i][2:] + else: + parts[i] = f"%{parts[i]}" + else: + parts[i] = f"%{parts[i]}" + return "".join(parts) + + +def requote_uri(uri): + """Re-quote the given URI. + + This function passes the given URI through an unquote/quote cycle to + ensure that it is fully and consistently quoted. + + :rtype: str + """ + safe_with_percent = "!#$%&'()*+,/:;=?@[]~" + safe_without_percent = "!#$&'()*+,/:;=?@[]~" + try: + # Unquote only the unreserved characters + # Then quote only illegal characters (do not quote reserved, + # unreserved, or '%') + return quote(unquote_unreserved(uri), safe=safe_with_percent) + except InvalidURL: + # We couldn't unquote the given URI, so let's try quoting it, but + # there may be unquoted '%'s in the URI. We need to make sure they're + # properly quoted so they do not cause issues elsewhere. + return quote(uri, safe=safe_without_percent) + + +def address_in_network(ip, net): + """This function allows you to check if an IP belongs to a network subnet + + Example: returns True if ip = 192.168.1.1 and net = 192.168.1.0/24 + returns False if ip = 192.168.1.1 and net = 192.168.100.0/24 + + :rtype: bool + """ + ipaddr = struct.unpack("=L", socket.inet_aton(ip))[0] + netaddr, bits = net.split("/") + netmask = struct.unpack("=L", socket.inet_aton(dotted_netmask(int(bits))))[0] + network = struct.unpack("=L", socket.inet_aton(netaddr))[0] & netmask + return (ipaddr & netmask) == (network & netmask) + + +def dotted_netmask(mask): + """Converts mask from /xx format to xxx.xxx.xxx.xxx + + Example: if mask is 24 function returns 255.255.255.0 + + :rtype: str + """ + bits = 0xFFFFFFFF ^ (1 << 32 - mask) - 1 + return socket.inet_ntoa(struct.pack(">I", bits)) + + +def is_ipv4_address(string_ip): + """ + :rtype: bool + """ + try: + socket.inet_aton(string_ip) + except OSError: + return False + return True + + +def is_valid_cidr(string_network): + """ + Very simple check of the cidr format in no_proxy variable. + + :rtype: bool + """ + if string_network.count("/") == 1: + try: + mask = int(string_network.split("/")[1]) + except ValueError: + return False + + if mask < 1 or mask > 32: + return False + + try: + socket.inet_aton(string_network.split("/")[0]) + except OSError: + return False + else: + return False + return True + + +@contextlib.contextmanager +def set_environ(env_name, value): + """Set the environment variable 'env_name' to 'value' + + Save previous value, yield, and then restore the previous value stored in + the environment variable 'env_name'. + + If 'value' is None, do nothing""" + value_changed = value is not None + if value_changed: + old_value = os.environ.get(env_name) + os.environ[env_name] = value + try: + yield + finally: + if value_changed: + if old_value is None: + del os.environ[env_name] + else: + os.environ[env_name] = old_value + + +def should_bypass_proxies(url, no_proxy): + """ + Returns whether we should bypass proxies or not. + + :rtype: bool + """ + # Prioritize lowercase environment variables over uppercase + # to keep a consistent behaviour with other http projects (curl, wget). + def get_proxy(key): + return os.environ.get(key) or os.environ.get(key.upper()) + + # First check whether no_proxy is defined. If it is, check that the URL + # we're getting isn't in the no_proxy list. + no_proxy_arg = no_proxy + if no_proxy is None: + no_proxy = get_proxy("no_proxy") + parsed = urlparse(url) + + if parsed.hostname is None: + # URLs don't always have hostnames, e.g. file:/// urls. + return True + + if no_proxy: + # We need to check whether we match here. We need to see if we match + # the end of the hostname, both with and without the port. + no_proxy = (host for host in no_proxy.replace(" ", "").split(",") if host) + + if is_ipv4_address(parsed.hostname): + for proxy_ip in no_proxy: + if is_valid_cidr(proxy_ip): + if address_in_network(parsed.hostname, proxy_ip): + return True + elif parsed.hostname == proxy_ip: + # If no_proxy ip was defined in plain IP notation instead of cidr notation & + # matches the IP of the index + return True + else: + host_with_port = parsed.hostname + if parsed.port: + host_with_port += f":{parsed.port}" + + for host in no_proxy: + if parsed.hostname.endswith(host) or host_with_port.endswith(host): + # The URL does match something in no_proxy, so we don't want + # to apply the proxies on this URL. + return True + + with set_environ("no_proxy", no_proxy_arg): + # parsed.hostname can be `None` in cases such as a file URI. + try: + bypass = proxy_bypass(parsed.hostname) + except (TypeError, socket.gaierror): + bypass = False + + if bypass: + return True + + return False + + +def get_environ_proxies(url, no_proxy=None): + """ + Return a dict of environment proxies. + + :rtype: dict + """ + if should_bypass_proxies(url, no_proxy=no_proxy): + return {} + else: + return getproxies() + + +def select_proxy(url, proxies): + """Select a proxy for the url, if applicable. + + :param url: The url being for the request + :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs + """ + proxies = proxies or {} + urlparts = urlparse(url) + if urlparts.hostname is None: + return proxies.get(urlparts.scheme, proxies.get("all")) + + proxy_keys = [ + urlparts.scheme + "://" + urlparts.hostname, + urlparts.scheme, + "all://" + urlparts.hostname, + "all", + ] + proxy = None + for proxy_key in proxy_keys: + if proxy_key in proxies: + proxy = proxies[proxy_key] + break + + return proxy + + +def resolve_proxies(request, proxies, trust_env=True): + """This method takes proxy information from a request and configuration + input to resolve a mapping of target proxies. This will consider settings + such a NO_PROXY to strip proxy configurations. + + :param request: Request or PreparedRequest + :param proxies: A dictionary of schemes or schemes and hosts to proxy URLs + :param trust_env: Boolean declaring whether to trust environment configs + + :rtype: dict + """ + proxies = proxies if proxies is not None else {} + url = request.url + scheme = urlparse(url).scheme + no_proxy = proxies.get("no_proxy") + new_proxies = proxies.copy() + + if trust_env and not should_bypass_proxies(url, no_proxy=no_proxy): + environ_proxies = get_environ_proxies(url, no_proxy=no_proxy) + + proxy = environ_proxies.get(scheme, environ_proxies.get("all")) + + if proxy: + new_proxies.setdefault(scheme, proxy) + return new_proxies + + +def default_user_agent(name="python-requests"): + """ + Return a string representing the default user agent. + + :rtype: str + """ + return f"{name}/{__version__}" + + +def default_headers(): + """ + :rtype: requests.structures.CaseInsensitiveDict + """ + return CaseInsensitiveDict( + { + "User-Agent": default_user_agent(), + "Accept-Encoding": DEFAULT_ACCEPT_ENCODING, + "Accept": "*/*", + "Connection": "keep-alive", + } + ) + + +def parse_header_links(value): + """Return a list of parsed link headers proxies. + + i.e. Link: ; rel=front; type="image/jpeg",; rel=back;type="image/jpeg" + + :rtype: list + """ + + links = [] + + replace_chars = " '\"" + + value = value.strip(replace_chars) + if not value: + return links + + for val in re.split(", *<", value): + try: + url, params = val.split(";", 1) + except ValueError: + url, params = val, "" + + link = {"url": url.strip("<> '\"")} + + for param in params.split(";"): + try: + key, value = param.split("=") + except ValueError: + break + + link[key.strip(replace_chars)] = value.strip(replace_chars) + + links.append(link) + + return links + + +# Null bytes; no need to recreate these on each call to guess_json_utf +_null = "\x00".encode("ascii") # encoding to ASCII for Python 3 +_null2 = _null * 2 +_null3 = _null * 3 + + +def guess_json_utf(data): + """ + :rtype: str + """ + # JSON always starts with two ASCII characters, so detection is as + # easy as counting the nulls and from their location and count + # determine the encoding. Also detect a BOM, if present. + sample = data[:4] + if sample in (codecs.BOM_UTF32_LE, codecs.BOM_UTF32_BE): + return "utf-32" # BOM included + if sample[:3] == codecs.BOM_UTF8: + return "utf-8-sig" # BOM included, MS style (discouraged) + if sample[:2] in (codecs.BOM_UTF16_LE, codecs.BOM_UTF16_BE): + return "utf-16" # BOM included + nullcount = sample.count(_null) + if nullcount == 0: + return "utf-8" + if nullcount == 2: + if sample[::2] == _null2: # 1st and 3rd are null + return "utf-16-be" + if sample[1::2] == _null2: # 2nd and 4th are null + return "utf-16-le" + # Did not detect 2 valid UTF-16 ascii-range characters + if nullcount == 3: + if sample[:3] == _null3: + return "utf-32-be" + if sample[1:] == _null3: + return "utf-32-le" + # Did not detect a valid UTF-32 ascii-range character + return None + + +def prepend_scheme_if_needed(url, new_scheme): + """Given a URL that may or may not have a scheme, prepend the given scheme. + Does not replace a present scheme with the one provided as an argument. + + :rtype: str + """ + parsed = parse_url(url) + scheme, auth, host, port, path, query, fragment = parsed + + # A defect in urlparse determines that there isn't a netloc present in some + # urls. We previously assumed parsing was overly cautious, and swapped the + # netloc and path. Due to a lack of tests on the original defect, this is + # maintained with parse_url for backwards compatibility. + netloc = parsed.netloc + if not netloc: + netloc, path = path, netloc + + if auth: + # parse_url doesn't provide the netloc with auth + # so we'll add it ourselves. + netloc = "@".join([auth, netloc]) + if scheme is None: + scheme = new_scheme + if path is None: + path = "" + + return urlunparse((scheme, netloc, path, "", query, fragment)) + + +def get_auth_from_url(url): + """Given a url with authentication components, extract them into a tuple of + username,password. + + :rtype: (str,str) + """ + parsed = urlparse(url) + + try: + auth = (unquote(parsed.username), unquote(parsed.password)) + except (AttributeError, TypeError): + auth = ("", "") + + return auth + + +def check_header_validity(header): + """Verifies that header parts don't contain leading whitespace + reserved characters, or return characters. + + :param header: tuple, in the format (name, value). + """ + name, value = header + _validate_header_part(header, name, 0) + _validate_header_part(header, value, 1) + + +def _validate_header_part(header, header_part, header_validator_index): + if isinstance(header_part, str): + validator = _HEADER_VALIDATORS_STR[header_validator_index] + elif isinstance(header_part, bytes): + validator = _HEADER_VALIDATORS_BYTE[header_validator_index] + else: + raise InvalidHeader( + f"Header part ({header_part!r}) from {header} " + f"must be of type str or bytes, not {type(header_part)}" + ) + + if not validator.match(header_part): + header_kind = "name" if header_validator_index == 0 else "value" + raise InvalidHeader( + f"Invalid leading whitespace, reserved character(s), or return" + f"character(s) in header {header_kind}: {header_part!r}" + ) + + +def urldefragauth(url): + """ + Given a url remove the fragment and the authentication part. + + :rtype: str + """ + scheme, netloc, path, params, query, fragment = urlparse(url) + + # see func:`prepend_scheme_if_needed` + if not netloc: + netloc, path = path, netloc + + netloc = netloc.rsplit("@", 1)[-1] + + return urlunparse((scheme, netloc, path, params, query, "")) + + +def rewind_body(prepared_request): + """Move file pointer back to its recorded starting position + so it can be read again on redirect. + """ + body_seek = getattr(prepared_request.body, "seek", None) + if body_seek is not None and isinstance( + prepared_request._body_position, integer_types + ): + try: + body_seek(prepared_request._body_position) + except OSError: + raise UnrewindableBodyError( + "An error occurred when rewinding request body for redirect." + ) + else: + raise UnrewindableBodyError("Unable to rewind request body for redirect.") diff --git a/Modules/urllib3/__init__.py b/Modules/urllib3/__init__.py new file mode 100644 index 0000000..46c8976 --- /dev/null +++ b/Modules/urllib3/__init__.py @@ -0,0 +1,149 @@ +""" +Python HTTP library with thread-safe connection pooling, file post support, user friendly, and more +""" + +from __future__ import annotations + +# Set default logging handler to avoid "No handler found" warnings. +import logging +import typing +import warnings +from logging import NullHandler + +from . import exceptions +from ._base_connection import _TYPE_BODY +from ._collections import HTTPHeaderDict +from ._version import __version__ +from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, connection_from_url +from .filepost import _TYPE_FIELDS, encode_multipart_formdata +from .poolmanager import PoolManager, ProxyManager, proxy_from_url +from .response import BaseHTTPResponse, HTTPResponse +from .util.request import make_headers +from .util.retry import Retry +from .util.timeout import Timeout + +# Ensure that Python is compiled with OpenSSL 1.1.1+ +# If the 'ssl' module isn't available at all that's +# fine, we only care if the module is available. +try: + import ssl +except ImportError: + pass +else: + if not ssl.OPENSSL_VERSION.startswith("OpenSSL "): # Defensive: + warnings.warn( + "urllib3 v2 only supports OpenSSL 1.1.1+, currently " + f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. " + "See: https://github.com/urllib3/urllib3/issues/3020", + exceptions.NotOpenSSLWarning, + ) + elif ssl.OPENSSL_VERSION_INFO < (1, 1, 1): # Defensive: + raise ImportError( + "urllib3 v2 only supports OpenSSL 1.1.1+, currently " + f"the 'ssl' module is compiled with {ssl.OPENSSL_VERSION!r}. " + "See: https://github.com/urllib3/urllib3/issues/2168" + ) + +__author__ = "Andrey Petrov (andrey.petrov@shazow.net)" +__license__ = "MIT" +__version__ = __version__ + +__all__ = ( + "HTTPConnectionPool", + "HTTPHeaderDict", + "HTTPSConnectionPool", + "PoolManager", + "ProxyManager", + "HTTPResponse", + "Retry", + "Timeout", + "add_stderr_logger", + "connection_from_url", + "disable_warnings", + "encode_multipart_formdata", + "make_headers", + "proxy_from_url", + "request", + "BaseHTTPResponse", +) + +logging.getLogger(__name__).addHandler(NullHandler()) + + +def add_stderr_logger( + level: int = logging.DEBUG, +) -> logging.StreamHandler[typing.TextIO]: + """ + Helper for quickly adding a StreamHandler to the logger. Useful for + debugging. + + Returns the handler after adding it. + """ + # This method needs to be in this __init__.py to get the __name__ correct + # even if urllib3 is vendored within another package. + logger = logging.getLogger(__name__) + handler = logging.StreamHandler() + handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s")) + logger.addHandler(handler) + logger.setLevel(level) + logger.debug("Added a stderr logging handler to logger: %s", __name__) + return handler + + +# ... Clean up. +del NullHandler + + +# All warning filters *must* be appended unless you're really certain that they +# shouldn't be: otherwise, it's very hard for users to use most Python +# mechanisms to silence them. +# SecurityWarning's always go off by default. +warnings.simplefilter("always", exceptions.SecurityWarning, append=True) +# InsecurePlatformWarning's don't vary between requests, so we keep it default. +warnings.simplefilter("default", exceptions.InsecurePlatformWarning, append=True) + + +def disable_warnings(category: type[Warning] = exceptions.HTTPWarning) -> None: + """ + Helper for quickly disabling all urllib3 warnings. + """ + warnings.simplefilter("ignore", category) + + +_DEFAULT_POOL = PoolManager() + + +def request( + method: str, + url: str, + *, + body: _TYPE_BODY | None = None, + fields: _TYPE_FIELDS | None = None, + headers: typing.Mapping[str, str] | None = None, + preload_content: bool | None = True, + decode_content: bool | None = True, + redirect: bool | None = True, + retries: Retry | bool | int | None = None, + timeout: Timeout | float | int | None = 3, + json: typing.Any | None = None, +) -> BaseHTTPResponse: + """ + A convenience, top-level request method. It uses a module-global ``PoolManager`` instance. + Therefore, its side effects could be shared across dependencies relying on it. + To avoid side effects create a new ``PoolManager`` instance and use it instead. + The method does not accept low-level ``**urlopen_kw`` keyword arguments. + """ + + return _DEFAULT_POOL.request( + method, + url, + body=body, + fields=fields, + headers=headers, + preload_content=preload_content, + decode_content=decode_content, + redirect=redirect, + retries=retries, + timeout=timeout, + json=json, + ) diff --git a/Modules/urllib3/__pycache__/__init__.cpython-311.pyc b/Modules/urllib3/__pycache__/__init__.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..181279c9852f3100290ed93f8bcfdefb9140d8d3 GIT binary patch literal 5338 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 literal 0 HcmV?d00001 diff --git a/Modules/urllib3/__pycache__/_base_connection.cpython-311.pyc b/Modules/urllib3/__pycache__/_base_connection.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1574d596dd27ce15e256dad7a7c29072c8f0ce3b GIT binary patch literal 7123 zcmbtZ&2Jmm5nqx^a`_?Z!?M0?*=yOBMcbhyf5nND#>z=ro~gtSIiI#CXY7 z-Y#uZC<-5ZaDW_wqCj%Up@$-^ksf;Np?^S+OTdT47AOStlp78EQ1H~5*MGt%f|u&3w}=HV2>;TZ%Ka;p!BtKFa&5x2+No}k$o*xeg)Ndd3n_{E8#+)EoKgb5y1V}}g5&U^GI-mwu zz=A76dhkbNr2|f)P_61_!7S@lBl{y59GSyP?z81ZWo2pM!^NDkw4A%XlwC;&odMmMyH-OM?CZcXnMnucz2t>_NtqGyl5vy1TljlhI_Ko#=Ao3N@Zqz2yt zt{MVLBq|J4gs3P`5>YXjZ`?^NbNzmOL9dp|>#hBUp=DN9ZosR_?wj&&<*Z(1P6F6U z(d9YfnyzckSj}KcN$2+pTrF4EkyJKJbJJ)Yz$VbrFgf6jvdMTsyY+5CGuUmXzhD@Q zo63f6nAJjswc>6y8fM57mY_q%H+i{gW*>`=q$pTbQJlDL+Rd zs6nEJfZ9jYFi`u68Ubn)shFU?!9;aT9akp+$J7JgMbtM{`C&94j)4^9m(;h^;}666 zi2AlV{ZPzDiTf+{ggQgN^mn5Aj(P@KNa|(v9Mp(G&GYbYoF&vN>V=2m_b}2As5m|O zB=KK=f!{~`i!bm~>KM4$RcFYzErbm3(`gNx^-cJMGYcAg(4Q3eE%=acJ4uz53N_7C zHg#^cj_UAAM*K#GUcAFhMR$FfPr|Gn5u=C`g5DhwJKaipp{E4?YdTT0Tw!|6 zbYg27v^L6HtTkfRHZ^t&zJ${<&dQH)DMPQJOBYm?GXsKHujzDD?wm|34zbyng*P#r zwuU;QsxL~C2tO-`LhiSgC>zRM#>=HLQ@0WrSpCX_ZsiVnwk*hkkV!}QEGW;MNdU->@-2kQ~cn>_o7u*r72#*6<`h+2Zhz8S2 z{4|Jo2H~Z{8ZoFM`wz!&9|L!}S~eAB>%fa%lJSK&b87uSXpRYe1CJKyi-y&ObmBxe zSV3jnXdU((=A*(UI+weIu#W8|j2OiYR$;|3^yfc46y)!K&{Z+aFC)F9;R3!c0vOl{ zDdTDqH^BGI8hE(2HQ7U#9q~16jkW-7QajodaVGxr(pfzY(5wusB)g+Wy|lD7(PL;& z_7PNnhRgjxu#^3s4d2bBMJHO^s8#PUmCGRIM-Zj}oQRhJLJ;{esjKzYpzHNlm#%&0 zd(aK6FC(;Dwk<3I`=z?1W3Gj9ay*N$gg|EQ(Qz*yihB8}r|zC?89McCerU(${5bG` zy5aeC?54x)iFIZ|FrXZ|b*P8wJLCn_>q7)geZOGPa8c6@wl&scIFhJ8eV_mY=-}4B ze!T&io^csK_M8RwH!>>|w`|C3yiir;D!V7^T;3=EgR!a%yMVi8y=G{2*&R3&_rGrZ z_j(CBgvJo2Heo|omx0dl8pC0#@|tdL$g8Umy}S{by1FXkFsrLD!VXt4b%i3`>S|Z_ zUbkgt$d#I5!jxp%L3U5V4OK5JTnxuWGpbt$d)TopT?boI=ySIuuU|suIlI;_sKCpaoB8UlN}}w@0l|2Y&_|x_k=D8rFlZ(aT-a zdM59l>mKGF>FtzT=^lpfU6pq&0VSFAkega?ui|FVOGr@~#YpX@@Oh->5MD!|WPTPY z%IN2j!nDp`N5JhNe;Xhj%4Rv971HsZgHVXQhP5%B(RQh$aj=ulW?`Zfp=qKNrir3h zjj`1Y*wh+zk=`{ z!UqT+BjgZ10dOQQHq`m2$h(Db8)4VU;{@^$j>4a@4T0VL%w4pllNObRbkdd7;n}QEdiHZoZ(MPFAsV`Hul(DEZq>L?{wWu_tv)j_RMWrE) z+tQ3hr6J99^QSEdOGBD&#s&FUGn$MI05yHVKL3V2dBlG6ZCgHO&z^1WM}e>xOhH@w z^-K1I+)PBVVhi${KT|JFKn{l|*V2j+ys#uEGiFGMpJ ziu3K`8U{-UVY`oO9jBR5ei>WQRCZ=T6PQB*Wfn>*lux>iz-d@q+@GbmfkC@-Ti8L< z*@a^H&MvIOC)?-0-$NJv?)_ZH?j6r*>CA4^{^Ar$dKXYp@&IylbOYDX$qeN3WD9b6 z@&w|MI}k-a!LS)Q2F;4RgD7$l8iV|VT9C64rL{+EFEbqKU!Dzj<+fGq0-+9n#>JnQ z+u*h>cFdBFLTN}xZRwmvr6HZODGRxYs53KSi%Cm52&Ew%w57uqm4xm1I@61ZRHAz(QX_tL@X zubE{H?~lDJE*?f{lDOV2le=}nkKU1pj~A+Vx9Eg#Rx!eb-GCUpzT||iRO^m(9dE|h zH0EAr#dpr$PCN_u-D(c6s@zNHgV;|W{pZ2L`-=-7UeCS<*SUtqkAi?7qe1x7;iAU-92TGYl!l9{`)7Kp_{e6g=ON4hv%ZNocewECmAtwwQYG0sd@p#_CnJ y#gkTdX^Oc(7`&-Be*5WDl05H}Yr(VF;zh6y&HW7~2!iK5q|JH|=jhIqeDi;4*UIDo literal 0 HcmV?d00001 diff --git a/Modules/urllib3/__pycache__/_collections.cpython-311.pyc b/Modules/urllib3/__pycache__/_collections.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2bbe86952cb9c8284acc3aa90d3f40313bb3435a GIT binary patch literal 26027 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 L_0wZxX9t*M{ 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 literal 0 HcmV?d00001 diff --git a/Modules/urllib3/__pycache__/connection.cpython-311.pyc b/Modules/urllib3/__pycache__/connection.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2b257e5b4392fae028b01683c05a59d4a5cf2357 GIT binary patch literal 33075 zcmch=3ve9QnI78n!n`pv7(9sq(0F4A0(^-tkfI3UL4u?}iU1{XWNI`-H%O54fO-Zb z0S_El(eAGMAS`CsSsA9}qm4%e&oXGQbt9QPCQ=vR&EFg<+H z!f|hL0w5?QuteeB4#61@Ch8;g z%t? zJD9sEzB92avMaGWvODoqCGU$*{Tx0EcT|&;>(d2#1|q_r0}v36<$ONuL$NDF8s>RDeJIFamSL$R3?^LNF~$L z@Yf!nojo&_N+!iQ3PXsOLMCp^iHll*|E!o^M09aFl{qWMgyrv=6nkbNA*Plxh;Ki& zkP)R={O8msc;un?^;ht`IXZj(%tZ9e#KhU?*u>e{=-G+c==jvwES`C0W=_pYu_V%$ zC@of+40i&7?fnFU4{V^Vq{c`0mB{L%4=$-Hn zjC8Mk)+l04CKXL*BqZm(9$Uyn=TlNtLV|O8f6%Wsq)ZQM;dzS_xrj;NfP747KC|LE z8cT~P?Sv$yq-o^uh(?pKgcyw~u4puo5|-lR_C%wvF2&;Nlkaj5Dd9(ZwqH&q#O;DO zcXj*lTq-%gaA|vbIh_#`!uBQ9Zu^oHk1t%@y&ccAei&X{mYVP`13hr0eE@65pX~6g zTcwa512uE0wLf}#{5*W_Gg9itGWr#H!RwFe9derWYWll~5{+IH(VD4bG#ai^g4!U^ zT8-6HsZ;ynjN0mISa2HEMslh65)BY7;=*9Iz#=BqFK&K@t>bT zCoTLLM%Q=EiuH0Pv#8hzrWgLw&T%WPFTFg}+1=CI*S~de_~qy;*{|#vIuILL86ApT zP;9X!VIfm7N*zcIm+9euLyEsuHcroB;fz>Bt6*+XqX1%ww1_o=^$^^m{fhQ3b364& zf^FV%$rN!3HHc}an1UnX7M$?8m=DXR;DOJ}e6?`-n9C1WfVt}63NjbHRnJ@va5XYl z6I{*A)dJTRBdnENKvd6)UcoJdL>Hi2XnVUxm|o}RO~TgKeUVzxC!7`rU$?%8xF6_6 z<|2O4Us|e#Gs4j37{YVHb|B0;C-OipXN4J->h9OQk)SXuJcVcVNd26!XVbe4EPU^# z@J1HCZ&P@aFw4^3|GFpA%yN5Pc!7mHjoey<7n%DAo^D}J&tqX4Wq(KCwgS~py>5@R zYENDgP5^0#gfFpoPT`%lb?$~K(he+iL9(I=V)wAnyLeoLk_0}Lm;@uQ(6}0& zi!X@D%y1=Me}%uel;Ibp)U^dcO!KiMkI5j#cuWf*#-+JTN@7V~jLluW9+QOh&|E69 zh-Kp9LVO{!%*SKPqQqYmGuK5i$*1B#&`3n!lj3!_&MapxBcWjzOJh{Ppam9)#rdn^ z^7WJ?@Ic#`5m+XWwIuRDdIFzGQSQJ`O9+W&GSUKyh_a>T`OIaJp6R$yO?8e|B)nIa z)hQcE&c~MG z8MQ^?DXe({KQE;cs6}Pp4Qnwq+*2wKfBo{p++|*Cg)}cLq+=K3D1es3bnH@G>_-Oi zODSm~b2-5eq(x*nJ9Z{IeR_Q2)aZHYg`HuPJq~oJHi*&g{6ZQ%et7}i9HXIgV_EB9 zo}WbPi8o@2#kjbQUzq2YQ%n5yh4f`gPE4W@B4xs#6vah;G`?_6L?Nl^*|?xc)L?o8 zY}1NMi6j;-UB)=2(X4hV&kqlya|ChdVjQSFCLci8G_8rkrhlT~sy2K*QriFBd9}tHx4R1qlzjWc1SHi=raMA%x@Rj<^@*?67kI}4t zJ|?|{CGCRZ(T4%iN)jh$!?1*K6>M6J9&mL?VJ#Z)S; zxUo87&BO2(h3OSHh4EQ_I+YZa02=|(vIvR=HC6Wmc3U#0hOlc2#nzV>FJ3bu;S@ z)&K0rIvy=-)=aJ#uF+{kF>k%->@CZXIT? zbiaNg(k1r1qXUI@1(n!RxA`+XhjnPq= z%S&lS9V~0DTA~alR$1!?ke{V(nC}m3YF3-OJypm2Y zC1@r9nXul`WDCU3sI$zdbcvri$P-fr=?=P!mIEVaH3fQ8%~Zt$3*Z(+F_A{g#?oM+ zh>}(_M3+e*94|^SX#p?Ir{eL{bw0hckWooTYI_Luq!?-%HnX;t1h~`GAp94#_@7Zs zRm4>Eb6Yxq`fJzm$C~+(S0k0xp9;KA>o9BXAE0C30;gS0Q(Q4t0N{J0liNSsb z{z{1=;I5SD0q%-H4Sa?pQ+kk*Pv}(@K8m?W)!JrSaT-IDE ze9f9)GYjTb^HL<)*h9rSWQ6I+i ztTb1lO5@2t!wV3FGJNT(b2i)$wiSZgLH51bzES^9OU^$i`|IEI$Q|8-lXKKm4)53XZV2xz+^N6wYQFA3q3*y(ujV{QKErk2 z7bLl7V@6s1<&!E=lBC(aNV6ALX*9=doTBod`EX$eq?JJ4OxB^@{&8;b<}P7 z*iG(_o9mBmvwXbG2Df5YRS@Y%9U9mDEY@C(f0f_G8fWmkH7c7pXW%mAMQ-$~>ETT{ zi1*4`1=BT?6fDP=;CigTZx$@ys^X?zGi8jqyNOdX@G25EF5=X(mJh9!xDGQN7%OU| z#rPxJw6q`Zt@KPK8PQ3r-wn)e#_FmoBV&?LRm`QXZG2)0)XGJX7eR|*P3ouF)emAu zb*1|;tr@44MyinVyPl^tTAc_H1Su{c4vnE!Ii(tPwJPyw^ro~#;AMa`tpk`3Jg>1r zH{f4sshSL>M1M-}yaE7bs94K+>T)exb8fot*M(&N+?{JV|D1Z4##50qduxADW3WzJ z?mD*IeriLwb1diBl6M>`I1c3;hvfF2UyjT9BVlq3s zNrW^9P)5orb`5{7G*)$s7XE)xe0p<@lk1z`n*PRgzP_hWkJh~Dl-<698)(GlY<)1e zeSN&(831bV2EKmkjZ!M&N$tfv3U7)^m& zfTYF5e!{`S_fJ-&_*vEOegf;ZZm$ zS>83KRxF>?=qSWeFTwnwrIHBnkRZc4J$XrwBH7`>L}S%xfO}JqkfKX#d{n2ks$0q* zTB%0;NMntA;P%}-kaLIRVDqg#_k%p)@H=C<;QoAYe<8R(=i8ri?B85d8osQiemE*? zI>Sk;2t`OUG7jt%FtMTr;;o#f>>1_BF80h=2-q`YLNXt9q#Bdbe4>zRhU@;{o~ur7hRxHH zVVA^^w~fsYb=)06xusD8tZyGD1k)H1hQ_JAbQJzN+$;4}oy?MkO%9hP^hwy;>~Z$r z_XNIn?B=nrKl{eBUpsyC^!n+dgKKG9AHO*zck~dp2+6%+`t6bjcQEW>_<8ocP1b+A z`sjH_j@_RXeZO`(eL0VIvtjtx`O!A+M{OfVn=DF=Dwk3$;1U&Q`s%`>$`02vXN+mH zqGA%N4J@n`qymiyHk%b%T{e!n>0`^s>L`ofwVAZZ5v2?^Hn** z84+TuTrfa{7(&-gM2IoM%Trc~kgOGC2 zle!A&(%faJ4I$}=U}`1656m<92$=6Uc;gH&T}EC&fxm?xX`S3PN=tO?^z`iL)btE< zoP}y_I$|oeOAxj!sw3L9xRlZ47+C*EMj`zMf!`!xB(B()c3&k( zsD~Iqq7UcaM!+VDq?B$Ojp^4Ahs3k>Twv=x|Bk!<9d{b@{{032{&kz|_7l}x%LtUK zAI<0dSLr_g^1buI-Sa~J{CwfO9_YVXO|>{Uf5X?V-@Ja$*Lm01DSPT}jcpvrjlEE` zaQ?1OII|xDUI36dP8UOuN{vd(Dm6@glCBV-5PCudO%Gv%wMk1Lm|h15Jzk|Ps2nKi zkeMrA+A4=unH<1$2~_HLOlP^@=73UbX1EMBtafEh8wL{9!|1m%waT0`2A|JypsmLR z^9I#s(cd^KOG~-%w5*w~vY5|vZ<$Qo&0Zqw)YaFbxE5eH z1@=A(S@v1vCWQeYs51}mP)yg#g+z~>he-H+V^KQ1GFXM7F{IUzGkgfz*jPM$c-V-% zn+7>a_x}oiYh14GB<_!1{pQH+*t@}eu(uHG%>_r^@BH4E?`|DYpO!;5FjuVo+xY%X zZ4@j~QJ1KNLTDjmq+h=rPW&D7%{H`0E8YUupf*r!nT1STgzua1Nw)wh8p3sm1i54g zad>6hFVPZ4Y*?~QBU48GO!jh5Sc^MS5Hpv!omR(wDcCJsaX9Um?; zj8a97P*ITtInDP!GWAb~or(oo4i$enjZTqB*mLw(SN zF%(CYm41if1ZY88BuS%YWS3Tv91TuFavIb1EqFIk#YWaUsm4D*6kxcY`Rde;{oy2j z^K~Z+fWDIj-^n89aMsG6w!b++D|*4xc6&bO8Q!=CP<7w;25(Kib?O_ZerNj4>AbhQ z;O+j4!9zJO-7??zhwksVW!AFaZ~Tk>Q~8}I3Oi4rMf3iX1^-Fl$4-(Gbk^oPZQ$vG zZLB91(K*=UgSKEFEZ6y5xfp-YJ3t%k%R(J>ls-!f0m8A4n zJIa}aCk*;BIcp^*17BEyT_GQ+fdRuN%DUV=*x!5nNgKhqg)*0i`X&&shtJ@k=t^4{Ivr8mpeH=ZZm`ta{-y zR)W=9kV3739px}djVMPMcdXYFxEluEm8jLkCC>;hD!pV8+^e?a6ib7A9{7$@ShjYp zHS7IqGll$0DR)0Hwzop!TwB?P)g=^aS*^OBn3^v`=uW$;R?dorgd{^7W%6|Wo$B>= zoV(EaCA_)nTlGIF*Q_t=uP*7$5Mr10=#$b%IlNzeHS0w_$<;tMkT%`4mCLuYflPDR zyA^ei8nS_nvh}zWPw-c^BT@!=j1twA;*?xMAk$y+WdoJ(W&`u)6^!M|P%O9SpOjv8 z3W%FR{!LGcFVt11O$#}b(F9@3pww#AYEtUu{*JMYc^i}!|UI<{&$z(SQgzcA)Vu5QhSt*7zak>!~GlN z9;1Q_$gC;blO(I;rQmbM9ArKIO zit8M?N15BUl$jsepLQUX-Wy(5??taGO?|Y(>+-t7^^C`6!cyJxgknlOf#U#*6V`$& zBJA=r67e4riL_bql^WGJTG7jB%}8k8z#iN=V;WVh5ZRYOs6tLa5y6PhkHyW&;L8ih3}WN*^n zr#J5qU=)e~mts?+&}1cor1Da=BzA4+Y?41};m^?c`3BGhgbE?f<0mN>FXMOWo`=8d zAwgFt?-?#ILIf;Y*DkrWQ*LgRLxW^2(|w@muIX~YSf-1NWx8C<1_qi^PjLMixv_cu z*!{*1b=-Zl55M`2u>xS@SfO!j-7R{*BC?$sY=Tp3F6$%Qv4ZG@o1d%7OMmpm)7SZs{wu z>{%yOiYHj)>YXP{vajp?!JKaoZs<Z(eu@g$eEZ9)2p(`|C&FZA<2iOy)hUvw3bb?eJ-E?&)E_2i50!lCjj3Dlyr;Y1>CWkQ(SnC82E$JV4Tv#b zq5&m%Dy{TN8g-$9@na%m(2b={U|31H$BTM&v5a5^)dhr8ZlR}gsw;opFjE+fL;jM4 zAvoCpsdl?yh!RlwYBNi-zap~}GDar!z>Fb`6o?X5?RGS(8WzH;)Qf49$=nDQIAjIM zEJ=;`R&G9ibx?PHh{8aajJE_4Bs%TEfGrfPQm&Js4s=thDVP8Q8eX^3xVCF}=kN}) zg2K+5m_Sw=)uzK*l?H}~VMe2s_UTz^NemDF9Jqsaa5yM0m{TtUGiP8dABVA1d=@I) zO5`^UF2VsrdfMrdR;=Vw>c+LQLdmRcf|33dsp>2lTYi2M0j0Fqdcg3VispP;3H3Hu zY5)8-qP09t)`*ZhHFD0tO>fa`^1f*LSwp|v)C?W46F3b3I$**$1U#J6`*qJ7o?Fk~ zo&n~0;fKPyC+|2}aGcEPHyg2%2gz1&>Rtpe)`dhoOvPEI(^#v0vPkGPBJT0Bdaat6 z%v|?k7?(swPZ-c;CM26kC#X~7wnWXUxss)*q-Qp0Y29>H##yyMZvaVzeq}8sCZjsn z59=Rs15CKQ^UdFT`>rIxDB(L@;ZNLe-F&t2L=PTT9YNgnj=O=Uk2WQSt!}J0R^a* z-|D6c3Q?^b%M4YpKZC+6=MZ5PpbdI32NMsngTzeFz)({)YhebXx-5-$tI+Fb^~|6K zN6>ZHh>;Z}pSpO35pUm!cus?-soEZNOF zYpC#Qgpx7QG}{s((coC=DH#UQhEb8%NLikwY)|*5!y|len)aVM#2a(4`kqgP-6f<8 zc^Ue9DXrMaCKkvVCXCD)uSC%*0o``f*kHg!InsBLz4Z40!dn=TF4a)LB7yG_AUvZu z^qyikRF&enL5~~3G|LrBB7I5fA(wM@c~RSAXo;sTDRymPQR-=XW0W=x>8f6`U!v?K z;V z>+s#y;e6|kLhFv4qq%5>5c0mKGuO4N(6u-3*;nxF%dz{j`~I$Xr$7~xDST}Sz?kUk zC*L?J`}f}W_iW6*f2c4xmiLbr{Nu7eD7Umhe&_||Zu62Yl@~959w1w%q6O)b!IGZ? zecidU(7ESc=fS(32lJgz7doHL*Bvg@9bUIT2zJ~$BnLX>`c^sET?lTK$!21k<_--M zLi^>`{zB_sxqVpf-d^aQ)V$3-h2|Z_CQm(9cYsd`tUHQZIDhlHFHLy%M}zf8IqqXF zFy^s*9N0N#xBOGP4Q^FkP^WHMI7=NoL*OI<>Sd{pzyyJD0%HV_l4`^!&64XhfpY}T z5Fp)#^a25rJABuyx+(3jm075&`UoQi7;)yFrx=#$X|^W{>StyiR8=H44l|VY5&`zq zNJ!6$vegqM3zo2XlGNFZ++uJ1rt$7?k&9WmtQ#&PJ?!|oWyB=Wc~yQ;lTU*weq6fm zQS3h?P%80v$jkC#QH+E^CJw1CmiVc2>yKF0=bePgT zLSU2tN#fY96~&?MVaP12rjpRalF_wlYIK8QeVM>l2&@r!jlk;!m|TNNEr?K-{wV=M zE!gX?uA6gWJRXh0ww&Q1;1li$qm*=@ zeR5-{==RvaoPRC|d2IVBN;wFzf|+ccV4O8z6pR9D*mH~R0N8g87|$udrM>w$%0OFJx7V3sTQ z4;C9(7%T$uAh~?N?_46rx>AyYAV3 zc-rr*+OZQMT(*%Mo6lH!s^K}Y4ha#0X-axzad~8ZDLFUtiYDMtHOEy4RlK4S$kGV9 zV)~I^-Qilc1J-FAd?8IC3W+z^Sr}=>t+}GYg7m0P+oh_$d2t#0^c9a0A(n|LZpv7r zml?UB1SuqeEtQF-g#JVejNK>?l!lSBGz|cuHzP6_eKAI%lLQz+!Dxy90I%Ys)}kX} zuvdq6(6RS%L5D06wp zMLk0&7*taqzYZ<*pOEFF)`}L@j?j5&5+)Vm1?fLi$^HvPYd|9oV-#S7(eWj^7WuzY zg#Sk1zY{Q)dtMRQM-t0_(1n?kJtI=foD1S@a zoW6>7DfzC{>2Iw%lfH5_q)?@BTy%&1b1;HktlePhT23hJ}W1j%qV(szME^BaUY+p6Ox+b}$w-{g>teqrZ1t>Dm$hCCB>fI~1 zbkQa|eSfvw+DAI2X1RmyqYfFrT~ASXhw;37FZp>{|83@T&7<$0edmRHz5DL=?)%7* z?;S1ljP zLTDR!%UjM{&Yy*b-WT$r-G$KZTTZRW#=gKgVRtd)tE--M6U?mINl@|?>=9ojy5O>)P!pOW}47N;$ADcA*W zD;L&b;na@bAz>S4IQDq!^Je86RaDO~ZN4E&;@8#5fKj9aikLjGnr>3%v}IGXoQxWl zet_{O{SyG^B4B{2$032&Y|B-k80EkZUy#koLxnLmR4( zZ>ayJC-Z}5z8nozVIv(2>DcGj#WGON;#O6izz@bnGyrC|>7fgd%-uGON9B%6YUKuP zi!xGKCG8QKO1)OGvj%g&Y_scEpM%e;KNrlZjjYszybO9oe@egQsll!uDVOYRt8*4C ztKczEni4I;Z5WhHd8(B)AmwanJMJoNf;OnCuVUkF$%jqC22FqiR}8%Lcr&)jT*|4T ztE@1q)~r?PE;kChQmdB|+9p~fwM#W*F5hTe*%HvEb?R|}eH#~O`?Be8nP4Qxl{O*6 zk7Hd*R1N&VR3$wT{Gk0xx+3^N{gw1Z@Pkq;>5SkfdZ|gz8U9-MjdH{9gWu2|!4K-| zilJ$PKae#8f^xiKn8v{$%vu0Jzg`KIr48!#N?XbQ+a}sqaiv`kDIbLh?OYGbatW)!4J?Y-O(z(mzfh)p2w&XlfP1B*}74}=vSzSM+h*%>}j|l6K3ndB89TH zc?1_bM~i9@MNh%N8vD9gfz*Bwh0=~zbv0lDQ1x)1vh{6PTZ3b?4)_7qxCgBr-#+|% zhx4t2g;v_^1`O`JH4f3y+so@dIzmHo<8oW)EqZsGx`XNgtX7QOmk-*z3hmq1Ph)dn!QGK_ z56TpMY6l9HwV=CehssbTN;uR`M1 zu(t%Thy}Vnao3Q_1OU1g?7sDLZAVC))do^o2Oz9()fX-BK4{$XX7X0DXro6p*t%6{ z9>_Hh6z$}9aGkvcet(YNUv!e+Rr0&Z@8R(FgMYE6XcLzIy%L2J$tQ;x>`LnQPm2`*g8|+*?ZNwvs=@HFw=wDYlWjoonkXgm&aY zJBl6T=Q+No(6KkyvA5U>KUpvJa1DLX?@*`8t=kH%`x&AB1)E4+nOr zVgvP10z)c*M_ds9Y{jK*pHHIG%lDK32O_?DRjvV8XDy|bwbD#HYo4cd*}!UW8|xz6 z#%c$5iSjO6-w^KBbA{VuxJ}r?ZYlBhaFG+bSxw#%tyTWN&?rEFa} zZ;-a-Ct%E;njsQXCxbQXCv|uH5}iV-2zF!9M7-+Q&l~!@F zgjm9LN{xE@fMUf_KpBbF8CA{3a21C>{bjN%;j|-^0Ig9>yQ8Bs3#G$`(;0fi(uM&| z*;afFas5AdywX+84s6EpZxastT|@>g>*AW*-~95s2k%%5J4W+OM+;3yq2q1rDl`tS zyYGjdfyrFaQm0LL*c)P=Lq3k#t-*$tH!o>uh zG_!J3sMw99AggZFwL%Z*~b@r{W(X!D*RqW5yQjP(!P__2u!3xwAlZI z`jf4*|DN7uEng(pFo7uotn-Fit_NjN?+9$Vm ztR2r;JJdUG?ZC=OI>IjX&Re^n@*%b3pnB)6gL2OR#TZcUymde(9b%KJE7a75n?rh` zVQehdGoo0e3LLR@!&OoR9x4pasMJ~icoMNMKuGKZn2@?26NlTfU~9pq~xmv*G#Rpfg<;XK%KSJQFHh= zE{p0iJtXR|be6k%Mz&zaDcP1ocmj134Ck1O?a;*j;TLeo_o66_CWYsChOjBoN)L#IQHQY;16LyOr-Xm^BD^$)X?uOyD7Ik; z(Ws*#M>=b|^SVP#k`kK4Ne;9UsjCAK8*D;8@>l3Hpl4Dgu~mqwgjyK7VOXVV7Bl=- zg<49hBg2g>f7Tv^S_~UhTI-2UKh%Hs z)eEvgYx&Ok>b>>VyV+L*NprS#HSl@wWCLY-5l^~3>rRKVZo#y~rJFOfuxM9F6Oi^) zgd22J+79d3K$*70k=~khrU$aFbYIpl^^|W&&IW|4{&6xt0IE2hRsa0NaLj zEbHBH89`+Zp{BCMR_nm^*I}bvTec1-4AebdHX+z6-};TRgX&l7Dz?2D2`$o4858oFa9LWxC)TAwkEP1V7Hcy@dI%&Kp2}AG z&|TR|bV^Bv7GCY@;Us(|2lXa|wdty?w~2d=)9sVPp4cu-$Wy6H3v=uUD$wDec5zNU zk=;13wM-?-&P<0Co8i@x(0Ch9x?4nNXqefs3aRTjsV)gZzDio4pTP=CRQ24U;@WgUW#=Mddjrafp+(4E6pTjm{9X zQpff&>pQ-vg6T)*mo7Xq^+KjibeLj?!dumW(^GP(qVbh<1yxZ>7Kp?+T@L1R&fZZ726G0y_yX`TRDx6wlO5^vwCw zXC|i6%}OgBn>Ri2Jbgaq_{7*rob2)Jv!|z{)1%K$V22y!Qd0WcVf#$q5|GGN1t&Yx z$)k!*Lf;6|4$5UWWe|*NCIn@DrjP~hq9|fBH%|PvV1y`6_PLtr)6)}*9Snc4C}~hZHY;p27Hz4zp(qH>%4fBVnt^Rkk!faaH_JRCY$uRyMy9 z)O(bMG)4vc$O)as#T>3A`UEEluV62`gJO^<3alflDB-hKT)GkI>S~?JUzLDh3?+d- zCj#P+06;eEfFTrUQrTXYvu^=OivyqU*A3in9(?~~zIlJ48I0O)-1i&%-*@I4cNH3U zVW&xucA5lfr%BMYZeO=U2or2yxBqO*;QLegEqe=F_O2Z(SernuI$Mi2Hw>{L$!aay z$>oCUwwQBw@NI_$E)0e}Tvz|P9ZVfu-iD&ZZtH#EM`HLz zVu7}zom>vi%NLz+ff4oA-#V6S+nM+5DtLAk-SoJYbNcT&y6!r<@{S%Hc#T8GkiVlT zXYZ05dhRuBz1y(${ipH`I|>au)?Ko@_7+Z-gSaguw{+)v4sKkz*SGg>-`+dveBZ%B z-$4WwS`MwBxbJSd?aI5m3vSTTCTCb~AAkVO*DiYlvLAQ85{+_%3o;&q9e^1`Ox8UEK+kXNF9FSxU z0A`9hK*j5E`q8_)-+B73XGhMn19=qcw_@L+cjp6t$Hr35zYX_;p*{D8M(+-d=7+`# zLu2dXsJ{~0I&MN!&{v$IwsQ7LbjJwGY!ZN|JQ5ZsLeZ?p+JX)x9srZY)BhfSf{-h z;D2s9x_@$n`{yJ4u`L#<7o+)6hk7!@=8sb8r|1V%41uo<=m<@<_N7_F44Es0YDAu4 zVKzOanGH3TX#>BTuj(_+aefRV7}S{6XXu0Mv88MOiMVo-CPq3xq$k@V5rO+-c zykQ9B%1Fz{E4x6hK}=UoDj*kYNu~7~(x+`irR_s7%a-sRJ#OX57%+);GCDqgf$za! zHy=Zg+7aSVE$i(^doG6gvKJ@-_9{)(q6|0hLE)vR2>fdT{{{e`wIZC%l*{0IsPCkH z0@M$XtP_3*yH@I?SMgHSt~sflULY`v)=u9>3?MN-*Ru6q^Y**V+wWNO&3g*Xd%*DA zw`2JA=Iwn2dmqN5ZCDNsk;KUAw$E}yA{SAG#Yhq z-{Jnc`wh43nZ|J^5NKfrkQE338^*vg&7pPEO%H}D+Yk`Mi!@w``g%Wbkoz;&=rE2Y z?HLW@KvEmriUoQb#c8Z3`WGfNgYAC2S8<9H^*kGqML38N+Q9GTt9<;Gl&FHa;;fJ= z)1wXR=5(shiKrwCD~U#^Xf0XuHEz*@(?ReH6{@XLcnnpdMRH`JOw^RMI2SbuRU(~^ zjM0i!sHBpmlQ*)q(rC@vAkuYCKQi$vH7~u4FKJy^slP6zh)_~@^YF=~#6?kB@#Fhp zNumfrdu38{srbsD4fE&m{UAn+E%PJ?h~ellP;L5I-Rhy|M5EC-XHrjWe3F*wq_QNA za=%2MgwfwWclH#$3mXfHIE)Vwi6iVV@bt*`?Yhk-HWmqx3BU?JJ-m?GE+)6fq4G*+ zw#S5PbXJovw3Noi{Nc-)M7*2!;-rU|0D6dN@rEcw4OrQ7PCG4}eO8Ht)|5Mo%ruGY z^eIfYZ=>@RvjnwT8po1nRIK)Q5Gc_YVqc+%!Q6ws2`3HG#KET`ImOTNiB#c_nq_~@Bfqi|M>7fIGo=-R@gn3=f?~Dc)n?(&@_>=)<1BxV_Q$o zv5VH&U05fvxhCh{S+sGsmZHnz9KZ@?Yr^{DYr#fX=a)=!=boJV{72h<+<$lExg2i1 zg8PN@v_Jbx>=5KHnI1UYn7=-(!2oN=upYLAh*)Wm-LU3ovXMCy*SIh~)wxI170tbj z@rdJS3}b|vr&oOHmyCwAv9Mk0L^O6jRhb0mk131*oeG`y!+{f2-CMu)lDeH962Z;+ zqYddYJtS#$N%}?Khhrauv?#vur9^^052z_OR))@L2FL=w(uJWDC*@bA`!SwWv9kiGyY`jzMOum)uo6aO;M&tY{ryw#+qEEVPN(-75L6r zfp4%nmkWEc+>;MblVC0a%!2dZD^^)D$UvFZ3vR37HsNSi_&zW~N+KJkN;-FzeSL>* zf#(SYsO%|!2^;8fqM^~^8jA?EJ$(rT`g$_4QcqjP^jEoD0pD)8L}+DLoxulC3bgzZ zepC$wv!EnXCCt?~Df9t>y#$^kz@GmmT-cv}kUE3nviB>_7?*MsOyD)@s1Z1rnx>_D z6YDRmzwptuwaK4>=AGYo>YW30wDu35%DIo{-Ny@bLy~=pbtWtT z7Aehn0z?x@bX2R#moitCT<|1CsS*w{Wd)NEGS^Qi3UmF`aQ!8@9w#tl@ffGXTqU(i zrRb1}M#H8_Y=C5xMIRNCkrzxm!Du~0&d8`f9Vy~lx+-Q=i^NnMgg>PM0j5Q&QJegb z(eA7$EGDHMj?srh=a=xUCLmjhMw|3M02I5{>C!_A!UuU()trnwAO&^n-^x$6-AjzrXWT(#&qbL#KtORsF zI}e8mqiZSL16C7ugG{=SW_wK)FN<2ah1J8t^y6y+lntRI^#e<4UKB$;w@&rb_gN*P zf}~bdRdGN9Fu_)aCd$`6#Xh9MLX_H3{iA_u44z)_M=yfy))kPn9hS^>R6QwANjUVq z2vQe$VZuz`6-30e)J-va2$0x~o!ZY9MQMOyT3J!U^kgf6K?170LaRF4sjVKv!&vne z>MSPZ*gxgO9%7k%7Sn5FNyvB@DZ z0RSVQX=!FF5ku)pldd13L04wAq9T*ZmEe)%kotw(!%_sP;Kp)>(TPRYWRkhAT;=_M z^R2NznX6r6e=_G>V}E51?;87)IoBHdlQ|>Ac>O?*tGH!uZ?5u|xq)2eEpvmp%KL%E zS+F#L12*lD*_x%UoNo z@|L-tT;+|e&L*#HtzA1oe-DC%B81Y}q3+8FG0YzW&7 zZmoVop`SkH5jb@d@iAa)OyNzh={$*1Md zU#_v68mVuq!A1=ZaQlQFd|GXusv-J`>>o4^^p%p8x;= literal 0 HcmV?d00001 diff --git a/Modules/urllib3/__pycache__/connectionpool.cpython-311.pyc b/Modules/urllib3/__pycache__/connectionpool.cpython-311.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4b690fbf16b123036fd689343396c4571e7a258f GIT binary patch literal 41191 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