Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/astor/VERSION

@@ -0,0 +1 @@
+0.8.1

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

@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""
+Part of the astor library for Python AST manipulation.
+
+License: 3-clause BSD
+
+Copyright 2012 (c) Patrick Maupin
+Copyright 2013 (c) Berker Peksag
+
+"""
+
+import os
+import warnings
+
+from .code_gen import SourceGenerator, to_source  # NOQA
+from .node_util import iter_node, strip_tree, dump_tree  # NOQA
+from .node_util import ExplicitNodeVisitor  # NOQA
+from .file_util import CodeToAst, code_to_ast  # NOQA
+from .op_util import get_op_symbol, get_op_precedence  # NOQA
+from .op_util import symbol_data  # NOQA
+from .tree_walk import TreeWalk  # NOQA
+
+ROOT = os.path.dirname(__file__)
+with open(os.path.join(ROOT, 'VERSION')) as version_file:
+    __version__ = version_file.read().strip()
+
+parse_file = code_to_ast.parse_file
+
+# DEPRECATED!!!
+# These aliases support old programs.  Please do not use in future.
+
+deprecated = """
+get_boolop = get_binop = get_cmpop = get_unaryop = get_op_symbol
+get_anyop = get_op_symbol
+parsefile = code_to_ast.parse_file
+codetoast = code_to_ast
+dump = dump_tree
+all_symbols = symbol_data
+treewalk = tree_walk
+codegen = code_gen
+"""
+
+exec(deprecated)
+
+
+def deprecate():
+    def wrap(deprecated_name, target_name):
+        if '.' in target_name:
+            target_mod, target_fname = target_name.split('.')
+            target_func = getattr(globals()[target_mod], target_fname)
+        else:
+            target_func = globals()[target_name]
+        msg = "astor.%s is deprecated.  Please use astor.%s." % (
+            deprecated_name, target_name)
+        if callable(target_func):
+            def newfunc(*args, **kwarg):
+                warnings.warn(msg, DeprecationWarning, stacklevel=2)
+                return target_func(*args, **kwarg)
+        else:
+            class ModProxy:
+                def __getattr__(self, name):
+                    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+                    return getattr(target_func, name)
+            newfunc = ModProxy()
+
+        globals()[deprecated_name] = newfunc
+
+    for line in deprecated.splitlines():  # NOQA
+        line = line.split('#')[0].replace('=', '').split()
+        if line:
+            target_name = line.pop()
+            for deprecated_name in line:
+                wrap(deprecated_name, target_name)
+
+
+deprecate()
+
+del deprecate, deprecated

.venv/lib/python3.11/site-packages/astor/code_gen.py

@@ -0,0 +1,901 @@
+# -*- coding: utf-8 -*-
+"""
+Part of the astor library for Python AST manipulation.
+
+License: 3-clause BSD
+
+Copyright (c) 2008      Armin Ronacher
+Copyright (c) 2012-2017 Patrick Maupin
+Copyright (c) 2013-2017 Berker Peksag
+
+This module converts an AST into Python source code.
+
+Before being version-controlled as part of astor,
+this code came from here (in 2012):
+
+    https://gist.github.com/1250562
+
+"""
+
+import ast
+import inspect
+import math
+import sys
+
+from .op_util import get_op_symbol, get_op_precedence, Precedence
+from .node_util import ExplicitNodeVisitor
+from .string_repr import pretty_string
+from .source_repr import pretty_source
+
+
+def to_source(node, indent_with=' ' * 4, add_line_information=False,
+              pretty_string=pretty_string, pretty_source=pretty_source,
+              source_generator_class=None):
+    """This function can convert a node tree back into python sourcecode.
+    This is useful for debugging purposes, especially if you're dealing with
+    custom asts not generated by python itself.
+
+    It could be that the sourcecode is evaluable when the AST itself is not
+    compilable / evaluable.  The reason for this is that the AST contains some
+    more data than regular sourcecode does, which is dropped during
+    conversion.
+
+    Each level of indentation is replaced with `indent_with`.  Per default this
+    parameter is equal to four spaces as suggested by PEP 8, but it might be
+    adjusted to match the application's styleguide.
+
+    If `add_line_information` is set to `True` comments for the line numbers
+    of the nodes are added to the output.  This can be used to spot wrong line
+    number information of statement nodes.
+
+    `source_generator_class` defaults to `SourceGenerator`, and specifies the
+    class that will be instantiated and used to generate the source code.
+
+    """
+    if source_generator_class is None:
+        source_generator_class = SourceGenerator
+    elif not inspect.isclass(source_generator_class):
+        raise TypeError('source_generator_class should be a class')
+    elif not issubclass(source_generator_class, SourceGenerator):
+        raise TypeError('source_generator_class should be a subclass of SourceGenerator')
+    generator = source_generator_class(
+        indent_with, add_line_information, pretty_string)
+    generator.visit(node)
+    generator.result.append('\n')
+    if set(generator.result[0]) == set('\n'):
+        generator.result[0] = ''
+    return pretty_source(generator.result)
+
+
+def precedence_setter(AST=ast.AST, get_op_precedence=get_op_precedence,
+                      isinstance=isinstance, list=list):
+    """ This only uses a closure for performance reasons,
+        to reduce the number of attribute lookups.  (set_precedence
+        is called a lot of times.)
+    """
+
+    def set_precedence(value, *nodes):
+        """Set the precedence (of the parent) into the children.
+        """
+        if isinstance(value, AST):
+            value = get_op_precedence(value)
+        for node in nodes:
+            if isinstance(node, AST):
+                node._pp = value
+            elif isinstance(node, list):
+                set_precedence(value, *node)
+            else:
+                assert node is None, node
+
+    return set_precedence
+
+
+set_precedence = precedence_setter()
+
+
+class Delimit(object):
+    """A context manager that can add enclosing
+       delimiters around the output of a
+       SourceGenerator method.  By default, the
+       parentheses are added, but the enclosed code
+       may set discard=True to get rid of them.
+    """
+
+    discard = False
+
+    def __init__(self, tree, *args):
+        """ use write instead of using result directly
+            for initial data, because it may flush
+            preceding data into result.
+        """
+        delimiters = '()'
+        node = None
+        op = None
+        for arg in args:
+            if isinstance(arg, ast.AST):
+                if node is None:
+                    node = arg
+                else:
+                    op = arg
+            else:
+                delimiters = arg
+        tree.write(delimiters[0])
+        result = self.result = tree.result
+        self.index = len(result)
+        self.closing = delimiters[1]
+        if node is not None:
+            self.p = p = get_op_precedence(op or node)
+            self.pp = pp = tree.get__pp(node)
+            self.discard = p >= pp
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        result = self.result
+        start = self.index - 1
+        if self.discard:
+            result[start] = ''
+        else:
+            result.append(self.closing)
+
+
+class SourceGenerator(ExplicitNodeVisitor):
+    """This visitor is able to transform a well formed syntax tree into Python
+    sourcecode.
+
+    For more details have a look at the docstring of the `node_to_source`
+    function.
+
+    """
+
+    using_unicode_literals = False
+
+    def __init__(self, indent_with, add_line_information=False,
+                 pretty_string=pretty_string,
+                 # constants
+                 len=len, isinstance=isinstance, callable=callable):
+        self.result = []
+        self.indent_with = indent_with
+        self.add_line_information = add_line_information
+        self.indentation = 0  # Current indentation level
+        self.new_lines = 0  # Number of lines to insert before next code
+        self.colinfo = 0, 0  # index in result of string containing linefeed, and
+                             # position of last linefeed in that string
+        self.pretty_string = pretty_string
+        AST = ast.AST
+
+        visit = self.visit
+        result = self.result
+        append = result.append
+
+        def write(*params):
+            """ self.write is a closure for performance (to reduce the number
+                of attribute lookups).
+            """
+            for item in params:
+                if isinstance(item, AST):
+                    visit(item)
+                elif callable(item):
+                    item()
+                else:
+                    if self.new_lines:
+                        append('\n' * self.new_lines)
+                        self.colinfo = len(result), 0
+                        append(self.indent_with * self.indentation)
+                        self.new_lines = 0
+                    if item:
+                        append(item)
+
+        self.write = write
+
+    def __getattr__(self, name, defaults=dict(keywords=(),
+                    _pp=Precedence.highest).get):
+        """ Get an attribute of the node.
+            like dict.get (returns None if doesn't exist)
+        """
+        if not name.startswith('get_'):
+            raise AttributeError
+        geta = getattr
+        shortname = name[4:]
+        default = defaults(shortname)
+
+        def getter(node):
+            return geta(node, shortname, default)
+
+        setattr(self, name, getter)
+        return getter
+
+    def delimit(self, *args):
+        return Delimit(self, *args)
+
+    def conditional_write(self, *stuff):
+        if stuff[-1] is not None:
+            self.write(*stuff)
+            # Inform the caller that we wrote
+            return True
+
+    def newline(self, node=None, extra=0):
+        self.new_lines = max(self.new_lines, 1 + extra)
+        if node is not None and self.add_line_information:
+            self.write('# line: %s' % node.lineno)
+            self.new_lines = 1
+
+    def body(self, statements):
+        self.indentation += 1
+        self.write(*statements)
+        self.indentation -= 1
+
+    def else_body(self, elsewhat):
+        if elsewhat:
+            self.write(self.newline, 'else:')
+            self.body(elsewhat)
+
+    def body_or_else(self, node):
+        self.body(node.body)
+        self.else_body(node.orelse)
+
+    def visit_arguments(self, node):
+        want_comma = []
+
+        def write_comma():
+            if want_comma:
+                self.write(', ')
+            else:
+                want_comma.append(True)
+
+        def loop_args(args, defaults):
+            set_precedence(Precedence.Comma, defaults)
+            padding = [None] * (len(args) - len(defaults))
+            for arg, default in zip(args, padding + defaults):
+                self.write(write_comma, arg)
+                self.conditional_write('=', default)
+
+        posonlyargs = getattr(node, 'posonlyargs', [])
+        offset = 0
+        if posonlyargs:
+            offset += len(node.defaults) - len(node.args)
+            loop_args(posonlyargs, node.defaults[:offset])
+            self.write(write_comma, '/')
+
+        loop_args(node.args, node.defaults[offset:])
+        self.conditional_write(write_comma, '*', node.vararg)
+
+        kwonlyargs = self.get_kwonlyargs(node)
+        if kwonlyargs:
+            if node.vararg is None:
+                self.write(write_comma, '*')
+            loop_args(kwonlyargs, node.kw_defaults)
+        self.conditional_write(write_comma, '**', node.kwarg)
+
+    def statement(self, node, *params, **kw):
+        self.newline(node)
+        self.write(*params)
+
+    def decorators(self, node, extra):
+        self.newline(extra=extra)
+        for decorator in node.decorator_list:
+            self.statement(decorator, '@', decorator)
+
+    def comma_list(self, items, trailing=False):
+        set_precedence(Precedence.Comma, *items)
+        for idx, item in enumerate(items):
+            self.write(', ' if idx else '', item)
+        self.write(',' if trailing else '')
+
+    # Statements
+
+    def visit_Assign(self, node):
+        set_precedence(node, node.value, *node.targets)
+        self.newline(node)
+        for target in node.targets:
+            self.write(target, ' = ')
+        self.visit(node.value)
+
+    def visit_AugAssign(self, node):
+        set_precedence(node, node.value, node.target)
+        self.statement(node, node.target, get_op_symbol(node.op, ' %s= '),
+                       node.value)
+
+    def visit_AnnAssign(self, node):
+        set_precedence(node, node.target, node.annotation)
+        set_precedence(Precedence.Comma, node.value)
+        need_parens = isinstance(node.target, ast.Name) and not node.simple
+        begin = '(' if need_parens else ''
+        end = ')' if need_parens else ''
+        self.statement(node, begin, node.target, end, ': ', node.annotation)
+        self.conditional_write(' = ', node.value)
+
+    def visit_ImportFrom(self, node):
+        self.statement(node, 'from ', node.level * '.',
+                       node.module or '', ' import ')
+        self.comma_list(node.names)
+        # Goofy stuff for Python 2.7 _pyio module
+        if node.module == '__future__' and 'unicode_literals' in (
+                x.name for x in node.names):
+            self.using_unicode_literals = True
+
+    def visit_Import(self, node):
+        self.statement(node, 'import ')
+        self.comma_list(node.names)
+
+    def visit_Expr(self, node):
+        set_precedence(node, node.value)
+        self.statement(node)
+        self.generic_visit(node)
+
+    def visit_FunctionDef(self, node, is_async=False):
+        prefix = 'async ' if is_async else ''
+        self.decorators(node, 1 if self.indentation else 2)
+        self.statement(node, '%sdef %s' % (prefix, node.name), '(')
+        self.visit_arguments(node.args)
+        self.write(')')
+        self.conditional_write(' ->', self.get_returns(node))
+        self.write(':')
+        self.body(node.body)
+        if not self.indentation:
+            self.newline(extra=2)
+
+    # introduced in Python 3.5
+    def visit_AsyncFunctionDef(self, node):
+        self.visit_FunctionDef(node, is_async=True)
+
+    def visit_ClassDef(self, node):
+        have_args = []
+
+        def paren_or_comma():
+            if have_args:
+                self.write(', ')
+            else:
+                have_args.append(True)
+                self.write('(')
+
+        self.decorators(node, 2)
+        self.statement(node, 'class %s' % node.name)
+        for base in node.bases:
+            self.write(paren_or_comma, base)
+        # keywords not available in early version
+        for keyword in self.get_keywords(node):
+            self.write(paren_or_comma, keyword.arg or '',
+                       '=' if keyword.arg else '**', keyword.value)
+        self.conditional_write(paren_or_comma, '*', self.get_starargs(node))
+        self.conditional_write(paren_or_comma, '**', self.get_kwargs(node))
+        self.write(have_args and '):' or ':')
+        self.body(node.body)
+        if not self.indentation:
+            self.newline(extra=2)
+
+    def visit_If(self, node):
+        set_precedence(node, node.test)
+        self.statement(node, 'if ', node.test, ':')
+        self.body(node.body)
+        while True:
+            else_ = node.orelse
+            if len(else_) == 1 and isinstance(else_[0], ast.If):
+                node = else_[0]
+                set_precedence(node, node.test)
+                self.write(self.newline, 'elif ', node.test, ':')
+                self.body(node.body)
+            else:
+                self.else_body(else_)
+                break
+
+    def visit_For(self, node, is_async=False):
+        set_precedence(node, node.target)
+        prefix = 'async ' if is_async else ''
+        self.statement(node, '%sfor ' % prefix,
+                       node.target, ' in ', node.iter, ':')
+        self.body_or_else(node)
+
+    # introduced in Python 3.5
+    def visit_AsyncFor(self, node):
+        self.visit_For(node, is_async=True)
+
+    def visit_While(self, node):
+        set_precedence(node, node.test)
+        self.statement(node, 'while ', node.test, ':')
+        self.body_or_else(node)
+
+    def visit_With(self, node, is_async=False):
+        prefix = 'async ' if is_async else ''
+        self.statement(node, '%swith ' % prefix)
+        if hasattr(node, "context_expr"):  # Python < 3.3
+            self.visit_withitem(node)
+        else:                              # Python >= 3.3
+            self.comma_list(node.items)
+        self.write(':')
+        self.body(node.body)
+
+    # new for Python 3.5
+    def visit_AsyncWith(self, node):
+        self.visit_With(node, is_async=True)
+
+    # new for Python 3.3
+    def visit_withitem(self, node):
+        self.write(node.context_expr)
+        self.conditional_write(' as ', node.optional_vars)
+
+    # deprecated in Python 3.8
+    def visit_NameConstant(self, node):
+        self.write(repr(node.value))
+
+    def visit_Pass(self, node):
+        self.statement(node, 'pass')
+
+    def visit_Print(self, node):
+        # XXX: python 2.6 only
+        self.statement(node, 'print ')
+        values = node.values
+        if node.dest is not None:
+            self.write(' >> ')
+            values = [node.dest] + node.values
+        self.comma_list(values, not node.nl)
+
+    def visit_Delete(self, node):
+        self.statement(node, 'del ')
+        self.comma_list(node.targets)
+
+    def visit_TryExcept(self, node):
+        self.statement(node, 'try:')
+        self.body(node.body)
+        self.write(*node.handlers)
+        self.else_body(node.orelse)
+
+    # new for Python 3.3
+    def visit_Try(self, node):
+        self.statement(node, 'try:')
+        self.body(node.body)
+        self.write(*node.handlers)
+        self.else_body(node.orelse)
+        if node.finalbody:
+            self.statement(node, 'finally:')
+            self.body(node.finalbody)
+
+    def visit_ExceptHandler(self, node):
+        self.statement(node, 'except')
+        if self.conditional_write(' ', node.type):
+            self.conditional_write(' as ', node.name)
+        self.write(':')
+        self.body(node.body)
+
+    def visit_TryFinally(self, node):
+        self.statement(node, 'try:')
+        self.body(node.body)
+        self.statement(node, 'finally:')
+        self.body(node.finalbody)
+
+    def visit_Exec(self, node):
+        dicts = node.globals, node.locals
+        dicts = dicts[::-1] if dicts[0] is None else dicts
+        self.statement(node, 'exec ', node.body)
+        self.conditional_write(' in ', dicts[0])
+        self.conditional_write(', ', dicts[1])
+
+    def visit_Assert(self, node):
+        set_precedence(node, node.test, node.msg)
+        self.statement(node, 'assert ', node.test)
+        self.conditional_write(', ', node.msg)
+
+    def visit_Global(self, node):
+        self.statement(node, 'global ', ', '.join(node.names))
+
+    def visit_Nonlocal(self, node):
+        self.statement(node, 'nonlocal ', ', '.join(node.names))
+
+    def visit_Return(self, node):
+        set_precedence(node, node.value)
+        self.statement(node, 'return')
+        self.conditional_write(' ', node.value)
+
+    def visit_Break(self, node):
+        self.statement(node, 'break')
+
+    def visit_Continue(self, node):
+        self.statement(node, 'continue')
+
+    def visit_Raise(self, node):
+        # XXX: Python 2.6 / 3.0 compatibility
+        self.statement(node, 'raise')
+        if self.conditional_write(' ', self.get_exc(node)):
+            self.conditional_write(' from ', node.cause)
+        elif self.conditional_write(' ', self.get_type(node)):
+            set_precedence(node, node.inst)
+            self.conditional_write(', ', node.inst)
+            self.conditional_write(', ', node.tback)
+
+    # Expressions
+
+    def visit_Attribute(self, node):
+        self.write(node.value, '.', node.attr)
+
+    def visit_Call(self, node, len=len):
+        write = self.write
+        want_comma = []
+
+        def write_comma():
+            if want_comma:
+                write(', ')
+            else:
+                want_comma.append(True)
+
+        args = node.args
+        keywords = node.keywords
+        starargs = self.get_starargs(node)
+        kwargs = self.get_kwargs(node)
+        numargs = len(args) + len(keywords)
+        numargs += starargs is not None
+        numargs += kwargs is not None
+        p = Precedence.Comma if numargs > 1 else Precedence.call_one_arg
+        set_precedence(p, *args)
+        self.visit(node.func)
+        write('(')
+        for arg in args:
+            write(write_comma, arg)
+
+        set_precedence(Precedence.Comma, *(x.value for x in keywords))
+        for keyword in keywords:
+            # a keyword.arg of None indicates dictionary unpacking
+            # (Python >= 3.5)
+            arg = keyword.arg or ''
+            write(write_comma, arg, '=' if arg else '**', keyword.value)
+        # 3.5 no longer has these
+        self.conditional_write(write_comma, '*', starargs)
+        self.conditional_write(write_comma, '**', kwargs)
+        write(')')
+
+    def visit_Name(self, node):
+        self.write(node.id)
+
+    # ast.Constant is new in Python 3.6 and it replaces ast.Bytes,
+    # ast.Ellipsis, ast.NameConstant, ast.Num, ast.Str in Python 3.8
+    def visit_Constant(self, node):
+        value = node.value
+
+        if isinstance(value, (int, float, complex)):
+            with self.delimit(node):
+                self._handle_numeric_constant(value)
+        elif isinstance(value, str):
+            self._handle_string_constant(node, node.value)
+        elif value is Ellipsis:
+            self.write('...')
+        else:
+            self.write(repr(value))
+
+    def visit_JoinedStr(self, node):
+        self._handle_string_constant(node, None, is_joined=True)
+
+    def _handle_string_constant(self, node, value, is_joined=False):
+        # embedded is used to control when we might want
+        # to use a triple-quoted string.  We determine
+        # if we are in an assignment and/or in an expression
+        precedence = self.get__pp(node)
+        embedded = ((precedence > Precedence.Expr) +
+                    (precedence >= Precedence.Assign))
+
+        # Flush any pending newlines, because we're about
+        # to severely abuse the result list.
+        self.write('')
+        result = self.result
+
+        # Calculate the string representing the line
+        # we are working on, up to but not including
+        # the string we are adding.
+
+        res_index, str_index = self.colinfo
+        current_line = self.result[res_index:]
+        if str_index:
+            current_line[0] = current_line[0][str_index:]
+        current_line = ''.join(current_line)
+
+        has_ast_constant = sys.version_info >= (3, 6)
+
+        if is_joined:
+            # Handle new f-strings.  This is a bit complicated, because
+            # the tree can contain subnodes that recurse back to JoinedStr
+            # subnodes...
+
+            def recurse(node):
+                for value in node.values:
+                    if isinstance(value, ast.Str):
+                        # Double up braces to escape them.
+                        self.write(value.s.replace('{', '{{').replace('}', '}}'))
+                    elif isinstance(value, ast.FormattedValue):
+                        with self.delimit('{}'):
+                            # expr_text used for f-string debugging syntax.
+                            if getattr(value, 'expr_text', None):
+                                self.write(value.expr_text)
+                            else:
+                                set_precedence(value, value.value)
+                                self.visit(value.value)
+                            if value.conversion != -1:
+                                self.write('!%s' % chr(value.conversion))
+                            if value.format_spec is not None:
+                                self.write(':')
+                                recurse(value.format_spec)
+                    elif has_ast_constant and isinstance(value, ast.Constant):
+                        self.write(value.value)
+                    else:
+                        kind = type(value).__name__
+                        assert False, 'Invalid node %s inside JoinedStr' % kind
+
+            index = len(result)
+            recurse(node)
+
+            # Flush trailing newlines (so that they are part of mystr)
+            self.write('')
+            mystr = ''.join(result[index:])
+            del result[index:]
+            self.colinfo = res_index, str_index  # Put it back like we found it
+            uni_lit = False  # No formatted byte strings
+
+        else:
+            assert value is not None, "Node value cannot be None"
+            mystr = value
+            uni_lit = self.using_unicode_literals
+
+        mystr = self.pretty_string(mystr, embedded, current_line, uni_lit)
+
+        if is_joined:
+            mystr = 'f' + mystr
+        elif getattr(node, 'kind', False):
+            # Constant.kind is a Python 3.8 addition.
+            mystr = node.kind + mystr
+
+        self.write(mystr)
+
+        lf = mystr.rfind('\n') + 1
+        if lf:
+            self.colinfo = len(result) - 1, lf
+
+    # deprecated in Python 3.8
+    def visit_Str(self, node):
+        self._handle_string_constant(node, node.s)
+
+    # deprecated in Python 3.8
+    def visit_Bytes(self, node):
+        self.write(repr(node.s))
+
+    def _handle_numeric_constant(self, value):
+        x = value
+
+        def part(p, imaginary):
+            # Represent infinity as 1e1000 and NaN as 1e1000-1e1000.
+            s = 'j' if imaginary else ''
+            try:
+                if math.isinf(p):
+                    if p < 0:
+                        return '-1e1000' + s
+                    return '1e1000' + s
+                if math.isnan(p):
+                    return '(1e1000%s-1e1000%s)' % (s, s)
+            except OverflowError:
+                # math.isinf will raise this when given an integer
+                # that's too large to convert to a float.
+                pass
+            return repr(p) + s
+
+        real = part(x.real if isinstance(x, complex) else x, imaginary=False)
+        if isinstance(x, complex):
+            imag = part(x.imag, imaginary=True)
+            if x.real == 0:
+                s = imag
+            elif x.imag == 0:
+                s = '(%s+0j)' % real
+            else:
+                # x has nonzero real and imaginary parts.
+                s = '(%s%s%s)' % (real, ['+', ''][imag.startswith('-')], imag)
+        else:
+            s = real
+        self.write(s)
+
+    def visit_Num(self, node,
+                  # constants
+                  new=sys.version_info >= (3, 0)):
+        with self.delimit(node) as delimiters:
+            self._handle_numeric_constant(node.n)
+
+            # We can leave the delimiters handling in visit_Num
+            # since this is meant to handle a Python 2.x specific
+            # issue and ast.Constant exists only in 3.6+
+
+            # The Python 2.x compiler merges a unary minus
+            # with a number.  This is a premature optimization
+            # that we deal with here...
+            if not new and delimiters.discard:
+                if not isinstance(node.n, complex) and node.n < 0:
+                    pow_lhs = Precedence.Pow + 1
+                    delimiters.discard = delimiters.pp != pow_lhs
+                else:
+                    op = self.get__p_op(node)
+                    delimiters.discard = not isinstance(op, ast.USub)
+
+    def visit_Tuple(self, node):
+        with self.delimit(node) as delimiters:
+            # Two things are special about tuples:
+            #   1) We cannot discard the enclosing parentheses if empty
+            #   2) We need the trailing comma if only one item
+            elts = node.elts
+            delimiters.discard = delimiters.discard and elts
+            self.comma_list(elts, len(elts) == 1)
+
+    def visit_List(self, node):
+        with self.delimit('[]'):
+            self.comma_list(node.elts)
+
+    def visit_Set(self, node):
+        if node.elts:
+            with self.delimit('{}'):
+                self.comma_list(node.elts)
+        else:
+            # If we tried to use "{}" to represent an empty set, it would be
+            # interpreted as an empty dictionary. We can't use "set()" either
+            # because the name "set" might be rebound.
+            self.write('{1}.__class__()')
+
+    def visit_Dict(self, node):
+        set_precedence(Precedence.Comma, *node.values)
+        with self.delimit('{}'):
+            for idx, (key, value) in enumerate(zip(node.keys, node.values)):
+                self.write(', ' if idx else '',
+                           key if key else '',
+                           ': ' if key else '**', value)
+
+    def visit_BinOp(self, node):
+        op, left, right = node.op, node.left, node.right
+        with self.delimit(node, op) as delimiters:
+            ispow = isinstance(op, ast.Pow)
+            p = delimiters.p
+            set_precedence((Precedence.Pow + 1) if ispow else p, left)
+            set_precedence(Precedence.PowRHS if ispow else (p + 1), right)
+            self.write(left, get_op_symbol(op, ' %s '), right)
+
+    def visit_BoolOp(self, node):
+        with self.delimit(node, node.op) as delimiters:
+            op = get_op_symbol(node.op, ' %s ')
+            set_precedence(delimiters.p + 1, *node.values)
+            for idx, value in enumerate(node.values):
+                self.write(idx and op or '', value)
+
+    def visit_Compare(self, node):
+        with self.delimit(node, node.ops[0]) as delimiters:
+            set_precedence(delimiters.p + 1, node.left, *node.comparators)
+            self.visit(node.left)
+            for op, right in zip(node.ops, node.comparators):
+                self.write(get_op_symbol(op, ' %s '), right)
+
+    # assignment expressions; new for Python 3.8
+    def visit_NamedExpr(self, node):
+        with self.delimit(node) as delimiters:
+            p = delimiters.p
+            set_precedence(p, node.target)
+            set_precedence(p + 1, node.value)
+            # Python is picky about delimiters for assignment
+            # expressions: it requires at least one pair in any
+            # statement that uses an assignment expression, even
+            # when not necessary according to the precedence
+            # rules. We address this with the kludge of forcing a
+            # pair of parentheses around every assignment
+            # expression.
+            delimiters.discard = False
+            self.write(node.target, ' := ', node.value)
+
+    def visit_UnaryOp(self, node):
+        with self.delimit(node, node.op) as delimiters:
+            set_precedence(delimiters.p, node.operand)
+            # In Python 2.x, a unary negative of a literal
+            # number is merged into the number itself.  This
+            # bit of ugliness means it is useful to know
+            # what the parent operation was...
+            node.operand._p_op = node.op
+            sym = get_op_symbol(node.op)
+            self.write(sym, ' ' if sym.isalpha() else '', node.operand)
+
+    def visit_Subscript(self, node):
+        set_precedence(node, node.slice)
+        self.write(node.value, '[', node.slice, ']')
+
+    def visit_Slice(self, node):
+        set_precedence(node, node.lower, node.upper, node.step)
+        self.conditional_write(node.lower)
+        self.write(':')
+        self.conditional_write(node.upper)
+        if node.step is not None:
+            self.write(':')
+            if not (isinstance(node.step, ast.Name) and
+                    node.step.id == 'None'):
+                self.visit(node.step)
+
+    def visit_Index(self, node):
+        with self.delimit(node) as delimiters:
+            set_precedence(delimiters.p, node.value)
+            self.visit(node.value)
+
+    def visit_ExtSlice(self, node):
+        dims = node.dims
+        set_precedence(node, *dims)
+        self.comma_list(dims, len(dims) == 1)
+
+    def visit_Yield(self, node):
+        with self.delimit(node):
+            set_precedence(get_op_precedence(node) + 1, node.value)
+            self.write('yield')
+            self.conditional_write(' ', node.value)
+
+    # new for Python 3.3
+    def visit_YieldFrom(self, node):
+        with self.delimit(node):
+            self.write('yield from ', node.value)
+
+    # new for Python 3.5
+    def visit_Await(self, node):
+        with self.delimit(node):
+            self.write('await ', node.value)
+
+    def visit_Lambda(self, node):
+        with self.delimit(node) as delimiters:
+            set_precedence(delimiters.p, node.body)
+            self.write('lambda ')
+            self.visit_arguments(node.args)
+            self.write(': ', node.body)
+
+    def visit_Ellipsis(self, node):
+        self.write('...')
+
+    def visit_ListComp(self, node):
+        with self.delimit('[]'):
+            self.write(node.elt, *node.generators)
+
+    def visit_GeneratorExp(self, node):
+        with self.delimit(node) as delimiters:
+            if delimiters.pp == Precedence.call_one_arg:
+                delimiters.discard = True
+            set_precedence(Precedence.Comma, node.elt)
+            self.write(node.elt, *node.generators)
+
+    def visit_SetComp(self, node):
+        with self.delimit('{}'):
+            self.write(node.elt, *node.generators)
+
+    def visit_DictComp(self, node):
+        with self.delimit('{}'):
+            self.write(node.key, ': ', node.value, *node.generators)
+
+    def visit_IfExp(self, node):
+        with self.delimit(node) as delimiters:
+            set_precedence(delimiters.p + 1, node.body, node.test)
+            set_precedence(delimiters.p, node.orelse)
+            self.write(node.body, ' if ', node.test, ' else ', node.orelse)
+
+    def visit_Starred(self, node):
+        self.write('*', node.value)
+
+    def visit_Repr(self, node):
+        # XXX: python 2.6 only
+        with self.delimit('``'):
+            self.visit(node.value)
+
+    def visit_Module(self, node):
+        self.write(*node.body)
+
+    visit_Interactive = visit_Module
+
+    def visit_Expression(self, node):
+        self.visit(node.body)
+
+    # Helper Nodes
+
+    def visit_arg(self, node):
+        self.write(node.arg)
+        self.conditional_write(': ', node.annotation)
+
+    def visit_alias(self, node):
+        self.write(node.name)
+        self.conditional_write(' as ', node.asname)
+
+    def visit_comprehension(self, node):
+        set_precedence(node, node.iter, *node.ifs)
+        set_precedence(Precedence.comprehension_target, node.target)
+        stmt = ' async for ' if self.get_is_async(node) else ' for '
+        self.write(stmt, node.target, ' in ', node.iter)
+        for if_ in node.ifs:
+            self.write(' if ', if_)

.venv/lib/python3.11/site-packages/astor/codegen.py

@@ -0,0 +1,11 @@
+import warnings
+
+from .code_gen import *  # NOQA
+
+
+warnings.warn(
+    'astor.codegen module is deprecated. Please import '
+    'astor.code_gen module instead.',
+    DeprecationWarning,
+    stacklevel=2
+)

.venv/lib/python3.11/site-packages/astor/file_util.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+"""
+Part of the astor library for Python AST manipulation.
+
+License: 3-clause BSD
+
+Copyright (c) 2012-2015 Patrick Maupin
+Copyright (c) 2013-2015 Berker Peksag
+
+Functions that interact with the filesystem go here.
+
+"""
+
+import ast
+import sys
+import os
+
+try:
+    from tokenize import open as fopen
+except ImportError:
+    fopen = open
+
+
+class CodeToAst(object):
+    """Given a module, or a function that was compiled as part
+    of a module, re-compile the module into an AST and extract
+    the sub-AST for the function.  Allow caching to reduce
+    number of compiles.
+
+    Also contains static helper utility functions to
+    look for python files, to parse python files, and to extract
+    the file/line information from a code object.
+    """
+
+    @staticmethod
+    def find_py_files(srctree, ignore=None):
+        """Return all the python files in a source tree
+
+        Ignores any path that contains the ignore string
+
+        This is not used by other class methods, but is
+        designed to be used in code that uses this class.
+        """
+
+        if not os.path.isdir(srctree):
+            yield os.path.split(srctree)
+        for srcpath, _, fnames in os.walk(srctree):
+            # Avoid infinite recursion for silly users
+            if ignore is not None and ignore in srcpath:
+                continue
+            for fname in (x for x in fnames if x.endswith('.py')):
+                yield srcpath, fname
+
+    @staticmethod
+    def parse_file(fname):
+        """Parse a python file into an AST.
+
+        This is a very thin wrapper around ast.parse
+
+            TODO: Handle encodings other than the default for Python 2
+                        (issue #26)
+        """
+        try:
+            with fopen(fname) as f:
+                fstr = f.read()
+        except IOError:
+            if fname != 'stdin':
+                raise
+            sys.stdout.write('\nReading from stdin:\n\n')
+            fstr = sys.stdin.read()
+        fstr = fstr.replace('\r\n', '\n').replace('\r', '\n')
+        if not fstr.endswith('\n'):
+            fstr += '\n'
+        return ast.parse(fstr, filename=fname)
+
+    @staticmethod
+    def get_file_info(codeobj):
+        """Returns the file and line number of a code object.
+
+            If the code object has a __file__ attribute (e.g. if
+            it is a module), then the returned line number will
+            be 0
+        """
+        fname = getattr(codeobj, '__file__', None)
+        linenum = 0
+        if fname is None:
+            func_code = codeobj.__code__
+            fname = func_code.co_filename
+            linenum = func_code.co_firstlineno
+        fname = fname.replace('.pyc', '.py')
+        return fname, linenum
+
+    def __init__(self, cache=None):
+        self.cache = cache or {}
+
+    def __call__(self, codeobj):
+        cache = self.cache
+        key = self.get_file_info(codeobj)
+        result = cache.get(key)
+        if result is not None:
+            return result
+        fname = key[0]
+        cache[(fname, 0)] = mod_ast = self.parse_file(fname)
+        for obj in mod_ast.body:
+            if not isinstance(obj, ast.FunctionDef):
+                continue
+            cache[(fname, obj.lineno)] = obj
+        return cache[key]
+
+
+code_to_ast = CodeToAst()

.venv/lib/python3.11/site-packages/astor/node_util.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+"""
+Part of the astor library for Python AST manipulation.
+
+License: 3-clause BSD
+
+Copyright 2012-2015 (c) Patrick Maupin
+Copyright 2013-2015 (c) Berker Peksag
+
+Utilities for node (and, by extension, tree) manipulation.
+For a whole-tree approach, see the treewalk submodule.
+
+"""
+
+import ast
+import itertools
+
+try:
+    zip_longest = itertools.zip_longest
+except AttributeError:
+    zip_longest = itertools.izip_longest
+
+
+class NonExistent(object):
+    """This is not the class you are looking for.
+    """
+    pass
+
+
+def iter_node(node, name='', unknown=None,
+              # Runtime optimization
+              list=list, getattr=getattr, isinstance=isinstance,
+              enumerate=enumerate, missing=NonExistent):
+    """Iterates over an object:
+
+       - If the object has a _fields attribute,
+         it gets attributes in the order of this
+         and returns name, value pairs.
+
+       - Otherwise, if the object is a list instance,
+         it returns name, value pairs for each item
+         in the list, where the name is passed into
+         this function (defaults to blank).
+
+       - Can update an unknown set with information about
+         attributes that do not exist in fields.
+    """
+    fields = getattr(node, '_fields', None)
+    if fields is not None:
+        for name in fields:
+            value = getattr(node, name, missing)
+            if value is not missing:
+                yield value, name
+        if unknown is not None:
+            unknown.update(set(vars(node)) - set(fields))
+    elif isinstance(node, list):
+        for value in node:
+            yield value, name
+
+
+def dump_tree(node, name=None, initial_indent='', indentation='    ',
+              maxline=120, maxmerged=80,
+              # Runtime optimization
+              iter_node=iter_node, special=ast.AST,
+              list=list, isinstance=isinstance, type=type, len=len):
+    """Dumps an AST or similar structure:
+
+       - Pretty-prints with indentation
+       - Doesn't print line/column/ctx info
+
+    """
+    def dump(node, name=None, indent=''):
+        level = indent + indentation
+        name = name and name + '=' or ''
+        values = list(iter_node(node))
+        if isinstance(node, list):
+            prefix, suffix = '%s[' % name, ']'
+        elif values:
+            prefix, suffix = '%s%s(' % (name, type(node).__name__), ')'
+        elif isinstance(node, special):
+            prefix, suffix = name + type(node).__name__, ''
+        else:
+            return '%s%s' % (name, repr(node))
+        node = [dump(a, b, level) for a, b in values if b != 'ctx']
+        oneline = '%s%s%s' % (prefix, ', '.join(node), suffix)
+        if len(oneline) + len(indent) < maxline:
+            return '%s' % oneline
+        if node and len(prefix) + len(node[0]) < maxmerged:
+            prefix = '%s%s,' % (prefix, node.pop(0))
+        node = (',\n%s' % level).join(node).lstrip()
+        return '%s\n%s%s%s' % (prefix, level, node, suffix)
+    return dump(node, name, initial_indent)
+
+
+def strip_tree(node,
+               # Runtime optimization
+               iter_node=iter_node, special=ast.AST,
+               list=list, isinstance=isinstance, type=type, len=len):
+    """Strips an AST by removing all attributes not in _fields.
+
+    Returns a set of the names of all attributes stripped.
+
+    This canonicalizes two trees for comparison purposes.
+    """
+    stripped = set()
+
+    def strip(node, indent):
+        unknown = set()
+        leaf = True
+        for subnode, _ in iter_node(node, unknown=unknown):
+            leaf = False
+            strip(subnode, indent + '    ')
+        if leaf:
+            if isinstance(node, special):
+                unknown = set(vars(node))
+        stripped.update(unknown)
+        for name in unknown:
+            delattr(node, name)
+        if hasattr(node, 'ctx'):
+            delattr(node, 'ctx')
+            if 'ctx' in node._fields:
+                mylist = list(node._fields)
+                mylist.remove('ctx')
+                node._fields = mylist
+    strip(node, '')
+    return stripped
+
+
+class ExplicitNodeVisitor(ast.NodeVisitor):
+    """This expands on the ast module's NodeVisitor class
+    to remove any implicit visits.
+
+    """
+
+    def abort_visit(node):  # XXX: self?
+        msg = 'No defined handler for node of type %s'
+        raise AttributeError(msg % node.__class__.__name__)
+
+    def visit(self, node, abort=abort_visit):
+        """Visit a node."""
+        method = 'visit_' + node.__class__.__name__
+        visitor = getattr(self, method, abort)
+        return visitor(node)
+
+
+def allow_ast_comparison():
+    """This ugly little monkey-patcher adds in a helper class
+    to all the AST node types.  This helper class allows
+    eq/ne comparisons to work, so that entire trees can
+    be easily compared by Python's comparison machinery.
+    Used by the anti8 functions to compare old and new ASTs.
+    Could also be used by the test library.
+
+
+    """
+
+    class CompareHelper(object):
+        def __eq__(self, other):
+            return type(self) == type(other) and vars(self) == vars(other)
+
+        def __ne__(self, other):
+            return type(self) != type(other) or vars(self) != vars(other)
+
+    for item in vars(ast).values():
+        if type(item) != type:
+            continue
+        if issubclass(item, ast.AST):
+            try:
+                item.__bases__ = tuple(list(item.__bases__) + [CompareHelper])
+            except TypeError:
+                pass
+
+
+def fast_compare(tree1, tree2):
+    """ This is optimized to compare two AST trees for equality.
+        It makes several assumptions that are currently true for
+        AST trees used by rtrip, and it doesn't examine the _attributes.
+    """
+
+    geta = ast.AST.__getattribute__
+
+    work = [(tree1, tree2)]
+    pop = work.pop
+    extend = work.extend
+    # TypeError in cPython, AttributeError in PyPy
+    exception = TypeError, AttributeError
+    zipl = zip_longest
+    type_ = type
+    list_ = list
+    while work:
+        n1, n2 = pop()
+        try:
+            f1 = geta(n1, '_fields')
+            f2 = geta(n2, '_fields')
+        except exception:
+            if type_(n1) is list_:
+                extend(zipl(n1, n2))
+                continue
+            if n1 == n2:
+                continue
+            return False
+        else:
+            f1 = [x for x in f1 if x != 'ctx']
+            if f1 != [x for x in f2 if x != 'ctx']:
+                return False
+            extend((geta(n1, fname), geta(n2, fname)) for fname in f1)
+
+    return True

.venv/lib/python3.11/site-packages/astor/op_util.py

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+"""
+Part of the astor library for Python AST manipulation.
+
+License: 3-clause BSD
+
+Copyright (c) 2015 Patrick Maupin
+
+This module provides data and functions for mapping
+AST nodes to symbols and precedences.
+
+"""
+
+import ast
+
+op_data = """
+    GeneratorExp                1
+
+          Assign                1
+       AnnAssign                1
+       AugAssign                0
+            Expr                0
+           Yield                1
+       YieldFrom                0
+              If                1
+             For                0
+        AsyncFor                0
+           While                0
+          Return                1
+
+           Slice                1
+       Subscript                0
+           Index                1
+        ExtSlice                1
+    comprehension_target        1
+           Tuple                0
+  FormattedValue                0
+
+           Comma                1
+       NamedExpr                1
+          Assert                0
+           Raise                0
+    call_one_arg                1
+
+          Lambda                1
+           IfExp                0
+
+   comprehension                1
+              Or   or           1
+             And   and          1
+             Not   not          1
+
+              Eq   ==           1
+              Gt   >            0
+             GtE   >=           0
+              In   in           0
+              Is   is           0
+           NotEq   !=           0
+              Lt   <            0
+             LtE   <=           0
+           NotIn   not in       0
+           IsNot   is not       0
+
+           BitOr   |            1
+          BitXor   ^            1
+          BitAnd   &            1
+          LShift   <<           1
+          RShift   >>           0
+             Add   +            1
+             Sub   -            0
+            Mult   *            1
+             Div   /            0
+             Mod   %            0
+        FloorDiv   //           0
+         MatMult   @            0
+          PowRHS                1
+          Invert   ~            1
+            UAdd   +            0
+            USub   -            0
+             Pow   **           1
+           Await                1
+             Num                1
+        Constant                1
+"""
+
+op_data = [x.split() for x in op_data.splitlines()]
+op_data = [[x[0], ' '.join(x[1:-1]), int(x[-1])] for x in op_data if x]
+for index in range(1, len(op_data)):
+    op_data[index][2] *= 2
+    op_data[index][2] += op_data[index - 1][2]
+
+precedence_data = dict((getattr(ast, x, None), z) for x, y, z in op_data)
+symbol_data = dict((getattr(ast, x, None), y) for x, y, z in op_data)
+
+
+def get_op_symbol(obj, fmt='%s', symbol_data=symbol_data, type=type):
+    """Given an AST node object, returns a string containing the symbol.
+    """
+    return fmt % symbol_data[type(obj)]
+
+
+def get_op_precedence(obj, precedence_data=precedence_data, type=type):
+    """Given an AST node object, returns the precedence.
+    """
+    return precedence_data[type(obj)]
+
+
+class Precedence(object):
+    vars().update((x, z) for x, y, z in op_data)
+    highest = max(z for x, y, z in op_data) + 2

.venv/lib/python3.11/site-packages/astor/rtrip.py

@@ -0,0 +1,209 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Part of the astor library for Python AST manipulation.
+
+License: 3-clause BSD
+
+Copyright (c) 2015 Patrick Maupin
+"""
+
+import sys
+import os
+import ast
+import shutil
+import logging
+
+from astor.code_gen import to_source
+from astor.file_util import code_to_ast
+from astor.node_util import (allow_ast_comparison, dump_tree,
+                             strip_tree, fast_compare)
+
+
+dsttree = 'tmp_rtrip'
+
+# TODO:  Remove this workaround once we remove version 2 support
+
+
+def out_prep(s, pre_encoded=(sys.version_info[0] == 2)):
+    return s if pre_encoded else s.encode('utf-8')
+
+
+def convert(srctree, dsttree=dsttree, readonly=False, dumpall=False,
+            ignore_exceptions=False, fullcomp=False):
+    """Walk the srctree, and convert/copy all python files
+    into the dsttree
+
+    """
+
+    if fullcomp:
+        allow_ast_comparison()
+
+    parse_file = code_to_ast.parse_file
+    find_py_files = code_to_ast.find_py_files
+    srctree = os.path.normpath(srctree)
+
+    if not readonly:
+        dsttree = os.path.normpath(dsttree)
+        logging.info('')
+        logging.info('Trashing ' + dsttree)
+        shutil.rmtree(dsttree, True)
+
+    unknown_src_nodes = set()
+    unknown_dst_nodes = set()
+    badfiles = set()
+    broken = []
+
+    oldpath = None
+
+    allfiles = find_py_files(srctree, None if readonly else dsttree)
+    for srcpath, fname in allfiles:
+        # Create destination directory
+        if not readonly and srcpath != oldpath:
+            oldpath = srcpath
+            if srcpath >= srctree:
+                dstpath = srcpath.replace(srctree, dsttree, 1)
+                if not dstpath.startswith(dsttree):
+                    raise ValueError("%s not a subdirectory of %s" %
+                                     (dstpath, dsttree))
+            else:
+                assert srctree.startswith(srcpath)
+                dstpath = dsttree
+            os.makedirs(dstpath)
+
+        srcfname = os.path.join(srcpath, fname)
+        logging.info('Converting %s' % srcfname)
+        try:
+            srcast = parse_file(srcfname)
+        except SyntaxError:
+            badfiles.add(srcfname)
+            continue
+
+        try:
+            dsttxt = to_source(srcast)
+        except Exception:
+            if not ignore_exceptions:
+                raise
+            dsttxt = ''
+
+        if not readonly:
+            dstfname = os.path.join(dstpath, fname)
+            try:
+                with open(dstfname, 'wb') as f:
+                    f.write(out_prep(dsttxt))
+            except UnicodeEncodeError:
+                badfiles.add(dstfname)
+
+        # As a sanity check, make sure that ASTs themselves
+        # round-trip OK
+        try:
+            dstast = ast.parse(dsttxt) if readonly else parse_file(dstfname)
+        except SyntaxError:
+            dstast = []
+        if fullcomp:
+            unknown_src_nodes.update(strip_tree(srcast))
+            unknown_dst_nodes.update(strip_tree(dstast))
+            bad = srcast != dstast
+        else:
+            bad = not fast_compare(srcast, dstast)
+        if dumpall or bad:
+            srcdump = dump_tree(srcast)
+            dstdump = dump_tree(dstast)
+            logging.warning('    calculating dump -- %s' %
+                            ('bad' if bad else 'OK'))
+            if bad:
+                broken.append(srcfname)
+            if dumpall or bad:
+                if not readonly:
+                    try:
+                        with open(dstfname[:-3] + '.srcdmp', 'wb') as f:
+                            f.write(out_prep(srcdump))
+                    except UnicodeEncodeError:
+                        badfiles.add(dstfname[:-3] + '.srcdmp')
+                    try:
+                        with open(dstfname[:-3] + '.dstdmp', 'wb') as f:
+                            f.write(out_prep(dstdump))
+                    except UnicodeEncodeError:
+                        badfiles.add(dstfname[:-3] + '.dstdmp')
+                elif dumpall:
+                    sys.stdout.write('\n\nAST:\n\n    ')
+                    sys.stdout.write(srcdump.replace('\n', '\n    '))
+                    sys.stdout.write('\n\nDecompile:\n\n    ')
+                    sys.stdout.write(dsttxt.replace('\n', '\n    '))
+                    sys.stdout.write('\n\nNew AST:\n\n    ')
+                    sys.stdout.write('(same as old)' if dstdump == srcdump
+                                     else dstdump.replace('\n', '\n    '))
+                    sys.stdout.write('\n')
+
+    if badfiles:
+        logging.warning('\nFiles not processed due to syntax errors:')
+        for fname in sorted(badfiles):
+            logging.warning('    %s' % fname)
+    if broken:
+        logging.warning('\nFiles failed to round-trip to AST:')
+        for srcfname in broken:
+            logging.warning('    %s' % srcfname)
+
+    ok_to_strip = 'col_offset _precedence _use_parens lineno _p_op _pp'
+    ok_to_strip = set(ok_to_strip.split())
+    bad_nodes = (unknown_dst_nodes | unknown_src_nodes) - ok_to_strip
+    if bad_nodes:
+        logging.error('\nERROR -- UNKNOWN NODES STRIPPED: %s' % bad_nodes)
+    logging.info('\n')
+    return broken
+
+
+def usage(msg):
+    raise SystemExit(textwrap.dedent("""
+
+        Error: %s
+
+        Usage:
+
+            python -m astor.rtrip [readonly] [<source>]
+
+
+        This utility tests round-tripping of Python source to AST
+        and back to source.
+
+        If readonly is specified, then the source will be tested,
+        but no files will be written.
+
+        if the source is specified to be "stdin" (without quotes)
+        then any source entered at the command line will be compiled
+        into an AST, converted back to text, and then compiled to
+        an AST again, and the results will be displayed to stdout.
+
+        If neither readonly nor stdin is specified, then rtrip
+        will create a mirror directory named tmp_rtrip and will
+        recursively round-trip all the Python source from the source
+        into the tmp_rtrip dir, after compiling it and then reconstituting
+        it through code_gen.to_source.
+
+        If the source is not specified, the entire Python library will be used.
+
+        """) % msg)
+
+
+if __name__ == '__main__':
+    import textwrap
+
+    args = sys.argv[1:]
+
+    readonly = 'readonly' in args
+    if readonly:
+        args.remove('readonly')
+
+    if not args:
+        args = [os.path.dirname(textwrap.__file__)]
+
+    if len(args) > 1:
+        usage("Too many arguments")
+
+    fname, = args
+    dumpall = False
+    if not os.path.exists(fname):
+        dumpall = fname == 'stdin' or usage("Cannot find directory %s" % fname)
+
+    logging.basicConfig(format='%(msg)s', level=logging.INFO)
+    convert(fname, readonly=readonly or dumpall, dumpall=dumpall)

.venv/lib/python3.11/site-packages/astor/source_repr.py

@@ -0,0 +1,273 @@
+# -*- coding: utf-8 -*-
+"""
+Part of the astor library for Python AST manipulation.
+
+License: 3-clause BSD
+
+Copyright (c) 2015 Patrick Maupin
+
+Pretty-print source -- post-process for the decompiler
+
+The goals of the initial cut of this engine are:
+
+1) Do a passable, if not PEP8, job of line-wrapping.
+
+2) Serve as an example of an interface to the decompiler
+   for anybody who wants to do a better job. :)
+"""
+
+
+def pretty_source(source):
+    """ Prettify the source.
+    """
+
+    return ''.join(split_lines(source))
+
+
+def split_lines(source, maxline=79):
+    """Split inputs according to lines.
+       If a line is short enough, just yield it.
+       Otherwise, fix it.
+    """
+    result = []
+    extend = result.extend
+    append = result.append
+    line = []
+    multiline = False
+    count = 0
+    for item in source:
+        newline = type(item)('\n')
+        index = item.find(newline)
+        if index:
+            line.append(item)
+            multiline = index > 0
+            count += len(item)
+        else:
+            if line:
+                if count <= maxline or multiline:
+                    extend(line)
+                else:
+                    wrap_line(line, maxline, result)
+                count = 0
+                multiline = False
+                line = []
+            append(item)
+    return result
+
+
+def count(group, slen=str.__len__):
+    return sum([slen(x) for x in group])
+
+
+def wrap_line(line, maxline=79, result=[], count=count):
+    """ We have a line that is too long,
+        so we're going to try to wrap it.
+    """
+
+    # Extract the indentation
+
+    append = result.append
+    extend = result.extend
+
+    indentation = line[0]
+    lenfirst = len(indentation)
+    indent = lenfirst - len(indentation.lstrip())
+    assert indent in (0, lenfirst)
+    indentation = line.pop(0) if indent else ''
+
+    # Get splittable/non-splittable groups
+
+    dgroups = list(delimiter_groups(line))
+    unsplittable = dgroups[::2]
+    splittable = dgroups[1::2]
+
+    # If the largest non-splittable group won't fit
+    # on a line, try to add parentheses to the line.
+
+    if max(count(x) for x in unsplittable) > maxline - indent:
+        line = add_parens(line, maxline, indent)
+        dgroups = list(delimiter_groups(line))
+        unsplittable = dgroups[::2]
+        splittable = dgroups[1::2]
+
+    # Deal with the first (always unsplittable) group, and
+    # then set up to deal with the remainder in pairs.
+
+    first = unsplittable[0]
+    append(indentation)
+    extend(first)
+    if not splittable:
+        return result
+    pos = indent + count(first)
+    indentation += '    '
+    indent += 4
+    if indent >= maxline / 2:
+        maxline = maxline / 2 + indent
+
+    for sg, nsg in zip(splittable, unsplittable[1:]):
+
+        if sg:
+            # If we already have stuff on the line and even
+            # the very first item won't fit, start a new line
+            if pos > indent and pos + len(sg[0]) > maxline:
+                append('\n')
+                append(indentation)
+                pos = indent
+
+            # Dump lines out of the splittable group
+            # until the entire thing fits
+            csg = count(sg)
+            while pos + csg > maxline:
+                ready, sg = split_group(sg, pos, maxline)
+                if ready[-1].endswith(' '):
+                    ready[-1] = ready[-1][:-1]
+                extend(ready)
+                append('\n')
+                append(indentation)
+                pos = indent
+                csg = count(sg)
+
+            # Dump the remainder of the splittable group
+            if sg:
+                extend(sg)
+                pos += csg
+
+        # Dump the unsplittable group, optionally
+        # preceded by a linefeed.
+        cnsg = count(nsg)
+        if pos > indent and pos + cnsg > maxline:
+            append('\n')
+            append(indentation)
+            pos = indent
+        extend(nsg)
+        pos += cnsg
+
+
+def split_group(source, pos, maxline):
+    """ Split a group into two subgroups.  The
+        first will be appended to the current
+        line, the second will start the new line.
+
+        Note that the first group must always
+        contain at least one item.
+
+        The original group may be destroyed.
+    """
+    first = []
+    source.reverse()
+    while source:
+        tok = source.pop()
+        first.append(tok)
+        pos += len(tok)
+        if source:
+            tok = source[-1]
+            allowed = (maxline + 1) if tok.endswith(' ') else (maxline - 4)
+            if pos + len(tok) > allowed:
+                break
+
+    source.reverse()
+    return first, source
+
+
+begin_delim = set('([{')
+end_delim = set(')]}')
+end_delim.add('):')
+
+
+def delimiter_groups(line, begin_delim=begin_delim,
+                     end_delim=end_delim):
+    """Split a line into alternating groups.
+       The first group cannot have a line feed inserted,
+       the next one can, etc.
+    """
+    text = []
+    line = iter(line)
+    while True:
+        # First build and yield an unsplittable group
+        for item in line:
+            text.append(item)
+            if item in begin_delim:
+                break
+        if not text:
+            break
+        yield text
+
+        # Now build and yield a splittable group
+        level = 0
+        text = []
+        for item in line:
+            if item in begin_delim:
+                level += 1
+            elif item in end_delim:
+                level -= 1
+                if level < 0:
+                    yield text
+                    text = [item]
+                    break
+            text.append(item)
+        else:
+            assert not text, text
+            break
+
+
+statements = set(['del ', 'return', 'yield ', 'if ', 'while '])
+
+
+def add_parens(line, maxline, indent, statements=statements, count=count):
+    """Attempt to add parentheses around the line
+       in order to make it splittable.
+    """
+
+    if line[0] in statements:
+        index = 1
+        if not line[0].endswith(' '):
+            index = 2
+            assert line[1] == ' '
+        line.insert(index, '(')
+        if line[-1] == ':':
+            line.insert(-1, ')')
+        else:
+            line.append(')')
+
+    # That was the easy stuff.  Now for assignments.
+    groups = list(get_assign_groups(line))
+    if len(groups) == 1:
+        # So sad, too bad
+        return line
+
+    counts = list(count(x) for x in groups)
+    didwrap = False
+
+    # If the LHS is large, wrap it first
+    if sum(counts[:-1]) >= maxline - indent - 4:
+        for group in groups[:-1]:
+            didwrap = False  # Only want to know about last group
+            if len(group) > 1:
+                group.insert(0, '(')
+                group.insert(-1, ')')
+                didwrap = True
+
+    # Might not need to wrap the RHS if wrapped the LHS
+    if not didwrap or counts[-1] > maxline - indent - 10:
+        groups[-1].insert(0, '(')
+        groups[-1].append(')')
+
+    return [item for group in groups for item in group]
+
+
+# Assignment operators
+ops = list('|^&+-*/%@~') + '<< >> // **'.split() + ['']
+ops = set(' %s= ' % x for x in ops)
+
+
+def get_assign_groups(line, ops=ops):
+    """ Split a line into groups by assignment (including
+        augmented assignment)
+    """
+    group = []
+    for item in line:
+        group.append(item)
+        if item in ops:
+            yield group
+            group = []
+    yield group

.venv/lib/python3.11/site-packages/astor/string_repr.py

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*-
+"""
+Part of the astor library for Python AST manipulation.
+
+License: 3-clause BSD
+
+Copyright (c) 2015 Patrick Maupin
+
+Pretty-print strings for the decompiler
+
+We either return the repr() of the string,
+or try to format it as a triple-quoted string.
+
+This is a lot harder than you would think.
+
+This has lots of Python 2 / Python 3 ugliness.
+
+"""
+
+import re
+
+try:
+    special_unicode = unicode
+except NameError:
+    class special_unicode(object):
+        pass
+
+try:
+    basestring = basestring
+except NameError:
+    basestring = str
+
+
+def _properly_indented(s, line_indent):
+    mylist = s.split('\n')[1:]
+    mylist = [x.rstrip() for x in mylist]
+    mylist = [x for x in mylist if x]
+    if not s:
+        return False
+    counts = [(len(x) - len(x.lstrip())) for x in mylist]
+    return counts and min(counts) >= line_indent
+
+
+mysplit = re.compile(r'(\\|\"\"\"|\"$)').split
+replacements = {'\\': '\\\\', '"""': '""\\"', '"': '\\"'}
+
+
+def _prep_triple_quotes(s, mysplit=mysplit, replacements=replacements):
+    """ Split the string up and force-feed some replacements
+        to make sure it will round-trip OK
+    """
+
+    s = mysplit(s)
+    s[1::2] = (replacements[x] for x in s[1::2])
+    return ''.join(s)
+
+
+def string_triplequote_repr(s):
+    """Return string's python representation in triple quotes.
+    """
+    return '"""%s"""' % _prep_triple_quotes(s)
+
+
+def pretty_string(s, embedded, current_line, uni_lit=False,
+                  min_trip_str=20, max_line=100):
+    """There are a lot of reasons why we might not want to or
+       be able to return a triple-quoted string.  We can always
+       punt back to the default normal string.
+    """
+
+    default = repr(s)
+
+    # Punt on abnormal strings
+    if (isinstance(s, special_unicode) or not isinstance(s, basestring)):
+        return default
+    if uni_lit and isinstance(s, bytes):
+        return 'b' + default
+
+    len_s = len(default)
+
+    if current_line.strip():
+        len_current = len(current_line)
+        second_line_start = s.find('\n') + 1
+        if embedded > 1 and not second_line_start:
+            return default
+
+        if len_s < min_trip_str:
+            return default
+
+        line_indent = len_current - len(current_line.lstrip())
+
+        # Could be on a line by itself...
+        if embedded and not second_line_start:
+            return default
+
+        total_len = len_current + len_s
+        if total_len < max_line and not _properly_indented(s, line_indent):
+            return default
+
+    fancy = string_triplequote_repr(s)
+
+    # Sometimes this doesn't work.  One reason is that
+    # the AST has no understanding of whether \r\n was
+    # entered that way in the string or was a cr/lf in the
+    # file.  So we punt just so we can round-trip properly.
+
+    try:
+        if eval(fancy) == s and '\r' not in fancy:
+            return fancy
+    except Exception:
+        pass
+    return default

.venv/lib/python3.11/site-packages/astor/tree_walk.py

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+"""
+Part of the astor library for Python AST manipulation.
+
+License: 3-clause BSD
+
+Copyright 2012 (c) Patrick Maupin
+Copyright 2013 (c) Berker Peksag
+
+This file contains a TreeWalk class that views a node tree
+as a unified whole and allows several modes of traversal.
+
+"""
+
+from .node_util import iter_node
+
+
+class MetaFlatten(type):
+    """This metaclass is used to flatten classes to remove
+    class hierarchy.
+
+    This makes it easier to manipulate classes (find
+    attributes in a single dict, etc.)
+
+    """
+    def __new__(clstype, name, bases, clsdict):
+        newbases = (object,)
+        newdict = {}
+        for base in reversed(bases):
+            if base not in newbases:
+                newdict.update(vars(base))
+        newdict.update(clsdict)
+        # These are class-bound, we should let Python recreate them.
+        newdict.pop('__dict__', None)
+        newdict.pop('__weakref__', None)
+        # Delegate the real work to type
+        return type.__new__(clstype, name, newbases, newdict)
+
+
+MetaFlatten = MetaFlatten('MetaFlatten', (object,), {})
+
+
+class TreeWalk(MetaFlatten):
+    """The TreeWalk class can be used as a superclass in order
+    to walk an AST or similar tree.
+
+    Unlike other treewalkers, this class can walk a tree either
+    recursively or non-recursively.  Subclasses can define
+    methods with the following signatures::
+
+        def pre_xxx(self):
+            pass
+
+        def post_xxx(self):
+            pass
+
+        def init_xxx(self):
+            pass
+
+    Where 'xxx' is one of:
+
+      - A class name
+      - An attribute member name concatenated with '_name'
+        For example, 'pre_targets_name' will process nodes
+        that are referenced by the name 'targets' in their
+        parent's node.
+      - An attribute member name concatenated with '_item'
+        For example, 'pre_targets_item'  will process nodes
+        that are in a list that is the targets attribute
+        of some node.
+
+    pre_xxx will process a node before processing any of its subnodes.
+    if the return value from pre_xxx evalates to true, then walk
+    will not process any of the subnodes.  Those can be manually
+    processed, if desired, by calling self.walk(node) on the subnodes
+    before returning True.
+
+    post_xxx will process a node after processing all its subnodes.
+
+    init_xxx methods can decorate the class instance with subclass-specific
+    information.  A single init_whatever method could be written, but to
+    make it easy to keep initialization with use, any number of init_xxx
+    methods can be written.  They will be called in alphabetical order.
+
+    """
+
+    def __init__(self, node=None):
+        self.nodestack = []
+        self.setup()
+        if node is not None:
+            self.walk(node)
+
+    def setup(self):
+        """All the node-specific handlers are setup at
+        object initialization time.
+
+        """
+        self.pre_handlers = pre_handlers = {}
+        self.post_handlers = post_handlers = {}
+        for name in sorted(vars(type(self))):
+            if name.startswith('init_'):
+                getattr(self, name)()
+            elif name.startswith('pre_'):
+                pre_handlers[name[4:]] = getattr(self, name)
+            elif name.startswith('post_'):
+                post_handlers[name[5:]] = getattr(self, name)
+
+    def walk(self, node, name='', list=list, len=len, type=type):
+        """Walk the tree starting at a given node.
+
+        Maintain a stack of nodes.
+
+        """
+        pre_handlers = self.pre_handlers.get
+        post_handlers = self.post_handlers.get
+        nodestack = self.nodestack
+        emptystack = len(nodestack)
+        append, pop = nodestack.append, nodestack.pop
+        append([node, name, list(iter_node(node, name + '_item')), -1])
+        while len(nodestack) > emptystack:
+            node, name, subnodes, index = nodestack[-1]
+            if index >= len(subnodes):
+                handler = (post_handlers(type(node).__name__) or
+                           post_handlers(name + '_name'))
+                if handler is None:
+                    pop()
+                    continue
+                self.cur_node = node
+                self.cur_name = name
+                handler()
+                current = nodestack and nodestack[-1]
+                popstack = current and current[0] is node
+                if popstack and current[-1] >= len(current[-2]):
+                    pop()
+                continue
+            nodestack[-1][-1] = index + 1
+            if index < 0:
+                handler = (pre_handlers(type(node).__name__) or
+                           pre_handlers(name + '_name'))
+                if handler is not None:
+                    self.cur_node = node
+                    self.cur_name = name
+                    if handler():
+                        pop()
+            else:
+                node, name = subnodes[index]
+                append([node, name, list(iter_node(node, name + '_item')), -1])
+
+    @property
+    def parent(self):
+        """Return the parent node of the current node."""
+        nodestack = self.nodestack
+        if len(nodestack) < 2:
+            return None
+        return nodestack[-2][0]
+
+    @property
+    def parent_name(self):
+        """Return the parent node and name."""
+        nodestack = self.nodestack
+        if len(nodestack) < 2:
+            return None
+        return nodestack[-2][:2]
+
+    def replace(self, new_node):
+        """Replace a node after first checking integrity of node stack."""
+        cur_node = self.cur_node
+        nodestack = self.nodestack
+        cur = nodestack.pop()
+        prev = nodestack[-1]
+        index = prev[-1] - 1
+        oldnode, name = prev[-2][index]
+        assert cur[0] is cur_node is oldnode, (cur[0], cur_node, prev[-2],
+                                               index)
+        parent = prev[0]
+        if isinstance(parent, list):
+            parent[index] = new_node
+        else:
+            setattr(parent, name, new_node)

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

@@ -0,0 +1,25 @@
+"""FastAPI framework, high performance, easy to learn, fast to code, ready for production"""
+
+__version__ = "0.115.8"
+
+from starlette import status as status
+
+from .applications import FastAPI as FastAPI
+from .background import BackgroundTasks as BackgroundTasks
+from .datastructures import UploadFile as UploadFile
+from .exceptions import HTTPException as HTTPException
+from .exceptions import WebSocketException as WebSocketException
+from .param_functions import Body as Body
+from .param_functions import Cookie as Cookie
+from .param_functions import Depends as Depends
+from .param_functions import File as File
+from .param_functions import Form as Form
+from .param_functions import Header as Header
+from .param_functions import Path as Path
+from .param_functions import Query as Query
+from .param_functions import Security as Security
+from .requests import Request as Request
+from .responses import Response as Response
+from .routing import APIRouter as APIRouter
+from .websockets import WebSocket as WebSocket
+from .websockets import WebSocketDisconnect as WebSocketDisconnect

.venv/lib/python3.11/site-packages/fastapi/__main__.py

@@ -0,0 +1,3 @@
+from fastapi.cli import main
+
+main()

.venv/lib/python3.11/site-packages/fastapi/_compat.py

@@ -0,0 +1,659 @@
+from collections import deque
+from copy import copy
+from dataclasses import dataclass, is_dataclass
+from enum import Enum
+from functools import lru_cache
+from typing import (
+    Any,
+    Callable,
+    Deque,
+    Dict,
+    FrozenSet,
+    List,
+    Mapping,
+    Sequence,
+    Set,
+    Tuple,
+    Type,
+    Union,
+)
+
+from fastapi.exceptions import RequestErrorModel
+from fastapi.types import IncEx, ModelNameMap, UnionType
+from pydantic import BaseModel, create_model
+from pydantic.version import VERSION as PYDANTIC_VERSION
+from starlette.datastructures import UploadFile
+from typing_extensions import Annotated, Literal, get_args, get_origin
+
+PYDANTIC_VERSION_MINOR_TUPLE = tuple(int(x) for x in PYDANTIC_VERSION.split(".")[:2])
+PYDANTIC_V2 = PYDANTIC_VERSION_MINOR_TUPLE[0] == 2
+
+
+sequence_annotation_to_type = {
+    Sequence: list,
+    List: list,
+    list: list,
+    Tuple: tuple,
+    tuple: tuple,
+    Set: set,
+    set: set,
+    FrozenSet: frozenset,
+    frozenset: frozenset,
+    Deque: deque,
+    deque: deque,
+}
+
+sequence_types = tuple(sequence_annotation_to_type.keys())
+
+Url: Type[Any]
+
+if PYDANTIC_V2:
+    from pydantic import PydanticSchemaGenerationError as PydanticSchemaGenerationError
+    from pydantic import TypeAdapter
+    from pydantic import ValidationError as ValidationError
+    from pydantic._internal._schema_generation_shared import (  # type: ignore[attr-defined]
+        GetJsonSchemaHandler as GetJsonSchemaHandler,
+    )
+    from pydantic._internal._typing_extra import eval_type_lenient
+    from pydantic._internal._utils import lenient_issubclass as lenient_issubclass
+    from pydantic.fields import FieldInfo
+    from pydantic.json_schema import GenerateJsonSchema as GenerateJsonSchema
+    from pydantic.json_schema import JsonSchemaValue as JsonSchemaValue
+    from pydantic_core import CoreSchema as CoreSchema
+    from pydantic_core import PydanticUndefined, PydanticUndefinedType
+    from pydantic_core import Url as Url
+
+    try:
+        from pydantic_core.core_schema import (
+            with_info_plain_validator_function as with_info_plain_validator_function,
+        )
+    except ImportError:  # pragma: no cover
+        from pydantic_core.core_schema import (
+            general_plain_validator_function as with_info_plain_validator_function,  # noqa: F401
+        )
+
+    RequiredParam = PydanticUndefined
+    Undefined = PydanticUndefined
+    UndefinedType = PydanticUndefinedType
+    evaluate_forwardref = eval_type_lenient
+    Validator = Any
+
+    class BaseConfig:
+        pass
+
+    class ErrorWrapper(Exception):
+        pass
+
+    @dataclass
+    class ModelField:
+        field_info: FieldInfo
+        name: str
+        mode: Literal["validation", "serialization"] = "validation"
+
+        @property
+        def alias(self) -> str:
+            a = self.field_info.alias
+            return a if a is not None else self.name
+
+        @property
+        def required(self) -> bool:
+            return self.field_info.is_required()
+
+        @property
+        def default(self) -> Any:
+            return self.get_default()
+
+        @property
+        def type_(self) -> Any:
+            return self.field_info.annotation
+
+        def __post_init__(self) -> None:
+            self._type_adapter: TypeAdapter[Any] = TypeAdapter(
+                Annotated[self.field_info.annotation, self.field_info]
+            )
+
+        def get_default(self) -> Any:
+            if self.field_info.is_required():
+                return Undefined
+            return self.field_info.get_default(call_default_factory=True)
+
+        def validate(
+            self,
+            value: Any,
+            values: Dict[str, Any] = {},  # noqa: B006
+            *,
+            loc: Tuple[Union[int, str], ...] = (),
+        ) -> Tuple[Any, Union[List[Dict[str, Any]], None]]:
+            try:
+                return (
+                    self._type_adapter.validate_python(value, from_attributes=True),
+                    None,
+                )
+            except ValidationError as exc:
+                return None, _regenerate_error_with_loc(
+                    errors=exc.errors(include_url=False), loc_prefix=loc
+                )
+
+        def serialize(
+            self,
+            value: Any,
+            *,
+            mode: Literal["json", "python"] = "json",
+            include: Union[IncEx, None] = None,
+            exclude: Union[IncEx, None] = None,
+            by_alias: bool = True,
+            exclude_unset: bool = False,
+            exclude_defaults: bool = False,
+            exclude_none: bool = False,
+        ) -> Any:
+            # What calls this code passes a value that already called
+            # self._type_adapter.validate_python(value)
+            return self._type_adapter.dump_python(
+                value,
+                mode=mode,
+                include=include,
+                exclude=exclude,
+                by_alias=by_alias,
+                exclude_unset=exclude_unset,
+                exclude_defaults=exclude_defaults,
+                exclude_none=exclude_none,
+            )
+
+        def __hash__(self) -> int:
+            # Each ModelField is unique for our purposes, to allow making a dict from
+            # ModelField to its JSON Schema.
+            return id(self)
+
+    def get_annotation_from_field_info(
+        annotation: Any, field_info: FieldInfo, field_name: str
+    ) -> Any:
+        return annotation
+
+    def _normalize_errors(errors: Sequence[Any]) -> List[Dict[str, Any]]:
+        return errors  # type: ignore[return-value]
+
+    def _model_rebuild(model: Type[BaseModel]) -> None:
+        model.model_rebuild()
+
+    def _model_dump(
+        model: BaseModel, mode: Literal["json", "python"] = "json", **kwargs: Any
+    ) -> Any:
+        return model.model_dump(mode=mode, **kwargs)
+
+    def _get_model_config(model: BaseModel) -> Any:
+        return model.model_config
+
+    def get_schema_from_model_field(
+        *,
+        field: ModelField,
+        schema_generator: GenerateJsonSchema,
+        model_name_map: ModelNameMap,
+        field_mapping: Dict[
+            Tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue
+        ],
+        separate_input_output_schemas: bool = True,
+    ) -> Dict[str, Any]:
+        override_mode: Union[Literal["validation"], None] = (
+            None if separate_input_output_schemas else "validation"
+        )
+        # This expects that GenerateJsonSchema was already used to generate the definitions
+        json_schema = field_mapping[(field, override_mode or field.mode)]
+        if "$ref" not in json_schema:
+            # TODO remove when deprecating Pydantic v1
+            # Ref: https://github.com/pydantic/pydantic/blob/d61792cc42c80b13b23e3ffa74bc37ec7c77f7d1/pydantic/schema.py#L207
+            json_schema["title"] = (
+                field.field_info.title or field.alias.title().replace("_", " ")
+            )
+        return json_schema
+
+    def get_compat_model_name_map(fields: List[ModelField]) -> ModelNameMap:
+        return {}
+
+    def get_definitions(
+        *,
+        fields: List[ModelField],
+        schema_generator: GenerateJsonSchema,
+        model_name_map: ModelNameMap,
+        separate_input_output_schemas: bool = True,
+    ) -> Tuple[
+        Dict[
+            Tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue
+        ],
+        Dict[str, Dict[str, Any]],
+    ]:
+        override_mode: Union[Literal["validation"], None] = (
+            None if separate_input_output_schemas else "validation"
+        )
+        inputs = [
+            (field, override_mode or field.mode, field._type_adapter.core_schema)
+            for field in fields
+        ]
+        field_mapping, definitions = schema_generator.generate_definitions(
+            inputs=inputs
+        )
+        return field_mapping, definitions  # type: ignore[return-value]
+
+    def is_scalar_field(field: ModelField) -> bool:
+        from fastapi import params
+
+        return field_annotation_is_scalar(
+            field.field_info.annotation
+        ) and not isinstance(field.field_info, params.Body)
+
+    def is_sequence_field(field: ModelField) -> bool:
+        return field_annotation_is_sequence(field.field_info.annotation)
+
+    def is_scalar_sequence_field(field: ModelField) -> bool:
+        return field_annotation_is_scalar_sequence(field.field_info.annotation)
+
+    def is_bytes_field(field: ModelField) -> bool:
+        return is_bytes_or_nonable_bytes_annotation(field.type_)
+
+    def is_bytes_sequence_field(field: ModelField) -> bool:
+        return is_bytes_sequence_annotation(field.type_)
+
+    def copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:
+        cls = type(field_info)
+        merged_field_info = cls.from_annotation(annotation)
+        new_field_info = copy(field_info)
+        new_field_info.metadata = merged_field_info.metadata
+        new_field_info.annotation = merged_field_info.annotation
+        return new_field_info
+
+    def serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:
+        origin_type = (
+            get_origin(field.field_info.annotation) or field.field_info.annotation
+        )
+        assert issubclass(origin_type, sequence_types)  # type: ignore[arg-type]
+        return sequence_annotation_to_type[origin_type](value)  # type: ignore[no-any-return]
+
+    def get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]:
+        error = ValidationError.from_exception_data(
+            "Field required", [{"type": "missing", "loc": loc, "input": {}}]
+        ).errors(include_url=False)[0]
+        error["input"] = None
+        return error  # type: ignore[return-value]
+
+    def create_body_model(
+        *, fields: Sequence[ModelField], model_name: str
+    ) -> Type[BaseModel]:
+        field_params = {f.name: (f.field_info.annotation, f.field_info) for f in fields}
+        BodyModel: Type[BaseModel] = create_model(model_name, **field_params)  # type: ignore[call-overload]
+        return BodyModel
+
+    def get_model_fields(model: Type[BaseModel]) -> List[ModelField]:
+        return [
+            ModelField(field_info=field_info, name=name)
+            for name, field_info in model.model_fields.items()
+        ]
+
+else:
+    from fastapi.openapi.constants import REF_PREFIX as REF_PREFIX
+    from pydantic import AnyUrl as Url  # noqa: F401
+    from pydantic import (  # type: ignore[assignment]
+        BaseConfig as BaseConfig,  # noqa: F401
+    )
+    from pydantic import ValidationError as ValidationError  # noqa: F401
+    from pydantic.class_validators import (  # type: ignore[no-redef]
+        Validator as Validator,  # noqa: F401
+    )
+    from pydantic.error_wrappers import (  # type: ignore[no-redef]
+        ErrorWrapper as ErrorWrapper,  # noqa: F401
+    )
+    from pydantic.errors import MissingError
+    from pydantic.fields import (  # type: ignore[attr-defined]
+        SHAPE_FROZENSET,
+        SHAPE_LIST,
+        SHAPE_SEQUENCE,
+        SHAPE_SET,
+        SHAPE_SINGLETON,
+        SHAPE_TUPLE,
+        SHAPE_TUPLE_ELLIPSIS,
+    )
+    from pydantic.fields import FieldInfo as FieldInfo
+    from pydantic.fields import (  # type: ignore[no-redef,attr-defined]
+        ModelField as ModelField,  # noqa: F401
+    )
+
+    # Keeping old "Required" functionality from Pydantic V1, without
+    # shadowing typing.Required.
+    RequiredParam: Any = Ellipsis  # type: ignore[no-redef]
+    from pydantic.fields import (  # type: ignore[no-redef,attr-defined]
+        Undefined as Undefined,
+    )
+    from pydantic.fields import (  # type: ignore[no-redef, attr-defined]
+        UndefinedType as UndefinedType,  # noqa: F401
+    )
+    from pydantic.schema import (
+        field_schema,
+        get_flat_models_from_fields,
+        get_model_name_map,
+        model_process_schema,
+    )
+    from pydantic.schema import (  # type: ignore[no-redef]  # noqa: F401
+        get_annotation_from_field_info as get_annotation_from_field_info,
+    )
+    from pydantic.typing import (  # type: ignore[no-redef]
+        evaluate_forwardref as evaluate_forwardref,  # noqa: F401
+    )
+    from pydantic.utils import (  # type: ignore[no-redef]
+        lenient_issubclass as lenient_issubclass,  # noqa: F401
+    )
+
+    GetJsonSchemaHandler = Any  # type: ignore[assignment,misc]
+    JsonSchemaValue = Dict[str, Any]  # type: ignore[misc]
+    CoreSchema = Any  # type: ignore[assignment,misc]
+
+    sequence_shapes = {
+        SHAPE_LIST,
+        SHAPE_SET,
+        SHAPE_FROZENSET,
+        SHAPE_TUPLE,
+        SHAPE_SEQUENCE,
+        SHAPE_TUPLE_ELLIPSIS,
+    }
+    sequence_shape_to_type = {
+        SHAPE_LIST: list,
+        SHAPE_SET: set,
+        SHAPE_TUPLE: tuple,
+        SHAPE_SEQUENCE: list,
+        SHAPE_TUPLE_ELLIPSIS: list,
+    }
+
+    @dataclass
+    class GenerateJsonSchema:  # type: ignore[no-redef]
+        ref_template: str
+
+    class PydanticSchemaGenerationError(Exception):  # type: ignore[no-redef]
+        pass
+
+    def with_info_plain_validator_function(  # type: ignore[misc]
+        function: Callable[..., Any],
+        *,
+        ref: Union[str, None] = None,
+        metadata: Any = None,
+        serialization: Any = None,
+    ) -> Any:
+        return {}
+
+    def get_model_definitions(
+        *,
+        flat_models: Set[Union[Type[BaseModel], Type[Enum]]],
+        model_name_map: Dict[Union[Type[BaseModel], Type[Enum]], str],
+    ) -> Dict[str, Any]:
+        definitions: Dict[str, Dict[str, Any]] = {}
+        for model in flat_models:
+            m_schema, m_definitions, m_nested_models = model_process_schema(
+                model, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+            )
+            definitions.update(m_definitions)
+            model_name = model_name_map[model]
+            if "description" in m_schema:
+                m_schema["description"] = m_schema["description"].split("\f")[0]
+            definitions[model_name] = m_schema
+        return definitions
+
+    def is_pv1_scalar_field(field: ModelField) -> bool:
+        from fastapi import params
+
+        field_info = field.field_info
+        if not (
+            field.shape == SHAPE_SINGLETON  # type: ignore[attr-defined]
+            and not lenient_issubclass(field.type_, BaseModel)
+            and not lenient_issubclass(field.type_, dict)
+            and not field_annotation_is_sequence(field.type_)
+            and not is_dataclass(field.type_)
+            and not isinstance(field_info, params.Body)
+        ):
+            return False
+        if field.sub_fields:  # type: ignore[attr-defined]
+            if not all(
+                is_pv1_scalar_field(f)
+                for f in field.sub_fields  # type: ignore[attr-defined]
+            ):
+                return False
+        return True
+
+    def is_pv1_scalar_sequence_field(field: ModelField) -> bool:
+        if (field.shape in sequence_shapes) and not lenient_issubclass(  # type: ignore[attr-defined]
+            field.type_, BaseModel
+        ):
+            if field.sub_fields is not None:  # type: ignore[attr-defined]
+                for sub_field in field.sub_fields:  # type: ignore[attr-defined]
+                    if not is_pv1_scalar_field(sub_field):
+                        return False
+            return True
+        if _annotation_is_sequence(field.type_):
+            return True
+        return False
+
+    def _normalize_errors(errors: Sequence[Any]) -> List[Dict[str, Any]]:
+        use_errors: List[Any] = []
+        for error in errors:
+            if isinstance(error, ErrorWrapper):
+                new_errors = ValidationError(  # type: ignore[call-arg]
+                    errors=[error], model=RequestErrorModel
+                ).errors()
+                use_errors.extend(new_errors)
+            elif isinstance(error, list):
+                use_errors.extend(_normalize_errors(error))
+            else:
+                use_errors.append(error)
+        return use_errors
+
+    def _model_rebuild(model: Type[BaseModel]) -> None:
+        model.update_forward_refs()
+
+    def _model_dump(
+        model: BaseModel, mode: Literal["json", "python"] = "json", **kwargs: Any
+    ) -> Any:
+        return model.dict(**kwargs)
+
+    def _get_model_config(model: BaseModel) -> Any:
+        return model.__config__  # type: ignore[attr-defined]
+
+    def get_schema_from_model_field(
+        *,
+        field: ModelField,
+        schema_generator: GenerateJsonSchema,
+        model_name_map: ModelNameMap,
+        field_mapping: Dict[
+            Tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue
+        ],
+        separate_input_output_schemas: bool = True,
+    ) -> Dict[str, Any]:
+        # This expects that GenerateJsonSchema was already used to generate the definitions
+        return field_schema(  # type: ignore[no-any-return]
+            field, model_name_map=model_name_map, ref_prefix=REF_PREFIX
+        )[0]
+
+    def get_compat_model_name_map(fields: List[ModelField]) -> ModelNameMap:
+        models = get_flat_models_from_fields(fields, known_models=set())
+        return get_model_name_map(models)  # type: ignore[no-any-return]
+
+    def get_definitions(
+        *,
+        fields: List[ModelField],
+        schema_generator: GenerateJsonSchema,
+        model_name_map: ModelNameMap,
+        separate_input_output_schemas: bool = True,
+    ) -> Tuple[
+        Dict[
+            Tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue
+        ],
+        Dict[str, Dict[str, Any]],
+    ]:
+        models = get_flat_models_from_fields(fields, known_models=set())
+        return {}, get_model_definitions(
+            flat_models=models, model_name_map=model_name_map
+        )
+
+    def is_scalar_field(field: ModelField) -> bool:
+        return is_pv1_scalar_field(field)
+
+    def is_sequence_field(field: ModelField) -> bool:
+        return field.shape in sequence_shapes or _annotation_is_sequence(field.type_)  # type: ignore[attr-defined]
+
+    def is_scalar_sequence_field(field: ModelField) -> bool:
+        return is_pv1_scalar_sequence_field(field)
+
+    def is_bytes_field(field: ModelField) -> bool:
+        return lenient_issubclass(field.type_, bytes)
+
+    def is_bytes_sequence_field(field: ModelField) -> bool:
+        return field.shape in sequence_shapes and lenient_issubclass(field.type_, bytes)  # type: ignore[attr-defined]
+
+    def copy_field_info(*, field_info: FieldInfo, annotation: Any) -> FieldInfo:
+        return copy(field_info)
+
+    def serialize_sequence_value(*, field: ModelField, value: Any) -> Sequence[Any]:
+        return sequence_shape_to_type[field.shape](value)  # type: ignore[no-any-return,attr-defined]
+
+    def get_missing_field_error(loc: Tuple[str, ...]) -> Dict[str, Any]:
+        missing_field_error = ErrorWrapper(MissingError(), loc=loc)  # type: ignore[call-arg]
+        new_error = ValidationError([missing_field_error], RequestErrorModel)
+        return new_error.errors()[0]  # type: ignore[return-value]
+
+    def create_body_model(
+        *, fields: Sequence[ModelField], model_name: str
+    ) -> Type[BaseModel]:
+        BodyModel = create_model(model_name)
+        for f in fields:
+            BodyModel.__fields__[f.name] = f  # type: ignore[index]
+        return BodyModel
+
+    def get_model_fields(model: Type[BaseModel]) -> List[ModelField]:
+        return list(model.__fields__.values())  # type: ignore[attr-defined]
+
+
+def _regenerate_error_with_loc(
+    *, errors: Sequence[Any], loc_prefix: Tuple[Union[str, int], ...]
+) -> List[Dict[str, Any]]:
+    updated_loc_errors: List[Any] = [
+        {**err, "loc": loc_prefix + err.get("loc", ())}
+        for err in _normalize_errors(errors)
+    ]
+
+    return updated_loc_errors
+
+
+def _annotation_is_sequence(annotation: Union[Type[Any], None]) -> bool:
+    if lenient_issubclass(annotation, (str, bytes)):
+        return False
+    return lenient_issubclass(annotation, sequence_types)
+
+
+def field_annotation_is_sequence(annotation: Union[Type[Any], None]) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if field_annotation_is_sequence(arg):
+                return True
+        return False
+    return _annotation_is_sequence(annotation) or _annotation_is_sequence(
+        get_origin(annotation)
+    )
+
+
+def value_is_sequence(value: Any) -> bool:
+    return isinstance(value, sequence_types) and not isinstance(value, (str, bytes))  # type: ignore[arg-type]
+
+
+def _annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:
+    return (
+        lenient_issubclass(annotation, (BaseModel, Mapping, UploadFile))
+        or _annotation_is_sequence(annotation)
+        or is_dataclass(annotation)
+    )
+
+
+def field_annotation_is_complex(annotation: Union[Type[Any], None]) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        return any(field_annotation_is_complex(arg) for arg in get_args(annotation))
+
+    return (
+        _annotation_is_complex(annotation)
+        or _annotation_is_complex(origin)
+        or hasattr(origin, "__pydantic_core_schema__")
+        or hasattr(origin, "__get_pydantic_core_schema__")
+    )
+
+
+def field_annotation_is_scalar(annotation: Any) -> bool:
+    # handle Ellipsis here to make tuple[int, ...] work nicely
+    return annotation is Ellipsis or not field_annotation_is_complex(annotation)
+
+
+def field_annotation_is_scalar_sequence(annotation: Union[Type[Any], None]) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        at_least_one_scalar_sequence = False
+        for arg in get_args(annotation):
+            if field_annotation_is_scalar_sequence(arg):
+                at_least_one_scalar_sequence = True
+                continue
+            elif not field_annotation_is_scalar(arg):
+                return False
+        return at_least_one_scalar_sequence
+    return field_annotation_is_sequence(annotation) and all(
+        field_annotation_is_scalar(sub_annotation)
+        for sub_annotation in get_args(annotation)
+    )
+
+
+def is_bytes_or_nonable_bytes_annotation(annotation: Any) -> bool:
+    if lenient_issubclass(annotation, bytes):
+        return True
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if lenient_issubclass(arg, bytes):
+                return True
+    return False
+
+
+def is_uploadfile_or_nonable_uploadfile_annotation(annotation: Any) -> bool:
+    if lenient_issubclass(annotation, UploadFile):
+        return True
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        for arg in get_args(annotation):
+            if lenient_issubclass(arg, UploadFile):
+                return True
+    return False
+
+
+def is_bytes_sequence_annotation(annotation: Any) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        at_least_one = False
+        for arg in get_args(annotation):
+            if is_bytes_sequence_annotation(arg):
+                at_least_one = True
+                continue
+        return at_least_one
+    return field_annotation_is_sequence(annotation) and all(
+        is_bytes_or_nonable_bytes_annotation(sub_annotation)
+        for sub_annotation in get_args(annotation)
+    )
+
+
+def is_uploadfile_sequence_annotation(annotation: Any) -> bool:
+    origin = get_origin(annotation)
+    if origin is Union or origin is UnionType:
+        at_least_one = False
+        for arg in get_args(annotation):
+            if is_uploadfile_sequence_annotation(arg):
+                at_least_one = True
+                continue
+        return at_least_one
+    return field_annotation_is_sequence(annotation) and all(
+        is_uploadfile_or_nonable_uploadfile_annotation(sub_annotation)
+        for sub_annotation in get_args(annotation)
+    )
+
+
+@lru_cache
+def get_cached_model_fields(model: Type[BaseModel]) -> List[ModelField]:
+    return get_model_fields(model)

.venv/lib/python3.11/site-packages/fastapi/background.py

@@ -0,0 +1,59 @@
+from typing import Any, Callable
+
+from starlette.background import BackgroundTasks as StarletteBackgroundTasks
+from typing_extensions import Annotated, Doc, ParamSpec
+
+P = ParamSpec("P")
+
+
+class BackgroundTasks(StarletteBackgroundTasks):
+    """
+    A collection of background tasks that will be called after a response has been
+    sent to the client.
+
+    Read more about it in the
+    [FastAPI docs for Background Tasks](https://fastapi.tiangolo.com/tutorial/background-tasks/).
+
+    ## Example
+
+    ```python
+    from fastapi import BackgroundTasks, FastAPI
+
+    app = FastAPI()
+
+
+    def write_notification(email: str, message=""):
+        with open("log.txt", mode="w") as email_file:
+            content = f"notification for {email}: {message}"
+            email_file.write(content)
+
+
+    @app.post("/send-notification/{email}")
+    async def send_notification(email: str, background_tasks: BackgroundTasks):
+        background_tasks.add_task(write_notification, email, message="some notification")
+        return {"message": "Notification sent in the background"}
+    ```
+    """
+
+    def add_task(
+        self,
+        func: Annotated[
+            Callable[P, Any],
+            Doc(
+                """
+                The function to call after the response is sent.
+
+                It can be a regular `def` function or an `async def` function.
+                """
+            ),
+        ],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> None:
+        """
+        Add a function to be called in the background after the response is sent.
+
+        Read more about it in the
+        [FastAPI docs for Background Tasks](https://fastapi.tiangolo.com/tutorial/background-tasks/).
+        """
+        return super().add_task(func, *args, **kwargs)

.venv/lib/python3.11/site-packages/fastapi/cli.py

@@ -0,0 +1,13 @@
+try:
+    from fastapi_cli.cli import main as cli_main
+
+except ImportError:  # pragma: no cover
+    cli_main = None  # type: ignore
+
+
+def main() -> None:
+    if not cli_main:  # type: ignore[truthy-function]
+        message = 'To use the fastapi command, please install "fastapi[standard]":\n\n\tpip install "fastapi[standard]"\n'
+        print(message)
+        raise RuntimeError(message)  # noqa: B904
+    cli_main()

.venv/lib/python3.11/site-packages/fastapi/concurrency.py

@@ -0,0 +1,39 @@
+from contextlib import asynccontextmanager as asynccontextmanager
+from typing import AsyncGenerator, ContextManager, TypeVar
+
+import anyio.to_thread
+from anyio import CapacityLimiter
+from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool  # noqa
+from starlette.concurrency import run_in_threadpool as run_in_threadpool  # noqa
+from starlette.concurrency import (  # noqa
+    run_until_first_complete as run_until_first_complete,
+)
+
+_T = TypeVar("_T")
+
+
+@asynccontextmanager
+async def contextmanager_in_threadpool(
+    cm: ContextManager[_T],
+) -> AsyncGenerator[_T, None]:
+    # blocking __exit__ from running waiting on a free thread
+    # can create race conditions/deadlocks if the context manager itself
+    # has its own internal pool (e.g. a database connection pool)
+    # to avoid this we let __exit__ run without a capacity limit
+    # since we're creating a new limiter for each call, any non-zero limit
+    # works (1 is arbitrary)
+    exit_limiter = CapacityLimiter(1)
+    try:
+        yield await run_in_threadpool(cm.__enter__)
+    except Exception as e:
+        ok = bool(
+            await anyio.to_thread.run_sync(
+                cm.__exit__, type(e), e, e.__traceback__, limiter=exit_limiter
+            )
+        )
+        if not ok:
+            raise e
+    else:
+        await anyio.to_thread.run_sync(
+            cm.__exit__, None, None, None, limiter=exit_limiter
+        )

.venv/lib/python3.11/site-packages/fastapi/datastructures.py

@@ -0,0 +1,204 @@
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    Dict,
+    Iterable,
+    Optional,
+    Type,
+    TypeVar,
+    cast,
+)
+
+from fastapi._compat import (
+    PYDANTIC_V2,
+    CoreSchema,
+    GetJsonSchemaHandler,
+    JsonSchemaValue,
+    with_info_plain_validator_function,
+)
+from starlette.datastructures import URL as URL  # noqa: F401
+from starlette.datastructures import Address as Address  # noqa: F401
+from starlette.datastructures import FormData as FormData  # noqa: F401
+from starlette.datastructures import Headers as Headers  # noqa: F401
+from starlette.datastructures import QueryParams as QueryParams  # noqa: F401
+from starlette.datastructures import State as State  # noqa: F401
+from starlette.datastructures import UploadFile as StarletteUploadFile
+from typing_extensions import Annotated, Doc
+
+
+class UploadFile(StarletteUploadFile):
+    """
+    A file uploaded in a request.
+
+    Define it as a *path operation function* (or dependency) parameter.
+
+    If you are using a regular `def` function, you can use the `upload_file.file`
+    attribute to access the raw standard Python file (blocking, not async), useful and
+    needed for non-async code.
+
+    Read more about it in the
+    [FastAPI docs for Request Files](https://fastapi.tiangolo.com/tutorial/request-files/).
+
+    ## Example
+
+    ```python
+    from typing import Annotated
+
+    from fastapi import FastAPI, File, UploadFile
+
+    app = FastAPI()
+
+
+    @app.post("/files/")
+    async def create_file(file: Annotated[bytes, File()]):
+        return {"file_size": len(file)}
+
+
+    @app.post("/uploadfile/")
+    async def create_upload_file(file: UploadFile):
+        return {"filename": file.filename}
+    ```
+    """
+
+    file: Annotated[
+        BinaryIO,
+        Doc("The standard Python file object (non-async)."),
+    ]
+    filename: Annotated[Optional[str], Doc("The original file name.")]
+    size: Annotated[Optional[int], Doc("The size of the file in bytes.")]
+    headers: Annotated[Headers, Doc("The headers of the request.")]
+    content_type: Annotated[
+        Optional[str], Doc("The content type of the request, from the headers.")
+    ]
+
+    async def write(
+        self,
+        data: Annotated[
+            bytes,
+            Doc(
+                """
+                The bytes to write to the file.
+                """
+            ),
+        ],
+    ) -> None:
+        """
+        Write some bytes to the file.
+
+        You normally wouldn't use this from a file you read in a request.
+
+        To be awaitable, compatible with async, this is run in threadpool.
+        """
+        return await super().write(data)
+
+    async def read(
+        self,
+        size: Annotated[
+            int,
+            Doc(
+                """
+                The number of bytes to read from the file.
+                """
+            ),
+        ] = -1,
+    ) -> bytes:
+        """
+        Read some bytes from the file.
+
+        To be awaitable, compatible with async, this is run in threadpool.
+        """
+        return await super().read(size)
+
+    async def seek(
+        self,
+        offset: Annotated[
+            int,
+            Doc(
+                """
+                The position in bytes to seek to in the file.
+                """
+            ),
+        ],
+    ) -> None:
+        """
+        Move to a position in the file.
+
+        Any next read or write will be done from that position.
+
+        To be awaitable, compatible with async, this is run in threadpool.
+        """
+        return await super().seek(offset)
+
+    async def close(self) -> None:
+        """
+        Close the file.
+
+        To be awaitable, compatible with async, this is run in threadpool.
+        """
+        return await super().close()
+
+    @classmethod
+    def __get_validators__(cls: Type["UploadFile"]) -> Iterable[Callable[..., Any]]:
+        yield cls.validate
+
+    @classmethod
+    def validate(cls: Type["UploadFile"], v: Any) -> Any:
+        if not isinstance(v, StarletteUploadFile):
+            raise ValueError(f"Expected UploadFile, received: {type(v)}")
+        return v
+
+    @classmethod
+    def _validate(cls, __input_value: Any, _: Any) -> "UploadFile":
+        if not isinstance(__input_value, StarletteUploadFile):
+            raise ValueError(f"Expected UploadFile, received: {type(__input_value)}")
+        return cast(UploadFile, __input_value)
+
+    if not PYDANTIC_V2:
+
+        @classmethod
+        def __modify_schema__(cls, field_schema: Dict[str, Any]) -> None:
+            field_schema.update({"type": "string", "format": "binary"})
+
+    @classmethod
+    def __get_pydantic_json_schema__(
+        cls, core_schema: CoreSchema, handler: GetJsonSchemaHandler
+    ) -> JsonSchemaValue:
+        return {"type": "string", "format": "binary"}
+
+    @classmethod
+    def __get_pydantic_core_schema__(
+        cls, source: Type[Any], handler: Callable[[Any], CoreSchema]
+    ) -> CoreSchema:
+        return with_info_plain_validator_function(cls._validate)
+
+
+class DefaultPlaceholder:
+    """
+    You shouldn't use this class directly.
+
+    It's used internally to recognize when a default value has been overwritten, even
+    if the overridden default value was truthy.
+    """
+
+    def __init__(self, value: Any):
+        self.value = value
+
+    def __bool__(self) -> bool:
+        return bool(self.value)
+
+    def __eq__(self, o: object) -> bool:
+        return isinstance(o, DefaultPlaceholder) and o.value == self.value
+
+
+DefaultType = TypeVar("DefaultType")
+
+
+def Default(value: DefaultType) -> DefaultType:
+    """
+    You shouldn't use this function directly.
+
+    It's used internally to recognize when a default value has been overwritten, even
+    if the overridden default value was truthy.
+    """
+    return DefaultPlaceholder(value)  # type: ignore

.venv/lib/python3.11/site-packages/fastapi/encoders.py

@@ -0,0 +1,343 @@
+import dataclasses
+import datetime
+from collections import defaultdict, deque
+from decimal import Decimal
+from enum import Enum
+from ipaddress import (
+    IPv4Address,
+    IPv4Interface,
+    IPv4Network,
+    IPv6Address,
+    IPv6Interface,
+    IPv6Network,
+)
+from pathlib import Path, PurePath
+from re import Pattern
+from types import GeneratorType
+from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union
+from uuid import UUID
+
+from fastapi.types import IncEx
+from pydantic import BaseModel
+from pydantic.color import Color
+from pydantic.networks import AnyUrl, NameEmail
+from pydantic.types import SecretBytes, SecretStr
+from typing_extensions import Annotated, Doc
+
+from ._compat import PYDANTIC_V2, UndefinedType, Url, _model_dump
+
+
+# Taken from Pydantic v1 as is
+def isoformat(o: Union[datetime.date, datetime.time]) -> str:
+    return o.isoformat()
+
+
+# Taken from Pydantic v1 as is
+# TODO: pv2 should this return strings instead?
+def decimal_encoder(dec_value: Decimal) -> Union[int, float]:
+    """
+    Encodes a Decimal as int of there's no exponent, otherwise float
+
+    This is useful when we use ConstrainedDecimal to represent Numeric(x,0)
+    where a integer (but not int typed) is used. Encoding this as a float
+    results in failed round-tripping between encode and parse.
+    Our Id type is a prime example of this.
+
+    >>> decimal_encoder(Decimal("1.0"))
+    1.0
+
+    >>> decimal_encoder(Decimal("1"))
+    1
+    """
+    if dec_value.as_tuple().exponent >= 0:  # type: ignore[operator]
+        return int(dec_value)
+    else:
+        return float(dec_value)
+
+
+ENCODERS_BY_TYPE: Dict[Type[Any], Callable[[Any], Any]] = {
+    bytes: lambda o: o.decode(),
+    Color: str,
+    datetime.date: isoformat,
+    datetime.datetime: isoformat,
+    datetime.time: isoformat,
+    datetime.timedelta: lambda td: td.total_seconds(),
+    Decimal: decimal_encoder,
+    Enum: lambda o: o.value,
+    frozenset: list,
+    deque: list,
+    GeneratorType: list,
+    IPv4Address: str,
+    IPv4Interface: str,
+    IPv4Network: str,
+    IPv6Address: str,
+    IPv6Interface: str,
+    IPv6Network: str,
+    NameEmail: str,
+    Path: str,
+    Pattern: lambda o: o.pattern,
+    SecretBytes: str,
+    SecretStr: str,
+    set: list,
+    UUID: str,
+    Url: str,
+    AnyUrl: str,
+}
+
+
+def generate_encoders_by_class_tuples(
+    type_encoder_map: Dict[Any, Callable[[Any], Any]],
+) -> Dict[Callable[[Any], Any], Tuple[Any, ...]]:
+    encoders_by_class_tuples: Dict[Callable[[Any], Any], Tuple[Any, ...]] = defaultdict(
+        tuple
+    )
+    for type_, encoder in type_encoder_map.items():
+        encoders_by_class_tuples[encoder] += (type_,)
+    return encoders_by_class_tuples
+
+
+encoders_by_class_tuples = generate_encoders_by_class_tuples(ENCODERS_BY_TYPE)
+
+
+def jsonable_encoder(
+    obj: Annotated[
+        Any,
+        Doc(
+            """
+            The input object to convert to JSON.
+            """
+        ),
+    ],
+    include: Annotated[
+        Optional[IncEx],
+        Doc(
+            """
+            Pydantic's `include` parameter, passed to Pydantic models to set the
+            fields to include.
+            """
+        ),
+    ] = None,
+    exclude: Annotated[
+        Optional[IncEx],
+        Doc(
+            """
+            Pydantic's `exclude` parameter, passed to Pydantic models to set the
+            fields to exclude.
+            """
+        ),
+    ] = None,
+    by_alias: Annotated[
+        bool,
+        Doc(
+            """
+            Pydantic's `by_alias` parameter, passed to Pydantic models to define if
+            the output should use the alias names (when provided) or the Python
+            attribute names. In an API, if you set an alias, it's probably because you
+            want to use it in the result, so you probably want to leave this set to
+            `True`.
+            """
+        ),
+    ] = True,
+    exclude_unset: Annotated[
+        bool,
+        Doc(
+            """
+            Pydantic's `exclude_unset` parameter, passed to Pydantic models to define
+            if it should exclude from the output the fields that were not explicitly
+            set (and that only had their default values).
+            """
+        ),
+    ] = False,
+    exclude_defaults: Annotated[
+        bool,
+        Doc(
+            """
+            Pydantic's `exclude_defaults` parameter, passed to Pydantic models to define
+            if it should exclude from the output the fields that had the same default
+            value, even when they were explicitly set.
+            """
+        ),
+    ] = False,
+    exclude_none: Annotated[
+        bool,
+        Doc(
+            """
+            Pydantic's `exclude_none` parameter, passed to Pydantic models to define
+            if it should exclude from the output any fields that have a `None` value.
+            """
+        ),
+    ] = False,
+    custom_encoder: Annotated[
+        Optional[Dict[Any, Callable[[Any], Any]]],
+        Doc(
+            """
+            Pydantic's `custom_encoder` parameter, passed to Pydantic models to define
+            a custom encoder.
+            """
+        ),
+    ] = None,
+    sqlalchemy_safe: Annotated[
+        bool,
+        Doc(
+            """
+            Exclude from the output any fields that start with the name `_sa`.
+
+            This is mainly a hack for compatibility with SQLAlchemy objects, they
+            store internal SQLAlchemy-specific state in attributes named with `_sa`,
+            and those objects can't (and shouldn't be) serialized to JSON.
+            """
+        ),
+    ] = True,
+) -> Any:
+    """
+    Convert any object to something that can be encoded in JSON.
+
+    This is used internally by FastAPI to make sure anything you return can be
+    encoded as JSON before it is sent to the client.
+
+    You can also use it yourself, for example to convert objects before saving them
+    in a database that supports only JSON.
+
+    Read more about it in the
+    [FastAPI docs for JSON Compatible Encoder](https://fastapi.tiangolo.com/tutorial/encoder/).
+    """
+    custom_encoder = custom_encoder or {}
+    if custom_encoder:
+        if type(obj) in custom_encoder:
+            return custom_encoder[type(obj)](obj)
+        else:
+            for encoder_type, encoder_instance in custom_encoder.items():
+                if isinstance(obj, encoder_type):
+                    return encoder_instance(obj)
+    if include is not None and not isinstance(include, (set, dict)):
+        include = set(include)
+    if exclude is not None and not isinstance(exclude, (set, dict)):
+        exclude = set(exclude)
+    if isinstance(obj, BaseModel):
+        # TODO: remove when deprecating Pydantic v1
+        encoders: Dict[Any, Any] = {}
+        if not PYDANTIC_V2:
+            encoders = getattr(obj.__config__, "json_encoders", {})  # type: ignore[attr-defined]
+            if custom_encoder:
+                encoders.update(custom_encoder)
+        obj_dict = _model_dump(
+            obj,
+            mode="json",
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+        )
+        if "__root__" in obj_dict:
+            obj_dict = obj_dict["__root__"]
+        return jsonable_encoder(
+            obj_dict,
+            exclude_none=exclude_none,
+            exclude_defaults=exclude_defaults,
+            # TODO: remove when deprecating Pydantic v1
+            custom_encoder=encoders,
+            sqlalchemy_safe=sqlalchemy_safe,
+        )
+    if dataclasses.is_dataclass(obj):
+        obj_dict = dataclasses.asdict(obj)
+        return jsonable_encoder(
+            obj_dict,
+            include=include,
+            exclude=exclude,
+            by_alias=by_alias,
+            exclude_unset=exclude_unset,
+            exclude_defaults=exclude_defaults,
+            exclude_none=exclude_none,
+            custom_encoder=custom_encoder,
+            sqlalchemy_safe=sqlalchemy_safe,
+        )
+    if isinstance(obj, Enum):
+        return obj.value
+    if isinstance(obj, PurePath):
+        return str(obj)
+    if isinstance(obj, (str, int, float, type(None))):
+        return obj
+    if isinstance(obj, UndefinedType):
+        return None
+    if isinstance(obj, dict):
+        encoded_dict = {}
+        allowed_keys = set(obj.keys())
+        if include is not None:
+            allowed_keys &= set(include)
+        if exclude is not None:
+            allowed_keys -= set(exclude)
+        for key, value in obj.items():
+            if (
+                (
+                    not sqlalchemy_safe
+                    or (not isinstance(key, str))
+                    or (not key.startswith("_sa"))
+                )
+                and (value is not None or not exclude_none)
+                and key in allowed_keys
+            ):
+                encoded_key = jsonable_encoder(
+                    key,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+                encoded_value = jsonable_encoder(
+                    value,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+                encoded_dict[encoded_key] = encoded_value
+        return encoded_dict
+    if isinstance(obj, (list, set, frozenset, GeneratorType, tuple, deque)):
+        encoded_list = []
+        for item in obj:
+            encoded_list.append(
+                jsonable_encoder(
+                    item,
+                    include=include,
+                    exclude=exclude,
+                    by_alias=by_alias,
+                    exclude_unset=exclude_unset,
+                    exclude_defaults=exclude_defaults,
+                    exclude_none=exclude_none,
+                    custom_encoder=custom_encoder,
+                    sqlalchemy_safe=sqlalchemy_safe,
+                )
+            )
+        return encoded_list
+
+    if type(obj) in ENCODERS_BY_TYPE:
+        return ENCODERS_BY_TYPE[type(obj)](obj)
+    for encoder, classes_tuple in encoders_by_class_tuples.items():
+        if isinstance(obj, classes_tuple):
+            return encoder(obj)
+
+    try:
+        data = dict(obj)
+    except Exception as e:
+        errors: List[Exception] = []
+        errors.append(e)
+        try:
+            data = vars(obj)
+        except Exception as e:
+            errors.append(e)
+            raise ValueError(errors) from e
+    return jsonable_encoder(
+        data,
+        include=include,
+        exclude=exclude,
+        by_alias=by_alias,
+        exclude_unset=exclude_unset,
+        exclude_defaults=exclude_defaults,
+        exclude_none=exclude_none,
+        custom_encoder=custom_encoder,
+        sqlalchemy_safe=sqlalchemy_safe,
+    )

.venv/lib/python3.11/site-packages/fastapi/exception_handlers.py

@@ -0,0 +1,34 @@
+from fastapi.encoders import jsonable_encoder
+from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError
+from fastapi.utils import is_body_allowed_for_status_code
+from fastapi.websockets import WebSocket
+from starlette.exceptions import HTTPException
+from starlette.requests import Request
+from starlette.responses import JSONResponse, Response
+from starlette.status import HTTP_422_UNPROCESSABLE_ENTITY, WS_1008_POLICY_VIOLATION
+
+
+async def http_exception_handler(request: Request, exc: HTTPException) -> Response:
+    headers = getattr(exc, "headers", None)
+    if not is_body_allowed_for_status_code(exc.status_code):
+        return Response(status_code=exc.status_code, headers=headers)
+    return JSONResponse(
+        {"detail": exc.detail}, status_code=exc.status_code, headers=headers
+    )
+
+
+async def request_validation_exception_handler(
+    request: Request, exc: RequestValidationError
+) -> JSONResponse:
+    return JSONResponse(
+        status_code=HTTP_422_UNPROCESSABLE_ENTITY,
+        content={"detail": jsonable_encoder(exc.errors())},
+    )
+
+
+async def websocket_request_validation_exception_handler(
+    websocket: WebSocket, exc: WebSocketRequestValidationError
+) -> None:
+    await websocket.close(
+        code=WS_1008_POLICY_VIOLATION, reason=jsonable_encoder(exc.errors())
+    )

.venv/lib/python3.11/site-packages/fastapi/exceptions.py

@@ -0,0 +1,176 @@
+from typing import Any, Dict, Optional, Sequence, Type, Union
+
+from pydantic import BaseModel, create_model
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.exceptions import WebSocketException as StarletteWebSocketException
+from typing_extensions import Annotated, Doc
+
+
+class HTTPException(StarletteHTTPException):
+    """
+    An HTTP exception you can raise in your own code to show errors to the client.
+
+    This is for client errors, invalid authentication, invalid data, etc. Not for server
+    errors in your code.
+
+    Read more about it in the
+    [FastAPI docs for Handling Errors](https://fastapi.tiangolo.com/tutorial/handling-errors/).
+
+    ## Example
+
+    ```python
+    from fastapi import FastAPI, HTTPException
+
+    app = FastAPI()
+
+    items = {"foo": "The Foo Wrestlers"}
+
+
+    @app.get("/items/{item_id}")
+    async def read_item(item_id: str):
+        if item_id not in items:
+            raise HTTPException(status_code=404, detail="Item not found")
+        return {"item": items[item_id]}
+    ```
+    """
+
+    def __init__(
+        self,
+        status_code: Annotated[
+            int,
+            Doc(
+                """
+                HTTP status code to send to the client.
+                """
+            ),
+        ],
+        detail: Annotated[
+            Any,
+            Doc(
+                """
+                Any data to be sent to the client in the `detail` key of the JSON
+                response.
+                """
+            ),
+        ] = None,
+        headers: Annotated[
+            Optional[Dict[str, str]],
+            Doc(
+                """
+                Any headers to send to the client in the response.
+                """
+            ),
+        ] = None,
+    ) -> None:
+        super().__init__(status_code=status_code, detail=detail, headers=headers)
+
+
+class WebSocketException(StarletteWebSocketException):
+    """
+    A WebSocket exception you can raise in your own code to show errors to the client.
+
+    This is for client errors, invalid authentication, invalid data, etc. Not for server
+    errors in your code.
+
+    Read more about it in the
+    [FastAPI docs for WebSockets](https://fastapi.tiangolo.com/advanced/websockets/).
+
+    ## Example
+
+    ```python
+    from typing import Annotated
+
+    from fastapi import (
+        Cookie,
+        FastAPI,
+        WebSocket,
+        WebSocketException,
+        status,
+    )
+
+    app = FastAPI()
+
+    @app.websocket("/items/{item_id}/ws")
+    async def websocket_endpoint(
+        *,
+        websocket: WebSocket,
+        session: Annotated[str | None, Cookie()] = None,
+        item_id: str,
+    ):
+        if session is None:
+            raise WebSocketException(code=status.WS_1008_POLICY_VIOLATION)
+        await websocket.accept()
+        while True:
+            data = await websocket.receive_text()
+            await websocket.send_text(f"Session cookie is: {session}")
+            await websocket.send_text(f"Message text was: {data}, for item ID: {item_id}")
+    ```
+    """
+
+    def __init__(
+        self,
+        code: Annotated[
+            int,
+            Doc(
+                """
+                A closing code from the
+                [valid codes defined in the specification](https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1).
+                """
+            ),
+        ],
+        reason: Annotated[
+            Union[str, None],
+            Doc(
+                """
+                The reason to close the WebSocket connection.
+
+                It is UTF-8-encoded data. The interpretation of the reason is up to the
+                application, it is not specified by the WebSocket specification.
+
+                It could contain text that could be human-readable or interpretable
+                by the client code, etc.
+                """
+            ),
+        ] = None,
+    ) -> None:
+        super().__init__(code=code, reason=reason)
+
+
+RequestErrorModel: Type[BaseModel] = create_model("Request")
+WebSocketErrorModel: Type[BaseModel] = create_model("WebSocket")
+
+
+class FastAPIError(RuntimeError):
+    """
+    A generic, FastAPI-specific error.
+    """
+
+
+class ValidationException(Exception):
+    def __init__(self, errors: Sequence[Any]) -> None:
+        self._errors = errors
+
+    def errors(self) -> Sequence[Any]:
+        return self._errors
+
+
+class RequestValidationError(ValidationException):
+    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:
+        super().__init__(errors)
+        self.body = body
+
+
+class WebSocketRequestValidationError(ValidationException):
+    pass
+
+
+class ResponseValidationError(ValidationException):
+    def __init__(self, errors: Sequence[Any], *, body: Any = None) -> None:
+        super().__init__(errors)
+        self.body = body
+
+    def __str__(self) -> str:
+        message = f"{len(self._errors)} validation errors:\n"
+        for err in self._errors:
+            message += f"  {err}\n"
+        return message

.venv/lib/python3.11/site-packages/fastapi/logger.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("fastapi")

.venv/lib/python3.11/site-packages/fastapi/middleware/__init__.py

@@ -0,0 +1 @@
+from starlette.middleware import Middleware as Middleware