Delete emissary-ml

emissary-ml/llm-scripts/fine-tuning/llama3/gpu_monitoring.py

@@ -1,134 +0,0 @@
-#!/usr/bin/env python3
-"""
-GPU Memory Monitoring Script for Model Parallelization Experiments
-"""
-
-import subprocess
-import time
-import csv
-import datetime
-import argparse
-
-
-def get_gpu_memory_info():
-    """Get current GPU memory usage using nvidia-smi"""
-    try:
-        result = subprocess.run(
-            ['nvidia-smi', '--query-gpu=index,name,memory.used,memory.total,utilization.gpu', 
-             '--format=csv,noheader,nounits'],
-            capture_output=True, text=True, check=True
-        )
-        
-        gpu_info = []
-        for line in result.stdout.strip().split('\n'):
-            parts = line.split(', ')
-            gpu_info.append({
-                'index': int(parts[0]),
-                'name': parts[1],
-                'memory_used_mb': int(parts[2]),
-                'memory_total_mb': int(parts[3]),
-                'gpu_utilization': int(parts[4])
-            })
-        return gpu_info
-    except Exception as e:
-        print(f"Error getting GPU info: {e}")
-        return []
-
-def monitor_gpus(output_file, interval=5, experiment_name=""):
-    """Monitor GPU memory usage and save to CSV"""
-    
-    with open(output_file, 'w', newline='') as csvfile:
-        fieldnames = ['timestamp', 'experiment', 'gpu_index', 'gpu_name', 
-                     'memory_used_mb', 'memory_total_mb', 'memory_percent', 
-                     'gpu_utilization']
-        writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
-        writer.writeheader()
-        
-        print(f"Starting GPU monitoring for experiment: {experiment_name}")
-        print(f"Writing to: {output_file}")
-        print("Press Ctrl+C to stop monitoring\n")
-        
-        try:
-            while True:
-                timestamp = datetime.datetime.now().isoformat()
-                gpu_infos = get_gpu_memory_info()
-                
-                for gpu in gpu_infos:
-                    memory_percent = (gpu['memory_used_mb'] / gpu['memory_total_mb']) * 100
-                    
-                    writer.writerow({
-                        'timestamp': timestamp,
-                        'experiment': experiment_name,
-                        'gpu_index': gpu['index'],
-                        'gpu_name': gpu['name'],
-                        'memory_used_mb': gpu['memory_used_mb'],
-                        'memory_total_mb': gpu['memory_total_mb'],
-                        'memory_percent': f"{memory_percent:.2f}",
-                        'gpu_utilization': gpu['gpu_utilization']
-                    })
-                    
-                    print(f"GPU {gpu['index']}: {gpu['memory_used_mb']}/{gpu['memory_total_mb']} MB "
-                          f"({memory_percent:.1f}%) | Util: {gpu['gpu_utilization']}%")
-                
-                print("-" * 80)
-                csvfile.flush()
-                time.sleep(interval)
-                
-        except KeyboardInterrupt:
-            print("\nMonitoring stopped.")
-            
-def analyze_log(log_file):
-    """Analyze the monitoring log and produce summary statistics"""
-    data = []
-    with open(log_file, 'r') as f:
-        reader = csv.DictReader(f)
-        for row in reader:
-            row['memory_used_mb'] = int(row['memory_used_mb'])
-            row['memory_total_mb'] = int(row['memory_total_mb'])
-            row['memory_percent'] = float(row['memory_percent'])
-            row['gpu_utilization'] = int(row['gpu_utilization'])
-            data.append(row)
-    
-    if not data:
-        print("No data found in log file")
-        return
-    
-    # Group by GPU
-    gpus = {}
-    for row in data:
-        gpu_idx = row['gpu_index']
-        if gpu_idx not in gpus:
-            gpus[gpu_idx] = []
-        gpus[gpu_idx].append(row)
-    
-    print(f"\nAnalysis of {log_file}:")
-    print("=" * 80)
-    
-    for gpu_idx, gpu_data in sorted(gpus.items()):
-        memory_used = [d['memory_used_mb'] for d in gpu_data]
-        memory_percent = [d['memory_percent'] for d in gpu_data]
-        gpu_util = [d['gpu_utilization'] for d in gpu_data]
-        
-        print(f"\nGPU {gpu_idx} ({gpu_data[0]['gpu_name']}):")
-        print(f"  Memory - Max: {max(memory_used)} MB ({max(memory_percent):.1f}%)")
-        print(f"  Memory - Avg: {sum(memory_used)/len(memory_used):.0f} MB ({sum(memory_percent)/len(memory_percent):.1f}%)")
-        print(f"  GPU Util - Max: {max(gpu_util)}%")
-        print(f"  GPU Util - Avg: {sum(gpu_util)/len(gpu_util):.1f}%")
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description='GPU Memory Monitor for ML Experiments')
-    parser.add_argument('--output', '-o', default='gpu_monitor.csv', 
-                       help='Output CSV file')
-    parser.add_argument('--interval', '-i', type=int, default=5,
-                       help='Monitoring interval in seconds')
-    parser.add_argument('--experiment', '-e', default='',
-                       help='Experiment name/description')
-    parser.add_argument('--analyze', '-a', 
-                       help='Analyze existing log file instead of monitoring')
-    
-    args = parser.parse_args()
-    
-    if args.analyze:
-        analyze_log(args.analyze)
-    else:
-        monitor_gpus(args.output, args.interval, args.experiment)

emissary-ml/llm-scripts/fine-tuning/llama3/outputs/special_tokens_map.json

@@ -1,30 +0,0 @@
-{
-  "bos_token": {
-    "content": "<s>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "eos_token": {
-    "content": "</s>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "pad_token": {
-    "content": "</s>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  },
-  "unk_token": {
-    "content": "<unk>",
-    "lstrip": false,
-    "normalized": false,
-    "rstrip": false,
-    "single_word": false
-  }
-}

emissary-ml/llm-scripts/fine-tuning/llama3/test_script.py

@@ -1 +0,0 @@
-test_functions = {}

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/_virtualenv.py

@@ -1,130 +0,0 @@
-"""Patches that are applied at runtime to the virtual environment"""
-# -*- coding: utf-8 -*-
-
-import os
-import sys
-
-VIRTUALENV_PATCH_FILE = os.path.join(__file__)
-
-
-def patch_dist(dist):
-    """
-    Distutils allows user to configure some arguments via a configuration file:
-    https://docs.python.org/3/install/index.html#distutils-configuration-files
-
-    Some of this arguments though don't make sense in context of the virtual environment files, let's fix them up.
-    """
-    # we cannot allow some install config as that would get packages installed outside of the virtual environment
-    old_parse_config_files = dist.Distribution.parse_config_files
-
-    def parse_config_files(self, *args, **kwargs):
-        result = old_parse_config_files(self, *args, **kwargs)
-        install = self.get_option_dict("install")
-
-        if "prefix" in install:  # the prefix governs where to install the libraries
-            install["prefix"] = VIRTUALENV_PATCH_FILE, os.path.abspath(sys.prefix)
-        for base in ("purelib", "platlib", "headers", "scripts", "data"):
-            key = "install_{}".format(base)
-            if key in install:  # do not allow global configs to hijack venv paths
-                install.pop(key, None)
-        return result
-
-    dist.Distribution.parse_config_files = parse_config_files
-
-
-# Import hook that patches some modules to ignore configuration values that break package installation in case
-# of virtual environments.
-_DISTUTILS_PATCH = "distutils.dist", "setuptools.dist"
-if sys.version_info > (3, 4):
-    # https://docs.python.org/3/library/importlib.html#setting-up-an-importer
-    from functools import partial
-    from importlib.abc import MetaPathFinder
-    from importlib.util import find_spec
-
-    class _Finder(MetaPathFinder):
-        """A meta path finder that allows patching the imported distutils modules"""
-
-        fullname = None
-
-        # lock[0] is threading.Lock(), but initialized lazily to avoid importing threading very early at startup,
-        # because there are gevent-based applications that need to be first to import threading by themselves.
-        # See https://github.com/pypa/virtualenv/issues/1895 for details.
-        lock = []
-
-        def find_spec(self, fullname, path, target=None):
-            if fullname in _DISTUTILS_PATCH and self.fullname is None:
-                # initialize lock[0] lazily
-                if len(self.lock) == 0:
-                    import threading
-
-                    lock = threading.Lock()
-                    # there is possibility that two threads T1 and T2 are simultaneously running into find_spec,
-                    # observing .lock as empty, and further going into hereby initialization. However due to the GIL,
-                    # list.append() operation is atomic and this way only one of the threads will "win" to put the lock
-                    # - that every thread will use - into .lock[0].
-                    # https://docs.python.org/3/faq/library.html#what-kinds-of-global-value-mutation-are-thread-safe
-                    self.lock.append(lock)
-
-                with self.lock[0]:
-                    self.fullname = fullname
-                    try:
-                        spec = find_spec(fullname, path)
-                        if spec is not None:
-                            # https://www.python.org/dev/peps/pep-0451/#how-loading-will-work
-                            is_new_api = hasattr(spec.loader, "exec_module")
-                            func_name = "exec_module" if is_new_api else "load_module"
-                            old = getattr(spec.loader, func_name)
-                            func = self.exec_module if is_new_api else self.load_module
-                            if old is not func:
-                                try:
-                                    setattr(spec.loader, func_name, partial(func, old))
-                                except AttributeError:
-                                    pass  # C-Extension loaders are r/o such as zipimporter with <python 3.7
-                            return spec
-                    finally:
-                        self.fullname = None
-
-        @staticmethod
-        def exec_module(old, module):
-            old(module)
-            if module.__name__ in _DISTUTILS_PATCH:
-                patch_dist(module)
-
-        @staticmethod
-        def load_module(old, name):
-            module = old(name)
-            if module.__name__ in _DISTUTILS_PATCH:
-                patch_dist(module)
-            return module
-
-    sys.meta_path.insert(0, _Finder())
-else:
-    # https://www.python.org/dev/peps/pep-0302/
-    from imp import find_module
-    from pkgutil import ImpImporter, ImpLoader
-
-    class _VirtualenvImporter(object, ImpImporter):
-        def __init__(self, path=None):
-            object.__init__(self)
-            ImpImporter.__init__(self, path)
-
-        def find_module(self, fullname, path=None):
-            if fullname in _DISTUTILS_PATCH:
-                try:
-                    return _VirtualenvLoader(fullname, *find_module(fullname.split(".")[-1], path))
-                except ImportError:
-                    pass
-            return None
-
-    class _VirtualenvLoader(object, ImpLoader):
-        def __init__(self, fullname, file, filename, etc):
-            object.__init__(self)
-            ImpLoader.__init__(self, fullname, file, filename, etc)
-
-        def load_module(self, fullname):
-            module = super(_VirtualenvLoader, self).load_module(fullname)
-            patch_dist(module)
-            module.__loader__ = None  # distlib fallback
-            return module
-
-    sys.meta_path.append(_VirtualenvImporter())

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/appdirs.py

@@ -1,608 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright (c) 2005-2010 ActiveState Software Inc.
-# Copyright (c) 2013 Eddy Petrișor
-
-"""Utilities for determining application-specific dirs.
-
-See <http://github.com/ActiveState/appdirs> for details and usage.
-"""
-# Dev Notes:
-# - MSDN on where to store app data files:
-#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
-# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
-# - XDG spec for Un*x: http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
-
-__version__ = "1.4.4"
-__version_info__ = tuple(int(segment) for segment in __version__.split("."))
-
-
-import sys
-import os
-
-PY3 = sys.version_info[0] == 3
-
-if PY3:
-    unicode = str
-
-if sys.platform.startswith('java'):
-    import platform
-    os_name = platform.java_ver()[3][0]
-    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
-        system = 'win32'
-    elif os_name.startswith('Mac'): # "Mac OS X", etc.
-        system = 'darwin'
-    else: # "Linux", "SunOS", "FreeBSD", etc.
-        # Setting this to "linux2" is not ideal, but only Windows or Mac
-        # are actually checked for and the rest of the module expects
-        # *sys.platform* style strings.
-        system = 'linux2'
-else:
-    system = sys.platform
-
-
-
-def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user data directories are:
-        Mac OS X:               ~/Library/Application Support/<AppName>
-        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
-        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
-        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
-        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
-        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
-
-    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
-    That means, by default "~/.local/share/<AppName>".
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
-        path = os.path.normpath(_get_win_folder(const))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-    elif system == 'darwin':
-        path = os.path.expanduser('~/Library/Application Support/')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
-    r"""Return full path to the user-shared data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "multipath" is an optional parameter only applicable to *nix
-            which indicates that the entire list of data dirs should be
-            returned. By default, the first item from XDG_DATA_DIRS is
-            returned, or '/usr/local/share/<AppName>',
-            if XDG_DATA_DIRS is not set
-
-    Typical site data directories are:
-        Mac OS X:   /Library/Application Support/<AppName>
-        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
-        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
-        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
-        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
-
-    For Unix, this is using the $XDG_DATA_DIRS[0] default.
-
-    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-    elif system == 'darwin':
-        path = os.path.expanduser('/Library/Application Support')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        # XDG default for $XDG_DATA_DIRS
-        # only first, if multipath is False
-        path = os.getenv('XDG_DATA_DIRS',
-                         os.pathsep.join(['/usr/local/share', '/usr/share']))
-        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
-        if appname:
-            if version:
-                appname = os.path.join(appname, version)
-            pathlist = [os.sep.join([x, appname]) for x in pathlist]
-
-        if multipath:
-            path = os.pathsep.join(pathlist)
-        else:
-            path = pathlist[0]
-        return path
-
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific config dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user config directories are:
-        Mac OS X:               same as user_data_dir
-        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
-        Win *:                  same as user_data_dir
-
-    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
-    That means, by default "~/.config/<AppName>".
-    """
-    if system in ["win32", "darwin"]:
-        path = user_data_dir(appname, appauthor, None, roaming)
-    else:
-        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
-    r"""Return full path to the user-shared data dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "multipath" is an optional parameter only applicable to *nix
-            which indicates that the entire list of config dirs should be
-            returned. By default, the first item from XDG_CONFIG_DIRS is
-            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
-
-    Typical site config directories are:
-        Mac OS X:   same as site_data_dir
-        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
-                    $XDG_CONFIG_DIRS
-        Win *:      same as site_data_dir
-        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
-
-    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
-
-    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
-    """
-    if system in ["win32", "darwin"]:
-        path = site_data_dir(appname, appauthor)
-        if appname and version:
-            path = os.path.join(path, version)
-    else:
-        # XDG default for $XDG_CONFIG_DIRS
-        # only first, if multipath is False
-        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
-        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
-        if appname:
-            if version:
-                appname = os.path.join(appname, version)
-            pathlist = [os.sep.join([x, appname]) for x in pathlist]
-
-        if multipath:
-            path = os.pathsep.join(pathlist)
-        else:
-            path = pathlist[0]
-    return path
-
-
-def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
-    r"""Return full path to the user-specific cache dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "opinion" (boolean) can be False to disable the appending of
-            "Cache" to the base app data dir for Windows. See
-            discussion below.
-
-    Typical user cache directories are:
-        Mac OS X:   ~/Library/Caches/<AppName>
-        Unix:       ~/.cache/<AppName> (XDG default)
-        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
-        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
-
-    On Windows the only suggestion in the MSDN docs is that local settings go in
-    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
-    app data dir (the default returned by `user_data_dir` above). Apps typically
-    put cache data somewhere *under* the given dir here. Some examples:
-        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
-        ...\Acme\SuperApp\Cache\1.0
-    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
-    This can be disabled with the `opinion=False` option.
-    """
-    if system == "win32":
-        if appauthor is None:
-            appauthor = appname
-        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
-        if appname:
-            if appauthor is not False:
-                path = os.path.join(path, appauthor, appname)
-            else:
-                path = os.path.join(path, appname)
-            if opinion:
-                path = os.path.join(path, "Cache")
-    elif system == 'darwin':
-        path = os.path.expanduser('~/Library/Caches')
-        if appname:
-            path = os.path.join(path, appname)
-    else:
-        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_state_dir(appname=None, appauthor=None, version=None, roaming=False):
-    r"""Return full path to the user-specific state dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "roaming" (boolean, default False) can be set True to use the Windows
-            roaming appdata directory. That means that for users on a Windows
-            network setup for roaming profiles, this user data will be
-            sync'd on login. See
-            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
-            for a discussion of issues.
-
-    Typical user state directories are:
-        Mac OS X:  same as user_data_dir
-        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined
-        Win *:     same as user_data_dir
-
-    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state>
-    to extend the XDG spec and support $XDG_STATE_HOME.
-
-    That means, by default "~/.local/state/<AppName>".
-    """
-    if system in ["win32", "darwin"]:
-        path = user_data_dir(appname, appauthor, None, roaming)
-    else:
-        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state"))
-        if appname:
-            path = os.path.join(path, appname)
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
-    r"""Return full path to the user-specific log dir for this application.
-
-        "appname" is the name of application.
-            If None, just the system directory is returned.
-        "appauthor" (only used on Windows) is the name of the
-            appauthor or distributing body for this application. Typically
-            it is the owning company name. This falls back to appname. You may
-            pass False to disable it.
-        "version" is an optional version path element to append to the
-            path. You might want to use this if you want multiple versions
-            of your app to be able to run independently. If used, this
-            would typically be "<major>.<minor>".
-            Only applied when appname is present.
-        "opinion" (boolean) can be False to disable the appending of
-            "Logs" to the base app data dir for Windows, and "log" to the
-            base cache dir for Unix. See discussion below.
-
-    Typical user log directories are:
-        Mac OS X:   ~/Library/Logs/<AppName>
-        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
-        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
-        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
-
-    On Windows the only suggestion in the MSDN docs is that local settings
-    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
-    examples of what some windows apps use for a logs dir.)
-
-    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
-    value for Windows and appends "log" to the user cache dir for Unix.
-    This can be disabled with the `opinion=False` option.
-    """
-    if system == "darwin":
-        path = os.path.join(
-            os.path.expanduser('~/Library/Logs'),
-            appname)
-    elif system == "win32":
-        path = user_data_dir(appname, appauthor, version)
-        version = False
-        if opinion:
-            path = os.path.join(path, "Logs")
-    else:
-        path = user_cache_dir(appname, appauthor, version)
-        version = False
-        if opinion:
-            path = os.path.join(path, "log")
-    if appname and version:
-        path = os.path.join(path, version)
-    return path
-
-
-class AppDirs(object):
-    """Convenience wrapper for getting application dirs."""
-    def __init__(self, appname=None, appauthor=None, version=None,
-            roaming=False, multipath=False):
-        self.appname = appname
-        self.appauthor = appauthor
-        self.version = version
-        self.roaming = roaming
-        self.multipath = multipath
-
-    @property
-    def user_data_dir(self):
-        return user_data_dir(self.appname, self.appauthor,
-                             version=self.version, roaming=self.roaming)
-
-    @property
-    def site_data_dir(self):
-        return site_data_dir(self.appname, self.appauthor,
-                             version=self.version, multipath=self.multipath)
-
-    @property
-    def user_config_dir(self):
-        return user_config_dir(self.appname, self.appauthor,
-                               version=self.version, roaming=self.roaming)
-
-    @property
-    def site_config_dir(self):
-        return site_config_dir(self.appname, self.appauthor,
-                             version=self.version, multipath=self.multipath)
-
-    @property
-    def user_cache_dir(self):
-        return user_cache_dir(self.appname, self.appauthor,
-                              version=self.version)
-
-    @property
-    def user_state_dir(self):
-        return user_state_dir(self.appname, self.appauthor,
-                              version=self.version)
-
-    @property
-    def user_log_dir(self):
-        return user_log_dir(self.appname, self.appauthor,
-                            version=self.version)
-
-
-#---- internal support stuff
-
-def _get_win_folder_from_registry(csidl_name):
-    """This is a fallback technique at best. I'm not sure if using the
-    registry for this guarantees us the correct answer for all CSIDL_*
-    names.
-    """
-    if PY3:
-      import winreg as _winreg
-    else:
-      import _winreg
-
-    shell_folder_name = {
-        "CSIDL_APPDATA": "AppData",
-        "CSIDL_COMMON_APPDATA": "Common AppData",
-        "CSIDL_LOCAL_APPDATA": "Local AppData",
-    }[csidl_name]
-
-    key = _winreg.OpenKey(
-        _winreg.HKEY_CURRENT_USER,
-        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
-    )
-    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
-    return dir
-
-
-def _get_win_folder_with_pywin32(csidl_name):
-    from win32com.shell import shellcon, shell
-    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
-    # Try to make this a unicode path because SHGetFolderPath does
-    # not return unicode strings when there is unicode data in the
-    # path.
-    try:
-        dir = unicode(dir)
-
-        # Downgrade to short path name if have highbit chars. See
-        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-        has_high_char = False
-        for c in dir:
-            if ord(c) > 255:
-                has_high_char = True
-                break
-        if has_high_char:
-            try:
-                import win32api
-                dir = win32api.GetShortPathName(dir)
-            except ImportError:
-                pass
-    except UnicodeError:
-        pass
-    return dir
-
-
-def _get_win_folder_with_ctypes(csidl_name):
-    import ctypes
-
-    csidl_const = {
-        "CSIDL_APPDATA": 26,
-        "CSIDL_COMMON_APPDATA": 35,
-        "CSIDL_LOCAL_APPDATA": 28,
-    }[csidl_name]
-
-    buf = ctypes.create_unicode_buffer(1024)
-    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
-
-    # Downgrade to short path name if have highbit chars. See
-    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-    has_high_char = False
-    for c in buf:
-        if ord(c) > 255:
-            has_high_char = True
-            break
-    if has_high_char:
-        buf2 = ctypes.create_unicode_buffer(1024)
-        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
-            buf = buf2
-
-    return buf.value
-
-def _get_win_folder_with_jna(csidl_name):
-    import array
-    from com.sun import jna
-    from com.sun.jna.platform import win32
-
-    buf_size = win32.WinDef.MAX_PATH * 2
-    buf = array.zeros('c', buf_size)
-    shell = win32.Shell32.INSTANCE
-    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
-    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
-
-    # Downgrade to short path name if have highbit chars. See
-    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
-    has_high_char = False
-    for c in dir:
-        if ord(c) > 255:
-            has_high_char = True
-            break
-    if has_high_char:
-        buf = array.zeros('c', buf_size)
-        kernel = win32.Kernel32.INSTANCE
-        if kernel.GetShortPathName(dir, buf, buf_size):
-            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
-
-    return dir
-
-if system == "win32":
-    try:
-        import win32com.shell
-        _get_win_folder = _get_win_folder_with_pywin32
-    except ImportError:
-        try:
-            from ctypes import windll
-            _get_win_folder = _get_win_folder_with_ctypes
-        except ImportError:
-            try:
-                import com.sun.jna
-                _get_win_folder = _get_win_folder_with_jna
-            except ImportError:
-                _get_win_folder = _get_win_folder_from_registry
-
-
-#---- self test code
-
-if __name__ == "__main__":
-    appname = "MyApp"
-    appauthor = "MyCompany"
-
-    props = ("user_data_dir",
-             "user_config_dir",
-             "user_cache_dir",
-             "user_state_dir",
-             "user_log_dir",
-             "site_data_dir",
-             "site_config_dir")
-
-    print("-- app dirs %s --" % __version__)
-
-    print("-- app dirs (with optional 'version')")
-    dirs = AppDirs(appname, appauthor, version="1.0")
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (without optional 'version')")
-    dirs = AppDirs(appname, appauthor)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (without optional 'appauthor')")
-    dirs = AppDirs(appname)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))
-
-    print("\n-- app dirs (with disabled 'appauthor')")
-    dirs = AppDirs(appname, appauthor=False)
-    for prop in props:
-        print("%s: %s" % (prop, getattr(dirs, prop)))

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/decorator.py

@@ -1,459 +0,0 @@
-# #########################     LICENSE     ############################ #
-
-# Copyright (c) 2005-2025, Michele Simionato
-# All rights reserved.
-
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-
-#   Redistributions of source code must retain the above copyright
-#   notice, this list of conditions and the following disclaimer.
-#   Redistributions in bytecode form must reproduce the above copyright
-#   notice, this list of conditions and the following disclaimer in
-#   the documentation and/or other materials provided with the
-#   distribution.
-
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
-# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
-# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-# DAMAGE.
-
-"""
-Decorator module, see
-https://github.com/micheles/decorator/blob/master/docs/documentation.md
-for the documentation.
-"""
-import re
-import sys
-import inspect
-import operator
-import itertools
-import functools
-from contextlib import _GeneratorContextManager
-from inspect import getfullargspec, iscoroutinefunction, isgeneratorfunction
-
-__version__ = '5.2.1'
-
-DEF = re.compile(r'\s*def\s*([_\w][_\w\d]*)\s*\(')
-POS = inspect.Parameter.POSITIONAL_OR_KEYWORD
-EMPTY = inspect.Parameter.empty
-
-
-# this is not used anymore in the core, but kept for backward compatibility
-class FunctionMaker(object):
-    """
-    An object with the ability to create functions with a given signature.
-    It has attributes name, doc, module, signature, defaults, dict and
-    methods update and make.
-    """
-
-    # Atomic get-and-increment provided by the GIL
-    _compile_count = itertools.count()
-
-    # make pylint happy
-    args = varargs = varkw = defaults = kwonlyargs = kwonlydefaults = ()
-
-    def __init__(self, func=None, name=None, signature=None,
-                 defaults=None, doc=None, module=None, funcdict=None):
-        self.shortsignature = signature
-        if func:
-            # func can be a class or a callable, but not an instance method
-            self.name = func.__name__
-            if self.name == '<lambda>':  # small hack for lambda functions
-                self.name = '_lambda_'
-            self.doc = func.__doc__
-            self.module = func.__module__
-            if inspect.isroutine(func) or isinstance(func, functools.partial):
-                argspec = getfullargspec(func)
-                self.annotations = getattr(func, '__annotations__', {})
-                for a in ('args', 'varargs', 'varkw', 'defaults', 'kwonlyargs',
-                          'kwonlydefaults'):
-                    setattr(self, a, getattr(argspec, a))
-                for i, arg in enumerate(self.args):
-                    setattr(self, 'arg%d' % i, arg)
-                allargs = list(self.args)
-                allshortargs = list(self.args)
-                if self.varargs:
-                    allargs.append('*' + self.varargs)
-                    allshortargs.append('*' + self.varargs)
-                elif self.kwonlyargs:
-                    allargs.append('*')  # single star syntax
-                for a in self.kwonlyargs:
-                    allargs.append('%s=None' % a)
-                    allshortargs.append('%s=%s' % (a, a))
-                if self.varkw:
-                    allargs.append('**' + self.varkw)
-                    allshortargs.append('**' + self.varkw)
-                self.signature = ', '.join(allargs)
-                self.shortsignature = ', '.join(allshortargs)
-                self.dict = func.__dict__.copy()
-        # func=None happens when decorating a caller
-        if name:
-            self.name = name
-        if signature is not None:
-            self.signature = signature
-        if defaults:
-            self.defaults = defaults
-        if doc:
-            self.doc = doc
-        if module:
-            self.module = module
-        if funcdict:
-            self.dict = funcdict
-        # check existence required attributes
-        assert hasattr(self, 'name')
-        if not hasattr(self, 'signature'):
-            raise TypeError('You are decorating a non function: %s' % func)
-
-    def update(self, func, **kw):
-        """
-        Update the signature of func with the data in self
-        """
-        func.__name__ = self.name
-        func.__doc__ = getattr(self, 'doc', None)
-        func.__dict__ = getattr(self, 'dict', {})
-        func.__defaults__ = self.defaults
-        func.__kwdefaults__ = self.kwonlydefaults or None
-        func.__annotations__ = getattr(self, 'annotations', None)
-        try:
-            frame = sys._getframe(3)
-        except AttributeError:  # for IronPython and similar implementations
-            callermodule = '?'
-        else:
-            callermodule = frame.f_globals.get('__name__', '?')
-        func.__module__ = getattr(self, 'module', callermodule)
-        func.__dict__.update(kw)
-
-    def make(self, src_templ, evaldict=None, addsource=False, **attrs):
-        """
-        Make a new function from a given template and update the signature
-        """
-        src = src_templ % vars(self)  # expand name and signature
-        evaldict = evaldict or {}
-        mo = DEF.search(src)
-        if mo is None:
-            raise SyntaxError('not a valid function template\n%s' % src)
-        name = mo.group(1)  # extract the function name
-        names = set([name] + [arg.strip(' *') for arg in
-                              self.shortsignature.split(',')])
-        for n in names:
-            if n in ('_func_', '_call_'):
-                raise NameError('%s is overridden in\n%s' % (n, src))
-
-        if not src.endswith('\n'):  # add a newline for old Pythons
-            src += '\n'
-
-        # Ensure each generated function has a unique filename for profilers
-        # (such as cProfile) that depend on the tuple of (<filename>,
-        # <definition line>, <function name>) being unique.
-        filename = '<decorator-gen-%d>' % next(self._compile_count)
-        try:
-            code = compile(src, filename, 'single')
-            exec(code, evaldict)
-        except Exception:
-            print('Error in generated code:', file=sys.stderr)
-            print(src, file=sys.stderr)
-            raise
-        func = evaldict[name]
-        if addsource:
-            attrs['__source__'] = src
-        self.update(func, **attrs)
-        return func
-
-    @classmethod
-    def create(cls, obj, body, evaldict, defaults=None,
-               doc=None, module=None, addsource=True, **attrs):
-        """
-        Create a function from the strings name, signature and body.
-        evaldict is the evaluation dictionary. If addsource is true an
-        attribute __source__ is added to the result. The attributes attrs
-        are added, if any.
-        """
-        if isinstance(obj, str):  # "name(signature)"
-            name, rest = obj.strip().split('(', 1)
-            signature = rest[:-1]  # strip a right parens
-            func = None
-        else:  # a function
-            name = None
-            signature = None
-            func = obj
-        self = cls(func, name, signature, defaults, doc, module)
-        ibody = '\n'.join('    ' + line for line in body.splitlines())
-        caller = evaldict.get('_call_')  # when called from `decorate`
-        if caller and iscoroutinefunction(caller):
-            body = ('async def %(name)s(%(signature)s):\n' + ibody).replace(
-                'return', 'return await')
-        else:
-            body = 'def %(name)s(%(signature)s):\n' + ibody
-        return self.make(body, evaldict, addsource, **attrs)
-
-
-def fix(args, kwargs, sig):
-    """
-    Fix args and kwargs to be consistent with the signature
-    """
-    ba = sig.bind(*args, **kwargs)
-    ba.apply_defaults()  # needed for test_dan_schult
-    return ba.args, ba.kwargs
-
-
-def decorate(func, caller, extras=(), kwsyntax=False):
-    """
-    Decorates a function/generator/coroutine using a caller.
-    If kwsyntax is True calling the decorated functions with keyword
-    syntax will pass the named arguments inside the ``kw`` dictionary,
-    even if such argument are positional, similarly to what functools.wraps
-    does. By default kwsyntax is False and the the arguments are untouched.
-    """
-    sig = inspect.signature(func)
-    if isinstance(func, functools.partial):
-        func = functools.update_wrapper(func, func.func)
-    if iscoroutinefunction(caller):
-        async def fun(*args, **kw):
-            if not kwsyntax:
-                args, kw = fix(args, kw, sig)
-            return await caller(func, *(extras + args), **kw)
-    elif isgeneratorfunction(caller):
-        def fun(*args, **kw):
-            if not kwsyntax:
-                args, kw = fix(args, kw, sig)
-            for res in caller(func, *(extras + args), **kw):
-                yield res
-    else:
-        def fun(*args, **kw):
-            if not kwsyntax:
-                args, kw = fix(args, kw, sig)
-            return caller(func, *(extras + args), **kw)
-
-    fun.__name__ = func.__name__
-    fun.__doc__ = func.__doc__
-    fun.__wrapped__ = func
-    fun.__signature__ = sig
-    fun.__qualname__ = func.__qualname__
-    # builtin functions like defaultdict.__setitem__ lack many attributes
-    try:
-        fun.__defaults__ = func.__defaults__
-    except AttributeError:
-        pass
-    try:
-        fun.__kwdefaults__ = func.__kwdefaults__
-    except AttributeError:
-        pass
-    try:
-        fun.__annotations__ = func.__annotations__
-    except AttributeError:
-        pass
-    try:
-        fun.__module__ = func.__module__
-    except AttributeError:
-        pass
-    try:
-        fun.__name__ = func.__name__
-    except AttributeError:  # happens with old versions of numpy.vectorize
-        func.__name__ == 'noname'
-    try:
-        fun.__dict__.update(func.__dict__)
-    except AttributeError:
-        pass
-    return fun
-
-
-def decoratorx(caller):
-    """
-    A version of "decorator" implemented via "exec" and not via the
-    Signature object. Use this if you are want to preserve the `.__code__`
-    object properties (https://github.com/micheles/decorator/issues/129).
-    """
-    def dec(func):
-        return FunctionMaker.create(
-            func,
-            "return _call_(_func_, %(shortsignature)s)",
-            dict(_call_=caller, _func_=func),
-            __wrapped__=func, __qualname__=func.__qualname__)
-    return dec
-
-
-def decorator(caller, _func=None, kwsyntax=False):
-    """
-    decorator(caller) converts a caller function into a decorator
-    """
-    if _func is not None:  # return a decorated function
-        # this is obsolete behavior; you should use decorate instead
-        return decorate(_func, caller, (), kwsyntax)
-    # else return a decorator function
-    sig = inspect.signature(caller)
-    dec_params = [p for p in sig.parameters.values() if p.kind is POS]
-
-    def dec(func=None, *args, **kw):
-        na = len(args) + 1
-        extras = args + tuple(kw.get(p.name, p.default)
-                              for p in dec_params[na:]
-                              if p.default is not EMPTY)
-        if func is None:
-            return lambda func: decorate(func, caller, extras, kwsyntax)
-        else:
-            return decorate(func, caller, extras, kwsyntax)
-    dec.__signature__ = sig.replace(parameters=dec_params)
-    dec.__name__ = caller.__name__
-    dec.__doc__ = caller.__doc__
-    dec.__wrapped__ = caller
-    dec.__qualname__ = caller.__qualname__
-    dec.__kwdefaults__ = getattr(caller, '__kwdefaults__', None)
-    dec.__dict__.update(caller.__dict__)
-    return dec
-
-
-# ####################### contextmanager ####################### #
-
-
-class ContextManager(_GeneratorContextManager):
-    def __init__(self, g, *a, **k):
-        _GeneratorContextManager.__init__(self, g, a, k)
-
-    def __call__(self, func):
-        def caller(f, *a, **k):
-            with self.__class__(self.func, *self.args, **self.kwds):
-                return f(*a, **k)
-        return decorate(func, caller)
-
-
-_contextmanager = decorator(ContextManager)
-
-
-def contextmanager(func):
-    # Enable Pylint config: contextmanager-decorators=decorator.contextmanager
-    return _contextmanager(func)
-
-
-# ############################ dispatch_on ############################ #
-
-def append(a, vancestors):
-    """
-    Append ``a`` to the list of the virtual ancestors, unless it is already
-    included.
-    """
-    add = True
-    for j, va in enumerate(vancestors):
-        if issubclass(va, a):
-            add = False
-            break
-        if issubclass(a, va):
-            vancestors[j] = a
-            add = False
-    if add:
-        vancestors.append(a)
-
-
-# inspired from simplegeneric by P.J. Eby and functools.singledispatch
-def dispatch_on(*dispatch_args):
-    """
-    Factory of decorators turning a function into a generic function
-    dispatching on the given arguments.
-    """
-    assert dispatch_args, 'No dispatch args passed'
-    dispatch_str = '(%s,)' % ', '.join(dispatch_args)
-
-    def check(arguments, wrong=operator.ne, msg=''):
-        """Make sure one passes the expected number of arguments"""
-        if wrong(len(arguments), len(dispatch_args)):
-            raise TypeError('Expected %d arguments, got %d%s' %
-                            (len(dispatch_args), len(arguments), msg))
-
-    def gen_func_dec(func):
-        """Decorator turning a function into a generic function"""
-
-        # first check the dispatch arguments
-        argset = set(getfullargspec(func).args)
-        if not set(dispatch_args) <= argset:
-            raise NameError('Unknown dispatch arguments %s' % dispatch_str)
-
-        typemap = {}
-
-        def vancestors(*types):
-            """
-            Get a list of sets of virtual ancestors for the given types
-            """
-            check(types)
-            ras = [[] for _ in range(len(dispatch_args))]
-            for types_ in typemap:
-                for t, type_, ra in zip(types, types_, ras):
-                    if issubclass(t, type_) and type_ not in t.mro():
-                        append(type_, ra)
-            return [set(ra) for ra in ras]
-
-        def ancestors(*types):
-            """
-            Get a list of virtual MROs, one for each type
-            """
-            check(types)
-            lists = []
-            for t, vas in zip(types, vancestors(*types)):
-                n_vas = len(vas)
-                if n_vas > 1:
-                    raise RuntimeError(
-                        'Ambiguous dispatch for %s: %s' % (t, vas))
-                elif n_vas == 1:
-                    va, = vas
-                    mro = type('t', (t, va), {}).mro()[1:]
-                else:
-                    mro = t.mro()
-                lists.append(mro[:-1])  # discard t and object
-            return lists
-
-        def register(*types):
-            """
-            Decorator to register an implementation for the given types
-            """
-            check(types)
-
-            def dec(f):
-                check(getfullargspec(f).args, operator.lt, ' in ' + f.__name__)
-                typemap[types] = f
-                return f
-            return dec
-
-        def dispatch_info(*types):
-            """
-            An utility to introspect the dispatch algorithm
-            """
-            check(types)
-            lst = []
-            for ancs in itertools.product(*ancestors(*types)):
-                lst.append(tuple(a.__name__ for a in ancs))
-            return lst
-
-        def _dispatch(dispatch_args, *args, **kw):
-            types = tuple(type(arg) for arg in dispatch_args)
-            try:  # fast path
-                f = typemap[types]
-            except KeyError:
-                pass
-            else:
-                return f(*args, **kw)
-            combinations = itertools.product(*ancestors(*types))
-            next(combinations)  # the first one has been already tried
-            for types_ in combinations:
-                f = typemap.get(types_)
-                if f is not None:
-                    return f(*args, **kw)
-
-            # else call the default implementation
-            return func(*args, **kw)
-
-        return FunctionMaker.create(
-            func, 'return _f_(%s, %%(shortsignature)s)' % dispatch_str,
-            dict(_f_=_dispatch), register=register, default=func,
-            typemap=typemap, vancestors=vancestors, ancestors=ancestors,
-            dispatch_info=dispatch_info, __wrapped__=func)
-
-    gen_func_dec.__name__ = 'dispatch_on' + dispatch_str
-    return gen_func_dec

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/distutils-precedence.pth

@@ -1 +0,0 @@
-import os; var = 'SETUPTOOLS_USE_DISTUTILS'; enabled = os.environ.get(var, 'stdlib') == 'local'; enabled and __import__('_distutils_hack').add_shim(); 

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/__init__.py

@@ -1,105 +0,0 @@
-from .__version__ import __description__, __title__, __version__
-from ._api import *
-from ._auth import *
-from ._client import *
-from ._config import *
-from ._content import *
-from ._exceptions import *
-from ._models import *
-from ._status_codes import *
-from ._transports import *
-from ._types import *
-from ._urls import *
-
-try:
-    from ._main import main
-except ImportError:  # pragma: no cover
-
-    def main() -> None:  # type: ignore
-        import sys
-
-        print(
-            "The httpx command line client could not run because the required "
-            "dependencies were not installed.\nMake sure you've installed "
-            "everything with: pip install 'httpx[cli]'"
-        )
-        sys.exit(1)
-
-
-__all__ = [
-    "__description__",
-    "__title__",
-    "__version__",
-    "ASGITransport",
-    "AsyncBaseTransport",
-    "AsyncByteStream",
-    "AsyncClient",
-    "AsyncHTTPTransport",
-    "Auth",
-    "BaseTransport",
-    "BasicAuth",
-    "ByteStream",
-    "Client",
-    "CloseError",
-    "codes",
-    "ConnectError",
-    "ConnectTimeout",
-    "CookieConflict",
-    "Cookies",
-    "create_ssl_context",
-    "DecodingError",
-    "delete",
-    "DigestAuth",
-    "get",
-    "head",
-    "Headers",
-    "HTTPError",
-    "HTTPStatusError",
-    "HTTPTransport",
-    "InvalidURL",
-    "Limits",
-    "LocalProtocolError",
-    "main",
-    "MockTransport",
-    "NetRCAuth",
-    "NetworkError",
-    "options",
-    "patch",
-    "PoolTimeout",
-    "post",
-    "ProtocolError",
-    "Proxy",
-    "ProxyError",
-    "put",
-    "QueryParams",
-    "ReadError",
-    "ReadTimeout",
-    "RemoteProtocolError",
-    "request",
-    "Request",
-    "RequestError",
-    "RequestNotRead",
-    "Response",
-    "ResponseNotRead",
-    "stream",
-    "StreamClosed",
-    "StreamConsumed",
-    "StreamError",
-    "SyncByteStream",
-    "Timeout",
-    "TimeoutException",
-    "TooManyRedirects",
-    "TransportError",
-    "UnsupportedProtocol",
-    "URL",
-    "USE_CLIENT_DEFAULT",
-    "WriteError",
-    "WriteTimeout",
-    "WSGITransport",
-]
-
-
-__locals = locals()
-for __name in __all__:
-    if not __name.startswith("__"):
-        setattr(__locals[__name], "__module__", "httpx")  # noqa

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/__version__.py

@@ -1,3 +0,0 @@
-__title__ = "httpx"
-__description__ = "A next generation HTTP client, for Python 3."
-__version__ = "0.28.1"

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_api.py

@@ -1,438 +0,0 @@
-from __future__ import annotations
-
-import typing
-from contextlib import contextmanager
-
-from ._client import Client
-from ._config import DEFAULT_TIMEOUT_CONFIG
-from ._models import Response
-from ._types import (
-    AuthTypes,
-    CookieTypes,
-    HeaderTypes,
-    ProxyTypes,
-    QueryParamTypes,
-    RequestContent,
-    RequestData,
-    RequestFiles,
-    TimeoutTypes,
-)
-from ._urls import URL
-
-if typing.TYPE_CHECKING:
-    import ssl  # pragma: no cover
-
-
-__all__ = [
-    "delete",
-    "get",
-    "head",
-    "options",
-    "patch",
-    "post",
-    "put",
-    "request",
-    "stream",
-]
-
-
-def request(
-    method: str,
-    url: URL | str,
-    *,
-    params: QueryParamTypes | None = None,
-    content: RequestContent | None = None,
-    data: RequestData | None = None,
-    files: RequestFiles | None = None,
-    json: typing.Any | None = None,
-    headers: HeaderTypes | None = None,
-    cookies: CookieTypes | None = None,
-    auth: AuthTypes | None = None,
-    proxy: ProxyTypes | None = None,
-    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    follow_redirects: bool = False,
-    verify: ssl.SSLContext | str | bool = True,
-    trust_env: bool = True,
-) -> Response:
-    """
-    Sends an HTTP request.
-
-    **Parameters:**
-
-    * **method** - HTTP method for the new `Request` object: `GET`, `OPTIONS`,
-    `HEAD`, `POST`, `PUT`, `PATCH`, or `DELETE`.
-    * **url** - URL for the new `Request` object.
-    * **params** - *(optional)* Query parameters to include in the URL, as a
-    string, dictionary, or sequence of two-tuples.
-    * **content** - *(optional)* Binary content to include in the body of the
-    request, as bytes or a byte iterator.
-    * **data** - *(optional)* Form data to include in the body of the request,
-    as a dictionary.
-    * **files** - *(optional)* A dictionary of upload files to include in the
-    body of the request.
-    * **json** - *(optional)* A JSON serializable object to include in the body
-    of the request.
-    * **headers** - *(optional)* Dictionary of HTTP headers to include in the
-    request.
-    * **cookies** - *(optional)* Dictionary of Cookie items to include in the
-    request.
-    * **auth** - *(optional)* An authentication class to use when sending the
-    request.
-    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
-    * **timeout** - *(optional)* The timeout configuration to use when sending
-    the request.
-    * **follow_redirects** - *(optional)* Enables or disables HTTP redirects.
-    * **verify** - *(optional)* Either `True` to use an SSL context with the
-    default CA bundle, `False` to disable verification, or an instance of
-    `ssl.SSLContext` to use a custom context.
-    * **trust_env** - *(optional)* Enables or disables usage of environment
-    variables for configuration.
-
-    **Returns:** `Response`
-
-    Usage:
-
-    ```
-    >>> import httpx
-    >>> response = httpx.request('GET', 'https://httpbin.org/get')
-    >>> response
-    <Response [200 OK]>
-    ```
-    """
-    with Client(
-        cookies=cookies,
-        proxy=proxy,
-        verify=verify,
-        timeout=timeout,
-        trust_env=trust_env,
-    ) as client:
-        return client.request(
-            method=method,
-            url=url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            auth=auth,
-            follow_redirects=follow_redirects,
-        )
-
-
-@contextmanager
-def stream(
-    method: str,
-    url: URL | str,
-    *,
-    params: QueryParamTypes | None = None,
-    content: RequestContent | None = None,
-    data: RequestData | None = None,
-    files: RequestFiles | None = None,
-    json: typing.Any | None = None,
-    headers: HeaderTypes | None = None,
-    cookies: CookieTypes | None = None,
-    auth: AuthTypes | None = None,
-    proxy: ProxyTypes | None = None,
-    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    follow_redirects: bool = False,
-    verify: ssl.SSLContext | str | bool = True,
-    trust_env: bool = True,
-) -> typing.Iterator[Response]:
-    """
-    Alternative to `httpx.request()` that streams the response body
-    instead of loading it into memory at once.
-
-    **Parameters**: See `httpx.request`.
-
-    See also: [Streaming Responses][0]
-
-    [0]: /quickstart#streaming-responses
-    """
-    with Client(
-        cookies=cookies,
-        proxy=proxy,
-        verify=verify,
-        timeout=timeout,
-        trust_env=trust_env,
-    ) as client:
-        with client.stream(
-            method=method,
-            url=url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            auth=auth,
-            follow_redirects=follow_redirects,
-        ) as response:
-            yield response
-
-
-def get(
-    url: URL | str,
-    *,
-    params: QueryParamTypes | None = None,
-    headers: HeaderTypes | None = None,
-    cookies: CookieTypes | None = None,
-    auth: AuthTypes | None = None,
-    proxy: ProxyTypes | None = None,
-    follow_redirects: bool = False,
-    verify: ssl.SSLContext | str | bool = True,
-    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    trust_env: bool = True,
-) -> Response:
-    """
-    Sends a `GET` request.
-
-    **Parameters**: See `httpx.request`.
-
-    Note that the `data`, `files`, `json` and `content` parameters are not available
-    on this function, as `GET` requests should not include a request body.
-    """
-    return request(
-        "GET",
-        url,
-        params=params,
-        headers=headers,
-        cookies=cookies,
-        auth=auth,
-        proxy=proxy,
-        follow_redirects=follow_redirects,
-        verify=verify,
-        timeout=timeout,
-        trust_env=trust_env,
-    )
-
-
-def options(
-    url: URL | str,
-    *,
-    params: QueryParamTypes | None = None,
-    headers: HeaderTypes | None = None,
-    cookies: CookieTypes | None = None,
-    auth: AuthTypes | None = None,
-    proxy: ProxyTypes | None = None,
-    follow_redirects: bool = False,
-    verify: ssl.SSLContext | str | bool = True,
-    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    trust_env: bool = True,
-) -> Response:
-    """
-    Sends an `OPTIONS` request.
-
-    **Parameters**: See `httpx.request`.
-
-    Note that the `data`, `files`, `json` and `content` parameters are not available
-    on this function, as `OPTIONS` requests should not include a request body.
-    """
-    return request(
-        "OPTIONS",
-        url,
-        params=params,
-        headers=headers,
-        cookies=cookies,
-        auth=auth,
-        proxy=proxy,
-        follow_redirects=follow_redirects,
-        verify=verify,
-        timeout=timeout,
-        trust_env=trust_env,
-    )
-
-
-def head(
-    url: URL | str,
-    *,
-    params: QueryParamTypes | None = None,
-    headers: HeaderTypes | None = None,
-    cookies: CookieTypes | None = None,
-    auth: AuthTypes | None = None,
-    proxy: ProxyTypes | None = None,
-    follow_redirects: bool = False,
-    verify: ssl.SSLContext | str | bool = True,
-    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    trust_env: bool = True,
-) -> Response:
-    """
-    Sends a `HEAD` request.
-
-    **Parameters**: See `httpx.request`.
-
-    Note that the `data`, `files`, `json` and `content` parameters are not available
-    on this function, as `HEAD` requests should not include a request body.
-    """
-    return request(
-        "HEAD",
-        url,
-        params=params,
-        headers=headers,
-        cookies=cookies,
-        auth=auth,
-        proxy=proxy,
-        follow_redirects=follow_redirects,
-        verify=verify,
-        timeout=timeout,
-        trust_env=trust_env,
-    )
-
-
-def post(
-    url: URL | str,
-    *,
-    content: RequestContent | None = None,
-    data: RequestData | None = None,
-    files: RequestFiles | None = None,
-    json: typing.Any | None = None,
-    params: QueryParamTypes | None = None,
-    headers: HeaderTypes | None = None,
-    cookies: CookieTypes | None = None,
-    auth: AuthTypes | None = None,
-    proxy: ProxyTypes | None = None,
-    follow_redirects: bool = False,
-    verify: ssl.SSLContext | str | bool = True,
-    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    trust_env: bool = True,
-) -> Response:
-    """
-    Sends a `POST` request.
-
-    **Parameters**: See `httpx.request`.
-    """
-    return request(
-        "POST",
-        url,
-        content=content,
-        data=data,
-        files=files,
-        json=json,
-        params=params,
-        headers=headers,
-        cookies=cookies,
-        auth=auth,
-        proxy=proxy,
-        follow_redirects=follow_redirects,
-        verify=verify,
-        timeout=timeout,
-        trust_env=trust_env,
-    )
-
-
-def put(
-    url: URL | str,
-    *,
-    content: RequestContent | None = None,
-    data: RequestData | None = None,
-    files: RequestFiles | None = None,
-    json: typing.Any | None = None,
-    params: QueryParamTypes | None = None,
-    headers: HeaderTypes | None = None,
-    cookies: CookieTypes | None = None,
-    auth: AuthTypes | None = None,
-    proxy: ProxyTypes | None = None,
-    follow_redirects: bool = False,
-    verify: ssl.SSLContext | str | bool = True,
-    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    trust_env: bool = True,
-) -> Response:
-    """
-    Sends a `PUT` request.
-
-    **Parameters**: See `httpx.request`.
-    """
-    return request(
-        "PUT",
-        url,
-        content=content,
-        data=data,
-        files=files,
-        json=json,
-        params=params,
-        headers=headers,
-        cookies=cookies,
-        auth=auth,
-        proxy=proxy,
-        follow_redirects=follow_redirects,
-        verify=verify,
-        timeout=timeout,
-        trust_env=trust_env,
-    )
-
-
-def patch(
-    url: URL | str,
-    *,
-    content: RequestContent | None = None,
-    data: RequestData | None = None,
-    files: RequestFiles | None = None,
-    json: typing.Any | None = None,
-    params: QueryParamTypes | None = None,
-    headers: HeaderTypes | None = None,
-    cookies: CookieTypes | None = None,
-    auth: AuthTypes | None = None,
-    proxy: ProxyTypes | None = None,
-    follow_redirects: bool = False,
-    verify: ssl.SSLContext | str | bool = True,
-    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    trust_env: bool = True,
-) -> Response:
-    """
-    Sends a `PATCH` request.
-
-    **Parameters**: See `httpx.request`.
-    """
-    return request(
-        "PATCH",
-        url,
-        content=content,
-        data=data,
-        files=files,
-        json=json,
-        params=params,
-        headers=headers,
-        cookies=cookies,
-        auth=auth,
-        proxy=proxy,
-        follow_redirects=follow_redirects,
-        verify=verify,
-        timeout=timeout,
-        trust_env=trust_env,
-    )
-
-
-def delete(
-    url: URL | str,
-    *,
-    params: QueryParamTypes | None = None,
-    headers: HeaderTypes | None = None,
-    cookies: CookieTypes | None = None,
-    auth: AuthTypes | None = None,
-    proxy: ProxyTypes | None = None,
-    follow_redirects: bool = False,
-    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-    verify: ssl.SSLContext | str | bool = True,
-    trust_env: bool = True,
-) -> Response:
-    """
-    Sends a `DELETE` request.
-
-    **Parameters**: See `httpx.request`.
-
-    Note that the `data`, `files`, `json` and `content` parameters are not available
-    on this function, as `DELETE` requests should not include a request body.
-    """
-    return request(
-        "DELETE",
-        url,
-        params=params,
-        headers=headers,
-        cookies=cookies,
-        auth=auth,
-        proxy=proxy,
-        follow_redirects=follow_redirects,
-        verify=verify,
-        timeout=timeout,
-        trust_env=trust_env,
-    )

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_auth.py

@@ -1,348 +0,0 @@
-from __future__ import annotations
-
-import hashlib
-import os
-import re
-import time
-import typing
-from base64 import b64encode
-from urllib.request import parse_http_list
-
-from ._exceptions import ProtocolError
-from ._models import Cookies, Request, Response
-from ._utils import to_bytes, to_str, unquote
-
-if typing.TYPE_CHECKING:  # pragma: no cover
-    from hashlib import _Hash
-
-
-__all__ = ["Auth", "BasicAuth", "DigestAuth", "NetRCAuth"]
-
-
-class Auth:
-    """
-    Base class for all authentication schemes.
-
-    To implement a custom authentication scheme, subclass `Auth` and override
-    the `.auth_flow()` method.
-
-    If the authentication scheme does I/O such as disk access or network calls, or uses
-    synchronization primitives such as locks, you should override `.sync_auth_flow()`
-    and/or `.async_auth_flow()` instead of `.auth_flow()` to provide specialized
-    implementations that will be used by `Client` and `AsyncClient` respectively.
-    """
-
-    requires_request_body = False
-    requires_response_body = False
-
-    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
-        """
-        Execute the authentication flow.
-
-        To dispatch a request, `yield` it:
-
-        ```
-        yield request
-        ```
-
-        The client will `.send()` the response back into the flow generator. You can
-        access it like so:
-
-        ```
-        response = yield request
-        ```
-
-        A `return` (or reaching the end of the generator) will result in the
-        client returning the last response obtained from the server.
-
-        You can dispatch as many requests as is necessary.
-        """
-        yield request
-
-    def sync_auth_flow(
-        self, request: Request
-    ) -> typing.Generator[Request, Response, None]:
-        """
-        Execute the authentication flow synchronously.
-
-        By default, this defers to `.auth_flow()`. You should override this method
-        when the authentication scheme does I/O and/or uses concurrency primitives.
-        """
-        if self.requires_request_body:
-            request.read()
-
-        flow = self.auth_flow(request)
-        request = next(flow)
-
-        while True:
-            response = yield request
-            if self.requires_response_body:
-                response.read()
-
-            try:
-                request = flow.send(response)
-            except StopIteration:
-                break
-
-    async def async_auth_flow(
-        self, request: Request
-    ) -> typing.AsyncGenerator[Request, Response]:
-        """
-        Execute the authentication flow asynchronously.
-
-        By default, this defers to `.auth_flow()`. You should override this method
-        when the authentication scheme does I/O and/or uses concurrency primitives.
-        """
-        if self.requires_request_body:
-            await request.aread()
-
-        flow = self.auth_flow(request)
-        request = next(flow)
-
-        while True:
-            response = yield request
-            if self.requires_response_body:
-                await response.aread()
-
-            try:
-                request = flow.send(response)
-            except StopIteration:
-                break
-
-
-class FunctionAuth(Auth):
-    """
-    Allows the 'auth' argument to be passed as a simple callable function,
-    that takes the request, and returns a new, modified request.
-    """
-
-    def __init__(self, func: typing.Callable[[Request], Request]) -> None:
-        self._func = func
-
-    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
-        yield self._func(request)
-
-
-class BasicAuth(Auth):
-    """
-    Allows the 'auth' argument to be passed as a (username, password) pair,
-    and uses HTTP Basic authentication.
-    """
-
-    def __init__(self, username: str | bytes, password: str | bytes) -> None:
-        self._auth_header = self._build_auth_header(username, password)
-
-    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
-        request.headers["Authorization"] = self._auth_header
-        yield request
-
-    def _build_auth_header(self, username: str | bytes, password: str | bytes) -> str:
-        userpass = b":".join((to_bytes(username), to_bytes(password)))
-        token = b64encode(userpass).decode()
-        return f"Basic {token}"
-
-
-class NetRCAuth(Auth):
-    """
-    Use a 'netrc' file to lookup basic auth credentials based on the url host.
-    """
-
-    def __init__(self, file: str | None = None) -> None:
-        # Lazily import 'netrc'.
-        # There's no need for us to load this module unless 'NetRCAuth' is being used.
-        import netrc
-
-        self._netrc_info = netrc.netrc(file)
-
-    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
-        auth_info = self._netrc_info.authenticators(request.url.host)
-        if auth_info is None or not auth_info[2]:
-            # The netrc file did not have authentication credentials for this host.
-            yield request
-        else:
-            # Build a basic auth header with credentials from the netrc file.
-            request.headers["Authorization"] = self._build_auth_header(
-                username=auth_info[0], password=auth_info[2]
-            )
-            yield request
-
-    def _build_auth_header(self, username: str | bytes, password: str | bytes) -> str:
-        userpass = b":".join((to_bytes(username), to_bytes(password)))
-        token = b64encode(userpass).decode()
-        return f"Basic {token}"
-
-
-class DigestAuth(Auth):
-    _ALGORITHM_TO_HASH_FUNCTION: dict[str, typing.Callable[[bytes], _Hash]] = {
-        "MD5": hashlib.md5,
-        "MD5-SESS": hashlib.md5,
-        "SHA": hashlib.sha1,
-        "SHA-SESS": hashlib.sha1,
-        "SHA-256": hashlib.sha256,
-        "SHA-256-SESS": hashlib.sha256,
-        "SHA-512": hashlib.sha512,
-        "SHA-512-SESS": hashlib.sha512,
-    }
-
-    def __init__(self, username: str | bytes, password: str | bytes) -> None:
-        self._username = to_bytes(username)
-        self._password = to_bytes(password)
-        self._last_challenge: _DigestAuthChallenge | None = None
-        self._nonce_count = 1
-
-    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
-        if self._last_challenge:
-            request.headers["Authorization"] = self._build_auth_header(
-                request, self._last_challenge
-            )
-
-        response = yield request
-
-        if response.status_code != 401 or "www-authenticate" not in response.headers:
-            # If the response is not a 401 then we don't
-            # need to build an authenticated request.
-            return
-
-        for auth_header in response.headers.get_list("www-authenticate"):
-            if auth_header.lower().startswith("digest "):
-                break
-        else:
-            # If the response does not include a 'WWW-Authenticate: Digest ...'
-            # header, then we don't need to build an authenticated request.
-            return
-
-        self._last_challenge = self._parse_challenge(request, response, auth_header)
-        self._nonce_count = 1
-
-        request.headers["Authorization"] = self._build_auth_header(
-            request, self._last_challenge
-        )
-        if response.cookies:
-            Cookies(response.cookies).set_cookie_header(request=request)
-        yield request
-
-    def _parse_challenge(
-        self, request: Request, response: Response, auth_header: str
-    ) -> _DigestAuthChallenge:
-        """
-        Returns a challenge from a Digest WWW-Authenticate header.
-        These take the form of:
-        `Digest realm="[email protected]",qop="auth,auth-int",nonce="abc",opaque="xyz"`
-        """
-        scheme, _, fields = auth_header.partition(" ")
-
-        # This method should only ever have been called with a Digest auth header.
-        assert scheme.lower() == "digest"
-
-        header_dict: dict[str, str] = {}
-        for field in parse_http_list(fields):
-            key, value = field.strip().split("=", 1)
-            header_dict[key] = unquote(value)
-
-        try:
-            realm = header_dict["realm"].encode()
-            nonce = header_dict["nonce"].encode()
-            algorithm = header_dict.get("algorithm", "MD5")
-            opaque = header_dict["opaque"].encode() if "opaque" in header_dict else None
-            qop = header_dict["qop"].encode() if "qop" in header_dict else None
-            return _DigestAuthChallenge(
-                realm=realm, nonce=nonce, algorithm=algorithm, opaque=opaque, qop=qop
-            )
-        except KeyError as exc:
-            message = "Malformed Digest WWW-Authenticate header"
-            raise ProtocolError(message, request=request) from exc
-
-    def _build_auth_header(
-        self, request: Request, challenge: _DigestAuthChallenge
-    ) -> str:
-        hash_func = self._ALGORITHM_TO_HASH_FUNCTION[challenge.algorithm.upper()]
-
-        def digest(data: bytes) -> bytes:
-            return hash_func(data).hexdigest().encode()
-
-        A1 = b":".join((self._username, challenge.realm, self._password))
-
-        path = request.url.raw_path
-        A2 = b":".join((request.method.encode(), path))
-        # TODO: implement auth-int
-        HA2 = digest(A2)
-
-        nc_value = b"%08x" % self._nonce_count
-        cnonce = self._get_client_nonce(self._nonce_count, challenge.nonce)
-        self._nonce_count += 1
-
-        HA1 = digest(A1)
-        if challenge.algorithm.lower().endswith("-sess"):
-            HA1 = digest(b":".join((HA1, challenge.nonce, cnonce)))
-
-        qop = self._resolve_qop(challenge.qop, request=request)
-        if qop is None:
-            # Following RFC 2069
-            digest_data = [HA1, challenge.nonce, HA2]
-        else:
-            # Following RFC 2617/7616
-            digest_data = [HA1, challenge.nonce, nc_value, cnonce, qop, HA2]
-
-        format_args = {
-            "username": self._username,
-            "realm": challenge.realm,
-            "nonce": challenge.nonce,
-            "uri": path,
-            "response": digest(b":".join(digest_data)),
-            "algorithm": challenge.algorithm.encode(),
-        }
-        if challenge.opaque:
-            format_args["opaque"] = challenge.opaque
-        if qop:
-            format_args["qop"] = b"auth"
-            format_args["nc"] = nc_value
-            format_args["cnonce"] = cnonce
-
-        return "Digest " + self._get_header_value(format_args)
-
-    def _get_client_nonce(self, nonce_count: int, nonce: bytes) -> bytes:
-        s = str(nonce_count).encode()
-        s += nonce
-        s += time.ctime().encode()
-        s += os.urandom(8)
-
-        return hashlib.sha1(s).hexdigest()[:16].encode()
-
-    def _get_header_value(self, header_fields: dict[str, bytes]) -> str:
-        NON_QUOTED_FIELDS = ("algorithm", "qop", "nc")
-        QUOTED_TEMPLATE = '{}="{}"'
-        NON_QUOTED_TEMPLATE = "{}={}"
-
-        header_value = ""
-        for i, (field, value) in enumerate(header_fields.items()):
-            if i > 0:
-                header_value += ", "
-            template = (
-                QUOTED_TEMPLATE
-                if field not in NON_QUOTED_FIELDS
-                else NON_QUOTED_TEMPLATE
-            )
-            header_value += template.format(field, to_str(value))
-
-        return header_value
-
-    def _resolve_qop(self, qop: bytes | None, request: Request) -> bytes | None:
-        if qop is None:
-            return None
-        qops = re.split(b", ?", qop)
-        if b"auth" in qops:
-            return b"auth"
-
-        if qops == [b"auth-int"]:
-            raise NotImplementedError("Digest auth-int support is not yet implemented")
-
-        message = f'Unexpected qop value "{qop!r}" in digest auth'
-        raise ProtocolError(message, request=request)
-
-
-class _DigestAuthChallenge(typing.NamedTuple):
-    realm: bytes
-    nonce: bytes
-    algorithm: str
-    opaque: bytes | None
-    qop: bytes | None

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_client.py

@@ -1,2019 +0,0 @@
-from __future__ import annotations
-
-import datetime
-import enum
-import logging
-import time
-import typing
-import warnings
-from contextlib import asynccontextmanager, contextmanager
-from types import TracebackType
-
-from .__version__ import __version__
-from ._auth import Auth, BasicAuth, FunctionAuth
-from ._config import (
-    DEFAULT_LIMITS,
-    DEFAULT_MAX_REDIRECTS,
-    DEFAULT_TIMEOUT_CONFIG,
-    Limits,
-    Proxy,
-    Timeout,
-)
-from ._decoders import SUPPORTED_DECODERS
-from ._exceptions import (
-    InvalidURL,
-    RemoteProtocolError,
-    TooManyRedirects,
-    request_context,
-)
-from ._models import Cookies, Headers, Request, Response
-from ._status_codes import codes
-from ._transports.base import AsyncBaseTransport, BaseTransport
-from ._transports.default import AsyncHTTPTransport, HTTPTransport
-from ._types import (
-    AsyncByteStream,
-    AuthTypes,
-    CertTypes,
-    CookieTypes,
-    HeaderTypes,
-    ProxyTypes,
-    QueryParamTypes,
-    RequestContent,
-    RequestData,
-    RequestExtensions,
-    RequestFiles,
-    SyncByteStream,
-    TimeoutTypes,
-)
-from ._urls import URL, QueryParams
-from ._utils import URLPattern, get_environment_proxies
-
-if typing.TYPE_CHECKING:
-    import ssl  # pragma: no cover
-
-__all__ = ["USE_CLIENT_DEFAULT", "AsyncClient", "Client"]
-
-# The type annotation for @classmethod and context managers here follows PEP 484
-# https://www.python.org/dev/peps/pep-0484/#annotating-instance-and-class-methods
-T = typing.TypeVar("T", bound="Client")
-U = typing.TypeVar("U", bound="AsyncClient")
-
-
-def _is_https_redirect(url: URL, location: URL) -> bool:
-    """
-    Return 'True' if 'location' is a HTTPS upgrade of 'url'
-    """
-    if url.host != location.host:
-        return False
-
-    return (
-        url.scheme == "http"
-        and _port_or_default(url) == 80
-        and location.scheme == "https"
-        and _port_or_default(location) == 443
-    )
-
-
-def _port_or_default(url: URL) -> int | None:
-    if url.port is not None:
-        return url.port
-    return {"http": 80, "https": 443}.get(url.scheme)
-
-
-def _same_origin(url: URL, other: URL) -> bool:
-    """
-    Return 'True' if the given URLs share the same origin.
-    """
-    return (
-        url.scheme == other.scheme
-        and url.host == other.host
-        and _port_or_default(url) == _port_or_default(other)
-    )
-
-
-class UseClientDefault:
-    """
-    For some parameters such as `auth=...` and `timeout=...` we need to be able
-    to indicate the default "unset" state, in a way that is distinctly different
-    to using `None`.
-
-    The default "unset" state indicates that whatever default is set on the
-    client should be used. This is different to setting `None`, which
-    explicitly disables the parameter, possibly overriding a client default.
-
-    For example we use `timeout=USE_CLIENT_DEFAULT` in the `request()` signature.
-    Omitting the `timeout` parameter will send a request using whatever default
-    timeout has been configured on the client. Including `timeout=None` will
-    ensure no timeout is used.
-
-    Note that user code shouldn't need to use the `USE_CLIENT_DEFAULT` constant,
-    but it is used internally when a parameter is not included.
-    """
-
-
-USE_CLIENT_DEFAULT = UseClientDefault()
-
-
-logger = logging.getLogger("httpx")
-
-USER_AGENT = f"python-httpx/{__version__}"
-ACCEPT_ENCODING = ", ".join(
-    [key for key in SUPPORTED_DECODERS.keys() if key != "identity"]
-)
-
-
-class ClientState(enum.Enum):
-    # UNOPENED:
-    #   The client has been instantiated, but has not been used to send a request,
-    #   or been opened by entering the context of a `with` block.
-    UNOPENED = 1
-    # OPENED:
-    #   The client has either sent a request, or is within a `with` block.
-    OPENED = 2
-    # CLOSED:
-    #   The client has either exited the `with` block, or `close()` has
-    #   been called explicitly.
-    CLOSED = 3
-
-
-class BoundSyncStream(SyncByteStream):
-    """
-    A byte stream that is bound to a given response instance, and that
-    ensures the `response.elapsed` is set once the response is closed.
-    """
-
-    def __init__(
-        self, stream: SyncByteStream, response: Response, start: float
-    ) -> None:
-        self._stream = stream
-        self._response = response
-        self._start = start
-
-    def __iter__(self) -> typing.Iterator[bytes]:
-        for chunk in self._stream:
-            yield chunk
-
-    def close(self) -> None:
-        elapsed = time.perf_counter() - self._start
-        self._response.elapsed = datetime.timedelta(seconds=elapsed)
-        self._stream.close()
-
-
-class BoundAsyncStream(AsyncByteStream):
-    """
-    An async byte stream that is bound to a given response instance, and that
-    ensures the `response.elapsed` is set once the response is closed.
-    """
-
-    def __init__(
-        self, stream: AsyncByteStream, response: Response, start: float
-    ) -> None:
-        self._stream = stream
-        self._response = response
-        self._start = start
-
-    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
-        async for chunk in self._stream:
-            yield chunk
-
-    async def aclose(self) -> None:
-        elapsed = time.perf_counter() - self._start
-        self._response.elapsed = datetime.timedelta(seconds=elapsed)
-        await self._stream.aclose()
-
-
-EventHook = typing.Callable[..., typing.Any]
-
-
-class BaseClient:
-    def __init__(
-        self,
-        *,
-        auth: AuthTypes | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-        follow_redirects: bool = False,
-        max_redirects: int = DEFAULT_MAX_REDIRECTS,
-        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
-        base_url: URL | str = "",
-        trust_env: bool = True,
-        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
-    ) -> None:
-        event_hooks = {} if event_hooks is None else event_hooks
-
-        self._base_url = self._enforce_trailing_slash(URL(base_url))
-
-        self._auth = self._build_auth(auth)
-        self._params = QueryParams(params)
-        self.headers = Headers(headers)
-        self._cookies = Cookies(cookies)
-        self._timeout = Timeout(timeout)
-        self.follow_redirects = follow_redirects
-        self.max_redirects = max_redirects
-        self._event_hooks = {
-            "request": list(event_hooks.get("request", [])),
-            "response": list(event_hooks.get("response", [])),
-        }
-        self._trust_env = trust_env
-        self._default_encoding = default_encoding
-        self._state = ClientState.UNOPENED
-
-    @property
-    def is_closed(self) -> bool:
-        """
-        Check if the client being closed
-        """
-        return self._state == ClientState.CLOSED
-
-    @property
-    def trust_env(self) -> bool:
-        return self._trust_env
-
-    def _enforce_trailing_slash(self, url: URL) -> URL:
-        if url.raw_path.endswith(b"/"):
-            return url
-        return url.copy_with(raw_path=url.raw_path + b"/")
-
-    def _get_proxy_map(
-        self, proxy: ProxyTypes | None, allow_env_proxies: bool
-    ) -> dict[str, Proxy | None]:
-        if proxy is None:
-            if allow_env_proxies:
-                return {
-                    key: None if url is None else Proxy(url=url)
-                    for key, url in get_environment_proxies().items()
-                }
-            return {}
-        else:
-            proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
-            return {"all://": proxy}
-
-    @property
-    def timeout(self) -> Timeout:
-        return self._timeout
-
-    @timeout.setter
-    def timeout(self, timeout: TimeoutTypes) -> None:
-        self._timeout = Timeout(timeout)
-
-    @property
-    def event_hooks(self) -> dict[str, list[EventHook]]:
-        return self._event_hooks
-
-    @event_hooks.setter
-    def event_hooks(self, event_hooks: dict[str, list[EventHook]]) -> None:
-        self._event_hooks = {
-            "request": list(event_hooks.get("request", [])),
-            "response": list(event_hooks.get("response", [])),
-        }
-
-    @property
-    def auth(self) -> Auth | None:
-        """
-        Authentication class used when none is passed at the request-level.
-
-        See also [Authentication][0].
-
-        [0]: /quickstart/#authentication
-        """
-        return self._auth
-
-    @auth.setter
-    def auth(self, auth: AuthTypes) -> None:
-        self._auth = self._build_auth(auth)
-
-    @property
-    def base_url(self) -> URL:
-        """
-        Base URL to use when sending requests with relative URLs.
-        """
-        return self._base_url
-
-    @base_url.setter
-    def base_url(self, url: URL | str) -> None:
-        self._base_url = self._enforce_trailing_slash(URL(url))
-
-    @property
-    def headers(self) -> Headers:
-        """
-        HTTP headers to include when sending requests.
-        """
-        return self._headers
-
-    @headers.setter
-    def headers(self, headers: HeaderTypes) -> None:
-        client_headers = Headers(
-            {
-                b"Accept": b"*/*",
-                b"Accept-Encoding": ACCEPT_ENCODING.encode("ascii"),
-                b"Connection": b"keep-alive",
-                b"User-Agent": USER_AGENT.encode("ascii"),
-            }
-        )
-        client_headers.update(headers)
-        self._headers = client_headers
-
-    @property
-    def cookies(self) -> Cookies:
-        """
-        Cookie values to include when sending requests.
-        """
-        return self._cookies
-
-    @cookies.setter
-    def cookies(self, cookies: CookieTypes) -> None:
-        self._cookies = Cookies(cookies)
-
-    @property
-    def params(self) -> QueryParams:
-        """
-        Query parameters to include in the URL when sending requests.
-        """
-        return self._params
-
-    @params.setter
-    def params(self, params: QueryParamTypes) -> None:
-        self._params = QueryParams(params)
-
-    def build_request(
-        self,
-        method: str,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Request:
-        """
-        Build and return a request instance.
-
-        * The `params`, `headers` and `cookies` arguments
-        are merged with any values set on the client.
-        * The `url` argument is merged with any `base_url` set on the client.
-
-        See also: [Request instances][0]
-
-        [0]: /advanced/clients/#request-instances
-        """
-        url = self._merge_url(url)
-        headers = self._merge_headers(headers)
-        cookies = self._merge_cookies(cookies)
-        params = self._merge_queryparams(params)
-        extensions = {} if extensions is None else extensions
-        if "timeout" not in extensions:
-            timeout = (
-                self.timeout
-                if isinstance(timeout, UseClientDefault)
-                else Timeout(timeout)
-            )
-            extensions = dict(**extensions, timeout=timeout.as_dict())
-        return Request(
-            method,
-            url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            extensions=extensions,
-        )
-
-    def _merge_url(self, url: URL | str) -> URL:
-        """
-        Merge a URL argument together with any 'base_url' on the client,
-        to create the URL used for the outgoing request.
-        """
-        merge_url = URL(url)
-        if merge_url.is_relative_url:
-            # To merge URLs we always append to the base URL. To get this
-            # behaviour correct we always ensure the base URL ends in a '/'
-            # separator, and strip any leading '/' from the merge URL.
-            #
-            # So, eg...
-            #
-            # >>> client = Client(base_url="https://www.example.com/subpath")
-            # >>> client.base_url
-            # URL('https://www.example.com/subpath/')
-            # >>> client.build_request("GET", "/path").url
-            # URL('https://www.example.com/subpath/path')
-            merge_raw_path = self.base_url.raw_path + merge_url.raw_path.lstrip(b"/")
-            return self.base_url.copy_with(raw_path=merge_raw_path)
-        return merge_url
-
-    def _merge_cookies(self, cookies: CookieTypes | None = None) -> CookieTypes | None:
-        """
-        Merge a cookies argument together with any cookies on the client,
-        to create the cookies used for the outgoing request.
-        """
-        if cookies or self.cookies:
-            merged_cookies = Cookies(self.cookies)
-            merged_cookies.update(cookies)
-            return merged_cookies
-        return cookies
-
-    def _merge_headers(self, headers: HeaderTypes | None = None) -> HeaderTypes | None:
-        """
-        Merge a headers argument together with any headers on the client,
-        to create the headers used for the outgoing request.
-        """
-        merged_headers = Headers(self.headers)
-        merged_headers.update(headers)
-        return merged_headers
-
-    def _merge_queryparams(
-        self, params: QueryParamTypes | None = None
-    ) -> QueryParamTypes | None:
-        """
-        Merge a queryparams argument together with any queryparams on the client,
-        to create the queryparams used for the outgoing request.
-        """
-        if params or self.params:
-            merged_queryparams = QueryParams(self.params)
-            return merged_queryparams.merge(params)
-        return params
-
-    def _build_auth(self, auth: AuthTypes | None) -> Auth | None:
-        if auth is None:
-            return None
-        elif isinstance(auth, tuple):
-            return BasicAuth(username=auth[0], password=auth[1])
-        elif isinstance(auth, Auth):
-            return auth
-        elif callable(auth):
-            return FunctionAuth(func=auth)
-        else:
-            raise TypeError(f'Invalid "auth" argument: {auth!r}')
-
-    def _build_request_auth(
-        self,
-        request: Request,
-        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
-    ) -> Auth:
-        auth = (
-            self._auth if isinstance(auth, UseClientDefault) else self._build_auth(auth)
-        )
-
-        if auth is not None:
-            return auth
-
-        username, password = request.url.username, request.url.password
-        if username or password:
-            return BasicAuth(username=username, password=password)
-
-        return Auth()
-
-    def _build_redirect_request(self, request: Request, response: Response) -> Request:
-        """
-        Given a request and a redirect response, return a new request that
-        should be used to effect the redirect.
-        """
-        method = self._redirect_method(request, response)
-        url = self._redirect_url(request, response)
-        headers = self._redirect_headers(request, url, method)
-        stream = self._redirect_stream(request, method)
-        cookies = Cookies(self.cookies)
-        return Request(
-            method=method,
-            url=url,
-            headers=headers,
-            cookies=cookies,
-            stream=stream,
-            extensions=request.extensions,
-        )
-
-    def _redirect_method(self, request: Request, response: Response) -> str:
-        """
-        When being redirected we may want to change the method of the request
-        based on certain specs or browser behavior.
-        """
-        method = request.method
-
-        # https://tools.ietf.org/html/rfc7231#section-6.4.4
-        if response.status_code == codes.SEE_OTHER and method != "HEAD":
-            method = "GET"
-
-        # Do what the browsers do, despite standards...
-        # Turn 302s into GETs.
-        if response.status_code == codes.FOUND and method != "HEAD":
-            method = "GET"
-
-        # If a POST is responded to with a 301, turn it into a GET.
-        # This bizarre behaviour is explained in 'requests' issue 1704.
-        if response.status_code == codes.MOVED_PERMANENTLY and method == "POST":
-            method = "GET"
-
-        return method
-
-    def _redirect_url(self, request: Request, response: Response) -> URL:
-        """
-        Return the URL for the redirect to follow.
-        """
-        location = response.headers["Location"]
-
-        try:
-            url = URL(location)
-        except InvalidURL as exc:
-            raise RemoteProtocolError(
-                f"Invalid URL in location header: {exc}.", request=request
-            ) from None
-
-        # Handle malformed 'Location' headers that are "absolute" form, have no host.
-        # See: https://github.com/encode/httpx/issues/771
-        if url.scheme and not url.host:
-            url = url.copy_with(host=request.url.host)
-
-        # Facilitate relative 'Location' headers, as allowed by RFC 7231.
-        # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
-        if url.is_relative_url:
-            url = request.url.join(url)
-
-        # Attach previous fragment if needed (RFC 7231 7.1.2)
-        if request.url.fragment and not url.fragment:
-            url = url.copy_with(fragment=request.url.fragment)
-
-        return url
-
-    def _redirect_headers(self, request: Request, url: URL, method: str) -> Headers:
-        """
-        Return the headers that should be used for the redirect request.
-        """
-        headers = Headers(request.headers)
-
-        if not _same_origin(url, request.url):
-            if not _is_https_redirect(request.url, url):
-                # Strip Authorization headers when responses are redirected
-                # away from the origin. (Except for direct HTTP to HTTPS redirects.)
-                headers.pop("Authorization", None)
-
-            # Update the Host header.
-            headers["Host"] = url.netloc.decode("ascii")
-
-        if method != request.method and method == "GET":
-            # If we've switch to a 'GET' request, then strip any headers which
-            # are only relevant to the request body.
-            headers.pop("Content-Length", None)
-            headers.pop("Transfer-Encoding", None)
-
-        # We should use the client cookie store to determine any cookie header,
-        # rather than whatever was on the original outgoing request.
-        headers.pop("Cookie", None)
-
-        return headers
-
-    def _redirect_stream(
-        self, request: Request, method: str
-    ) -> SyncByteStream | AsyncByteStream | None:
-        """
-        Return the body that should be used for the redirect request.
-        """
-        if method != request.method and method == "GET":
-            return None
-
-        return request.stream
-
-    def _set_timeout(self, request: Request) -> None:
-        if "timeout" not in request.extensions:
-            timeout = (
-                self.timeout
-                if isinstance(self.timeout, UseClientDefault)
-                else Timeout(self.timeout)
-            )
-            request.extensions = dict(**request.extensions, timeout=timeout.as_dict())
-
-
-class Client(BaseClient):
-    """
-    An HTTP client, with connection pooling, HTTP/2, redirects, cookie persistence, etc.
-
-    It can be shared between threads.
-
-    Usage:
-
-    ```python
-    >>> client = httpx.Client()
-    >>> response = client.get('https://example.org')
-    ```
-
-    **Parameters:**
-
-    * **auth** - *(optional)* An authentication class to use when sending
-    requests.
-    * **params** - *(optional)* Query parameters to include in request URLs, as
-    a string, dictionary, or sequence of two-tuples.
-    * **headers** - *(optional)* Dictionary of HTTP headers to include when
-    sending requests.
-    * **cookies** - *(optional)* Dictionary of Cookie items to include when
-    sending requests.
-    * **verify** - *(optional)* Either `True` to use an SSL context with the
-    default CA bundle, `False` to disable verification, or an instance of
-    `ssl.SSLContext` to use a custom context.
-    * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
-    enabled. Defaults to `False`.
-    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
-    * **timeout** - *(optional)* The timeout configuration to use when sending
-    requests.
-    * **limits** - *(optional)* The limits configuration to use.
-    * **max_redirects** - *(optional)* The maximum number of redirect responses
-    that should be followed.
-    * **base_url** - *(optional)* A URL to use as the base when building
-    request URLs.
-    * **transport** - *(optional)* A transport class to use for sending requests
-    over the network.
-    * **trust_env** - *(optional)* Enables or disables usage of environment
-    variables for configuration.
-    * **default_encoding** - *(optional)* The default encoding to use for decoding
-    response text, if no charset information is included in a response Content-Type
-    header. Set to a callable for automatic character set detection. Default: "utf-8".
-    """
-
-    def __init__(
-        self,
-        *,
-        auth: AuthTypes | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        verify: ssl.SSLContext | str | bool = True,
-        cert: CertTypes | None = None,
-        trust_env: bool = True,
-        http1: bool = True,
-        http2: bool = False,
-        proxy: ProxyTypes | None = None,
-        mounts: None | (typing.Mapping[str, BaseTransport | None]) = None,
-        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-        follow_redirects: bool = False,
-        limits: Limits = DEFAULT_LIMITS,
-        max_redirects: int = DEFAULT_MAX_REDIRECTS,
-        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
-        base_url: URL | str = "",
-        transport: BaseTransport | None = None,
-        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
-    ) -> None:
-        super().__init__(
-            auth=auth,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            timeout=timeout,
-            follow_redirects=follow_redirects,
-            max_redirects=max_redirects,
-            event_hooks=event_hooks,
-            base_url=base_url,
-            trust_env=trust_env,
-            default_encoding=default_encoding,
-        )
-
-        if http2:
-            try:
-                import h2  # noqa
-            except ImportError:  # pragma: no cover
-                raise ImportError(
-                    "Using http2=True, but the 'h2' package is not installed. "
-                    "Make sure to install httpx using `pip install httpx[http2]`."
-                ) from None
-
-        allow_env_proxies = trust_env and transport is None
-        proxy_map = self._get_proxy_map(proxy, allow_env_proxies)
-
-        self._transport = self._init_transport(
-            verify=verify,
-            cert=cert,
-            trust_env=trust_env,
-            http1=http1,
-            http2=http2,
-            limits=limits,
-            transport=transport,
-        )
-        self._mounts: dict[URLPattern, BaseTransport | None] = {
-            URLPattern(key): None
-            if proxy is None
-            else self._init_proxy_transport(
-                proxy,
-                verify=verify,
-                cert=cert,
-                trust_env=trust_env,
-                http1=http1,
-                http2=http2,
-                limits=limits,
-            )
-            for key, proxy in proxy_map.items()
-        }
-        if mounts is not None:
-            self._mounts.update(
-                {URLPattern(key): transport for key, transport in mounts.items()}
-            )
-
-        self._mounts = dict(sorted(self._mounts.items()))
-
-    def _init_transport(
-        self,
-        verify: ssl.SSLContext | str | bool = True,
-        cert: CertTypes | None = None,
-        trust_env: bool = True,
-        http1: bool = True,
-        http2: bool = False,
-        limits: Limits = DEFAULT_LIMITS,
-        transport: BaseTransport | None = None,
-    ) -> BaseTransport:
-        if transport is not None:
-            return transport
-
-        return HTTPTransport(
-            verify=verify,
-            cert=cert,
-            trust_env=trust_env,
-            http1=http1,
-            http2=http2,
-            limits=limits,
-        )
-
-    def _init_proxy_transport(
-        self,
-        proxy: Proxy,
-        verify: ssl.SSLContext | str | bool = True,
-        cert: CertTypes | None = None,
-        trust_env: bool = True,
-        http1: bool = True,
-        http2: bool = False,
-        limits: Limits = DEFAULT_LIMITS,
-    ) -> BaseTransport:
-        return HTTPTransport(
-            verify=verify,
-            cert=cert,
-            trust_env=trust_env,
-            http1=http1,
-            http2=http2,
-            limits=limits,
-            proxy=proxy,
-        )
-
-    def _transport_for_url(self, url: URL) -> BaseTransport:
-        """
-        Returns the transport instance that should be used for a given URL.
-        This will either be the standard connection pool, or a proxy.
-        """
-        for pattern, transport in self._mounts.items():
-            if pattern.matches(url):
-                return self._transport if transport is None else transport
-
-        return self._transport
-
-    def request(
-        self,
-        method: str,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Build and send a request.
-
-        Equivalent to:
-
-        ```python
-        request = client.build_request(...)
-        response = client.send(request, ...)
-        ```
-
-        See `Client.build_request()`, `Client.send()` and
-        [Merging of configuration][0] for how the various parameters
-        are merged with client-level configuration.
-
-        [0]: /advanced/clients/#merging-of-configuration
-        """
-        if cookies is not None:
-            message = (
-                "Setting per-request cookies=<...> is being deprecated, because "
-                "the expected behaviour on cookie persistence is ambiguous. Set "
-                "cookies directly on the client instance instead."
-            )
-            warnings.warn(message, DeprecationWarning, stacklevel=2)
-
-        request = self.build_request(
-            method=method,
-            url=url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            timeout=timeout,
-            extensions=extensions,
-        )
-        return self.send(request, auth=auth, follow_redirects=follow_redirects)
-
-    @contextmanager
-    def stream(
-        self,
-        method: str,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> typing.Iterator[Response]:
-        """
-        Alternative to `httpx.request()` that streams the response body
-        instead of loading it into memory at once.
-
-        **Parameters**: See `httpx.request`.
-
-        See also: [Streaming Responses][0]
-
-        [0]: /quickstart#streaming-responses
-        """
-        request = self.build_request(
-            method=method,
-            url=url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            timeout=timeout,
-            extensions=extensions,
-        )
-        response = self.send(
-            request=request,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            stream=True,
-        )
-        try:
-            yield response
-        finally:
-            response.close()
-
-    def send(
-        self,
-        request: Request,
-        *,
-        stream: bool = False,
-        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-    ) -> Response:
-        """
-        Send a request.
-
-        The request is sent as-is, unmodified.
-
-        Typically you'll want to build one with `Client.build_request()`
-        so that any client-level configuration is merged into the request,
-        but passing an explicit `httpx.Request()` is supported as well.
-
-        See also: [Request instances][0]
-
-        [0]: /advanced/clients/#request-instances
-        """
-        if self._state == ClientState.CLOSED:
-            raise RuntimeError("Cannot send a request, as the client has been closed.")
-
-        self._state = ClientState.OPENED
-        follow_redirects = (
-            self.follow_redirects
-            if isinstance(follow_redirects, UseClientDefault)
-            else follow_redirects
-        )
-
-        self._set_timeout(request)
-
-        auth = self._build_request_auth(request, auth)
-
-        response = self._send_handling_auth(
-            request,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            history=[],
-        )
-        try:
-            if not stream:
-                response.read()
-
-            return response
-
-        except BaseException as exc:
-            response.close()
-            raise exc
-
-    def _send_handling_auth(
-        self,
-        request: Request,
-        auth: Auth,
-        follow_redirects: bool,
-        history: list[Response],
-    ) -> Response:
-        auth_flow = auth.sync_auth_flow(request)
-        try:
-            request = next(auth_flow)
-
-            while True:
-                response = self._send_handling_redirects(
-                    request,
-                    follow_redirects=follow_redirects,
-                    history=history,
-                )
-                try:
-                    try:
-                        next_request = auth_flow.send(response)
-                    except StopIteration:
-                        return response
-
-                    response.history = list(history)
-                    response.read()
-                    request = next_request
-                    history.append(response)
-
-                except BaseException as exc:
-                    response.close()
-                    raise exc
-        finally:
-            auth_flow.close()
-
-    def _send_handling_redirects(
-        self,
-        request: Request,
-        follow_redirects: bool,
-        history: list[Response],
-    ) -> Response:
-        while True:
-            if len(history) > self.max_redirects:
-                raise TooManyRedirects(
-                    "Exceeded maximum allowed redirects.", request=request
-                )
-
-            for hook in self._event_hooks["request"]:
-                hook(request)
-
-            response = self._send_single_request(request)
-            try:
-                for hook in self._event_hooks["response"]:
-                    hook(response)
-                response.history = list(history)
-
-                if not response.has_redirect_location:
-                    return response
-
-                request = self._build_redirect_request(request, response)
-                history = history + [response]
-
-                if follow_redirects:
-                    response.read()
-                else:
-                    response.next_request = request
-                    return response
-
-            except BaseException as exc:
-                response.close()
-                raise exc
-
-    def _send_single_request(self, request: Request) -> Response:
-        """
-        Sends a single request, without handling any redirections.
-        """
-        transport = self._transport_for_url(request.url)
-        start = time.perf_counter()
-
-        if not isinstance(request.stream, SyncByteStream):
-            raise RuntimeError(
-                "Attempted to send an async request with a sync Client instance."
-            )
-
-        with request_context(request=request):
-            response = transport.handle_request(request)
-
-        assert isinstance(response.stream, SyncByteStream)
-
-        response.request = request
-        response.stream = BoundSyncStream(
-            response.stream, response=response, start=start
-        )
-        self.cookies.extract_cookies(response)
-        response.default_encoding = self._default_encoding
-
-        logger.info(
-            'HTTP Request: %s %s "%s %d %s"',
-            request.method,
-            request.url,
-            response.http_version,
-            response.status_code,
-            response.reason_phrase,
-        )
-
-        return response
-
-    def get(
-        self,
-        url: URL | str,
-        *,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `GET` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return self.request(
-            "GET",
-            url,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    def options(
-        self,
-        url: URL | str,
-        *,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send an `OPTIONS` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return self.request(
-            "OPTIONS",
-            url,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    def head(
-        self,
-        url: URL | str,
-        *,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `HEAD` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return self.request(
-            "HEAD",
-            url,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    def post(
-        self,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `POST` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return self.request(
-            "POST",
-            url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    def put(
-        self,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `PUT` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return self.request(
-            "PUT",
-            url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    def patch(
-        self,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `PATCH` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return self.request(
-            "PATCH",
-            url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    def delete(
-        self,
-        url: URL | str,
-        *,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `DELETE` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return self.request(
-            "DELETE",
-            url,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    def close(self) -> None:
-        """
-        Close transport and proxies.
-        """
-        if self._state != ClientState.CLOSED:
-            self._state = ClientState.CLOSED
-
-            self._transport.close()
-            for transport in self._mounts.values():
-                if transport is not None:
-                    transport.close()
-
-    def __enter__(self: T) -> T:
-        if self._state != ClientState.UNOPENED:
-            msg = {
-                ClientState.OPENED: "Cannot open a client instance more than once.",
-                ClientState.CLOSED: (
-                    "Cannot reopen a client instance, once it has been closed."
-                ),
-            }[self._state]
-            raise RuntimeError(msg)
-
-        self._state = ClientState.OPENED
-
-        self._transport.__enter__()
-        for transport in self._mounts.values():
-            if transport is not None:
-                transport.__enter__()
-        return self
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None = None,
-        exc_value: BaseException | None = None,
-        traceback: TracebackType | None = None,
-    ) -> None:
-        self._state = ClientState.CLOSED
-
-        self._transport.__exit__(exc_type, exc_value, traceback)
-        for transport in self._mounts.values():
-            if transport is not None:
-                transport.__exit__(exc_type, exc_value, traceback)
-
-
-class AsyncClient(BaseClient):
-    """
-    An asynchronous HTTP client, with connection pooling, HTTP/2, redirects,
-    cookie persistence, etc.
-
-    It can be shared between tasks.
-
-    Usage:
-
-    ```python
-    >>> async with httpx.AsyncClient() as client:
-    >>>     response = await client.get('https://example.org')
-    ```
-
-    **Parameters:**
-
-    * **auth** - *(optional)* An authentication class to use when sending
-    requests.
-    * **params** - *(optional)* Query parameters to include in request URLs, as
-    a string, dictionary, or sequence of two-tuples.
-    * **headers** - *(optional)* Dictionary of HTTP headers to include when
-    sending requests.
-    * **cookies** - *(optional)* Dictionary of Cookie items to include when
-    sending requests.
-    * **verify** - *(optional)* Either `True` to use an SSL context with the
-    default CA bundle, `False` to disable verification, or an instance of
-    `ssl.SSLContext` to use a custom context.
-    * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
-    enabled. Defaults to `False`.
-    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
-    * **timeout** - *(optional)* The timeout configuration to use when sending
-    requests.
-    * **limits** - *(optional)* The limits configuration to use.
-    * **max_redirects** - *(optional)* The maximum number of redirect responses
-    that should be followed.
-    * **base_url** - *(optional)* A URL to use as the base when building
-    request URLs.
-    * **transport** - *(optional)* A transport class to use for sending requests
-    over the network.
-    * **trust_env** - *(optional)* Enables or disables usage of environment
-    variables for configuration.
-    * **default_encoding** - *(optional)* The default encoding to use for decoding
-    response text, if no charset information is included in a response Content-Type
-    header. Set to a callable for automatic character set detection. Default: "utf-8".
-    """
-
-    def __init__(
-        self,
-        *,
-        auth: AuthTypes | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        verify: ssl.SSLContext | str | bool = True,
-        cert: CertTypes | None = None,
-        http1: bool = True,
-        http2: bool = False,
-        proxy: ProxyTypes | None = None,
-        mounts: None | (typing.Mapping[str, AsyncBaseTransport | None]) = None,
-        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
-        follow_redirects: bool = False,
-        limits: Limits = DEFAULT_LIMITS,
-        max_redirects: int = DEFAULT_MAX_REDIRECTS,
-        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
-        base_url: URL | str = "",
-        transport: AsyncBaseTransport | None = None,
-        trust_env: bool = True,
-        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
-    ) -> None:
-        super().__init__(
-            auth=auth,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            timeout=timeout,
-            follow_redirects=follow_redirects,
-            max_redirects=max_redirects,
-            event_hooks=event_hooks,
-            base_url=base_url,
-            trust_env=trust_env,
-            default_encoding=default_encoding,
-        )
-
-        if http2:
-            try:
-                import h2  # noqa
-            except ImportError:  # pragma: no cover
-                raise ImportError(
-                    "Using http2=True, but the 'h2' package is not installed. "
-                    "Make sure to install httpx using `pip install httpx[http2]`."
-                ) from None
-
-        allow_env_proxies = trust_env and transport is None
-        proxy_map = self._get_proxy_map(proxy, allow_env_proxies)
-
-        self._transport = self._init_transport(
-            verify=verify,
-            cert=cert,
-            trust_env=trust_env,
-            http1=http1,
-            http2=http2,
-            limits=limits,
-            transport=transport,
-        )
-
-        self._mounts: dict[URLPattern, AsyncBaseTransport | None] = {
-            URLPattern(key): None
-            if proxy is None
-            else self._init_proxy_transport(
-                proxy,
-                verify=verify,
-                cert=cert,
-                trust_env=trust_env,
-                http1=http1,
-                http2=http2,
-                limits=limits,
-            )
-            for key, proxy in proxy_map.items()
-        }
-        if mounts is not None:
-            self._mounts.update(
-                {URLPattern(key): transport for key, transport in mounts.items()}
-            )
-        self._mounts = dict(sorted(self._mounts.items()))
-
-    def _init_transport(
-        self,
-        verify: ssl.SSLContext | str | bool = True,
-        cert: CertTypes | None = None,
-        trust_env: bool = True,
-        http1: bool = True,
-        http2: bool = False,
-        limits: Limits = DEFAULT_LIMITS,
-        transport: AsyncBaseTransport | None = None,
-    ) -> AsyncBaseTransport:
-        if transport is not None:
-            return transport
-
-        return AsyncHTTPTransport(
-            verify=verify,
-            cert=cert,
-            trust_env=trust_env,
-            http1=http1,
-            http2=http2,
-            limits=limits,
-        )
-
-    def _init_proxy_transport(
-        self,
-        proxy: Proxy,
-        verify: ssl.SSLContext | str | bool = True,
-        cert: CertTypes | None = None,
-        trust_env: bool = True,
-        http1: bool = True,
-        http2: bool = False,
-        limits: Limits = DEFAULT_LIMITS,
-    ) -> AsyncBaseTransport:
-        return AsyncHTTPTransport(
-            verify=verify,
-            cert=cert,
-            trust_env=trust_env,
-            http1=http1,
-            http2=http2,
-            limits=limits,
-            proxy=proxy,
-        )
-
-    def _transport_for_url(self, url: URL) -> AsyncBaseTransport:
-        """
-        Returns the transport instance that should be used for a given URL.
-        This will either be the standard connection pool, or a proxy.
-        """
-        for pattern, transport in self._mounts.items():
-            if pattern.matches(url):
-                return self._transport if transport is None else transport
-
-        return self._transport
-
-    async def request(
-        self,
-        method: str,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Build and send a request.
-
-        Equivalent to:
-
-        ```python
-        request = client.build_request(...)
-        response = await client.send(request, ...)
-        ```
-
-        See `AsyncClient.build_request()`, `AsyncClient.send()`
-        and [Merging of configuration][0] for how the various parameters
-        are merged with client-level configuration.
-
-        [0]: /advanced/clients/#merging-of-configuration
-        """
-
-        if cookies is not None:  # pragma: no cover
-            message = (
-                "Setting per-request cookies=<...> is being deprecated, because "
-                "the expected behaviour on cookie persistence is ambiguous. Set "
-                "cookies directly on the client instance instead."
-            )
-            warnings.warn(message, DeprecationWarning, stacklevel=2)
-
-        request = self.build_request(
-            method=method,
-            url=url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            timeout=timeout,
-            extensions=extensions,
-        )
-        return await self.send(request, auth=auth, follow_redirects=follow_redirects)
-
-    @asynccontextmanager
-    async def stream(
-        self,
-        method: str,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> typing.AsyncIterator[Response]:
-        """
-        Alternative to `httpx.request()` that streams the response body
-        instead of loading it into memory at once.
-
-        **Parameters**: See `httpx.request`.
-
-        See also: [Streaming Responses][0]
-
-        [0]: /quickstart#streaming-responses
-        """
-        request = self.build_request(
-            method=method,
-            url=url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            timeout=timeout,
-            extensions=extensions,
-        )
-        response = await self.send(
-            request=request,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            stream=True,
-        )
-        try:
-            yield response
-        finally:
-            await response.aclose()
-
-    async def send(
-        self,
-        request: Request,
-        *,
-        stream: bool = False,
-        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-    ) -> Response:
-        """
-        Send a request.
-
-        The request is sent as-is, unmodified.
-
-        Typically you'll want to build one with `AsyncClient.build_request()`
-        so that any client-level configuration is merged into the request,
-        but passing an explicit `httpx.Request()` is supported as well.
-
-        See also: [Request instances][0]
-
-        [0]: /advanced/clients/#request-instances
-        """
-        if self._state == ClientState.CLOSED:
-            raise RuntimeError("Cannot send a request, as the client has been closed.")
-
-        self._state = ClientState.OPENED
-        follow_redirects = (
-            self.follow_redirects
-            if isinstance(follow_redirects, UseClientDefault)
-            else follow_redirects
-        )
-
-        self._set_timeout(request)
-
-        auth = self._build_request_auth(request, auth)
-
-        response = await self._send_handling_auth(
-            request,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            history=[],
-        )
-        try:
-            if not stream:
-                await response.aread()
-
-            return response
-
-        except BaseException as exc:
-            await response.aclose()
-            raise exc
-
-    async def _send_handling_auth(
-        self,
-        request: Request,
-        auth: Auth,
-        follow_redirects: bool,
-        history: list[Response],
-    ) -> Response:
-        auth_flow = auth.async_auth_flow(request)
-        try:
-            request = await auth_flow.__anext__()
-
-            while True:
-                response = await self._send_handling_redirects(
-                    request,
-                    follow_redirects=follow_redirects,
-                    history=history,
-                )
-                try:
-                    try:
-                        next_request = await auth_flow.asend(response)
-                    except StopAsyncIteration:
-                        return response
-
-                    response.history = list(history)
-                    await response.aread()
-                    request = next_request
-                    history.append(response)
-
-                except BaseException as exc:
-                    await response.aclose()
-                    raise exc
-        finally:
-            await auth_flow.aclose()
-
-    async def _send_handling_redirects(
-        self,
-        request: Request,
-        follow_redirects: bool,
-        history: list[Response],
-    ) -> Response:
-        while True:
-            if len(history) > self.max_redirects:
-                raise TooManyRedirects(
-                    "Exceeded maximum allowed redirects.", request=request
-                )
-
-            for hook in self._event_hooks["request"]:
-                await hook(request)
-
-            response = await self._send_single_request(request)
-            try:
-                for hook in self._event_hooks["response"]:
-                    await hook(response)
-
-                response.history = list(history)
-
-                if not response.has_redirect_location:
-                    return response
-
-                request = self._build_redirect_request(request, response)
-                history = history + [response]
-
-                if follow_redirects:
-                    await response.aread()
-                else:
-                    response.next_request = request
-                    return response
-
-            except BaseException as exc:
-                await response.aclose()
-                raise exc
-
-    async def _send_single_request(self, request: Request) -> Response:
-        """
-        Sends a single request, without handling any redirections.
-        """
-        transport = self._transport_for_url(request.url)
-        start = time.perf_counter()
-
-        if not isinstance(request.stream, AsyncByteStream):
-            raise RuntimeError(
-                "Attempted to send an sync request with an AsyncClient instance."
-            )
-
-        with request_context(request=request):
-            response = await transport.handle_async_request(request)
-
-        assert isinstance(response.stream, AsyncByteStream)
-        response.request = request
-        response.stream = BoundAsyncStream(
-            response.stream, response=response, start=start
-        )
-        self.cookies.extract_cookies(response)
-        response.default_encoding = self._default_encoding
-
-        logger.info(
-            'HTTP Request: %s %s "%s %d %s"',
-            request.method,
-            request.url,
-            response.http_version,
-            response.status_code,
-            response.reason_phrase,
-        )
-
-        return response
-
-    async def get(
-        self,
-        url: URL | str,
-        *,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `GET` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return await self.request(
-            "GET",
-            url,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    async def options(
-        self,
-        url: URL | str,
-        *,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send an `OPTIONS` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return await self.request(
-            "OPTIONS",
-            url,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    async def head(
-        self,
-        url: URL | str,
-        *,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `HEAD` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return await self.request(
-            "HEAD",
-            url,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    async def post(
-        self,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `POST` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return await self.request(
-            "POST",
-            url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    async def put(
-        self,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `PUT` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return await self.request(
-            "PUT",
-            url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    async def patch(
-        self,
-        url: URL | str,
-        *,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `PATCH` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return await self.request(
-            "PATCH",
-            url,
-            content=content,
-            data=data,
-            files=files,
-            json=json,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    async def delete(
-        self,
-        url: URL | str,
-        *,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
-        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
-        extensions: RequestExtensions | None = None,
-    ) -> Response:
-        """
-        Send a `DELETE` request.
-
-        **Parameters**: See `httpx.request`.
-        """
-        return await self.request(
-            "DELETE",
-            url,
-            params=params,
-            headers=headers,
-            cookies=cookies,
-            auth=auth,
-            follow_redirects=follow_redirects,
-            timeout=timeout,
-            extensions=extensions,
-        )
-
-    async def aclose(self) -> None:
-        """
-        Close transport and proxies.
-        """
-        if self._state != ClientState.CLOSED:
-            self._state = ClientState.CLOSED
-
-            await self._transport.aclose()
-            for proxy in self._mounts.values():
-                if proxy is not None:
-                    await proxy.aclose()
-
-    async def __aenter__(self: U) -> U:
-        if self._state != ClientState.UNOPENED:
-            msg = {
-                ClientState.OPENED: "Cannot open a client instance more than once.",
-                ClientState.CLOSED: (
-                    "Cannot reopen a client instance, once it has been closed."
-                ),
-            }[self._state]
-            raise RuntimeError(msg)
-
-        self._state = ClientState.OPENED
-
-        await self._transport.__aenter__()
-        for proxy in self._mounts.values():
-            if proxy is not None:
-                await proxy.__aenter__()
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None = None,
-        exc_value: BaseException | None = None,
-        traceback: TracebackType | None = None,
-    ) -> None:
-        self._state = ClientState.CLOSED
-
-        await self._transport.__aexit__(exc_type, exc_value, traceback)
-        for proxy in self._mounts.values():
-            if proxy is not None:
-                await proxy.__aexit__(exc_type, exc_value, traceback)

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_config.py

@@ -1,248 +0,0 @@
-from __future__ import annotations
-
-import os
-import typing
-
-from ._models import Headers
-from ._types import CertTypes, HeaderTypes, TimeoutTypes
-from ._urls import URL
-
-if typing.TYPE_CHECKING:
-    import ssl  # pragma: no cover
-
-__all__ = ["Limits", "Proxy", "Timeout", "create_ssl_context"]
-
-
-class UnsetType:
-    pass  # pragma: no cover
-
-
-UNSET = UnsetType()
-
-
-def create_ssl_context(
-    verify: ssl.SSLContext | str | bool = True,
-    cert: CertTypes | None = None,
-    trust_env: bool = True,
-) -> ssl.SSLContext:
-    import ssl
-    import warnings
-
-    import certifi
-
-    if verify is True:
-        if trust_env and os.environ.get("SSL_CERT_FILE"):  # pragma: nocover
-            ctx = ssl.create_default_context(cafile=os.environ["SSL_CERT_FILE"])
-        elif trust_env and os.environ.get("SSL_CERT_DIR"):  # pragma: nocover
-            ctx = ssl.create_default_context(capath=os.environ["SSL_CERT_DIR"])
-        else:
-            # Default case...
-            ctx = ssl.create_default_context(cafile=certifi.where())
-    elif verify is False:
-        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
-        ctx.check_hostname = False
-        ctx.verify_mode = ssl.CERT_NONE
-    elif isinstance(verify, str):  # pragma: nocover
-        message = (
-            "`verify=<str>` is deprecated. "
-            "Use `verify=ssl.create_default_context(cafile=...)` "
-            "or `verify=ssl.create_default_context(capath=...)` instead."
-        )
-        warnings.warn(message, DeprecationWarning)
-        if os.path.isdir(verify):
-            return ssl.create_default_context(capath=verify)
-        return ssl.create_default_context(cafile=verify)
-    else:
-        ctx = verify
-
-    if cert:  # pragma: nocover
-        message = (
-            "`cert=...` is deprecated. Use `verify=<ssl_context>` instead,"
-            "with `.load_cert_chain()` to configure the certificate chain."
-        )
-        warnings.warn(message, DeprecationWarning)
-        if isinstance(cert, str):
-            ctx.load_cert_chain(cert)
-        else:
-            ctx.load_cert_chain(*cert)
-
-    return ctx
-
-
-class Timeout:
-    """
-    Timeout configuration.
-
-    **Usage**:
-
-    Timeout(None)               # No timeouts.
-    Timeout(5.0)                # 5s timeout on all operations.
-    Timeout(None, connect=5.0)  # 5s timeout on connect, no other timeouts.
-    Timeout(5.0, connect=10.0)  # 10s timeout on connect. 5s timeout elsewhere.
-    Timeout(5.0, pool=None)     # No timeout on acquiring connection from pool.
-                                # 5s timeout elsewhere.
-    """
-
-    def __init__(
-        self,
-        timeout: TimeoutTypes | UnsetType = UNSET,
-        *,
-        connect: None | float | UnsetType = UNSET,
-        read: None | float | UnsetType = UNSET,
-        write: None | float | UnsetType = UNSET,
-        pool: None | float | UnsetType = UNSET,
-    ) -> None:
-        if isinstance(timeout, Timeout):
-            # Passed as a single explicit Timeout.
-            assert connect is UNSET
-            assert read is UNSET
-            assert write is UNSET
-            assert pool is UNSET
-            self.connect = timeout.connect  # type: typing.Optional[float]
-            self.read = timeout.read  # type: typing.Optional[float]
-            self.write = timeout.write  # type: typing.Optional[float]
-            self.pool = timeout.pool  # type: typing.Optional[float]
-        elif isinstance(timeout, tuple):
-            # Passed as a tuple.
-            self.connect = timeout[0]
-            self.read = timeout[1]
-            self.write = None if len(timeout) < 3 else timeout[2]
-            self.pool = None if len(timeout) < 4 else timeout[3]
-        elif not (
-            isinstance(connect, UnsetType)
-            or isinstance(read, UnsetType)
-            or isinstance(write, UnsetType)
-            or isinstance(pool, UnsetType)
-        ):
-            self.connect = connect
-            self.read = read
-            self.write = write
-            self.pool = pool
-        else:
-            if isinstance(timeout, UnsetType):
-                raise ValueError(
-                    "httpx.Timeout must either include a default, or set all "
-                    "four parameters explicitly."
-                )
-            self.connect = timeout if isinstance(connect, UnsetType) else connect
-            self.read = timeout if isinstance(read, UnsetType) else read
-            self.write = timeout if isinstance(write, UnsetType) else write
-            self.pool = timeout if isinstance(pool, UnsetType) else pool
-
-    def as_dict(self) -> dict[str, float | None]:
-        return {
-            "connect": self.connect,
-            "read": self.read,
-            "write": self.write,
-            "pool": self.pool,
-        }
-
-    def __eq__(self, other: typing.Any) -> bool:
-        return (
-            isinstance(other, self.__class__)
-            and self.connect == other.connect
-            and self.read == other.read
-            and self.write == other.write
-            and self.pool == other.pool
-        )
-
-    def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-        if len({self.connect, self.read, self.write, self.pool}) == 1:
-            return f"{class_name}(timeout={self.connect})"
-        return (
-            f"{class_name}(connect={self.connect}, "
-            f"read={self.read}, write={self.write}, pool={self.pool})"
-        )
-
-
-class Limits:
-    """
-    Configuration for limits to various client behaviors.
-
-    **Parameters:**
-
-    * **max_connections** - The maximum number of concurrent connections that may be
-            established.
-    * **max_keepalive_connections** - Allow the connection pool to maintain
-            keep-alive connections below this point. Should be less than or equal
-            to `max_connections`.
-    * **keepalive_expiry** - Time limit on idle keep-alive connections in seconds.
-    """
-
-    def __init__(
-        self,
-        *,
-        max_connections: int | None = None,
-        max_keepalive_connections: int | None = None,
-        keepalive_expiry: float | None = 5.0,
-    ) -> None:
-        self.max_connections = max_connections
-        self.max_keepalive_connections = max_keepalive_connections
-        self.keepalive_expiry = keepalive_expiry
-
-    def __eq__(self, other: typing.Any) -> bool:
-        return (
-            isinstance(other, self.__class__)
-            and self.max_connections == other.max_connections
-            and self.max_keepalive_connections == other.max_keepalive_connections
-            and self.keepalive_expiry == other.keepalive_expiry
-        )
-
-    def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-        return (
-            f"{class_name}(max_connections={self.max_connections}, "
-            f"max_keepalive_connections={self.max_keepalive_connections}, "
-            f"keepalive_expiry={self.keepalive_expiry})"
-        )
-
-
-class Proxy:
-    def __init__(
-        self,
-        url: URL | str,
-        *,
-        ssl_context: ssl.SSLContext | None = None,
-        auth: tuple[str, str] | None = None,
-        headers: HeaderTypes | None = None,
-    ) -> None:
-        url = URL(url)
-        headers = Headers(headers)
-
-        if url.scheme not in ("http", "https", "socks5", "socks5h"):
-            raise ValueError(f"Unknown scheme for proxy URL {url!r}")
-
-        if url.username or url.password:
-            # Remove any auth credentials from the URL.
-            auth = (url.username, url.password)
-            url = url.copy_with(username=None, password=None)
-
-        self.url = url
-        self.auth = auth
-        self.headers = headers
-        self.ssl_context = ssl_context
-
-    @property
-    def raw_auth(self) -> tuple[bytes, bytes] | None:
-        # The proxy authentication as raw bytes.
-        return (
-            None
-            if self.auth is None
-            else (self.auth[0].encode("utf-8"), self.auth[1].encode("utf-8"))
-        )
-
-    def __repr__(self) -> str:
-        # The authentication is represented with the password component masked.
-        auth = (self.auth[0], "********") if self.auth else None
-
-        # Build a nice concise representation.
-        url_str = f"{str(self.url)!r}"
-        auth_str = f", auth={auth!r}" if auth else ""
-        headers_str = f", headers={dict(self.headers)!r}" if self.headers else ""
-        return f"Proxy({url_str}{auth_str}{headers_str})"
-
-
-DEFAULT_TIMEOUT_CONFIG = Timeout(timeout=5.0)
-DEFAULT_LIMITS = Limits(max_connections=100, max_keepalive_connections=20)
-DEFAULT_MAX_REDIRECTS = 20

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_content.py

@@ -1,240 +0,0 @@
-from __future__ import annotations
-
-import inspect
-import warnings
-from json import dumps as json_dumps
-from typing import (
-    Any,
-    AsyncIterable,
-    AsyncIterator,
-    Iterable,
-    Iterator,
-    Mapping,
-)
-from urllib.parse import urlencode
-
-from ._exceptions import StreamClosed, StreamConsumed
-from ._multipart import MultipartStream
-from ._types import (
-    AsyncByteStream,
-    RequestContent,
-    RequestData,
-    RequestFiles,
-    ResponseContent,
-    SyncByteStream,
-)
-from ._utils import peek_filelike_length, primitive_value_to_str
-
-__all__ = ["ByteStream"]
-
-
-class ByteStream(AsyncByteStream, SyncByteStream):
-    def __init__(self, stream: bytes) -> None:
-        self._stream = stream
-
-    def __iter__(self) -> Iterator[bytes]:
-        yield self._stream
-
-    async def __aiter__(self) -> AsyncIterator[bytes]:
-        yield self._stream
-
-
-class IteratorByteStream(SyncByteStream):
-    CHUNK_SIZE = 65_536
-
-    def __init__(self, stream: Iterable[bytes]) -> None:
-        self._stream = stream
-        self._is_stream_consumed = False
-        self._is_generator = inspect.isgenerator(stream)
-
-    def __iter__(self) -> Iterator[bytes]:
-        if self._is_stream_consumed and self._is_generator:
-            raise StreamConsumed()
-
-        self._is_stream_consumed = True
-        if hasattr(self._stream, "read"):
-            # File-like interfaces should use 'read' directly.
-            chunk = self._stream.read(self.CHUNK_SIZE)
-            while chunk:
-                yield chunk
-                chunk = self._stream.read(self.CHUNK_SIZE)
-        else:
-            # Otherwise iterate.
-            for part in self._stream:
-                yield part
-
-
-class AsyncIteratorByteStream(AsyncByteStream):
-    CHUNK_SIZE = 65_536
-
-    def __init__(self, stream: AsyncIterable[bytes]) -> None:
-        self._stream = stream
-        self._is_stream_consumed = False
-        self._is_generator = inspect.isasyncgen(stream)
-
-    async def __aiter__(self) -> AsyncIterator[bytes]:
-        if self._is_stream_consumed and self._is_generator:
-            raise StreamConsumed()
-
-        self._is_stream_consumed = True
-        if hasattr(self._stream, "aread"):
-            # File-like interfaces should use 'aread' directly.
-            chunk = await self._stream.aread(self.CHUNK_SIZE)
-            while chunk:
-                yield chunk
-                chunk = await self._stream.aread(self.CHUNK_SIZE)
-        else:
-            # Otherwise iterate.
-            async for part in self._stream:
-                yield part
-
-
-class UnattachedStream(AsyncByteStream, SyncByteStream):
-    """
-    If a request or response is serialized using pickle, then it is no longer
-    attached to a stream for I/O purposes. Any stream operations should result
-    in `httpx.StreamClosed`.
-    """
-
-    def __iter__(self) -> Iterator[bytes]:
-        raise StreamClosed()
-
-    async def __aiter__(self) -> AsyncIterator[bytes]:
-        raise StreamClosed()
-        yield b""  # pragma: no cover
-
-
-def encode_content(
-    content: str | bytes | Iterable[bytes] | AsyncIterable[bytes],
-) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
-    if isinstance(content, (bytes, str)):
-        body = content.encode("utf-8") if isinstance(content, str) else content
-        content_length = len(body)
-        headers = {"Content-Length": str(content_length)} if body else {}
-        return headers, ByteStream(body)
-
-    elif isinstance(content, Iterable) and not isinstance(content, dict):
-        # `not isinstance(content, dict)` is a bit oddly specific, but it
-        # catches a case that's easy for users to make in error, and would
-        # otherwise pass through here, like any other bytes-iterable,
-        # because `dict` happens to be iterable. See issue #2491.
-        content_length_or_none = peek_filelike_length(content)
-
-        if content_length_or_none is None:
-            headers = {"Transfer-Encoding": "chunked"}
-        else:
-            headers = {"Content-Length": str(content_length_or_none)}
-        return headers, IteratorByteStream(content)  # type: ignore
-
-    elif isinstance(content, AsyncIterable):
-        headers = {"Transfer-Encoding": "chunked"}
-        return headers, AsyncIteratorByteStream(content)
-
-    raise TypeError(f"Unexpected type for 'content', {type(content)!r}")
-
-
-def encode_urlencoded_data(
-    data: RequestData,
-) -> tuple[dict[str, str], ByteStream]:
-    plain_data = []
-    for key, value in data.items():
-        if isinstance(value, (list, tuple)):
-            plain_data.extend([(key, primitive_value_to_str(item)) for item in value])
-        else:
-            plain_data.append((key, primitive_value_to_str(value)))
-    body = urlencode(plain_data, doseq=True).encode("utf-8")
-    content_length = str(len(body))
-    content_type = "application/x-www-form-urlencoded"
-    headers = {"Content-Length": content_length, "Content-Type": content_type}
-    return headers, ByteStream(body)
-
-
-def encode_multipart_data(
-    data: RequestData, files: RequestFiles, boundary: bytes | None
-) -> tuple[dict[str, str], MultipartStream]:
-    multipart = MultipartStream(data=data, files=files, boundary=boundary)
-    headers = multipart.get_headers()
-    return headers, multipart
-
-
-def encode_text(text: str) -> tuple[dict[str, str], ByteStream]:
-    body = text.encode("utf-8")
-    content_length = str(len(body))
-    content_type = "text/plain; charset=utf-8"
-    headers = {"Content-Length": content_length, "Content-Type": content_type}
-    return headers, ByteStream(body)
-
-
-def encode_html(html: str) -> tuple[dict[str, str], ByteStream]:
-    body = html.encode("utf-8")
-    content_length = str(len(body))
-    content_type = "text/html; charset=utf-8"
-    headers = {"Content-Length": content_length, "Content-Type": content_type}
-    return headers, ByteStream(body)
-
-
-def encode_json(json: Any) -> tuple[dict[str, str], ByteStream]:
-    body = json_dumps(
-        json, ensure_ascii=False, separators=(",", ":"), allow_nan=False
-    ).encode("utf-8")
-    content_length = str(len(body))
-    content_type = "application/json"
-    headers = {"Content-Length": content_length, "Content-Type": content_type}
-    return headers, ByteStream(body)
-
-
-def encode_request(
-    content: RequestContent | None = None,
-    data: RequestData | None = None,
-    files: RequestFiles | None = None,
-    json: Any | None = None,
-    boundary: bytes | None = None,
-) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
-    """
-    Handles encoding the given `content`, `data`, `files`, and `json`,
-    returning a two-tuple of (<headers>, <stream>).
-    """
-    if data is not None and not isinstance(data, Mapping):
-        # We prefer to separate `content=<bytes|str|byte iterator|bytes aiterator>`
-        # for raw request content, and `data=<form data>` for url encoded or
-        # multipart form content.
-        #
-        # However for compat with requests, we *do* still support
-        # `data=<bytes...>` usages. We deal with that case here, treating it
-        # as if `content=<...>` had been supplied instead.
-        message = "Use 'content=<...>' to upload raw bytes/text content."
-        warnings.warn(message, DeprecationWarning, stacklevel=2)
-        return encode_content(data)
-
-    if content is not None:
-        return encode_content(content)
-    elif files:
-        return encode_multipart_data(data or {}, files, boundary)
-    elif data:
-        return encode_urlencoded_data(data)
-    elif json is not None:
-        return encode_json(json)
-
-    return {}, ByteStream(b"")
-
-
-def encode_response(
-    content: ResponseContent | None = None,
-    text: str | None = None,
-    html: str | None = None,
-    json: Any | None = None,
-) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
-    """
-    Handles encoding the given `content`, returning a two-tuple of
-    (<headers>, <stream>).
-    """
-    if content is not None:
-        return encode_content(content)
-    elif text is not None:
-        return encode_text(text)
-    elif html is not None:
-        return encode_html(html)
-    elif json is not None:
-        return encode_json(json)
-
-    return {}, ByteStream(b"")

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_decoders.py

@@ -1,393 +0,0 @@
-"""
-Handlers for Content-Encoding.
-
-See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
-"""
-
-from __future__ import annotations
-
-import codecs
-import io
-import typing
-import zlib
-
-from ._exceptions import DecodingError
-
-# Brotli support is optional
-try:
-    # The C bindings in `brotli` are recommended for CPython.
-    import brotli
-except ImportError:  # pragma: no cover
-    try:
-        # The CFFI bindings in `brotlicffi` are recommended for PyPy
-        # and other environments.
-        import brotlicffi as brotli
-    except ImportError:
-        brotli = None
-
-
-# Zstandard support is optional
-try:
-    import zstandard
-except ImportError:  # pragma: no cover
-    zstandard = None  # type: ignore
-
-
-class ContentDecoder:
-    def decode(self, data: bytes) -> bytes:
-        raise NotImplementedError()  # pragma: no cover
-
-    def flush(self) -> bytes:
-        raise NotImplementedError()  # pragma: no cover
-
-
-class IdentityDecoder(ContentDecoder):
-    """
-    Handle unencoded data.
-    """
-
-    def decode(self, data: bytes) -> bytes:
-        return data
-
-    def flush(self) -> bytes:
-        return b""
-
-
-class DeflateDecoder(ContentDecoder):
-    """
-    Handle 'deflate' decoding.
-
-    See: https://stackoverflow.com/questions/1838699
-    """
-
-    def __init__(self) -> None:
-        self.first_attempt = True
-        self.decompressor = zlib.decompressobj()
-
-    def decode(self, data: bytes) -> bytes:
-        was_first_attempt = self.first_attempt
-        self.first_attempt = False
-        try:
-            return self.decompressor.decompress(data)
-        except zlib.error as exc:
-            if was_first_attempt:
-                self.decompressor = zlib.decompressobj(-zlib.MAX_WBITS)
-                return self.decode(data)
-            raise DecodingError(str(exc)) from exc
-
-    def flush(self) -> bytes:
-        try:
-            return self.decompressor.flush()
-        except zlib.error as exc:  # pragma: no cover
-            raise DecodingError(str(exc)) from exc
-
-
-class GZipDecoder(ContentDecoder):
-    """
-    Handle 'gzip' decoding.
-
-    See: https://stackoverflow.com/questions/1838699
-    """
-
-    def __init__(self) -> None:
-        self.decompressor = zlib.decompressobj(zlib.MAX_WBITS | 16)
-
-    def decode(self, data: bytes) -> bytes:
-        try:
-            return self.decompressor.decompress(data)
-        except zlib.error as exc:
-            raise DecodingError(str(exc)) from exc
-
-    def flush(self) -> bytes:
-        try:
-            return self.decompressor.flush()
-        except zlib.error as exc:  # pragma: no cover
-            raise DecodingError(str(exc)) from exc
-
-
-class BrotliDecoder(ContentDecoder):
-    """
-    Handle 'brotli' decoding.
-
-    Requires `pip install brotlipy`. See: https://brotlipy.readthedocs.io/
-        or   `pip install brotli`. See https://github.com/google/brotli
-    Supports both 'brotlipy' and 'Brotli' packages since they share an import
-    name. The top branches are for 'brotlipy' and bottom branches for 'Brotli'
-    """
-
-    def __init__(self) -> None:
-        if brotli is None:  # pragma: no cover
-            raise ImportError(
-                "Using 'BrotliDecoder', but neither of the 'brotlicffi' or 'brotli' "
-                "packages have been installed. "
-                "Make sure to install httpx using `pip install httpx[brotli]`."
-            ) from None
-
-        self.decompressor = brotli.Decompressor()
-        self.seen_data = False
-        self._decompress: typing.Callable[[bytes], bytes]
-        if hasattr(self.decompressor, "decompress"):
-            # The 'brotlicffi' package.
-            self._decompress = self.decompressor.decompress  # pragma: no cover
-        else:
-            # The 'brotli' package.
-            self._decompress = self.decompressor.process  # pragma: no cover
-
-    def decode(self, data: bytes) -> bytes:
-        if not data:
-            return b""
-        self.seen_data = True
-        try:
-            return self._decompress(data)
-        except brotli.error as exc:
-            raise DecodingError(str(exc)) from exc
-
-    def flush(self) -> bytes:
-        if not self.seen_data:
-            return b""
-        try:
-            if hasattr(self.decompressor, "finish"):
-                # Only available in the 'brotlicffi' package.
-
-                # As the decompressor decompresses eagerly, this
-                # will never actually emit any data. However, it will potentially throw
-                # errors if a truncated or damaged data stream has been used.
-                self.decompressor.finish()  # pragma: no cover
-            return b""
-        except brotli.error as exc:  # pragma: no cover
-            raise DecodingError(str(exc)) from exc
-
-
-class ZStandardDecoder(ContentDecoder):
-    """
-    Handle 'zstd' RFC 8878 decoding.
-
-    Requires `pip install zstandard`.
-    Can be installed as a dependency of httpx using `pip install httpx[zstd]`.
-    """
-
-    # inspired by the ZstdDecoder implementation in urllib3
-    def __init__(self) -> None:
-        if zstandard is None:  # pragma: no cover
-            raise ImportError(
-                "Using 'ZStandardDecoder', ..."
-                "Make sure to install httpx using `pip install httpx[zstd]`."
-            ) from None
-
-        self.decompressor = zstandard.ZstdDecompressor().decompressobj()
-        self.seen_data = False
-
-    def decode(self, data: bytes) -> bytes:
-        assert zstandard is not None
-        self.seen_data = True
-        output = io.BytesIO()
-        try:
-            output.write(self.decompressor.decompress(data))
-            while self.decompressor.eof and self.decompressor.unused_data:
-                unused_data = self.decompressor.unused_data
-                self.decompressor = zstandard.ZstdDecompressor().decompressobj()
-                output.write(self.decompressor.decompress(unused_data))
-        except zstandard.ZstdError as exc:
-            raise DecodingError(str(exc)) from exc
-        return output.getvalue()
-
-    def flush(self) -> bytes:
-        if not self.seen_data:
-            return b""
-        ret = self.decompressor.flush()  # note: this is a no-op
-        if not self.decompressor.eof:
-            raise DecodingError("Zstandard data is incomplete")  # pragma: no cover
-        return bytes(ret)
-
-
-class MultiDecoder(ContentDecoder):
-    """
-    Handle the case where multiple encodings have been applied.
-    """
-
-    def __init__(self, children: typing.Sequence[ContentDecoder]) -> None:
-        """
-        'children' should be a sequence of decoders in the order in which
-        each was applied.
-        """
-        # Note that we reverse the order for decoding.
-        self.children = list(reversed(children))
-
-    def decode(self, data: bytes) -> bytes:
-        for child in self.children:
-            data = child.decode(data)
-        return data
-
-    def flush(self) -> bytes:
-        data = b""
-        for child in self.children:
-            data = child.decode(data) + child.flush()
-        return data
-
-
-class ByteChunker:
-    """
-    Handles returning byte content in fixed-size chunks.
-    """
-
-    def __init__(self, chunk_size: int | None = None) -> None:
-        self._buffer = io.BytesIO()
-        self._chunk_size = chunk_size
-
-    def decode(self, content: bytes) -> list[bytes]:
-        if self._chunk_size is None:
-            return [content] if content else []
-
-        self._buffer.write(content)
-        if self._buffer.tell() >= self._chunk_size:
-            value = self._buffer.getvalue()
-            chunks = [
-                value[i : i + self._chunk_size]
-                for i in range(0, len(value), self._chunk_size)
-            ]
-            if len(chunks[-1]) == self._chunk_size:
-                self._buffer.seek(0)
-                self._buffer.truncate()
-                return chunks
-            else:
-                self._buffer.seek(0)
-                self._buffer.write(chunks[-1])
-                self._buffer.truncate()
-                return chunks[:-1]
-        else:
-            return []
-
-    def flush(self) -> list[bytes]:
-        value = self._buffer.getvalue()
-        self._buffer.seek(0)
-        self._buffer.truncate()
-        return [value] if value else []
-
-
-class TextChunker:
-    """
-    Handles returning text content in fixed-size chunks.
-    """
-
-    def __init__(self, chunk_size: int | None = None) -> None:
-        self._buffer = io.StringIO()
-        self._chunk_size = chunk_size
-
-    def decode(self, content: str) -> list[str]:
-        if self._chunk_size is None:
-            return [content] if content else []
-
-        self._buffer.write(content)
-        if self._buffer.tell() >= self._chunk_size:
-            value = self._buffer.getvalue()
-            chunks = [
-                value[i : i + self._chunk_size]
-                for i in range(0, len(value), self._chunk_size)
-            ]
-            if len(chunks[-1]) == self._chunk_size:
-                self._buffer.seek(0)
-                self._buffer.truncate()
-                return chunks
-            else:
-                self._buffer.seek(0)
-                self._buffer.write(chunks[-1])
-                self._buffer.truncate()
-                return chunks[:-1]
-        else:
-            return []
-
-    def flush(self) -> list[str]:
-        value = self._buffer.getvalue()
-        self._buffer.seek(0)
-        self._buffer.truncate()
-        return [value] if value else []
-
-
-class TextDecoder:
-    """
-    Handles incrementally decoding bytes into text
-    """
-
-    def __init__(self, encoding: str = "utf-8") -> None:
-        self.decoder = codecs.getincrementaldecoder(encoding)(errors="replace")
-
-    def decode(self, data: bytes) -> str:
-        return self.decoder.decode(data)
-
-    def flush(self) -> str:
-        return self.decoder.decode(b"", True)
-
-
-class LineDecoder:
-    """
-    Handles incrementally reading lines from text.
-
-    Has the same behaviour as the stdllib splitlines,
-    but handling the input iteratively.
-    """
-
-    def __init__(self) -> None:
-        self.buffer: list[str] = []
-        self.trailing_cr: bool = False
-
-    def decode(self, text: str) -> list[str]:
-        # See https://docs.python.org/3/library/stdtypes.html#str.splitlines
-        NEWLINE_CHARS = "\n\r\x0b\x0c\x1c\x1d\x1e\x85\u2028\u2029"
-
-        # We always push a trailing `\r` into the next decode iteration.
-        if self.trailing_cr:
-            text = "\r" + text
-            self.trailing_cr = False
-        if text.endswith("\r"):
-            self.trailing_cr = True
-            text = text[:-1]
-
-        if not text:
-            # NOTE: the edge case input of empty text doesn't occur in practice,
-            # because other httpx internals filter out this value
-            return []  # pragma: no cover
-
-        trailing_newline = text[-1] in NEWLINE_CHARS
-        lines = text.splitlines()
-
-        if len(lines) == 1 and not trailing_newline:
-            # No new lines, buffer the input and continue.
-            self.buffer.append(lines[0])
-            return []
-
-        if self.buffer:
-            # Include any existing buffer in the first portion of the
-            # splitlines result.
-            lines = ["".join(self.buffer) + lines[0]] + lines[1:]
-            self.buffer = []
-
-        if not trailing_newline:
-            # If the last segment of splitlines is not newline terminated,
-            # then drop it from our output and start a new buffer.
-            self.buffer = [lines.pop()]
-
-        return lines
-
-    def flush(self) -> list[str]:
-        if not self.buffer and not self.trailing_cr:
-            return []
-
-        lines = ["".join(self.buffer)]
-        self.buffer = []
-        self.trailing_cr = False
-        return lines
-
-
-SUPPORTED_DECODERS = {
-    "identity": IdentityDecoder,
-    "gzip": GZipDecoder,
-    "deflate": DeflateDecoder,
-    "br": BrotliDecoder,
-    "zstd": ZStandardDecoder,
-}
-
-
-if brotli is None:
-    SUPPORTED_DECODERS.pop("br")  # pragma: no cover
-if zstandard is None:
-    SUPPORTED_DECODERS.pop("zstd")  # pragma: no cover

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_exceptions.py

@@ -1,379 +0,0 @@
-"""
-Our exception hierarchy:
-
-* HTTPError
-  x RequestError
-    + TransportError
-      - TimeoutException
-        · ConnectTimeout
-        · ReadTimeout
-        · WriteTimeout
-        · PoolTimeout
-      - NetworkError
-        · ConnectError
-        · ReadError
-        · WriteError
-        · CloseError
-      - ProtocolError
-        · LocalProtocolError
-        · RemoteProtocolError
-      - ProxyError
-      - UnsupportedProtocol
-    + DecodingError
-    + TooManyRedirects
-  x HTTPStatusError
-* InvalidURL
-* CookieConflict
-* StreamError
-  x StreamConsumed
-  x StreamClosed
-  x ResponseNotRead
-  x RequestNotRead
-"""
-
-from __future__ import annotations
-
-import contextlib
-import typing
-
-if typing.TYPE_CHECKING:
-    from ._models import Request, Response  # pragma: no cover
-
-__all__ = [
-    "CloseError",
-    "ConnectError",
-    "ConnectTimeout",
-    "CookieConflict",
-    "DecodingError",
-    "HTTPError",
-    "HTTPStatusError",
-    "InvalidURL",
-    "LocalProtocolError",
-    "NetworkError",
-    "PoolTimeout",
-    "ProtocolError",
-    "ProxyError",
-    "ReadError",
-    "ReadTimeout",
-    "RemoteProtocolError",
-    "RequestError",
-    "RequestNotRead",
-    "ResponseNotRead",
-    "StreamClosed",
-    "StreamConsumed",
-    "StreamError",
-    "TimeoutException",
-    "TooManyRedirects",
-    "TransportError",
-    "UnsupportedProtocol",
-    "WriteError",
-    "WriteTimeout",
-]
-
-
-class HTTPError(Exception):
-    """
-    Base class for `RequestError` and `HTTPStatusError`.
-
-    Useful for `try...except` blocks when issuing a request,
-    and then calling `.raise_for_status()`.
-
-    For example:
-
-    ```
-    try:
-        response = httpx.get("https://www.example.com")
-        response.raise_for_status()
-    except httpx.HTTPError as exc:
-        print(f"HTTP Exception for {exc.request.url} - {exc}")
-    ```
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-        self._request: Request | None = None
-
-    @property
-    def request(self) -> Request:
-        if self._request is None:
-            raise RuntimeError("The .request property has not been set.")
-        return self._request
-
-    @request.setter
-    def request(self, request: Request) -> None:
-        self._request = request
-
-
-class RequestError(HTTPError):
-    """
-    Base class for all exceptions that may occur when issuing a `.request()`.
-    """
-
-    def __init__(self, message: str, *, request: Request | None = None) -> None:
-        super().__init__(message)
-        # At the point an exception is raised we won't typically have a request
-        # instance to associate it with.
-        #
-        # The 'request_context' context manager is used within the Client and
-        # Response methods in order to ensure that any raised exceptions
-        # have a `.request` property set on them.
-        self._request = request
-
-
-class TransportError(RequestError):
-    """
-    Base class for all exceptions that occur at the level of the Transport API.
-    """
-
-
-# Timeout exceptions...
-
-
-class TimeoutException(TransportError):
-    """
-    The base class for timeout errors.
-
-    An operation has timed out.
-    """
-
-
-class ConnectTimeout(TimeoutException):
-    """
-    Timed out while connecting to the host.
-    """
-
-
-class ReadTimeout(TimeoutException):
-    """
-    Timed out while receiving data from the host.
-    """
-
-
-class WriteTimeout(TimeoutException):
-    """
-    Timed out while sending data to the host.
-    """
-
-
-class PoolTimeout(TimeoutException):
-    """
-    Timed out waiting to acquire a connection from the pool.
-    """
-
-
-# Core networking exceptions...
-
-
-class NetworkError(TransportError):
-    """
-    The base class for network-related errors.
-
-    An error occurred while interacting with the network.
-    """
-
-
-class ReadError(NetworkError):
-    """
-    Failed to receive data from the network.
-    """
-
-
-class WriteError(NetworkError):
-    """
-    Failed to send data through the network.
-    """
-
-
-class ConnectError(NetworkError):
-    """
-    Failed to establish a connection.
-    """
-
-
-class CloseError(NetworkError):
-    """
-    Failed to close a connection.
-    """
-
-
-# Other transport exceptions...
-
-
-class ProxyError(TransportError):
-    """
-    An error occurred while establishing a proxy connection.
-    """
-
-
-class UnsupportedProtocol(TransportError):
-    """
-    Attempted to make a request to an unsupported protocol.
-
-    For example issuing a request to `ftp://www.example.com`.
-    """
-
-
-class ProtocolError(TransportError):
-    """
-    The protocol was violated.
-    """
-
-
-class LocalProtocolError(ProtocolError):
-    """
-    A protocol was violated by the client.
-
-    For example if the user instantiated a `Request` instance explicitly,
-    failed to include the mandatory `Host:` header, and then issued it directly
-    using `client.send()`.
-    """
-
-
-class RemoteProtocolError(ProtocolError):
-    """
-    The protocol was violated by the server.
-
-    For example, returning malformed HTTP.
-    """
-
-
-# Other request exceptions...
-
-
-class DecodingError(RequestError):
-    """
-    Decoding of the response failed, due to a malformed encoding.
-    """
-
-
-class TooManyRedirects(RequestError):
-    """
-    Too many redirects.
-    """
-
-
-# Client errors
-
-
-class HTTPStatusError(HTTPError):
-    """
-    The response had an error HTTP status of 4xx or 5xx.
-
-    May be raised when calling `response.raise_for_status()`
-    """
-
-    def __init__(self, message: str, *, request: Request, response: Response) -> None:
-        super().__init__(message)
-        self.request = request
-        self.response = response
-
-
-class InvalidURL(Exception):
-    """
-    URL is improperly formed or cannot be parsed.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-
-
-class CookieConflict(Exception):
-    """
-    Attempted to lookup a cookie by name, but multiple cookies existed.
-
-    Can occur when calling `response.cookies.get(...)`.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-
-
-# Stream exceptions...
-
-# These may occur as the result of a programming error, by accessing
-# the request/response stream in an invalid manner.
-
-
-class StreamError(RuntimeError):
-    """
-    The base class for stream exceptions.
-
-    The developer made an error in accessing the request stream in
-    an invalid way.
-    """
-
-    def __init__(self, message: str) -> None:
-        super().__init__(message)
-
-
-class StreamConsumed(StreamError):
-    """
-    Attempted to read or stream content, but the content has already
-    been streamed.
-    """
-
-    def __init__(self) -> None:
-        message = (
-            "Attempted to read or stream some content, but the content has "
-            "already been streamed. For requests, this could be due to passing "
-            "a generator as request content, and then receiving a redirect "
-            "response or a secondary request as part of an authentication flow."
-            "For responses, this could be due to attempting to stream the response "
-            "content more than once."
-        )
-        super().__init__(message)
-
-
-class StreamClosed(StreamError):
-    """
-    Attempted to read or stream response content, but the request has been
-    closed.
-    """
-
-    def __init__(self) -> None:
-        message = (
-            "Attempted to read or stream content, but the stream has " "been closed."
-        )
-        super().__init__(message)
-
-
-class ResponseNotRead(StreamError):
-    """
-    Attempted to access streaming response content, without having called `read()`.
-    """
-
-    def __init__(self) -> None:
-        message = (
-            "Attempted to access streaming response content,"
-            " without having called `read()`."
-        )
-        super().__init__(message)
-
-
-class RequestNotRead(StreamError):
-    """
-    Attempted to access streaming request content, without having called `read()`.
-    """
-
-    def __init__(self) -> None:
-        message = (
-            "Attempted to access streaming request content,"
-            " without having called `read()`."
-        )
-        super().__init__(message)
-
-
-@contextlib.contextmanager
-def request_context(
-    request: Request | None = None,
-) -> typing.Iterator[None]:
-    """
-    A context manager that can be used to attach the given request context
-    to any `RequestError` exceptions that are raised within the block.
-    """
-    try:
-        yield
-    except RequestError as exc:
-        if request is not None:
-            exc.request = request
-        raise exc

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_main.py

@@ -1,506 +0,0 @@
-from __future__ import annotations
-
-import functools
-import json
-import sys
-import typing
-
-import click
-import pygments.lexers
-import pygments.util
-import rich.console
-import rich.markup
-import rich.progress
-import rich.syntax
-import rich.table
-
-from ._client import Client
-from ._exceptions import RequestError
-from ._models import Response
-from ._status_codes import codes
-
-if typing.TYPE_CHECKING:
-    import httpcore  # pragma: no cover
-
-
-def print_help() -> None:
-    console = rich.console.Console()
-
-    console.print("[bold]HTTPX :butterfly:", justify="center")
-    console.print()
-    console.print("A next generation HTTP client.", justify="center")
-    console.print()
-    console.print(
-        "Usage: [bold]httpx[/bold] [cyan]<URL> [OPTIONS][/cyan] ", justify="left"
-    )
-    console.print()
-
-    table = rich.table.Table.grid(padding=1, pad_edge=True)
-    table.add_column("Parameter", no_wrap=True, justify="left", style="bold")
-    table.add_column("Description")
-    table.add_row(
-        "-m, --method [cyan]METHOD",
-        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD.\n"
-        "[Default: GET, or POST if a request body is included]",
-    )
-    table.add_row(
-        "-p, --params [cyan]<NAME VALUE> ...",
-        "Query parameters to include in the request URL.",
-    )
-    table.add_row(
-        "-c, --content [cyan]TEXT", "Byte content to include in the request body."
-    )
-    table.add_row(
-        "-d, --data [cyan]<NAME VALUE> ...", "Form data to include in the request body."
-    )
-    table.add_row(
-        "-f, --files [cyan]<NAME FILENAME> ...",
-        "Form files to include in the request body.",
-    )
-    table.add_row("-j, --json [cyan]TEXT", "JSON data to include in the request body.")
-    table.add_row(
-        "-h, --headers [cyan]<NAME VALUE> ...",
-        "Include additional HTTP headers in the request.",
-    )
-    table.add_row(
-        "--cookies [cyan]<NAME VALUE> ...", "Cookies to include in the request."
-    )
-    table.add_row(
-        "--auth [cyan]<USER PASS>",
-        "Username and password to include in the request. Specify '-' for the password"
-        " to use a password prompt. Note that using --verbose/-v will expose"
-        " the Authorization header, including the password encoding"
-        " in a trivially reversible format.",
-    )
-
-    table.add_row(
-        "--proxy [cyan]URL",
-        "Send the request via a proxy. Should be the URL giving the proxy address.",
-    )
-
-    table.add_row(
-        "--timeout [cyan]FLOAT",
-        "Timeout value to use for network operations, such as establishing the"
-        " connection, reading some data, etc... [Default: 5.0]",
-    )
-
-    table.add_row("--follow-redirects", "Automatically follow redirects.")
-    table.add_row("--no-verify", "Disable SSL verification.")
-    table.add_row(
-        "--http2", "Send the request using HTTP/2, if the remote server supports it."
-    )
-
-    table.add_row(
-        "--download [cyan]FILE",
-        "Save the response content as a file, rather than displaying it.",
-    )
-
-    table.add_row("-v, --verbose", "Verbose output. Show request as well as response.")
-    table.add_row("--help", "Show this message and exit.")
-    console.print(table)
-
-
-def get_lexer_for_response(response: Response) -> str:
-    content_type = response.headers.get("Content-Type")
-    if content_type is not None:
-        mime_type, _, _ = content_type.partition(";")
-        try:
-            return typing.cast(
-                str, pygments.lexers.get_lexer_for_mimetype(mime_type.strip()).name
-            )
-        except pygments.util.ClassNotFound:  # pragma: no cover
-            pass
-    return ""  # pragma: no cover
-
-
-def format_request_headers(request: httpcore.Request, http2: bool = False) -> str:
-    version = "HTTP/2" if http2 else "HTTP/1.1"
-    headers = [
-        (name.lower() if http2 else name, value) for name, value in request.headers
-    ]
-    method = request.method.decode("ascii")
-    target = request.url.target.decode("ascii")
-    lines = [f"{method} {target} {version}"] + [
-        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
-    ]
-    return "\n".join(lines)
-
-
-def format_response_headers(
-    http_version: bytes,
-    status: int,
-    reason_phrase: bytes | None,
-    headers: list[tuple[bytes, bytes]],
-) -> str:
-    version = http_version.decode("ascii")
-    reason = (
-        codes.get_reason_phrase(status)
-        if reason_phrase is None
-        else reason_phrase.decode("ascii")
-    )
-    lines = [f"{version} {status} {reason}"] + [
-        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
-    ]
-    return "\n".join(lines)
-
-
-def print_request_headers(request: httpcore.Request, http2: bool = False) -> None:
-    console = rich.console.Console()
-    http_text = format_request_headers(request, http2=http2)
-    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
-    console.print(syntax)
-    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
-    console.print(syntax)
-
-
-def print_response_headers(
-    http_version: bytes,
-    status: int,
-    reason_phrase: bytes | None,
-    headers: list[tuple[bytes, bytes]],
-) -> None:
-    console = rich.console.Console()
-    http_text = format_response_headers(http_version, status, reason_phrase, headers)
-    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
-    console.print(syntax)
-    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
-    console.print(syntax)
-
-
-def print_response(response: Response) -> None:
-    console = rich.console.Console()
-    lexer_name = get_lexer_for_response(response)
-    if lexer_name:
-        if lexer_name.lower() == "json":
-            try:
-                data = response.json()
-                text = json.dumps(data, indent=4)
-            except ValueError:  # pragma: no cover
-                text = response.text
-        else:
-            text = response.text
-
-        syntax = rich.syntax.Syntax(text, lexer_name, theme="ansi_dark", word_wrap=True)
-        console.print(syntax)
-    else:
-        console.print(f"<{len(response.content)} bytes of binary data>")
-
-
-_PCTRTT = typing.Tuple[typing.Tuple[str, str], ...]
-_PCTRTTT = typing.Tuple[_PCTRTT, ...]
-_PeerCertRetDictType = typing.Dict[str, typing.Union[str, _PCTRTTT, _PCTRTT]]
-
-
-def format_certificate(cert: _PeerCertRetDictType) -> str:  # pragma: no cover
-    lines = []
-    for key, value in cert.items():
-        if isinstance(value, (list, tuple)):
-            lines.append(f"*   {key}:")
-            for item in value:
-                if key in ("subject", "issuer"):
-                    for sub_item in item:
-                        lines.append(f"*     {sub_item[0]}: {sub_item[1]!r}")
-                elif isinstance(item, tuple) and len(item) == 2:
-                    lines.append(f"*     {item[0]}: {item[1]!r}")
-                else:
-                    lines.append(f"*     {item!r}")
-        else:
-            lines.append(f"*   {key}: {value!r}")
-    return "\n".join(lines)
-
-
-def trace(
-    name: str, info: typing.Mapping[str, typing.Any], verbose: bool = False
-) -> None:
-    console = rich.console.Console()
-    if name == "connection.connect_tcp.started" and verbose:
-        host = info["host"]
-        console.print(f"* Connecting to {host!r}")
-    elif name == "connection.connect_tcp.complete" and verbose:
-        stream = info["return_value"]
-        server_addr = stream.get_extra_info("server_addr")
-        console.print(f"* Connected to {server_addr[0]!r} on port {server_addr[1]}")
-    elif name == "connection.start_tls.complete" and verbose:  # pragma: no cover
-        stream = info["return_value"]
-        ssl_object = stream.get_extra_info("ssl_object")
-        version = ssl_object.version()
-        cipher = ssl_object.cipher()
-        server_cert = ssl_object.getpeercert()
-        alpn = ssl_object.selected_alpn_protocol()
-        console.print(f"* SSL established using {version!r} / {cipher[0]!r}")
-        console.print(f"* Selected ALPN protocol: {alpn!r}")
-        if server_cert:
-            console.print("* Server certificate:")
-            console.print(format_certificate(server_cert))
-    elif name == "http11.send_request_headers.started" and verbose:
-        request = info["request"]
-        print_request_headers(request, http2=False)
-    elif name == "http2.send_request_headers.started" and verbose:  # pragma: no cover
-        request = info["request"]
-        print_request_headers(request, http2=True)
-    elif name == "http11.receive_response_headers.complete":
-        http_version, status, reason_phrase, headers = info["return_value"]
-        print_response_headers(http_version, status, reason_phrase, headers)
-    elif name == "http2.receive_response_headers.complete":  # pragma: no cover
-        status, headers = info["return_value"]
-        http_version = b"HTTP/2"
-        reason_phrase = None
-        print_response_headers(http_version, status, reason_phrase, headers)
-
-
-def download_response(response: Response, download: typing.BinaryIO) -> None:
-    console = rich.console.Console()
-    console.print()
-    content_length = response.headers.get("Content-Length")
-    with rich.progress.Progress(
-        "[progress.description]{task.description}",
-        "[progress.percentage]{task.percentage:>3.0f}%",
-        rich.progress.BarColumn(bar_width=None),
-        rich.progress.DownloadColumn(),
-        rich.progress.TransferSpeedColumn(),
-    ) as progress:
-        description = f"Downloading [bold]{rich.markup.escape(download.name)}"
-        download_task = progress.add_task(
-            description,
-            total=int(content_length or 0),
-            start=content_length is not None,
-        )
-        for chunk in response.iter_bytes():
-            download.write(chunk)
-            progress.update(download_task, completed=response.num_bytes_downloaded)
-
-
-def validate_json(
-    ctx: click.Context,
-    param: click.Option | click.Parameter,
-    value: typing.Any,
-) -> typing.Any:
-    if value is None:
-        return None
-
-    try:
-        return json.loads(value)
-    except json.JSONDecodeError:  # pragma: no cover
-        raise click.BadParameter("Not valid JSON")
-
-
-def validate_auth(
-    ctx: click.Context,
-    param: click.Option | click.Parameter,
-    value: typing.Any,
-) -> typing.Any:
-    if value == (None, None):
-        return None
-
-    username, password = value
-    if password == "-":  # pragma: no cover
-        password = click.prompt("Password", hide_input=True)
-    return (username, password)
-
-
-def handle_help(
-    ctx: click.Context,
-    param: click.Option | click.Parameter,
-    value: typing.Any,
-) -> None:
-    if not value or ctx.resilient_parsing:
-        return
-
-    print_help()
-    ctx.exit()
-
-
-@click.command(add_help_option=False)
-@click.argument("url", type=str)
-@click.option(
-    "--method",
-    "-m",
-    "method",
-    type=str,
-    help=(
-        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD. "
-        "[Default: GET, or POST if a request body is included]"
-    ),
-)
-@click.option(
-    "--params",
-    "-p",
-    "params",
-    type=(str, str),
-    multiple=True,
-    help="Query parameters to include in the request URL.",
-)
-@click.option(
-    "--content",
-    "-c",
-    "content",
-    type=str,
-    help="Byte content to include in the request body.",
-)
-@click.option(
-    "--data",
-    "-d",
-    "data",
-    type=(str, str),
-    multiple=True,
-    help="Form data to include in the request body.",
-)
-@click.option(
-    "--files",
-    "-f",
-    "files",
-    type=(str, click.File(mode="rb")),
-    multiple=True,
-    help="Form files to include in the request body.",
-)
-@click.option(
-    "--json",
-    "-j",
-    "json",
-    type=str,
-    callback=validate_json,
-    help="JSON data to include in the request body.",
-)
-@click.option(
-    "--headers",
-    "-h",
-    "headers",
-    type=(str, str),
-    multiple=True,
-    help="Include additional HTTP headers in the request.",
-)
-@click.option(
-    "--cookies",
-    "cookies",
-    type=(str, str),
-    multiple=True,
-    help="Cookies to include in the request.",
-)
-@click.option(
-    "--auth",
-    "auth",
-    type=(str, str),
-    default=(None, None),
-    callback=validate_auth,
-    help=(
-        "Username and password to include in the request. "
-        "Specify '-' for the password to use a password prompt. "
-        "Note that using --verbose/-v will expose the Authorization header, "
-        "including the password encoding in a trivially reversible format."
-    ),
-)
-@click.option(
-    "--proxy",
-    "proxy",
-    type=str,
-    default=None,
-    help="Send the request via a proxy. Should be the URL giving the proxy address.",
-)
-@click.option(
-    "--timeout",
-    "timeout",
-    type=float,
-    default=5.0,
-    help=(
-        "Timeout value to use for network operations, such as establishing the "
-        "connection, reading some data, etc... [Default: 5.0]"
-    ),
-)
-@click.option(
-    "--follow-redirects",
-    "follow_redirects",
-    is_flag=True,
-    default=False,
-    help="Automatically follow redirects.",
-)
-@click.option(
-    "--no-verify",
-    "verify",
-    is_flag=True,
-    default=True,
-    help="Disable SSL verification.",
-)
-@click.option(
-    "--http2",
-    "http2",
-    type=bool,
-    is_flag=True,
-    default=False,
-    help="Send the request using HTTP/2, if the remote server supports it.",
-)
-@click.option(
-    "--download",
-    type=click.File("wb"),
-    help="Save the response content as a file, rather than displaying it.",
-)
-@click.option(
-    "--verbose",
-    "-v",
-    type=bool,
-    is_flag=True,
-    default=False,
-    help="Verbose. Show request as well as response.",
-)
-@click.option(
-    "--help",
-    is_flag=True,
-    is_eager=True,
-    expose_value=False,
-    callback=handle_help,
-    help="Show this message and exit.",
-)
-def main(
-    url: str,
-    method: str,
-    params: list[tuple[str, str]],
-    content: str,
-    data: list[tuple[str, str]],
-    files: list[tuple[str, click.File]],
-    json: str,
-    headers: list[tuple[str, str]],
-    cookies: list[tuple[str, str]],
-    auth: tuple[str, str] | None,
-    proxy: str,
-    timeout: float,
-    follow_redirects: bool,
-    verify: bool,
-    http2: bool,
-    download: typing.BinaryIO | None,
-    verbose: bool,
-) -> None:
-    """
-    An HTTP command line client.
-    Sends a request and displays the response.
-    """
-    if not method:
-        method = "POST" if content or data or files or json else "GET"
-
-    try:
-        with Client(proxy=proxy, timeout=timeout, http2=http2, verify=verify) as client:
-            with client.stream(
-                method,
-                url,
-                params=list(params),
-                content=content,
-                data=dict(data),
-                files=files,  # type: ignore
-                json=json,
-                headers=headers,
-                cookies=dict(cookies),
-                auth=auth,
-                follow_redirects=follow_redirects,
-                extensions={"trace": functools.partial(trace, verbose=verbose)},
-            ) as response:
-                if download is not None:
-                    download_response(response, download)
-                else:
-                    response.read()
-                    if response.content:
-                        print_response(response)
-
-    except RequestError as exc:
-        console = rich.console.Console()
-        console.print(f"[red]{type(exc).__name__}[/red]: {exc}")
-        sys.exit(1)
-
-    sys.exit(0 if response.is_success else 1)

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_models.py

@@ -1,1277 +0,0 @@
-from __future__ import annotations
-
-import codecs
-import datetime
-import email.message
-import json as jsonlib
-import re
-import typing
-import urllib.request
-from collections.abc import Mapping
-from http.cookiejar import Cookie, CookieJar
-
-from ._content import ByteStream, UnattachedStream, encode_request, encode_response
-from ._decoders import (
-    SUPPORTED_DECODERS,
-    ByteChunker,
-    ContentDecoder,
-    IdentityDecoder,
-    LineDecoder,
-    MultiDecoder,
-    TextChunker,
-    TextDecoder,
-)
-from ._exceptions import (
-    CookieConflict,
-    HTTPStatusError,
-    RequestNotRead,
-    ResponseNotRead,
-    StreamClosed,
-    StreamConsumed,
-    request_context,
-)
-from ._multipart import get_multipart_boundary_from_content_type
-from ._status_codes import codes
-from ._types import (
-    AsyncByteStream,
-    CookieTypes,
-    HeaderTypes,
-    QueryParamTypes,
-    RequestContent,
-    RequestData,
-    RequestExtensions,
-    RequestFiles,
-    ResponseContent,
-    ResponseExtensions,
-    SyncByteStream,
-)
-from ._urls import URL
-from ._utils import to_bytes_or_str, to_str
-
-__all__ = ["Cookies", "Headers", "Request", "Response"]
-
-SENSITIVE_HEADERS = {"authorization", "proxy-authorization"}
-
-
-def _is_known_encoding(encoding: str) -> bool:
-    """
-    Return `True` if `encoding` is a known codec.
-    """
-    try:
-        codecs.lookup(encoding)
-    except LookupError:
-        return False
-    return True
-
-
-def _normalize_header_key(key: str | bytes, encoding: str | None = None) -> bytes:
-    """
-    Coerce str/bytes into a strictly byte-wise HTTP header key.
-    """
-    return key if isinstance(key, bytes) else key.encode(encoding or "ascii")
-
-
-def _normalize_header_value(value: str | bytes, encoding: str | None = None) -> bytes:
-    """
-    Coerce str/bytes into a strictly byte-wise HTTP header value.
-    """
-    if isinstance(value, bytes):
-        return value
-    if not isinstance(value, str):
-        raise TypeError(f"Header value must be str or bytes, not {type(value)}")
-    return value.encode(encoding or "ascii")
-
-
-def _parse_content_type_charset(content_type: str) -> str | None:
-    # We used to use `cgi.parse_header()` here, but `cgi` became a dead battery.
-    # See: https://peps.python.org/pep-0594/#cgi
-    msg = email.message.Message()
-    msg["content-type"] = content_type
-    return msg.get_content_charset(failobj=None)
-
-
-def _parse_header_links(value: str) -> list[dict[str, str]]:
-    """
-    Returns a list of parsed link headers, for more info see:
-    https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link
-    The generic syntax of those is:
-    Link: < uri-reference >; param1=value1; param2="value2"
-    So for instance:
-    Link; '<http:/.../front.jpeg>; type="image/jpeg",<http://.../back.jpeg>;'
-    would return
-        [
-            {"url": "http:/.../front.jpeg", "type": "image/jpeg"},
-            {"url": "http://.../back.jpeg"},
-        ]
-    :param value: HTTP Link entity-header field
-    :return: list of parsed link headers
-    """
-    links: list[dict[str, str]] = []
-    replace_chars = " '\""
-    value = value.strip(replace_chars)
-    if not value:
-        return links
-    for val in re.split(", *<", value):
-        try:
-            url, params = val.split(";", 1)
-        except ValueError:
-            url, params = val, ""
-        link = {"url": url.strip("<> '\"")}
-        for param in params.split(";"):
-            try:
-                key, value = param.split("=")
-            except ValueError:
-                break
-            link[key.strip(replace_chars)] = value.strip(replace_chars)
-        links.append(link)
-    return links
-
-
-def _obfuscate_sensitive_headers(
-    items: typing.Iterable[tuple[typing.AnyStr, typing.AnyStr]],
-) -> typing.Iterator[tuple[typing.AnyStr, typing.AnyStr]]:
-    for k, v in items:
-        if to_str(k.lower()) in SENSITIVE_HEADERS:
-            v = to_bytes_or_str("[secure]", match_type_of=v)
-        yield k, v
-
-
-class Headers(typing.MutableMapping[str, str]):
-    """
-    HTTP headers, as a case-insensitive multi-dict.
-    """
-
-    def __init__(
-        self,
-        headers: HeaderTypes | None = None,
-        encoding: str | None = None,
-    ) -> None:
-        self._list = []  # type: typing.List[typing.Tuple[bytes, bytes, bytes]]
-
-        if isinstance(headers, Headers):
-            self._list = list(headers._list)
-        elif isinstance(headers, Mapping):
-            for k, v in headers.items():
-                bytes_key = _normalize_header_key(k, encoding)
-                bytes_value = _normalize_header_value(v, encoding)
-                self._list.append((bytes_key, bytes_key.lower(), bytes_value))
-        elif headers is not None:
-            for k, v in headers:
-                bytes_key = _normalize_header_key(k, encoding)
-                bytes_value = _normalize_header_value(v, encoding)
-                self._list.append((bytes_key, bytes_key.lower(), bytes_value))
-
-        self._encoding = encoding
-
-    @property
-    def encoding(self) -> str:
-        """
-        Header encoding is mandated as ascii, but we allow fallbacks to utf-8
-        or iso-8859-1.
-        """
-        if self._encoding is None:
-            for encoding in ["ascii", "utf-8"]:
-                for key, value in self.raw:
-                    try:
-                        key.decode(encoding)
-                        value.decode(encoding)
-                    except UnicodeDecodeError:
-                        break
-                else:
-                    # The else block runs if 'break' did not occur, meaning
-                    # all values fitted the encoding.
-                    self._encoding = encoding
-                    break
-            else:
-                # The ISO-8859-1 encoding covers all 256 code points in a byte,
-                # so will never raise decode errors.
-                self._encoding = "iso-8859-1"
-        return self._encoding
-
-    @encoding.setter
-    def encoding(self, value: str) -> None:
-        self._encoding = value
-
-    @property
-    def raw(self) -> list[tuple[bytes, bytes]]:
-        """
-        Returns a list of the raw header items, as byte pairs.
-        """
-        return [(raw_key, value) for raw_key, _, value in self._list]
-
-    def keys(self) -> typing.KeysView[str]:
-        return {key.decode(self.encoding): None for _, key, value in self._list}.keys()
-
-    def values(self) -> typing.ValuesView[str]:
-        values_dict: dict[str, str] = {}
-        for _, key, value in self._list:
-            str_key = key.decode(self.encoding)
-            str_value = value.decode(self.encoding)
-            if str_key in values_dict:
-                values_dict[str_key] += f", {str_value}"
-            else:
-                values_dict[str_key] = str_value
-        return values_dict.values()
-
-    def items(self) -> typing.ItemsView[str, str]:
-        """
-        Return `(key, value)` items of headers. Concatenate headers
-        into a single comma separated value when a key occurs multiple times.
-        """
-        values_dict: dict[str, str] = {}
-        for _, key, value in self._list:
-            str_key = key.decode(self.encoding)
-            str_value = value.decode(self.encoding)
-            if str_key in values_dict:
-                values_dict[str_key] += f", {str_value}"
-            else:
-                values_dict[str_key] = str_value
-        return values_dict.items()
-
-    def multi_items(self) -> list[tuple[str, str]]:
-        """
-        Return a list of `(key, value)` pairs of headers. Allow multiple
-        occurrences of the same key without concatenating into a single
-        comma separated value.
-        """
-        return [
-            (key.decode(self.encoding), value.decode(self.encoding))
-            for _, key, value in self._list
-        ]
-
-    def get(self, key: str, default: typing.Any = None) -> typing.Any:
-        """
-        Return a header value. If multiple occurrences of the header occur
-        then concatenate them together with commas.
-        """
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def get_list(self, key: str, split_commas: bool = False) -> list[str]:
-        """
-        Return a list of all header values for a given key.
-        If `split_commas=True` is passed, then any comma separated header
-        values are split into multiple return strings.
-        """
-        get_header_key = key.lower().encode(self.encoding)
-
-        values = [
-            item_value.decode(self.encoding)
-            for _, item_key, item_value in self._list
-            if item_key.lower() == get_header_key
-        ]
-
-        if not split_commas:
-            return values
-
-        split_values = []
-        for value in values:
-            split_values.extend([item.strip() for item in value.split(",")])
-        return split_values
-
-    def update(self, headers: HeaderTypes | None = None) -> None:  # type: ignore
-        headers = Headers(headers)
-        for key in headers.keys():
-            if key in self:
-                self.pop(key)
-        self._list.extend(headers._list)
-
-    def copy(self) -> Headers:
-        return Headers(self, encoding=self.encoding)
-
-    def __getitem__(self, key: str) -> str:
-        """
-        Return a single header value.
-
-        If there are multiple headers with the same key, then we concatenate
-        them with commas. See: https://tools.ietf.org/html/rfc7230#section-3.2.2
-        """
-        normalized_key = key.lower().encode(self.encoding)
-
-        items = [
-            header_value.decode(self.encoding)
-            for _, header_key, header_value in self._list
-            if header_key == normalized_key
-        ]
-
-        if items:
-            return ", ".join(items)
-
-        raise KeyError(key)
-
-    def __setitem__(self, key: str, value: str) -> None:
-        """
-        Set the header `key` to `value`, removing any duplicate entries.
-        Retains insertion order.
-        """
-        set_key = key.encode(self._encoding or "utf-8")
-        set_value = value.encode(self._encoding or "utf-8")
-        lookup_key = set_key.lower()
-
-        found_indexes = [
-            idx
-            for idx, (_, item_key, _) in enumerate(self._list)
-            if item_key == lookup_key
-        ]
-
-        for idx in reversed(found_indexes[1:]):
-            del self._list[idx]
-
-        if found_indexes:
-            idx = found_indexes[0]
-            self._list[idx] = (set_key, lookup_key, set_value)
-        else:
-            self._list.append((set_key, lookup_key, set_value))
-
-    def __delitem__(self, key: str) -> None:
-        """
-        Remove the header `key`.
-        """
-        del_key = key.lower().encode(self.encoding)
-
-        pop_indexes = [
-            idx
-            for idx, (_, item_key, _) in enumerate(self._list)
-            if item_key.lower() == del_key
-        ]
-
-        if not pop_indexes:
-            raise KeyError(key)
-
-        for idx in reversed(pop_indexes):
-            del self._list[idx]
-
-    def __contains__(self, key: typing.Any) -> bool:
-        header_key = key.lower().encode(self.encoding)
-        return header_key in [key for _, key, _ in self._list]
-
-    def __iter__(self) -> typing.Iterator[typing.Any]:
-        return iter(self.keys())
-
-    def __len__(self) -> int:
-        return len(self._list)
-
-    def __eq__(self, other: typing.Any) -> bool:
-        try:
-            other_headers = Headers(other)
-        except ValueError:
-            return False
-
-        self_list = [(key, value) for _, key, value in self._list]
-        other_list = [(key, value) for _, key, value in other_headers._list]
-        return sorted(self_list) == sorted(other_list)
-
-    def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-
-        encoding_str = ""
-        if self.encoding != "ascii":
-            encoding_str = f", encoding={self.encoding!r}"
-
-        as_list = list(_obfuscate_sensitive_headers(self.multi_items()))
-        as_dict = dict(as_list)
-
-        no_duplicate_keys = len(as_dict) == len(as_list)
-        if no_duplicate_keys:
-            return f"{class_name}({as_dict!r}{encoding_str})"
-        return f"{class_name}({as_list!r}{encoding_str})"
-
-
-class Request:
-    def __init__(
-        self,
-        method: str,
-        url: URL | str,
-        *,
-        params: QueryParamTypes | None = None,
-        headers: HeaderTypes | None = None,
-        cookies: CookieTypes | None = None,
-        content: RequestContent | None = None,
-        data: RequestData | None = None,
-        files: RequestFiles | None = None,
-        json: typing.Any | None = None,
-        stream: SyncByteStream | AsyncByteStream | None = None,
-        extensions: RequestExtensions | None = None,
-    ) -> None:
-        self.method = method.upper()
-        self.url = URL(url) if params is None else URL(url, params=params)
-        self.headers = Headers(headers)
-        self.extensions = {} if extensions is None else dict(extensions)
-
-        if cookies:
-            Cookies(cookies).set_cookie_header(self)
-
-        if stream is None:
-            content_type: str | None = self.headers.get("content-type")
-            headers, stream = encode_request(
-                content=content,
-                data=data,
-                files=files,
-                json=json,
-                boundary=get_multipart_boundary_from_content_type(
-                    content_type=content_type.encode(self.headers.encoding)
-                    if content_type
-                    else None
-                ),
-            )
-            self._prepare(headers)
-            self.stream = stream
-            # Load the request body, except for streaming content.
-            if isinstance(stream, ByteStream):
-                self.read()
-        else:
-            # There's an important distinction between `Request(content=...)`,
-            # and `Request(stream=...)`.
-            #
-            # Using `content=...` implies automatically populated `Host` and content
-            # headers, of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
-            #
-            # Using `stream=...` will not automatically include *any*
-            # auto-populated headers.
-            #
-            # As an end-user you don't really need `stream=...`. It's only
-            # useful when:
-            #
-            # * Preserving the request stream when copying requests, eg for redirects.
-            # * Creating request instances on the *server-side* of the transport API.
-            self.stream = stream
-
-    def _prepare(self, default_headers: dict[str, str]) -> None:
-        for key, value in default_headers.items():
-            # Ignore Transfer-Encoding if the Content-Length has been set explicitly.
-            if key.lower() == "transfer-encoding" and "Content-Length" in self.headers:
-                continue
-            self.headers.setdefault(key, value)
-
-        auto_headers: list[tuple[bytes, bytes]] = []
-
-        has_host = "Host" in self.headers
-        has_content_length = (
-            "Content-Length" in self.headers or "Transfer-Encoding" in self.headers
-        )
-
-        if not has_host and self.url.host:
-            auto_headers.append((b"Host", self.url.netloc))
-        if not has_content_length and self.method in ("POST", "PUT", "PATCH"):
-            auto_headers.append((b"Content-Length", b"0"))
-
-        self.headers = Headers(auto_headers + self.headers.raw)
-
-    @property
-    def content(self) -> bytes:
-        if not hasattr(self, "_content"):
-            raise RequestNotRead()
-        return self._content
-
-    def read(self) -> bytes:
-        """
-        Read and return the request content.
-        """
-        if not hasattr(self, "_content"):
-            assert isinstance(self.stream, typing.Iterable)
-            self._content = b"".join(self.stream)
-            if not isinstance(self.stream, ByteStream):
-                # If a streaming request has been read entirely into memory, then
-                # we can replace the stream with a raw bytes implementation,
-                # to ensure that any non-replayable streams can still be used.
-                self.stream = ByteStream(self._content)
-        return self._content
-
-    async def aread(self) -> bytes:
-        """
-        Read and return the request content.
-        """
-        if not hasattr(self, "_content"):
-            assert isinstance(self.stream, typing.AsyncIterable)
-            self._content = b"".join([part async for part in self.stream])
-            if not isinstance(self.stream, ByteStream):
-                # If a streaming request has been read entirely into memory, then
-                # we can replace the stream with a raw bytes implementation,
-                # to ensure that any non-replayable streams can still be used.
-                self.stream = ByteStream(self._content)
-        return self._content
-
-    def __repr__(self) -> str:
-        class_name = self.__class__.__name__
-        url = str(self.url)
-        return f"<{class_name}({self.method!r}, {url!r})>"
-
-    def __getstate__(self) -> dict[str, typing.Any]:
-        return {
-            name: value
-            for name, value in self.__dict__.items()
-            if name not in ["extensions", "stream"]
-        }
-
-    def __setstate__(self, state: dict[str, typing.Any]) -> None:
-        for name, value in state.items():
-            setattr(self, name, value)
-        self.extensions = {}
-        self.stream = UnattachedStream()
-
-
-class Response:
-    def __init__(
-        self,
-        status_code: int,
-        *,
-        headers: HeaderTypes | None = None,
-        content: ResponseContent | None = None,
-        text: str | None = None,
-        html: str | None = None,
-        json: typing.Any = None,
-        stream: SyncByteStream | AsyncByteStream | None = None,
-        request: Request | None = None,
-        extensions: ResponseExtensions | None = None,
-        history: list[Response] | None = None,
-        default_encoding: str | typing.Callable[[bytes], str] = "utf-8",
-    ) -> None:
-        self.status_code = status_code
-        self.headers = Headers(headers)
-
-        self._request: Request | None = request
-
-        # When follow_redirects=False and a redirect is received,
-        # the client will set `response.next_request`.
-        self.next_request: Request | None = None
-
-        self.extensions = {} if extensions is None else dict(extensions)
-        self.history = [] if history is None else list(history)
-
-        self.is_closed = False
-        self.is_stream_consumed = False
-
-        self.default_encoding = default_encoding
-
-        if stream is None:
-            headers, stream = encode_response(content, text, html, json)
-            self._prepare(headers)
-            self.stream = stream
-            if isinstance(stream, ByteStream):
-                # Load the response body, except for streaming content.
-                self.read()
-        else:
-            # There's an important distinction between `Response(content=...)`,
-            # and `Response(stream=...)`.
-            #
-            # Using `content=...` implies automatically populated content headers,
-            # of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
-            #
-            # Using `stream=...` will not automatically include any content headers.
-            #
-            # As an end-user you don't really need `stream=...`. It's only
-            # useful when creating response instances having received a stream
-            # from the transport API.
-            self.stream = stream
-
-        self._num_bytes_downloaded = 0
-
-    def _prepare(self, default_headers: dict[str, str]) -> None:
-        for key, value in default_headers.items():
-            # Ignore Transfer-Encoding if the Content-Length has been set explicitly.
-            if key.lower() == "transfer-encoding" and "content-length" in self.headers:
-                continue
-            self.headers.setdefault(key, value)
-
-    @property
-    def elapsed(self) -> datetime.timedelta:
-        """
-        Returns the time taken for the complete request/response
-        cycle to complete.
-        """
-        if not hasattr(self, "_elapsed"):
-            raise RuntimeError(
-                "'.elapsed' may only be accessed after the response "
-                "has been read or closed."
-            )
-        return self._elapsed
-
-    @elapsed.setter
-    def elapsed(self, elapsed: datetime.timedelta) -> None:
-        self._elapsed = elapsed
-
-    @property
-    def request(self) -> Request:
-        """
-        Returns the request instance associated to the current response.
-        """
-        if self._request is None:
-            raise RuntimeError(
-                "The request instance has not been set on this response."
-            )
-        return self._request
-
-    @request.setter
-    def request(self, value: Request) -> None:
-        self._request = value
-
-    @property
-    def http_version(self) -> str:
-        try:
-            http_version: bytes = self.extensions["http_version"]
-        except KeyError:
-            return "HTTP/1.1"
-        else:
-            return http_version.decode("ascii", errors="ignore")
-
-    @property
-    def reason_phrase(self) -> str:
-        try:
-            reason_phrase: bytes = self.extensions["reason_phrase"]
-        except KeyError:
-            return codes.get_reason_phrase(self.status_code)
-        else:
-            return reason_phrase.decode("ascii", errors="ignore")
-
-    @property
-    def url(self) -> URL:
-        """
-        Returns the URL for which the request was made.
-        """
-        return self.request.url
-
-    @property
-    def content(self) -> bytes:
-        if not hasattr(self, "_content"):
-            raise ResponseNotRead()
-        return self._content
-
-    @property
-    def text(self) -> str:
-        if not hasattr(self, "_text"):
-            content = self.content
-            if not content:
-                self._text = ""
-            else:
-                decoder = TextDecoder(encoding=self.encoding or "utf-8")
-                self._text = "".join([decoder.decode(self.content), decoder.flush()])
-        return self._text
-
-    @property
-    def encoding(self) -> str | None:
-        """
-        Return an encoding to use for decoding the byte content into text.
-        The priority for determining this is given by...
-
-        * `.encoding = <>` has been set explicitly.
-        * The encoding as specified by the charset parameter in the Content-Type header.
-        * The encoding as determined by `default_encoding`, which may either be
-          a string like "utf-8" indicating the encoding to use, or may be a callable
-          which enables charset autodetection.
-        """
-        if not hasattr(self, "_encoding"):
-            encoding = self.charset_encoding
-            if encoding is None or not _is_known_encoding(encoding):
-                if isinstance(self.default_encoding, str):
-                    encoding = self.default_encoding
-                elif hasattr(self, "_content"):
-                    encoding = self.default_encoding(self._content)
-            self._encoding = encoding or "utf-8"
-        return self._encoding
-
-    @encoding.setter
-    def encoding(self, value: str) -> None:
-        """
-        Set the encoding to use for decoding the byte content into text.
-
-        If the `text` attribute has been accessed, attempting to set the
-        encoding will throw a ValueError.
-        """
-        if hasattr(self, "_text"):
-            raise ValueError(
-                "Setting encoding after `text` has been accessed is not allowed."
-            )
-        self._encoding = value
-
-    @property
-    def charset_encoding(self) -> str | None:
-        """
-        Return the encoding, as specified by the Content-Type header.
-        """
-        content_type = self.headers.get("Content-Type")
-        if content_type is None:
-            return None
-
-        return _parse_content_type_charset(content_type)
-
-    def _get_content_decoder(self) -> ContentDecoder:
-        """
-        Returns a decoder instance which can be used to decode the raw byte
-        content, depending on the Content-Encoding used in the response.
-        """
-        if not hasattr(self, "_decoder"):
-            decoders: list[ContentDecoder] = []
-            values = self.headers.get_list("content-encoding", split_commas=True)
-            for value in values:
-                value = value.strip().lower()
-                try:
-                    decoder_cls = SUPPORTED_DECODERS[value]
-                    decoders.append(decoder_cls())
-                except KeyError:
-                    continue
-
-            if len(decoders) == 1:
-                self._decoder = decoders[0]
-            elif len(decoders) > 1:
-                self._decoder = MultiDecoder(children=decoders)
-            else:
-                self._decoder = IdentityDecoder()
-
-        return self._decoder
-
-    @property
-    def is_informational(self) -> bool:
-        """
-        A property which is `True` for 1xx status codes, `False` otherwise.
-        """
-        return codes.is_informational(self.status_code)
-
-    @property
-    def is_success(self) -> bool:
-        """
-        A property which is `True` for 2xx status codes, `False` otherwise.
-        """
-        return codes.is_success(self.status_code)
-
-    @property
-    def is_redirect(self) -> bool:
-        """
-        A property which is `True` for 3xx status codes, `False` otherwise.
-
-        Note that not all responses with a 3xx status code indicate a URL redirect.
-
-        Use `response.has_redirect_location` to determine responses with a properly
-        formed URL redirection.
-        """
-        return codes.is_redirect(self.status_code)
-
-    @property
-    def is_client_error(self) -> bool:
-        """
-        A property which is `True` for 4xx status codes, `False` otherwise.
-        """
-        return codes.is_client_error(self.status_code)
-
-    @property
-    def is_server_error(self) -> bool:
-        """
-        A property which is `True` for 5xx status codes, `False` otherwise.
-        """
-        return codes.is_server_error(self.status_code)
-
-    @property
-    def is_error(self) -> bool:
-        """
-        A property which is `True` for 4xx and 5xx status codes, `False` otherwise.
-        """
-        return codes.is_error(self.status_code)
-
-    @property
-    def has_redirect_location(self) -> bool:
-        """
-        Returns True for 3xx responses with a properly formed URL redirection,
-        `False` otherwise.
-        """
-        return (
-            self.status_code
-            in (
-                # 301 (Cacheable redirect. Method may change to GET.)
-                codes.MOVED_PERMANENTLY,
-                # 302 (Uncacheable redirect. Method may change to GET.)
-                codes.FOUND,
-                # 303 (Client should make a GET or HEAD request.)
-                codes.SEE_OTHER,
-                # 307 (Equiv. 302, but retain method)
-                codes.TEMPORARY_REDIRECT,
-                # 308 (Equiv. 301, but retain method)
-                codes.PERMANENT_REDIRECT,
-            )
-            and "Location" in self.headers
-        )
-
-    def raise_for_status(self) -> Response:
-        """
-        Raise the `HTTPStatusError` if one occurred.
-        """
-        request = self._request
-        if request is None:
-            raise RuntimeError(
-                "Cannot call `raise_for_status` as the request "
-                "instance has not been set on this response."
-            )
-
-        if self.is_success:
-            return self
-
-        if self.has_redirect_location:
-            message = (
-                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
-                "Redirect location: '{0.headers[location]}'\n"
-                "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}"
-            )
-        else:
-            message = (
-                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
-                "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}"
-            )
-
-        status_class = self.status_code // 100
-        error_types = {
-            1: "Informational response",
-            3: "Redirect response",
-            4: "Client error",
-            5: "Server error",
-        }
-        error_type = error_types.get(status_class, "Invalid status code")
-        message = message.format(self, error_type=error_type)
-        raise HTTPStatusError(message, request=request, response=self)
-
-    def json(self, **kwargs: typing.Any) -> typing.Any:
-        return jsonlib.loads(self.content, **kwargs)
-
-    @property
-    def cookies(self) -> Cookies:
-        if not hasattr(self, "_cookies"):
-            self._cookies = Cookies()
-            self._cookies.extract_cookies(self)
-        return self._cookies
-
-    @property
-    def links(self) -> dict[str | None, dict[str, str]]:
-        """
-        Returns the parsed header links of the response, if any
-        """
-        header = self.headers.get("link")
-        if header is None:
-            return {}
-
-        return {
-            (link.get("rel") or link.get("url")): link
-            for link in _parse_header_links(header)
-        }
-
-    @property
-    def num_bytes_downloaded(self) -> int:
-        return self._num_bytes_downloaded
-
-    def __repr__(self) -> str:
-        return f"<Response [{self.status_code} {self.reason_phrase}]>"
-
-    def __getstate__(self) -> dict[str, typing.Any]:
-        return {
-            name: value
-            for name, value in self.__dict__.items()
-            if name not in ["extensions", "stream", "is_closed", "_decoder"]
-        }
-
-    def __setstate__(self, state: dict[str, typing.Any]) -> None:
-        for name, value in state.items():
-            setattr(self, name, value)
-        self.is_closed = True
-        self.extensions = {}
-        self.stream = UnattachedStream()
-
-    def read(self) -> bytes:
-        """
-        Read and return the response content.
-        """
-        if not hasattr(self, "_content"):
-            self._content = b"".join(self.iter_bytes())
-        return self._content
-
-    def iter_bytes(self, chunk_size: int | None = None) -> typing.Iterator[bytes]:
-        """
-        A byte-iterator over the decoded response content.
-        This allows us to handle gzip, deflate, brotli, and zstd encoded responses.
-        """
-        if hasattr(self, "_content"):
-            chunk_size = len(self._content) if chunk_size is None else chunk_size
-            for i in range(0, len(self._content), max(chunk_size, 1)):
-                yield self._content[i : i + chunk_size]
-        else:
-            decoder = self._get_content_decoder()
-            chunker = ByteChunker(chunk_size=chunk_size)
-            with request_context(request=self._request):
-                for raw_bytes in self.iter_raw():
-                    decoded = decoder.decode(raw_bytes)
-                    for chunk in chunker.decode(decoded):
-                        yield chunk
-                decoded = decoder.flush()
-                for chunk in chunker.decode(decoded):
-                    yield chunk  # pragma: no cover
-                for chunk in chunker.flush():
-                    yield chunk
-
-    def iter_text(self, chunk_size: int | None = None) -> typing.Iterator[str]:
-        """
-        A str-iterator over the decoded response content
-        that handles both gzip, deflate, etc but also detects the content's
-        string encoding.
-        """
-        decoder = TextDecoder(encoding=self.encoding or "utf-8")
-        chunker = TextChunker(chunk_size=chunk_size)
-        with request_context(request=self._request):
-            for byte_content in self.iter_bytes():
-                text_content = decoder.decode(byte_content)
-                for chunk in chunker.decode(text_content):
-                    yield chunk
-            text_content = decoder.flush()
-            for chunk in chunker.decode(text_content):
-                yield chunk  # pragma: no cover
-            for chunk in chunker.flush():
-                yield chunk
-
-    def iter_lines(self) -> typing.Iterator[str]:
-        decoder = LineDecoder()
-        with request_context(request=self._request):
-            for text in self.iter_text():
-                for line in decoder.decode(text):
-                    yield line
-            for line in decoder.flush():
-                yield line
-
-    def iter_raw(self, chunk_size: int | None = None) -> typing.Iterator[bytes]:
-        """
-        A byte-iterator over the raw response content.
-        """
-        if self.is_stream_consumed:
-            raise StreamConsumed()
-        if self.is_closed:
-            raise StreamClosed()
-        if not isinstance(self.stream, SyncByteStream):
-            raise RuntimeError("Attempted to call a sync iterator on an async stream.")
-
-        self.is_stream_consumed = True
-        self._num_bytes_downloaded = 0
-        chunker = ByteChunker(chunk_size=chunk_size)
-
-        with request_context(request=self._request):
-            for raw_stream_bytes in self.stream:
-                self._num_bytes_downloaded += len(raw_stream_bytes)
-                for chunk in chunker.decode(raw_stream_bytes):
-                    yield chunk
-
-        for chunk in chunker.flush():
-            yield chunk
-
-        self.close()
-
-    def close(self) -> None:
-        """
-        Close the response and release the connection.
-        Automatically called if the response body is read to completion.
-        """
-        if not isinstance(self.stream, SyncByteStream):
-            raise RuntimeError("Attempted to call an sync close on an async stream.")
-
-        if not self.is_closed:
-            self.is_closed = True
-            with request_context(request=self._request):
-                self.stream.close()
-
-    async def aread(self) -> bytes:
-        """
-        Read and return the response content.
-        """
-        if not hasattr(self, "_content"):
-            self._content = b"".join([part async for part in self.aiter_bytes()])
-        return self._content
-
-    async def aiter_bytes(
-        self, chunk_size: int | None = None
-    ) -> typing.AsyncIterator[bytes]:
-        """
-        A byte-iterator over the decoded response content.
-        This allows us to handle gzip, deflate, brotli, and zstd encoded responses.
-        """
-        if hasattr(self, "_content"):
-            chunk_size = len(self._content) if chunk_size is None else chunk_size
-            for i in range(0, len(self._content), max(chunk_size, 1)):
-                yield self._content[i : i + chunk_size]
-        else:
-            decoder = self._get_content_decoder()
-            chunker = ByteChunker(chunk_size=chunk_size)
-            with request_context(request=self._request):
-                async for raw_bytes in self.aiter_raw():
-                    decoded = decoder.decode(raw_bytes)
-                    for chunk in chunker.decode(decoded):
-                        yield chunk
-                decoded = decoder.flush()
-                for chunk in chunker.decode(decoded):
-                    yield chunk  # pragma: no cover
-                for chunk in chunker.flush():
-                    yield chunk
-
-    async def aiter_text(
-        self, chunk_size: int | None = None
-    ) -> typing.AsyncIterator[str]:
-        """
-        A str-iterator over the decoded response content
-        that handles both gzip, deflate, etc but also detects the content's
-        string encoding.
-        """
-        decoder = TextDecoder(encoding=self.encoding or "utf-8")
-        chunker = TextChunker(chunk_size=chunk_size)
-        with request_context(request=self._request):
-            async for byte_content in self.aiter_bytes():
-                text_content = decoder.decode(byte_content)
-                for chunk in chunker.decode(text_content):
-                    yield chunk
-            text_content = decoder.flush()
-            for chunk in chunker.decode(text_content):
-                yield chunk  # pragma: no cover
-            for chunk in chunker.flush():
-                yield chunk
-
-    async def aiter_lines(self) -> typing.AsyncIterator[str]:
-        decoder = LineDecoder()
-        with request_context(request=self._request):
-            async for text in self.aiter_text():
-                for line in decoder.decode(text):
-                    yield line
-            for line in decoder.flush():
-                yield line
-
-    async def aiter_raw(
-        self, chunk_size: int | None = None
-    ) -> typing.AsyncIterator[bytes]:
-        """
-        A byte-iterator over the raw response content.
-        """
-        if self.is_stream_consumed:
-            raise StreamConsumed()
-        if self.is_closed:
-            raise StreamClosed()
-        if not isinstance(self.stream, AsyncByteStream):
-            raise RuntimeError("Attempted to call an async iterator on an sync stream.")
-
-        self.is_stream_consumed = True
-        self._num_bytes_downloaded = 0
-        chunker = ByteChunker(chunk_size=chunk_size)
-
-        with request_context(request=self._request):
-            async for raw_stream_bytes in self.stream:
-                self._num_bytes_downloaded += len(raw_stream_bytes)
-                for chunk in chunker.decode(raw_stream_bytes):
-                    yield chunk
-
-        for chunk in chunker.flush():
-            yield chunk
-
-        await self.aclose()
-
-    async def aclose(self) -> None:
-        """
-        Close the response and release the connection.
-        Automatically called if the response body is read to completion.
-        """
-        if not isinstance(self.stream, AsyncByteStream):
-            raise RuntimeError("Attempted to call an async close on an sync stream.")
-
-        if not self.is_closed:
-            self.is_closed = True
-            with request_context(request=self._request):
-                await self.stream.aclose()
-
-
-class Cookies(typing.MutableMapping[str, str]):
-    """
-    HTTP Cookies, as a mutable mapping.
-    """
-
-    def __init__(self, cookies: CookieTypes | None = None) -> None:
-        if cookies is None or isinstance(cookies, dict):
-            self.jar = CookieJar()
-            if isinstance(cookies, dict):
-                for key, value in cookies.items():
-                    self.set(key, value)
-        elif isinstance(cookies, list):
-            self.jar = CookieJar()
-            for key, value in cookies:
-                self.set(key, value)
-        elif isinstance(cookies, Cookies):
-            self.jar = CookieJar()
-            for cookie in cookies.jar:
-                self.jar.set_cookie(cookie)
-        else:
-            self.jar = cookies
-
-    def extract_cookies(self, response: Response) -> None:
-        """
-        Loads any cookies based on the response `Set-Cookie` headers.
-        """
-        urllib_response = self._CookieCompatResponse(response)
-        urllib_request = self._CookieCompatRequest(response.request)
-
-        self.jar.extract_cookies(urllib_response, urllib_request)  # type: ignore
-
-    def set_cookie_header(self, request: Request) -> None:
-        """
-        Sets an appropriate 'Cookie:' HTTP header on the `Request`.
-        """
-        urllib_request = self._CookieCompatRequest(request)
-        self.jar.add_cookie_header(urllib_request)
-
-    def set(self, name: str, value: str, domain: str = "", path: str = "/") -> None:
-        """
-        Set a cookie value by name. May optionally include domain and path.
-        """
-        kwargs = {
-            "version": 0,
-            "name": name,
-            "value": value,
-            "port": None,
-            "port_specified": False,
-            "domain": domain,
-            "domain_specified": bool(domain),
-            "domain_initial_dot": domain.startswith("."),
-            "path": path,
-            "path_specified": bool(path),
-            "secure": False,
-            "expires": None,
-            "discard": True,
-            "comment": None,
-            "comment_url": None,
-            "rest": {"HttpOnly": None},
-            "rfc2109": False,
-        }
-        cookie = Cookie(**kwargs)  # type: ignore
-        self.jar.set_cookie(cookie)
-
-    def get(  # type: ignore
-        self,
-        name: str,
-        default: str | None = None,
-        domain: str | None = None,
-        path: str | None = None,
-    ) -> str | None:
-        """
-        Get a cookie by name. May optionally include domain and path
-        in order to specify exactly which cookie to retrieve.
-        """
-        value = None
-        for cookie in self.jar:
-            if cookie.name == name:
-                if domain is None or cookie.domain == domain:
-                    if path is None or cookie.path == path:
-                        if value is not None:
-                            message = f"Multiple cookies exist with name={name}"
-                            raise CookieConflict(message)
-                        value = cookie.value
-
-        if value is None:
-            return default
-        return value
-
-    def delete(
-        self,
-        name: str,
-        domain: str | None = None,
-        path: str | None = None,
-    ) -> None:
-        """
-        Delete a cookie by name. May optionally include domain and path
-        in order to specify exactly which cookie to delete.
-        """
-        if domain is not None and path is not None:
-            return self.jar.clear(domain, path, name)
-
-        remove = [
-            cookie
-            for cookie in self.jar
-            if cookie.name == name
-            and (domain is None or cookie.domain == domain)
-            and (path is None or cookie.path == path)
-        ]
-
-        for cookie in remove:
-            self.jar.clear(cookie.domain, cookie.path, cookie.name)
-
-    def clear(self, domain: str | None = None, path: str | None = None) -> None:
-        """
-        Delete all cookies. Optionally include a domain and path in
-        order to only delete a subset of all the cookies.
-        """
-        args = []
-        if domain is not None:
-            args.append(domain)
-        if path is not None:
-            assert domain is not None
-            args.append(path)
-        self.jar.clear(*args)
-
-    def update(self, cookies: CookieTypes | None = None) -> None:  # type: ignore
-        cookies = Cookies(cookies)
-        for cookie in cookies.jar:
-            self.jar.set_cookie(cookie)
-
-    def __setitem__(self, name: str, value: str) -> None:
-        return self.set(name, value)
-
-    def __getitem__(self, name: str) -> str:
-        value = self.get(name)
-        if value is None:
-            raise KeyError(name)
-        return value
-
-    def __delitem__(self, name: str) -> None:
-        return self.delete(name)
-
-    def __len__(self) -> int:
-        return len(self.jar)
-
-    def __iter__(self) -> typing.Iterator[str]:
-        return (cookie.name for cookie in self.jar)
-
-    def __bool__(self) -> bool:
-        for _ in self.jar:
-            return True
-        return False
-
-    def __repr__(self) -> str:
-        cookies_repr = ", ".join(
-            [
-                f"<Cookie {cookie.name}={cookie.value} for {cookie.domain} />"
-                for cookie in self.jar
-            ]
-        )
-
-        return f"<Cookies[{cookies_repr}]>"
-
-    class _CookieCompatRequest(urllib.request.Request):
-        """
-        Wraps a `Request` instance up in a compatibility interface suitable
-        for use with `CookieJar` operations.
-        """
-
-        def __init__(self, request: Request) -> None:
-            super().__init__(
-                url=str(request.url),
-                headers=dict(request.headers),
-                method=request.method,
-            )
-            self.request = request
-
-        def add_unredirected_header(self, key: str, value: str) -> None:
-            super().add_unredirected_header(key, value)
-            self.request.headers[key] = value
-
-    class _CookieCompatResponse:
-        """
-        Wraps a `Request` instance up in a compatibility interface suitable
-        for use with `CookieJar` operations.
-        """
-
-        def __init__(self, response: Response) -> None:
-            self.response = response
-
-        def info(self) -> email.message.Message:
-            info = email.message.Message()
-            for key, value in self.response.headers.multi_items():
-                # Note that setting `info[key]` here is an "append" operation,
-                # not a "replace" operation.
-                # https://docs.python.org/3/library/email.compat32-message.html#email.message.Message.__setitem__
-                info[key] = value
-            return info

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_multipart.py

@@ -1,300 +0,0 @@
-from __future__ import annotations
-
-import io
-import mimetypes
-import os
-import re
-import typing
-from pathlib import Path
-
-from ._types import (
-    AsyncByteStream,
-    FileContent,
-    FileTypes,
-    RequestData,
-    RequestFiles,
-    SyncByteStream,
-)
-from ._utils import (
-    peek_filelike_length,
-    primitive_value_to_str,
-    to_bytes,
-)
-
-_HTML5_FORM_ENCODING_REPLACEMENTS = {'"': "%22", "\\": "\\\\"}
-_HTML5_FORM_ENCODING_REPLACEMENTS.update(
-    {chr(c): "%{:02X}".format(c) for c in range(0x1F + 1) if c != 0x1B}
-)
-_HTML5_FORM_ENCODING_RE = re.compile(
-    r"|".join([re.escape(c) for c in _HTML5_FORM_ENCODING_REPLACEMENTS.keys()])
-)
-
-
-def _format_form_param(name: str, value: str) -> bytes:
-    """
-    Encode a name/value pair within a multipart form.
-    """
-
-    def replacer(match: typing.Match[str]) -> str:
-        return _HTML5_FORM_ENCODING_REPLACEMENTS[match.group(0)]
-
-    value = _HTML5_FORM_ENCODING_RE.sub(replacer, value)
-    return f'{name}="{value}"'.encode()
-
-
-def _guess_content_type(filename: str | None) -> str | None:
-    """
-    Guesses the mimetype based on a filename. Defaults to `application/octet-stream`.
-
-    Returns `None` if `filename` is `None` or empty.
-    """
-    if filename:
-        return mimetypes.guess_type(filename)[0] or "application/octet-stream"
-    return None
-
-
-def get_multipart_boundary_from_content_type(
-    content_type: bytes | None,
-) -> bytes | None:
-    if not content_type or not content_type.startswith(b"multipart/form-data"):
-        return None
-    # parse boundary according to
-    # https://www.rfc-editor.org/rfc/rfc2046#section-5.1.1
-    if b";" in content_type:
-        for section in content_type.split(b";"):
-            if section.strip().lower().startswith(b"boundary="):
-                return section.strip()[len(b"boundary=") :].strip(b'"')
-    return None
-
-
-class DataField:
-    """
-    A single form field item, within a multipart form field.
-    """
-
-    def __init__(self, name: str, value: str | bytes | int | float | None) -> None:
-        if not isinstance(name, str):
-            raise TypeError(
-                f"Invalid type for name. Expected str, got {type(name)}: {name!r}"
-            )
-        if value is not None and not isinstance(value, (str, bytes, int, float)):
-            raise TypeError(
-                "Invalid type for value. Expected primitive type,"
-                f" got {type(value)}: {value!r}"
-            )
-        self.name = name
-        self.value: str | bytes = (
-            value if isinstance(value, bytes) else primitive_value_to_str(value)
-        )
-
-    def render_headers(self) -> bytes:
-        if not hasattr(self, "_headers"):
-            name = _format_form_param("name", self.name)
-            self._headers = b"".join(
-                [b"Content-Disposition: form-data; ", name, b"\r\n\r\n"]
-            )
-
-        return self._headers
-
-    def render_data(self) -> bytes:
-        if not hasattr(self, "_data"):
-            self._data = to_bytes(self.value)
-
-        return self._data
-
-    def get_length(self) -> int:
-        headers = self.render_headers()
-        data = self.render_data()
-        return len(headers) + len(data)
-
-    def render(self) -> typing.Iterator[bytes]:
-        yield self.render_headers()
-        yield self.render_data()
-
-
-class FileField:
-    """
-    A single file field item, within a multipart form field.
-    """
-
-    CHUNK_SIZE = 64 * 1024
-
-    def __init__(self, name: str, value: FileTypes) -> None:
-        self.name = name
-
-        fileobj: FileContent
-
-        headers: dict[str, str] = {}
-        content_type: str | None = None
-
-        # This large tuple based API largely mirror's requests' API
-        # It would be good to think of better APIs for this that we could
-        # include in httpx 2.0 since variable length tuples(especially of 4 elements)
-        # are quite unwieldly
-        if isinstance(value, tuple):
-            if len(value) == 2:
-                # neither the 3rd parameter (content_type) nor the 4th (headers)
-                # was included
-                filename, fileobj = value
-            elif len(value) == 3:
-                filename, fileobj, content_type = value
-            else:
-                # all 4 parameters included
-                filename, fileobj, content_type, headers = value  # type: ignore
-        else:
-            filename = Path(str(getattr(value, "name", "upload"))).name
-            fileobj = value
-
-        if content_type is None:
-            content_type = _guess_content_type(filename)
-
-        has_content_type_header = any("content-type" in key.lower() for key in headers)
-        if content_type is not None and not has_content_type_header:
-            # note that unlike requests, we ignore the content_type provided in the 3rd
-            # tuple element if it is also included in the headers requests does
-            # the opposite (it overwrites the headerwith the 3rd tuple element)
-            headers["Content-Type"] = content_type
-
-        if isinstance(fileobj, io.StringIO):
-            raise TypeError(
-                "Multipart file uploads require 'io.BytesIO', not 'io.StringIO'."
-            )
-        if isinstance(fileobj, io.TextIOBase):
-            raise TypeError(
-                "Multipart file uploads must be opened in binary mode, not text mode."
-            )
-
-        self.filename = filename
-        self.file = fileobj
-        self.headers = headers
-
-    def get_length(self) -> int | None:
-        headers = self.render_headers()
-
-        if isinstance(self.file, (str, bytes)):
-            return len(headers) + len(to_bytes(self.file))
-
-        file_length = peek_filelike_length(self.file)
-
-        # If we can't determine the filesize without reading it into memory,
-        # then return `None` here, to indicate an unknown file length.
-        if file_length is None:
-            return None
-
-        return len(headers) + file_length
-
-    def render_headers(self) -> bytes:
-        if not hasattr(self, "_headers"):
-            parts = [
-                b"Content-Disposition: form-data; ",
-                _format_form_param("name", self.name),
-            ]
-            if self.filename:
-                filename = _format_form_param("filename", self.filename)
-                parts.extend([b"; ", filename])
-            for header_name, header_value in self.headers.items():
-                key, val = f"\r\n{header_name}: ".encode(), header_value.encode()
-                parts.extend([key, val])
-            parts.append(b"\r\n\r\n")
-            self._headers = b"".join(parts)
-
-        return self._headers
-
-    def render_data(self) -> typing.Iterator[bytes]:
-        if isinstance(self.file, (str, bytes)):
-            yield to_bytes(self.file)
-            return
-
-        if hasattr(self.file, "seek"):
-            try:
-                self.file.seek(0)
-            except io.UnsupportedOperation:
-                pass
-
-        chunk = self.file.read(self.CHUNK_SIZE)
-        while chunk:
-            yield to_bytes(chunk)
-            chunk = self.file.read(self.CHUNK_SIZE)
-
-    def render(self) -> typing.Iterator[bytes]:
-        yield self.render_headers()
-        yield from self.render_data()
-
-
-class MultipartStream(SyncByteStream, AsyncByteStream):
-    """
-    Request content as streaming multipart encoded form data.
-    """
-
-    def __init__(
-        self,
-        data: RequestData,
-        files: RequestFiles,
-        boundary: bytes | None = None,
-    ) -> None:
-        if boundary is None:
-            boundary = os.urandom(16).hex().encode("ascii")
-
-        self.boundary = boundary
-        self.content_type = "multipart/form-data; boundary=%s" % boundary.decode(
-            "ascii"
-        )
-        self.fields = list(self._iter_fields(data, files))
-
-    def _iter_fields(
-        self, data: RequestData, files: RequestFiles
-    ) -> typing.Iterator[FileField | DataField]:
-        for name, value in data.items():
-            if isinstance(value, (tuple, list)):
-                for item in value:
-                    yield DataField(name=name, value=item)
-            else:
-                yield DataField(name=name, value=value)
-
-        file_items = files.items() if isinstance(files, typing.Mapping) else files
-        for name, value in file_items:
-            yield FileField(name=name, value=value)
-
-    def iter_chunks(self) -> typing.Iterator[bytes]:
-        for field in self.fields:
-            yield b"--%s\r\n" % self.boundary
-            yield from field.render()
-            yield b"\r\n"
-        yield b"--%s--\r\n" % self.boundary
-
-    def get_content_length(self) -> int | None:
-        """
-        Return the length of the multipart encoded content, or `None` if
-        any of the files have a length that cannot be determined upfront.
-        """
-        boundary_length = len(self.boundary)
-        length = 0
-
-        for field in self.fields:
-            field_length = field.get_length()
-            if field_length is None:
-                return None
-
-            length += 2 + boundary_length + 2  # b"--{boundary}\r\n"
-            length += field_length
-            length += 2  # b"\r\n"
-
-        length += 2 + boundary_length + 4  # b"--{boundary}--\r\n"
-        return length
-
-    # Content stream interface.
-
-    def get_headers(self) -> dict[str, str]:
-        content_length = self.get_content_length()
-        content_type = self.content_type
-        if content_length is None:
-            return {"Transfer-Encoding": "chunked", "Content-Type": content_type}
-        return {"Content-Length": str(content_length), "Content-Type": content_type}
-
-    def __iter__(self) -> typing.Iterator[bytes]:
-        for chunk in self.iter_chunks():
-            yield chunk
-
-    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
-        for chunk in self.iter_chunks():
-            yield chunk

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_status_codes.py

@@ -1,162 +0,0 @@
-from __future__ import annotations
-
-from enum import IntEnum
-
-__all__ = ["codes"]
-
-
-class codes(IntEnum):
-    """HTTP status codes and reason phrases
-
-    Status codes from the following RFCs are all observed:
-
-        * RFC 7231: Hypertext Transfer Protocol (HTTP/1.1), obsoletes 2616
-        * RFC 6585: Additional HTTP Status Codes
-        * RFC 3229: Delta encoding in HTTP
-        * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518
-        * RFC 5842: Binding Extensions to WebDAV
-        * RFC 7238: Permanent Redirect
-        * RFC 2295: Transparent Content Negotiation in HTTP
-        * RFC 2774: An HTTP Extension Framework
-        * RFC 7540: Hypertext Transfer Protocol Version 2 (HTTP/2)
-        * RFC 2324: Hyper Text Coffee Pot Control Protocol (HTCPCP/1.0)
-        * RFC 7725: An HTTP Status Code to Report Legal Obstacles
-        * RFC 8297: An HTTP Status Code for Indicating Hints
-        * RFC 8470: Using Early Data in HTTP
-    """
-
-    def __new__(cls, value: int, phrase: str = "") -> codes:
-        obj = int.__new__(cls, value)
-        obj._value_ = value
-
-        obj.phrase = phrase  # type: ignore[attr-defined]
-        return obj
-
-    def __str__(self) -> str:
-        return str(self.value)
-
-    @classmethod
-    def get_reason_phrase(cls, value: int) -> str:
-        try:
-            return codes(value).phrase  # type: ignore
-        except ValueError:
-            return ""
-
-    @classmethod
-    def is_informational(cls, value: int) -> bool:
-        """
-        Returns `True` for 1xx status codes, `False` otherwise.
-        """
-        return 100 <= value <= 199
-
-    @classmethod
-    def is_success(cls, value: int) -> bool:
-        """
-        Returns `True` for 2xx status codes, `False` otherwise.
-        """
-        return 200 <= value <= 299
-
-    @classmethod
-    def is_redirect(cls, value: int) -> bool:
-        """
-        Returns `True` for 3xx status codes, `False` otherwise.
-        """
-        return 300 <= value <= 399
-
-    @classmethod
-    def is_client_error(cls, value: int) -> bool:
-        """
-        Returns `True` for 4xx status codes, `False` otherwise.
-        """
-        return 400 <= value <= 499
-
-    @classmethod
-    def is_server_error(cls, value: int) -> bool:
-        """
-        Returns `True` for 5xx status codes, `False` otherwise.
-        """
-        return 500 <= value <= 599
-
-    @classmethod
-    def is_error(cls, value: int) -> bool:
-        """
-        Returns `True` for 4xx or 5xx status codes, `False` otherwise.
-        """
-        return 400 <= value <= 599
-
-    # informational
-    CONTINUE = 100, "Continue"
-    SWITCHING_PROTOCOLS = 101, "Switching Protocols"
-    PROCESSING = 102, "Processing"
-    EARLY_HINTS = 103, "Early Hints"
-
-    # success
-    OK = 200, "OK"
-    CREATED = 201, "Created"
-    ACCEPTED = 202, "Accepted"
-    NON_AUTHORITATIVE_INFORMATION = 203, "Non-Authoritative Information"
-    NO_CONTENT = 204, "No Content"
-    RESET_CONTENT = 205, "Reset Content"
-    PARTIAL_CONTENT = 206, "Partial Content"
-    MULTI_STATUS = 207, "Multi-Status"
-    ALREADY_REPORTED = 208, "Already Reported"
-    IM_USED = 226, "IM Used"
-
-    # redirection
-    MULTIPLE_CHOICES = 300, "Multiple Choices"
-    MOVED_PERMANENTLY = 301, "Moved Permanently"
-    FOUND = 302, "Found"
-    SEE_OTHER = 303, "See Other"
-    NOT_MODIFIED = 304, "Not Modified"
-    USE_PROXY = 305, "Use Proxy"
-    TEMPORARY_REDIRECT = 307, "Temporary Redirect"
-    PERMANENT_REDIRECT = 308, "Permanent Redirect"
-
-    # client error
-    BAD_REQUEST = 400, "Bad Request"
-    UNAUTHORIZED = 401, "Unauthorized"
-    PAYMENT_REQUIRED = 402, "Payment Required"
-    FORBIDDEN = 403, "Forbidden"
-    NOT_FOUND = 404, "Not Found"
-    METHOD_NOT_ALLOWED = 405, "Method Not Allowed"
-    NOT_ACCEPTABLE = 406, "Not Acceptable"
-    PROXY_AUTHENTICATION_REQUIRED = 407, "Proxy Authentication Required"
-    REQUEST_TIMEOUT = 408, "Request Timeout"
-    CONFLICT = 409, "Conflict"
-    GONE = 410, "Gone"
-    LENGTH_REQUIRED = 411, "Length Required"
-    PRECONDITION_FAILED = 412, "Precondition Failed"
-    REQUEST_ENTITY_TOO_LARGE = 413, "Request Entity Too Large"
-    REQUEST_URI_TOO_LONG = 414, "Request-URI Too Long"
-    UNSUPPORTED_MEDIA_TYPE = 415, "Unsupported Media Type"
-    REQUESTED_RANGE_NOT_SATISFIABLE = 416, "Requested Range Not Satisfiable"
-    EXPECTATION_FAILED = 417, "Expectation Failed"
-    IM_A_TEAPOT = 418, "I'm a teapot"
-    MISDIRECTED_REQUEST = 421, "Misdirected Request"
-    UNPROCESSABLE_ENTITY = 422, "Unprocessable Entity"
-    LOCKED = 423, "Locked"
-    FAILED_DEPENDENCY = 424, "Failed Dependency"
-    TOO_EARLY = 425, "Too Early"
-    UPGRADE_REQUIRED = 426, "Upgrade Required"
-    PRECONDITION_REQUIRED = 428, "Precondition Required"
-    TOO_MANY_REQUESTS = 429, "Too Many Requests"
-    REQUEST_HEADER_FIELDS_TOO_LARGE = 431, "Request Header Fields Too Large"
-    UNAVAILABLE_FOR_LEGAL_REASONS = 451, "Unavailable For Legal Reasons"
-
-    # server errors
-    INTERNAL_SERVER_ERROR = 500, "Internal Server Error"
-    NOT_IMPLEMENTED = 501, "Not Implemented"
-    BAD_GATEWAY = 502, "Bad Gateway"
-    SERVICE_UNAVAILABLE = 503, "Service Unavailable"
-    GATEWAY_TIMEOUT = 504, "Gateway Timeout"
-    HTTP_VERSION_NOT_SUPPORTED = 505, "HTTP Version Not Supported"
-    VARIANT_ALSO_NEGOTIATES = 506, "Variant Also Negotiates"
-    INSUFFICIENT_STORAGE = 507, "Insufficient Storage"
-    LOOP_DETECTED = 508, "Loop Detected"
-    NOT_EXTENDED = 510, "Not Extended"
-    NETWORK_AUTHENTICATION_REQUIRED = 511, "Network Authentication Required"
-
-
-# Include lower-case styles for `requests` compatibility.
-for code in codes:
-    setattr(codes, code._name_.lower(), int(code))

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_transports/__init__.py

@@ -1,15 +0,0 @@
-from .asgi import *
-from .base import *
-from .default import *
-from .mock import *
-from .wsgi import *
-
-__all__ = [
-    "ASGITransport",
-    "AsyncBaseTransport",
-    "BaseTransport",
-    "AsyncHTTPTransport",
-    "HTTPTransport",
-    "MockTransport",
-    "WSGITransport",
-]

emissary-ml/llm-scripts/fine-tuning/llama3/venv/lib/python3.10/site-packages/httpx/_transports/asgi.py

@@ -1,187 +0,0 @@
-from __future__ import annotations
-
-import typing
-
-from .._models import Request, Response
-from .._types import AsyncByteStream
-from .base import AsyncBaseTransport
-
-if typing.TYPE_CHECKING:  # pragma: no cover
-    import asyncio
-
-    import trio
-
-    Event = typing.Union[asyncio.Event, trio.Event]
-
-
-_Message = typing.MutableMapping[str, typing.Any]
-_Receive = typing.Callable[[], typing.Awaitable[_Message]]
-_Send = typing.Callable[
-    [typing.MutableMapping[str, typing.Any]], typing.Awaitable[None]
-]
-_ASGIApp = typing.Callable[
-    [typing.MutableMapping[str, typing.Any], _Receive, _Send], typing.Awaitable[None]
-]
-
-__all__ = ["ASGITransport"]
-
-
-def is_running_trio() -> bool:
-    try:
-        # sniffio is a dependency of trio.
-
-        # See https://github.com/python-trio/trio/issues/2802
-        import sniffio
-
-        if sniffio.current_async_library() == "trio":
-            return True
-    except ImportError:  # pragma: nocover
-        pass
-
-    return False
-
-
-def create_event() -> Event:
-    if is_running_trio():
-        import trio
-
-        return trio.Event()
-
-    import asyncio
-
-    return asyncio.Event()
-
-
-class ASGIResponseStream(AsyncByteStream):
-    def __init__(self, body: list[bytes]) -> None:
-        self._body = body
-
-    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
-        yield b"".join(self._body)
-
-
-class ASGITransport(AsyncBaseTransport):
-    """
-    A custom AsyncTransport that handles sending requests directly to an ASGI app.
-
-    ```python
-    transport = httpx.ASGITransport(
-        app=app,
-        root_path="/submount",
-        client=("1.2.3.4", 123)
-    )
-    client = httpx.AsyncClient(transport=transport)
-    ```
-
-    Arguments:
-
-    * `app` - The ASGI application.
-    * `raise_app_exceptions` - Boolean indicating if exceptions in the application
-       should be raised. Default to `True`. Can be set to `False` for use cases
-       such as testing the content of a client 500 response.
-    * `root_path` - The root path on which the ASGI application should be mounted.
-    * `client` - A two-tuple indicating the client IP and port of incoming requests.
-    ```
-    """
-
-    def __init__(
-        self,
-        app: _ASGIApp,
-        raise_app_exceptions: bool = True,
-        root_path: str = "",
-        client: tuple[str, int] = ("127.0.0.1", 123),
-    ) -> None:
-        self.app = app
-        self.raise_app_exceptions = raise_app_exceptions
-        self.root_path = root_path
-        self.client = client
-
-    async def handle_async_request(
-        self,
-        request: Request,
-    ) -> Response:
-        assert isinstance(request.stream, AsyncByteStream)
-
-        # ASGI scope.
-        scope = {
-            "type": "http",
-            "asgi": {"version": "3.0"},
-            "http_version": "1.1",
-            "method": request.method,
-            "headers": [(k.lower(), v) for (k, v) in request.headers.raw],
-            "scheme": request.url.scheme,
-            "path": request.url.path,
-            "raw_path": request.url.raw_path.split(b"?")[0],
-            "query_string": request.url.query,
-            "server": (request.url.host, request.url.port),
-            "client": self.client,
-            "root_path": self.root_path,
-        }
-
-        # Request.
-        request_body_chunks = request.stream.__aiter__()
-        request_complete = False
-
-        # Response.
-        status_code = None
-        response_headers = None
-        body_parts = []
-        response_started = False
-        response_complete = create_event()
-
-        # ASGI callables.
-
-        async def receive() -> dict[str, typing.Any]:
-            nonlocal request_complete
-
-            if request_complete:
-                await response_complete.wait()
-                return {"type": "http.disconnect"}
-
-            try:
-                body = await request_body_chunks.__anext__()
-            except StopAsyncIteration:
-                request_complete = True
-                return {"type": "http.request", "body": b"", "more_body": False}
-            return {"type": "http.request", "body": body, "more_body": True}
-
-        async def send(message: typing.MutableMapping[str, typing.Any]) -> None:
-            nonlocal status_code, response_headers, response_started
-
-            if message["type"] == "http.response.start":
-                assert not response_started
-
-                status_code = message["status"]
-                response_headers = message.get("headers", [])
-                response_started = True
-
-            elif message["type"] == "http.response.body":
-                assert not response_complete.is_set()
-                body = message.get("body", b"")
-                more_body = message.get("more_body", False)
-
-                if body and request.method != "HEAD":
-                    body_parts.append(body)
-
-                if not more_body:
-                    response_complete.set()
-
-        try:
-            await self.app(scope, receive, send)
-        except Exception:  # noqa: PIE-786
-            if self.raise_app_exceptions:
-                raise
-
-            response_complete.set()
-            if status_code is None:
-                status_code = 500
-            if response_headers is None:
-                response_headers = {}
-
-        assert response_complete.is_set()
-        assert status_code is not None
-        assert response_headers is not None
-
-        stream = ASGIResponseStream(body_parts)
-
-        return Response(status_code, headers=response_headers, stream=stream)