Add files using upload-large-folder tool

server.py

@@ -0,0 +1,975 @@
+import os
+import sys
+import asyncio
+import traceback
+
+import nodes
+import folder_paths
+import execution
+import uuid
+import urllib
+import json
+import glob
+import struct
+import ssl
+import socket
+import ipaddress
+from PIL import Image, ImageOps
+from PIL.PngImagePlugin import PngInfo
+from io import BytesIO
+
+import aiohttp
+from aiohttp import web
+import logging
+
+import mimetypes
+from comfy.cli_args import args
+import comfy.utils
+import comfy.model_management
+from comfy_api import feature_flags
+import node_helpers
+from comfyui_version import __version__
+from app.frontend_management import FrontendManager
+
+from app.user_manager import UserManager
+from app.model_manager import ModelFileManager
+from app.custom_node_manager import CustomNodeManager
+from typing import Optional, Union
+from api_server.routes.internal.internal_routes import InternalRoutes
+from protocol import BinaryEventTypes
+
+async def send_socket_catch_exception(function, message):
+    try:
+        await function(message)
+    except (aiohttp.ClientError, aiohttp.ClientPayloadError, ConnectionResetError, BrokenPipeError, ConnectionError) as err:
+        logging.warning("send error: {}".format(err))
+
+@web.middleware
+async def cache_control(request: web.Request, handler):
+    response: web.Response = await handler(request)
+    if request.path.endswith('.js') or request.path.endswith('.css') or request.path.endswith('index.json'):
+        response.headers.setdefault('Cache-Control', 'no-cache')
+    return response
+
+
+@web.middleware
+async def compress_body(request: web.Request, handler):
+    accept_encoding = request.headers.get("Accept-Encoding", "")
+    response: web.Response = await handler(request)
+    if not isinstance(response, web.Response):
+        return response
+    if response.content_type not in ["application/json", "text/plain"]:
+        return response
+    if response.body and "gzip" in accept_encoding:
+        response.enable_compression()
+    return response
+
+
+def create_cors_middleware(allowed_origin: str):
+    @web.middleware
+    async def cors_middleware(request: web.Request, handler):
+        if request.method == "OPTIONS":
+            # Pre-flight request. Reply successfully:
+            response = web.Response()
+        else:
+            response = await handler(request)
+
+        response.headers['Access-Control-Allow-Origin'] = allowed_origin
+        response.headers['Access-Control-Allow-Methods'] = 'POST, GET, DELETE, PUT, OPTIONS'
+        response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
+        response.headers['Access-Control-Allow-Credentials'] = 'true'
+        return response
+
+    return cors_middleware
+
+def is_loopback(host):
+    if host is None:
+        return False
+    try:
+        if ipaddress.ip_address(host).is_loopback:
+            return True
+        else:
+            return False
+    except:
+        pass
+
+    loopback = False
+    for family in (socket.AF_INET, socket.AF_INET6):
+        try:
+            r = socket.getaddrinfo(host, None, family, socket.SOCK_STREAM)
+            for family, _, _, _, sockaddr in r:
+                if not ipaddress.ip_address(sockaddr[0]).is_loopback:
+                    return loopback
+                else:
+                    loopback = True
+        except socket.gaierror:
+            pass
+
+    return loopback
+
+
+def create_origin_only_middleware():
+    @web.middleware
+    async def origin_only_middleware(request: web.Request, handler):
+        #this code is used to prevent the case where a random website can queue comfy workflows by making a POST to 127.0.0.1 which browsers don't prevent for some dumb reason.
+        #in that case the Host and Origin hostnames won't match
+        #I know the proper fix would be to add a cookie but this should take care of the problem in the meantime
+        if 'Host' in request.headers and 'Origin' in request.headers:
+            host = request.headers['Host']
+            origin = request.headers['Origin']
+            host_domain = host.lower()
+            parsed = urllib.parse.urlparse(origin)
+            origin_domain = parsed.netloc.lower()
+            host_domain_parsed = urllib.parse.urlsplit('//' + host_domain)
+
+            #limit the check to when the host domain is localhost, this makes it slightly less safe but should still prevent the exploit
+            loopback = is_loopback(host_domain_parsed.hostname)
+
+            if parsed.port is None: #if origin doesn't have a port strip it from the host to handle weird browsers, same for host
+                host_domain = host_domain_parsed.hostname
+            if host_domain_parsed.port is None:
+                origin_domain = parsed.hostname
+
+            if loopback and host_domain is not None and origin_domain is not None and len(host_domain) > 0 and len(origin_domain) > 0:
+                if host_domain != origin_domain:
+                    logging.warning("WARNING: request with non matching host and origin {} != {}, returning 403".format(host_domain, origin_domain))
+                    return web.Response(status=403)
+
+        if request.method == "OPTIONS":
+            response = web.Response()
+        else:
+            response = await handler(request)
+
+        return response
+
+    return origin_only_middleware
+
+class PromptServer():
+    def __init__(self, loop):
+        PromptServer.instance = self
+
+        mimetypes.init()
+        mimetypes.add_type('application/javascript; charset=utf-8', '.js')
+        mimetypes.add_type('image/webp', '.webp')
+
+        self.user_manager = UserManager()
+        self.model_file_manager = ModelFileManager()
+        self.custom_node_manager = CustomNodeManager()
+        self.internal_routes = InternalRoutes(self)
+        self.supports = ["custom_nodes_from_web"]
+        self.prompt_queue = execution.PromptQueue(self)
+        self.loop = loop
+        self.messages = asyncio.Queue()
+        self.client_session:Optional[aiohttp.ClientSession] = None
+        self.number = 0
+
+        middlewares = [cache_control]
+        if args.enable_compress_response_body:
+            middlewares.append(compress_body)
+
+        if args.enable_cors_header:
+            middlewares.append(create_cors_middleware(args.enable_cors_header))
+        else:
+            middlewares.append(create_origin_only_middleware())
+
+        max_upload_size = round(args.max_upload_size * 1024 * 1024)
+        self.app = web.Application(client_max_size=max_upload_size, middlewares=middlewares)
+        self.sockets = dict()
+        self.sockets_metadata = dict()
+        self.web_root = (
+            FrontendManager.init_frontend(args.front_end_version)
+            if args.front_end_root is None
+            else args.front_end_root
+        )
+        logging.info(f"[Prompt Server] web root: {self.web_root}")
+        routes = web.RouteTableDef()
+        self.routes = routes
+        self.last_node_id = None
+        self.client_id = None
+
+        self.on_prompt_handlers = []
+
+        @routes.get('/ws')
+        async def websocket_handler(request):
+            ws = web.WebSocketResponse()
+            await ws.prepare(request)
+            sid = request.rel_url.query.get('clientId', '')
+            if sid:
+                # Reusing existing session, remove old
+                self.sockets.pop(sid, None)
+            else:
+                sid = uuid.uuid4().hex
+
+            # Store WebSocket for backward compatibility
+            self.sockets[sid] = ws
+            # Store metadata separately
+            self.sockets_metadata[sid] = {"feature_flags": {}}
+
+            try:
+                # Send initial state to the new client
+                await self.send("status", {"status": self.get_queue_info(), "sid": sid}, sid)
+                # On reconnect if we are the currently executing client send the current node
+                if self.client_id == sid and self.last_node_id is not None:
+                    await self.send("executing", { "node": self.last_node_id }, sid)
+
+                # Flag to track if we've received the first message
+                first_message = True
+
+                async for msg in ws:
+                    if msg.type == aiohttp.WSMsgType.ERROR:
+                        logging.warning('ws connection closed with exception %s' % ws.exception())
+                    elif msg.type == aiohttp.WSMsgType.TEXT:
+                        try:
+                            data = json.loads(msg.data)
+                            # Check if first message is feature flags
+                            if first_message and data.get("type") == "feature_flags":
+                                # Store client feature flags
+                                client_flags = data.get("data", {})
+                                self.sockets_metadata[sid]["feature_flags"] = client_flags
+
+                                # Send server feature flags in response
+                                await self.send(
+                                    "feature_flags",
+                                    feature_flags.get_server_features(),
+                                    sid,
+                                )
+
+                                logging.info(
+                                    f"Feature flags negotiated for client {sid}: {client_flags}"
+                                )
+                            first_message = False
+                        except json.JSONDecodeError:
+                            logging.warning(
+                                f"Invalid JSON received from client {sid}: {msg.data}"
+                            )
+                        except Exception as e:
+                            logging.error(f"Error processing WebSocket message: {e}")
+            finally:
+                self.sockets.pop(sid, None)
+                self.sockets_metadata.pop(sid, None)
+            return ws
+
+        @routes.get("/")
+        async def get_root(request):
+            response = web.FileResponse(os.path.join(self.web_root, "index.html"))
+            response.headers['Cache-Control'] = 'no-cache'
+            response.headers["Pragma"] = "no-cache"
+            response.headers["Expires"] = "0"
+            return response
+
+        @routes.get("/embeddings")
+        def get_embeddings(request):
+            embeddings = folder_paths.get_filename_list("embeddings")
+            return web.json_response(list(map(lambda a: os.path.splitext(a)[0], embeddings)))
+
+        @routes.get("/models")
+        def list_model_types(request):
+            model_types = list(folder_paths.folder_names_and_paths.keys())
+
+            return web.json_response(model_types)
+
+        @routes.get("/models/{folder}")
+        async def get_models(request):
+            folder = request.match_info.get("folder", None)
+            if not folder in folder_paths.folder_names_and_paths:
+                return web.Response(status=404)
+            files = folder_paths.get_filename_list(folder)
+            return web.json_response(files)
+
+        @routes.get("/extensions")
+        async def get_extensions(request):
+            files = glob.glob(os.path.join(
+                glob.escape(self.web_root), 'extensions/**/*.js'), recursive=True)
+
+            extensions = list(map(lambda f: "/" + os.path.relpath(f, self.web_root).replace("\\", "/"), files))
+
+            for name, dir in nodes.EXTENSION_WEB_DIRS.items():
+                files = glob.glob(os.path.join(glob.escape(dir), '**/*.js'), recursive=True)
+                extensions.extend(list(map(lambda f: "/extensions/" + urllib.parse.quote(
+                    name) + "/" + os.path.relpath(f, dir).replace("\\", "/"), files)))
+
+            return web.json_response(extensions)
+
+        def get_dir_by_type(dir_type):
+            if dir_type is None:
+                dir_type = "input"
+
+            if dir_type == "input":
+                type_dir = folder_paths.get_input_directory()
+            elif dir_type == "temp":
+                type_dir = folder_paths.get_temp_directory()
+            elif dir_type == "output":
+                type_dir = folder_paths.get_output_directory()
+
+            return type_dir, dir_type
+
+        def compare_image_hash(filepath, image):
+            hasher = node_helpers.hasher()
+
+            # function to compare hashes of two images to see if it already exists, fix to #3465
+            if os.path.exists(filepath):
+                a = hasher()
+                b = hasher()
+                with open(filepath, "rb") as f:
+                    a.update(f.read())
+                    b.update(image.file.read())
+                    image.file.seek(0)
+                return a.hexdigest() == b.hexdigest()
+            return False
+
+        def image_upload(post, image_save_function=None):
+            image = post.get("image")
+            overwrite = post.get("overwrite")
+            image_is_duplicate = False
+
+            image_upload_type = post.get("type")
+            upload_dir, image_upload_type = get_dir_by_type(image_upload_type)
+
+            if image and image.file:
+                filename = image.filename
+                if not filename:
+                    return web.Response(status=400)
+
+                subfolder = post.get("subfolder", "")
+                full_output_folder = os.path.join(upload_dir, os.path.normpath(subfolder))
+                filepath = os.path.abspath(os.path.join(full_output_folder, filename))
+
+                if os.path.commonpath((upload_dir, filepath)) != upload_dir:
+                    return web.Response(status=400)
+
+                if not os.path.exists(full_output_folder):
+                    os.makedirs(full_output_folder)
+
+                split = os.path.splitext(filename)
+
+                if overwrite is not None and (overwrite == "true" or overwrite == "1"):
+                    pass
+                else:
+                    i = 1
+                    while os.path.exists(filepath):
+                        if compare_image_hash(filepath, image): #compare hash to prevent saving of duplicates with same name, fix for #3465
+                            image_is_duplicate = True
+                            break
+                        filename = f"{split[0]} ({i}){split[1]}"
+                        filepath = os.path.join(full_output_folder, filename)
+                        i += 1
+
+                if not image_is_duplicate:
+                    if image_save_function is not None:
+                        image_save_function(image, post, filepath)
+                    else:
+                        with open(filepath, "wb") as f:
+                            f.write(image.file.read())
+
+                return web.json_response({"name" : filename, "subfolder": subfolder, "type": image_upload_type})
+            else:
+                return web.Response(status=400)
+
+        @routes.post("/upload/image")
+        async def upload_image(request):
+            post = await request.post()
+            return image_upload(post)
+
+
+        @routes.post("/upload/mask")
+        async def upload_mask(request):
+            post = await request.post()
+
+            def image_save_function(image, post, filepath):
+                original_ref = json.loads(post.get("original_ref"))
+                filename, output_dir = folder_paths.annotated_filepath(original_ref['filename'])
+
+                if not filename:
+                    return web.Response(status=400)
+
+                # validation for security: prevent accessing arbitrary path
+                if filename[0] == '/' or '..' in filename:
+                    return web.Response(status=400)
+
+                if output_dir is None:
+                    type = original_ref.get("type", "output")
+                    output_dir = folder_paths.get_directory_by_type(type)
+
+                if output_dir is None:
+                    return web.Response(status=400)
+
+                if original_ref.get("subfolder", "") != "":
+                    full_output_dir = os.path.join(output_dir, original_ref["subfolder"])
+                    if os.path.commonpath((os.path.abspath(full_output_dir), output_dir)) != output_dir:
+                        return web.Response(status=403)
+                    output_dir = full_output_dir
+
+                file = os.path.join(output_dir, filename)
+
+                if os.path.isfile(file):
+                    with Image.open(file) as original_pil:
+                        metadata = PngInfo()
+                        if hasattr(original_pil,'text'):
+                            for key in original_pil.text:
+                                metadata.add_text(key, original_pil.text[key])
+                        original_pil = original_pil.convert('RGBA')
+                        mask_pil = Image.open(image.file).convert('RGBA')
+
+                        # alpha copy
+                        new_alpha = mask_pil.getchannel('A')
+                        original_pil.putalpha(new_alpha)
+                        original_pil.save(filepath, compress_level=4, pnginfo=metadata)
+
+            return image_upload(post, image_save_function)
+
+        @routes.get("/view")
+        async def view_image(request):
+            if "filename" in request.rel_url.query:
+                filename = request.rel_url.query["filename"]
+                filename, output_dir = folder_paths.annotated_filepath(filename)
+
+                if not filename:
+                    return web.Response(status=400)
+
+                # validation for security: prevent accessing arbitrary path
+                if filename[0] == '/' or '..' in filename:
+                    return web.Response(status=400)
+
+                if output_dir is None:
+                    type = request.rel_url.query.get("type", "output")
+                    output_dir = folder_paths.get_directory_by_type(type)
+
+                if output_dir is None:
+                    return web.Response(status=400)
+
+                if "subfolder" in request.rel_url.query:
+                    full_output_dir = os.path.join(output_dir, request.rel_url.query["subfolder"])
+                    if os.path.commonpath((os.path.abspath(full_output_dir), output_dir)) != output_dir:
+                        return web.Response(status=403)
+                    output_dir = full_output_dir
+
+                filename = os.path.basename(filename)
+                file = os.path.join(output_dir, filename)
+
+                if os.path.isfile(file):
+                    if 'preview' in request.rel_url.query:
+                        with Image.open(file) as img:
+                            preview_info = request.rel_url.query['preview'].split(';')
+                            image_format = preview_info[0]
+                            if image_format not in ['webp', 'jpeg'] or 'a' in request.rel_url.query.get('channel', ''):
+                                image_format = 'webp'
+
+                            quality = 90
+                            if preview_info[-1].isdigit():
+                                quality = int(preview_info[-1])
+
+                            buffer = BytesIO()
+                            if image_format in ['jpeg'] or request.rel_url.query.get('channel', '') == 'rgb':
+                                img = img.convert("RGB")
+                            img.save(buffer, format=image_format, quality=quality)
+                            buffer.seek(0)
+
+                            return web.Response(body=buffer.read(), content_type=f'image/{image_format}',
+                                                headers={"Content-Disposition": f"filename=\"{filename}\""})
+
+                    if 'channel' not in request.rel_url.query:
+                        channel = 'rgba'
+                    else:
+                        channel = request.rel_url.query["channel"]
+
+                    if channel == 'rgb':
+                        with Image.open(file) as img:
+                            if img.mode == "RGBA":
+                                r, g, b, a = img.split()
+                                new_img = Image.merge('RGB', (r, g, b))
+                            else:
+                                new_img = img.convert("RGB")
+
+                            buffer = BytesIO()
+                            new_img.save(buffer, format='PNG')
+                            buffer.seek(0)
+
+                            return web.Response(body=buffer.read(), content_type='image/png',
+                                                headers={"Content-Disposition": f"filename=\"{filename}\""})
+
+                    elif channel == 'a':
+                        with Image.open(file) as img:
+                            if img.mode == "RGBA":
+                                _, _, _, a = img.split()
+                            else:
+                                a = Image.new('L', img.size, 255)
+
+                            # alpha img
+                            alpha_img = Image.new('RGBA', img.size)
+                            alpha_img.putalpha(a)
+                            alpha_buffer = BytesIO()
+                            alpha_img.save(alpha_buffer, format='PNG')
+                            alpha_buffer.seek(0)
+
+                            return web.Response(body=alpha_buffer.read(), content_type='image/png',
+                                                headers={"Content-Disposition": f"filename=\"{filename}\""})
+                    else:
+                        # Get content type from mimetype, defaulting to 'application/octet-stream'
+                        content_type = mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+
+                        # For security, force certain mimetypes to download instead of display
+                        if content_type in {'text/html', 'text/html-sandboxed', 'application/xhtml+xml', 'text/javascript', 'text/css'}:
+                            content_type = 'application/octet-stream'  # Forces download
+
+                        return web.FileResponse(
+                            file,
+                            headers={
+                                "Content-Disposition": f"filename=\"{filename}\"",
+                                "Content-Type": content_type
+                            }
+                        )
+
+            return web.Response(status=404)
+
+        @routes.get("/view_metadata/{folder_name}")
+        async def view_metadata(request):
+            folder_name = request.match_info.get("folder_name", None)
+            if folder_name is None:
+                return web.Response(status=404)
+            if not "filename" in request.rel_url.query:
+                return web.Response(status=404)
+
+            filename = request.rel_url.query["filename"]
+            if not filename.endswith(".safetensors"):
+                return web.Response(status=404)
+
+            safetensors_path = folder_paths.get_full_path(folder_name, filename)
+            if safetensors_path is None:
+                return web.Response(status=404)
+            out = comfy.utils.safetensors_header(safetensors_path, max_size=1024*1024)
+            if out is None:
+                return web.Response(status=404)
+            dt = json.loads(out)
+            if not "__metadata__" in dt:
+                return web.Response(status=404)
+            return web.json_response(dt["__metadata__"])
+
+        @routes.get("/system_stats")
+        async def system_stats(request):
+            device = comfy.model_management.get_torch_device()
+            device_name = comfy.model_management.get_torch_device_name(device)
+            cpu_device = comfy.model_management.torch.device("cpu")
+            ram_total = comfy.model_management.get_total_memory(cpu_device)
+            ram_free = comfy.model_management.get_free_memory(cpu_device)
+            vram_total, torch_vram_total = comfy.model_management.get_total_memory(device, torch_total_too=True)
+            vram_free, torch_vram_free = comfy.model_management.get_free_memory(device, torch_free_too=True)
+
+            system_stats = {
+                "system": {
+                    "os": os.name,
+                    "ram_total": ram_total,
+                    "ram_free": ram_free,
+                    "comfyui_version": __version__,
+                    "python_version": sys.version,
+                    "pytorch_version": comfy.model_management.torch_version,
+                    "embedded_python": os.path.split(os.path.split(sys.executable)[0])[1] == "python_embeded",
+                    "argv": sys.argv
+                },
+                "devices": [
+                    {
+                        "name": device_name,
+                        "type": device.type,
+                        "index": device.index,
+                        "vram_total": vram_total,
+                        "vram_free": vram_free,
+                        "torch_vram_total": torch_vram_total,
+                        "torch_vram_free": torch_vram_free,
+                    }
+                ]
+            }
+            return web.json_response(system_stats)
+
+        @routes.get("/features")
+        async def get_features(request):
+            return web.json_response(feature_flags.get_server_features())
+
+        @routes.get("/prompt")
+        async def get_prompt(request):
+            return web.json_response(self.get_queue_info())
+
+        def node_info(node_class):
+            obj_class = nodes.NODE_CLASS_MAPPINGS[node_class]
+            info = {}
+            info['input'] = obj_class.INPUT_TYPES()
+            info['input_order'] = {key: list(value.keys()) for (key, value) in obj_class.INPUT_TYPES().items()}
+            info['output'] = obj_class.RETURN_TYPES
+            info['output_is_list'] = obj_class.OUTPUT_IS_LIST if hasattr(obj_class, 'OUTPUT_IS_LIST') else [False] * len(obj_class.RETURN_TYPES)
+            info['output_name'] = obj_class.RETURN_NAMES if hasattr(obj_class, 'RETURN_NAMES') else info['output']
+            info['name'] = node_class
+            info['display_name'] = nodes.NODE_DISPLAY_NAME_MAPPINGS[node_class] if node_class in nodes.NODE_DISPLAY_NAME_MAPPINGS.keys() else node_class
+            info['description'] = obj_class.DESCRIPTION if hasattr(obj_class,'DESCRIPTION') else ''
+            info['python_module'] = getattr(obj_class, "RELATIVE_PYTHON_MODULE", "nodes")
+            info['category'] = 'sd'
+            if hasattr(obj_class, 'OUTPUT_NODE') and obj_class.OUTPUT_NODE == True:
+                info['output_node'] = True
+            else:
+                info['output_node'] = False
+
+            if hasattr(obj_class, 'CATEGORY'):
+                info['category'] = obj_class.CATEGORY
+
+            if hasattr(obj_class, 'OUTPUT_TOOLTIPS'):
+                info['output_tooltips'] = obj_class.OUTPUT_TOOLTIPS
+
+            if getattr(obj_class, "DEPRECATED", False):
+                info['deprecated'] = True
+            if getattr(obj_class, "EXPERIMENTAL", False):
+                info['experimental'] = True
+
+            if hasattr(obj_class, 'API_NODE'):
+                info['api_node'] = obj_class.API_NODE
+            return info
+
+        @routes.get("/object_info")
+        async def get_object_info(request):
+            with folder_paths.cache_helper:
+                out = {}
+                for x in nodes.NODE_CLASS_MAPPINGS:
+                    try:
+                        out[x] = node_info(x)
+                    except Exception:
+                        logging.error(f"[ERROR] An error occurred while retrieving information for the '{x}' node.")
+                        logging.error(traceback.format_exc())
+                return web.json_response(out)
+
+        @routes.get("/object_info/{node_class}")
+        async def get_object_info_node(request):
+            node_class = request.match_info.get("node_class", None)
+            out = {}
+            if (node_class is not None) and (node_class in nodes.NODE_CLASS_MAPPINGS):
+                out[node_class] = node_info(node_class)
+            return web.json_response(out)
+
+        @routes.get("/history")
+        async def get_history(request):
+            max_items = request.rel_url.query.get("max_items", None)
+            if max_items is not None:
+                max_items = int(max_items)
+            return web.json_response(self.prompt_queue.get_history(max_items=max_items))
+
+        @routes.get("/history/{prompt_id}")
+        async def get_history_prompt_id(request):
+            prompt_id = request.match_info.get("prompt_id", None)
+            return web.json_response(self.prompt_queue.get_history(prompt_id=prompt_id))
+
+        @routes.get("/queue")
+        async def get_queue(request):
+            queue_info = {}
+            current_queue = self.prompt_queue.get_current_queue_volatile()
+            queue_info['queue_running'] = current_queue[0]
+            queue_info['queue_pending'] = current_queue[1]
+            return web.json_response(queue_info)
+
+        @routes.post("/prompt")
+        async def post_prompt(request):
+            logging.info("got prompt")
+            json_data =  await request.json()
+            json_data = self.trigger_on_prompt(json_data)
+
+            if "number" in json_data:
+                number = float(json_data['number'])
+            else:
+                number = self.number
+                if "front" in json_data:
+                    if json_data['front']:
+                        number = -number
+
+                self.number += 1
+
+            if "prompt" in json_data:
+                prompt = json_data["prompt"]
+                prompt_id = str(json_data.get("prompt_id", uuid.uuid4()))
+                valid = await execution.validate_prompt(prompt_id, prompt)
+                extra_data = {}
+                if "extra_data" in json_data:
+                    extra_data = json_data["extra_data"]
+
+                if "client_id" in json_data:
+                    extra_data["client_id"] = json_data["client_id"]
+                if valid[0]:
+                    outputs_to_execute = valid[2]
+                    self.prompt_queue.put((number, prompt_id, prompt, extra_data, outputs_to_execute))
+                    response = {"prompt_id": prompt_id, "number": number, "node_errors": valid[3]}
+                    return web.json_response(response)
+                else:
+                    logging.warning("invalid prompt: {}".format(valid[1]))
+                    return web.json_response({"error": valid[1], "node_errors": valid[3]}, status=400)
+            else:
+                error = {
+                    "type": "no_prompt",
+                    "message": "No prompt provided",
+                    "details": "No prompt provided",
+                    "extra_info": {}
+                }
+                return web.json_response({"error": error, "node_errors": {}}, status=400)
+
+        @routes.post("/queue")
+        async def post_queue(request):
+            json_data =  await request.json()
+            if "clear" in json_data:
+                if json_data["clear"]:
+                    self.prompt_queue.wipe_queue()
+            if "delete" in json_data:
+                to_delete = json_data['delete']
+                for id_to_delete in to_delete:
+                    delete_func = lambda a: a[1] == id_to_delete
+                    self.prompt_queue.delete_queue_item(delete_func)
+
+            return web.Response(status=200)
+
+        @routes.post("/interrupt")
+        async def post_interrupt(request):
+            nodes.interrupt_processing()
+            return web.Response(status=200)
+
+        @routes.post("/free")
+        async def post_free(request):
+            json_data = await request.json()
+            unload_models = json_data.get("unload_models", False)
+            free_memory = json_data.get("free_memory", False)
+            if unload_models:
+                self.prompt_queue.set_flag("unload_models", unload_models)
+            if free_memory:
+                self.prompt_queue.set_flag("free_memory", free_memory)
+            return web.Response(status=200)
+
+        @routes.post("/history")
+        async def post_history(request):
+            json_data =  await request.json()
+            if "clear" in json_data:
+                if json_data["clear"]:
+                    self.prompt_queue.wipe_history()
+            if "delete" in json_data:
+                to_delete = json_data['delete']
+                for id_to_delete in to_delete:
+                    self.prompt_queue.delete_history_item(id_to_delete)
+
+            return web.Response(status=200)
+
+    async def setup(self):
+        timeout = aiohttp.ClientTimeout(total=None) # no timeout
+        self.client_session = aiohttp.ClientSession(timeout=timeout)
+
+    def add_routes(self):
+        self.user_manager.add_routes(self.routes)
+        self.model_file_manager.add_routes(self.routes)
+        self.custom_node_manager.add_routes(self.routes, self.app, nodes.LOADED_MODULE_DIRS.items())
+        self.app.add_subapp('/internal', self.internal_routes.get_app())
+
+        # Prefix every route with /api for easier matching for delegation.
+        # This is very useful for frontend dev server, which need to forward
+        # everything except serving of static files.
+        # Currently both the old endpoints without prefix and new endpoints with
+        # prefix are supported.
+        api_routes = web.RouteTableDef()
+        for route in self.routes:
+            # Custom nodes might add extra static routes. Only process non-static
+            # routes to add /api prefix.
+            if isinstance(route, web.RouteDef):
+                api_routes.route(route.method, "/api" + route.path)(route.handler, **route.kwargs)
+        self.app.add_routes(api_routes)
+        self.app.add_routes(self.routes)
+
+        # Add routes from web extensions.
+        for name, dir in nodes.EXTENSION_WEB_DIRS.items():
+            self.app.add_routes([web.static('/extensions/' + name, dir)])
+
+        workflow_templates_path = FrontendManager.templates_path()
+        if workflow_templates_path:
+            self.app.add_routes([
+                web.static('/templates', workflow_templates_path)
+            ])
+
+        # Serve embedded documentation from the package
+        embedded_docs_path = FrontendManager.embedded_docs_path()
+        if embedded_docs_path:
+            self.app.add_routes([
+                web.static('/docs', embedded_docs_path)
+            ])
+
+        self.app.add_routes([
+            web.static('/', self.web_root),
+        ])
+
+    def get_queue_info(self):
+        prompt_info = {}
+        exec_info = {}
+        exec_info['queue_remaining'] = self.prompt_queue.get_tasks_remaining()
+        prompt_info['exec_info'] = exec_info
+        return prompt_info
+
+    async def send(self, event, data, sid=None):
+        if event == BinaryEventTypes.UNENCODED_PREVIEW_IMAGE:
+            await self.send_image(data, sid=sid)
+        elif event == BinaryEventTypes.PREVIEW_IMAGE_WITH_METADATA:
+            # data is (preview_image, metadata)
+            preview_image, metadata = data
+            await self.send_image_with_metadata(preview_image, metadata, sid=sid)
+        elif isinstance(data, (bytes, bytearray)):
+            await self.send_bytes(event, data, sid)
+        else:
+            await self.send_json(event, data, sid)
+
+    def encode_bytes(self, event, data):
+        if not isinstance(event, int):
+            raise RuntimeError(f"Binary event types must be integers, got {event}")
+
+        packed = struct.pack(">I", event)
+        message = bytearray(packed)
+        message.extend(data)
+        return message
+
+    async def send_image(self, image_data, sid=None):
+        image_type = image_data[0]
+        image = image_data[1]
+        max_size = image_data[2]
+        if max_size is not None:
+            if hasattr(Image, 'Resampling'):
+                resampling = Image.Resampling.BILINEAR
+            else:
+                resampling = Image.Resampling.LANCZOS
+
+            image = ImageOps.contain(image, (max_size, max_size), resampling)
+        type_num = 1
+        if image_type == "JPEG":
+            type_num = 1
+        elif image_type == "PNG":
+            type_num = 2
+
+        bytesIO = BytesIO()
+        header = struct.pack(">I", type_num)
+        bytesIO.write(header)
+        image.save(bytesIO, format=image_type, quality=95, compress_level=1)
+        preview_bytes = bytesIO.getvalue()
+        await self.send_bytes(BinaryEventTypes.PREVIEW_IMAGE, preview_bytes, sid=sid)
+
+    async def send_image_with_metadata(self, image_data, metadata=None, sid=None):
+        image_type = image_data[0]
+        image = image_data[1]
+        max_size = image_data[2]
+        if max_size is not None:
+            if hasattr(Image, 'Resampling'):
+                resampling = Image.Resampling.BILINEAR
+            else:
+                resampling = Image.Resampling.LANCZOS
+
+            image = ImageOps.contain(image, (max_size, max_size), resampling)
+
+        mimetype = "image/png" if image_type == "PNG" else "image/jpeg"
+
+        # Prepare metadata
+        if metadata is None:
+            metadata = {}
+        metadata["image_type"] = mimetype
+
+        # Serialize metadata as JSON
+        import json
+        metadata_json = json.dumps(metadata).encode('utf-8')
+        metadata_length = len(metadata_json)
+
+        # Prepare image data
+        bytesIO = BytesIO()
+        image.save(bytesIO, format=image_type, quality=95, compress_level=1)
+        image_bytes = bytesIO.getvalue()
+
+        # Combine metadata and image
+        combined_data = bytearray()
+        combined_data.extend(struct.pack(">I", metadata_length))
+        combined_data.extend(metadata_json)
+        combined_data.extend(image_bytes)
+
+        await self.send_bytes(BinaryEventTypes.PREVIEW_IMAGE_WITH_METADATA, combined_data, sid=sid)
+
+    async def send_bytes(self, event, data, sid=None):
+        message = self.encode_bytes(event, data)
+
+        if sid is None:
+            sockets = list(self.sockets.values())
+            for ws in sockets:
+                await send_socket_catch_exception(ws.send_bytes, message)
+        elif sid in self.sockets:
+            await send_socket_catch_exception(self.sockets[sid].send_bytes, message)
+
+    async def send_json(self, event, data, sid=None):
+        message = {"type": event, "data": data}
+
+        if sid is None:
+            sockets = list(self.sockets.values())
+            for ws in sockets:
+                await send_socket_catch_exception(ws.send_json, message)
+        elif sid in self.sockets:
+            await send_socket_catch_exception(self.sockets[sid].send_json, message)
+
+    def send_sync(self, event, data, sid=None):
+        self.loop.call_soon_threadsafe(
+            self.messages.put_nowait, (event, data, sid))
+
+    def queue_updated(self):
+        self.send_sync("status", { "status": self.get_queue_info() })
+
+    async def publish_loop(self):
+        while True:
+            msg = await self.messages.get()
+            await self.send(*msg)
+
+    async def start(self, address, port, verbose=True, call_on_start=None):
+        await self.start_multi_address([(address, port)], call_on_start=call_on_start)
+
+    async def start_multi_address(self, addresses, call_on_start=None, verbose=True):
+        runner = web.AppRunner(self.app, access_log=None)
+        await runner.setup()
+        ssl_ctx = None
+        scheme = "http"
+        if args.tls_keyfile and args.tls_certfile:
+            ssl_ctx = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS_SERVER, verify_mode=ssl.CERT_NONE)
+            ssl_ctx.load_cert_chain(certfile=args.tls_certfile,
+                                keyfile=args.tls_keyfile)
+            scheme = "https"
+
+        if verbose:
+            logging.info("Starting server\n")
+        for addr in addresses:
+            address = addr[0]
+            port = addr[1]
+            site = web.TCPSite(runner, address, port, ssl_context=ssl_ctx)
+            await site.start()
+
+            if not hasattr(self, 'address'):
+                self.address = address #TODO: remove this
+                self.port = port
+
+            if ':' in address:
+                address_print = "[{}]".format(address)
+            else:
+                address_print = address
+
+            if verbose:
+                logging.info("To see the GUI go to: {}://{}:{}".format(scheme, address_print, port))
+
+        if call_on_start is not None:
+            call_on_start(scheme, self.address, self.port)
+
+    def add_on_prompt_handler(self, handler):
+        self.on_prompt_handlers.append(handler)
+
+    def trigger_on_prompt(self, json_data):
+        for handler in self.on_prompt_handlers:
+            try:
+                json_data = handler(json_data)
+            except Exception:
+                logging.warning("[ERROR] An error occurred during the on_prompt_handler processing")
+                logging.warning(traceback.format_exc())
+
+        return json_data
+
+    def send_progress_text(
+        self, text: Union[bytes, bytearray, str], node_id: str, sid=None
+    ):
+        if isinstance(text, str):
+            text = text.encode("utf-8")
+        node_id_bytes = str(node_id).encode("utf-8")
+
+        # Pack the node_id length as a 4-byte unsigned integer, followed by the node_id bytes
+        message = struct.pack(">I", len(node_id_bytes)) + node_id_bytes + text
+
+        self.send_sync(BinaryEventTypes.TEXT, message, sid)

venv/bin/Activate.ps1

@@ -0,0 +1,247 @@
+<#
+.Synopsis
+Activate a Python virtual environment for the current PowerShell session.
+
+.Description
+Pushes the python executable for a virtual environment to the front of the
+$Env:PATH environment variable and sets the prompt to signify that you are
+in a Python virtual environment. Makes use of the command line switches as
+well as the `pyvenv.cfg` file values present in the virtual environment.
+
+.Parameter VenvDir
+Path to the directory that contains the virtual environment to activate. The
+default value for this is the parent of the directory that the Activate.ps1
+script is located within.
+
+.Parameter Prompt
+The prompt prefix to display when this virtual environment is activated. By
+default, this prompt is the name of the virtual environment folder (VenvDir)
+surrounded by parentheses and followed by a single space (ie. '(.venv) ').
+
+.Example
+Activate.ps1
+Activates the Python virtual environment that contains the Activate.ps1 script.
+
+.Example
+Activate.ps1 -Verbose
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and shows extra information about the activation as it executes.
+
+.Example
+Activate.ps1 -VenvDir C:\Users\MyUser\Common\.venv
+Activates the Python virtual environment located in the specified location.
+
+.Example
+Activate.ps1 -Prompt "MyPython"
+Activates the Python virtual environment that contains the Activate.ps1 script,
+and prefixes the current prompt with the specified string (surrounded in
+parentheses) while the virtual environment is active.
+
+.Notes
+On Windows, it may be required to enable this Activate.ps1 script by setting the
+execution policy for the user. You can do this by issuing the following PowerShell
+command:
+
+PS C:\> Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
+
+For more information on Execution Policies: 
+https://go.microsoft.com/fwlink/?LinkID=135170
+
+#>
+Param(
+    [Parameter(Mandatory = $false)]
+    [String]
+    $VenvDir,
+    [Parameter(Mandatory = $false)]
+    [String]
+    $Prompt
+)
+
+<# Function declarations --------------------------------------------------- #>
+
+<#
+.Synopsis
+Remove all shell session elements added by the Activate script, including the
+addition of the virtual environment's Python executable from the beginning of
+the PATH variable.
+
+.Parameter NonDestructive
+If present, do not remove this function from the global namespace for the
+session.
+
+#>
+function global:deactivate ([switch]$NonDestructive) {
+    # Revert to original values
+
+    # The prior prompt:
+    if (Test-Path -Path Function:_OLD_VIRTUAL_PROMPT) {
+        Copy-Item -Path Function:_OLD_VIRTUAL_PROMPT -Destination Function:prompt
+        Remove-Item -Path Function:_OLD_VIRTUAL_PROMPT
+    }
+
+    # The prior PYTHONHOME:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PYTHONHOME) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME -Destination Env:PYTHONHOME
+        Remove-Item -Path Env:_OLD_VIRTUAL_PYTHONHOME
+    }
+
+    # The prior PATH:
+    if (Test-Path -Path Env:_OLD_VIRTUAL_PATH) {
+        Copy-Item -Path Env:_OLD_VIRTUAL_PATH -Destination Env:PATH
+        Remove-Item -Path Env:_OLD_VIRTUAL_PATH
+    }
+
+    # Just remove the VIRTUAL_ENV altogether:
+    if (Test-Path -Path Env:VIRTUAL_ENV) {
+        Remove-Item -Path env:VIRTUAL_ENV
+    }
+
+    # Just remove VIRTUAL_ENV_PROMPT altogether.
+    if (Test-Path -Path Env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item -Path env:VIRTUAL_ENV_PROMPT
+    }
+
+    # Just remove the _PYTHON_VENV_PROMPT_PREFIX altogether:
+    if (Get-Variable -Name "_PYTHON_VENV_PROMPT_PREFIX" -ErrorAction SilentlyContinue) {
+        Remove-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Scope Global -Force
+    }
+
+    # Leave deactivate function in the global namespace if requested:
+    if (-not $NonDestructive) {
+        Remove-Item -Path function:deactivate
+    }
+}
+
+<#
+.Description
+Get-PyVenvConfig parses the values from the pyvenv.cfg file located in the
+given folder, and returns them in a map.
+
+For each line in the pyvenv.cfg file, if that line can be parsed into exactly
+two strings separated by `=` (with any amount of whitespace surrounding the =)
+then it is considered a `key = value` line. The left hand string is the key,
+the right hand is the value.
+
+If the value starts with a `'` or a `"` then the first and last character is
+stripped from the value before being captured.
+
+.Parameter ConfigDir
+Path to the directory that contains the `pyvenv.cfg` file.
+#>
+function Get-PyVenvConfig(
+    [String]
+    $ConfigDir
+) {
+    Write-Verbose "Given ConfigDir=$ConfigDir, obtain values in pyvenv.cfg"
+
+    # Ensure the file exists, and issue a warning if it doesn't (but still allow the function to continue).
+    $pyvenvConfigPath = Join-Path -Resolve -Path $ConfigDir -ChildPath 'pyvenv.cfg' -ErrorAction Continue
+
+    # An empty map will be returned if no config file is found.
+    $pyvenvConfig = @{ }
+
+    if ($pyvenvConfigPath) {
+
+        Write-Verbose "File exists, parse `key = value` lines"
+        $pyvenvConfigContent = Get-Content -Path $pyvenvConfigPath
+
+        $pyvenvConfigContent | ForEach-Object {
+            $keyval = $PSItem -split "\s*=\s*", 2
+            if ($keyval[0] -and $keyval[1]) {
+                $val = $keyval[1]
+
+                # Remove extraneous quotations around a string value.
+                if ("'""".Contains($val.Substring(0, 1))) {
+                    $val = $val.Substring(1, $val.Length - 2)
+                }
+
+                $pyvenvConfig[$keyval[0]] = $val
+                Write-Verbose "Adding Key: '$($keyval[0])'='$val'"
+            }
+        }
+    }
+    return $pyvenvConfig
+}
+
+
+<# Begin Activate script --------------------------------------------------- #>
+
+# Determine the containing directory of this script
+$VenvExecPath = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$VenvExecDir = Get-Item -Path $VenvExecPath
+
+Write-Verbose "Activation script is located in path: '$VenvExecPath'"
+Write-Verbose "VenvExecDir Fullname: '$($VenvExecDir.FullName)"
+Write-Verbose "VenvExecDir Name: '$($VenvExecDir.Name)"
+
+# Set values required in priority: CmdLine, ConfigFile, Default
+# First, get the location of the virtual environment, it might not be
+# VenvExecDir if specified on the command line.
+if ($VenvDir) {
+    Write-Verbose "VenvDir given as parameter, using '$VenvDir' to determine values"
+}
+else {
+    Write-Verbose "VenvDir not given as a parameter, using parent directory name as VenvDir."
+    $VenvDir = $VenvExecDir.Parent.FullName.TrimEnd("\\/")
+    Write-Verbose "VenvDir=$VenvDir"
+}
+
+# Next, read the `pyvenv.cfg` file to determine any required value such
+# as `prompt`.
+$pyvenvCfg = Get-PyVenvConfig -ConfigDir $VenvDir
+
+# Next, set the prompt from the command line, or the config file, or
+# just use the name of the virtual environment folder.
+if ($Prompt) {
+    Write-Verbose "Prompt specified as argument, using '$Prompt'"
+}
+else {
+    Write-Verbose "Prompt not specified as argument to script, checking pyvenv.cfg value"
+    if ($pyvenvCfg -and $pyvenvCfg['prompt']) {
+        Write-Verbose "  Setting based on value in pyvenv.cfg='$($pyvenvCfg['prompt'])'"
+        $Prompt = $pyvenvCfg['prompt'];
+    }
+    else {
+        Write-Verbose "  Setting prompt based on parent's directory's name. (Is the directory name passed to venv module when creating the virtual environment)"
+        Write-Verbose "  Got leaf-name of $VenvDir='$(Split-Path -Path $venvDir -Leaf)'"
+        $Prompt = Split-Path -Path $venvDir -Leaf
+    }
+}
+
+Write-Verbose "Prompt = '$Prompt'"
+Write-Verbose "VenvDir='$VenvDir'"
+
+# Deactivate any currently active virtual environment, but leave the
+# deactivate function in place.
+deactivate -nondestructive
+
+# Now set the environment variable VIRTUAL_ENV, used by many tools to determine
+# that there is an activated venv.
+$env:VIRTUAL_ENV = $VenvDir
+
+if (-not $Env:VIRTUAL_ENV_DISABLE_PROMPT) {
+
+    Write-Verbose "Setting prompt to '$Prompt'"
+
+    # Set the prompt to include the env name
+    # Make sure _OLD_VIRTUAL_PROMPT is global
+    function global:_OLD_VIRTUAL_PROMPT { "" }
+    Copy-Item -Path function:prompt -Destination function:_OLD_VIRTUAL_PROMPT
+    New-Variable -Name _PYTHON_VENV_PROMPT_PREFIX -Description "Python virtual environment prompt prefix" -Scope Global -Option ReadOnly -Visibility Public -Value $Prompt
+
+    function global:prompt {
+        Write-Host -NoNewline -ForegroundColor Green "($_PYTHON_VENV_PROMPT_PREFIX) "
+        _OLD_VIRTUAL_PROMPT
+    }
+    $env:VIRTUAL_ENV_PROMPT = $Prompt
+}
+
+# Clear PYTHONHOME
+if (Test-Path -Path Env:PYTHONHOME) {
+    Copy-Item -Path Env:PYTHONHOME -Destination Env:_OLD_VIRTUAL_PYTHONHOME
+    Remove-Item -Path Env:PYTHONHOME
+}
+
+# Add the venv to the PATH
+Copy-Item -Path Env:PATH -Destination Env:_OLD_VIRTUAL_PATH
+$Env:PATH = "$VenvExecDir$([System.IO.Path]::PathSeparator)$Env:PATH"

venv/bin/activate

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

venv/bin/activate.csh

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

venv/bin/activate.fish

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

venv/bin/alembic

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

venv/bin/dotenv

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

venv/bin/ds

@@ -0,0 +1,6 @@
+#!/workspace/ComfyUI/venv/bin/python
+
+from deepspeed.launcher.runner import main
+
+if __name__ == '__main__':
+    main()

venv/bin/fonttools

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

venv/bin/huggingface-cli

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from huggingface_hub.commands.huggingface_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/imageio_download_bin

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from imageio.__main__ import download_bin_main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(download_bin_main())

venv/bin/imageio_remove_bin

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from imageio.__main__ import remove_bin_main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(remove_bin_main())

venv/bin/insightface-cli

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from insightface.commands.insightface_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/isympy

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

venv/bin/lsm2bin

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

venv/bin/mako-render

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from mako.cmd import cmdline
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(cmdline())

venv/bin/normalizer

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

venv/bin/pip

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

venv/bin/pip3

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

venv/bin/pip3.10

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

venv/bin/proton

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from triton.profiler.proton import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/proton-viewer

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from triton.profiler.viewer import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/pyav

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

venv/bin/pyftmerge

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

venv/bin/sz_split

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

venv/bin/sz_wc

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

venv/bin/tiff2fsspec

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

venv/bin/tiffcomment

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

venv/bin/tifffile

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

venv/bin/tiny-agents

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from huggingface_hub.inference._mcp.cli import app
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(app())

venv/bin/torchfrtrace

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from tools.flight_recorder.fr_trace import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/torchrun

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from torch.distributed.run import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/tqdm

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

venv/bin/transformers

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from transformers.commands.transformers_cli import main
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main())

venv/bin/transformers-cli

@@ -0,0 +1,8 @@
+#!/workspace/ComfyUI/venv/bin/python
+# -*- coding: utf-8 -*-
+import re
+import sys
+from transformers.commands.transformers_cli import main_cli
+if __name__ == '__main__':
+    sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])
+    sys.exit(main_cli())

venv/lib/python3.10/site-packages/PyGithub-2.6.1.dist-info/INSTALLER

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

venv/lib/python3.10/site-packages/PyGithub-2.6.1.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.2
+Name: PyGithub
+Version: 2.6.1
+Summary: Use the full Github API v3
+Author-email: Vincent Jacques <vincent@vincent-jacques.net>
+Project-URL: Documentation, https://pygithub.readthedocs.io/en/stable/
+Project-URL: Source, https://github.com/pygithub/pygithub
+Project-URL: Tracker, https://github.com/pygithub/pygithub/issues
+Keywords: github
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Library or Lesser General Public License (LGPL)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: COPYING
+License-File: COPYING.LESSER
+Requires-Dist: pynacl>=1.4.0
+Requires-Dist: requests>=2.14.0
+Requires-Dist: pyjwt[crypto]>=2.4.0
+Requires-Dist: typing-extensions>=4.0.0
+Requires-Dist: urllib3>=1.26.0
+Requires-Dist: Deprecated
+Provides-Extra: integrations
+
+# PyGitHub
+
+[![PyPI](https://img.shields.io/pypi/v/PyGithub.svg)](https://pypi.python.org/pypi/PyGithub)
+![CI](https://github.com/PyGithub/PyGithub/workflows/CI/badge.svg)
+[![readthedocs](https://img.shields.io/badge/docs-stable-brightgreen.svg?style=flat)](https://pygithub.readthedocs.io/en/stable/?badge=stable)
+[![License](https://img.shields.io/badge/license-LGPL-blue.svg)](https://en.wikipedia.org/wiki/GNU_Lesser_General_Public_License)
+[![Slack](https://img.shields.io/badge/Slack%20channel-%20%20-blue.svg)](https://join.slack.com/t/pygithub-project/shared_invite/zt-duj89xtx-uKFZtgAg209o6Vweqm8xeQ)
+[![Open Source Helpers](https://www.codetriage.com/pygithub/pygithub/badges/users.svg)](https://www.codetriage.com/pygithub/pygithub)
+[![codecov](https://codecov.io/gh/PyGithub/PyGithub/branch/master/graph/badge.svg)](https://codecov.io/gh/PyGithub/PyGithub)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+PyGitHub is a Python library to access the [GitHub REST API].
+This library enables you to manage [GitHub] resources such as repositories, user profiles, and organizations in your Python applications.
+
+[GitHub REST API]: https://docs.github.com/en/rest
+[GitHub]: https://github.com
+
+## Install
+
+```bash
+pip install PyGithub
+```
+
+## Simple Demo
+
+```python
+from github import Github
+
+# Authentication is defined via github.Auth
+from github import Auth
+
+# using an access token
+auth = Auth.Token("access_token")
+
+# First create a Github instance:
+
+# Public Web Github
+g = Github(auth=auth)
+
+# Github Enterprise with custom hostname
+g = Github(base_url="https://{hostname}/api/v3", auth=auth)
+
+# Then play with your Github objects:
+for repo in g.get_user().get_repos():
+    print(repo.name)
+
+# To close connections after use
+g.close()
+```
+
+## Documentation
+
+More information can be found on the [PyGitHub documentation site.](https://pygithub.readthedocs.io/en/stable/introduction.html)
+
+## Development
+
+### Contributing
+
+Long-term discussion and bug reports are maintained via GitHub Issues.
+Code review is done via GitHub Pull Requests.
+
+For more information read [CONTRIBUTING.md].
+
+[CONTRIBUTING.md]: https://github.com/PyGithub/PyGithub/blob/main/CONTRIBUTING.md
+
+### Maintainership
+
+We're actively seeking maintainers that will triage issues and pull requests and cut releases.
+If you work on a project that leverages PyGitHub and have a vested interest in keeping the code alive and well, send an email to someone in the MAINTAINERS file.

venv/lib/python3.10/site-packages/PyGithub-2.6.1.dist-info/RECORD

@@ -0,0 +1,337 @@
+PyGithub-2.6.1.dist-info/COPYING,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+PyGithub-2.6.1.dist-info/COPYING.LESSER,sha256=2n6rt7r999OuXp8iOqW9we7ORaxWncIbOwN1ILRGR2g,7651
+PyGithub-2.6.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyGithub-2.6.1.dist-info/METADATA,sha256=6GM2H6ECoFpjMHvmsQMTQvrkHNNqLQxqLrSaduB7pow,3889
+PyGithub-2.6.1.dist-info/RECORD,,
+PyGithub-2.6.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+PyGithub-2.6.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+PyGithub-2.6.1.dist-info/top_level.txt,sha256=X_Dn8Q-zPGudQV37mRBM5uHhwhEsv4x1AeAuB1dfEls,7
+github/AccessToken.py,sha256=_Ryw-pme8fxvSY-2dqDlnH7x1akRrxry_EKWGex4mEU,6756
+github/AdvisoryBase.py,sha256=61onXFv5hVi0GpmUjKCPAJo8bRKJAwxA6cxix8V3M3I,7196
+github/AdvisoryCredit.py,sha256=Sth4hayVCtuAS8vkCBITY7iAQ9Z_2_QEh8vIYXtxuKs,5213
+github/AdvisoryCreditDetailed.py,sha256=0Jns6-Wgi2da_nAc_-cdKrdrcx6q1LTn73VXz-1kI24,5163
+github/AdvisoryVulnerability.py,sha256=kOYX8pNMO2YA2bA3j02w69GVUSBfqvOL4VXFcppT9ss,8607
+github/AdvisoryVulnerabilityPackage.py,sha256=Bh_BiNS34PBv5aZYFR9SUNUNdXRvhMPh1Nll11x3Tpg,4972
+github/AppAuthentication.py,sha256=8ItYtxH1Z3qUCFiI5pIrUgWkfxrNfDtv_PTLlhAUhCs,3362
+github/ApplicationOAuth.py,sha256=bXK9Vuw4d_VlgqfR3I4eDLflTWiJWqYDT2ee6W3TLPA,8200
+github/Artifact.py,sha256=5wWfNLP61VqVBBnmy0OPgX_XXezpyLw3UO3D7V53M8o,8364
+github/Auth.py,sha256=j4n343bx20ZYTFu7KjdBXIe8JvtGh-VxNaRwWGRBWDc,18777
+github/AuthenticatedUser.py,sha256=RPSbudt7Fwf93A6y0MagxCjqGS6cZ74IianKlvfVSfM,51604
+github/Authorization.py,sha256=X1HngQla9ail9EMVvd7hIYe3D7iD8bkP7VOEyEn5Oi8,8589
+github/AuthorizationApplication.py,sha256=AO_iJkla_Z-SlGBdjDgU4vdIhQvC-xyi3g9ZavwLPXY,3912
+github/Autolink.py,sha256=oca0RVXVIcjZJ-m9_2i01-8aaz7Ric8QUcWq-kc8AY8,4945
+github/Branch.py,sha256=xMHCSGF6atubtwMTWev9ImwRASMXQCLQVHxIcpjnRQU,32091
+github/BranchProtection.py,sha256=emtYLjbzekTi5VxvVO7fk1bwCdyY0fkxHBjEB3qxvHs,10599
+github/CVSS.py,sha256=O7nf9sgk1XVZ8n0CnHgxXZ_A5NH8oarvWfUIUTamL7I,4658
+github/CWE.py,sha256=liISfggat6zcylarfj0SB67SIBNuTHJjVcPmoOUuzxg,4072
+github/CheckRun.py,sha256=8oVyQ0iR2VyiLLRoHNR0ABXwwI6m8MI1LQWP1WJNNq4,12905
+github/CheckRunAnnotation.py,sha256=3ZmsqDEoxIX0ggVk87cczYeyQVv9WMjwZRP_3cAdR6o,5647
+github/CheckRunOutput.py,sha256=28uFE7IsNBxdm2nrpsRrXmkH-zKKR6J3JWgZa5b6wzU,5058
+github/CheckSuite.py,sha256=ZVbfdkDmmJxhwnD5LYBofRcOdHXjPHIp9JVX_IVHeQg,12650
+github/Clones.py,sha256=IDesxzVgVHIf4OyJeunH6--5V-fUn0z4a4YeSgFDcpA,4862
+github/CodeScanAlert.py,sha256=kzdKASKNHz4zqjLWuQ4j8bsk8ukDpWnRalRGq-QYpSU,7166
+github/CodeScanAlertInstance.py,sha256=A5OdwJBXmvYnTQgpFEMN5iadIMbwobWbL-JTd-Kanvo,5463
+github/CodeScanAlertInstanceLocation.py,sha256=5o4nPcL5VZgwys6EnvhGshXTOqplZgxDw7zB6wzNDTs,4539
+github/CodeScanRule.py,sha256=fqunSyh14WpluH95E5aKF7zCVLr8kv3El5rHNmXrPqA,5182
+github/CodeScanTool.py,sha256=z4gipqMPyBArAqX4bUvnINCc3P5cABzes1fY3D1_IWY,4545
+github/CodeSecurityConfig.py,sha256=Z36edlAPbKh3B5V4MmuJUyQaU0zvsaOvDnf2NENuE30,9907
+github/CodeSecurityConfigRepository.py,sha256=TvM3cdov7dpiJnBzsSpiWOatBMcSDxVP6cXl6ebiTJ0,3291
+github/Commit.py,sha256=jJO2eLxCfkGj3fKavpKEnda8Yn1hLqu_A7HEhKeualU,16463
+github/CommitCombinedStatus.py,sha256=rZIoDhiJtdSAhKlKIXcg2AaOedb5F8tymHPdgVqsRRE,5892
+github/CommitComment.py,sha256=KTavqBGP56fFVWjI_ycuR6aC1rvag5kMjXd3BAY2E1o,11391
+github/CommitStats.py,sha256=1YwhWBFBGzUE6wE8BVTYhMMIUDAVQaz6SDnc8Z8Ck6A,4012
+github/CommitStatus.py,sha256=u3ZpM_zwyQSPRlagL_nuNDWQ0X9WtU0KZhq2bRTFwL4,6973
+github/Comparison.py,sha256=II8s1H54jBhyEmgVBNHzM3qklbj1LnQHbhh9Ep7HscE,8010
+github/Consts.py,sha256=GJUQi2O4WHJTjNyB42fYj5x2eQFDrm8aQhfB7ahicRQ,10492
+github/ContentFile.py,sha256=8g-Qasve1GdVok9Ym_3sVUaQ2nPjT9FgI4xH75BPliE,12595
+github/Copilot.py,sha256=GoE5Goq3wI9Aeel7KsjodX_Dm4YYRGJla5GZM52J0gI,4532
+github/CopilotSeat.py,sha256=xvhOo-A6sAKkGMhiXWaZAcW4p9qIqE7FeU3BZPVf6BQ,4794
+github/DefaultCodeSecurityConfig.py,sha256=PGrYyWk7WdLK_NqP7mTW6VnPT0H4b8wXKPjzx0rBJik,4741
+github/DependabotAlert.py,sha256=0Hq4RgnanHzOsXOMSTG544g9NTbwG5SNFJBR1B255bo,7711
+github/DependabotAlertAdvisory.py,sha256=7TI5mRyg6PJmZUkLSdHL2Zypq6hKmc8FqeWShA61Cag,3591
+github/DependabotAlertDependency.py,sha256=2Cg3e6G2W6LajWZ-xBArSsRtz4zW5wab-8oKINU0h_Y,3665
+github/DependabotAlertVulnerability.py,sha256=eAt2Fy-REMD8lSzTSxyAtn6Nf9P0NEyTffRXc2sgKr4,3988
+github/Deployment.py,sha256=D1tYEGGmn62nqexHQzda5oVHDhBPihB0Y6o8dN57oBM,13654
+github/DeploymentStatus.py,sha256=qq-qMMBHAtw3hIIkMNiXbaD_7JdPpLvywHwF0lSb1Hs,9370
+github/DiscussionBase.py,sha256=54013rlbYF4_MItFXuH0AYzmuhMW6Z8kpvDVhc5Z1gQ,6784
+github/DiscussionCommentBase.py,sha256=Hnuox_kzfZ9xruwYWzRtqbDnl5Ehndr5TynkcNC2WlA,6835
+github/Download.py,sha256=MKVNGIqD4kZo5fhdF2HUnyweLnPcgs7nWuQSMAbo1Kk,11218
+github/Enterprise.py,sha256=x-qYVrFUFlE6ZR1LeZgg8eFkvrucLwGshJnn3EAJgQo,5327
+github/EnterpriseConsumedLicenses.py,sha256=eDO5MrobiG5bRXGGIYOnIl8hgftq3IO_IooOu4LjmMs,5762
+github/Environment.py,sha256=iynT0fU-E7m8Tt9jqa94QdOezGjchayxw2nfI3Lh1k8,13623
+github/EnvironmentDeploymentBranchPolicy.py,sha256=vZeU3Y4nQJSHJ3Lz_rd5PF_J7rJdvdWkIaXR330q2yY,4090
+github/EnvironmentProtectionRule.py,sha256=91IbsSTP2lW4n8xWd8FAjpJEe26frqqg-6yVputx-Gw,5574
+github/EnvironmentProtectionRuleReviewer.py,sha256=_HLqHz4nSJeaYnk38bbcb-283Hg7jQ1nmTnUDxehQd8,5217
+github/Event.py,sha256=hkNr9ps_wiJCCKsk1-3aBR0uhJBxronm7ebSGyoHTMs,6182
+github/File.py,sha256=aO9qr6VoVWVrcn7ej-mR0mq-nTbJLpFYK1jy94xKTCk,6684
+github/Gist.py,sha256=PPa2kPhY142xQ_hqXtBtKJjR_tu3UXkGKHCKaMIcri8,15230
+github/GistComment.py,sha256=Bh4j2lvIl7lmRtPYuneOAU9C2ENtGUTdL5SjDu6sYZQ,7187
+github/GistFile.py,sha256=RZWinuJBhSQ2V4K2jU9PLVEeMvp6nLWM3b4LxsOAItY,5168
+github/GistHistoryState.py,sha256=B2CY5KWBySuIqJfIWdUfSyHklRPiyuSi2lgdmVuvXIE,10660
+github/GitAuthor.py,sha256=KkvmNGbJLdBb2KaBI9b51YCHwqHVbhlNT-AkK5fW634,4925
+github/GitBlob.py,sha256=qIsFepFXDhtHeV7FePc2K9ArcZTEPqeTrH6DYydoVgA,5133
+github/GitCommit.py,sha256=P50SxhMzC41208FYNgt24q_5OCEjCer5pnv_eowNTIk,9603
+github/GitCommitVerification.py,sha256=mNB8LYL3HAK7H9j7tlnL7bsQNHFzIy-7ocFfVehkvF8,5178
+github/GitObject.py,sha256=gSKCYAv4aMnLYrIyfPbmwxuD1tFzdnmP6aLqul9YpJ4,4263
+github/GitRef.py,sha256=QdXAK6l-hEou-fz73agqmUhWGb2ubXHT8mB_UWeoFbk,5958
+github/GitRelease.py,sha256=mdi6VKI8fMPl3zqVG7fi3ixC8BXlm0BSCUJ3SNqZCuM,19855
+github/GitReleaseAsset.py,sha256=ej3ZvO5deyNABVOO6USbghjywYe5YHXbzRu9wYE2Qy8,9336
+github/GitTag.py,sha256=wOTNQy1WQcsm44SiA2Q4yyB-Y9HbjPO2K7pAR51IxR8,6682
+github/GitTree.py,sha256=iGdDGSup7MfQ3HuS4F5e7W_JWsU8dyz_XqdNqt39fR8,5460
+github/GitTreeElement.py,sha256=XiHf3uk9SBzdK7eqzVvuD8JzWzn2rg3LuS9hZzE-wAo,4975
+github/GithubApp.py,sha256=UaoMUb-6lwxz5Ho-rrixLl7qQLuwXUePICqGmr_ydgY,10064
+github/GithubException.py,sha256=OBCphJtOygdOID_-6pekI13tFoO1xPF_-B6TbvIP-jI,7175
+github/GithubIntegration.py,sha256=iO4OX27rJjr8BsVmwbue1IpJpMZlQJVUEeLu2OsT3S0,15186
+github/GithubObject.py,sha256=2R3MxaWqsBwSWmjN0X0ZYVEGXEyL5_qNsJabflNhj-k,22219
+github/GithubRetry.py,sha256=Rzz4pN-0x5tEZ9Z-q9VrhS04y6rficm9SnSmru6dLH0,12063
+github/GitignoreTemplate.py,sha256=el6be_upqLHbVc9N36K71LT1iR82bGBNftg7j1zpepM,4178
+github/GlobalAdvisory.py,sha256=K98M-E0zPg5MU60GFMJwFtH-fPsgwClQGaNLjNthdic,6500
+github/Hook.py,sha256=GWufDuLdPEtPYE__BumrZN-cITS41mD2c0dibd4SQ0U,10162
+github/HookDelivery.py,sha256=xassYw8R-YdLEzzsmP3l7_nmrd9ED57lI8ybe-Nd58w,9555
+github/HookDescription.py,sha256=uiAtb4k8CDPcNG63aal3zyQTTEer7b3cPqh9hm517Lk,4587
+github/HookResponse.py,sha256=y8lPbm9h9APbhrHQ0nKPBardAqTozQYin5tD0eHuIAo,4250
+github/InputFileContent.py,sha256=U8bCrl2z9KHQhWtxc-fwliIwJDZlcvUbzY8WbhKfIx0,3480
+github/InputGitAuthor.py,sha256=iW7vxND5eUq6Ull_aH7J8iMKfTZ2ejGLtoSoSGGDX2E,3820
+github/InputGitTreeElement.py,sha256=gAq3OTo0NOOmyjqqtNbwk3wagrmaOp1n-XK990tcYss,3933
+github/Installation.py,sha256=tuVqoD2xRT-2tjYfFlFf4MYr2k-NJMKGRmo6_ugfexk,12641
+github/InstallationAuthorization.py,sha256=4_nDj-7Ltcr1Wdc9yqs-sOuMH6BPA5Pcc_cI067bNZI,6901
+github/Invitation.py,sha256=3KGXH57B5VbU1dUk83AqE9GZ3rBeR79QtXN8WD7yY0o,7305
+github/Issue.py,sha256=7T-S9QZ1ifQEIRxRJ0HPRL9nVe5UpuIi3pJhBfOTTvs,30560
+github/IssueComment.py,sha256=bjwtq1QDFxq3q2jOeNt6fF3Ia85xvr0Xc240pmQ6Wps,13141
+github/IssueEvent.py,sha256=GXMUXdk0vT4EFT-l3HJoLt__7iUMB7WiPFb3jb4gJWM,12108
+github/IssuePullRequest.py,sha256=yYYgYohKY46v9Eq9eWNQAV7R8fsHrx8d6vNeUxOgx-Y,4869
+github/Label.py,sha256=Ohli5Ya-vaNtyKnUUoanRs8hcBvcD58pOcyh5nJkgwU,7617
+github/License.py,sha256=ffxavMjTTK1inKTmt96Avrv6d9sB0OUnV4tCaO5udmc,7992
+github/MainClass.py,sha256=mwPg14ViVjmlz9AAFLjlDttgAzC0AYvERVY76PsCpRc,49018
+github/Membership.py,sha256=PoZy0XAAtNPGvU2G1h90zBQzpYUJzvjDEhWJkVunCtA,6575
+github/MergedUpstream.py,sha256=Mxqfh8GV2aVs682hwnWsVala6O6OsuvkvL4PuD3vYLE,3372
+github/Migration.py,sha256=FD4X2ZyjH9zFIGE-wABt_pd7qY09Gs1BdPNSfoTAChc,12145
+github/Milestone.py,sha256=ScAUsM3UwHKmY5uUdI0XB-92fqAT-4xPrFm_uORsjiw,10985
+github/NamedEnterpriseUser.py,sha256=IGLTM3XL7gouxmbTxZDlfMzROiQu_bEJ7bNG-2DJTbs,10543
+github/NamedUser.py,sha256=8fbxtu98KHZ5TlcgaxQilmfidh-VuvGKSvVKBD-25cg,30543
+github/Notification.py,sha256=G3ZlYtbwEVX2K7SGMfaKNbCMXlEaEslIcN_Tohec2e4,8434
+github/NotificationSubject.py,sha256=9Vl6b_j98V4UhGIkHRXYj_v3bAUIH0qSbh-AJs-bJPU,4960
+github/Organization.py,sha256=jUoT6Pt0X6qiwuLKdv4_1O2d1ZlkhmRBAWtrgbh2iDY,95864
+github/OrganizationCustomProperty.py,sha256=7AgcQgTpOkYgv2mAmwvqmHEHFPaEHWLTDNqCWpMeJPc,7941
+github/OrganizationDependabotAlert.py,sha256=rI7b3NS4Dhs4Cz3SZBmZaF95qMGf5k0zsfUc9Rgqz2I,2983
+github/OrganizationSecret.py,sha256=c34t5QiHgYfPEYoj4I4j5HnvK0ALuR_Cj7Y-TGXPFDM,6336
+github/OrganizationVariable.py,sha256=qQcoHpGjdhb0IPD76GjL8Biqvgdeq_2nD3tO2IOu600,6065
+github/PaginatedList.py,sha256=GdBlOD9FxR2wVb8CQwtmG1t9UIy7jcL4i1Qr6gFMUH0,19548
+github/Path.py,sha256=ZmUgLnYu-WPHt54qhA2GjFZxFb1oR--lHKoiGrmgfRQ,4952
+github/Permissions.py,sha256=EqchnebEsf8zhxa1_ONIS2BlWPO-KmjUK6Q9J5W73Zk,5403
+github/Plan.py,sha256=FtYnYjHjsEGVM4gs6aTCSVPIHp6eKY2dtYW88yDC5BQ,5297
+github/Project.py,sha256=9_DwCeIUTU7QMYEuMnQk0g--qUy4puErSA9nQXguiWs,11991
+github/ProjectCard.py,sha256=ICxGVyuzNDaQ6oWe1O65g4eVJqSrZjh6xDGuh0isKsU,10881
+github/ProjectColumn.py,sha256=2dvDWGAT1fbE0Z75WOz9EevmHJVe3AfzOfrDSXgGgmU,10141
+github/PublicKey.py,sha256=gD5-H7eqCvYGW1MDJLIra7wz0HZI5br9GgUVqMtKuI0,6587
+github/PullRequest.py,sha256=yOWWfKFnvQcAJ0zGmecqFSNZU5UPdiPsvFnjIHx_6Kc,51191
+github/PullRequestComment.py,sha256=-y9Y8BspYRe8hgt5pSRFOCuv-HQ4P45XSAlpAIuT25s,17133
+github/PullRequestMergeStatus.py,sha256=o2x4A_YxXAF-1dMiOAZLP8rbfl-6nbsgkVgU5iYc8c0,4503
+github/PullRequestPart.py,sha256=8G3qy1aFvjdWsck7GErNS1heApGSOIHD0KQ_wVjf3vU,5385
+github/PullRequestReview.py,sha256=Zh1spNf3mST9VTfPVvDd052I-ksoGLX1EcBy7cqWOXE,7766
+github/Rate.py,sha256=zppWBE9wwGgg28TtGQZom6caG-kYz7Edw8O6bK4o-jk,5006
+github/RateLimit.py,sha256=aXmT5-B6W4AUQD1K79g012MCmmwITRaUG4VbHW6gIa8,7871
+github/Reaction.py,sha256=YauwrJTcoPhUfP85sgMg0FuLRvJceloqktJ6wfXesu8,5576
+github/Referrer.py,sha256=_ZLDv74O26rySNT8OWCYJRxlPw27V7bw_3bRZlVNMhw,4701
+github/RepoCodeSecurityConfig.py,sha256=TaMX2mYEW-6nsDbxYs-OAhnV2aveHGtiPa09mH-W4tk,4682
+github/Repository.py,sha256=wOlqESLJqZpohEclXLxpHS_-jDWohaVyzPplG58w_i8,204970
+github/RepositoryAdvisory.py,sha256=iu6LtELT85aC7PPxqDsOu1FFPZW_XUIls2Pf_233QFM,18310
+github/RepositoryDiscussion.py,sha256=imjaUm7riDnuNENvUVIB0GotoN2TXsXO3qthMcOOtU8,9163
+github/RepositoryDiscussionCategory.py,sha256=Wu8tplwDQdfzc8kfuKxMKDHPg3LOVLOg9pMFydyHNqQ,6803
+github/RepositoryDiscussionComment.py,sha256=xKCbqPHdN4Qa8MO02Q4hkjvid3qtpeUJgq99VmN_uoY,6581
+github/RepositoryKey.py,sha256=-g6f9PPaMwpTNCeGnfc787gSE7s3WH1jR8Vd-BjaRAA,7508
+github/RepositoryPreferences.py,sha256=WhXwIqydh4PewCjKt7WXGzmVZU3CZodkilLojSSESrM,4555
+github/Requester.py,sha256=0BuG_dB_aol27T-QEIieZrgqHxT8idx9GlTaxiSoRds,52603
+github/RequiredPullRequestReviews.py,sha256=13mLV-Fa2ZQj30v0Zl_5vOoaeZLoAIaMCz2PfN_XmdU,7704
+github/RequiredStatusChecks.py,sha256=QQuY8o1H6cv7HafvpBhu8Mm45hsYoroQtNdhwVHoFO8,4966
+github/Secret.py,sha256=OzFE9tp62nd02_rf1KMKxYpTzxV5DFvJKMRh4IJ5jls,5741
+github/SecurityAndAnalysis.py,sha256=31x-3HrAqWc0dfiZfnwcw-HmQIeXWvMOXFjWTFiXuJ0,8178
+github/SecurityAndAnalysisFeature.py,sha256=CJJ6rR4AzGigv4RfVbPCZKHq6USQAGS6b9BW8uE29XI,4258
+github/SelfHostedActionsRunner.py,sha256=60ucM62i80VDG9migGM0pFWeJ4seDczNGu_Tp4OanjU,5524
+github/SourceImport.py,sha256=Bcpc_MlsYB0VjwwuviLelh_3bSfZGxssnIQKm9PMqC0,11372
+github/Stargazer.py,sha256=7nNVcVeIqjK9SWr1QMG0M_fb6pHijPzm3AMLmGpL5ww,4825
+github/StatsCodeFrequency.py,sha256=R7XWZsjSExFjQvNWc9TZ2bJhBGLxywoU5LfVjKao7V0,4290
+github/StatsCommitActivity.py,sha256=YmuVoKMvfTcYpdqZgfYddZ1fIML_I8786-zXxS0vdU4,4472
+github/StatsContributor.py,sha256=7e46cpqLCfwCojxjzVVA4kBO-76IA50gZP8hbX5C2lw,5805
+github/StatsParticipation.py,sha256=TsW0s5CK2S042aZARHZtmhRntUIEY-BioaCsxa3mQxA,4244
+github/StatsPunchCard.py,sha256=JBAWWEUowsCiMAY98kT7iZRGQ2KUsq4n8b27zI2qQHA,4012
+github/Tag.py,sha256=1vPAqpjcJ9k-Gfl2L6zaiYEGeTE5JlmBvMrN5qw4O1g,5402
+github/Team.py,sha256=LKEFCKmx4oE7MnUV-6tkA0g5AX7lhPhuBb8KDV5I_Jg,23893
+github/TeamDiscussion.py,sha256=BLVmJYU3Er9VQO1005gzPvWqpy82GLULlDFFzriegRQ,6599
+github/TimelineEvent.py,sha256=QYM38PNDtiDeXZuQURHc86OGw6PflmXyUN6W0S4_e_I,7533
+github/TimelineEventSource.py,sha256=tf5x3asgFzz3z3SbOmINxBAA4BMuoSVS-X_ZkkHU4hA,4324
+github/Topic.py,sha256=codJNHBB5imQvI4bVJUXl7QH8NEgsJ_JA2YgtvPupg4,8373
+github/Traffic.py,sha256=RTkvDq-RyFRkveTpi_kwZ3qITFkz249pXh3g1SlENbg,4768
+github/UserKey.py,sha256=gRGKuveCFtZI_ZhId6hHKodS8El3snf9Mk7wMmCLEwM,6272
+github/Variable.py,sha256=3sOXF7nJlia_YEzTBF9nrZd5BPsWo5akXCiAeZE0xvc,5699
+github/View.py,sha256=9cP39jexYuQOhYDHheWCy1qOEVUlDG_0ACF1LJXf8fA,4845
+github/Workflow.py,sha256=YA3a37RAeIjBGmFn1kXicg_ZyV02WnOBGLe56KObIdI,12088
+github/WorkflowJob.py,sha256=FckU3PIOfHK-8RMlkwv9v_xNypGM82aG4-Gjy0TblJI,10652
+github/WorkflowRun.py,sha256=zm4lX7BCoPzpMuAiOB8CSgNzgQ4vFOyXKlSFlTLFL8c,19556
+github/WorkflowStep.py,sha256=vloX2qGP9tzjpeAIcU1B_EoY9TLn-Z15QZQnx8I4LeQ,5643
+github/__init__.py,sha256=62guPyYWH5dj0djnitPdPX-GpGa1xH4bc3WCYncXE60,5401
+github/__pycache__/AccessToken.cpython-310.pyc,,
+github/__pycache__/AdvisoryBase.cpython-310.pyc,,
+github/__pycache__/AdvisoryCredit.cpython-310.pyc,,
+github/__pycache__/AdvisoryCreditDetailed.cpython-310.pyc,,
+github/__pycache__/AdvisoryVulnerability.cpython-310.pyc,,
+github/__pycache__/AdvisoryVulnerabilityPackage.cpython-310.pyc,,
+github/__pycache__/AppAuthentication.cpython-310.pyc,,
+github/__pycache__/ApplicationOAuth.cpython-310.pyc,,
+github/__pycache__/Artifact.cpython-310.pyc,,
+github/__pycache__/Auth.cpython-310.pyc,,
+github/__pycache__/AuthenticatedUser.cpython-310.pyc,,
+github/__pycache__/Authorization.cpython-310.pyc,,
+github/__pycache__/AuthorizationApplication.cpython-310.pyc,,
+github/__pycache__/Autolink.cpython-310.pyc,,
+github/__pycache__/Branch.cpython-310.pyc,,
+github/__pycache__/BranchProtection.cpython-310.pyc,,
+github/__pycache__/CVSS.cpython-310.pyc,,
+github/__pycache__/CWE.cpython-310.pyc,,
+github/__pycache__/CheckRun.cpython-310.pyc,,
+github/__pycache__/CheckRunAnnotation.cpython-310.pyc,,
+github/__pycache__/CheckRunOutput.cpython-310.pyc,,
+github/__pycache__/CheckSuite.cpython-310.pyc,,
+github/__pycache__/Clones.cpython-310.pyc,,
+github/__pycache__/CodeScanAlert.cpython-310.pyc,,
+github/__pycache__/CodeScanAlertInstance.cpython-310.pyc,,
+github/__pycache__/CodeScanAlertInstanceLocation.cpython-310.pyc,,
+github/__pycache__/CodeScanRule.cpython-310.pyc,,
+github/__pycache__/CodeScanTool.cpython-310.pyc,,
+github/__pycache__/CodeSecurityConfig.cpython-310.pyc,,
+github/__pycache__/CodeSecurityConfigRepository.cpython-310.pyc,,
+github/__pycache__/Commit.cpython-310.pyc,,
+github/__pycache__/CommitCombinedStatus.cpython-310.pyc,,
+github/__pycache__/CommitComment.cpython-310.pyc,,
+github/__pycache__/CommitStats.cpython-310.pyc,,
+github/__pycache__/CommitStatus.cpython-310.pyc,,
+github/__pycache__/Comparison.cpython-310.pyc,,
+github/__pycache__/Consts.cpython-310.pyc,,
+github/__pycache__/ContentFile.cpython-310.pyc,,
+github/__pycache__/Copilot.cpython-310.pyc,,
+github/__pycache__/CopilotSeat.cpython-310.pyc,,
+github/__pycache__/DefaultCodeSecurityConfig.cpython-310.pyc,,
+github/__pycache__/DependabotAlert.cpython-310.pyc,,
+github/__pycache__/DependabotAlertAdvisory.cpython-310.pyc,,
+github/__pycache__/DependabotAlertDependency.cpython-310.pyc,,
+github/__pycache__/DependabotAlertVulnerability.cpython-310.pyc,,
+github/__pycache__/Deployment.cpython-310.pyc,,
+github/__pycache__/DeploymentStatus.cpython-310.pyc,,
+github/__pycache__/DiscussionBase.cpython-310.pyc,,
+github/__pycache__/DiscussionCommentBase.cpython-310.pyc,,
+github/__pycache__/Download.cpython-310.pyc,,
+github/__pycache__/Enterprise.cpython-310.pyc,,
+github/__pycache__/EnterpriseConsumedLicenses.cpython-310.pyc,,
+github/__pycache__/Environment.cpython-310.pyc,,
+github/__pycache__/EnvironmentDeploymentBranchPolicy.cpython-310.pyc,,
+github/__pycache__/EnvironmentProtectionRule.cpython-310.pyc,,
+github/__pycache__/EnvironmentProtectionRuleReviewer.cpython-310.pyc,,
+github/__pycache__/Event.cpython-310.pyc,,
+github/__pycache__/File.cpython-310.pyc,,
+github/__pycache__/Gist.cpython-310.pyc,,
+github/__pycache__/GistComment.cpython-310.pyc,,
+github/__pycache__/GistFile.cpython-310.pyc,,
+github/__pycache__/GistHistoryState.cpython-310.pyc,,
+github/__pycache__/GitAuthor.cpython-310.pyc,,
+github/__pycache__/GitBlob.cpython-310.pyc,,
+github/__pycache__/GitCommit.cpython-310.pyc,,
+github/__pycache__/GitCommitVerification.cpython-310.pyc,,
+github/__pycache__/GitObject.cpython-310.pyc,,
+github/__pycache__/GitRef.cpython-310.pyc,,
+github/__pycache__/GitRelease.cpython-310.pyc,,
+github/__pycache__/GitReleaseAsset.cpython-310.pyc,,
+github/__pycache__/GitTag.cpython-310.pyc,,
+github/__pycache__/GitTree.cpython-310.pyc,,
+github/__pycache__/GitTreeElement.cpython-310.pyc,,
+github/__pycache__/GithubApp.cpython-310.pyc,,
+github/__pycache__/GithubException.cpython-310.pyc,,
+github/__pycache__/GithubIntegration.cpython-310.pyc,,
+github/__pycache__/GithubObject.cpython-310.pyc,,
+github/__pycache__/GithubRetry.cpython-310.pyc,,
+github/__pycache__/GitignoreTemplate.cpython-310.pyc,,
+github/__pycache__/GlobalAdvisory.cpython-310.pyc,,
+github/__pycache__/Hook.cpython-310.pyc,,
+github/__pycache__/HookDelivery.cpython-310.pyc,,
+github/__pycache__/HookDescription.cpython-310.pyc,,
+github/__pycache__/HookResponse.cpython-310.pyc,,
+github/__pycache__/InputFileContent.cpython-310.pyc,,
+github/__pycache__/InputGitAuthor.cpython-310.pyc,,
+github/__pycache__/InputGitTreeElement.cpython-310.pyc,,
+github/__pycache__/Installation.cpython-310.pyc,,
+github/__pycache__/InstallationAuthorization.cpython-310.pyc,,
+github/__pycache__/Invitation.cpython-310.pyc,,
+github/__pycache__/Issue.cpython-310.pyc,,
+github/__pycache__/IssueComment.cpython-310.pyc,,
+github/__pycache__/IssueEvent.cpython-310.pyc,,
+github/__pycache__/IssuePullRequest.cpython-310.pyc,,
+github/__pycache__/Label.cpython-310.pyc,,
+github/__pycache__/License.cpython-310.pyc,,
+github/__pycache__/MainClass.cpython-310.pyc,,
+github/__pycache__/Membership.cpython-310.pyc,,
+github/__pycache__/MergedUpstream.cpython-310.pyc,,
+github/__pycache__/Migration.cpython-310.pyc,,
+github/__pycache__/Milestone.cpython-310.pyc,,
+github/__pycache__/NamedEnterpriseUser.cpython-310.pyc,,
+github/__pycache__/NamedUser.cpython-310.pyc,,
+github/__pycache__/Notification.cpython-310.pyc,,
+github/__pycache__/NotificationSubject.cpython-310.pyc,,
+github/__pycache__/Organization.cpython-310.pyc,,
+github/__pycache__/OrganizationCustomProperty.cpython-310.pyc,,
+github/__pycache__/OrganizationDependabotAlert.cpython-310.pyc,,
+github/__pycache__/OrganizationSecret.cpython-310.pyc,,
+github/__pycache__/OrganizationVariable.cpython-310.pyc,,
+github/__pycache__/PaginatedList.cpython-310.pyc,,
+github/__pycache__/Path.cpython-310.pyc,,
+github/__pycache__/Permissions.cpython-310.pyc,,
+github/__pycache__/Plan.cpython-310.pyc,,
+github/__pycache__/Project.cpython-310.pyc,,
+github/__pycache__/ProjectCard.cpython-310.pyc,,
+github/__pycache__/ProjectColumn.cpython-310.pyc,,
+github/__pycache__/PublicKey.cpython-310.pyc,,
+github/__pycache__/PullRequest.cpython-310.pyc,,
+github/__pycache__/PullRequestComment.cpython-310.pyc,,
+github/__pycache__/PullRequestMergeStatus.cpython-310.pyc,,
+github/__pycache__/PullRequestPart.cpython-310.pyc,,
+github/__pycache__/PullRequestReview.cpython-310.pyc,,
+github/__pycache__/Rate.cpython-310.pyc,,
+github/__pycache__/RateLimit.cpython-310.pyc,,
+github/__pycache__/Reaction.cpython-310.pyc,,
+github/__pycache__/Referrer.cpython-310.pyc,,
+github/__pycache__/RepoCodeSecurityConfig.cpython-310.pyc,,
+github/__pycache__/Repository.cpython-310.pyc,,
+github/__pycache__/RepositoryAdvisory.cpython-310.pyc,,
+github/__pycache__/RepositoryDiscussion.cpython-310.pyc,,
+github/__pycache__/RepositoryDiscussionCategory.cpython-310.pyc,,
+github/__pycache__/RepositoryDiscussionComment.cpython-310.pyc,,
+github/__pycache__/RepositoryKey.cpython-310.pyc,,
+github/__pycache__/RepositoryPreferences.cpython-310.pyc,,
+github/__pycache__/Requester.cpython-310.pyc,,
+github/__pycache__/RequiredPullRequestReviews.cpython-310.pyc,,
+github/__pycache__/RequiredStatusChecks.cpython-310.pyc,,
+github/__pycache__/Secret.cpython-310.pyc,,
+github/__pycache__/SecurityAndAnalysis.cpython-310.pyc,,
+github/__pycache__/SecurityAndAnalysisFeature.cpython-310.pyc,,
+github/__pycache__/SelfHostedActionsRunner.cpython-310.pyc,,
+github/__pycache__/SourceImport.cpython-310.pyc,,
+github/__pycache__/Stargazer.cpython-310.pyc,,
+github/__pycache__/StatsCodeFrequency.cpython-310.pyc,,
+github/__pycache__/StatsCommitActivity.cpython-310.pyc,,
+github/__pycache__/StatsContributor.cpython-310.pyc,,
+github/__pycache__/StatsParticipation.cpython-310.pyc,,
+github/__pycache__/StatsPunchCard.cpython-310.pyc,,
+github/__pycache__/Tag.cpython-310.pyc,,
+github/__pycache__/Team.cpython-310.pyc,,
+github/__pycache__/TeamDiscussion.cpython-310.pyc,,
+github/__pycache__/TimelineEvent.cpython-310.pyc,,
+github/__pycache__/TimelineEventSource.cpython-310.pyc,,
+github/__pycache__/Topic.cpython-310.pyc,,
+github/__pycache__/Traffic.cpython-310.pyc,,
+github/__pycache__/UserKey.cpython-310.pyc,,
+github/__pycache__/Variable.cpython-310.pyc,,
+github/__pycache__/View.cpython-310.pyc,,
+github/__pycache__/Workflow.cpython-310.pyc,,
+github/__pycache__/WorkflowJob.cpython-310.pyc,,
+github/__pycache__/WorkflowRun.cpython-310.pyc,,
+github/__pycache__/WorkflowStep.cpython-310.pyc,,
+github/__pycache__/__init__.cpython-310.pyc,,
+github/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

venv/lib/python3.10/site-packages/PyGithub-2.6.1.dist-info/WHEEL

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

venv/lib/python3.10/site-packages/PyGithub-2.6.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+github

venv/lib/python3.10/site-packages/_soundfile.py

@@ -0,0 +1,11 @@
+# auto-generated file
+import _cffi_backend
+
+ffi = _cffi_backend.FFI('_soundfile',
+    _version = 0x2601,
+    _types = b'\x00\x00\x12\x0D\x00\x00\x68\x03\x00\x00\x07\x01\x00\x00\x67\x03\x00\x00\x75\x03\x00\x00\x00\x0F\x00\x00\x12\x0D\x00\x00\x6A\x03\x00\x00\x07\x01\x00\x00\x03\x11\x00\x00\x00\x0F\x00\x00\x12\x0D\x00\x00\x07\x01\x00\x00\x07\x01\x00\x00\x03\x11\x00\x00\x07\x01\x00\x00\x00\x0F\x00\x00\x07\x0D\x00\x00\x69\x03\x00\x00\x00\x0F\x00\x00\x07\x0D\x00\x00\x12\x11\x00\x00\x07\x01\x00\x00\x00\x0F\x00\x00\x07\x0D\x00\x00\x07\x01\x00\x00\x00\x0F\x00\x00\x07\x0D\x00\x00\x00\x0F\x00\x00\x02\x0D\x00\x00\x67\x03\x00\x00\x00\x0F\x00\x00\x02\x0D\x00\x00\x12\x11\x00\x00\x00\x0F\x00\x00\x02\x0D\x00\x00\x12\x11\x00\x00\x6A\x03\x00\x00\x1C\x01\x00\x00\x00\x0F\x00\x00\x02\x0D\x00\x00\x12\x11\x00\x00\x07\x01\x00\x00\x07\x11\x00\x00\x00\x0F\x00\x00\x02\x0D\x00\x00\x12\x11\x00\x00\x07\x01\x00\x00\x04\x11\x00\x00\x07\x01\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x12\x11\x00\x00\x6B\x03\x00\x00\x17\x01\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x12\x11\x00\x00\x6F\x03\x00\x00\x17\x01\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x12\x11\x00\x00\x02\x03\x00\x00\x17\x01\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x12\x11\x00\x00\x17\x01\x00\x00\x07\x01\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x12\x11\x00\x00\x74\x03\x00\x00\x17\x01\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x12\x11\x00\x00\x04\x11\x00\x00\x17\x01\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x17\x01\x00\x00\x07\x01\x00\x00\x04\x11\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x04\x11\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x04\x11\x00\x00\x17\x01\x00\x00\x04\x11\x00\x00\x00\x0F\x00\x00\x36\x0D\x00\x00\x75\x03\x00\x00\x17\x01\x00\x00\x04\x11\x00\x00\x00\x0F\x00\x00\x75\x0D\x00\x00\x12\x11\x00\x00\x00\x0F\x00\x00\x00\x09\x00\x00\x01\x09\x00\x00\x02\x09\x00\x00\x03\x09\x00\x00\x02\x01\x00\x00\x0E\x01\x00\x00\x00\x0B\x00\x00\x01\x0B\x00\x00\x02\x0B\x00\x00\x0D\x01\x00\x00\x51\x03\x00\x00\x56\x03\x00\x00\x59\x03\x00\x00\x5E\x03\x00\x00\x05\x01\x00\x00\x00\x01',
+    _globals = (b'\xFF\xFF\xFF\x0BSFC_FILE_TRUNCATE',4224,b'\xFF\xFF\xFF\x0BSFC_GET_FORMAT_INFO',4136,b'\xFF\xFF\xFF\x0BSFC_GET_FORMAT_MAJOR',4145,b'\xFF\xFF\xFF\x0BSFC_GET_FORMAT_MAJOR_COUNT',4144,b'\xFF\xFF\xFF\x0BSFC_GET_FORMAT_SUBTYPE',4147,b'\xFF\xFF\xFF\x0BSFC_GET_FORMAT_SUBTYPE_COUNT',4146,b'\xFF\xFF\xFF\x0BSFC_GET_LIB_VERSION',4096,b'\xFF\xFF\xFF\x0BSFC_GET_LOG_INFO',4097,b'\xFF\xFF\xFF\x0BSFC_SET_BITRATE_MODE',4869,b'\xFF\xFF\xFF\x0BSFC_SET_CLIPPING',4288,b'\xFF\xFF\xFF\x0BSFC_SET_COMPRESSION_LEVEL',4865,b'\xFF\xFF\xFF\x0BSFC_SET_SCALE_FLOAT_INT_READ',4116,b'\xFF\xFF\xFF\x0BSFC_SET_SCALE_INT_FLOAT_WRITE',4117,b'\xFF\xFF\xFF\x0BSFM_RDWR',48,b'\xFF\xFF\xFF\x0BSFM_READ',16,b'\xFF\xFF\xFF\x0BSFM_WRITE',32,b'\xFF\xFF\xFF\x0BSF_BITRATE_MODE_AVERAGE',1,b'\xFF\xFF\xFF\x0BSF_BITRATE_MODE_CONSTANT',0,b'\xFF\xFF\xFF\x0BSF_BITRATE_MODE_VARIABLE',2,b'\xFF\xFF\xFF\x0BSF_FALSE',0,b'\xFF\xFF\xFF\x0BSF_FORMAT_ENDMASK',805306368,b'\xFF\xFF\xFF\x0BSF_FORMAT_SUBMASK',65535,b'\xFF\xFF\xFF\x0BSF_FORMAT_TYPEMASK',268369920,b'\xFF\xFF\xFF\x0BSF_TRUE',1,b'\x00\x00\x20\x23sf_close',0,b'\x00\x00\x2D\x23sf_command',0,b'\x00\x00\x20\x23sf_error',0,b'\x00\x00\x18\x23sf_error_number',0,b'\x00\x00\x23\x23sf_error_str',0,b'\x00\x00\x1D\x23sf_format_check',0,b'\x00\x00\x14\x23sf_get_string',0,b'\x00\x00\x06\x23sf_open',0,b'\x00\x00\x0B\x23sf_open_fd',0,b'\x00\x00\x00\x23sf_open_virtual',0,b'\x00\x00\x20\x23sf_perror',0,b'\x00\x00\x33\x23sf_read_double',0,b'\x00\x00\x38\x23sf_read_float',0,b'\x00\x00\x3D\x23sf_read_int',0,b'\x00\x00\x4C\x23sf_read_raw',0,b'\x00\x00\x47\x23sf_read_short',0,b'\x00\x00\x4C\x23sf_readf_double',0,b'\x00\x00\x4C\x23sf_readf_float',0,b'\x00\x00\x4C\x23sf_readf_int',0,b'\x00\x00\x4C\x23sf_readf_short',0,b'\x00\x00\x42\x23sf_seek',0,b'\x00\x00\x28\x23sf_set_string',0,b'\x00\x00\x11\x23sf_strerror',0,b'\x00\x00\x1B\x23sf_version_string',0,b'\x00\x00\x33\x23sf_write_double',0,b'\x00\x00\x38\x23sf_write_float',0,b'\x00\x00\x3D\x23sf_write_int',0,b'\x00\x00\x4C\x23sf_write_raw',0,b'\x00\x00\x47\x23sf_write_short',0,b'\x00\x00\x63\x23sf_write_sync',0,b'\x00\x00\x4C\x23sf_writef_double',0,b'\x00\x00\x4C\x23sf_writef_float',0,b'\x00\x00\x4C\x23sf_writef_int',0,b'\x00\x00\x4C\x23sf_writef_short',0),
+    _struct_unions = ((b'\x00\x00\x00\x66\x00\x00\x00\x02SF_FORMAT_INFO',b'\x00\x00\x02\x11format',b'\x00\x00\x07\x11name',b'\x00\x00\x07\x11extension'),(b'\x00\x00\x00\x67\x00\x00\x00\x02SF_INFO',b'\x00\x00\x36\x11frames',b'\x00\x00\x02\x11samplerate',b'\x00\x00\x02\x11channels',b'\x00\x00\x02\x11format',b'\x00\x00\x02\x11sections',b'\x00\x00\x02\x11seekable'),(b'\x00\x00\x00\x68\x00\x00\x00\x02SF_VIRTUAL_IO',b'\x00\x00\x71\x11get_filelen',b'\x00\x00\x70\x11seek',b'\x00\x00\x72\x11read',b'\x00\x00\x73\x11write',b'\x00\x00\x71\x11tell'),(b'\x00\x00\x00\x69\x00\x00\x00\x10SNDFILE_tag',)),
+    _enums = (b'\x00\x00\x00\x6C\x00\x00\x00\x16$1\x00SF_FORMAT_SUBMASK,SF_FORMAT_TYPEMASK,SF_FORMAT_ENDMASK',b'\x00\x00\x00\x6D\x00\x00\x00\x16$2\x00SFC_GET_LIB_VERSION,SFC_GET_LOG_INFO,SFC_GET_FORMAT_INFO,SFC_GET_FORMAT_MAJOR_COUNT,SFC_GET_FORMAT_MAJOR,SFC_GET_FORMAT_SUBTYPE_COUNT,SFC_GET_FORMAT_SUBTYPE,SFC_FILE_TRUNCATE,SFC_SET_CLIPPING,SFC_SET_SCALE_FLOAT_INT_READ,SFC_SET_SCALE_INT_FLOAT_WRITE,SFC_SET_COMPRESSION_LEVEL,SFC_SET_BITRATE_MODE',b'\x00\x00\x00\x6E\x00\x00\x00\x16$3\x00SF_FALSE,SF_TRUE,SFM_READ,SFM_WRITE,SFM_RDWR,SF_BITRATE_MODE_CONSTANT,SF_BITRATE_MODE_AVERAGE,SF_BITRATE_MODE_VARIABLE'),
+    _typenames = (b'\x00\x00\x00\x66SF_FORMAT_INFO',b'\x00\x00\x00\x67SF_INFO',b'\x00\x00\x00\x68SF_VIRTUAL_IO',b'\x00\x00\x00\x69SNDFILE',b'\x00\x00\x00\x36sf_count_t',b'\x00\x00\x00\x71sf_vio_get_filelen',b'\x00\x00\x00\x72sf_vio_read',b'\x00\x00\x00\x70sf_vio_seek',b'\x00\x00\x00\x71sf_vio_tell',b'\x00\x00\x00\x73sf_vio_write'),
+)

venv/lib/python3.10/site-packages/cython.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python
+
+#
+#   Cython -- Main Program, generic
+#
+
+try:
+    from typing import TYPE_CHECKING
+except ImportError:
+    TYPE_CHECKING = False
+
+if not TYPE_CHECKING and __name__ == '__main__':
+
+    import os
+    import sys
+
+    # Make sure we import the right Cython
+    cythonpath, _ = os.path.split(os.path.realpath(__file__))
+    sys.path.insert(0, cythonpath)
+
+    from Cython.Compiler.Main import main
+    main(command_line = 1)
+
+else:
+    # Void cython.* directives.
+    from Cython.Shadow import *
+    ## and bring in the __version__
+    from Cython import __version__
+    from Cython import load_ipython_extension

venv/lib/python3.10/site-packages/github/WorkflowStep.py

@@ -0,0 +1,109 @@
+############################ Copyrights and license ############################
+#                                                                              #
+# Copyright 2012 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2012 Zearin <zearin@gonk.net>                                      #
+# Copyright 2013 AKFish <akfish@gmail.com>                                     #
+# Copyright 2013 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2014 Vincent Jacques <vincent@vincent-jacques.net>                 #
+# Copyright 2016 Jannis Gebauer <ja.geb@me.com>                                #
+# Copyright 2016 Peter Buckley <dx-pbuckley@users.noreply.github.com>          #
+# Copyright 2018 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2018 sfdye <tsfdye@gmail.com>                                      #
+# Copyright 2019 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2019 Wan Liuyang <tsfdye@gmail.com>                                #
+# Copyright 2020 Steve Kowalik <steven@wedontsleep.org>                        #
+# Copyright 2020 Victor Zeng <zacker150@users.noreply.github.com>              #
+# Copyright 2023 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2023 Jeppe Fihl-Pearson <tenzer@tenzer.dk>                         #
+# Copyright 2023 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+# Copyright 2023 Trim21 <trim21.me@gmail.com>                                  #
+# Copyright 2024 Enrico Minack <github@enrico.minack.dev>                      #
+# Copyright 2024 Jirka Borovec <6035284+Borda@users.noreply.github.com>        #
+#                                                                              #
+# This file is part of PyGithub.                                               #
+# http://pygithub.readthedocs.io/                                              #
+#                                                                              #
+# PyGithub is free software: you can redistribute it and/or modify it under    #
+# the terms of the GNU Lesser General Public License as published by the Free  #
+# Software Foundation, either version 3 of the License, or (at your option)    #
+# any later version.                                                           #
+#                                                                              #
+# PyGithub is distributed in the hope that it will be useful, but WITHOUT ANY  #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS    #
+# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more #
+# details.                                                                     #
+#                                                                              #
+# You should have received a copy of the GNU Lesser General Public License     #
+# along with PyGithub. If not, see <http://www.gnu.org/licenses/>.             #
+#                                                                              #
+################################################################################
+
+from datetime import datetime
+from typing import Any, Dict
+
+from github.GithubObject import Attribute, CompletableGithubObject, NotSet
+
+
+class WorkflowStep(CompletableGithubObject):
+    """
+    This class represents steps in a Workflow Job.
+
+    The reference can be found here
+    https://docs.github.com/en/rest/reference/actions#workflow-jobs
+
+    """
+
+    def _initAttributes(self) -> None:
+        self._completed_at: Attribute[datetime] = NotSet
+        self._conclusion: Attribute[str] = NotSet
+        self._name: Attribute[str] = NotSet
+        self._number: Attribute[int] = NotSet
+        self._started_at: Attribute[datetime] = NotSet
+        self._status: Attribute[str] = NotSet
+
+    def __repr__(self) -> str:
+        return self.get__repr__({"number": self._number.value, "name": self._name.value})
+
+    @property
+    def completed_at(self) -> datetime:
+        self._completeIfNotSet(self._completed_at)
+        return self._completed_at.value
+
+    @property
+    def conclusion(self) -> str:
+        self._completeIfNotSet(self._conclusion)
+        return self._conclusion.value
+
+    @property
+    def name(self) -> str:
+        self._completeIfNotSet(self._name)
+        return self._name.value
+
+    @property
+    def number(self) -> int:
+        self._completeIfNotSet(self._number)
+        return self._number.value
+
+    @property
+    def started_at(self) -> datetime:
+        self._completeIfNotSet(self._started_at)
+        return self._started_at.value
+
+    @property
+    def status(self) -> str:
+        self._completeIfNotSet(self._status)
+        return self._status.value
+
+    def _useAttributes(self, attributes: Dict[str, Any]) -> None:
+        if "completed_at" in attributes:  # pragma no branch
+            self._completed_at = self._makeDatetimeAttribute(attributes["completed_at"])
+        if "conclusion" in attributes:  # pragma no branch
+            self._conclusion = self._makeStringAttribute(attributes["conclusion"])
+        if "name" in attributes:  # pragma no branch
+            self._name = self._makeStringAttribute(attributes["name"])
+        if "number" in attributes:  # pragma no branch
+            self._number = self._makeIntAttribute(attributes["number"])
+        if "started_at" in attributes:  # pragma no branch
+            self._started_at = self._makeDatetimeAttribute(attributes["started_at"])
+        if "status" in attributes:  # pragma no branch
+            self._status = self._makeStringAttribute(attributes["status"])

venv/lib/python3.10/site-packages/isympy.py

@@ -0,0 +1,342 @@
+"""
+Python shell for SymPy.
+
+This is just a normal Python shell (IPython shell if you have the
+IPython package installed), that executes the following commands for
+the user:
+
+    >>> from __future__ import division
+    >>> from sympy import *
+    >>> x, y, z, t = symbols('x y z t')
+    >>> k, m, n = symbols('k m n', integer=True)
+    >>> f, g, h = symbols('f g h', cls=Function)
+    >>> init_printing()
+
+So starting 'isympy' is equivalent to starting Python (or IPython) and
+executing the above commands by hand.  It is intended for easy and quick
+experimentation with SymPy.  isympy is a good way to use SymPy as an
+interactive calculator. If you have IPython and Matplotlib installed, then
+interactive plotting is enabled by default.
+
+COMMAND LINE OPTIONS
+--------------------
+
+-c CONSOLE, --console=CONSOLE
+
+     Use the specified shell (Python or IPython) shell as the console
+     backend instead of the default one (IPython if present, Python
+     otherwise), e.g.:
+
+        $isympy -c python
+
+    CONSOLE must be one of 'ipython' or 'python'
+
+-p PRETTY, --pretty PRETTY
+
+    Setup pretty-printing in SymPy. When pretty-printing is enabled,
+    expressions can be printed with Unicode or ASCII. The default is
+    to use pretty-printing (with Unicode if the terminal supports it).
+    When this option is 'no', expressions will not be pretty-printed
+    and ASCII will be used:
+
+        $isympy -p no
+
+    PRETTY must be one of 'unicode', 'ascii', or 'no'
+
+-t TYPES, --types=TYPES
+
+    Setup the ground types for the polys.  By default, gmpy ground types
+    are used if gmpy2 or gmpy is installed, otherwise it falls back to python
+    ground types, which are a little bit slower.  You can manually
+    choose python ground types even if gmpy is installed (e.g., for
+    testing purposes):
+
+        $isympy -t python
+
+    TYPES must be one of 'gmpy', 'gmpy1' or 'python'
+
+    Note that the ground type gmpy1 is primarily intended for testing; it
+    forces the use of gmpy version 1 even if gmpy2 is available.
+
+    This is the same as setting the environment variable
+    SYMPY_GROUND_TYPES to the given ground type (e.g.,
+    SYMPY_GROUND_TYPES='gmpy')
+
+    The ground types can be determined interactively from the variable
+    sympy.polys.domains.GROUND_TYPES.
+
+-o ORDER, --order ORDER
+
+    Setup the ordering of terms for printing.  The default is lex, which
+    orders terms lexicographically (e.g., x**2 + x + 1). You can choose
+    other orderings, such as rev-lex, which will use reverse
+    lexicographic ordering (e.g., 1 + x + x**2):
+
+        $isympy -o rev-lex
+
+    ORDER must be one of 'lex', 'rev-lex', 'grlex', 'rev-grlex',
+    'grevlex', 'rev-grevlex', 'old', or 'none'.
+
+    Note that for very large expressions, ORDER='none' may speed up
+    printing considerably but the terms will have no canonical order.
+
+-q, --quiet
+
+    Print only Python's and SymPy's versions to stdout at startup.
+
+-d, --doctest
+
+    Use the same format that should be used for doctests.  This is
+    equivalent to -c python -p no.
+
+-C, --no-cache
+
+    Disable the caching mechanism.  Disabling the cache may slow certain
+    operations down considerably.  This is useful for testing the cache,
+    or for benchmarking, as the cache can result in deceptive timings.
+
+    This is equivalent to setting the environment variable
+    SYMPY_USE_CACHE to 'no'.
+
+-a, --auto-symbols (requires at least IPython 0.11)
+
+    Automatically create missing symbols.  Normally, typing a name of a
+    Symbol that has not been instantiated first would raise NameError,
+    but with this option enabled, any undefined name will be
+    automatically created as a Symbol.
+
+    Note that this is intended only for interactive, calculator style
+    usage. In a script that uses SymPy, Symbols should be instantiated
+    at the top, so that it's clear what they are.
+
+    This will not override any names that are already defined, which
+    includes the single character letters represented by the mnemonic
+    QCOSINE (see the "Gotchas and Pitfalls" document in the
+    documentation). You can delete existing names by executing "del
+    name".  If a name is defined, typing "'name' in dir()" will return True.
+
+    The Symbols that are created using this have default assumptions.
+    If you want to place assumptions on symbols, you should create them
+    using symbols() or var().
+
+    Finally, this only works in the top level namespace. So, for
+    example, if you define a function in isympy with an undefined
+    Symbol, it will not work.
+
+    See also the -i and -I options.
+
+-i, --int-to-Integer (requires at least IPython 0.11)
+
+    Automatically wrap int literals with Integer.  This makes it so that
+    things like 1/2 will come out as Rational(1, 2), rather than 0.5.  This
+    works by preprocessing the source and wrapping all int literals with
+    Integer.  Note that this will not change the behavior of int literals
+    assigned to variables, and it also won't change the behavior of functions
+    that return int literals.
+
+    If you want an int, you can wrap the literal in int(), e.g. int(3)/int(2)
+    gives 1.5 (with division imported from __future__).
+
+-I, --interactive (requires at least IPython 0.11)
+
+    This is equivalent to --auto-symbols --int-to-Integer.  Future options
+    designed for ease of interactive use may be added to this.
+
+-D, --debug
+
+    Enable debugging output.  This is the same as setting the
+    environment variable SYMPY_DEBUG to 'True'.  The debug status is set
+    in the variable SYMPY_DEBUG within isympy.
+
+-- IPython options
+
+    Additionally you can pass command line options directly to the IPython
+    interpreter (the standard Python shell is not supported).  However you
+    need to add the '--' separator between two types of options, e.g the
+    startup banner option and the colors option. You need to enter the
+    options as required by the version of IPython that you are using, too:
+
+    in IPython 0.11,
+
+        $isympy -q -- --colors=NoColor
+
+    or older versions of IPython,
+
+        $isympy -q -- -colors NoColor
+
+See also isympy --help.
+"""
+
+import os
+import sys
+
+# DO NOT IMPORT SYMPY HERE! Or the setting of the sympy environment variables
+# by the command line will break.
+
+def main() -> None:
+    from argparse import ArgumentParser, RawDescriptionHelpFormatter
+
+    VERSION = None
+    if '--version' in sys.argv:
+        # We cannot import sympy before this is run, because flags like -C and
+        # -t set environment variables that must be set before SymPy is
+        # imported. The only thing we need to import it for is to get the
+        # version, which only matters with the --version flag.
+        import sympy
+        VERSION = sympy.__version__
+
+    usage = 'isympy [options] -- [ipython options]'
+    parser = ArgumentParser(
+        usage=usage,
+        description=__doc__,
+        formatter_class=RawDescriptionHelpFormatter,
+    )
+
+    parser.add_argument('--version', action='version', version=VERSION)
+
+    parser.add_argument(
+        '-c', '--console',
+        dest='console',
+        action='store',
+        default=None,
+        choices=['ipython', 'python'],
+        metavar='CONSOLE',
+        help='select type of interactive session: ipython | python; defaults '
+        'to ipython if IPython is installed, otherwise python')
+
+    parser.add_argument(
+        '-p', '--pretty',
+        dest='pretty',
+        action='store',
+        default=None,
+        metavar='PRETTY',
+        choices=['unicode', 'ascii', 'no'],
+        help='setup pretty printing: unicode | ascii | no; defaults to '
+        'unicode printing if the terminal supports it, otherwise ascii')
+
+    parser.add_argument(
+        '-t', '--types',
+        dest='types',
+        action='store',
+        default=None,
+        metavar='TYPES',
+        choices=['gmpy', 'gmpy1', 'python'],
+        help='setup ground types: gmpy | gmpy1 | python; defaults to gmpy if gmpy2 '
+        'or gmpy is installed, otherwise python')
+
+    parser.add_argument(
+        '-o', '--order',
+        dest='order',
+        action='store',
+        default=None,
+        metavar='ORDER',
+        choices=['lex', 'grlex', 'grevlex', 'rev-lex', 'rev-grlex', 'rev-grevlex', 'old', 'none'],
+        help='setup ordering of terms: [rev-]lex | [rev-]grlex | [rev-]grevlex | old | none; defaults to lex')
+
+    parser.add_argument(
+        '-q', '--quiet',
+        dest='quiet',
+        action='store_true',
+        default=False,
+        help='print only version information at startup')
+
+    parser.add_argument(
+        '-d', '--doctest',
+        dest='doctest',
+        action='store_true',
+        default=False,
+        help='use the doctest format for output (you can just copy and paste it)')
+
+    parser.add_argument(
+        '-C', '--no-cache',
+        dest='cache',
+        action='store_false',
+        default=True,
+        help='disable caching mechanism')
+
+    parser.add_argument(
+        '-a', '--auto-symbols',
+        dest='auto_symbols',
+        action='store_true',
+        default=False,
+        help='automatically construct missing symbols')
+
+    parser.add_argument(
+        '-i', '--int-to-Integer',
+        dest='auto_int_to_Integer',
+        action='store_true',
+        default=False,
+        help="automatically wrap int literals with Integer")
+
+    parser.add_argument(
+        '-I', '--interactive',
+        dest='interactive',
+        action='store_true',
+        default=False,
+        help="equivalent to -a -i")
+
+    parser.add_argument(
+        '-D', '--debug',
+        dest='debug',
+        action='store_true',
+        default=False,
+        help='enable debugging output')
+
+    (options, ipy_args) = parser.parse_known_args()
+    if '--' in ipy_args:
+        ipy_args.remove('--')
+
+    if not options.cache:
+        os.environ['SYMPY_USE_CACHE'] = 'no'
+
+    if options.types:
+        os.environ['SYMPY_GROUND_TYPES'] = options.types
+
+    if options.debug:
+        os.environ['SYMPY_DEBUG'] = str(options.debug)
+
+    if options.doctest:
+        options.pretty = 'no'
+        options.console = 'python'
+
+    session = options.console
+
+    if session is not None:
+        ipython = session == 'ipython'
+    else:
+        try:
+            import IPython # noqa: F401
+            ipython = True
+        except ImportError:
+            if not options.quiet:
+                from sympy.interactive.session import no_ipython
+                print(no_ipython)
+            ipython = False
+
+    args = {
+        'pretty_print': True,
+        'use_unicode':  None,
+        'use_latex':    None,
+        'order':        None,
+        'argv':         ipy_args,
+    }
+
+    if options.pretty == 'unicode':
+        args['use_unicode'] = True
+    elif options.pretty == 'ascii':
+        args['use_unicode'] = False
+    elif options.pretty == 'no':
+        args['pretty_print'] = False
+
+    if options.order is not None:
+        args['order'] = options.order
+
+    args['quiet'] = options.quiet
+    args['auto_symbols'] = options.auto_symbols or options.interactive
+    args['auto_int_to_Integer'] = options.auto_int_to_Integer or options.interactive
+
+    from sympy.interactive import init_session
+    init_session(ipython, **args)
+
+if __name__ == "__main__":
+    main()

venv/lib/python3.10/site-packages/pylab.py

@@ -0,0 +1,3 @@
+from matplotlib.pylab import *  # noqa: F401, F403
+import matplotlib.pylab
+__doc__ = matplotlib.pylab.__doc__

venv/lib/python3.10/site-packages/six.py

@@ -0,0 +1,1003 @@
+# Copyright (c) 2010-2024 Benjamin Peterson
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""Utilities for writing code that runs on Python 2 and 3"""
+
+from __future__ import absolute_import
+
+import functools
+import itertools
+import operator
+import sys
+import types
+
+__author__ = "Benjamin Peterson <benjamin@python.org>"
+__version__ = "1.17.0"
+
+
+# Useful for very coarse version differentiation.
+PY2 = sys.version_info[0] == 2
+PY3 = sys.version_info[0] == 3
+PY34 = sys.version_info[0:2] >= (3, 4)
+
+if PY3:
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+
+    MAXSIZE = sys.maxsize
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+
+    if sys.platform.startswith("java"):
+        # Jython always uses 32 bits.
+        MAXSIZE = int((1 << 31) - 1)
+    else:
+        # It's possible to have sizeof(long) != sizeof(Py_ssize_t).
+        class X(object):
+
+            def __len__(self):
+                return 1 << 31
+        try:
+            len(X())
+        except OverflowError:
+            # 32-bit
+            MAXSIZE = int((1 << 31) - 1)
+        else:
+            # 64-bit
+            MAXSIZE = int((1 << 63) - 1)
+        del X
+
+if PY34:
+    from importlib.util import spec_from_loader
+else:
+    spec_from_loader = None
+
+
+def _add_doc(func, doc):
+    """Add documentation to a function."""
+    func.__doc__ = doc
+
+
+def _import_module(name):
+    """Import module, returning the module after the last dot."""
+    __import__(name)
+    return sys.modules[name]
+
+
+class _LazyDescr(object):
+
+    def __init__(self, name):
+        self.name = name
+
+    def __get__(self, obj, tp):
+        result = self._resolve()
+        setattr(obj, self.name, result)  # Invokes __set__.
+        try:
+            # This is a bit ugly, but it avoids running this again by
+            # removing this descriptor.
+            delattr(obj.__class__, self.name)
+        except AttributeError:
+            pass
+        return result
+
+
+class MovedModule(_LazyDescr):
+
+    def __init__(self, name, old, new=None):
+        super(MovedModule, self).__init__(name)
+        if PY3:
+            if new is None:
+                new = name
+            self.mod = new
+        else:
+            self.mod = old
+
+    def _resolve(self):
+        return _import_module(self.mod)
+
+    def __getattr__(self, attr):
+        _module = self._resolve()
+        value = getattr(_module, attr)
+        setattr(self, attr, value)
+        return value
+
+
+class _LazyModule(types.ModuleType):
+
+    def __init__(self, name):
+        super(_LazyModule, self).__init__(name)
+        self.__doc__ = self.__class__.__doc__
+
+    def __dir__(self):
+        attrs = ["__doc__", "__name__"]
+        attrs += [attr.name for attr in self._moved_attributes]
+        return attrs
+
+    # Subclasses should override this
+    _moved_attributes = []
+
+
+class MovedAttribute(_LazyDescr):
+
+    def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
+        super(MovedAttribute, self).__init__(name)
+        if PY3:
+            if new_mod is None:
+                new_mod = name
+            self.mod = new_mod
+            if new_attr is None:
+                if old_attr is None:
+                    new_attr = name
+                else:
+                    new_attr = old_attr
+            self.attr = new_attr
+        else:
+            self.mod = old_mod
+            if old_attr is None:
+                old_attr = name
+            self.attr = old_attr
+
+    def _resolve(self):
+        module = _import_module(self.mod)
+        return getattr(module, self.attr)
+
+
+class _SixMetaPathImporter(object):
+
+    """
+    A meta path importer to import six.moves and its submodules.
+
+    This class implements a PEP302 finder and loader. It should be compatible
+    with Python 2.5 and all existing versions of Python3
+    """
+
+    def __init__(self, six_module_name):
+        self.name = six_module_name
+        self.known_modules = {}
+
+    def _add_module(self, mod, *fullnames):
+        for fullname in fullnames:
+            self.known_modules[self.name + "." + fullname] = mod
+
+    def _get_module(self, fullname):
+        return self.known_modules[self.name + "." + fullname]
+
+    def find_module(self, fullname, path=None):
+        if fullname in self.known_modules:
+            return self
+        return None
+
+    def find_spec(self, fullname, path, target=None):
+        if fullname in self.known_modules:
+            return spec_from_loader(fullname, self)
+        return None
+
+    def __get_module(self, fullname):
+        try:
+            return self.known_modules[fullname]
+        except KeyError:
+            raise ImportError("This loader does not know module " + fullname)
+
+    def load_module(self, fullname):
+        try:
+            # in case of a reload
+            return sys.modules[fullname]
+        except KeyError:
+            pass
+        mod = self.__get_module(fullname)
+        if isinstance(mod, MovedModule):
+            mod = mod._resolve()
+        else:
+            mod.__loader__ = self
+        sys.modules[fullname] = mod
+        return mod
+
+    def is_package(self, fullname):
+        """
+        Return true, if the named module is a package.
+
+        We need this method to get correct spec objects with
+        Python 3.4 (see PEP451)
+        """
+        return hasattr(self.__get_module(fullname), "__path__")
+
+    def get_code(self, fullname):
+        """Return None
+
+        Required, if is_package is implemented"""
+        self.__get_module(fullname)  # eventually raises ImportError
+        return None
+    get_source = get_code  # same as get_code
+
+    def create_module(self, spec):
+        return self.load_module(spec.name)
+
+    def exec_module(self, module):
+        pass
+
+_importer = _SixMetaPathImporter(__name__)
+
+
+class _MovedItems(_LazyModule):
+
+    """Lazy loading of moved objects"""
+    __path__ = []  # mark as package
+
+
+_moved_attributes = [
+    MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"),
+    MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"),
+    MovedAttribute("filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse"),
+    MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"),
+    MovedAttribute("intern", "__builtin__", "sys"),
+    MovedAttribute("map", "itertools", "builtins", "imap", "map"),
+    MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"),
+    MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"),
+    MovedAttribute("getoutput", "commands", "subprocess"),
+    MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload"),
+    MovedAttribute("reduce", "__builtin__", "functools"),
+    MovedAttribute("shlex_quote", "pipes", "shlex", "quote"),
+    MovedAttribute("StringIO", "StringIO", "io"),
+    MovedAttribute("UserDict", "UserDict", "collections", "IterableUserDict", "UserDict"),
+    MovedAttribute("UserList", "UserList", "collections"),
+    MovedAttribute("UserString", "UserString", "collections"),
+    MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"),
+    MovedAttribute("zip", "itertools", "builtins", "izip", "zip"),
+    MovedAttribute("zip_longest", "itertools", "itertools", "izip_longest", "zip_longest"),
+    MovedModule("builtins", "__builtin__"),
+    MovedModule("configparser", "ConfigParser"),
+    MovedModule("collections_abc", "collections", "collections.abc" if sys.version_info >= (3, 3) else "collections"),
+    MovedModule("copyreg", "copy_reg"),
+    MovedModule("dbm_gnu", "gdbm", "dbm.gnu"),
+    MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"),
+    MovedModule("_dummy_thread", "dummy_thread", "_dummy_thread" if sys.version_info < (3, 9) else "_thread"),
+    MovedModule("http_cookiejar", "cookielib", "http.cookiejar"),
+    MovedModule("http_cookies", "Cookie", "http.cookies"),
+    MovedModule("html_entities", "htmlentitydefs", "html.entities"),
+    MovedModule("html_parser", "HTMLParser", "html.parser"),
+    MovedModule("http_client", "httplib", "http.client"),
+    MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"),
+    MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"),
+    MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"),
+    MovedModule("email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart"),
+    MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"),
+    MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"),
+    MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"),
+    MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"),
+    MovedModule("cPickle", "cPickle", "pickle"),
+    MovedModule("queue", "Queue"),
+    MovedModule("reprlib", "repr"),
+    MovedModule("socketserver", "SocketServer"),
+    MovedModule("_thread", "thread", "_thread"),
+    MovedModule("tkinter", "Tkinter"),
+    MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"),
+    MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"),
+    MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"),
+    MovedModule("tkinter_tix", "Tix", "tkinter.tix"),
+    MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"),
+    MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"),
+    MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"),
+    MovedModule("tkinter_colorchooser", "tkColorChooser",
+                "tkinter.colorchooser"),
+    MovedModule("tkinter_commondialog", "tkCommonDialog",
+                "tkinter.commondialog"),
+    MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"),
+    MovedModule("tkinter_font", "tkFont", "tkinter.font"),
+    MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"),
+    MovedModule("tkinter_tksimpledialog", "tkSimpleDialog",
+                "tkinter.simpledialog"),
+    MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"),
+    MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"),
+    MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"),
+    MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"),
+    MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"),
+    MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"),
+]
+# Add windows specific modules.
+if sys.platform == "win32":
+    _moved_attributes += [
+        MovedModule("winreg", "_winreg"),
+    ]
+
+for attr in _moved_attributes:
+    setattr(_MovedItems, attr.name, attr)
+    if isinstance(attr, MovedModule):
+        _importer._add_module(attr, "moves." + attr.name)
+del attr
+
+_MovedItems._moved_attributes = _moved_attributes
+
+moves = _MovedItems(__name__ + ".moves")
+_importer._add_module(moves, "moves")
+
+
+class Module_six_moves_urllib_parse(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_parse"""
+
+
+_urllib_parse_moved_attributes = [
+    MovedAttribute("ParseResult", "urlparse", "urllib.parse"),
+    MovedAttribute("SplitResult", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qs", "urlparse", "urllib.parse"),
+    MovedAttribute("parse_qsl", "urlparse", "urllib.parse"),
+    MovedAttribute("urldefrag", "urlparse", "urllib.parse"),
+    MovedAttribute("urljoin", "urlparse", "urllib.parse"),
+    MovedAttribute("urlparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunparse", "urlparse", "urllib.parse"),
+    MovedAttribute("urlunsplit", "urlparse", "urllib.parse"),
+    MovedAttribute("quote", "urllib", "urllib.parse"),
+    MovedAttribute("quote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_plus", "urllib", "urllib.parse"),
+    MovedAttribute("unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes"),
+    MovedAttribute("urlencode", "urllib", "urllib.parse"),
+    MovedAttribute("splitquery", "urllib", "urllib.parse"),
+    MovedAttribute("splittag", "urllib", "urllib.parse"),
+    MovedAttribute("splituser", "urllib", "urllib.parse"),
+    MovedAttribute("splitvalue", "urllib", "urllib.parse"),
+    MovedAttribute("uses_fragment", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_netloc", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_params", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_query", "urlparse", "urllib.parse"),
+    MovedAttribute("uses_relative", "urlparse", "urllib.parse"),
+]
+for attr in _urllib_parse_moved_attributes:
+    setattr(Module_six_moves_urllib_parse, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"),
+                      "moves.urllib_parse", "moves.urllib.parse")
+
+
+class Module_six_moves_urllib_error(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_error"""
+
+
+_urllib_error_moved_attributes = [
+    MovedAttribute("URLError", "urllib2", "urllib.error"),
+    MovedAttribute("HTTPError", "urllib2", "urllib.error"),
+    MovedAttribute("ContentTooShortError", "urllib", "urllib.error"),
+]
+for attr in _urllib_error_moved_attributes:
+    setattr(Module_six_moves_urllib_error, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"),
+                      "moves.urllib_error", "moves.urllib.error")
+
+
+class Module_six_moves_urllib_request(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_request"""
+
+
+_urllib_request_moved_attributes = [
+    MovedAttribute("urlopen", "urllib2", "urllib.request"),
+    MovedAttribute("install_opener", "urllib2", "urllib.request"),
+    MovedAttribute("build_opener", "urllib2", "urllib.request"),
+    MovedAttribute("pathname2url", "urllib", "urllib.request"),
+    MovedAttribute("url2pathname", "urllib", "urllib.request"),
+    MovedAttribute("getproxies", "urllib", "urllib.request"),
+    MovedAttribute("Request", "urllib2", "urllib.request"),
+    MovedAttribute("OpenerDirector", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyHandler", "urllib2", "urllib.request"),
+    MovedAttribute("BaseHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FileHandler", "urllib2", "urllib.request"),
+    MovedAttribute("FTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"),
+    MovedAttribute("UnknownHandler", "urllib2", "urllib.request"),
+    MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"),
+    MovedAttribute("urlretrieve", "urllib", "urllib.request"),
+    MovedAttribute("urlcleanup", "urllib", "urllib.request"),
+    MovedAttribute("proxy_bypass", "urllib", "urllib.request"),
+    MovedAttribute("parse_http_list", "urllib2", "urllib.request"),
+    MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"),
+]
+if sys.version_info[:2] < (3, 14):
+    _urllib_request_moved_attributes.extend(
+        [
+            MovedAttribute("URLopener", "urllib", "urllib.request"),
+            MovedAttribute("FancyURLopener", "urllib", "urllib.request"),
+        ]
+    )
+for attr in _urllib_request_moved_attributes:
+    setattr(Module_six_moves_urllib_request, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"),
+                      "moves.urllib_request", "moves.urllib.request")
+
+
+class Module_six_moves_urllib_response(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_response"""
+
+
+_urllib_response_moved_attributes = [
+    MovedAttribute("addbase", "urllib", "urllib.response"),
+    MovedAttribute("addclosehook", "urllib", "urllib.response"),
+    MovedAttribute("addinfo", "urllib", "urllib.response"),
+    MovedAttribute("addinfourl", "urllib", "urllib.response"),
+]
+for attr in _urllib_response_moved_attributes:
+    setattr(Module_six_moves_urllib_response, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"),
+                      "moves.urllib_response", "moves.urllib.response")
+
+
+class Module_six_moves_urllib_robotparser(_LazyModule):
+
+    """Lazy loading of moved objects in six.moves.urllib_robotparser"""
+
+
+_urllib_robotparser_moved_attributes = [
+    MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"),
+]
+for attr in _urllib_robotparser_moved_attributes:
+    setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
+del attr
+
+Module_six_moves_urllib_robotparser._moved_attributes = _urllib_robotparser_moved_attributes
+
+_importer._add_module(Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"),
+                      "moves.urllib_robotparser", "moves.urllib.robotparser")
+
+
+class Module_six_moves_urllib(types.ModuleType):
+
+    """Create a six.moves.urllib namespace that resembles the Python 3 namespace"""
+    __path__ = []  # mark as package
+    parse = _importer._get_module("moves.urllib_parse")
+    error = _importer._get_module("moves.urllib_error")
+    request = _importer._get_module("moves.urllib_request")
+    response = _importer._get_module("moves.urllib_response")
+    robotparser = _importer._get_module("moves.urllib_robotparser")
+
+    def __dir__(self):
+        return ['parse', 'error', 'request', 'response', 'robotparser']
+
+_importer._add_module(Module_six_moves_urllib(__name__ + ".moves.urllib"),
+                      "moves.urllib")
+
+
+def add_move(move):
+    """Add an item to six.moves."""
+    setattr(_MovedItems, move.name, move)
+
+
+def remove_move(name):
+    """Remove item from six.moves."""
+    try:
+        delattr(_MovedItems, name)
+    except AttributeError:
+        try:
+            del moves.__dict__[name]
+        except KeyError:
+            raise AttributeError("no such move, %r" % (name,))
+
+
+if PY3:
+    _meth_func = "__func__"
+    _meth_self = "__self__"
+
+    _func_closure = "__closure__"
+    _func_code = "__code__"
+    _func_defaults = "__defaults__"
+    _func_globals = "__globals__"
+else:
+    _meth_func = "im_func"
+    _meth_self = "im_self"
+
+    _func_closure = "func_closure"
+    _func_code = "func_code"
+    _func_defaults = "func_defaults"
+    _func_globals = "func_globals"
+
+
+try:
+    advance_iterator = next
+except NameError:
+    def advance_iterator(it):
+        return it.next()
+next = advance_iterator
+
+
+try:
+    callable = callable
+except NameError:
+    def callable(obj):
+        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
+
+
+if PY3:
+    def get_unbound_function(unbound):
+        return unbound
+
+    create_bound_method = types.MethodType
+
+    def create_unbound_method(func, cls):
+        return func
+
+    Iterator = object
+else:
+    def get_unbound_function(unbound):
+        return unbound.im_func
+
+    def create_bound_method(func, obj):
+        return types.MethodType(func, obj, obj.__class__)
+
+    def create_unbound_method(func, cls):
+        return types.MethodType(func, None, cls)
+
+    class Iterator(object):
+
+        def next(self):
+            return type(self).__next__(self)
+
+    callable = callable
+_add_doc(get_unbound_function,
+         """Get the function out of a possibly unbound function""")
+
+
+get_method_function = operator.attrgetter(_meth_func)
+get_method_self = operator.attrgetter(_meth_self)
+get_function_closure = operator.attrgetter(_func_closure)
+get_function_code = operator.attrgetter(_func_code)
+get_function_defaults = operator.attrgetter(_func_defaults)
+get_function_globals = operator.attrgetter(_func_globals)
+
+
+if PY3:
+    def iterkeys(d, **kw):
+        return iter(d.keys(**kw))
+
+    def itervalues(d, **kw):
+        return iter(d.values(**kw))
+
+    def iteritems(d, **kw):
+        return iter(d.items(**kw))
+
+    def iterlists(d, **kw):
+        return iter(d.lists(**kw))
+
+    viewkeys = operator.methodcaller("keys")
+
+    viewvalues = operator.methodcaller("values")
+
+    viewitems = operator.methodcaller("items")
+else:
+    def iterkeys(d, **kw):
+        return d.iterkeys(**kw)
+
+    def itervalues(d, **kw):
+        return d.itervalues(**kw)
+
+    def iteritems(d, **kw):
+        return d.iteritems(**kw)
+
+    def iterlists(d, **kw):
+        return d.iterlists(**kw)
+
+    viewkeys = operator.methodcaller("viewkeys")
+
+    viewvalues = operator.methodcaller("viewvalues")
+
+    viewitems = operator.methodcaller("viewitems")
+
+_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.")
+_add_doc(itervalues, "Return an iterator over the values of a dictionary.")
+_add_doc(iteritems,
+         "Return an iterator over the (key, value) pairs of a dictionary.")
+_add_doc(iterlists,
+         "Return an iterator over the (key, [values]) pairs of a dictionary.")
+
+
+if PY3:
+    def b(s):
+        return s.encode("latin-1")
+
+    def u(s):
+        return s
+    unichr = chr
+    import struct
+    int2byte = struct.Struct(">B").pack
+    del struct
+    byte2int = operator.itemgetter(0)
+    indexbytes = operator.getitem
+    iterbytes = iter
+    import io
+    StringIO = io.StringIO
+    BytesIO = io.BytesIO
+    del io
+    _assertCountEqual = "assertCountEqual"
+    if sys.version_info[1] <= 1:
+        _assertRaisesRegex = "assertRaisesRegexp"
+        _assertRegex = "assertRegexpMatches"
+        _assertNotRegex = "assertNotRegexpMatches"
+    else:
+        _assertRaisesRegex = "assertRaisesRegex"
+        _assertRegex = "assertRegex"
+        _assertNotRegex = "assertNotRegex"
+else:
+    def b(s):
+        return s
+    # Workaround for standalone backslash
+
+    def u(s):
+        return unicode(s.replace(r'\\', r'\\\\'), "unicode_escape")
+    unichr = unichr
+    int2byte = chr
+
+    def byte2int(bs):
+        return ord(bs[0])
+
+    def indexbytes(buf, i):
+        return ord(buf[i])
+    iterbytes = functools.partial(itertools.imap, ord)
+    import StringIO
+    StringIO = BytesIO = StringIO.StringIO
+    _assertCountEqual = "assertItemsEqual"
+    _assertRaisesRegex = "assertRaisesRegexp"
+    _assertRegex = "assertRegexpMatches"
+    _assertNotRegex = "assertNotRegexpMatches"
+_add_doc(b, """Byte literal""")
+_add_doc(u, """Text literal""")
+
+
+def assertCountEqual(self, *args, **kwargs):
+    return getattr(self, _assertCountEqual)(*args, **kwargs)
+
+
+def assertRaisesRegex(self, *args, **kwargs):
+    return getattr(self, _assertRaisesRegex)(*args, **kwargs)
+
+
+def assertRegex(self, *args, **kwargs):
+    return getattr(self, _assertRegex)(*args, **kwargs)
+
+
+def assertNotRegex(self, *args, **kwargs):
+    return getattr(self, _assertNotRegex)(*args, **kwargs)
+
+
+if PY3:
+    exec_ = getattr(moves.builtins, "exec")
+
+    def reraise(tp, value, tb=None):
+        try:
+            if value is None:
+                value = tp()
+            if value.__traceback__ is not tb:
+                raise value.with_traceback(tb)
+            raise value
+        finally:
+            value = None
+            tb = None
+
+else:
+    def exec_(_code_, _globs_=None, _locs_=None):
+        """Execute code in a namespace."""
+        if _globs_ is None:
+            frame = sys._getframe(1)
+            _globs_ = frame.f_globals
+            if _locs_ is None:
+                _locs_ = frame.f_locals
+            del frame
+        elif _locs_ is None:
+            _locs_ = _globs_
+        exec("""exec _code_ in _globs_, _locs_""")
+
+    exec_("""def reraise(tp, value, tb=None):
+    try:
+        raise tp, value, tb
+    finally:
+        tb = None
+""")
+
+
+if sys.version_info[:2] > (3,):
+    exec_("""def raise_from(value, from_value):
+    try:
+        raise value from from_value
+    finally:
+        value = None
+""")
+else:
+    def raise_from(value, from_value):
+        raise value
+
+
+print_ = getattr(moves.builtins, "print", None)
+if print_ is None:
+    def print_(*args, **kwargs):
+        """The new-style print function for Python 2.4 and 2.5."""
+        fp = kwargs.pop("file", sys.stdout)
+        if fp is None:
+            return
+
+        def write(data):
+            if not isinstance(data, basestring):
+                data = str(data)
+            # If the file has an encoding, encode unicode with it.
+            if (isinstance(fp, file) and
+                    isinstance(data, unicode) and
+                    fp.encoding is not None):
+                errors = getattr(fp, "errors", None)
+                if errors is None:
+                    errors = "strict"
+                data = data.encode(fp.encoding, errors)
+            fp.write(data)
+        want_unicode = False
+        sep = kwargs.pop("sep", None)
+        if sep is not None:
+            if isinstance(sep, unicode):
+                want_unicode = True
+            elif not isinstance(sep, str):
+                raise TypeError("sep must be None or a string")
+        end = kwargs.pop("end", None)
+        if end is not None:
+            if isinstance(end, unicode):
+                want_unicode = True
+            elif not isinstance(end, str):
+                raise TypeError("end must be None or a string")
+        if kwargs:
+            raise TypeError("invalid keyword arguments to print()")
+        if not want_unicode:
+            for arg in args:
+                if isinstance(arg, unicode):
+                    want_unicode = True
+                    break
+        if want_unicode:
+            newline = unicode("\n")
+            space = unicode(" ")
+        else:
+            newline = "\n"
+            space = " "
+        if sep is None:
+            sep = space
+        if end is None:
+            end = newline
+        for i, arg in enumerate(args):
+            if i:
+                write(sep)
+            write(arg)
+        write(end)
+if sys.version_info[:2] < (3, 3):
+    _print = print_
+
+    def print_(*args, **kwargs):
+        fp = kwargs.get("file", sys.stdout)
+        flush = kwargs.pop("flush", False)
+        _print(*args, **kwargs)
+        if flush and fp is not None:
+            fp.flush()
+
+_add_doc(reraise, """Reraise an exception.""")
+
+if sys.version_info[0:2] < (3, 4):
+    # This does exactly the same what the :func:`py3:functools.update_wrapper`
+    # function does on Python versions after 3.2. It sets the ``__wrapped__``
+    # attribute on ``wrapper`` object and it doesn't raise an error if any of
+    # the attributes mentioned in ``assigned`` and ``updated`` are missing on
+    # ``wrapped`` object.
+    def _update_wrapper(wrapper, wrapped,
+                        assigned=functools.WRAPPER_ASSIGNMENTS,
+                        updated=functools.WRAPPER_UPDATES):
+        for attr in assigned:
+            try:
+                value = getattr(wrapped, attr)
+            except AttributeError:
+                continue
+            else:
+                setattr(wrapper, attr, value)
+        for attr in updated:
+            getattr(wrapper, attr).update(getattr(wrapped, attr, {}))
+        wrapper.__wrapped__ = wrapped
+        return wrapper
+    _update_wrapper.__doc__ = functools.update_wrapper.__doc__
+
+    def wraps(wrapped, assigned=functools.WRAPPER_ASSIGNMENTS,
+              updated=functools.WRAPPER_UPDATES):
+        return functools.partial(_update_wrapper, wrapped=wrapped,
+                                 assigned=assigned, updated=updated)
+    wraps.__doc__ = functools.wraps.__doc__
+
+else:
+    wraps = functools.wraps
+
+
+def with_metaclass(meta, *bases):
+    """Create a base class with a metaclass."""
+    # This requires a bit of explanation: the basic idea is to make a dummy
+    # metaclass for one level of class instantiation that replaces itself with
+    # the actual metaclass.
+    class metaclass(type):
+
+        def __new__(cls, name, this_bases, d):
+            if sys.version_info[:2] >= (3, 7):
+                # This version introduced PEP 560 that requires a bit
+                # of extra care (we mimic what is done by __build_class__).
+                resolved_bases = types.resolve_bases(bases)
+                if resolved_bases is not bases:
+                    d['__orig_bases__'] = bases
+            else:
+                resolved_bases = bases
+            return meta(name, resolved_bases, d)
+
+        @classmethod
+        def __prepare__(cls, name, this_bases):
+            return meta.__prepare__(name, bases)
+    return type.__new__(metaclass, 'temporary_class', (), {})
+
+
+def add_metaclass(metaclass):
+    """Class decorator for creating a class with a metaclass."""
+    def wrapper(cls):
+        orig_vars = cls.__dict__.copy()
+        slots = orig_vars.get('__slots__')
+        if slots is not None:
+            if isinstance(slots, str):
+                slots = [slots]
+            for slots_var in slots:
+                orig_vars.pop(slots_var)
+        orig_vars.pop('__dict__', None)
+        orig_vars.pop('__weakref__', None)
+        if hasattr(cls, '__qualname__'):
+            orig_vars['__qualname__'] = cls.__qualname__
+        return metaclass(cls.__name__, cls.__bases__, orig_vars)
+    return wrapper
+
+
+def ensure_binary(s, encoding='utf-8', errors='strict'):
+    """Coerce **s** to six.binary_type.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> encoded to `bytes`
+      - `bytes` -> `bytes`
+    """
+    if isinstance(s, binary_type):
+        return s
+    if isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    raise TypeError("not expecting type '%s'" % type(s))
+
+
+def ensure_str(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to `str`.
+
+    For Python 2:
+      - `unicode` -> encoded to `str`
+      - `str` -> `str`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    # Optimization: Fast return for the common case.
+    if type(s) is str:
+        return s
+    if PY2 and isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    elif PY3 and isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif not isinstance(s, (text_type, binary_type)):
+        raise TypeError("not expecting type '%s'" % type(s))
+    return s
+
+
+def ensure_text(s, encoding='utf-8', errors='strict'):
+    """Coerce *s* to six.text_type.
+
+    For Python 2:
+      - `unicode` -> `unicode`
+      - `str` -> `unicode`
+
+    For Python 3:
+      - `str` -> `str`
+      - `bytes` -> decoded to `str`
+    """
+    if isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    elif isinstance(s, text_type):
+        return s
+    else:
+        raise TypeError("not expecting type '%s'" % type(s))
+
+
+def python_2_unicode_compatible(klass):
+    """
+    A class decorator that defines __unicode__ and __str__ methods under Python 2.
+    Under Python 3 it does nothing.
+
+    To support Python 2 and 3 with a single code base, define a __str__ method
+    returning text and apply this decorator to the class.
+    """
+    if PY2:
+        if '__str__' not in klass.__dict__:
+            raise ValueError("@python_2_unicode_compatible cannot be applied "
+                             "to %s because it doesn't define __str__()." %
+                             klass.__name__)
+        klass.__unicode__ = klass.__str__
+        klass.__str__ = lambda self: self.__unicode__().encode('utf-8')
+    return klass
+
+
+# Complete the moves implementation.
+# This code is at the end of this module to speed up module loading.
+# Turn this module into a package.
+__path__ = []  # required for PEP 302 and PEP 451
+__package__ = __name__  # see PEP 366 @ReservedAssignment
+if globals().get("__spec__") is not None:
+    __spec__.submodule_search_locations = []  # PEP 451 @UndefinedVariable
+# Remove other six meta path importers, since they cause problems. This can
+# happen if six is removed from sys.modules and then reloaded. (Setuptools does
+# this for some reason.)
+if sys.meta_path:
+    for i, importer in enumerate(sys.meta_path):
+        # Here's some real nastiness: Another "instance" of the six module might
+        # be floating around. Therefore, we can't use isinstance() to check for
+        # the six meta path importer, since the other six instance will have
+        # inserted an importer with different class.
+        if (type(importer).__name__ == "_SixMetaPathImporter" and
+                importer.name == __name__):
+            del sys.meta_path[i]
+            break
+    del i, importer
+# Finally, add the importer to the meta path import hook.
+sys.meta_path.append(_importer)

venv/lib/python3.10/site-packages/soundfile.py

@@ -0,0 +1,1674 @@
+"""python-soundfile is an audio library based on libsndfile, CFFI and NumPy.
+
+Sound files can be read or written directly using the functions
+`read()` and `write()`.
+To read a sound file in a block-wise fashion, use `blocks()`.
+Alternatively, sound files can be opened as `SoundFile` objects.
+
+For further information, see https://python-soundfile.readthedocs.io/.
+
+"""
+__version__ = "0.13.1"
+
+import os as _os
+import sys as _sys
+from os import SEEK_SET, SEEK_CUR, SEEK_END
+from ctypes.util import find_library as _find_library
+from _soundfile import ffi as _ffi
+
+try:
+    _unicode = unicode  # doesn't exist in Python 3.x
+except NameError:
+    _unicode = str
+
+
+_str_types = {
+    'title':       0x01,
+    'copyright':   0x02,
+    'software':    0x03,
+    'artist':      0x04,
+    'comment':     0x05,
+    'date':        0x06,
+    'album':       0x07,
+    'license':     0x08,
+    'tracknumber': 0x09,
+    'genre':       0x10,
+}
+
+_formats = {
+    'WAV':   0x010000,  # Microsoft WAV format (little endian default).
+    'AIFF':  0x020000,  # Apple/SGI AIFF format (big endian).
+    'AU':    0x030000,  # Sun/NeXT AU format (big endian).
+    'RAW':   0x040000,  # RAW PCM data.
+    'PAF':   0x050000,  # Ensoniq PARIS file format.
+    'SVX':   0x060000,  # Amiga IFF / SVX8 / SV16 format.
+    'NIST':  0x070000,  # Sphere NIST format.
+    'VOC':   0x080000,  # VOC files.
+    'IRCAM': 0x0A0000,  # Berkeley/IRCAM/CARL
+    'W64':   0x0B0000,  # Sonic Foundry's 64 bit RIFF/WAV
+    'MAT4':  0x0C0000,  # Matlab (tm) V4.2 / GNU Octave 2.0
+    'MAT5':  0x0D0000,  # Matlab (tm) V5.0 / GNU Octave 2.1
+    'PVF':   0x0E0000,  # Portable Voice Format
+    'XI':    0x0F0000,  # Fasttracker 2 Extended Instrument
+    'HTK':   0x100000,  # HMM Tool Kit format
+    'SDS':   0x110000,  # Midi Sample Dump Standard
+    'AVR':   0x120000,  # Audio Visual Research
+    'WAVEX': 0x130000,  # MS WAVE with WAVEFORMATEX
+    'SD2':   0x160000,  # Sound Designer 2
+    'FLAC':  0x170000,  # FLAC lossless file format
+    'CAF':   0x180000,  # Core Audio File format
+    'WVE':   0x190000,  # Psion WVE format
+    'OGG':   0x200000,  # Xiph OGG container
+    'MPC2K': 0x210000,  # Akai MPC 2000 sampler
+    'RF64':  0x220000,  # RF64 WAV file
+    'MP3':   0x230000,  # MPEG-1/2 audio stream
+}
+
+_subtypes = {
+    'PCM_S8':         0x0001,  # Signed 8 bit data
+    'PCM_16':         0x0002,  # Signed 16 bit data
+    'PCM_24':         0x0003,  # Signed 24 bit data
+    'PCM_32':         0x0004,  # Signed 32 bit data
+    'PCM_U8':         0x0005,  # Unsigned 8 bit data (WAV and RAW only)
+    'FLOAT':          0x0006,  # 32 bit float data
+    'DOUBLE':         0x0007,  # 64 bit float data
+    'ULAW':           0x0010,  # U-Law encoded.
+    'ALAW':           0x0011,  # A-Law encoded.
+    'IMA_ADPCM':      0x0012,  # IMA ADPCM.
+    'MS_ADPCM':       0x0013,  # Microsoft ADPCM.
+    'GSM610':         0x0020,  # GSM 6.10 encoding.
+    'VOX_ADPCM':      0x0021,  # OKI / Dialogix ADPCM
+    'NMS_ADPCM_16':   0x0022,  # 16kbs NMS G721-variant encoding.
+    'NMS_ADPCM_24':   0x0023,  # 24kbs NMS G721-variant encoding.
+    'NMS_ADPCM_32':   0x0024,  # 32kbs NMS G721-variant encoding.
+    'G721_32':        0x0030,  # 32kbs G721 ADPCM encoding.
+    'G723_24':        0x0031,  # 24kbs G723 ADPCM encoding.
+    'G723_40':        0x0032,  # 40kbs G723 ADPCM encoding.
+    'DWVW_12':        0x0040,  # 12 bit Delta Width Variable Word encoding.
+    'DWVW_16':        0x0041,  # 16 bit Delta Width Variable Word encoding.
+    'DWVW_24':        0x0042,  # 24 bit Delta Width Variable Word encoding.
+    'DWVW_N':         0x0043,  # N bit Delta Width Variable Word encoding.
+    'DPCM_8':         0x0050,  # 8 bit differential PCM (XI only)
+    'DPCM_16':        0x0051,  # 16 bit differential PCM (XI only)
+    'VORBIS':         0x0060,  # Xiph Vorbis encoding.
+    'OPUS':           0x0064,  # Xiph/Skype Opus encoding.
+    'ALAC_16':        0x0070,  # Apple Lossless Audio Codec (16 bit).
+    'ALAC_20':        0x0071,  # Apple Lossless Audio Codec (20 bit).
+    'ALAC_24':        0x0072,  # Apple Lossless Audio Codec (24 bit).
+    'ALAC_32':        0x0073,  # Apple Lossless Audio Codec (32 bit).
+    'MPEG_LAYER_I':   0x0080,  # MPEG-1 Audio Layer I.
+    'MPEG_LAYER_II':  0x0081,  # MPEG-1 Audio Layer II.
+    'MPEG_LAYER_III': 0x0082,  # MPEG-2 Audio Layer III.
+}
+
+_endians = {
+    'FILE':   0x00000000,  # Default file endian-ness.
+    'LITTLE': 0x10000000,  # Force little endian-ness.
+    'BIG':    0x20000000,  # Force big endian-ness.
+    'CPU':    0x30000000,  # Force CPU endian-ness.
+}
+
+# libsndfile doesn't specify default subtypes, these are somehow arbitrary:
+_default_subtypes = {
+    'WAV':   'PCM_16',
+    'AIFF':  'PCM_16',
+    'AU':    'PCM_16',
+    # 'RAW':  # subtype must be explicit!
+    'PAF':   'PCM_16',
+    'SVX':   'PCM_16',
+    'NIST':  'PCM_16',
+    'VOC':   'PCM_16',
+    'IRCAM': 'PCM_16',
+    'W64':   'PCM_16',
+    'MAT4':  'DOUBLE',
+    'MAT5':  'DOUBLE',
+    'PVF':   'PCM_16',
+    'XI':    'DPCM_16',
+    'HTK':   'PCM_16',
+    'SDS':   'PCM_16',
+    'AVR':   'PCM_16',
+    'WAVEX': 'PCM_16',
+    'SD2':   'PCM_16',
+    'FLAC':  'PCM_16',
+    'CAF':   'PCM_16',
+    'WVE':   'ALAW',
+    'OGG':   'VORBIS',
+    'MPC2K': 'PCM_16',
+    'RF64':  'PCM_16',
+    'MP3':   'MPEG_LAYER_III',
+}
+
+_ffi_types = {
+    'float64': 'double',
+    'float32': 'float',
+    'int32': 'int',
+    'int16': 'short'
+}
+
+_bitrate_modes = {
+    'CONSTANT': 0,
+    'AVERAGE': 1,
+    'VARIABLE': 2,
+}
+
+try:  # packaged lib (in _soundfile_data which should be on python path)
+    if _sys.platform == 'darwin':
+        from platform import machine as _machine
+        _packaged_libname = 'libsndfile_' + _machine() + '.dylib'
+    elif _sys.platform == 'win32':
+        from platform import architecture as _architecture
+        from platform import machine as _machine
+        # this check can not be completed correctly: for x64 binaries running on
+        # arm64 Windows report the same values as arm64 binaries. For now, neither
+        # numpy nor cffi are available for arm64, so we can safely assume we're
+        # in x86 land:
+        if _architecture()[0] == '64bit':
+            _packaged_libname = 'libsndfile_x64.dll'
+        elif _architecture()[0] == '32bit':
+            _packaged_libname = 'libsndfile_x86.dll'
+        else:
+            raise OSError('no packaged library for Windows {} {}'
+                          .format(_architecture(), _machine()))
+    elif _sys.platform == 'linux':
+        from platform import machine as _machine
+        if _machine() in ["aarch64", "aarch64_be", "armv8b", "armv8l"]:
+            _packaged_libname = 'libsndfile_arm64.so'
+        else:
+            _packaged_libname = 'libsndfile_' + _machine() + '.so'
+    else:
+        raise OSError('no packaged library for this platform')
+
+    import _soundfile_data  # ImportError if this doesn't exist
+    _path = _os.path.dirname(_soundfile_data.__file__)  # TypeError if __file__ is None
+    _full_path = _os.path.join(_path, _packaged_libname)
+    _snd = _ffi.dlopen(_full_path)  # OSError if file doesn't exist or can't be loaded
+
+except (OSError, ImportError, TypeError):
+    try:  # system-wide libsndfile:
+        _libname = _find_library('sndfile')
+        if _libname is None:
+            raise OSError('sndfile library not found using ctypes.util.find_library')
+        _snd = _ffi.dlopen(_libname)
+
+    except OSError:
+        # Try explicit file name, if the general does not work (e.g. on nixos)
+        if _sys.platform == 'darwin':
+            _explicit_libname = 'libsndfile.dylib'
+        elif _sys.platform == 'win32':
+            _explicit_libname = 'libsndfile.dll'
+        elif _sys.platform == 'linux':
+            _explicit_libname = 'libsndfile.so'
+        else:
+            raise
+
+        # Homebrew on Apple M1 uses a `/opt/homebrew/lib` instead of
+        # `/usr/local/lib`. We are making sure we pick that up.
+        from platform import machine as _machine
+        if _sys.platform == 'darwin' and _machine() == 'arm64':
+            _hbrew_path = '/opt/homebrew/lib/' if _os.path.isdir('/opt/homebrew/lib/') \
+                else '/usr/local/lib/'
+            _snd = _ffi.dlopen(_os.path.join(_hbrew_path, _explicit_libname))
+        else:
+            _snd = _ffi.dlopen(_explicit_libname)
+
+__libsndfile_version__ = _ffi.string(_snd.sf_version_string()).decode('utf-8', 'replace')
+if __libsndfile_version__.startswith('libsndfile-'):
+    __libsndfile_version__ = __libsndfile_version__[len('libsndfile-'):]
+
+
+def read(file, frames=-1, start=0, stop=None, dtype='float64', always_2d=False,
+         fill_value=None, out=None, samplerate=None, channels=None,
+         format=None, subtype=None, endian=None, closefd=True):
+    """Provide audio data from a sound file as NumPy array.
+
+    By default, the whole file is read from the beginning, but the
+    position to start reading can be specified with *start* and the
+    number of frames to read can be specified with *frames*.
+    Alternatively, a range can be specified with *start* and *stop*.
+
+    If there is less data left in the file than requested, the rest of
+    the frames are filled with *fill_value*.
+    If no *fill_value* is specified, a smaller array is returned.
+
+    Parameters
+    ----------
+    file : str or int or file-like object
+        The file to read from.  See `SoundFile` for details.
+    frames : int, optional
+        The number of frames to read. If *frames* is negative, the whole
+        rest of the file is read.  Not allowed if *stop* is given.
+    start : int, optional
+        Where to start reading.  A negative value counts from the end.
+    stop : int, optional
+        The index after the last frame to be read.  A negative value
+        counts from the end.  Not allowed if *frames* is given.
+    dtype : {'float64', 'float32', 'int32', 'int16'}, optional
+        Data type of the returned array, by default ``'float64'``.
+        Floating point audio data is typically in the range from
+        ``-1.0`` to ``1.0``.  Integer data is in the range from
+        ``-2**15`` to ``2**15-1`` for ``'int16'`` and from ``-2**31`` to
+        ``2**31-1`` for ``'int32'``.
+
+        .. note:: Reading int values from a float file will *not*
+            scale the data to [-1.0, 1.0). If the file contains
+            ``np.array([42.6], dtype='float32')``, you will read
+            ``np.array([43], dtype='int32')`` for ``dtype='int32'``.
+
+    Returns
+    -------
+    audiodata : `numpy.ndarray` or type(out)
+        A two-dimensional (frames x channels) NumPy array is returned.
+        If the sound file has only one channel, a one-dimensional array
+        is returned.  Use ``always_2d=True`` to return a two-dimensional
+        array anyway.
+
+        If *out* was specified, it is returned.  If *out* has more
+        frames than available in the file (or if *frames* is smaller
+        than the length of *out*) and no *fill_value* is given, then
+        only a part of *out* is overwritten and a view containing all
+        valid frames is returned.
+    samplerate : int
+        The sample rate of the audio file.
+
+    Other Parameters
+    ----------------
+    always_2d : bool, optional
+        By default, reading a mono sound file will return a
+        one-dimensional array.  With ``always_2d=True``, audio data is
+        always returned as a two-dimensional array, even if the audio
+        file has only one channel.
+    fill_value : float, optional
+        If more frames are requested than available in the file, the
+        rest of the output is be filled with *fill_value*.  If
+        *fill_value* is not specified, a smaller array is returned.
+    out : `numpy.ndarray` or subclass, optional
+        If *out* is specified, the data is written into the given array
+        instead of creating a new array.  In this case, the arguments
+        *dtype* and *always_2d* are silently ignored!  If *frames* is
+        not given, it is obtained from the length of *out*.
+    samplerate, channels, format, subtype, endian, closefd
+        See `SoundFile`.
+
+    Examples
+    --------
+    >>> import soundfile as sf
+    >>> data, samplerate = sf.read('stereo_file.wav')
+    >>> data
+    array([[ 0.71329652,  0.06294799],
+           [-0.26450912, -0.38874483],
+           ...
+           [ 0.67398441, -0.11516333]])
+    >>> samplerate
+    44100
+
+    """
+    with SoundFile(file, 'r', samplerate, channels,
+                   subtype, endian, format, closefd) as f:
+        frames = f._prepare_read(start, stop, frames)
+        data = f.read(frames, dtype, always_2d, fill_value, out)
+    return data, f.samplerate
+
+
+def write(file, data, samplerate, subtype=None, endian=None, format=None,
+          closefd=True, compression_level=None, bitrate_mode=None):
+    """Write data to a sound file.
+
+    .. note:: If *file* exists, it will be truncated and overwritten!
+
+    Parameters
+    ----------
+    file : str or int or file-like object
+        The file to write to.  See `SoundFile` for details.
+    data : array_like
+        The data to write.  Usually two-dimensional (frames x channels),
+        but one-dimensional *data* can be used for mono files.
+        Only the data types ``'float64'``, ``'float32'``, ``'int32'``
+        and ``'int16'`` are supported.
+
+        .. note:: The data type of *data* does **not** select the data
+                  type of the written file. Audio data will be
+                  converted to the given *subtype*. Writing int values
+                  to a float file will *not* scale the values to
+                  [-1.0, 1.0). If you write the value ``np.array([42],
+                  dtype='int32')``, to a ``subtype='FLOAT'`` file, the
+                  file will then contain ``np.array([42.],
+                  dtype='float32')``.
+
+    samplerate : int
+        The sample rate of the audio data.
+    subtype : str, optional
+        See `default_subtype()` for the default value and
+        `available_subtypes()` for all possible values.
+
+    Other Parameters
+    ----------------
+    format, endian, closefd, compression_level, bitrate_mode
+        See `SoundFile`.
+
+    Examples
+    --------
+    Write 10 frames of random data to a new file:
+
+    >>> import numpy as np
+    >>> import soundfile as sf
+    >>> sf.write('stereo_file.wav', np.random.randn(10, 2), 44100, 'PCM_24')
+
+    """
+    import numpy as np
+    data = np.asarray(data)
+    if data.ndim == 1:
+        channels = 1
+    else:
+        channels = data.shape[1]
+    with SoundFile(file, 'w', samplerate, channels,
+                   subtype, endian, format, closefd,
+                   compression_level, bitrate_mode) as f:
+        f.write(data)
+
+
+def blocks(file, blocksize=None, overlap=0, frames=-1, start=0, stop=None,
+           dtype='float64', always_2d=False, fill_value=None, out=None,
+           samplerate=None, channels=None,
+           format=None, subtype=None, endian=None, closefd=True):
+    """Return a generator for block-wise reading.
+
+    By default, iteration starts at the beginning and stops at the end
+    of the file.  Use *start* to start at a later position and *frames*
+    or *stop* to stop earlier.
+
+    If you stop iterating over the generator before it's exhausted,
+    the sound file is not closed. This is normally not a problem
+    because the file is opened in read-only mode. To close the file
+    properly, the generator's ``close()`` method can be called.
+
+    Parameters
+    ----------
+    file : str or int or file-like object
+        The file to read from.  See `SoundFile` for details.
+    blocksize : int
+        The number of frames to read per block.
+        Either this or *out* must be given.
+    overlap : int, optional
+        The number of frames to rewind between each block.
+
+    Yields
+    ------
+    `numpy.ndarray` or type(out)
+        Blocks of audio data.
+        If *out* was given, and the requested frames are not an integer
+        multiple of the length of *out*, and no *fill_value* was given,
+        the last block will be a smaller view into *out*.
+
+    Other Parameters
+    ----------------
+    frames, start, stop
+        See `read()`.
+    dtype : {'float64', 'float32', 'int32', 'int16'}, optional
+        See `read()`.
+    always_2d, fill_value, out
+        See `read()`.
+    samplerate, channels, format, subtype, endian, closefd
+        See `SoundFile`.
+
+    Examples
+    --------
+    >>> import soundfile as sf
+    >>> for block in sf.blocks('stereo_file.wav', blocksize=1024):
+    >>>     pass  # do something with 'block'
+
+    """
+    with SoundFile(file, 'r', samplerate, channels,
+                   subtype, endian, format, closefd) as f:
+        frames = f._prepare_read(start, stop, frames)
+        for block in f.blocks(blocksize, overlap, frames,
+                              dtype, always_2d, fill_value, out):
+            yield block
+
+
+class _SoundFileInfo(object):
+    """Information about a SoundFile"""
+
+    def __init__(self, file, verbose):
+        self.verbose = verbose
+        with SoundFile(file) as f:
+            self.name = f.name
+            self.samplerate = f.samplerate
+            self.channels = f.channels
+            self.frames = f.frames
+            self.duration = float(self.frames)/f.samplerate
+            self.format = f.format
+            self.subtype = f.subtype
+            self.endian = f.endian
+            self.format_info = f.format_info
+            self.subtype_info = f.subtype_info
+            self.sections = f.sections
+            self.extra_info = f.extra_info
+
+    @property
+    def _duration_str(self):
+        hours, rest = divmod(self.duration, 3600)
+        minutes, seconds = divmod(rest, 60)
+        if hours >= 1:
+            duration = "{0:.0g}:{1:02.0g}:{2:05.3f} h".format(hours, minutes, seconds)
+        elif minutes >= 1:
+            duration = "{0:02.0g}:{1:05.3f} min".format(minutes, seconds)
+        elif seconds <= 1:
+            duration = "{0:d} samples".format(self.frames)
+        else:
+            duration = "{0:.3f} s".format(seconds)
+        return duration
+
+    def __repr__(self):
+        info = "\n".join(
+            ["{0.name}",
+             "samplerate: {0.samplerate} Hz",
+             "channels: {0.channels}",
+             "duration: {0._duration_str}",
+             "format: {0.format_info} [{0.format}]",
+             "subtype: {0.subtype_info} [{0.subtype}]"])
+        if self.verbose:
+            info += "\n".join(
+                ["\nendian: {0.endian}",
+                 "sections: {0.sections}",
+                 "frames: {0.frames}",
+                 'extra_info: """',
+                 '    {1}"""'])
+        indented_extra_info = ("\n"+" "*4).join(self.extra_info.split("\n"))
+        return info.format(self, indented_extra_info)
+
+
+def info(file, verbose=False):
+    """Returns an object with information about a `SoundFile`.
+
+    Parameters
+    ----------
+    verbose : bool
+        Whether to print additional information.
+    """
+    return _SoundFileInfo(file, verbose)
+
+
+def available_formats():
+    """Return a dictionary of available major formats.
+
+    Examples
+    --------
+    >>> import soundfile as sf
+    >>> sf.available_formats()
+    {'FLAC': 'FLAC (FLAC Lossless Audio Codec)',
+     'OGG': 'OGG (OGG Container format)',
+     'WAV': 'WAV (Microsoft)',
+     'AIFF': 'AIFF (Apple/SGI)',
+     ...
+     'WAVEX': 'WAVEX (Microsoft)',
+     'RAW': 'RAW (header-less)',
+     'MAT5': 'MAT5 (GNU Octave 2.1 / Matlab 5.0)'}
+
+    """
+    return dict(_available_formats_helper(_snd.SFC_GET_FORMAT_MAJOR_COUNT,
+                                          _snd.SFC_GET_FORMAT_MAJOR))
+
+
+def available_subtypes(format=None):
+    """Return a dictionary of available subtypes.
+
+    Parameters
+    ----------
+    format : str
+        If given, only compatible subtypes are returned.
+
+    Examples
+    --------
+    >>> import soundfile as sf
+    >>> sf.available_subtypes('FLAC')
+    {'PCM_24': 'Signed 24 bit PCM',
+     'PCM_16': 'Signed 16 bit PCM',
+     'PCM_S8': 'Signed 8 bit PCM'}
+
+    """
+    subtypes = _available_formats_helper(_snd.SFC_GET_FORMAT_SUBTYPE_COUNT,
+                                         _snd.SFC_GET_FORMAT_SUBTYPE)
+    return dict((subtype, name) for subtype, name in subtypes
+                if format is None or check_format(format, subtype))
+
+
+def check_format(format, subtype=None, endian=None):
+    """Check if the combination of format/subtype/endian is valid.
+
+    Examples
+    --------
+    >>> import soundfile as sf
+    >>> sf.check_format('WAV', 'PCM_24')
+    True
+    >>> sf.check_format('FLAC', 'VORBIS')
+    False
+
+    """
+    try:
+        return bool(_format_int(format, subtype, endian))
+    except (ValueError, TypeError):
+        return False
+
+
+def default_subtype(format):
+    """Return the default subtype for a given format.
+
+    Examples
+    --------
+    >>> import soundfile as sf
+    >>> sf.default_subtype('WAV')
+    'PCM_16'
+    >>> sf.default_subtype('MAT5')
+    'DOUBLE'
+
+    """
+    _check_format(format)
+    return _default_subtypes.get(format.upper())
+
+
+class SoundFile(object):
+    """A sound file.
+
+    For more documentation see the __init__() docstring (which is also
+    used for the online documentation (https://python-soundfile.readthedocs.io/).
+
+    """
+
+    def __init__(self, file, mode='r', samplerate=None, channels=None,
+                 subtype=None, endian=None, format=None, closefd=True,
+                 compression_level=None, bitrate_mode=None):
+        """Open a sound file.
+
+        If a file is opened with `mode` ``'r'`` (the default) or
+        ``'r+'``, no sample rate, channels or file format need to be
+        given because the information is obtained from the file. An
+        exception is the ``'RAW'`` data format, which always requires
+        these data points.
+
+        File formats consist of three case-insensitive strings:
+
+        * a *major format* which is by default obtained from the
+          extension of the file name (if known) and which can be
+          forced with the format argument (e.g. ``format='WAVEX'``).
+        * a *subtype*, e.g. ``'PCM_24'``. Most major formats have a
+          default subtype which is used if no subtype is specified.
+        * an *endian-ness*, which doesn't have to be specified at all in
+          most cases.
+
+        A `SoundFile` object is a *context manager*, which means
+        if used in a "with" statement, `close()` is automatically
+        called when reaching the end of the code block inside the "with"
+        statement.
+
+        Parameters
+        ----------
+        file : str or int or file-like object
+            The file to open.  This can be a file name, a file
+            descriptor or a Python file object (or a similar object with
+            the methods ``read()``/``readinto()``, ``write()``,
+            ``seek()`` and ``tell()``).
+        mode : {'r', 'r+', 'w', 'w+', 'x', 'x+'}, optional
+            Open mode.  Has to begin with one of these three characters:
+            ``'r'`` for reading, ``'w'`` for writing (truncates *file*)
+            or ``'x'`` for writing (raises an error if *file* already
+            exists).  Additionally, it may contain ``'+'`` to open
+            *file* for both reading and writing.
+            The character ``'b'`` for *binary mode* is implied because
+            all sound files have to be opened in this mode.
+            If *file* is a file descriptor or a file-like object,
+            ``'w'`` doesn't truncate and ``'x'`` doesn't raise an error.
+        samplerate : int
+            The sample rate of the file.  If `mode` contains ``'r'``,
+            this is obtained from the file (except for ``'RAW'`` files).
+        channels : int
+            The number of channels of the file.
+            If `mode` contains ``'r'``, this is obtained from the file
+            (except for ``'RAW'`` files).
+        subtype : str, sometimes optional
+            The subtype of the sound file.  If `mode` contains ``'r'``,
+            this is obtained from the file (except for ``'RAW'``
+            files), if not, the default value depends on the selected
+            `format` (see `default_subtype()`).
+            See `available_subtypes()` for all possible subtypes for
+            a given `format`.
+        endian : {'FILE', 'LITTLE', 'BIG', 'CPU'}, sometimes optional
+            The endian-ness of the sound file.  If `mode` contains
+            ``'r'``, this is obtained from the file (except for
+            ``'RAW'`` files), if not, the default value is ``'FILE'``,
+            which is correct in most cases.
+        format : str, sometimes optional
+            The major format of the sound file.  If `mode` contains
+            ``'r'``, this is obtained from the file (except for
+            ``'RAW'`` files), if not, the default value is determined
+            from the file extension.  See `available_formats()` for
+            all possible values.
+        closefd : bool, optional
+            Whether to close the file descriptor on `close()`. Only
+            applicable if the *file* argument is a file descriptor.
+        compression_level : float, optional
+            The compression level on 'write()'. The compression level
+            should be between 0.0 (minimum compression level) and 1.0
+            (highest compression level).
+            See `libsndfile document <https://github.com/libsndfile/libsndfile/blob/c81375f070f3c6764969a738eacded64f53a076e/docs/command.md>`__.
+        bitrate_mode : {'CONSTANT', 'AVERAGE', 'VARIABLE'}, optional
+            The bitrate mode on 'write()'. 
+            See `libsndfile document <https://github.com/libsndfile/libsndfile/blob/c81375f070f3c6764969a738eacded64f53a076e/docs/command.md>`__.
+
+        Examples
+        --------
+        >>> from soundfile import SoundFile
+
+        Open an existing file for reading:
+
+        >>> myfile = SoundFile('existing_file.wav')
+        >>> # do something with myfile
+        >>> myfile.close()
+
+        Create a new sound file for reading and writing using a with
+        statement:
+
+        >>> with SoundFile('new_file.wav', 'x+', 44100, 2) as myfile:
+        >>>     # do something with myfile
+        >>>     # ...
+        >>>     assert not myfile.closed
+        >>>     # myfile.close() is called automatically at the end
+        >>> assert myfile.closed
+
+        """
+        # resolve PathLike objects (see PEP519 for details):
+        # can be replaced with _os.fspath(file) for Python >= 3.6
+        file = file.__fspath__() if hasattr(file, '__fspath__') else file
+        self._name = file
+        if mode is None:
+            mode = getattr(file, 'mode', None)
+        mode_int = _check_mode(mode)
+        self._mode = mode
+        self._compression_level = compression_level
+        self._bitrate_mode = bitrate_mode
+        self._info = _create_info_struct(file, mode, samplerate, channels,
+                                         format, subtype, endian)
+        self._file = self._open(file, mode_int, closefd)
+        if set(mode).issuperset('r+') and self.seekable():
+            # Move write position to 0 (like in Python file objects)
+            self.seek(0)
+        _snd.sf_command(self._file, _snd.SFC_SET_CLIPPING, _ffi.NULL,
+                        _snd.SF_TRUE)
+        
+        # set compression setting
+        if self._compression_level is not None:
+            # needs to be called before set_bitrate_mode
+            self._set_compression_level(self._compression_level)
+            if self._bitrate_mode is not None:
+                self._set_bitrate_mode(self._bitrate_mode)
+
+    name = property(lambda self: self._name)
+    """The file name of the sound file."""
+    mode = property(lambda self: self._mode)
+    """The open mode the sound file was opened with."""
+    samplerate = property(lambda self: self._info.samplerate)
+    """The sample rate of the sound file."""
+    frames = property(lambda self: self._info.frames)
+    """The number of frames in the sound file."""
+    channels = property(lambda self: self._info.channels)
+    """The number of channels in the sound file."""
+    format = property(
+        lambda self: _format_str(self._info.format & _snd.SF_FORMAT_TYPEMASK))
+    """The major format of the sound file."""
+    subtype = property(
+        lambda self: _format_str(self._info.format & _snd.SF_FORMAT_SUBMASK))
+    """The subtype of data in the the sound file."""
+    endian = property(
+        lambda self: _format_str(self._info.format & _snd.SF_FORMAT_ENDMASK))
+    """The endian-ness of the data in the sound file."""
+    format_info = property(
+        lambda self: _format_info(self._info.format &
+                                  _snd.SF_FORMAT_TYPEMASK)[1])
+    """A description of the major format of the sound file."""
+    subtype_info = property(
+        lambda self: _format_info(self._info.format &
+                                  _snd.SF_FORMAT_SUBMASK)[1])
+    """A description of the subtype of the sound file."""
+    sections = property(lambda self: self._info.sections)
+    """The number of sections of the sound file."""
+    closed = property(lambda self: self._file is None)
+    """Whether the sound file is closed or not."""
+    _errorcode = property(lambda self: _snd.sf_error(self._file))
+    """A pending sndfile error code."""
+    compression_level = property(lambda self: self._compression_level)
+    """The compression level on 'write()'"""
+    bitrate_mode = property(lambda self: self._bitrate_mode)
+    """The bitrate mode on 'write()'"""
+
+    @property
+    def extra_info(self):
+        """Retrieve the log string generated when opening the file."""
+        info = _ffi.new("char[]", 2**14)
+        _snd.sf_command(self._file, _snd.SFC_GET_LOG_INFO,
+                        info, _ffi.sizeof(info))
+        return _ffi.string(info).decode('utf-8', 'replace')
+
+    # avoid confusion if something goes wrong before assigning self._file:
+    _file = None
+
+    def __repr__(self):
+        compression_setting = (", compression_level={0}".format(self.compression_level) 
+                               if self.compression_level is not None else "")
+        compression_setting += (", bitrate_mode='{0}'".format(self.bitrate_mode) 
+                                if self.bitrate_mode is not None else "")
+        return ("SoundFile({0.name!r}, mode={0.mode!r}, "
+                "samplerate={0.samplerate}, channels={0.channels}, "
+                "format={0.format!r}, subtype={0.subtype!r}, "
+                "endian={0.endian!r}{1})".format(self, compression_setting))
+
+    def __del__(self):
+        self.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+    def __setattr__(self, name, value):
+        """Write text meta-data in the sound file through properties."""
+        if name in _str_types:
+            self._check_if_closed()
+            err = _snd.sf_set_string(self._file, _str_types[name],
+                                     value.encode())
+            _error_check(err)
+        else:
+            object.__setattr__(self, name, value)
+
+    def __getattr__(self, name):
+        """Read text meta-data in the sound file through properties."""
+        if name in _str_types:
+            self._check_if_closed()
+            data = _snd.sf_get_string(self._file, _str_types[name])
+            return _ffi.string(data).decode('utf-8', 'replace') if data else ""
+        else:
+            raise AttributeError(
+                "'SoundFile' object has no attribute {0!r}".format(name))
+
+    def __len__(self):
+        # Note: This is deprecated and will be removed at some point,
+        # see https://github.com/bastibe/python-soundfile/issues/199
+        return self._info.frames
+
+    def __bool__(self):
+        # Note: This is temporary until __len__ is removed, afterwards it
+        # can (and should) be removed without change of behavior
+        return True
+
+    def __nonzero__(self):
+        # Note: This is only for compatibility with Python 2 and it shall be
+        # removed at the same time as __bool__().
+        return self.__bool__()
+
+    def seekable(self):
+        """Return True if the file supports seeking."""
+        return self._info.seekable == _snd.SF_TRUE
+
+    def seek(self, frames, whence=SEEK_SET):
+        """Set the read/write position.
+
+        Parameters
+        ----------
+        frames : int
+            The frame index or offset to seek.
+        whence : {SEEK_SET, SEEK_CUR, SEEK_END}, optional
+            By default (``whence=SEEK_SET``), *frames* are counted from
+            the beginning of the file.
+            ``whence=SEEK_CUR`` seeks from the current position
+            (positive and negative values are allowed for *frames*).
+            ``whence=SEEK_END`` seeks from the end (use negative value
+            for *frames*).
+
+        Returns
+        -------
+        int
+            The new absolute read/write position in frames.
+
+        Examples
+        --------
+        >>> from soundfile import SoundFile, SEEK_END
+        >>> myfile = SoundFile('stereo_file.wav')
+
+        Seek to the beginning of the file:
+
+        >>> myfile.seek(0)
+        0
+
+        Seek to the end of the file:
+
+        >>> myfile.seek(0, SEEK_END)
+        44100  # this is the file length
+
+        """
+        self._check_if_closed()
+        position = _snd.sf_seek(self._file, frames, whence)
+        _error_check(self._errorcode)
+        return position
+
+    def tell(self):
+        """Return the current read/write position."""
+        return self.seek(0, SEEK_CUR)
+
+    def read(self, frames=-1, dtype='float64', always_2d=False,
+             fill_value=None, out=None):
+        """Read from the file and return data as NumPy array.
+
+        Reads the given number of frames in the given data format
+        starting at the current read/write position.  This advances the
+        read/write position by the same number of frames.
+        By default, all frames from the current read/write position to
+        the end of the file are returned.
+        Use `seek()` to move the current read/write position.
+
+        Parameters
+        ----------
+        frames : int, optional
+            The number of frames to read. If ``frames < 0``, the whole
+            rest of the file is read.
+        dtype : {'float64', 'float32', 'int32', 'int16'}, optional
+            Data type of the returned array, by default ``'float64'``.
+            Floating point audio data is typically in the range from
+            ``-1.0`` to ``1.0``. Integer data is in the range from
+            ``-2**15`` to ``2**15-1`` for ``'int16'`` and from
+            ``-2**31`` to ``2**31-1`` for ``'int32'``.
+
+            .. note:: Reading int values from a float file will *not*
+                scale the data to [-1.0, 1.0). If the file contains
+                ``np.array([42.6], dtype='float32')``, you will read
+                ``np.array([43], dtype='int32')`` for
+                ``dtype='int32'``.
+
+        Returns
+        -------
+        audiodata : `numpy.ndarray` or type(out)
+            A two-dimensional NumPy (frames x channels) array is
+            returned. If the sound file has only one channel, a
+            one-dimensional array is returned. Use ``always_2d=True``
+            to return a two-dimensional array anyway.
+
+            If *out* was specified, it is returned. If *out* has more
+            frames than available in the file (or if *frames* is
+            smaller than the length of *out*) and no *fill_value* is
+            given, then only a part of *out* is overwritten and a view
+            containing all valid frames is returned.
+
+        Other Parameters
+        ----------------
+        always_2d : bool, optional
+            By default, reading a mono sound file will return a
+            one-dimensional array. With ``always_2d=True``, audio data
+            is always returned as a two-dimensional array, even if the
+            audio file has only one channel.
+        fill_value : float, optional
+            If more frames are requested than available in the file,
+            the rest of the output is be filled with *fill_value*. If
+            *fill_value* is not specified, a smaller array is
+            returned.
+        out : `numpy.ndarray` or subclass, optional
+            If *out* is specified, the data is written into the given
+            array instead of creating a new array. In this case, the
+            arguments *dtype* and *always_2d* are silently ignored! If
+            *frames* is not given, it is obtained from the length of
+            *out*.
+
+        Examples
+        --------
+        >>> from soundfile import SoundFile
+        >>> myfile = SoundFile('stereo_file.wav')
+
+        Reading 3 frames from a stereo file:
+
+        >>> myfile.read(3)
+        array([[ 0.71329652,  0.06294799],
+               [-0.26450912, -0.38874483],
+               [ 0.67398441, -0.11516333]])
+        >>> myfile.close()
+
+        See Also
+        --------
+        buffer_read, .write
+
+        """
+        if out is None:
+            frames = self._check_frames(frames, fill_value)
+            out = self._create_empty_array(frames, always_2d, dtype)
+        else:
+            if frames < 0 or frames > len(out):
+                frames = len(out)
+        frames = self._array_io('read', out, frames)
+        if len(out) > frames:
+            if fill_value is None:
+                out = out[:frames]
+            else:
+                out[frames:] = fill_value
+        return out
+
+    def buffer_read(self, frames=-1, dtype=None):
+        """Read from the file and return data as buffer object.
+
+        Reads the given number of *frames* in the given data format
+        starting at the current read/write position.  This advances the
+        read/write position by the same number of frames.
+        By default, all frames from the current read/write position to
+        the end of the file are returned.
+        Use `seek()` to move the current read/write position.
+
+        Parameters
+        ----------
+        frames : int, optional
+            The number of frames to read. If ``frames < 0``, the whole
+            rest of the file is read.
+        dtype : {'float64', 'float32', 'int32', 'int16'}
+            Audio data will be converted to the given data type.
+
+        Returns
+        -------
+        buffer
+            A buffer containing the read data.
+
+        See Also
+        --------
+        buffer_read_into, .read, buffer_write
+
+        """
+        frames = self._check_frames(frames, fill_value=None)
+        ctype = self._check_dtype(dtype)
+        cdata = _ffi.new(ctype + '[]', frames * self.channels)
+        read_frames = self._cdata_io('read', cdata, ctype, frames)
+        assert read_frames == frames
+        return _ffi.buffer(cdata)
+
+    def buffer_read_into(self, buffer, dtype):
+        """Read from the file into a given buffer object.
+
+        Fills the given *buffer* with frames in the given data format
+        starting at the current read/write position (which can be
+        changed with `seek()`) until the buffer is full or the end
+        of the file is reached.  This advances the read/write position
+        by the number of frames that were read.
+
+        Parameters
+        ----------
+        buffer : writable buffer
+            Audio frames from the file are written to this buffer.
+        dtype : {'float64', 'float32', 'int32', 'int16'}
+            The data type of *buffer*.
+
+        Returns
+        -------
+        int
+            The number of frames that were read from the file.
+            This can be less than the size of *buffer*.
+            The rest of the buffer is not filled with meaningful data.
+
+        See Also
+        --------
+        buffer_read, .read
+
+        """
+        ctype = self._check_dtype(dtype)
+        cdata, frames = self._check_buffer(buffer, ctype)
+        frames = self._cdata_io('read', cdata, ctype, frames)
+        return frames
+
+    def write(self, data):
+        """Write audio data from a NumPy array to the file.
+
+        Writes a number of frames at the read/write position to the
+        file. This also advances the read/write position by the same
+        number of frames and enlarges the file if necessary.
+
+        Note that writing int values to a float file will *not* scale
+        the values to [-1.0, 1.0). If you write the value
+        ``np.array([42], dtype='int32')``, to a ``subtype='FLOAT'``
+        file, the file will then contain ``np.array([42.],
+        dtype='float32')``.
+
+        Parameters
+        ----------
+        data : array_like
+            The data to write. Usually two-dimensional (frames x
+            channels), but one-dimensional *data* can be used for mono
+            files. Only the data types ``'float64'``, ``'float32'``,
+            ``'int32'`` and ``'int16'`` are supported.
+
+            .. note:: The data type of *data* does **not** select the
+                  data type of the written file. Audio data will be
+                  converted to the given *subtype*. Writing int values
+                  to a float file will *not* scale the values to
+                  [-1.0, 1.0). If you write the value ``np.array([42],
+                  dtype='int32')``, to a ``subtype='FLOAT'`` file, the
+                  file will then contain ``np.array([42.],
+                  dtype='float32')``.
+
+        Examples
+        --------
+        >>> import numpy as np
+        >>> from soundfile import SoundFile
+        >>> myfile = SoundFile('stereo_file.wav')
+
+        Write 10 frames of random data to a new file:
+
+        >>> with SoundFile('stereo_file.wav', 'w', 44100, 2, 'PCM_24') as f:
+        >>>     f.write(np.random.randn(10, 2))
+
+        See Also
+        --------
+        buffer_write, .read
+
+        """
+        import numpy as np
+
+        # no copy is made if data has already the correct memory layout:
+        data = np.ascontiguousarray(data)
+        written = self._array_io('write', data, len(data))
+        assert written == len(data)
+        self._update_frames(written)
+
+    def buffer_write(self, data, dtype):
+        """Write audio data from a buffer/bytes object to the file.
+
+        Writes the contents of *data* to the file at the current
+        read/write position.
+        This also advances the read/write position by the number of
+        frames that were written and enlarges the file if necessary.
+
+        Parameters
+        ----------
+        data : buffer or bytes
+            A buffer or bytes object containing the audio data to be
+            written.
+        dtype : {'float64', 'float32', 'int32', 'int16'}
+            The data type of the audio data stored in *data*.
+
+        See Also
+        --------
+        .write, buffer_read
+
+        """
+        ctype = self._check_dtype(dtype)
+        cdata, frames = self._check_buffer(data, ctype)
+        written = self._cdata_io('write', cdata, ctype, frames)
+        assert written == frames
+        self._update_frames(written)
+
+    def blocks(self, blocksize=None, overlap=0, frames=-1, dtype='float64',
+               always_2d=False, fill_value=None, out=None):
+        """Return a generator for block-wise reading.
+
+        By default, the generator yields blocks of the given
+        *blocksize* (using a given *overlap*) until the end of the file
+        is reached; *frames* can be used to stop earlier.
+
+        Parameters
+        ----------
+        blocksize : int
+            The number of frames to read per block. Either this or *out*
+            must be given.
+        overlap : int, optional
+            The number of frames to rewind between each block.
+        frames : int, optional
+            The number of frames to read.
+            If ``frames < 0``, the file is read until the end.
+        dtype : {'float64', 'float32', 'int32', 'int16'}, optional
+            See `read()`.
+
+        Yields
+        ------
+        `numpy.ndarray` or type(out)
+            Blocks of audio data.
+            If *out* was given, and the requested frames are not an
+            integer multiple of the length of *out*, and no
+            *fill_value* was given, the last block will be a smaller
+            view into *out*.
+
+
+        Other Parameters
+        ----------------
+        always_2d, fill_value, out
+            See `read()`.
+        fill_value : float, optional
+            See `read()`.
+        out : `numpy.ndarray` or subclass, optional
+            If *out* is specified, the data is written into the given
+            array instead of creating a new array. In this case, the
+            arguments *dtype* and *always_2d* are silently ignored!
+
+        Examples
+        --------
+        >>> from soundfile import SoundFile
+        >>> with SoundFile('stereo_file.wav') as f:
+        >>>     for block in f.blocks(blocksize=1024):
+        >>>         pass  # do something with 'block'
+
+        """
+        import numpy as np
+
+        if 'r' not in self.mode and '+' not in self.mode:
+            raise SoundFileRuntimeError("blocks() is not allowed in write-only mode")
+
+        frames = self._check_frames(frames, fill_value)
+        if out is None:
+            if blocksize is None:
+                raise TypeError("One of {blocksize, out} must be specified")
+            out_size = blocksize if fill_value is not None else min(blocksize, frames)
+            out = self._create_empty_array(out_size, always_2d, dtype)
+            copy_out = True
+        else:
+            if blocksize is not None:
+                raise TypeError(
+                    "Only one of {blocksize, out} may be specified")
+            blocksize = len(out)
+            copy_out = False
+
+        overlap_memory = None
+        while frames > 0:
+            if overlap_memory is None:
+                output_offset = 0
+            else:
+                output_offset = len(overlap_memory)
+                out[:output_offset] = overlap_memory
+
+            toread = min(blocksize - output_offset, frames)
+            self.read(toread, dtype, always_2d, fill_value, out[output_offset:])
+
+            if overlap:
+                if overlap_memory is None:
+                    overlap_memory = np.copy(out[-overlap:])
+                else:
+                    overlap_memory[:] = out[-overlap:]
+
+            if blocksize > frames + overlap and fill_value is None:
+                block = out[:frames + overlap]
+            else:
+                block = out
+            yield np.copy(block) if copy_out else block
+            frames -= toread
+
+    def truncate(self, frames=None):
+        """Truncate the file to a given number of frames.
+
+        After this command, the read/write position will be at the new
+        end of the file.
+
+        Parameters
+        ----------
+        frames : int, optional
+            Only the data before *frames* is kept, the rest is deleted.
+            If not specified, the current read/write position is used.
+
+        """
+        if frames is None:
+            frames = self.tell()
+        err = _snd.sf_command(self._file, _snd.SFC_FILE_TRUNCATE,
+                              _ffi.new("sf_count_t*", frames),
+                              _ffi.sizeof("sf_count_t"))
+        if err:
+            # get the actual error code
+            err = _snd.sf_error(self._file)
+            raise LibsndfileError(err, "Error truncating the file")
+        self._info.frames = frames
+
+    def flush(self):
+        """Write unwritten data to the file system.
+
+        Data written with `write()` is not immediately written to
+        the file system but buffered in memory to be written at a later
+        time.  Calling `flush()` makes sure that all changes are
+        actually written to the file system.
+
+        This has no effect on files opened in read-only mode.
+
+        """
+        self._check_if_closed()
+        _snd.sf_write_sync(self._file)
+
+    def close(self):
+        """Close the file.  Can be called multiple times."""
+        if not self.closed:
+            # be sure to flush data to disk before closing the file
+            self.flush()
+            err = _snd.sf_close(self._file)
+            self._file = None
+            _error_check(err)
+
+    def _open(self, file, mode_int, closefd):
+        """Call the appropriate sf_open*() function from libsndfile."""
+        if isinstance(file, (_unicode, bytes)):
+            if _os.path.isfile(file):
+                if 'x' in self.mode:
+                    raise OSError("File exists: {0!r}".format(self.name))
+                elif set(self.mode).issuperset('w+'):
+                    # truncate the file, because SFM_RDWR doesn't:
+                    _os.close(_os.open(file, _os.O_WRONLY | _os.O_TRUNC))
+            openfunction = _snd.sf_open
+            if isinstance(file, _unicode):
+                if _sys.platform == 'win32':
+                    openfunction = _snd.sf_wchar_open
+                else:
+                    file = file.encode(_sys.getfilesystemencoding())
+            file_ptr = openfunction(file, mode_int, self._info)
+        elif isinstance(file, int):
+            file_ptr = _snd.sf_open_fd(file, mode_int, self._info, closefd)
+        elif _has_virtual_io_attrs(file, mode_int):
+            file_ptr = _snd.sf_open_virtual(self._init_virtual_io(file),
+                                            mode_int, self._info, _ffi.NULL)
+        else:
+            raise TypeError("Invalid file: {0!r}".format(self.name))
+        if file_ptr == _ffi.NULL:
+            # get the actual error code
+            err = _snd.sf_error(file_ptr)
+            raise LibsndfileError(err, prefix="Error opening {0!r}: ".format(self.name))
+        if mode_int == _snd.SFM_WRITE:
+            # Due to a bug in libsndfile version <= 1.0.25, frames != 0
+            # when opening a named pipe in SFM_WRITE mode.
+            # See http://github.com/erikd/libsndfile/issues/77.
+            self._info.frames = 0
+            # This is not necessary for "normal" files (because
+            # frames == 0 in this case), but it doesn't hurt, either.
+        return file_ptr
+
+    def _init_virtual_io(self, file):
+        """Initialize callback functions for sf_open_virtual()."""
+        @_ffi.callback("sf_vio_get_filelen")
+        def vio_get_filelen(user_data):
+            curr = file.tell()
+            file.seek(0, SEEK_END)
+            size = file.tell()
+            file.seek(curr, SEEK_SET)
+            return size
+
+        @_ffi.callback("sf_vio_seek")
+        def vio_seek(offset, whence, user_data):
+            file.seek(offset, whence)
+            return file.tell()
+
+        @_ffi.callback("sf_vio_read")
+        def vio_read(ptr, count, user_data):
+            # first try readinto(), if not available fall back to read()
+            try:
+                buf = _ffi.buffer(ptr, count)
+                data_read = file.readinto(buf)
+            except AttributeError:
+                data = file.read(count)
+                data_read = len(data)
+                buf = _ffi.buffer(ptr, data_read)
+                buf[0:data_read] = data
+            return data_read
+
+        @_ffi.callback("sf_vio_write")
+        def vio_write(ptr, count, user_data):
+            buf = _ffi.buffer(ptr, count)
+            data = buf[:]
+            written = file.write(data)
+            # write() returns None for file objects in Python <= 2.7:
+            if written is None:
+                written = count
+            return written
+
+        @_ffi.callback("sf_vio_tell")
+        def vio_tell(user_data):
+            return file.tell()
+
+        # Note: the callback functions must be kept alive!
+        self._virtual_io = {'get_filelen': vio_get_filelen,
+                            'seek': vio_seek,
+                            'read': vio_read,
+                            'write': vio_write,
+                            'tell': vio_tell}
+
+        return _ffi.new("SF_VIRTUAL_IO*", self._virtual_io)
+
+    def _getAttributeNames(self):
+        """Return all attributes used in __setattr__ and __getattr__.
+
+        This is useful for auto-completion (e.g. IPython).
+
+        """
+        return _str_types
+
+    def _check_if_closed(self):
+        """Check if the file is closed and raise an error if it is.
+
+        This should be used in every method that uses self._file.
+
+        """
+        if self.closed:
+            raise SoundFileRuntimeError("I/O operation on closed file")
+
+    def _check_frames(self, frames, fill_value):
+        """Reduce frames to no more than are available in the file."""
+        if self.seekable():
+            remaining_frames = self.frames - self.tell()
+            if frames < 0 or (frames > remaining_frames and
+                              fill_value is None):
+                frames = remaining_frames
+        elif frames < 0:
+            raise ValueError("frames must be specified for non-seekable files")
+        return frames
+
+    def _check_buffer(self, data, ctype):
+        """Convert buffer to cdata and check for valid size."""
+        assert ctype in _ffi_types.values()
+        if not isinstance(data, bytes):
+            data = _ffi.from_buffer(data)
+        frames, remainder = divmod(len(data),
+                                   self.channels * _ffi.sizeof(ctype))
+        if remainder:
+            raise ValueError("Data size must be a multiple of frame size")
+        return data, frames
+
+    def _create_empty_array(self, frames, always_2d, dtype):
+        """Create an empty array with appropriate shape."""
+        import numpy as np
+        if always_2d or self.channels > 1:
+            shape = frames, self.channels
+        else:
+            shape = frames,
+        return np.empty(shape, dtype, order='C')
+
+    def _check_dtype(self, dtype):
+        """Check if dtype string is valid and return ctype string."""
+        try:
+            return _ffi_types[dtype]
+        except KeyError:
+            raise ValueError("dtype must be one of {0!r} and not {1!r}".format(
+                sorted(_ffi_types.keys()), dtype))
+
+    def _array_io(self, action, array, frames):
+        """Check array and call low-level IO function."""
+        if array.ndim not in (1,2):
+            raise ValueError("Invalid shape: {0!r} ({1})".format(array.shape, "0 dimensions not supported" if array.ndim < 1 else "too many dimensions"))
+        array_channels = 1 if array.ndim == 1 else array.shape[1]
+        if array_channels != self.channels:
+            raise ValueError("Invalid shape: {0!r} (Expected {1} channels, got {2})".format(array.shape, self.channels, array_channels))
+        if not array.flags.c_contiguous:
+            raise ValueError("Data must be C-contiguous")
+        ctype = self._check_dtype(array.dtype.name)
+        assert array.dtype.itemsize == _ffi.sizeof(ctype)
+        cdata = _ffi.cast(ctype + '*', array.__array_interface__['data'][0])
+        return self._cdata_io(action, cdata, ctype, frames)
+
+    def _cdata_io(self, action, data, ctype, frames):
+        """Call one of libsndfile's read/write functions."""
+        assert ctype in _ffi_types.values()
+        self._check_if_closed()
+        if self.seekable():
+            curr = self.tell()
+        func = getattr(_snd, 'sf_' + action + 'f_' + ctype)
+        frames = func(self._file, data, frames)
+        _error_check(self._errorcode)
+        if self.seekable():
+            self.seek(curr + frames, SEEK_SET)  # Update read & write position
+        return frames
+
+    def _update_frames(self, written):
+        """Update self.frames after writing."""
+        if self.seekable():
+            curr = self.tell()
+            self._info.frames = self.seek(0, SEEK_END)
+            self.seek(curr, SEEK_SET)
+        else:
+            self._info.frames += written
+
+    def _prepare_read(self, start, stop, frames):
+        """Seek to start frame and calculate length."""
+        if start != 0 and not self.seekable():
+            raise ValueError("start is only allowed for seekable files")
+        if frames >= 0 and stop is not None:
+            raise TypeError("Only one of {frames, stop} may be used")
+
+        start, stop, _ = slice(start, stop).indices(self.frames)
+        if stop < start:
+            stop = start
+        if frames < 0:
+            frames = stop - start
+        if self.seekable():
+            self.seek(start, SEEK_SET)
+        return frames
+
+    def copy_metadata(self):
+        """Get all metadata present in this SoundFile
+
+        Returns
+        -------
+
+        metadata: dict[str, str]
+            A dict with all metadata. Possible keys are: 'title', 'copyright',
+            'software', 'artist', 'comment', 'date', 'album', 'license',
+            'tracknumber' and 'genre'.
+        """
+        strs = {}
+        for strtype, strid in _str_types.items():
+            data = _snd.sf_get_string(self._file, strid)
+            if data:
+                strs[strtype] = _ffi.string(data).decode('utf-8', 'replace')
+        return strs
+    
+    def _set_bitrate_mode(self, bitrate_mode):
+        """Call libsndfile's set bitrate mode function."""
+        assert bitrate_mode in _bitrate_modes
+
+        pointer_bitrate_mode = _ffi.new("int[1]")
+        pointer_bitrate_mode[0] = _bitrate_modes[bitrate_mode]
+        err = _snd.sf_command(self._file, _snd.SFC_SET_BITRATE_MODE, pointer_bitrate_mode, _ffi.sizeof(pointer_bitrate_mode))
+        if err != _snd.SF_TRUE:
+            err = _snd.sf_error(self._file)
+            raise LibsndfileError(err, f"Error set bitrate mode {bitrate_mode}")
+
+        
+    def _set_compression_level(self, compression_level):
+        """Call libsndfile's set compression level function."""
+        if not (0 <= compression_level <= 1):
+            raise ValueError("Compression level must be in range [0..1]")
+
+        pointer_compression_level = _ffi.new("double[1]")
+        pointer_compression_level[0] = compression_level
+        err = _snd.sf_command(self._file, _snd.SFC_SET_COMPRESSION_LEVEL, pointer_compression_level, _ffi.sizeof(pointer_compression_level))
+        if err != _snd.SF_TRUE:
+            err = _snd.sf_error(self._file)
+            raise LibsndfileError(err, f"Error set compression level {compression_level}")
+
+
+def _error_check(err, prefix=""):
+    """Raise LibsndfileError if there is an error."""
+    if err != 0:
+        raise LibsndfileError(err, prefix=prefix)
+
+
+def _format_int(format, subtype, endian):
+    """Return numeric ID for given format|subtype|endian combo."""
+    result = _check_format(format)
+    if subtype is None:
+        subtype = default_subtype(format)
+        if subtype is None:
+            raise TypeError(
+                "No default subtype for major format {0!r}".format(format))
+    elif not isinstance(subtype, (_unicode, str)):
+        raise TypeError("Invalid subtype: {0!r}".format(subtype))
+    try:
+        result |= _subtypes[subtype.upper()]
+    except KeyError:
+        raise ValueError("Unknown subtype: {0!r}".format(subtype))
+    if endian is None:
+        endian = 'FILE'
+    elif not isinstance(endian, (_unicode, str)):
+        raise TypeError("Invalid endian-ness: {0!r}".format(endian))
+    try:
+        result |= _endians[endian.upper()]
+    except KeyError:
+        raise ValueError("Unknown endian-ness: {0!r}".format(endian))
+
+    info = _ffi.new("SF_INFO*")
+    info.format = result
+    info.channels = 1
+    if _snd.sf_format_check(info) == _snd.SF_FALSE:
+        raise ValueError(
+            "Invalid combination of format, subtype and endian")
+    return result
+
+
+def _check_mode(mode):
+    """Check if mode is valid and return its integer representation."""
+    if not isinstance(mode, (_unicode, str)):
+        raise TypeError("Invalid mode: {0!r}".format(mode))
+    mode_set = set(mode)
+    if mode_set.difference('xrwb+') or len(mode) > len(mode_set):
+        raise ValueError("Invalid mode: {0!r}".format(mode))
+    if len(mode_set.intersection('xrw')) != 1:
+        raise ValueError("mode must contain exactly one of 'xrw'")
+
+    if '+' in mode_set:
+        mode_int = _snd.SFM_RDWR
+    elif 'r' in mode_set:
+        mode_int = _snd.SFM_READ
+    else:
+        mode_int = _snd.SFM_WRITE
+    return mode_int
+
+
+def _create_info_struct(file, mode, samplerate, channels,
+                        format, subtype, endian):
+    """Check arguments and create SF_INFO struct."""
+    original_format = format
+    if format is None:
+        format = _get_format_from_filename(file, mode)
+        assert isinstance(format, (_unicode, str))
+    else:
+        _check_format(format)
+
+    info = _ffi.new("SF_INFO*")
+    if 'r' not in mode or format.upper() == 'RAW':
+        if samplerate is None:
+            raise TypeError("samplerate must be specified")
+        info.samplerate = samplerate
+        if channels is None:
+            raise TypeError("channels must be specified")
+        info.channels = channels
+        info.format = _format_int(format, subtype, endian)
+    else:
+        if any(arg is not None for arg in (
+                samplerate, channels, original_format, subtype, endian)):
+            raise TypeError("Not allowed for existing files (except 'RAW'): "
+                            "samplerate, channels, format, subtype, endian")
+    return info
+
+
+def _get_format_from_filename(file, mode):
+    """Return a format string obtained from file (or file.name).
+
+    If file already exists (= read mode), an empty string is returned on
+    error.  If not, an exception is raised.
+    The return type will always be str or unicode (even if
+    file/file.name is a bytes object).
+
+    """
+    format = ''
+    file = getattr(file, 'name', file)
+    try:
+        # This raises an exception if file is not a (Unicode/byte) string:
+        format = _os.path.splitext(file)[-1][1:]
+        # Convert bytes to unicode (raises AttributeError on Python 3 str):
+        format = format.decode('utf-8', 'replace')
+    except Exception:
+        pass
+    if format.upper() not in _formats and 'r' not in mode:
+        raise TypeError("No format specified and unable to get format from "
+                        "file extension: {0!r}".format(file))
+    return format
+
+
+def _format_str(format_int):
+    """Return the string representation of a given numeric format."""
+    for dictionary in _formats, _subtypes, _endians:
+        for k, v in dictionary.items():
+            if v == format_int:
+                return k
+    else:
+        return 'n/a'
+
+
+def _format_info(format_int, format_flag=_snd.SFC_GET_FORMAT_INFO):
+    """Return the ID and short description of a given format."""
+    format_info = _ffi.new("SF_FORMAT_INFO*")
+    format_info.format = format_int
+    _snd.sf_command(_ffi.NULL, format_flag, format_info,
+                    _ffi.sizeof("SF_FORMAT_INFO"))
+    name = format_info.name
+    return (_format_str(format_info.format),
+            _ffi.string(name).decode('utf-8', 'replace') if name else "")
+
+
+def _available_formats_helper(count_flag, format_flag):
+    """Helper for available_formats() and available_subtypes()."""
+    count = _ffi.new("int*")
+    _snd.sf_command(_ffi.NULL, count_flag, count, _ffi.sizeof("int"))
+    for format_int in range(count[0]):
+        yield _format_info(format_int, format_flag)
+
+
+def _check_format(format_str):
+    """Check if `format_str` is valid and return format ID."""
+    if not isinstance(format_str, (_unicode, str)):
+        raise TypeError("Invalid format: {0!r}".format(format_str))
+    try:
+        format_int = _formats[format_str.upper()]
+    except KeyError:
+        raise ValueError("Unknown format: {0!r}".format(format_str))
+    return format_int
+
+
+def _has_virtual_io_attrs(file, mode_int):
+    """Check if file has all the necessary attributes for virtual IO."""
+    readonly = mode_int == _snd.SFM_READ
+    writeonly = mode_int == _snd.SFM_WRITE
+    return all([
+        hasattr(file, 'seek'),
+        hasattr(file, 'tell'),
+        hasattr(file, 'write') or readonly,
+        hasattr(file, 'read') or hasattr(file, 'readinto') or writeonly,
+    ])
+
+
+class SoundFileError(Exception):
+    """Base class for all soundfile-specific errors."""
+    pass
+
+class SoundFileRuntimeError(SoundFileError, RuntimeError):
+    """soundfile module runtime error.
+
+    Errors that used to be `RuntimeError`."""
+    pass
+
+class LibsndfileError(SoundFileRuntimeError):
+    """libsndfile errors.
+
+
+    Attributes
+    ----------
+    code
+        libsndfile internal error number.
+    """
+    def __init__(self, code, prefix=""):
+        SoundFileRuntimeError.__init__(self, code, prefix)
+        self.code = code
+        self.prefix = prefix
+
+    @property
+    def error_string(self):
+        """Raw libsndfile error message."""
+        if self.code:
+            err_str = _snd.sf_error_number(self.code)
+            return _ffi.string(err_str).decode('utf-8', 'replace')
+        else:
+            # Due to race conditions, if used concurrently, sf_error() may
+            # return 0 (= no error) even if an error has happened.
+            # See https://github.com/erikd/libsndfile/issues/610 for details.
+            return "(Garbled error message from libsndfile)"
+
+    def __str__(self):
+        return self.prefix + self.error_string

venv/lib/python3.10/site-packages/threadpoolctl.py

@@ -0,0 +1,1292 @@
+"""threadpoolctl
+
+This module provides utilities to introspect native libraries that relies on
+thread pools (notably BLAS and OpenMP implementations) and dynamically set the
+maximal number of threads they can use.
+"""
+
+# License: BSD 3-Clause
+
+# The code to introspect dynamically loaded libraries on POSIX systems is
+# adapted from code by Intel developer @anton-malakhov available at
+# https://github.com/IntelPython/smp (Copyright (c) 2017, Intel Corporation)
+# and also published under the BSD 3-Clause license
+import os
+import re
+import sys
+import ctypes
+import itertools
+import textwrap
+from typing import final
+import warnings
+from ctypes.util import find_library
+from abc import ABC, abstractmethod
+from functools import lru_cache
+from contextlib import ContextDecorator
+
+__version__ = "3.6.0"
+__all__ = [
+    "threadpool_limits",
+    "threadpool_info",
+    "ThreadpoolController",
+    "LibController",
+    "register",
+]
+
+
+# One can get runtime errors or even segfaults due to multiple OpenMP libraries
+# loaded simultaneously which can happen easily in Python when importing and
+# using compiled extensions built with different compilers and therefore
+# different OpenMP runtimes in the same program. In particular libiomp (used by
+# Intel ICC) and libomp used by clang/llvm tend to crash. This can happen for
+# instance when calling BLAS inside a prange. Setting the following environment
+# variable allows multiple OpenMP libraries to be loaded. It should not degrade
+# performances since we manually take care of potential over-subscription
+# performance issues, in sections of the code where nested OpenMP loops can
+# happen, by dynamically reconfiguring the inner OpenMP runtime to temporarily
+# disable it while under the scope of the outer OpenMP parallel section.
+os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "True")
+
+# Structure to cast the info on dynamically loaded library. See
+# https://linux.die.net/man/3/dl_iterate_phdr for more details.
+_SYSTEM_UINT = ctypes.c_uint64 if sys.maxsize > 2**32 else ctypes.c_uint32
+_SYSTEM_UINT_HALF = ctypes.c_uint32 if sys.maxsize > 2**32 else ctypes.c_uint16
+
+
+class _dl_phdr_info(ctypes.Structure):
+    _fields_ = [
+        ("dlpi_addr", _SYSTEM_UINT),  # Base address of object
+        ("dlpi_name", ctypes.c_char_p),  # path to the library
+        ("dlpi_phdr", ctypes.c_void_p),  # pointer on dlpi_headers
+        ("dlpi_phnum", _SYSTEM_UINT_HALF),  # number of elements in dlpi_phdr
+    ]
+
+
+# The RTLD_NOLOAD flag for loading shared libraries is not defined on Windows.
+try:
+    _RTLD_NOLOAD = os.RTLD_NOLOAD
+except AttributeError:
+    _RTLD_NOLOAD = ctypes.DEFAULT_MODE
+
+
+class LibController(ABC):
+    """Abstract base class for the individual library controllers
+
+    A library controller must expose the following class attributes:
+        - user_api : str
+            Usually the name of the library or generic specification the library
+            implements, e.g. "blas" is a specification with different implementations.
+        - internal_api : str
+            Usually the name of the library or concrete implementation of some
+            specification, e.g. "openblas" is an implementation of the "blas"
+            specification.
+        - filename_prefixes : tuple
+            Possible prefixes of the shared library's filename that allow to
+            identify the library. e.g. "libopenblas" for libopenblas.so.
+
+    and implement the following methods: `get_num_threads`, `set_num_threads` and
+    `get_version`.
+
+    Threadpoolctl loops through all the loaded shared libraries and tries to match
+    the filename of each library with the `filename_prefixes`. If a match is found, a
+    controller is instantiated and a handler to the library is stored in the `dynlib`
+    attribute as a `ctypes.CDLL` object. It can be used to access the necessary symbols
+    of the shared library to implement the above methods.
+
+    The following information will be exposed in the info dictionary:
+      - user_api : standardized API, if any, or a copy of internal_api.
+      - internal_api : implementation-specific API.
+      - num_threads : the current thread limit.
+      - prefix : prefix of the shared library's filename.
+      - filepath : path to the loaded shared library.
+      - version : version of the library (if available).
+
+    In addition, each library controller may expose internal API specific entries. They
+    must be set as attributes in the `set_additional_attributes` method.
+    """
+
+    @final
+    def __init__(self, *, filepath=None, prefix=None, parent=None):
+        """This is not meant to be overriden by subclasses."""
+        self.parent = parent
+        self.prefix = prefix
+        self.filepath = filepath
+        self.dynlib = ctypes.CDLL(filepath, mode=_RTLD_NOLOAD)
+        self._symbol_prefix, self._symbol_suffix = self._find_affixes()
+        self.version = self.get_version()
+        self.set_additional_attributes()
+
+    def info(self):
+        """Return relevant info wrapped in a dict"""
+        hidden_attrs = ("dynlib", "parent", "_symbol_prefix", "_symbol_suffix")
+        return {
+            "user_api": self.user_api,
+            "internal_api": self.internal_api,
+            "num_threads": self.num_threads,
+            **{k: v for k, v in vars(self).items() if k not in hidden_attrs},
+        }
+
+    def set_additional_attributes(self):
+        """Set additional attributes meant to be exposed in the info dict"""
+
+    @property
+    def num_threads(self):
+        """Exposes the current thread limit as a dynamic property
+
+        This is not meant to be used or overriden by subclasses.
+        """
+        return self.get_num_threads()
+
+    @abstractmethod
+    def get_num_threads(self):
+        """Return the maximum number of threads available to use"""
+
+    @abstractmethod
+    def set_num_threads(self, num_threads):
+        """Set the maximum number of threads to use"""
+
+    @abstractmethod
+    def get_version(self):
+        """Return the version of the shared library"""
+
+    def _find_affixes(self):
+        """Return the affixes for the symbols of the shared library"""
+        return "", ""
+
+    def _get_symbol(self, name):
+        """Return the symbol of the shared library accounding for the affixes"""
+        return getattr(
+            self.dynlib, f"{self._symbol_prefix}{name}{self._symbol_suffix}", None
+        )
+
+
+class OpenBLASController(LibController):
+    """Controller class for OpenBLAS"""
+
+    user_api = "blas"
+    internal_api = "openblas"
+    filename_prefixes = ("libopenblas", "libblas", "libscipy_openblas")
+
+    _symbol_prefixes = ("", "scipy_")
+    _symbol_suffixes = ("", "64_", "_64")
+
+    # All variations of "openblas_get_num_threads", accounting for the affixes
+    check_symbols = tuple(
+        f"{prefix}openblas_get_num_threads{suffix}"
+        for prefix, suffix in itertools.product(_symbol_prefixes, _symbol_suffixes)
+    )
+
+    def _find_affixes(self):
+        for prefix, suffix in itertools.product(
+            self._symbol_prefixes, self._symbol_suffixes
+        ):
+            if hasattr(self.dynlib, f"{prefix}openblas_get_num_threads{suffix}"):
+                return prefix, suffix
+
+    def set_additional_attributes(self):
+        self.threading_layer = self._get_threading_layer()
+        self.architecture = self._get_architecture()
+
+    def get_num_threads(self):
+        get_num_threads_func = self._get_symbol("openblas_get_num_threads")
+        if get_num_threads_func is not None:
+            return get_num_threads_func()
+        return None
+
+    def set_num_threads(self, num_threads):
+        set_num_threads_func = self._get_symbol("openblas_set_num_threads")
+        if set_num_threads_func is not None:
+            return set_num_threads_func(num_threads)
+        return None
+
+    def get_version(self):
+        # None means OpenBLAS is not loaded or version < 0.3.4, since OpenBLAS
+        # did not expose its version before that.
+        get_version_func = self._get_symbol("openblas_get_config")
+        if get_version_func is not None:
+            get_version_func.restype = ctypes.c_char_p
+            config = get_version_func().split()
+            if config[0] == b"OpenBLAS":
+                return config[1].decode("utf-8")
+            return None
+        return None
+
+    def _get_threading_layer(self):
+        """Return the threading layer of OpenBLAS"""
+        get_threading_layer_func = self._get_symbol("openblas_get_parallel")
+        if get_threading_layer_func is not None:
+            threading_layer = get_threading_layer_func()
+            if threading_layer == 2:
+                return "openmp"
+            elif threading_layer == 1:
+                return "pthreads"
+            return "disabled"
+        return "unknown"
+
+    def _get_architecture(self):
+        """Return the architecture detected by OpenBLAS"""
+        get_architecture_func = self._get_symbol("openblas_get_corename")
+        if get_architecture_func is not None:
+            get_architecture_func.restype = ctypes.c_char_p
+            return get_architecture_func().decode("utf-8")
+        return None
+
+
+class BLISController(LibController):
+    """Controller class for BLIS"""
+
+    user_api = "blas"
+    internal_api = "blis"
+    filename_prefixes = ("libblis", "libblas")
+    check_symbols = (
+        "bli_thread_get_num_threads",
+        "bli_thread_set_num_threads",
+        "bli_info_get_version_str",
+        "bli_info_get_enable_openmp",
+        "bli_info_get_enable_pthreads",
+        "bli_arch_query_id",
+        "bli_arch_string",
+    )
+
+    def set_additional_attributes(self):
+        self.threading_layer = self._get_threading_layer()
+        self.architecture = self._get_architecture()
+
+    def get_num_threads(self):
+        get_func = getattr(self.dynlib, "bli_thread_get_num_threads", lambda: None)
+        num_threads = get_func()
+        # by default BLIS is single-threaded and get_num_threads
+        # returns -1. We map it to 1 for consistency with other libraries.
+        return 1 if num_threads == -1 else num_threads
+
+    def set_num_threads(self, num_threads):
+        set_func = getattr(
+            self.dynlib, "bli_thread_set_num_threads", lambda num_threads: None
+        )
+        return set_func(num_threads)
+
+    def get_version(self):
+        get_version_ = getattr(self.dynlib, "bli_info_get_version_str", None)
+        if get_version_ is None:
+            return None
+
+        get_version_.restype = ctypes.c_char_p
+        return get_version_().decode("utf-8")
+
+    def _get_threading_layer(self):
+        """Return the threading layer of BLIS"""
+        if getattr(self.dynlib, "bli_info_get_enable_openmp", lambda: False)():
+            return "openmp"
+        elif getattr(self.dynlib, "bli_info_get_enable_pthreads", lambda: False)():
+            return "pthreads"
+        return "disabled"
+
+    def _get_architecture(self):
+        """Return the architecture detected by BLIS"""
+        bli_arch_query_id = getattr(self.dynlib, "bli_arch_query_id", None)
+        bli_arch_string = getattr(self.dynlib, "bli_arch_string", None)
+        if bli_arch_query_id is None or bli_arch_string is None:
+            return None
+
+        # the true restype should be BLIS' arch_t (enum) but int should work
+        # for us:
+        bli_arch_query_id.restype = ctypes.c_int
+        bli_arch_string.restype = ctypes.c_char_p
+        return bli_arch_string(bli_arch_query_id()).decode("utf-8")
+
+
+class FlexiBLASController(LibController):
+    """Controller class for FlexiBLAS"""
+
+    user_api = "blas"
+    internal_api = "flexiblas"
+    filename_prefixes = ("libflexiblas",)
+    check_symbols = (
+        "flexiblas_get_num_threads",
+        "flexiblas_set_num_threads",
+        "flexiblas_get_version",
+        "flexiblas_list",
+        "flexiblas_list_loaded",
+        "flexiblas_current_backend",
+    )
+
+    @property
+    def loaded_backends(self):
+        return self._get_backend_list(loaded=True)
+
+    @property
+    def current_backend(self):
+        return self._get_current_backend()
+
+    def info(self):
+        """Return relevant info wrapped in a dict"""
+        # We override the info method because the loaded and current backends
+        # are dynamic properties
+        exposed_attrs = super().info()
+        exposed_attrs["loaded_backends"] = self.loaded_backends
+        exposed_attrs["current_backend"] = self.current_backend
+
+        return exposed_attrs
+
+    def set_additional_attributes(self):
+        self.available_backends = self._get_backend_list(loaded=False)
+
+    def get_num_threads(self):
+        get_func = getattr(self.dynlib, "flexiblas_get_num_threads", lambda: None)
+        num_threads = get_func()
+        # by default BLIS is single-threaded and get_num_threads
+        # returns -1. We map it to 1 for consistency with other libraries.
+        return 1 if num_threads == -1 else num_threads
+
+    def set_num_threads(self, num_threads):
+        set_func = getattr(
+            self.dynlib, "flexiblas_set_num_threads", lambda num_threads: None
+        )
+        return set_func(num_threads)
+
+    def get_version(self):
+        get_version_ = getattr(self.dynlib, "flexiblas_get_version", None)
+        if get_version_ is None:
+            return None
+
+        major = ctypes.c_int()
+        minor = ctypes.c_int()
+        patch = ctypes.c_int()
+        get_version_(ctypes.byref(major), ctypes.byref(minor), ctypes.byref(patch))
+        return f"{major.value}.{minor.value}.{patch.value}"
+
+    def _get_backend_list(self, loaded=False):
+        """Return the list of available backends for FlexiBLAS.
+
+        If loaded is False, return the list of available backends from the FlexiBLAS
+        configuration. If loaded is True, return the list of actually loaded backends.
+        """
+        func_name = f"flexiblas_list{'_loaded' if loaded else ''}"
+        get_backend_list_ = getattr(self.dynlib, func_name, None)
+        if get_backend_list_ is None:
+            return None
+
+        n_backends = get_backend_list_(None, 0, 0)
+
+        backends = []
+        for i in range(n_backends):
+            backend_name = ctypes.create_string_buffer(1024)
+            get_backend_list_(backend_name, 1024, i)
+            if backend_name.value.decode("utf-8") != "__FALLBACK__":
+                # We don't know when to expect __FALLBACK__ but it is not a real
+                # backend and does not show up when running flexiblas list.
+                backends.append(backend_name.value.decode("utf-8"))
+        return backends
+
+    def _get_current_backend(self):
+        """Return the backend of FlexiBLAS"""
+        get_backend_ = getattr(self.dynlib, "flexiblas_current_backend", None)
+        if get_backend_ is None:
+            return None
+
+        backend = ctypes.create_string_buffer(1024)
+        get_backend_(backend, ctypes.sizeof(backend))
+        return backend.value.decode("utf-8")
+
+    def switch_backend(self, backend):
+        """Switch the backend of FlexiBLAS
+
+        Parameters
+        ----------
+        backend : str
+            The name or the path to the shared library of the backend to switch to. If
+            the backend is not already loaded, it will be loaded first.
+        """
+        if backend not in self.loaded_backends:
+            if backend in self.available_backends:
+                load_func = getattr(self.dynlib, "flexiblas_load_backend", lambda _: -1)
+            else:  # assume backend is a path to a shared library
+                load_func = getattr(
+                    self.dynlib, "flexiblas_load_backend_library", lambda _: -1
+                )
+            res = load_func(str(backend).encode("utf-8"))
+            if res == -1:
+                raise RuntimeError(
+                    f"Failed to load backend {backend!r}. It must either be the name of"
+                    " a backend available in the FlexiBLAS configuration "
+                    f"{self.available_backends} or the path to a valid shared library."
+                )
+
+            # Trigger a new search of loaded shared libraries since loading a new
+            # backend caused a dlopen.
+            self.parent._load_libraries()
+
+        switch_func = getattr(self.dynlib, "flexiblas_switch", lambda _: -1)
+        idx = self.loaded_backends.index(backend)
+        res = switch_func(idx)
+        if res == -1:
+            raise RuntimeError(f"Failed to switch to backend {backend!r}.")
+
+
+class MKLController(LibController):
+    """Controller class for MKL"""
+
+    user_api = "blas"
+    internal_api = "mkl"
+    filename_prefixes = ("libmkl_rt", "mkl_rt", "libblas")
+    check_symbols = (
+        "MKL_Get_Max_Threads",
+        "MKL_Set_Num_Threads",
+        "MKL_Get_Version_String",
+        "MKL_Set_Threading_Layer",
+    )
+
+    def set_additional_attributes(self):
+        self.threading_layer = self._get_threading_layer()
+
+    def get_num_threads(self):
+        get_func = getattr(self.dynlib, "MKL_Get_Max_Threads", lambda: None)
+        return get_func()
+
+    def set_num_threads(self, num_threads):
+        set_func = getattr(self.dynlib, "MKL_Set_Num_Threads", lambda num_threads: None)
+        return set_func(num_threads)
+
+    def get_version(self):
+        if not hasattr(self.dynlib, "MKL_Get_Version_String"):
+            return None
+
+        res = ctypes.create_string_buffer(200)
+        self.dynlib.MKL_Get_Version_String(res, 200)
+
+        version = res.value.decode("utf-8")
+        group = re.search(r"Version ([^ ]+) ", version)
+        if group is not None:
+            version = group.groups()[0]
+        return version.strip()
+
+    def _get_threading_layer(self):
+        """Return the threading layer of MKL"""
+        # The function mkl_set_threading_layer returns the current threading
+        # layer. Calling it with an invalid threading layer allows us to safely
+        # get the threading layer
+        set_threading_layer = getattr(
+            self.dynlib, "MKL_Set_Threading_Layer", lambda layer: -1
+        )
+        layer_map = {
+            0: "intel",
+            1: "sequential",
+            2: "pgi",
+            3: "gnu",
+            4: "tbb",
+            -1: "not specified",
+        }
+        return layer_map[set_threading_layer(-1)]
+
+
+class OpenMPController(LibController):
+    """Controller class for OpenMP"""
+
+    user_api = "openmp"
+    internal_api = "openmp"
+    filename_prefixes = ("libiomp", "libgomp", "libomp", "vcomp")
+    check_symbols = (
+        "omp_get_max_threads",
+        "omp_get_num_threads",
+    )
+
+    def get_num_threads(self):
+        get_func = getattr(self.dynlib, "omp_get_max_threads", lambda: None)
+        return get_func()
+
+    def set_num_threads(self, num_threads):
+        set_func = getattr(self.dynlib, "omp_set_num_threads", lambda num_threads: None)
+        return set_func(num_threads)
+
+    def get_version(self):
+        # There is no way to get the version number programmatically in OpenMP.
+        return None
+
+
+# Controllers for the libraries that we'll look for in the loaded libraries.
+# Third party libraries can register their own controllers.
+_ALL_CONTROLLERS = [
+    OpenBLASController,
+    BLISController,
+    MKLController,
+    OpenMPController,
+    FlexiBLASController,
+]
+
+# Helpers for the doc and test names
+_ALL_USER_APIS = list(set(lib.user_api for lib in _ALL_CONTROLLERS))
+_ALL_INTERNAL_APIS = [lib.internal_api for lib in _ALL_CONTROLLERS]
+_ALL_PREFIXES = list(
+    set(prefix for lib in _ALL_CONTROLLERS for prefix in lib.filename_prefixes)
+)
+_ALL_BLAS_LIBRARIES = [
+    lib.internal_api for lib in _ALL_CONTROLLERS if lib.user_api == "blas"
+]
+_ALL_OPENMP_LIBRARIES = OpenMPController.filename_prefixes
+
+
+def register(controller):
+    """Register a new controller"""
+    _ALL_CONTROLLERS.append(controller)
+    _ALL_USER_APIS.append(controller.user_api)
+    _ALL_INTERNAL_APIS.append(controller.internal_api)
+    _ALL_PREFIXES.extend(controller.filename_prefixes)
+
+
+def _format_docstring(*args, **kwargs):
+    def decorator(o):
+        if o.__doc__ is not None:
+            o.__doc__ = o.__doc__.format(*args, **kwargs)
+        return o
+
+    return decorator
+
+
+@lru_cache(maxsize=10000)
+def _realpath(filepath):
+    """Small caching wrapper around os.path.realpath to limit system calls"""
+    return os.path.realpath(filepath)
+
+
+@_format_docstring(USER_APIS=list(_ALL_USER_APIS), INTERNAL_APIS=_ALL_INTERNAL_APIS)
+def threadpool_info():
+    """Return the maximal number of threads for each detected library.
+
+    Return a list with all the supported libraries that have been found. Each
+    library is represented by a dict with the following information:
+
+      - "user_api" : user API. Possible values are {USER_APIS}.
+      - "internal_api": internal API. Possible values are {INTERNAL_APIS}.
+      - "prefix" : filename prefix of the specific implementation.
+      - "filepath": path to the loaded library.
+      - "version": version of the library (if available).
+      - "num_threads": the current thread limit.
+
+    In addition, each library may contain internal_api specific entries.
+    """
+    return ThreadpoolController().info()
+
+
+class _ThreadpoolLimiter:
+    """The guts of ThreadpoolController.limit
+
+    Refer to the docstring of ThreadpoolController.limit for more details.
+
+    It will only act on the library controllers held by the provided `controller`.
+    Using the default constructor sets the limits right away such that it can be used as
+    a callable. Setting the limits can be delayed by using the `wrap` class method such
+    that it can be used as a decorator.
+    """
+
+    def __init__(self, controller, *, limits=None, user_api=None):
+        self._controller = controller
+        self._limits, self._user_api, self._prefixes = self._check_params(
+            limits, user_api
+        )
+        self._original_info = self._controller.info()
+        self._set_threadpool_limits()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.restore_original_limits()
+
+    @classmethod
+    def wrap(cls, controller, *, limits=None, user_api=None):
+        """Return an instance of this class that can be used as a decorator"""
+        return _ThreadpoolLimiterDecorator(
+            controller=controller, limits=limits, user_api=user_api
+        )
+
+    def restore_original_limits(self):
+        """Set the limits back to their original values"""
+        for lib_controller, original_info in zip(
+            self._controller.lib_controllers, self._original_info
+        ):
+            lib_controller.set_num_threads(original_info["num_threads"])
+
+    # Alias of `restore_original_limits` for backward compatibility
+    unregister = restore_original_limits
+
+    def get_original_num_threads(self):
+        """Original num_threads from before calling threadpool_limits
+
+        Return a dict `{user_api: num_threads}`.
+        """
+        num_threads = {}
+        warning_apis = []
+
+        for user_api in self._user_api:
+            limits = [
+                lib_info["num_threads"]
+                for lib_info in self._original_info
+                if lib_info["user_api"] == user_api
+            ]
+            limits = set(limits)
+            n_limits = len(limits)
+
+            if n_limits == 1:
+                limit = limits.pop()
+            elif n_limits == 0:
+                limit = None
+            else:
+                limit = min(limits)
+                warning_apis.append(user_api)
+
+            num_threads[user_api] = limit
+
+        if warning_apis:
+            warnings.warn(
+                "Multiple value possible for following user apis: "
+                + ", ".join(warning_apis)
+                + ". Returning the minimum."
+            )
+
+        return num_threads
+
+    def _check_params(self, limits, user_api):
+        """Suitable values for the _limits, _user_api and _prefixes attributes"""
+
+        if isinstance(limits, str) and limits == "sequential_blas_under_openmp":
+            (
+                limits,
+                user_api,
+            ) = self._controller._get_params_for_sequential_blas_under_openmp().values()
+
+        if limits is None or isinstance(limits, int):
+            if user_api is None:
+                user_api = _ALL_USER_APIS
+            elif user_api in _ALL_USER_APIS:
+                user_api = [user_api]
+            else:
+                raise ValueError(
+                    f"user_api must be either in {_ALL_USER_APIS} or None. Got "
+                    f"{user_api} instead."
+                )
+
+            if limits is not None:
+                limits = {api: limits for api in user_api}
+            prefixes = []
+        else:
+            if isinstance(limits, list):
+                # This should be a list of dicts of library info, for
+                # compatibility with the result from threadpool_info.
+                limits = {
+                    lib_info["prefix"]: lib_info["num_threads"] for lib_info in limits
+                }
+            elif isinstance(limits, ThreadpoolController):
+                # To set the limits from the library controllers of a
+                # ThreadpoolController object.
+                limits = {
+                    lib_controller.prefix: lib_controller.num_threads
+                    for lib_controller in limits.lib_controllers
+                }
+
+            if not isinstance(limits, dict):
+                raise TypeError(
+                    "limits must either be an int, a list, a dict, or "
+                    f"'sequential_blas_under_openmp'. Got {type(limits)} instead"
+                )
+
+            # With a dictionary, can set both specific limit for given
+            # libraries and global limit for user_api. Fetch each separately.
+            prefixes = [prefix for prefix in limits if prefix in _ALL_PREFIXES]
+            user_api = [api for api in limits if api in _ALL_USER_APIS]
+
+        return limits, user_api, prefixes
+
+    def _set_threadpool_limits(self):
+        """Change the maximal number of threads in selected thread pools.
+
+        Return a list with all the supported libraries that have been found
+        matching `self._prefixes` and `self._user_api`.
+        """
+        if self._limits is None:
+            return
+
+        for lib_controller in self._controller.lib_controllers:
+            # self._limits is a dict {key: num_threads} where key is either
+            # a prefix or a user_api. If a library matches both, the limit
+            # corresponding to the prefix is chosen.
+            if lib_controller.prefix in self._limits:
+                num_threads = self._limits[lib_controller.prefix]
+            elif lib_controller.user_api in self._limits:
+                num_threads = self._limits[lib_controller.user_api]
+            else:
+                continue
+
+            if num_threads is not None:
+                lib_controller.set_num_threads(num_threads)
+
+
+class _ThreadpoolLimiterDecorator(_ThreadpoolLimiter, ContextDecorator):
+    """Same as _ThreadpoolLimiter but to be used as a decorator"""
+
+    def __init__(self, controller, *, limits=None, user_api=None):
+        self._limits, self._user_api, self._prefixes = self._check_params(
+            limits, user_api
+        )
+        self._controller = controller
+
+    def __enter__(self):
+        # we need to set the limits here and not in the __init__ because we want the
+        # limits to be set when calling the decorated function, not when creating the
+        # decorator.
+        self._original_info = self._controller.info()
+        self._set_threadpool_limits()
+        return self
+
+
+@_format_docstring(
+    USER_APIS=", ".join(f'"{api}"' for api in _ALL_USER_APIS),
+    BLAS_LIBS=", ".join(_ALL_BLAS_LIBRARIES),
+    OPENMP_LIBS=", ".join(_ALL_OPENMP_LIBRARIES),
+)
+class threadpool_limits(_ThreadpoolLimiter):
+    """Change the maximal number of threads that can be used in thread pools.
+
+    This object can be used either as a callable (the construction of this object
+    limits the number of threads), as a context manager in a `with` block to
+    automatically restore the original state of the controlled libraries when exiting
+    the block, or as a decorator through its `wrap` method.
+
+    Set the maximal number of threads that can be used in thread pools used in
+    the supported libraries to `limit`. This function works for libraries that
+    are already loaded in the interpreter and can be changed dynamically.
+
+    This effect is global and impacts the whole Python process. There is no thread level
+    isolation as these libraries do not offer thread-local APIs to configure the number
+    of threads to use in nested parallel calls.
+
+    Parameters
+    ----------
+    limits : int, dict, 'sequential_blas_under_openmp' or None (default=None)
+        The maximal number of threads that can be used in thread pools
+
+        - If int, sets the maximum number of threads to `limits` for each
+          library selected by `user_api`.
+
+        - If it is a dictionary `{{key: max_threads}}`, this function sets a
+          custom maximum number of threads for each `key` which can be either a
+          `user_api` or a `prefix` for a specific library.
+
+        - If 'sequential_blas_under_openmp', it will chose the appropriate `limits`
+          and `user_api` parameters for the specific use case of sequential BLAS
+          calls within an OpenMP parallel region. The `user_api` parameter is
+          ignored.
+
+        - If None, this function does not do anything.
+
+    user_api : {USER_APIS} or None (default=None)
+        APIs of libraries to limit. Used only if `limits` is an int.
+
+        - If "blas", it will only limit BLAS supported libraries ({BLAS_LIBS}).
+
+        - If "openmp", it will only limit OpenMP supported libraries
+          ({OPENMP_LIBS}). Note that it can affect the number of threads used
+          by the BLAS libraries if they rely on OpenMP.
+
+        - If None, this function will apply to all supported libraries.
+    """
+
+    def __init__(self, limits=None, user_api=None):
+        super().__init__(ThreadpoolController(), limits=limits, user_api=user_api)
+
+    @classmethod
+    def wrap(cls, limits=None, user_api=None):
+        return super().wrap(ThreadpoolController(), limits=limits, user_api=user_api)
+
+
+class ThreadpoolController:
+    """Collection of LibController objects for all loaded supported libraries
+
+    Attributes
+    ----------
+    lib_controllers : list of `LibController` objects
+        The list of library controllers of all loaded supported libraries.
+    """
+
+    # Cache for libc under POSIX and a few system libraries under Windows.
+    # We use a class level cache instead of an instance level cache because
+    # it's very unlikely that a shared library will be unloaded and reloaded
+    # during the lifetime of a program.
+    _system_libraries = dict()
+
+    def __init__(self):
+        self.lib_controllers = []
+        self._load_libraries()
+        self._warn_if_incompatible_openmp()
+
+    @classmethod
+    def _from_controllers(cls, lib_controllers):
+        new_controller = cls.__new__(cls)
+        new_controller.lib_controllers = lib_controllers
+        return new_controller
+
+    def info(self):
+        """Return lib_controllers info as a list of dicts"""
+        return [lib_controller.info() for lib_controller in self.lib_controllers]
+
+    def select(self, **kwargs):
+        """Return a ThreadpoolController containing a subset of its current
+        library controllers
+
+        It will select all libraries matching at least one pair (key, value) from kwargs
+        where key is an entry of the library info dict (like "user_api", "internal_api",
+        "prefix", ...) and value is the value or a list of acceptable values for that
+        entry.
+
+        For instance, `ThreadpoolController().select(internal_api=["blis", "openblas"])`
+        will select all library controllers whose internal_api is either "blis" or
+        "openblas".
+        """
+        for key, vals in kwargs.items():
+            kwargs[key] = [vals] if not isinstance(vals, list) else vals
+
+        lib_controllers = [
+            lib_controller
+            for lib_controller in self.lib_controllers
+            if any(
+                getattr(lib_controller, key, None) in vals
+                for key, vals in kwargs.items()
+            )
+        ]
+
+        return ThreadpoolController._from_controllers(lib_controllers)
+
+    def _get_params_for_sequential_blas_under_openmp(self):
+        """Return appropriate params to use for a sequential BLAS call in an OpenMP loop
+
+        This function takes into account the unexpected behavior of OpenBLAS with the
+        OpenMP threading layer.
+        """
+        if self.select(
+            internal_api="openblas", threading_layer="openmp"
+        ).lib_controllers:
+            return {"limits": None, "user_api": None}
+        return {"limits": 1, "user_api": "blas"}
+
+    @_format_docstring(
+        USER_APIS=", ".join('"{}"'.format(api) for api in _ALL_USER_APIS),
+        BLAS_LIBS=", ".join(_ALL_BLAS_LIBRARIES),
+        OPENMP_LIBS=", ".join(_ALL_OPENMP_LIBRARIES),
+    )
+    def limit(self, *, limits=None, user_api=None):
+        """Change the maximal number of threads that can be used in thread pools.
+
+        This function returns an object that can be used either as a callable (the
+        construction of this object limits the number of threads) or as a context
+        manager, in a `with` block to automatically restore the original state of the
+        controlled libraries when exiting the block.
+
+        Set the maximal number of threads that can be used in thread pools used in
+        the supported libraries to `limits`. This function works for libraries that
+        are already loaded in the interpreter and can be changed dynamically.
+
+        This effect is global and impacts the whole Python process. There is no thread
+        level isolation as these libraries do not offer thread-local APIs to configure
+        the number of threads to use in nested parallel calls.
+
+        Parameters
+        ----------
+        limits : int, dict, 'sequential_blas_under_openmp' or None (default=None)
+            The maximal number of threads that can be used in thread pools
+
+            - If int, sets the maximum number of threads to `limits` for each
+              library selected by `user_api`.
+
+            - If it is a dictionary `{{key: max_threads}}`, this function sets a
+              custom maximum number of threads for each `key` which can be either a
+              `user_api` or a `prefix` for a specific library.
+
+            - If 'sequential_blas_under_openmp', it will chose the appropriate `limits`
+              and `user_api` parameters for the specific use case of sequential BLAS
+              calls within an OpenMP parallel region. The `user_api` parameter is
+              ignored.
+
+            - If None, this function does not do anything.
+
+        user_api : {USER_APIS} or None (default=None)
+            APIs of libraries to limit. Used only if `limits` is an int.
+
+            - If "blas", it will only limit BLAS supported libraries ({BLAS_LIBS}).
+
+            - If "openmp", it will only limit OpenMP supported libraries
+              ({OPENMP_LIBS}). Note that it can affect the number of threads used
+              by the BLAS libraries if they rely on OpenMP.
+
+            - If None, this function will apply to all supported libraries.
+        """
+        return _ThreadpoolLimiter(self, limits=limits, user_api=user_api)
+
+    @_format_docstring(
+        USER_APIS=", ".join('"{}"'.format(api) for api in _ALL_USER_APIS),
+        BLAS_LIBS=", ".join(_ALL_BLAS_LIBRARIES),
+        OPENMP_LIBS=", ".join(_ALL_OPENMP_LIBRARIES),
+    )
+    def wrap(self, *, limits=None, user_api=None):
+        """Change the maximal number of threads that can be used in thread pools.
+
+        This function returns an object that can be used as a decorator.
+
+        Set the maximal number of threads that can be used in thread pools used in
+        the supported libraries to `limits`. This function works for libraries that
+        are already loaded in the interpreter and can be changed dynamically.
+
+        Parameters
+        ----------
+        limits : int, dict or None (default=None)
+            The maximal number of threads that can be used in thread pools
+
+            - If int, sets the maximum number of threads to `limits` for each
+              library selected by `user_api`.
+
+            - If it is a dictionary `{{key: max_threads}}`, this function sets a
+              custom maximum number of threads for each `key` which can be either a
+              `user_api` or a `prefix` for a specific library.
+
+            - If None, this function does not do anything.
+
+        user_api : {USER_APIS} or None (default=None)
+            APIs of libraries to limit. Used only if `limits` is an int.
+
+            - If "blas", it will only limit BLAS supported libraries ({BLAS_LIBS}).
+
+            - If "openmp", it will only limit OpenMP supported libraries
+              ({OPENMP_LIBS}). Note that it can affect the number of threads used
+              by the BLAS libraries if they rely on OpenMP.
+
+            - If None, this function will apply to all supported libraries.
+        """
+        return _ThreadpoolLimiter.wrap(self, limits=limits, user_api=user_api)
+
+    def __len__(self):
+        return len(self.lib_controllers)
+
+    def _load_libraries(self):
+        """Loop through loaded shared libraries and store the supported ones"""
+        if sys.platform == "darwin":
+            self._find_libraries_with_dyld()
+        elif sys.platform == "win32":
+            self._find_libraries_with_enum_process_module_ex()
+        elif "pyodide" in sys.modules:
+            self._find_libraries_pyodide()
+        else:
+            self._find_libraries_with_dl_iterate_phdr()
+
+    def _find_libraries_with_dl_iterate_phdr(self):
+        """Loop through loaded libraries and return binders on supported ones
+
+        This function is expected to work on POSIX system only.
+        This code is adapted from code by Intel developer @anton-malakhov
+        available at https://github.com/IntelPython/smp
+
+        Copyright (c) 2017, Intel Corporation published under the BSD 3-Clause
+        license
+        """
+        libc = self._get_libc()
+        if not hasattr(libc, "dl_iterate_phdr"):  # pragma: no cover
+            warnings.warn(
+                "Could not find dl_iterate_phdr in the C standard library.",
+                RuntimeWarning,
+            )
+            return []
+
+        # Callback function for `dl_iterate_phdr` which is called for every
+        # library loaded in the current process until it returns 1.
+        def match_library_callback(info, size, data):
+            # Get the path of the current library
+            filepath = info.contents.dlpi_name
+            if filepath:
+                filepath = filepath.decode("utf-8")
+
+                # Store the library controller if it is supported and selected
+                self._make_controller_from_path(filepath)
+            return 0
+
+        c_func_signature = ctypes.CFUNCTYPE(
+            ctypes.c_int,  # Return type
+            ctypes.POINTER(_dl_phdr_info),
+            ctypes.c_size_t,
+            ctypes.c_char_p,
+        )
+        c_match_library_callback = c_func_signature(match_library_callback)
+
+        data = ctypes.c_char_p(b"")
+        libc.dl_iterate_phdr(c_match_library_callback, data)
+
+    def _find_libraries_with_dyld(self):
+        """Loop through loaded libraries and return binders on supported ones
+
+        This function is expected to work on OSX system only
+        """
+        libc = self._get_libc()
+        if not hasattr(libc, "_dyld_image_count"):  # pragma: no cover
+            warnings.warn(
+                "Could not find _dyld_image_count in the C standard library.",
+                RuntimeWarning,
+            )
+            return []
+
+        n_dyld = libc._dyld_image_count()
+        libc._dyld_get_image_name.restype = ctypes.c_char_p
+
+        for i in range(n_dyld):
+            filepath = ctypes.string_at(libc._dyld_get_image_name(i))
+            filepath = filepath.decode("utf-8")
+
+            # Store the library controller if it is supported and selected
+            self._make_controller_from_path(filepath)
+
+    def _find_libraries_with_enum_process_module_ex(self):
+        """Loop through loaded libraries and return binders on supported ones
+
+        This function is expected to work on windows system only.
+        This code is adapted from code by Philipp Hagemeister @phihag available
+        at https://stackoverflow.com/questions/17474574
+        """
+        from ctypes.wintypes import DWORD, HMODULE, MAX_PATH
+
+        PROCESS_QUERY_INFORMATION = 0x0400
+        PROCESS_VM_READ = 0x0010
+
+        LIST_LIBRARIES_ALL = 0x03
+
+        ps_api = self._get_windll("Psapi")
+        kernel_32 = self._get_windll("kernel32")
+
+        h_process = kernel_32.OpenProcess(
+            PROCESS_QUERY_INFORMATION | PROCESS_VM_READ, False, os.getpid()
+        )
+        if not h_process:  # pragma: no cover
+            raise OSError(f"Could not open PID {os.getpid()}")
+
+        try:
+            buf_count = 256
+            needed = DWORD()
+            # Grow the buffer until it becomes large enough to hold all the
+            # module headers
+            while True:
+                buf = (HMODULE * buf_count)()
+                buf_size = ctypes.sizeof(buf)
+                if not ps_api.EnumProcessModulesEx(
+                    h_process,
+                    ctypes.byref(buf),
+                    buf_size,
+                    ctypes.byref(needed),
+                    LIST_LIBRARIES_ALL,
+                ):
+                    raise OSError("EnumProcessModulesEx failed")
+                if buf_size >= needed.value:
+                    break
+                buf_count = needed.value // (buf_size // buf_count)
+
+            count = needed.value // (buf_size // buf_count)
+            h_modules = map(HMODULE, buf[:count])
+
+            # Loop through all the module headers and get the library path
+            # Allocate a buffer for the path 10 times the size of MAX_PATH to take
+            # into account long path names.
+            max_path = 10 * MAX_PATH
+            buf = ctypes.create_unicode_buffer(max_path)
+            n_size = DWORD()
+            for h_module in h_modules:
+                # Get the path of the current module
+                if not ps_api.GetModuleFileNameExW(
+                    h_process, h_module, ctypes.byref(buf), ctypes.byref(n_size)
+                ):
+                    raise OSError("GetModuleFileNameEx failed")
+                filepath = buf.value
+
+                if len(filepath) == max_path:  # pragma: no cover
+                    warnings.warn(
+                        "Could not get the full path of a dynamic library (path too "
+                        "long). This library will be ignored and threadpoolctl might "
+                        "not be able to control or display information about all "
+                        f"loaded libraries. Here's the truncated path: {filepath!r}",
+                        RuntimeWarning,
+                    )
+                else:
+                    # Store the library controller if it is supported and selected
+                    self._make_controller_from_path(filepath)
+        finally:
+            kernel_32.CloseHandle(h_process)
+
+    def _find_libraries_pyodide(self):
+        """Pyodide specific implementation for finding loaded libraries.
+
+        Adapted from suggestion in https://github.com/joblib/threadpoolctl/pull/169#issuecomment-1946696449.
+
+        One day, we may have a simpler solution. libc dl_iterate_phdr needs to
+        be implemented in Emscripten and exposed in Pyodide, see
+        https://github.com/emscripten-core/emscripten/issues/21354 for more
+        details.
+        """
+        try:
+            from pyodide_js._module import LDSO
+        except ImportError:
+            warnings.warn(
+                "Unable to import LDSO from pyodide_js._module. This should never "
+                "happen."
+            )
+            return
+
+        for filepath in LDSO.loadedLibsByName.as_object_map():
+            # Some libraries are duplicated by Pyodide and do not exist in the
+            # filesystem, so we first check for the existence of the file. For
+            # more details, see
+            # https://github.com/joblib/threadpoolctl/pull/169#issuecomment-1947946728
+            if os.path.exists(filepath):
+                self._make_controller_from_path(filepath)
+
+    def _make_controller_from_path(self, filepath):
+        """Store a library controller if it is supported and selected"""
+        # Required to resolve symlinks
+        filepath = _realpath(filepath)
+        # `lower` required to take account of OpenMP dll case on Windows
+        # (vcomp, VCOMP, Vcomp, ...)
+        filename = os.path.basename(filepath).lower()
+
+        # Loop through supported libraries to find if this filename corresponds
+        # to a supported one.
+        for controller_class in _ALL_CONTROLLERS:
+            # check if filename matches a supported prefix
+            prefix = self._check_prefix(filename, controller_class.filename_prefixes)
+
+            # filename does not match any of the prefixes of the candidate
+            # library. move to next library.
+            if prefix is None:
+                continue
+
+            # workaround for BLAS libraries packaged by conda-forge on windows, which
+            # are all renamed "libblas.dll". We thus have to check to which BLAS
+            # implementation it actually corresponds looking for implementation
+            # specific symbols.
+            if prefix == "libblas":
+                if filename.endswith(".dll"):
+                    libblas = ctypes.CDLL(filepath, _RTLD_NOLOAD)
+                    if not any(
+                        hasattr(libblas, func)
+                        for func in controller_class.check_symbols
+                    ):
+                        continue
+                else:
+                    # We ignore libblas on other platforms than windows because there
+                    # might be a libblas dso comming with openblas for instance that
+                    # can't be used to instantiate a pertinent LibController (many
+                    # symbols are missing) and would create confusion by making a
+                    # duplicate entry in threadpool_info.
+                    continue
+
+            # filename matches a prefix. Now we check if the library has the symbols we
+            # are looking for. If none of the symbols exists, it's very likely not the
+            # expected library (e.g. a library having a common prefix with one of the
+            # our supported libraries). Otherwise, create and store the library
+            # controller.
+            lib_controller = controller_class(
+                filepath=filepath, prefix=prefix, parent=self
+            )
+
+            if filepath in (lib.filepath for lib in self.lib_controllers):
+                # We already have a controller for this library.
+                continue
+
+            if not hasattr(controller_class, "check_symbols") or any(
+                hasattr(lib_controller.dynlib, func)
+                for func in controller_class.check_symbols
+            ):
+                self.lib_controllers.append(lib_controller)
+
+    def _check_prefix(self, library_basename, filename_prefixes):
+        """Return the prefix library_basename starts with
+
+        Return None if none matches.
+        """
+        for prefix in filename_prefixes:
+            if library_basename.startswith(prefix):
+                return prefix
+        return None
+
+    def _warn_if_incompatible_openmp(self):
+        """Raise a warning if llvm-OpenMP and intel-OpenMP are both loaded"""
+        prefixes = [lib_controller.prefix for lib_controller in self.lib_controllers]
+        msg = textwrap.dedent(
+            """
+            Found Intel OpenMP ('libiomp') and LLVM OpenMP ('libomp') loaded at
+            the same time. Both libraries are known to be incompatible and this
+            can cause random crashes or deadlocks on Linux when loaded in the
+            same Python program.
+            Using threadpoolctl may cause crashes or deadlocks. For more
+            information and possible workarounds, please see
+                https://github.com/joblib/threadpoolctl/blob/master/multiple_openmp.md
+            """
+        )
+        if "libomp" in prefixes and "libiomp" in prefixes:
+            warnings.warn(msg, RuntimeWarning)
+
+    @classmethod
+    def _get_libc(cls):
+        """Load the lib-C for unix systems."""
+        libc = cls._system_libraries.get("libc")
+        if libc is None:
+            # Remark: If libc is statically linked or if Python is linked against an
+            # alternative implementation of libc like musl, find_library will return
+            # None and CDLL will load the main program itself which should contain the
+            # libc symbols. We still name it libc for convenience.
+            # If the main program does not contain the libc symbols, it's ok because
+            # we check their presence later anyway.
+            libc = ctypes.CDLL(find_library("c"), mode=_RTLD_NOLOAD)
+            cls._system_libraries["libc"] = libc
+        return libc
+
+    @classmethod
+    def _get_windll(cls, dll_name):
+        """Load a windows DLL"""
+        dll = cls._system_libraries.get(dll_name)
+        if dll is None:
+            dll = ctypes.WinDLL(f"{dll_name}.dll")
+            cls._system_libraries[dll_name] = dll
+        return dll
+
+
+def _main():
+    """Commandline interface to display thread-pool information and exit."""
+    import argparse
+    import importlib
+    import json
+    import sys
+
+    parser = argparse.ArgumentParser(
+        usage="python -m threadpoolctl -i numpy scipy.linalg xgboost",
+        description="Display thread-pool information and exit.",
+    )
+    parser.add_argument(
+        "-i",
+        "--import",
+        dest="modules",
+        nargs="*",
+        default=(),
+        help="Python modules to import before introspecting thread-pools.",
+    )
+    parser.add_argument(
+        "-c",
+        "--command",
+        help="a Python statement to execute before introspecting thread-pools.",
+    )
+
+    options = parser.parse_args(sys.argv[1:])
+    for module in options.modules:
+        try:
+            importlib.import_module(module, package=None)
+        except ImportError:
+            print("WARNING: could not import", module, file=sys.stderr)
+
+    if options.command:
+        exec(options.command)
+
+    print(json.dumps(threadpool_info(), indent=2))
+
+
+if __name__ == "__main__":
+    _main()