Add files using upload-large-folder tool

venv/Lib/site-packages/decorator.py

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

venv/Lib/site-packages/ipykernel_launcher.py

@@ -0,0 +1,18 @@
+"""Entry point for launching an IPython kernel.
+
+This is separate from the ipykernel package so we can avoid doing imports until
+after removing the cwd from sys.path.
+"""
+
+import sys
+from pathlib import Path
+
+if __name__ == "__main__":
+    # Remove the CWD from sys.path while we load stuff.
+    # This is added back by InteractiveShellApp.init_path()
+    if sys.path[0] == "" or Path(sys.path[0]) == Path.cwd():
+        del sys.path[0]
+
+    from ipykernel import kernelapp as app
+
+    app.launch_new_instance()

venv/Lib/site-packages/ipython_pygments_lexers.py

@@ -0,0 +1,582 @@
+# -*- coding: utf-8 -*-
+"""
+Defines a variety of Pygments lexers for highlighting IPython code.
+
+This includes:
+
+    IPythonLexer, IPython3Lexer
+        Lexers for pure IPython (python + magic/shell commands)
+
+    IPythonPartialTracebackLexer, IPythonTracebackLexer
+        Supports 2.x and 3.x via keyword `python3`.  The partial traceback
+        lexer reads everything but the Python code appearing in a traceback.
+        The full lexer combines the partial lexer with an IPython lexer.
+
+    IPythonConsoleLexer
+        A lexer for IPython console sessions, with support for tracebacks.
+
+    IPyLexer
+        A friendly lexer which examines the first line of text and from it,
+        decides whether to use an IPython lexer or an IPython console lexer.
+        This is probably the only lexer that needs to be explicitly added
+        to Pygments.
+
+"""
+# -----------------------------------------------------------------------------
+# Copyright (c) 2013, the IPython Development Team.
+#
+# Distributed under the terms of the Modified BSD License.
+#
+# The full license is in the file COPYING.txt, distributed with this software.
+# -----------------------------------------------------------------------------
+
+__version__ = "1.1.1"
+
+# Standard library
+import re
+
+# Third party
+from pygments.lexers import (
+    BashLexer,
+    HtmlLexer,
+    JavascriptLexer,
+    RubyLexer,
+    PerlLexer,
+    Python2Lexer,
+    Python3Lexer,
+    TexLexer,
+)
+from pygments.lexer import (
+    Lexer,
+    DelegatingLexer,
+    RegexLexer,
+    do_insertions,
+    bygroups,
+    using,
+)
+from pygments.token import (
+    Generic,
+    Keyword,
+    Literal,
+    Name,
+    Operator,
+    Other,
+    Text,
+    Error,
+)
+
+
+line_re = re.compile(".*?\n")
+
+__all__ = [
+    "IPython3Lexer",
+    "IPythonLexer",
+    "IPythonPartialTracebackLexer",
+    "IPythonTracebackLexer",
+    "IPythonConsoleLexer",
+    "IPyLexer",
+]
+
+
+ipython_tokens = [
+    (
+        r"(?s)(\s*)(%%capture)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%debug)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (
+        r"(?is)(\s*)(%%html)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(HtmlLexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%javascript)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(JavascriptLexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%js)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(JavascriptLexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%latex)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(TexLexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%perl)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(PerlLexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%prun)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%pypy)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%python2)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python2Lexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%python3)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%python)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%ruby)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(RubyLexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%timeit)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%time)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%writefile)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (
+        r"(?s)(\s*)(%%file)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(Python3Lexer)),
+    ),
+    (r"(?s)(\s*)(%%)(\w+)(.*)", bygroups(Text, Operator, Keyword, Text)),
+    (
+        r"(?s)(^\s*)(%%!)([^\n]*\n)(.*)",
+        bygroups(Text, Operator, Text, using(BashLexer)),
+    ),
+    (r"(%%?)(\w+)(\?\??)$", bygroups(Operator, Keyword, Operator)),
+    (r"\b(\?\??)(\s*)$", bygroups(Operator, Text)),
+    (r"(%)(sx|sc|system)(.*)(\n)", bygroups(Operator, Keyword, using(BashLexer), Text)),
+    (r"(%)(\w+)(.*\n)", bygroups(Operator, Keyword, Text)),
+    (r"^(!!)(.+)(\n)", bygroups(Operator, using(BashLexer), Text)),
+    (r"(!)(?!=)(.+)(\n)", bygroups(Operator, using(BashLexer), Text)),
+    (r"^(\s*)(\?\??)(\s*%{0,2}[\w\.\*]*)", bygroups(Text, Operator, Text)),
+    (r"(\s*%{0,2}[\w\.\*]*)(\?\??)(\s*)$", bygroups(Text, Operator, Text)),
+]
+
+
+class IPython3Lexer(Python3Lexer):
+    """IPython code lexer (based on Python 3)"""
+
+    name = "IPython"
+    aliases = ["ipython", "ipython3"]
+
+    tokens = Python3Lexer.tokens.copy()
+    tokens["root"] = ipython_tokens + tokens["root"]
+
+
+IPythonLexer = IPython3Lexer
+
+
+class IPythonPartialTracebackLexer(RegexLexer):
+    """
+    Partial lexer for IPython tracebacks.
+
+    Handles all the non-python output.
+
+    """
+
+    name = "IPython Partial Traceback"
+
+    tokens = {
+        "root": [
+            # Tracebacks for syntax errors have a different style.
+            # For both types of tracebacks, we mark the first line with
+            # Generic.Traceback.  For syntax errors, we mark the filename
+            # as we mark the filenames for non-syntax tracebacks.
+            #
+            # These two regexps define how IPythonConsoleLexer finds a
+            # traceback.
+            #
+            ## Non-syntax traceback
+            (r"^(\^C)?(-+\n)", bygroups(Error, Generic.Traceback)),
+            ## Syntax traceback
+            (
+                r"^(  File)(.*)(, line )(\d+\n)",
+                bygroups(
+                    Generic.Traceback,
+                    Name.Namespace,
+                    Generic.Traceback,
+                    Literal.Number.Integer,
+                ),
+            ),
+            # (Exception Identifier)(Whitespace)(Traceback Message)
+            (
+                r"(?u)(^[^\d\W]\w*)(\s*)(Traceback.*?\n)",
+                bygroups(Name.Exception, Generic.Whitespace, Text),
+            ),
+            # (Module/Filename)(Text)(Callee)(Function Signature)
+            # Better options for callee and function signature?
+            (
+                r"(.*)( in )(.*)(\(.*\)\n)",
+                bygroups(Name.Namespace, Text, Name.Entity, Name.Tag),
+            ),
+            # Regular line: (Whitespace)(Line Number)(Python Code)
+            (
+                r"(\s*?)(\d+)(.*?\n)",
+                bygroups(Generic.Whitespace, Literal.Number.Integer, Other),
+            ),
+            # Emphasized line: (Arrow)(Line Number)(Python Code)
+            # Using Exception token so arrow color matches the Exception.
+            (
+                r"(-*>?\s?)(\d+)(.*?\n)",
+                bygroups(Name.Exception, Literal.Number.Integer, Other),
+            ),
+            # (Exception Identifier)(Message)
+            (r"(?u)(^[^\d\W]\w*)(:.*?\n)", bygroups(Name.Exception, Text)),
+            # Tag everything else as Other, will be handled later.
+            (r".*\n", Other),
+        ],
+    }
+
+
+class IPythonTracebackLexer(DelegatingLexer):
+    """
+    IPython traceback lexer.
+
+    For doctests, the tracebacks can be snipped as much as desired with the
+    exception to the lines that designate a traceback. For non-syntax error
+    tracebacks, this is the line of hyphens. For syntax error tracebacks,
+    this is the line which lists the File and line number.
+
+    """
+
+    # The lexer inherits from DelegatingLexer.  The "root" lexer is an
+    # appropriate IPython lexer, which depends on the value of the boolean
+    # `python3`.  First, we parse with the partial IPython traceback lexer.
+    # Then, any code marked with the "Other" token is delegated to the root
+    # lexer.
+    #
+    name = "IPython Traceback"
+    aliases = ["ipythontb", "ipython3tb"]
+
+    def __init__(self, **options):
+        """
+        A subclass of `DelegatingLexer` which delegates to the appropriate to either IPyLexer,
+        IPythonPartialTracebackLexer.
+        """
+        # note we need a __init__ doc, as otherwise it inherits the doc from the super class
+        # which will fail the documentation build as it references section of the pygments docs that
+        # do not exists when building IPython's docs.
+        DelegatingLexer.__init__(
+            self, IPython3Lexer, IPythonPartialTracebackLexer, **options
+        )
+
+
+class IPythonConsoleLexer(Lexer):
+    """
+    An IPython console lexer for IPython code-blocks and doctests, such as:
+
+    .. code-block:: rst
+
+        .. code-block:: ipythonconsole
+
+            In [1]: a = 'foo'
+
+            In [2]: a
+            Out[2]: 'foo'
+
+            In [3]: print(a)
+            foo
+
+
+    Support is also provided for IPython exceptions:
+
+    .. code-block:: rst
+
+        .. code-block:: ipythonconsole
+
+            In [1]: raise Exception
+            Traceback (most recent call last):
+            ...
+            Exception
+
+    """
+
+    name = "IPython console session"
+    aliases = ["ipythonconsole", "ipython3console"]
+    mimetypes = ["text/x-ipython-console"]
+
+    # The regexps used to determine what is input and what is output.
+    # The default prompts for IPython are:
+    #
+    #    in           = 'In [#]: '
+    #    continuation = '   .D.: '
+    #    template     = 'Out[#]: '
+    #
+    # Where '#' is the 'prompt number' or 'execution count' and 'D'
+    # D is a number of dots  matching the width of the execution count
+    #
+    in1_regex = r"In \[[0-9]+\]: "
+    in2_regex = r"   \.\.+\.: "
+    out_regex = r"Out\[[0-9]+\]: "
+
+    #: The regex to determine when a traceback starts.
+    ipytb_start = re.compile(r"^(\^C)?(-+\n)|^(  File)(.*)(, line )(\d+\n)")
+
+    def __init__(self, **options):
+        """Initialize the IPython console lexer.
+
+        Parameters
+        ----------
+        in1_regex : RegexObject
+            The compiled regular expression used to detect the start
+            of inputs. Although the IPython configuration setting may have a
+            trailing whitespace, do not include it in the regex. If `None`,
+            then the default input prompt is assumed.
+        in2_regex : RegexObject
+            The compiled regular expression used to detect the continuation
+            of inputs. Although the IPython configuration setting may have a
+            trailing whitespace, do not include it in the regex. If `None`,
+            then the default input prompt is assumed.
+        out_regex : RegexObject
+            The compiled regular expression used to detect outputs. If `None`,
+            then the default output prompt is assumed.
+
+        """
+        in1_regex = options.get("in1_regex", self.in1_regex)
+        in2_regex = options.get("in2_regex", self.in2_regex)
+        out_regex = options.get("out_regex", self.out_regex)
+
+        # So that we can work with input and output prompts which have been
+        # rstrip'd (possibly by editors) we also need rstrip'd variants. If
+        # we do not do this, then such prompts will be tagged as 'output'.
+        # The reason can't just use the rstrip'd variants instead is because
+        # we want any whitespace associated with the prompt to be inserted
+        # with the token. This allows formatted code to be modified so as hide
+        # the appearance of prompts, with the whitespace included. One example
+        # use of this is in copybutton.js from the standard lib Python docs.
+        in1_regex_rstrip = in1_regex.rstrip() + "\n"
+        in2_regex_rstrip = in2_regex.rstrip() + "\n"
+        out_regex_rstrip = out_regex.rstrip() + "\n"
+
+        # Compile and save them all.
+        attrs = [
+            "in1_regex",
+            "in2_regex",
+            "out_regex",
+            "in1_regex_rstrip",
+            "in2_regex_rstrip",
+            "out_regex_rstrip",
+        ]
+        for attr in attrs:
+            self.__setattr__(attr, re.compile(locals()[attr]))
+
+        Lexer.__init__(self, **options)
+
+        self.pylexer = IPython3Lexer(**options)
+        self.tblexer = IPythonTracebackLexer(**options)
+
+        self.reset()
+
+    def reset(self):
+        self.mode = "output"
+        self.index = 0
+        self.buffer = ""
+        self.insertions = []
+
+    def buffered_tokens(self):
+        """
+        Generator of unprocessed tokens after doing insertions and before
+        changing to a new state.
+
+        """
+        if self.mode == "output":
+            tokens = [(0, Generic.Output, self.buffer)]
+        elif self.mode == "input":
+            tokens = self.pylexer.get_tokens_unprocessed(self.buffer)
+        else:  # traceback
+            tokens = self.tblexer.get_tokens_unprocessed(self.buffer)
+
+        for i, t, v in do_insertions(self.insertions, tokens):
+            # All token indexes are relative to the buffer.
+            yield self.index + i, t, v
+
+        # Clear it all
+        self.index += len(self.buffer)
+        self.buffer = ""
+        self.insertions = []
+
+    def get_mci(self, line):
+        """
+        Parses the line and returns a 3-tuple: (mode, code, insertion).
+
+        `mode` is the next mode (or state) of the lexer, and is always equal
+        to 'input', 'output', or 'tb'.
+
+        `code` is a portion of the line that should be added to the buffer
+        corresponding to the next mode and eventually lexed by another lexer.
+        For example, `code` could be Python code if `mode` were 'input'.
+
+        `insertion` is a 3-tuple (index, token, text) representing an
+        unprocessed "token" that will be inserted into the stream of tokens
+        that are created from the buffer once we change modes. This is usually
+        the input or output prompt.
+
+        In general, the next mode depends on current mode and on the contents
+        of `line`.
+
+        """
+        # To reduce the number of regex match checks, we have multiple
+        # 'if' blocks instead of 'if-elif' blocks.
+
+        # Check for possible end of input
+        in2_match = self.in2_regex.match(line)
+        in2_match_rstrip = self.in2_regex_rstrip.match(line)
+        if (
+            in2_match and in2_match.group().rstrip() == line.rstrip()
+        ) or in2_match_rstrip:
+            end_input = True
+        else:
+            end_input = False
+        if end_input and self.mode != "tb":
+            # Only look for an end of input when not in tb mode.
+            # An ellipsis could appear within the traceback.
+            mode = "output"
+            code = ""
+            insertion = (0, Generic.Prompt, line)
+            return mode, code, insertion
+
+        # Check for output prompt
+        out_match = self.out_regex.match(line)
+        out_match_rstrip = self.out_regex_rstrip.match(line)
+        if out_match or out_match_rstrip:
+            mode = "output"
+            if out_match:
+                idx = out_match.end()
+            else:
+                idx = out_match_rstrip.end()
+            code = line[idx:]
+            # Use the 'heading' token for output.  We cannot use Generic.Error
+            # since it would conflict with exceptions.
+            insertion = (0, Generic.Heading, line[:idx])
+            return mode, code, insertion
+
+        # Check for input or continuation prompt (non stripped version)
+        in1_match = self.in1_regex.match(line)
+        if in1_match or (in2_match and self.mode != "tb"):
+            # New input or when not in tb, continued input.
+            # We do not check for continued input when in tb since it is
+            # allowable to replace a long stack with an ellipsis.
+            mode = "input"
+            if in1_match:
+                idx = in1_match.end()
+            else:  # in2_match
+                idx = in2_match.end()
+            code = line[idx:]
+            insertion = (0, Generic.Prompt, line[:idx])
+            return mode, code, insertion
+
+        # Check for input or continuation prompt (stripped version)
+        in1_match_rstrip = self.in1_regex_rstrip.match(line)
+        if in1_match_rstrip or (in2_match_rstrip and self.mode != "tb"):
+            # New input or when not in tb, continued input.
+            # We do not check for continued input when in tb since it is
+            # allowable to replace a long stack with an ellipsis.
+            mode = "input"
+            if in1_match_rstrip:
+                idx = in1_match_rstrip.end()
+            else:  # in2_match
+                idx = in2_match_rstrip.end()
+            code = line[idx:]
+            insertion = (0, Generic.Prompt, line[:idx])
+            return mode, code, insertion
+
+        # Check for traceback
+        if self.ipytb_start.match(line):
+            mode = "tb"
+            code = line
+            insertion = None
+            return mode, code, insertion
+
+        # All other stuff...
+        if self.mode in ("input", "output"):
+            # We assume all other text is output. Multiline input that
+            # does not use the continuation marker cannot be detected.
+            # For example, the 3 in the following is clearly output:
+            #
+            #    In [1]: print(3)
+            #    3
+            #
+            # But the following second line is part of the input:
+            #
+            #    In [2]: while True:
+            #        print(True)
+            #
+            # In both cases, the 2nd line will be 'output'.
+            #
+            mode = "output"
+        else:
+            mode = "tb"
+
+        code = line
+        insertion = None
+
+        return mode, code, insertion
+
+    def get_tokens_unprocessed(self, text):
+        self.reset()
+        for match in line_re.finditer(text):
+            line = match.group()
+            mode, code, insertion = self.get_mci(line)
+
+            if mode != self.mode:
+                # Yield buffered tokens before transitioning to new mode.
+                for token in self.buffered_tokens():
+                    yield token
+                self.mode = mode
+
+            if insertion:
+                self.insertions.append((len(self.buffer), [insertion]))
+            self.buffer += code
+
+        for token in self.buffered_tokens():
+            yield token
+
+
+class IPyLexer(Lexer):
+    r"""
+    Primary lexer for all IPython-like code.
+
+    This is a simple helper lexer.  If the first line of the text begins with
+    "In \[[0-9]+\]:", then the entire text is parsed with an IPython console
+    lexer. If not, then the entire text is parsed with an IPython lexer.
+
+    The goal is to reduce the number of lexers that are registered
+    with Pygments.
+
+    """
+
+    name = "IPy session"
+    aliases = ["ipy", "ipy3"]
+
+    def __init__(self, **options):
+        """
+        Create a new IPyLexer instance which dispatch to either an
+        IPythonCOnsoleLexer (if In prompts are present) or and IPythonLexer (if
+        In prompts are not present).
+        """
+        # init docstring is necessary for docs not to fail to build do to parent
+        # docs referenceing a section in pygments docs.
+        Lexer.__init__(self, **options)
+
+        self.IPythonLexer = IPythonLexer(**options)
+        self.IPythonConsoleLexer = IPythonConsoleLexer(**options)
+
+    def get_tokens_unprocessed(self, text):
+        # Search for the input prompt anywhere...this allows code blocks to
+        # begin with comments as well.
+        if re.match(r".*(In \[[0-9]+\]:)", text.strip(), re.DOTALL):
+            lex = self.IPythonConsoleLexer
+        else:
+            lex = self.IPythonLexer
+        for token in lex.get_tokens_unprocessed(text):
+            yield token

venv/Lib/site-packages/isympy.py

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

venv/Lib/site-packages/jsonpointer.py

@@ -0,0 +1,348 @@
+# -*- coding: utf-8 -*-
+#
+# python-json-pointer - An implementation of the JSON Pointer syntax
+# https://github.com/stefankoegl/python-json-pointer
+#
+# Copyright (c) 2011 Stefan Kögl <[email protected]>
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products
+# derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+
+""" Identify specific nodes in a JSON document (RFC 6901) """
+
+# Will be parsed by setup.py to determine package metadata
+__author__ = 'Stefan Kögl <[email protected]>'
+__version__ = '3.0.0'
+__website__ = 'https://github.com/stefankoegl/python-json-pointer'
+__license__ = 'Modified BSD License'
+
+import copy
+import re
+from collections.abc import Mapping, Sequence
+from itertools import tee, chain
+
+_nothing = object()
+
+
+def set_pointer(doc, pointer, value, inplace=True):
+    """Resolves a pointer against doc and sets the value of the target within doc.
+
+    With inplace set to true, doc is modified as long as pointer is not the
+    root.
+
+    >>> obj = {'foo': {'anArray': [ {'prop': 44}], 'another prop': {'baz': 'A string' }}}
+
+    >>> set_pointer(obj, '/foo/anArray/0/prop', 55) == \
+    {'foo': {'another prop': {'baz': 'A string'}, 'anArray': [{'prop': 55}]}}
+    True
+
+    >>> set_pointer(obj, '/foo/yet another prop', 'added prop') == \
+    {'foo': {'another prop': {'baz': 'A string'}, 'yet another prop': 'added prop', 'anArray': [{'prop': 55}]}}
+    True
+
+    >>> obj = {'foo': {}}
+    >>> set_pointer(obj, '/foo/a%20b', 'x') == \
+    {'foo': {'a%20b': 'x' }}
+    True
+    """
+
+    pointer = JsonPointer(pointer)
+    return pointer.set(doc, value, inplace)
+
+
+def resolve_pointer(doc, pointer, default=_nothing):
+    """ Resolves pointer against doc and returns the referenced object
+
+    >>> obj = {'foo': {'anArray': [ {'prop': 44}], 'another prop': {'baz': 'A string' }}, 'a%20b': 1, 'c d': 2}
+
+    >>> resolve_pointer(obj, '') == obj
+    True
+
+    >>> resolve_pointer(obj, '/foo') == obj['foo']
+    True
+
+    >>> resolve_pointer(obj, '/foo/another prop') == obj['foo']['another prop']
+    True
+
+    >>> resolve_pointer(obj, '/foo/another prop/baz') == obj['foo']['another prop']['baz']
+    True
+
+    >>> resolve_pointer(obj, '/foo/anArray/0') == obj['foo']['anArray'][0]
+    True
+
+    >>> resolve_pointer(obj, '/some/path', None) == None
+    True
+
+    >>> resolve_pointer(obj, '/a b', None) == None
+    True
+
+    >>> resolve_pointer(obj, '/a%20b') == 1
+    True
+
+    >>> resolve_pointer(obj, '/c d') == 2
+    True
+
+    >>> resolve_pointer(obj, '/c%20d', None) == None
+    True
+    """
+
+    pointer = JsonPointer(pointer)
+    return pointer.resolve(doc, default)
+
+
+def pairwise(iterable):
+    """ Transforms a list to a list of tuples of adjacent items
+
+    s -> (s0,s1), (s1,s2), (s2, s3), ...
+
+    >>> list(pairwise([]))
+    []
+
+    >>> list(pairwise([1]))
+    []
+
+    >>> list(pairwise([1, 2, 3, 4]))
+    [(1, 2), (2, 3), (3, 4)]
+    """
+    a, b = tee(iterable)
+    for _ in b:
+        break
+    return zip(a, b)
+
+
+class JsonPointerException(Exception):
+    pass
+
+
+class EndOfList(object):
+    """Result of accessing element "-" of a list"""
+
+    def __init__(self, list_):
+        self.list_ = list_
+
+    def __repr__(self):
+        return '{cls}({lst})'.format(cls=self.__class__.__name__,
+                                     lst=repr(self.list_))
+
+
+class JsonPointer(object):
+    """A JSON Pointer that can reference parts of a JSON document"""
+
+    # Array indices must not contain:
+    # leading zeros, signs, spaces, decimals, etc
+    _RE_ARRAY_INDEX = re.compile('0|[1-9][0-9]*$')
+    _RE_INVALID_ESCAPE = re.compile('(~[^01]|~$)')
+
+    def __init__(self, pointer):
+
+        # validate escapes
+        invalid_escape = self._RE_INVALID_ESCAPE.search(pointer)
+        if invalid_escape:
+            raise JsonPointerException('Found invalid escape {}'.format(
+                invalid_escape.group()))
+
+        parts = pointer.split('/')
+        if parts.pop(0) != '':
+            raise JsonPointerException('Location must start with /')
+
+        parts = [unescape(part) for part in parts]
+        self.parts = parts
+
+    def to_last(self, doc):
+        """Resolves ptr until the last step, returns (sub-doc, last-step)"""
+
+        if not self.parts:
+            return doc, None
+
+        for part in self.parts[:-1]:
+            doc = self.walk(doc, part)
+
+        return doc, JsonPointer.get_part(doc, self.parts[-1])
+
+    def resolve(self, doc, default=_nothing):
+        """Resolves the pointer against doc and returns the referenced object"""
+
+        for part in self.parts:
+
+            try:
+                doc = self.walk(doc, part)
+            except JsonPointerException:
+                if default is _nothing:
+                    raise
+                else:
+                    return default
+
+        return doc
+
+    get = resolve
+
+    def set(self, doc, value, inplace=True):
+        """Resolve the pointer against the doc and replace the target with value."""
+
+        if len(self.parts) == 0:
+            if inplace:
+                raise JsonPointerException('Cannot set root in place')
+            return value
+
+        if not inplace:
+            doc = copy.deepcopy(doc)
+
+        (parent, part) = self.to_last(doc)
+
+        if isinstance(parent, Sequence) and part == '-':
+            parent.append(value)
+        else:
+            parent[part] = value
+
+        return doc
+
+    @classmethod
+    def get_part(cls, doc, part):
+        """Returns the next step in the correct type"""
+
+        if isinstance(doc, Mapping):
+            return part
+
+        elif isinstance(doc, Sequence):
+
+            if part == '-':
+                return part
+
+            if not JsonPointer._RE_ARRAY_INDEX.match(str(part)):
+                raise JsonPointerException("'%s' is not a valid sequence index" % part)
+
+            return int(part)
+
+        elif hasattr(doc, '__getitem__'):
+            # Allow indexing via ducktyping
+            # if the target has defined __getitem__
+            return part
+
+        else:
+            raise JsonPointerException("Document '%s' does not support indexing, "
+                                       "must be mapping/sequence or support __getitem__" % type(doc))
+
+    def get_parts(self):
+        """Returns the list of the parts. For example, JsonPointer('/a/b').get_parts() == ['a', 'b']"""
+
+        return self.parts
+
+    def walk(self, doc, part):
+        """ Walks one step in doc and returns the referenced part """
+
+        part = JsonPointer.get_part(doc, part)
+
+        assert hasattr(doc, '__getitem__'), "invalid document type %s" % (type(doc),)
+
+        if isinstance(doc, Sequence):
+            if part == '-':
+                return EndOfList(doc)
+
+            try:
+                return doc[part]
+
+            except IndexError:
+                raise JsonPointerException("index '%s' is out of bounds" % (part,))
+
+        # Else the object is a mapping or supports __getitem__(so assume custom indexing)
+        try:
+            return doc[part]
+
+        except KeyError:
+            raise JsonPointerException("member '%s' not found in %s" % (part, doc))
+
+    def contains(self, ptr):
+        """ Returns True if self contains the given ptr """
+        return self.parts[:len(ptr.parts)] == ptr.parts
+
+    def __contains__(self, item):
+        """ Returns True if self contains the given ptr """
+        return self.contains(item)
+
+    def join(self, suffix):
+        """ Returns a new JsonPointer with the given suffix append to this ptr """
+        if isinstance(suffix, JsonPointer):
+            suffix_parts = suffix.parts
+        elif isinstance(suffix, str):
+            suffix_parts = JsonPointer(suffix).parts
+        else:
+            suffix_parts = suffix
+        try:
+            return JsonPointer.from_parts(chain(self.parts, suffix_parts))
+        except:  # noqa E722
+            raise JsonPointerException("Invalid suffix")
+
+    def __truediv__(self, suffix):  # Python 3
+        return self.join(suffix)
+
+    @property
+    def path(self):
+        """Returns the string representation of the pointer
+
+        >>> ptr = JsonPointer('/~0/0/~1').path == '/~0/0/~1'
+        """
+        parts = [escape(part) for part in self.parts]
+        return ''.join('/' + part for part in parts)
+
+    def __eq__(self, other):
+        """Compares a pointer to another object
+
+        Pointers can be compared by comparing their strings (or splitted
+        strings), because no two different parts can point to the same
+        structure in an object (eg no different number representations)
+        """
+
+        if not isinstance(other, JsonPointer):
+            return False
+
+        return self.parts == other.parts
+
+    def __hash__(self):
+        return hash(tuple(self.parts))
+
+    def __str__(self):
+        return self.path
+
+    def __repr__(self):
+        return type(self).__name__ + "(" + repr(self.path) + ")"
+
+    @classmethod
+    def from_parts(cls, parts):
+        """Constructs a JsonPointer from a list of (unescaped) paths
+
+        >>> JsonPointer.from_parts(['a', '~', '/', 0]).path == '/a/~0/~1/0'
+        True
+        """
+        parts = [escape(str(part)) for part in parts]
+        ptr = cls(''.join('/' + part for part in parts))
+        return ptr
+
+
+def escape(s):
+    return s.replace('~', '~0').replace('/', '~1')
+
+
+def unescape(s):
+    return s.replace('~1', '/').replace('~0', '~')

venv/Lib/site-packages/jupyter.py

@@ -0,0 +1,7 @@
+"""Launch the root jupyter command"""
+from __future__ import annotations
+
+if __name__ == "__main__":
+    from jupyter_core.command import main
+
+    main()

venv/Lib/site-packages/nest_asyncio.py

@@ -0,0 +1,219 @@
+"""Patch asyncio to allow nested event loops."""
+
+import asyncio
+import asyncio.events as events
+import os
+import sys
+import threading
+from contextlib import contextmanager, suppress
+from heapq import heappop
+
+
+def apply(loop=None):
+    """Patch asyncio to make its event loop reentrant."""
+    _patch_asyncio()
+    _patch_policy()
+    _patch_tornado()
+
+    loop = loop or asyncio.get_event_loop()
+    _patch_loop(loop)
+
+
+def _patch_asyncio():
+    """Patch asyncio module to use pure Python tasks and futures."""
+
+    def run(main, *, debug=False):
+        loop = asyncio.get_event_loop()
+        loop.set_debug(debug)
+        task = asyncio.ensure_future(main)
+        try:
+            return loop.run_until_complete(task)
+        finally:
+            if not task.done():
+                task.cancel()
+                with suppress(asyncio.CancelledError):
+                    loop.run_until_complete(task)
+
+    def _get_event_loop(stacklevel=3):
+        loop = events._get_running_loop()
+        if loop is None:
+            loop = events.get_event_loop_policy().get_event_loop()
+        return loop
+
+    # Use module level _current_tasks, all_tasks and patch run method.
+    if hasattr(asyncio, '_nest_patched'):
+        return
+    if sys.version_info >= (3, 6, 0):
+        asyncio.Task = asyncio.tasks._CTask = asyncio.tasks.Task = \
+            asyncio.tasks._PyTask
+        asyncio.Future = asyncio.futures._CFuture = asyncio.futures.Future = \
+            asyncio.futures._PyFuture
+    if sys.version_info < (3, 7, 0):
+        asyncio.tasks._current_tasks = asyncio.tasks.Task._current_tasks
+        asyncio.all_tasks = asyncio.tasks.Task.all_tasks
+    if sys.version_info >= (3, 9, 0):
+        events._get_event_loop = events.get_event_loop = \
+            asyncio.get_event_loop = _get_event_loop
+    asyncio.run = run
+    asyncio._nest_patched = True
+
+
+def _patch_policy():
+    """Patch the policy to always return a patched loop."""
+
+    def get_event_loop(self):
+        if self._local._loop is None:
+            loop = self.new_event_loop()
+            _patch_loop(loop)
+            self.set_event_loop(loop)
+        return self._local._loop
+
+    policy = events.get_event_loop_policy()
+    policy.__class__.get_event_loop = get_event_loop
+
+
+def _patch_loop(loop):
+    """Patch loop to make it reentrant."""
+
+    def run_forever(self):
+        with manage_run(self), manage_asyncgens(self):
+            while True:
+                self._run_once()
+                if self._stopping:
+                    break
+        self._stopping = False
+
+    def run_until_complete(self, future):
+        with manage_run(self):
+            f = asyncio.ensure_future(future, loop=self)
+            if f is not future:
+                f._log_destroy_pending = False
+            while not f.done():
+                self._run_once()
+                if self._stopping:
+                    break
+            if not f.done():
+                raise RuntimeError(
+                    'Event loop stopped before Future completed.')
+            return f.result()
+
+    def _run_once(self):
+        """
+        Simplified re-implementation of asyncio's _run_once that
+        runs handles as they become ready.
+        """
+        ready = self._ready
+        scheduled = self._scheduled
+        while scheduled and scheduled[0]._cancelled:
+            heappop(scheduled)
+
+        timeout = (
+            0 if ready or self._stopping
+            else min(max(
+                scheduled[0]._when - self.time(), 0), 86400) if scheduled
+            else None)
+        event_list = self._selector.select(timeout)
+        self._process_events(event_list)
+
+        end_time = self.time() + self._clock_resolution
+        while scheduled and scheduled[0]._when < end_time:
+            handle = heappop(scheduled)
+            ready.append(handle)
+
+        for _ in range(len(ready)):
+            if not ready:
+                break
+            handle = ready.popleft()
+            if not handle._cancelled:
+                # preempt the current task so that that checks in
+                # Task.__step do not raise
+                curr_task = curr_tasks.pop(self, None)
+
+                try:
+                    handle._run()
+                finally:
+                    # restore the current task
+                    if curr_task is not None:
+                        curr_tasks[self] = curr_task
+
+        handle = None
+
+    @contextmanager
+    def manage_run(self):
+        """Set up the loop for running."""
+        self._check_closed()
+        old_thread_id = self._thread_id
+        old_running_loop = events._get_running_loop()
+        try:
+            self._thread_id = threading.get_ident()
+            events._set_running_loop(self)
+            self._num_runs_pending += 1
+            if self._is_proactorloop:
+                if self._self_reading_future is None:
+                    self.call_soon(self._loop_self_reading)
+            yield
+        finally:
+            self._thread_id = old_thread_id
+            events._set_running_loop(old_running_loop)
+            self._num_runs_pending -= 1
+            if self._is_proactorloop:
+                if (self._num_runs_pending == 0
+                        and self._self_reading_future is not None):
+                    ov = self._self_reading_future._ov
+                    self._self_reading_future.cancel()
+                    if ov is not None:
+                        self._proactor._unregister(ov)
+                    self._self_reading_future = None
+
+    @contextmanager
+    def manage_asyncgens(self):
+        if not hasattr(sys, 'get_asyncgen_hooks'):
+            # Python version is too old.
+            return
+        old_agen_hooks = sys.get_asyncgen_hooks()
+        try:
+            self._set_coroutine_origin_tracking(self._debug)
+            if self._asyncgens is not None:
+                sys.set_asyncgen_hooks(
+                    firstiter=self._asyncgen_firstiter_hook,
+                    finalizer=self._asyncgen_finalizer_hook)
+            yield
+        finally:
+            self._set_coroutine_origin_tracking(False)
+            if self._asyncgens is not None:
+                sys.set_asyncgen_hooks(*old_agen_hooks)
+
+    def _check_running(self):
+        """Do not throw exception if loop is already running."""
+        pass
+
+    if hasattr(loop, '_nest_patched'):
+        return
+    if not isinstance(loop, asyncio.BaseEventLoop):
+        raise ValueError('Can\'t patch loop of type %s' % type(loop))
+    cls = loop.__class__
+    cls.run_forever = run_forever
+    cls.run_until_complete = run_until_complete
+    cls._run_once = _run_once
+    cls._check_running = _check_running
+    cls._check_runnung = _check_running  # typo in Python 3.7 source
+    cls._num_runs_pending = 1 if loop.is_running() else 0
+    cls._is_proactorloop = (
+        os.name == 'nt' and issubclass(cls, asyncio.ProactorEventLoop))
+    if sys.version_info < (3, 7, 0):
+        cls._set_coroutine_origin_tracking = cls._set_coroutine_wrapper
+    curr_tasks = asyncio.tasks._current_tasks \
+        if sys.version_info >= (3, 7, 0) else asyncio.Task._current_tasks
+    cls._nest_patched = True
+
+
+def _patch_tornado():
+    """
+    If tornado is imported before nest_asyncio, make tornado aware of
+    the pure-Python asyncio Future.
+    """
+    if 'tornado' in sys.modules:
+        import tornado.concurrent as tc  # type: ignore
+        tc.Future = asyncio.Future
+        if asyncio.Future not in tc.FUTURES:
+            tc.FUTURES += (asyncio.Future,)

venv/Lib/site-packages/pandocfilters.py

@@ -0,0 +1,304 @@
+# Author: John MacFarlane <[email protected]>
+# Copyright: (C) 2013 John MacFarlane
+# License: BSD3
+
+"""
+Functions to aid writing python scripts that process the pandoc
+AST serialized as JSON.
+"""
+
+import codecs
+import hashlib
+import io
+import json
+import os
+import sys
+import atexit
+import shutil
+import tempfile
+
+
+# some utility-functions: make it easier to create your own filters
+
+
+def get_filename4code(module, content, ext=None):
+    """Generate filename based on content
+
+    The function ensures that the (temporary) directory exists, so that the
+    file can be written.
+
+    By default, the directory won't be cleaned up,
+    so a filter can use the directory as a cache and
+    decide not to regenerate if there's no change.
+
+    In case the user preferres the files to be temporary files,
+    an environment variable `PANDOCFILTER_CLEANUP` can be set to
+    any non-empty value such as `1` to
+    make sure the directory is created in a temporary location and removed
+    after finishing the filter. In this case there's no caching and files
+    will be regenerated each time the filter is run.
+
+    Example:
+        filename = get_filename4code("myfilter", code)
+    """
+    if os.getenv('PANDOCFILTER_CLEANUP'):
+        imagedir = tempfile.mkdtemp(prefix=module)
+        atexit.register(lambda: shutil.rmtree(imagedir))
+    else:
+        imagedir = module + "-images"
+    fn = hashlib.sha1(content.encode(sys.getfilesystemencoding())).hexdigest()
+    try:
+        os.makedirs(imagedir, exist_ok=True)
+        sys.stderr.write('Created directory ' + imagedir + '\n')
+    except OSError:
+        sys.stderr.write('Could not create directory "' + imagedir + '"\n')
+    if ext:
+        fn += "." + ext
+    return os.path.join(imagedir, fn)
+
+def get_value(kv, key, value = None):
+    """get value from the keyvalues (options)"""
+    res = []
+    for k, v in kv:
+        if k == key:
+            value = v
+        else:
+            res.append([k, v])
+    return value, res
+
+def get_caption(kv):
+    """get caption from the keyvalues (options)
+
+    Example:
+      if key == 'CodeBlock':
+        [[ident, classes, keyvals], code] = value
+        caption, typef, keyvals = get_caption(keyvals)
+        ...
+        return Para([Image([ident, [], keyvals], caption, [filename, typef])])
+    """
+    caption = []
+    typef = ""
+    value, res = get_value(kv, u"caption")
+    if value is not None:
+        caption = [Str(value)]
+        typef = "fig:"
+
+    return caption, typef, res
+
+
+def get_extension(format, default, **alternates):
+    """get the extension for the result, needs a default and some specialisations
+
+    Example:
+      filetype = get_extension(format, "png", html="svg", latex="eps")
+    """
+    try:
+        return alternates[format]
+    except KeyError:
+        return default
+
+# end of utilities
+
+
+def walk(x, action, format, meta):
+    """Walk a tree, applying an action to every object.
+    Returns a modified tree.  An action is a function of the form
+    `action(key, value, format, meta)`, where:
+
+    * `key` is the type of the pandoc object (e.g. 'Str', 'Para') `value` is
+    * the contents of the object (e.g. a string for 'Str', a list of
+      inline elements for 'Para')
+    * `format` is the target output format (as supplied by the
+      `format` argument of `walk`)
+    * `meta` is the document's metadata
+
+    The return of an action is either:
+
+    * `None`: this means that the object should remain unchanged
+    * a pandoc object: this will replace the original object
+    * a list of pandoc objects: these will replace the original object; the
+      list is merged with the neighbors of the orignal objects (spliced into
+      the list the original object belongs to); returning an empty list deletes
+      the object
+    """
+    if isinstance(x, list):
+        array = []
+        for item in x:
+            if isinstance(item, dict) and 't' in item:
+                res = action(item['t'],
+                             item['c'] if 'c' in item else None, format, meta)
+                if res is None:
+                    array.append(walk(item, action, format, meta))
+                elif isinstance(res, list):
+                    for z in res:
+                        array.append(walk(z, action, format, meta))
+                else:
+                    array.append(walk(res, action, format, meta))
+            else:
+                array.append(walk(item, action, format, meta))
+        return array
+    elif isinstance(x, dict):
+        return {k: walk(v, action, format, meta) for k, v in x.items()}
+    else:
+        return x
+
+def toJSONFilter(action):
+    """Like `toJSONFilters`, but takes a single action as argument.
+    """
+    toJSONFilters([action])
+
+
+def toJSONFilters(actions):
+    """Generate a JSON-to-JSON filter from stdin to stdout
+
+    The filter:
+
+    * reads a JSON-formatted pandoc document from stdin
+    * transforms it by walking the tree and performing the actions
+    * returns a new JSON-formatted pandoc document to stdout
+
+    The argument `actions` is a list of functions of the form
+    `action(key, value, format, meta)`, as described in more
+    detail under `walk`.
+
+    This function calls `applyJSONFilters`, with the `format`
+    argument provided by the first command-line argument,
+    if present.  (Pandoc sets this by default when calling
+    filters.)
+    """
+    try:
+        input_stream = io.TextIOWrapper(sys.stdin.buffer, encoding='utf-8')
+    except AttributeError:
+        # Python 2 does not have sys.stdin.buffer.
+        # REF: https://stackoverflow.com/questions/2467928/python-unicodeencode
+        input_stream = codecs.getreader("utf-8")(sys.stdin)
+
+    source = input_stream.read()
+    if len(sys.argv) > 1:
+        format = sys.argv[1]
+    else:
+        format = ""
+
+    sys.stdout.write(applyJSONFilters(actions, source, format))
+
+def applyJSONFilters(actions, source, format=""):
+    """Walk through JSON structure and apply filters
+
+    This:
+
+    * reads a JSON-formatted pandoc document from a source string
+    * transforms it by walking the tree and performing the actions
+    * returns a new JSON-formatted pandoc document as a string
+
+    The `actions` argument is a list of functions (see `walk`
+    for a full description).
+
+    The argument `source` is a string encoded JSON object.
+
+    The argument `format` is a string describing the output format.
+
+    Returns a the new JSON-formatted pandoc document.
+    """
+
+    doc = json.loads(source)
+
+    if 'meta' in doc:
+        meta = doc['meta']
+    elif doc[0]:  # old API
+        meta = doc[0]['unMeta']
+    else:
+        meta = {}
+    altered = doc
+    for action in actions:
+        altered = walk(altered, action, format, meta)
+
+    return json.dumps(altered)
+
+
+def stringify(x):
+    """Walks the tree x and returns concatenated string content,
+    leaving out all formatting.
+    """
+    result = []
+
+    def go(key, val, format, meta):
+        if key in ['Str', 'MetaString']:
+            result.append(val)
+        elif key == 'Code':
+            result.append(val[1])
+        elif key == 'Math':
+            result.append(val[1])
+        elif key == 'LineBreak':
+            result.append(" ")
+        elif key == 'SoftBreak':
+            result.append(" ")
+        elif key == 'Space':
+            result.append(" ")
+
+    walk(x, go, "", {})
+    return ''.join(result)
+
+
+def attributes(attrs):
+    """Returns an attribute list, constructed from the
+    dictionary attrs.
+    """
+    attrs = attrs or {}
+    ident = attrs.get("id", "")
+    classes = attrs.get("classes", [])
+    keyvals = [[x, attrs[x]] for x in attrs if (x != "classes" and x != "id")]
+    return [ident, classes, keyvals]
+
+
+def elt(eltType, numargs):
+    def fun(*args):
+        lenargs = len(args)
+        if lenargs != numargs:
+            raise ValueError(eltType + ' expects ' + str(numargs) +
+                             ' arguments, but given ' + str(lenargs))
+        if numargs == 0:
+            xs = []
+        elif len(args) == 1:
+            xs = args[0]
+        else:
+            xs = list(args)
+        return {'t': eltType, 'c': xs}
+    return fun
+
+# Constructors for block elements
+
+Plain = elt('Plain', 1)
+Para = elt('Para', 1)
+CodeBlock = elt('CodeBlock', 2)
+RawBlock = elt('RawBlock', 2)
+BlockQuote = elt('BlockQuote', 1)
+OrderedList = elt('OrderedList', 2)
+BulletList = elt('BulletList', 1)
+DefinitionList = elt('DefinitionList', 1)
+Header = elt('Header', 3)
+HorizontalRule = elt('HorizontalRule', 0)
+Table = elt('Table', 5)
+Div = elt('Div', 2)
+Null = elt('Null', 0)
+
+# Constructors for inline elements
+
+Str = elt('Str', 1)
+Emph = elt('Emph', 1)
+Strong = elt('Strong', 1)
+Strikeout = elt('Strikeout', 1)
+Superscript = elt('Superscript', 1)
+Subscript = elt('Subscript', 1)
+SmallCaps = elt('SmallCaps', 1)
+Quoted = elt('Quoted', 2)
+Cite = elt('Cite', 2)
+Code = elt('Code', 2)
+Space = elt('Space', 0)
+LineBreak = elt('LineBreak', 0)
+Math = elt('Math', 2)
+RawInline = elt('RawInline', 2)
+Link = elt('Link', 3)
+Image = elt('Image', 3)
+Note = elt('Note', 1)
+SoftBreak = elt('SoftBreak', 0)
+Span = elt('Span', 2)

venv/Lib/site-packages/pylab.py

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

venv/Lib/site-packages/pythoncom.py

@@ -0,0 +1,4 @@
+# Magic utility that "redirects" to pythoncomXX.dll
+import pywintypes
+
+pywintypes.__import_pywin32_system_module__("pythoncom", globals())

venv/Lib/site-packages/pywin32.version.txt

@@ -0,0 +1 @@
+310

venv/Lib/site-packages/rfc3339_validator.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+
+__author__ = """Nicolas Aimetti"""
+__email__ = '[email protected]'
+__version__ = '0.1.4'
+
+import re
+import calendar
+import six
+
+RFC3339_REGEX_FLAGS = 0
+if six.PY3:
+    RFC3339_REGEX_FLAGS |= re.ASCII
+
+RFC3339_REGEX = re.compile(r"""
+    ^
+    (\d{4})      # Year
+    -
+    (0[1-9]|1[0-2]) # Month
+    -
+    (\d{2})          # Day
+    T
+    (?:[01]\d|2[0123]) # Hours
+    :
+    (?:[0-5]\d)     # Minutes
+    :
+    (?:[0-5]\d)     # Seconds
+    (?:\.\d+)?      # Secfrac
+    (?:  Z                              # UTC
+       | [+-](?:[01]\d|2[0123]):[0-5]\d # Offset
+    )
+    $
+""", re.VERBOSE | RFC3339_REGEX_FLAGS)
+
+
+def validate_rfc3339(date_string):
+    """
+    Validates dates against RFC3339 datetime format
+    Leap seconds are no supported.
+    """
+    m = RFC3339_REGEX.match(date_string)
+    if m is None:
+        return False
+    year, month, day = map(int, m.groups())
+    if not year:
+        # Year 0 is not valid a valid date
+        return False
+    (_, max_day) = calendar.monthrange(year, month)
+    if not 1 <= day <= max_day:
+        return False
+    return True

venv/Lib/site-packages/rfc3986_validator.py

@@ -0,0 +1,106 @@
+import re
+
+__version__ = '0.1.1'
+__author__ = 'Nicolas Aimetti <[email protected]>'
+__all__ = ['validate_rfc3986']
+
+# Following regex rules references the ABNF terminology from
+# [RFC3986](https://tools.ietf.org/html/rfc3986#appendix-A)
+
+
+# IPv6 validation rule
+IPv6_RE = (
+    r"(?:(?:[0-9A-Fa-f]{1,4}:){6}(?:[0-9A-Fa-f]{1,4}:[0-9A-Fa-f]{1,4}|(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]["
+    r"0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))|::(?:[0-9A-Fa-f]{1,4}:){5}(?:[0-9A-Fa-f]{1,"
+    r"4}:[0-9A-Fa-f]{1,4}|(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9]["
+    r"0-9]?))|(?:[0-9A-Fa-f]{1,4})?::(?:[0-9A-Fa-f]{1,4}:){4}(?:[0-9A-Fa-f]{1,4}:[0-9A-Fa-f]{1,4}|(?:(?:25[0-5]|2["
+    r"0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))|(?:(?:[0-9A-Fa-f]{1,"
+    r"4}:)?[0-9A-Fa-f]{1,4})?::(?:[0-9A-Fa-f]{1,4}:){3}(?:[0-9A-Fa-f]{1,4}:[0-9A-Fa-f]{1,4}|(?:(?:25[0-5]|2[0-4]["
+    r"0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))|(?:(?:[0-9A-Fa-f]{1,4}:){,"
+    r"2}[0-9A-Fa-f]{1,4})?::(?:[0-9A-Fa-f]{1,4}:){2}(?:[0-9A-Fa-f]{1,4}:[0-9A-Fa-f]{1,4}|(?:(?:25[0-5]|2[0-4]["
+    r"0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))|(?:(?:[0-9A-Fa-f]{1,4}:){,"
+    r"3}[0-9A-Fa-f]{1,4})?::(?:[0-9A-Fa-f]{1,4}:)(?:[0-9A-Fa-f]{1,4}:[0-9A-Fa-f]{1,4}|(?:(?:25[0-5]|2[0-4][0-9]|["
+    r"01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?))|(?:(?:[0-9A-Fa-f]{1,4}:){,4}[0-9A-Fa-f]{1,"
+    r"4})?::(?:[0-9A-Fa-f]{1,4}:[0-9A-Fa-f]{1,4}|(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2["
+    r"0-4][0-9]|[01]?[0-9][0-9]?))|(?:(?:[0-9A-Fa-f]{1,4}:){,5}[0-9A-Fa-f]{1,4})?::[0-9A-Fa-f]{1,4}|(?:(?:["
+    r"0-9A-Fa-f]{1,4}:){,6}[0-9A-Fa-f]{1,4})?::)"
+)
+
+
+# An authority is defined as: [ userinfo "@" ] host [ ":" port ]
+# \[(?:{ip_v6} | v[0-9A-Fa-f]+\.[a-zA-Z0-9_.~\-!$ & '()*+,;=:]+)\] # IP-literal
+AUTHORITY_RE = r"""
+    (?:(?:[a-zA-Z0-9_.~\-!$&'()*+,;=:]|%[0-9A-Fa-f]{{2}})*@)? # user info
+    (?:
+          \[(?:{ip_v6}|v[0-9A-Fa-f]+\.[a-zA-Z0-9_.~\-!$&'()*+,;=:]+)\] # IP-literal
+        | (?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){{3}}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?) # IPv4
+        | (?:[a-zA-Z0-9_.~\-!$&'()*+,;=]|%[0-9A-Fa-f]{{2}})* # reg-name
+    ) # host
+    (?::[0-9]*)? # port
+""".format(ip_v6=IPv6_RE,)
+# Path char regex rule
+PCHAR_RE = r"(?:[a-zA-Z0-9_.~\-!$&'()*+,;=:@]|%[0-9A-Fa-f]{2})"
+# Query and Fragment rules are exactly the same
+QUERY_RE = r"(?:[a-zA-Z0-9_.~\-!$&'()*+,;=:@/?]|%[0-9A-Fa-f]{2})*"
+# An URI is defined as: scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+URI_RE = r"""
+    [a-zA-Z][a-zA-Z0-9+.-]* #scheme
+    :
+    (?:
+          //
+          {authority}
+          (?:/{pchar}*)* # path-abempty
+        | /(?:{pchar}+ (?:/{pchar}*)*)? # path-absolute
+        | {pchar}+ (?:/{pchar}*)*  # path-rootless
+        |  # or nothing
+    ) # hier-part
+    (?:\?{query})? # Query
+    (?:\#{fragment})? # Fragment
+""".format(
+       authority=AUTHORITY_RE,
+       query=QUERY_RE,
+       fragment=QUERY_RE,
+       pchar=PCHAR_RE
+)
+
+# A relative-ref is defined as: relative-part [ "?" query ] [ "#" fragment ]
+RELATIVE_REF_RE = r"""
+    (?:
+          //
+          {authority}
+          (?:/{pchar}*)* # path-abempty
+        | /(?:{pchar}+ (?:/{pchar}*)*)? # path-absolute
+        | (?:[a-zA-Z0-9_.~\-!$&'()*+,;=@]|%[0-9A-Fa-f]{{2}})+ (?:/{pchar}*)*  # path-noscheme
+        |  # or nothing
+    ) # relative-part
+    (?:\?{query})? # Query
+    (?:\#{fragment})? # Fragment
+""".format(
+       authority=AUTHORITY_RE,
+       query=QUERY_RE,
+       fragment=QUERY_RE,
+       pchar=PCHAR_RE
+)
+# Compiled URI regex rule
+URI_RE_COMP = re.compile(r"^{uri_re}$".format(uri_re=URI_RE), re.VERBOSE)
+# Compiled URI-reference regex rule. URI-reference is defined as: URI / relative-ref
+URI_REF_RE_COMP = re.compile(r"^(?:{uri_re}|{relative_ref})$".format(
+       uri_re=URI_RE,
+       relative_ref=RELATIVE_REF_RE,
+), re.VERBOSE)
+
+
+def validate_rfc3986(url, rule='URI'):
+    """
+    Validates strings according to RFC3986
+
+    :param url: String cointaining URI to validate
+    :param rule: It could be 'URI' (default) or 'URI_reference'.
+    :return: True or False
+    """
+    if rule == 'URI':
+        return URI_RE_COMP.match(url)
+    elif rule == 'URI_reference':
+        return URI_REF_RE_COMP.match(url)
+    else:
+        raise ValueError('Invalid rule')

venv/etc/jupyter/jupyter_server_config.d/jupyter_server_terminals.json

@@ -0,0 +1,7 @@
+{
+  "ServerApp": {
+    "jpserver_extensions": {
+      "jupyter_server_terminals": true
+    }
+  }
+}

venv/etc/jupyter/jupyter_server_config.d/jupyterlab.json

@@ -0,0 +1,7 @@
+{
+  "ServerApp": {
+    "jpserver_extensions": {
+      "jupyterlab": true
+    }
+  }
+}

venv/etc/jupyter/jupyter_server_config.d/notebook.json

@@ -0,0 +1,7 @@
+{
+  "ServerApp": {
+    "jpserver_extensions": {
+      "notebook": true
+    }
+  }
+}

venv/etc/jupyter/jupyter_server_config.d/notebook_shim.json

@@ -0,0 +1,7 @@
+{
+    "ServerApp": {
+        "jpserver_extensions": {
+            "notebook_shim": true
+        }
+    }
+}

venv/etc/jupyter/labconfig/page_config.json

@@ -0,0 +1,3 @@
+{
+  "lockedExtensions": {}
+}

venv/etc/jupyter/nbconfig/notebook.d/widgetsnbextension.json

@@ -0,0 +1,5 @@
+{
+  "load_extensions": {
+    "jupyter-js-widgets/extension": true
+  }
+}