diff --git a/.gitattributes b/.gitattributes
index 3d1a48c02593a996f8bae4bd3e2af07f1648e028..636d8530afcb72d184f17dba7383f59838e678d6 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -155,3 +155,4 @@ parrot/lib/python3.10/site-packages/wandb/sdk/__pycache__/wandb_run.cpython-310.
 parrot/lib/python3.10/site-packages/wandb/sdk/internal/__pycache__/internal_api.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libgomp.so.1 filter=lfs diff=lfs merge=lfs -text
 parrot/lib/python3.10/site-packages/huggingface_hub/inference/_generated/__pycache__/_async_client.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text
+parrot/lib/libquadmath.so.0.0.0 filter=lfs diff=lfs merge=lfs -text
diff --git a/parrot/lib/libquadmath.so.0.0.0 b/parrot/lib/libquadmath.so.0.0.0
new file mode 100644
index 0000000000000000000000000000000000000000..cd082c15339041642f25b85e32bd65b9e0393619
--- /dev/null
+++ b/parrot/lib/libquadmath.so.0.0.0
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:10c6fadba4c2f6d77e836a50aadbd92e95b137a85eb01b1ca183b50d8f39a2c6
+size 1009408
diff --git a/parrot/lib/python3.10/site-packages/git/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d30c8f82de88bc88701d8984718c834fa85263b4
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/__pycache__/cmd.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/__pycache__/cmd.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac60fdc318a12af4c93ad4d19db280cbe2ac2906
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/__pycache__/cmd.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/__pycache__/compat.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/__pycache__/compat.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fa88f77cfcdc68dfa207ec03f7d7f61bc5ad060f
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/__pycache__/compat.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/__pycache__/db.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/__pycache__/db.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e7fb12f7eb30781d700a2e934c297c574ec7840
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/__pycache__/db.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/__pycache__/exc.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/__pycache__/exc.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8743a0b64ef5d45f3adb2de549e9bf27eab4c8fa
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/__pycache__/exc.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/__pycache__/remote.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/__pycache__/remote.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2040dd97fba1ef0acf54b3ae57abf47aa38ec46f
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/__pycache__/remote.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/__pycache__/types.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/__pycache__/types.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4d9337b41cd86a20ebf0fc3c363fc977a701ab7f
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/__pycache__/types.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/config.py b/parrot/lib/python3.10/site-packages/git/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ce9b123f920bdefb127f696b6a01543ed3c9e65
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/config.py
@@ -0,0 +1,944 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Parser for reading and writing configuration files."""
+
+__all__ = ["GitConfigParser", "SectionConstraint"]
+
+import abc
+import configparser as cp
+import fnmatch
+from functools import wraps
+import inspect
+from io import BufferedReader, IOBase
+import logging
+import os
+import os.path as osp
+import re
+import sys
+
+from git.compat import defenc, force_text
+from git.util import LockFile
+
+# typing-------------------------------------------------------
+
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    IO,
+    List,
+    Dict,
+    Sequence,
+    TYPE_CHECKING,
+    Tuple,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from git.types import Lit_config_levels, ConfigLevels_Tup, PathLike, assert_never, _T
+
+if TYPE_CHECKING:
+    from io import BytesIO
+
+    from git.repo.base import Repo
+
+T_ConfigParser = TypeVar("T_ConfigParser", bound="GitConfigParser")
+T_OMD_value = TypeVar("T_OMD_value", str, bytes, int, float, bool)
+
+if sys.version_info[:3] < (3, 7, 2):
+    # typing.Ordereddict not added until Python 3.7.2.
+    from collections import OrderedDict
+
+    OrderedDict_OMD = OrderedDict
+else:
+    from typing import OrderedDict
+
+    OrderedDict_OMD = OrderedDict[str, List[T_OMD_value]]  # type: ignore[assignment, misc]
+
+# -------------------------------------------------------------
+
+_logger = logging.getLogger(__name__)
+
+CONFIG_LEVELS: ConfigLevels_Tup = ("system", "user", "global", "repository")
+"""The configuration level of a configuration file."""
+
+CONDITIONAL_INCLUDE_REGEXP = re.compile(r"(?<=includeIf )\"(gitdir|gitdir/i|onbranch):(.+)\"")
+"""Section pattern to detect conditional includes.
+
+See: https://git-scm.com/docs/git-config#_conditional_includes
+"""
+
+
+class MetaParserBuilder(abc.ABCMeta):  # noqa: B024
+    """Utility class wrapping base-class methods into decorators that assure read-only
+    properties."""
+
+    def __new__(cls, name: str, bases: Tuple, clsdict: Dict[str, Any]) -> "MetaParserBuilder":
+        """Equip all base-class methods with a needs_values decorator, and all non-const
+        methods with a :func:`set_dirty_and_flush_changes` decorator in addition to
+        that.
+        """
+        kmm = "_mutating_methods_"
+        if kmm in clsdict:
+            mutating_methods = clsdict[kmm]
+            for base in bases:
+                methods = (t for t in inspect.getmembers(base, inspect.isroutine) if not t[0].startswith("_"))
+                for name, method in methods:
+                    if name in clsdict:
+                        continue
+                    method_with_values = needs_values(method)
+                    if name in mutating_methods:
+                        method_with_values = set_dirty_and_flush_changes(method_with_values)
+                    # END mutating methods handling
+
+                    clsdict[name] = method_with_values
+                # END for each name/method pair
+            # END for each base
+        # END if mutating methods configuration is set
+
+        new_type = super().__new__(cls, name, bases, clsdict)
+        return new_type
+
+
+def needs_values(func: Callable[..., _T]) -> Callable[..., _T]:
+    """Return a method for ensuring we read values (on demand) before we try to access
+    them."""
+
+    @wraps(func)
+    def assure_data_present(self: "GitConfigParser", *args: Any, **kwargs: Any) -> _T:
+        self.read()
+        return func(self, *args, **kwargs)
+
+    # END wrapper method
+    return assure_data_present
+
+
+def set_dirty_and_flush_changes(non_const_func: Callable[..., _T]) -> Callable[..., _T]:
+    """Return a method that checks whether given non constant function may be called.
+
+    If so, the instance will be set dirty. Additionally, we flush the changes right to
+    disk.
+    """
+
+    def flush_changes(self: "GitConfigParser", *args: Any, **kwargs: Any) -> _T:
+        rval = non_const_func(self, *args, **kwargs)
+        self._dirty = True
+        self.write()
+        return rval
+
+    # END wrapper method
+    flush_changes.__name__ = non_const_func.__name__
+    return flush_changes
+
+
+class SectionConstraint(Generic[T_ConfigParser]):
+    """Constrains a ConfigParser to only option commands which are constrained to
+    always use the section we have been initialized with.
+
+    It supports all ConfigParser methods that operate on an option.
+
+    :note:
+        If used as a context manager, will release the wrapped ConfigParser.
+    """
+
+    __slots__ = ("_config", "_section_name")
+
+    _valid_attrs_ = (
+        "get_value",
+        "set_value",
+        "get",
+        "set",
+        "getint",
+        "getfloat",
+        "getboolean",
+        "has_option",
+        "remove_section",
+        "remove_option",
+        "options",
+    )
+
+    def __init__(self, config: T_ConfigParser, section: str) -> None:
+        self._config = config
+        self._section_name = section
+
+    def __del__(self) -> None:
+        # Yes, for some reason, we have to call it explicitly for it to work in PY3 !
+        # Apparently __del__ doesn't get call anymore if refcount becomes 0
+        # Ridiculous ... .
+        self._config.release()
+
+    def __getattr__(self, attr: str) -> Any:
+        if attr in self._valid_attrs_:
+            return lambda *args, **kwargs: self._call_config(attr, *args, **kwargs)
+        return super().__getattribute__(attr)
+
+    def _call_config(self, method: str, *args: Any, **kwargs: Any) -> Any:
+        """Call the configuration at the given method which must take a section name as
+        first argument."""
+        return getattr(self._config, method)(self._section_name, *args, **kwargs)
+
+    @property
+    def config(self) -> T_ConfigParser:
+        """return: ConfigParser instance we constrain"""
+        return self._config
+
+    def release(self) -> None:
+        """Equivalent to :meth:`GitConfigParser.release`, which is called on our
+        underlying parser instance."""
+        return self._config.release()
+
+    def __enter__(self) -> "SectionConstraint[T_ConfigParser]":
+        self._config.__enter__()
+        return self
+
+    def __exit__(self, exception_type: str, exception_value: str, traceback: str) -> None:
+        self._config.__exit__(exception_type, exception_value, traceback)
+
+
+class _OMD(OrderedDict_OMD):
+    """Ordered multi-dict."""
+
+    def __setitem__(self, key: str, value: _T) -> None:
+        super().__setitem__(key, [value])
+
+    def add(self, key: str, value: Any) -> None:
+        if key not in self:
+            super().__setitem__(key, [value])
+            return
+
+        super().__getitem__(key).append(value)
+
+    def setall(self, key: str, values: List[_T]) -> None:
+        super().__setitem__(key, values)
+
+    def __getitem__(self, key: str) -> Any:
+        return super().__getitem__(key)[-1]
+
+    def getlast(self, key: str) -> Any:
+        return super().__getitem__(key)[-1]
+
+    def setlast(self, key: str, value: Any) -> None:
+        if key not in self:
+            super().__setitem__(key, [value])
+            return
+
+        prior = super().__getitem__(key)
+        prior[-1] = value
+
+    def get(self, key: str, default: Union[_T, None] = None) -> Union[_T, None]:
+        return super().get(key, [default])[-1]
+
+    def getall(self, key: str) -> List[_T]:
+        return super().__getitem__(key)
+
+    def items(self) -> List[Tuple[str, _T]]:  # type: ignore[override]
+        """List of (key, last value for key)."""
+        return [(k, self[k]) for k in self]
+
+    def items_all(self) -> List[Tuple[str, List[_T]]]:
+        """List of (key, list of values for key)."""
+        return [(k, self.getall(k)) for k in self]
+
+
+def get_config_path(config_level: Lit_config_levels) -> str:
+    # We do not support an absolute path of the gitconfig on Windows.
+    # Use the global config instead.
+    if sys.platform == "win32" and config_level == "system":
+        config_level = "global"
+
+    if config_level == "system":
+        return "/etc/gitconfig"
+    elif config_level == "user":
+        config_home = os.environ.get("XDG_CONFIG_HOME") or osp.join(os.environ.get("HOME", "~"), ".config")
+        return osp.normpath(osp.expanduser(osp.join(config_home, "git", "config")))
+    elif config_level == "global":
+        return osp.normpath(osp.expanduser("~/.gitconfig"))
+    elif config_level == "repository":
+        raise ValueError("No repo to get repository configuration from. Use Repo._get_config_path")
+    else:
+        # Should not reach here. Will raise ValueError if does. Static typing will warn
+        # about missing elifs.
+        assert_never(  # type: ignore[unreachable]
+            config_level,
+            ValueError(f"Invalid configuration level: {config_level!r}"),
+        )
+
+
+class GitConfigParser(cp.RawConfigParser, metaclass=MetaParserBuilder):
+    """Implements specifics required to read git style configuration files.
+
+    This variation behaves much like the :manpage:`git-config(1)` command, such that the
+    configuration will be read on demand based on the filepath given during
+    initialization.
+
+    The changes will automatically be written once the instance goes out of scope, but
+    can be triggered manually as well.
+
+    The configuration file will be locked if you intend to change values preventing
+    other instances to write concurrently.
+
+    :note:
+        The config is case-sensitive even when queried, hence section and option names
+        must match perfectly.
+
+    :note:
+        If used as a context manager, this will release the locked file.
+    """
+
+    # { Configuration
+    t_lock = LockFile
+    """The lock type determines the type of lock to use in new configuration readers.
+
+    They must be compatible to the :class:`~git.util.LockFile` interface.
+    A suitable alternative would be the :class:`~git.util.BlockingLockFile`.
+    """
+
+    re_comment = re.compile(r"^\s*[#;]")
+    # } END configuration
+
+    optvalueonly_source = r"\s*(?P<option>[^:=\s][^:=]*)"
+
+    OPTVALUEONLY = re.compile(optvalueonly_source)
+
+    OPTCRE = re.compile(optvalueonly_source + r"\s*(?P<vi>[:=])\s*" + r"(?P<value>.*)$")
+
+    del optvalueonly_source
+
+    _mutating_methods_ = ("add_section", "remove_section", "remove_option", "set")
+    """Names of :class:`~configparser.RawConfigParser` methods able to change the
+    instance."""
+
+    def __init__(
+        self,
+        file_or_files: Union[None, PathLike, "BytesIO", Sequence[Union[PathLike, "BytesIO"]]] = None,
+        read_only: bool = True,
+        merge_includes: bool = True,
+        config_level: Union[Lit_config_levels, None] = None,
+        repo: Union["Repo", None] = None,
+    ) -> None:
+        """Initialize a configuration reader to read the given `file_or_files` and to
+        possibly allow changes to it by setting `read_only` False.
+
+        :param file_or_files:
+            A file path or file object, or a sequence of possibly more than one of them.
+
+        :param read_only:
+            If ``True``, the ConfigParser may only read the data, but not change it.
+            If ``False``, only a single file path or file object may be given. We will
+            write back the changes when they happen, or when the ConfigParser is
+            released. This will not happen if other configuration files have been
+            included.
+
+        :param merge_includes:
+            If ``True``, we will read files mentioned in ``[include]`` sections and
+            merge their contents into ours. This makes it impossible to write back an
+            individual configuration file. Thus, if you want to modify a single
+            configuration file, turn this off to leave the original dataset unaltered
+            when reading it.
+
+        :param repo:
+            Reference to repository to use if ``[includeIf]`` sections are found in
+            configuration files.
+        """
+        cp.RawConfigParser.__init__(self, dict_type=_OMD)
+        self._dict: Callable[..., _OMD]
+        self._defaults: _OMD
+        self._sections: _OMD
+
+        # Used in Python 3. Needs to stay in sync with sections for underlying
+        # implementation to work.
+        if not hasattr(self, "_proxies"):
+            self._proxies = self._dict()
+
+        if file_or_files is not None:
+            self._file_or_files: Union[PathLike, "BytesIO", Sequence[Union[PathLike, "BytesIO"]]] = file_or_files
+        else:
+            if config_level is None:
+                if read_only:
+                    self._file_or_files = [
+                        get_config_path(cast(Lit_config_levels, f)) for f in CONFIG_LEVELS if f != "repository"
+                    ]
+                else:
+                    raise ValueError("No configuration level or configuration files specified")
+            else:
+                self._file_or_files = [get_config_path(config_level)]
+
+        self._read_only = read_only
+        self._dirty = False
+        self._is_initialized = False
+        self._merge_includes = merge_includes
+        self._repo = repo
+        self._lock: Union["LockFile", None] = None
+        self._acquire_lock()
+
+    def _acquire_lock(self) -> None:
+        if not self._read_only:
+            if not self._lock:
+                if isinstance(self._file_or_files, (str, os.PathLike)):
+                    file_or_files = self._file_or_files
+                elif isinstance(self._file_or_files, (tuple, list, Sequence)):
+                    raise ValueError(
+                        "Write-ConfigParsers can operate on a single file only, multiple files have been passed"
+                    )
+                else:
+                    file_or_files = self._file_or_files.name
+
+                # END get filename from handle/stream
+                # Initialize lock base - we want to write.
+                self._lock = self.t_lock(file_or_files)
+            # END lock check
+
+            self._lock._obtain_lock()
+        # END read-only check
+
+    def __del__(self) -> None:
+        """Write pending changes if required and release locks."""
+        # NOTE: Only consistent in Python 2.
+        self.release()
+
+    def __enter__(self) -> "GitConfigParser":
+        self._acquire_lock()
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.release()
+
+    def release(self) -> None:
+        """Flush changes and release the configuration write lock. This instance must
+        not be used anymore afterwards.
+
+        In Python 3, it's required to explicitly release locks and flush changes, as
+        ``__del__`` is not called deterministically anymore.
+        """
+        # Checking for the lock here makes sure we do not raise during write()
+        # in case an invalid parser was created who could not get a lock.
+        if self.read_only or (self._lock and not self._lock._has_lock()):
+            return
+
+        try:
+            self.write()
+        except IOError:
+            _logger.error("Exception during destruction of GitConfigParser", exc_info=True)
+        except ReferenceError:
+            # This happens in Python 3... and usually means that some state cannot be
+            # written as the sections dict cannot be iterated. This usually happens when
+            # the interpreter is shutting down. Can it be fixed?
+            pass
+        finally:
+            if self._lock is not None:
+                self._lock._release_lock()
+
+    def optionxform(self, optionstr: str) -> str:
+        """Do not transform options in any way when writing."""
+        return optionstr
+
+    def _read(self, fp: Union[BufferedReader, IO[bytes]], fpname: str) -> None:
+        """Originally a direct copy of the Python 2.4 version of
+        :meth:`RawConfigParser._read <configparser.RawConfigParser._read>`, to ensure it
+        uses ordered dicts.
+
+        The ordering bug was fixed in Python 2.4, and dict itself keeps ordering since
+        Python 3.7. This has some other changes, especially that it ignores initial
+        whitespace, since git uses tabs. (Big comments are removed to be more compact.)
+        """
+        cursect = None  # None, or a dictionary.
+        optname = None
+        lineno = 0
+        is_multi_line = False
+        e = None  # None, or an exception.
+
+        def string_decode(v: str) -> str:
+            if v[-1] == "\\":
+                v = v[:-1]
+            # END cut trailing escapes to prevent decode error
+
+            return v.encode(defenc).decode("unicode_escape")
+
+        # END string_decode
+
+        while True:
+            # We assume to read binary!
+            line = fp.readline().decode(defenc)
+            if not line:
+                break
+            lineno = lineno + 1
+            # Comment or blank line?
+            if line.strip() == "" or self.re_comment.match(line):
+                continue
+            if line.split(None, 1)[0].lower() == "rem" and line[0] in "rR":
+                # No leading whitespace.
+                continue
+
+            # Is it a section header?
+            mo = self.SECTCRE.match(line.strip())
+            if not is_multi_line and mo:
+                sectname: str = mo.group("header").strip()
+                if sectname in self._sections:
+                    cursect = self._sections[sectname]
+                elif sectname == cp.DEFAULTSECT:
+                    cursect = self._defaults
+                else:
+                    cursect = self._dict((("__name__", sectname),))
+                    self._sections[sectname] = cursect
+                    self._proxies[sectname] = None
+                # So sections can't start with a continuation line.
+                optname = None
+            # No section header in the file?
+            elif cursect is None:
+                raise cp.MissingSectionHeaderError(fpname, lineno, line)
+            # An option line?
+            elif not is_multi_line:
+                mo = self.OPTCRE.match(line)
+                if mo:
+                    # We might just have handled the last line, which could contain a quotation we want to remove.
+                    optname, vi, optval = mo.group("option", "vi", "value")
+                    if vi in ("=", ":") and ";" in optval and not optval.strip().startswith('"'):
+                        pos = optval.find(";")
+                        if pos != -1 and optval[pos - 1].isspace():
+                            optval = optval[:pos]
+                    optval = optval.strip()
+                    if optval == '""':
+                        optval = ""
+                    # END handle empty string
+                    optname = self.optionxform(optname.rstrip())
+                    if len(optval) > 1 and optval[0] == '"' and optval[-1] != '"':
+                        is_multi_line = True
+                        optval = string_decode(optval[1:])
+                    # END handle multi-line
+                    # Preserves multiple values for duplicate optnames.
+                    cursect.add(optname, optval)
+                else:
+                    # Check if it's an option with no value - it's just ignored by git.
+                    if not self.OPTVALUEONLY.match(line):
+                        if not e:
+                            e = cp.ParsingError(fpname)
+                        e.append(lineno, repr(line))
+                    continue
+            else:
+                line = line.rstrip()
+                if line.endswith('"'):
+                    is_multi_line = False
+                    line = line[:-1]
+                # END handle quotations
+                optval = cursect.getlast(optname)
+                cursect.setlast(optname, optval + string_decode(line))
+            # END parse section or option
+        # END while reading
+
+        # If any parsing errors occurred, raise an exception.
+        if e:
+            raise e
+
+    def _has_includes(self) -> Union[bool, int]:
+        return self._merge_includes and len(self._included_paths())
+
+    def _included_paths(self) -> List[Tuple[str, str]]:
+        """List all paths that must be included to configuration.
+
+        :return:
+            The list of paths, where each path is a tuple of (option, value).
+        """
+        paths = []
+
+        for section in self.sections():
+            if section == "include":
+                paths += self.items(section)
+
+            match = CONDITIONAL_INCLUDE_REGEXP.search(section)
+            if match is None or self._repo is None:
+                continue
+
+            keyword = match.group(1)
+            value = match.group(2).strip()
+
+            if keyword in ["gitdir", "gitdir/i"]:
+                value = osp.expanduser(value)
+
+                if not any(value.startswith(s) for s in ["./", "/"]):
+                    value = "**/" + value
+                if value.endswith("/"):
+                    value += "**"
+
+                # Ensure that glob is always case insensitive if required.
+                if keyword.endswith("/i"):
+                    value = re.sub(
+                        r"[a-zA-Z]",
+                        lambda m: "[{}{}]".format(m.group().lower(), m.group().upper()),
+                        value,
+                    )
+                if self._repo.git_dir:
+                    if fnmatch.fnmatchcase(str(self._repo.git_dir), value):
+                        paths += self.items(section)
+
+            elif keyword == "onbranch":
+                try:
+                    branch_name = self._repo.active_branch.name
+                except TypeError:
+                    # Ignore section if active branch cannot be retrieved.
+                    continue
+
+                if fnmatch.fnmatchcase(branch_name, value):
+                    paths += self.items(section)
+
+        return paths
+
+    def read(self) -> None:  # type: ignore[override]
+        """Read the data stored in the files we have been initialized with.
+
+        This will ignore files that cannot be read, possibly leaving an empty
+        configuration.
+
+        :raise IOError:
+            If a file cannot be handled.
+        """
+        if self._is_initialized:
+            return
+        self._is_initialized = True
+
+        files_to_read: List[Union[PathLike, IO]] = [""]
+        if isinstance(self._file_or_files, (str, os.PathLike)):
+            # For str or Path, as str is a type of Sequence.
+            files_to_read = [self._file_or_files]
+        elif not isinstance(self._file_or_files, (tuple, list, Sequence)):
+            # Could merge with above isinstance once runtime type known.
+            files_to_read = [self._file_or_files]
+        else:  # For lists or tuples.
+            files_to_read = list(self._file_or_files)
+        # END ensure we have a copy of the paths to handle
+
+        seen = set(files_to_read)
+        num_read_include_files = 0
+        while files_to_read:
+            file_path = files_to_read.pop(0)
+            file_ok = False
+
+            if hasattr(file_path, "seek"):
+                # Must be a file-object.
+                # TODO: Replace cast with assert to narrow type, once sure.
+                file_path = cast(IO[bytes], file_path)
+                self._read(file_path, file_path.name)
+            else:
+                # Assume a path if it is not a file-object.
+                file_path = cast(PathLike, file_path)
+                try:
+                    with open(file_path, "rb") as fp:
+                        file_ok = True
+                        self._read(fp, fp.name)
+                except IOError:
+                    continue
+
+            # Read includes and append those that we didn't handle yet. We expect all
+            # paths to be normalized and absolute (and will ensure that is the case).
+            if self._has_includes():
+                for _, include_path in self._included_paths():
+                    if include_path.startswith("~"):
+                        include_path = osp.expanduser(include_path)
+                    if not osp.isabs(include_path):
+                        if not file_ok:
+                            continue
+                        # END ignore relative paths if we don't know the configuration file path
+                        file_path = cast(PathLike, file_path)
+                        assert osp.isabs(file_path), "Need absolute paths to be sure our cycle checks will work"
+                        include_path = osp.join(osp.dirname(file_path), include_path)
+                    # END make include path absolute
+                    include_path = osp.normpath(include_path)
+                    if include_path in seen or not os.access(include_path, os.R_OK):
+                        continue
+                    seen.add(include_path)
+                    # Insert included file to the top to be considered first.
+                    files_to_read.insert(0, include_path)
+                    num_read_include_files += 1
+                # END each include path in configuration file
+            # END handle includes
+        # END for each file object to read
+
+        # If there was no file included, we can safely write back (potentially) the
+        # configuration file without altering its meaning.
+        if num_read_include_files == 0:
+            self._merge_includes = False
+
+    def _write(self, fp: IO) -> None:
+        """Write an .ini-format representation of the configuration state in
+        git compatible format."""
+
+        def write_section(name: str, section_dict: _OMD) -> None:
+            fp.write(("[%s]\n" % name).encode(defenc))
+
+            values: Sequence[str]  # Runtime only gets str in tests, but should be whatever _OMD stores.
+            v: str
+            for key, values in section_dict.items_all():
+                if key == "__name__":
+                    continue
+
+                for v in values:
+                    fp.write(("\t%s = %s\n" % (key, self._value_to_string(v).replace("\n", "\n\t"))).encode(defenc))
+                # END if key is not __name__
+
+        # END section writing
+
+        if self._defaults:
+            write_section(cp.DEFAULTSECT, self._defaults)
+        value: _OMD
+
+        for name, value in self._sections.items():
+            write_section(name, value)
+
+    def items(self, section_name: str) -> List[Tuple[str, str]]:  # type: ignore[override]
+        """:return: list((option, value), ...) pairs of all items in the given section"""
+        return [(k, v) for k, v in super().items(section_name) if k != "__name__"]
+
+    def items_all(self, section_name: str) -> List[Tuple[str, List[str]]]:
+        """:return: list((option, [values...]), ...) pairs of all items in the given section"""
+        rv = _OMD(self._defaults)
+
+        for k, vs in self._sections[section_name].items_all():
+            if k == "__name__":
+                continue
+
+            if k in rv and rv.getall(k) == vs:
+                continue
+
+            for v in vs:
+                rv.add(k, v)
+
+        return rv.items_all()
+
+    @needs_values
+    def write(self) -> None:
+        """Write changes to our file, if there are changes at all.
+
+        :raise IOError:
+            If this is a read-only writer instance or if we could not obtain a file
+            lock.
+        """
+        self._assure_writable("write")
+        if not self._dirty:
+            return
+
+        if isinstance(self._file_or_files, (list, tuple)):
+            raise AssertionError(
+                "Cannot write back if there is not exactly a single file to write to, have %i files"
+                % len(self._file_or_files)
+            )
+        # END assert multiple files
+
+        if self._has_includes():
+            _logger.debug(
+                "Skipping write-back of configuration file as include files were merged in."
+                + "Set merge_includes=False to prevent this."
+            )
+            return
+        # END stop if we have include files
+
+        fp = self._file_or_files
+
+        # We have a physical file on disk, so get a lock.
+        is_file_lock = isinstance(fp, (str, os.PathLike, IOBase))  # TODO: Use PathLike (having dropped 3.5).
+        if is_file_lock and self._lock is not None:  # Else raise error?
+            self._lock._obtain_lock()
+
+        if not hasattr(fp, "seek"):
+            fp = cast(PathLike, fp)
+            with open(fp, "wb") as fp_open:
+                self._write(fp_open)
+        else:
+            fp = cast("BytesIO", fp)
+            fp.seek(0)
+            # Make sure we do not overwrite into an existing file.
+            if hasattr(fp, "truncate"):
+                fp.truncate()
+            self._write(fp)
+
+    def _assure_writable(self, method_name: str) -> None:
+        if self.read_only:
+            raise IOError("Cannot execute non-constant method %s.%s" % (self, method_name))
+
+    def add_section(self, section: str) -> None:
+        """Assures added options will stay in order."""
+        return super().add_section(section)
+
+    @property
+    def read_only(self) -> bool:
+        """:return: ``True`` if this instance may change the configuration file"""
+        return self._read_only
+
+    # FIXME: Figure out if default or return type can really include bool.
+    def get_value(
+        self,
+        section: str,
+        option: str,
+        default: Union[int, float, str, bool, None] = None,
+    ) -> Union[int, float, str, bool]:
+        """Get an option's value.
+
+        If multiple values are specified for this option in the section, the last one
+        specified is returned.
+
+        :param default:
+            If not ``None``, the given default value will be returned in case the option
+            did not exist.
+
+        :return:
+            A properly typed value, either int, float or string
+
+        :raise TypeError:
+            In case the value could not be understood.
+            Otherwise the exceptions known to the ConfigParser will be raised.
+        """
+        try:
+            valuestr = self.get(section, option)
+        except Exception:
+            if default is not None:
+                return default
+            raise
+
+        return self._string_to_value(valuestr)
+
+    def get_values(
+        self,
+        section: str,
+        option: str,
+        default: Union[int, float, str, bool, None] = None,
+    ) -> List[Union[int, float, str, bool]]:
+        """Get an option's values.
+
+        If multiple values are specified for this option in the section, all are
+        returned.
+
+        :param default:
+            If not ``None``, a list containing the given default value will be returned
+            in case the option did not exist.
+
+        :return:
+            A list of properly typed values, either int, float or string
+
+        :raise TypeError:
+            In case the value could not be understood.
+            Otherwise the exceptions known to the ConfigParser will be raised.
+        """
+        try:
+            self.sections()
+            lst = self._sections[section].getall(option)
+        except Exception:
+            if default is not None:
+                return [default]
+            raise
+
+        return [self._string_to_value(valuestr) for valuestr in lst]
+
+    def _string_to_value(self, valuestr: str) -> Union[int, float, str, bool]:
+        types = (int, float)
+        for numtype in types:
+            try:
+                val = numtype(valuestr)
+                # truncated value ?
+                if val != float(valuestr):
+                    continue
+                return val
+            except (ValueError, TypeError):
+                continue
+        # END for each numeric type
+
+        # Try boolean values as git uses them.
+        vl = valuestr.lower()
+        if vl == "false":
+            return False
+        if vl == "true":
+            return True
+
+        if not isinstance(valuestr, str):
+            raise TypeError(
+                "Invalid value type: only int, long, float and str are allowed",
+                valuestr,
+            )
+
+        return valuestr
+
+    def _value_to_string(self, value: Union[str, bytes, int, float, bool]) -> str:
+        if isinstance(value, (int, float, bool)):
+            return str(value)
+        return force_text(value)
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def set_value(self, section: str, option: str, value: Union[str, bytes, int, float, bool]) -> "GitConfigParser":
+        """Set the given option in section to the given value.
+
+        This will create the section if required, and will not throw as opposed to the
+        default ConfigParser ``set`` method.
+
+        :param section:
+            Name of the section in which the option resides or should reside.
+
+        :param option:
+            Name of the options whose value to set.
+
+        :param value:
+            Value to set the option to. It must be a string or convertible to a string.
+
+        :return:
+            This instance
+        """
+        if not self.has_section(section):
+            self.add_section(section)
+        self.set(section, option, self._value_to_string(value))
+        return self
+
+    @needs_values
+    @set_dirty_and_flush_changes
+    def add_value(self, section: str, option: str, value: Union[str, bytes, int, float, bool]) -> "GitConfigParser":
+        """Add a value for the given option in section.
+
+        This will create the section if required, and will not throw as opposed to the
+        default ConfigParser ``set`` method. The value becomes the new value of the
+        option as returned by :meth:`get_value`, and appends to the list of values
+        returned by :meth:`get_values`.
+
+        :param section:
+            Name of the section in which the option resides or should reside.
+
+        :param option:
+            Name of the option.
+
+        :param value:
+            Value to add to option. It must be a string or convertible to a string.
+
+        :return:
+            This instance
+        """
+        if not self.has_section(section):
+            self.add_section(section)
+        self._sections[section].add(option, self._value_to_string(value))
+        return self
+
+    def rename_section(self, section: str, new_name: str) -> "GitConfigParser":
+        """Rename the given section to `new_name`.
+
+        :raise ValueError:
+            If:
+
+            * `section` doesn't exist.
+            * A section with `new_name` does already exist.
+
+        :return:
+            This instance
+        """
+        if not self.has_section(section):
+            raise ValueError("Source section '%s' doesn't exist" % section)
+        if self.has_section(new_name):
+            raise ValueError("Destination section '%s' already exists" % new_name)
+
+        super().add_section(new_name)
+        new_section = self._sections[new_name]
+        for k, vs in self.items_all(section):
+            new_section.setall(k, vs)
+        # END for each value to copy
+
+        # This call writes back the changes, which is why we don't have the respective
+        # decorator.
+        self.remove_section(section)
+        return self
diff --git a/parrot/lib/python3.10/site-packages/git/index/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/index/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..148aa82785ef742ec636bde00efa5085d20f749f
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/index/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/index/__pycache__/base.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/index/__pycache__/base.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c8c6f6b2fff4f5b369ee24f107bcfda598b17f0d
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/index/__pycache__/base.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/index/__pycache__/fun.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/index/__pycache__/fun.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2bce0c7025e13119947d4b586a2e47bd74bd1d0a
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/index/__pycache__/fun.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/index/fun.py b/parrot/lib/python3.10/site-packages/git/index/fun.py
new file mode 100644
index 0000000000000000000000000000000000000000..59cce6ae6ef845d686b4724fa99681805d9638a1
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/index/fun.py
@@ -0,0 +1,465 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Standalone functions to accompany the index implementation and make it more
+versatile."""
+
+__all__ = [
+    "write_cache",
+    "read_cache",
+    "write_tree_from_cache",
+    "entry_key",
+    "stat_mode_to_index_mode",
+    "S_IFGITLINK",
+    "run_commit_hook",
+    "hook_path",
+]
+
+from io import BytesIO
+import os
+import os.path as osp
+from pathlib import Path
+from stat import S_IFDIR, S_IFLNK, S_IFMT, S_IFREG, S_ISDIR, S_ISLNK, S_IXUSR
+import subprocess
+import sys
+
+from gitdb.base import IStream
+from gitdb.typ import str_tree_type
+
+from git.cmd import handle_process_output, safer_popen
+from git.compat import defenc, force_bytes, force_text, safe_decode
+from git.exc import HookExecutionError, UnmergedEntriesError
+from git.objects.fun import (
+    traverse_tree_recursive,
+    traverse_trees_recursive,
+    tree_to_stream,
+)
+from git.util import IndexFileSHA1Writer, finalize_process
+
+from .typ import BaseIndexEntry, IndexEntry, CE_NAMEMASK, CE_STAGESHIFT
+from .util import pack, unpack
+
+# typing -----------------------------------------------------------------------------
+
+from typing import Dict, IO, List, Sequence, TYPE_CHECKING, Tuple, Type, Union, cast
+
+from git.types import PathLike
+
+if TYPE_CHECKING:
+    from git.db import GitCmdObjectDB
+    from git.objects.tree import TreeCacheTup
+
+    from .base import IndexFile
+
+# ------------------------------------------------------------------------------------
+
+S_IFGITLINK = S_IFLNK | S_IFDIR
+"""Flags for a submodule."""
+
+CE_NAMEMASK_INV = ~CE_NAMEMASK
+
+
+def hook_path(name: str, git_dir: PathLike) -> str:
+    """:return: path to the given named hook in the given git repository directory"""
+    return osp.join(git_dir, "hooks", name)
+
+
+def _has_file_extension(path: str) -> str:
+    return osp.splitext(path)[1]
+
+
+def run_commit_hook(name: str, index: "IndexFile", *args: str) -> None:
+    """Run the commit hook of the given name. Silently ignore hooks that do not exist.
+
+    :param name:
+        Name of hook, like ``pre-commit``.
+
+    :param index:
+        :class:`~git.index.base.IndexFile` instance.
+
+    :param args:
+        Arguments passed to hook file.
+
+    :raise git.exc.HookExecutionError:
+    """
+    hp = hook_path(name, index.repo.git_dir)
+    if not os.access(hp, os.X_OK):
+        return
+
+    env = os.environ.copy()
+    env["GIT_INDEX_FILE"] = safe_decode(str(index.path))
+    env["GIT_EDITOR"] = ":"
+    cmd = [hp]
+    try:
+        if sys.platform == "win32" and not _has_file_extension(hp):
+            # Windows only uses extensions to determine how to open files
+            # (doesn't understand shebangs). Try using bash to run the hook.
+            relative_hp = Path(hp).relative_to(index.repo.working_dir).as_posix()
+            cmd = ["bash.exe", relative_hp]
+
+        process = safer_popen(
+            cmd + list(args),
+            env=env,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            cwd=index.repo.working_dir,
+        )
+    except Exception as ex:
+        raise HookExecutionError(hp, ex) from ex
+    else:
+        stdout_list: List[str] = []
+        stderr_list: List[str] = []
+        handle_process_output(process, stdout_list.append, stderr_list.append, finalize_process)
+        stdout = "".join(stdout_list)
+        stderr = "".join(stderr_list)
+        if process.returncode != 0:
+            stdout = force_text(stdout, defenc)
+            stderr = force_text(stderr, defenc)
+            raise HookExecutionError(hp, process.returncode, stderr, stdout)
+    # END handle return code
+
+
+def stat_mode_to_index_mode(mode: int) -> int:
+    """Convert the given mode from a stat call to the corresponding index mode and
+    return it."""
+    if S_ISLNK(mode):  # symlinks
+        return S_IFLNK
+    if S_ISDIR(mode) or S_IFMT(mode) == S_IFGITLINK:  # submodules
+        return S_IFGITLINK
+    return S_IFREG | (mode & S_IXUSR and 0o755 or 0o644)  # blobs with or without executable bit
+
+
+def write_cache(
+    entries: Sequence[Union[BaseIndexEntry, "IndexEntry"]],
+    stream: IO[bytes],
+    extension_data: Union[None, bytes] = None,
+    ShaStreamCls: Type[IndexFileSHA1Writer] = IndexFileSHA1Writer,
+) -> None:
+    """Write the cache represented by entries to a stream.
+
+    :param entries:
+        **Sorted** list of entries.
+
+    :param stream:
+        Stream to wrap into the AdapterStreamCls - it is used for final output.
+
+    :param ShaStreamCls:
+        Type to use when writing to the stream. It produces a sha while writing to it,
+        before the data is passed on to the wrapped stream.
+
+    :param extension_data:
+        Any kind of data to write as a trailer, it must begin a 4 byte identifier,
+        followed by its size (4 bytes).
+    """
+    # Wrap the stream into a compatible writer.
+    stream_sha = ShaStreamCls(stream)
+
+    tell = stream_sha.tell
+    write = stream_sha.write
+
+    # Header
+    version = 2
+    write(b"DIRC")
+    write(pack(">LL", version, len(entries)))
+
+    # Body
+    for entry in entries:
+        beginoffset = tell()
+        write(entry.ctime_bytes)  # ctime
+        write(entry.mtime_bytes)  # mtime
+        path_str = str(entry.path)
+        path: bytes = force_bytes(path_str, encoding=defenc)
+        plen = len(path) & CE_NAMEMASK  # Path length
+        assert plen == len(path), "Path %s too long to fit into index" % entry.path
+        flags = plen | (entry.flags & CE_NAMEMASK_INV)  # Clear possible previous values.
+        write(
+            pack(
+                ">LLLLLL20sH",
+                entry.dev,
+                entry.inode,
+                entry.mode,
+                entry.uid,
+                entry.gid,
+                entry.size,
+                entry.binsha,
+                flags,
+            )
+        )
+        write(path)
+        real_size = (tell() - beginoffset + 8) & ~7
+        write(b"\0" * ((beginoffset + real_size) - tell()))
+    # END for each entry
+
+    # Write previously cached extensions data.
+    if extension_data is not None:
+        stream_sha.write(extension_data)
+
+    # Write the sha over the content.
+    stream_sha.write_sha()
+
+
+def read_header(stream: IO[bytes]) -> Tuple[int, int]:
+    """Return tuple(version_long, num_entries) from the given stream."""
+    type_id = stream.read(4)
+    if type_id != b"DIRC":
+        raise AssertionError("Invalid index file header: %r" % type_id)
+    unpacked = cast(Tuple[int, int], unpack(">LL", stream.read(4 * 2)))
+    version, num_entries = unpacked
+
+    # TODO: Handle version 3: extended data, see read-cache.c.
+    assert version in (1, 2)
+    return version, num_entries
+
+
+def entry_key(*entry: Union[BaseIndexEntry, PathLike, int]) -> Tuple[PathLike, int]:
+    """
+    :return:
+        Key suitable to be used for the
+        :attr:`index.entries <git.index.base.IndexFile.entries>` dictionary.
+
+    :param entry:
+        One instance of type BaseIndexEntry or the path and the stage.
+    """
+
+    # def is_entry_key_tup(entry_key: Tuple) -> TypeGuard[Tuple[PathLike, int]]:
+    #     return isinstance(entry_key, tuple) and len(entry_key) == 2
+
+    if len(entry) == 1:
+        entry_first = entry[0]
+        assert isinstance(entry_first, BaseIndexEntry)
+        return (entry_first.path, entry_first.stage)
+    else:
+        # assert is_entry_key_tup(entry)
+        entry = cast(Tuple[PathLike, int], entry)
+        return entry
+    # END handle entry
+
+
+def read_cache(
+    stream: IO[bytes],
+) -> Tuple[int, Dict[Tuple[PathLike, int], "IndexEntry"], bytes, bytes]:
+    """Read a cache file from the given stream.
+
+    :return:
+        tuple(version, entries_dict, extension_data, content_sha)
+
+        * *version* is the integer version number.
+        * *entries_dict* is a dictionary which maps IndexEntry instances to a path at a
+          stage.
+        * *extension_data* is ``""`` or 4 bytes of type + 4 bytes of size + size bytes.
+        * *content_sha* is a 20 byte sha on all cache file contents.
+    """
+    version, num_entries = read_header(stream)
+    count = 0
+    entries: Dict[Tuple[PathLike, int], "IndexEntry"] = {}
+
+    read = stream.read
+    tell = stream.tell
+    while count < num_entries:
+        beginoffset = tell()
+        ctime = unpack(">8s", read(8))[0]
+        mtime = unpack(">8s", read(8))[0]
+        (dev, ino, mode, uid, gid, size, sha, flags) = unpack(">LLLLLL20sH", read(20 + 4 * 6 + 2))
+        path_size = flags & CE_NAMEMASK
+        path = read(path_size).decode(defenc)
+
+        real_size = (tell() - beginoffset + 8) & ~7
+        read((beginoffset + real_size) - tell())
+        entry = IndexEntry((mode, sha, flags, path, ctime, mtime, dev, ino, uid, gid, size))
+        # entry_key would be the method to use, but we save the effort.
+        entries[(path, entry.stage)] = entry
+        count += 1
+    # END for each entry
+
+    # The footer contains extension data and a sha on the content so far.
+    # Keep the extension footer,and verify we have a sha in the end.
+    # Extension data format is:
+    #   4 bytes ID
+    #   4 bytes length of chunk
+    #   Repeated 0 - N times
+    extension_data = stream.read(~0)
+    assert len(extension_data) > 19, (
+        "Index Footer was not at least a sha on content as it was only %i bytes in size" % len(extension_data)
+    )
+
+    content_sha = extension_data[-20:]
+
+    # Truncate the sha in the end as we will dynamically create it anyway.
+    extension_data = extension_data[:-20]
+
+    return (version, entries, extension_data, content_sha)
+
+
+def write_tree_from_cache(
+    entries: List[IndexEntry], odb: "GitCmdObjectDB", sl: slice, si: int = 0
+) -> Tuple[bytes, List["TreeCacheTup"]]:
+    R"""Create a tree from the given sorted list of entries and put the respective
+    trees into the given object database.
+
+    :param entries:
+        **Sorted** list of :class:`~git.index.typ.IndexEntry`\s.
+
+    :param odb:
+        Object database to store the trees in.
+
+    :param si:
+        Start index at which we should start creating subtrees.
+
+    :param sl:
+        Slice indicating the range we should process on the entries list.
+
+    :return:
+        tuple(binsha, list(tree_entry, ...))
+
+        A tuple of a sha and a list of tree entries being a tuple of hexsha, mode, name.
+    """
+    tree_items: List["TreeCacheTup"] = []
+
+    ci = sl.start
+    end = sl.stop
+    while ci < end:
+        entry = entries[ci]
+        if entry.stage != 0:
+            raise UnmergedEntriesError(entry)
+        # END abort on unmerged
+        ci += 1
+        rbound = entry.path.find("/", si)
+        if rbound == -1:
+            # It's not a tree.
+            tree_items.append((entry.binsha, entry.mode, entry.path[si:]))
+        else:
+            # Find common base range.
+            base = entry.path[si:rbound]
+            xi = ci
+            while xi < end:
+                oentry = entries[xi]
+                orbound = oentry.path.find("/", si)
+                if orbound == -1 or oentry.path[si:orbound] != base:
+                    break
+                # END abort on base mismatch
+                xi += 1
+            # END find common base
+
+            # Enter recursion.
+            # ci - 1 as we want to count our current item as well.
+            sha, _tree_entry_list = write_tree_from_cache(entries, odb, slice(ci - 1, xi), rbound + 1)
+            tree_items.append((sha, S_IFDIR, base))
+
+            # Skip ahead.
+            ci = xi
+        # END handle bounds
+    # END for each entry
+
+    # Finally create the tree.
+    sio = BytesIO()
+    tree_to_stream(tree_items, sio.write)  # Writes to stream as bytes, but doesn't change tree_items.
+    sio.seek(0)
+
+    istream = odb.store(IStream(str_tree_type, len(sio.getvalue()), sio))
+    return (istream.binsha, tree_items)
+
+
+def _tree_entry_to_baseindexentry(tree_entry: "TreeCacheTup", stage: int) -> BaseIndexEntry:
+    return BaseIndexEntry((tree_entry[1], tree_entry[0], stage << CE_STAGESHIFT, tree_entry[2]))
+
+
+def aggressive_tree_merge(odb: "GitCmdObjectDB", tree_shas: Sequence[bytes]) -> List[BaseIndexEntry]:
+    R"""
+    :return:
+        List of :class:`~git.index.typ.BaseIndexEntry`\s representing the aggressive
+        merge of the given trees. All valid entries are on stage 0, whereas the
+        conflicting ones are left on stage 1, 2 or 3, whereas stage 1 corresponds to the
+        common ancestor tree, 2 to our tree and 3 to 'their' tree.
+
+    :param tree_shas:
+        1, 2 or 3 trees as identified by their binary 20 byte shas. If 1 or two, the
+        entries will effectively correspond to the last given tree. If 3 are given, a 3
+        way merge is performed.
+    """
+    out: List[BaseIndexEntry] = []
+
+    # One and two way is the same for us, as we don't have to handle an existing
+    # index, instrea
+    if len(tree_shas) in (1, 2):
+        for entry in traverse_tree_recursive(odb, tree_shas[-1], ""):
+            out.append(_tree_entry_to_baseindexentry(entry, 0))
+        # END for each entry
+        return out
+    # END handle single tree
+
+    if len(tree_shas) > 3:
+        raise ValueError("Cannot handle %i trees at once" % len(tree_shas))
+
+    # Three trees.
+    for base, ours, theirs in traverse_trees_recursive(odb, tree_shas, ""):
+        if base is not None:
+            # Base version exists.
+            if ours is not None:
+                # Ours exists.
+                if theirs is not None:
+                    # It exists in all branches. Ff it was changed in both
+                    # its a conflict. Otherwise, we take the changed version.
+                    # This should be the most common branch, so it comes first.
+                    if (base[0] != ours[0] and base[0] != theirs[0] and ours[0] != theirs[0]) or (
+                        base[1] != ours[1] and base[1] != theirs[1] and ours[1] != theirs[1]
+                    ):
+                        # Changed by both.
+                        out.append(_tree_entry_to_baseindexentry(base, 1))
+                        out.append(_tree_entry_to_baseindexentry(ours, 2))
+                        out.append(_tree_entry_to_baseindexentry(theirs, 3))
+                    elif base[0] != ours[0] or base[1] != ours[1]:
+                        # Only we changed it.
+                        out.append(_tree_entry_to_baseindexentry(ours, 0))
+                    else:
+                        # Either nobody changed it, or they did. In either
+                        # case, use theirs.
+                        out.append(_tree_entry_to_baseindexentry(theirs, 0))
+                    # END handle modification
+                else:
+                    if ours[0] != base[0] or ours[1] != base[1]:
+                        # They deleted it, we changed it, conflict.
+                        out.append(_tree_entry_to_baseindexentry(base, 1))
+                        out.append(_tree_entry_to_baseindexentry(ours, 2))
+                    # else:
+                    #   # We didn't change it, ignore.
+                    #   pass
+                    # END handle our change
+                # END handle theirs
+            else:
+                if theirs is None:
+                    # Deleted in both, its fine - it's out.
+                    pass
+                else:
+                    if theirs[0] != base[0] or theirs[1] != base[1]:
+                        # Deleted in ours, changed theirs, conflict.
+                        out.append(_tree_entry_to_baseindexentry(base, 1))
+                        out.append(_tree_entry_to_baseindexentry(theirs, 3))
+                    # END theirs changed
+                    # else:
+                    #   # Theirs didn't change.
+                    #   pass
+                # END handle theirs
+            # END handle ours
+        else:
+            # All three can't be None.
+            if ours is None:
+                # Added in their branch.
+                assert theirs is not None
+                out.append(_tree_entry_to_baseindexentry(theirs, 0))
+            elif theirs is None:
+                # Added in our branch.
+                out.append(_tree_entry_to_baseindexentry(ours, 0))
+            else:
+                # Both have it, except for the base, see whether it changed.
+                if ours[0] != theirs[0] or ours[1] != theirs[1]:
+                    out.append(_tree_entry_to_baseindexentry(ours, 2))
+                    out.append(_tree_entry_to_baseindexentry(theirs, 3))
+                else:
+                    # It was added the same in both.
+                    out.append(_tree_entry_to_baseindexentry(ours, 0))
+                # END handle two items
+            # END handle heads
+        # END handle base exists
+    # END for each entries tuple
+
+    return out
diff --git a/parrot/lib/python3.10/site-packages/git/index/typ.py b/parrot/lib/python3.10/site-packages/git/index/typ.py
new file mode 100644
index 0000000000000000000000000000000000000000..974252528881dcc645fa425a4f35f10bed255ce4
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/index/typ.py
@@ -0,0 +1,202 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Additional types used by the index."""
+
+__all__ = ["BlobFilter", "BaseIndexEntry", "IndexEntry", "StageType"]
+
+from binascii import b2a_hex
+from pathlib import Path
+
+from git.objects import Blob
+
+from .util import pack, unpack
+
+# typing ----------------------------------------------------------------------
+
+from typing import NamedTuple, Sequence, TYPE_CHECKING, Tuple, Union, cast
+
+from git.types import PathLike
+
+if TYPE_CHECKING:
+    from git.repo import Repo
+
+StageType = int
+
+# ---------------------------------------------------------------------------------
+
+# { Invariants
+CE_NAMEMASK = 0x0FFF
+CE_STAGEMASK = 0x3000
+CE_EXTENDED = 0x4000
+CE_VALID = 0x8000
+CE_STAGESHIFT = 12
+
+# } END invariants
+
+
+class BlobFilter:
+    """Predicate to be used by
+    :meth:`IndexFile.iter_blobs <git.index.base.IndexFile.iter_blobs>` allowing to
+    filter only return blobs which match the given list of directories or files.
+
+    The given paths are given relative to the repository.
+    """
+
+    __slots__ = ("paths",)
+
+    def __init__(self, paths: Sequence[PathLike]) -> None:
+        """
+        :param paths:
+            Tuple or list of paths which are either pointing to directories or to files
+            relative to the current repository.
+        """
+        self.paths = paths
+
+    def __call__(self, stage_blob: Tuple[StageType, Blob]) -> bool:
+        blob_pathlike: PathLike = stage_blob[1].path
+        blob_path: Path = blob_pathlike if isinstance(blob_pathlike, Path) else Path(blob_pathlike)
+        for pathlike in self.paths:
+            path: Path = pathlike if isinstance(pathlike, Path) else Path(pathlike)
+            # TODO: Change to use `PosixPath.is_relative_to` once Python 3.8 is no
+            # longer supported.
+            filter_parts = path.parts
+            blob_parts = blob_path.parts
+            if len(filter_parts) > len(blob_parts):
+                continue
+            if all(i == j for i, j in zip(filter_parts, blob_parts)):
+                return True
+        return False
+
+
+class BaseIndexEntryHelper(NamedTuple):
+    """Typed named tuple to provide named attribute access for :class:`BaseIndexEntry`.
+
+    This is needed to allow overriding ``__new__`` in child class to preserve backwards
+    compatibility.
+    """
+
+    mode: int
+    binsha: bytes
+    flags: int
+    path: PathLike
+    ctime_bytes: bytes = pack(">LL", 0, 0)
+    mtime_bytes: bytes = pack(">LL", 0, 0)
+    dev: int = 0
+    inode: int = 0
+    uid: int = 0
+    gid: int = 0
+    size: int = 0
+
+
+class BaseIndexEntry(BaseIndexEntryHelper):
+    R"""Small brother of an index entry which can be created to describe changes
+    done to the index in which case plenty of additional information is not required.
+
+    As the first 4 data members match exactly to the :class:`IndexEntry` type, methods
+    expecting a :class:`BaseIndexEntry` can also handle full :class:`IndexEntry`\s even
+    if they use numeric indices for performance reasons.
+    """
+
+    def __new__(
+        cls,
+        inp_tuple: Union[
+            Tuple[int, bytes, int, PathLike],
+            Tuple[int, bytes, int, PathLike, bytes, bytes, int, int, int, int, int],
+        ],
+    ) -> "BaseIndexEntry":
+        """Override ``__new__`` to allow construction from a tuple for backwards
+        compatibility."""
+        return super().__new__(cls, *inp_tuple)
+
+    def __str__(self) -> str:
+        return "%o %s %i\t%s" % (self.mode, self.hexsha, self.stage, self.path)
+
+    def __repr__(self) -> str:
+        return "(%o, %s, %i, %s)" % (self.mode, self.hexsha, self.stage, self.path)
+
+    @property
+    def hexsha(self) -> str:
+        """hex version of our sha"""
+        return b2a_hex(self.binsha).decode("ascii")
+
+    @property
+    def stage(self) -> int:
+        """Stage of the entry, either:
+
+            * 0 = default stage
+            * 1 = stage before a merge or common ancestor entry in case of a 3 way merge
+            * 2 = stage of entries from the 'left' side of the merge
+            * 3 = stage of entries from the 'right' side of the merge
+
+        :note:
+            For more information, see :manpage:`git-read-tree(1)`.
+        """
+        return (self.flags & CE_STAGEMASK) >> CE_STAGESHIFT
+
+    @classmethod
+    def from_blob(cls, blob: Blob, stage: int = 0) -> "BaseIndexEntry":
+        """:return: Fully equipped BaseIndexEntry at the given stage"""
+        return cls((blob.mode, blob.binsha, stage << CE_STAGESHIFT, blob.path))
+
+    def to_blob(self, repo: "Repo") -> Blob:
+        """:return: Blob using the information of this index entry"""
+        return Blob(repo, self.binsha, self.mode, self.path)
+
+
+class IndexEntry(BaseIndexEntry):
+    """Allows convenient access to index entry data as defined in
+    :class:`BaseIndexEntry` without completely unpacking it.
+
+    Attributes usually accessed often are cached in the tuple whereas others are
+    unpacked on demand.
+
+    See the properties for a mapping between names and tuple indices.
+    """
+
+    @property
+    def ctime(self) -> Tuple[int, int]:
+        """
+        :return:
+            Tuple(int_time_seconds_since_epoch, int_nano_seconds) of the
+            file's creation time
+        """
+        return cast(Tuple[int, int], unpack(">LL", self.ctime_bytes))
+
+    @property
+    def mtime(self) -> Tuple[int, int]:
+        """See :attr:`ctime` property, but returns modification time."""
+        return cast(Tuple[int, int], unpack(">LL", self.mtime_bytes))
+
+    @classmethod
+    def from_base(cls, base: "BaseIndexEntry") -> "IndexEntry":
+        """
+        :return:
+            Minimal entry as created from the given :class:`BaseIndexEntry` instance.
+            Missing values will be set to null-like values.
+
+        :param base:
+            Instance of type :class:`BaseIndexEntry`.
+        """
+        time = pack(">LL", 0, 0)
+        return IndexEntry((base.mode, base.binsha, base.flags, base.path, time, time, 0, 0, 0, 0, 0))
+
+    @classmethod
+    def from_blob(cls, blob: Blob, stage: int = 0) -> "IndexEntry":
+        """:return: Minimal entry resembling the given blob object"""
+        time = pack(">LL", 0, 0)
+        return IndexEntry(
+            (
+                blob.mode,
+                blob.binsha,
+                stage << CE_STAGESHIFT,
+                blob.path,
+                time,
+                time,
+                0,
+                0,
+                0,
+                0,
+                blob.size,
+            )
+        )
diff --git a/parrot/lib/python3.10/site-packages/git/objects/__init__.py b/parrot/lib/python3.10/site-packages/git/objects/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4447ca50d321963e10b50178253a2d3edf5e707a
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/objects/__init__.py
@@ -0,0 +1,25 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Import all submodules' main classes into the package space."""
+
+__all__ = [
+    "IndexObject",
+    "Object",
+    "Blob",
+    "Commit",
+    "Submodule",
+    "UpdateProgress",
+    "RootModule",
+    "RootUpdateProgress",
+    "TagObject",
+    "Tree",
+    "TreeModifier",
+]
+
+from .base import IndexObject, Object
+from .blob import Blob
+from .commit import Commit
+from .submodule import RootModule, RootUpdateProgress, Submodule, UpdateProgress
+from .tag import TagObject
+from .tree import Tree, TreeModifier
diff --git a/parrot/lib/python3.10/site-packages/git/objects/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f227223436ccf67ae56e0c46da10607967b6b7b
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/objects/__pycache__/blob.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/blob.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7048b4f065e67c887f834fe47f5d8d95405ddfa2
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/blob.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/objects/__pycache__/commit.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/commit.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..174e90541b8ab3a81b763e939ca3db1156b6fd4e
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/commit.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/objects/__pycache__/tag.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/tag.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5ab8c58927aa40a3aac6e93ca61d9944eabb513
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/tag.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/objects/__pycache__/tree.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/tree.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5cf3509f6c643a6eed2f151aa275e9e9ea3c6963
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/objects/__pycache__/tree.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/objects/base.py b/parrot/lib/python3.10/site-packages/git/objects/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..eeaebc09bd320de6e0a2402c4d77c7dca5c263e6
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/objects/base.py
@@ -0,0 +1,301 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+__all__ = ["Object", "IndexObject"]
+
+import os.path as osp
+
+import gitdb.typ as dbtyp
+
+from git.exc import WorkTreeRepositoryUnsupported
+from git.util import LazyMixin, bin_to_hex, join_path_native, stream_copy
+
+from .util import get_object_type_by_name
+
+# typing ------------------------------------------------------------------
+
+from typing import Any, TYPE_CHECKING, Union
+
+from git.types import AnyGitObject, GitObjectTypeString, PathLike
+
+if TYPE_CHECKING:
+    from gitdb.base import OStream
+
+    from git.refs.reference import Reference
+    from git.repo import Repo
+
+    from .blob import Blob
+    from .submodule.base import Submodule
+    from .tree import Tree
+
+IndexObjUnion = Union["Tree", "Blob", "Submodule"]
+
+# --------------------------------------------------------------------------
+
+
+class Object(LazyMixin):
+    """Base class for classes representing git object types.
+
+    The following four leaf classes represent specific kinds of git objects:
+
+    * :class:`Blob <git.objects.blob.Blob>`
+    * :class:`Tree <git.objects.tree.Tree>`
+    * :class:`Commit <git.objects.commit.Commit>`
+    * :class:`TagObject <git.objects.tag.TagObject>`
+
+    See :manpage:`gitglossary(7)` on:
+
+    * "object": https://git-scm.com/docs/gitglossary#def_object
+    * "object type": https://git-scm.com/docs/gitglossary#def_object_type
+    * "blob": https://git-scm.com/docs/gitglossary#def_blob_object
+    * "tree object": https://git-scm.com/docs/gitglossary#def_tree_object
+    * "commit object": https://git-scm.com/docs/gitglossary#def_commit_object
+    * "tag object": https://git-scm.com/docs/gitglossary#def_tag_object
+
+    :note:
+        See the :class:`~git.types.AnyGitObject` union type of the four leaf subclasses
+        that represent actual git object types.
+
+    :note:
+        :class:`~git.objects.submodule.base.Submodule` is defined under the hierarchy
+        rooted at this :class:`Object` class, even though submodules are not really a
+        type of git object. (This also applies to its
+        :class:`~git.objects.submodule.root.RootModule` subclass.)
+
+    :note:
+        This :class:`Object` class should not be confused with :class:`object` (the root
+        of the class hierarchy in Python).
+    """
+
+    NULL_HEX_SHA = "0" * 40
+    NULL_BIN_SHA = b"\0" * 20
+
+    TYPES = (
+        dbtyp.str_blob_type,
+        dbtyp.str_tree_type,
+        dbtyp.str_commit_type,
+        dbtyp.str_tag_type,
+    )
+
+    __slots__ = ("repo", "binsha", "size")
+
+    type: Union[GitObjectTypeString, None] = None
+    """String identifying (a concrete :class:`Object` subtype for) a git object type.
+
+    The subtypes that this may name correspond to the kinds of git objects that exist,
+    i.e., the objects that may be present in a git repository.
+
+    :note:
+        Most subclasses represent specific types of git objects and override this class
+        attribute accordingly. This attribute is ``None`` in the :class:`Object` base
+        class, as well as the :class:`IndexObject` intermediate subclass, but never
+        ``None`` in concrete leaf subclasses representing specific git object types.
+
+    :note:
+        See also :class:`~git.types.GitObjectTypeString`.
+    """
+
+    def __init__(self, repo: "Repo", binsha: bytes) -> None:
+        """Initialize an object by identifying it by its binary sha.
+
+        All keyword arguments will be set on demand if ``None``.
+
+        :param repo:
+            Repository this object is located in.
+
+        :param binsha:
+            20 byte SHA1
+        """
+        super().__init__()
+        self.repo = repo
+        self.binsha = binsha
+        assert len(binsha) == 20, "Require 20 byte binary sha, got %r, len = %i" % (
+            binsha,
+            len(binsha),
+        )
+
+    @classmethod
+    def new(cls, repo: "Repo", id: Union[str, "Reference"]) -> AnyGitObject:
+        """
+        :return:
+            New :class:`Object` instance of a type appropriate to the object type behind
+            `id`. The id of the newly created object will be a binsha even though the
+            input id may have been a `~git.refs.reference.Reference` or rev-spec.
+
+        :param id:
+            :class:`~git.refs.reference.Reference`, rev-spec, or hexsha.
+
+        :note:
+            This cannot be a ``__new__`` method as it would always call :meth:`__init__`
+            with the input id which is not necessarily a binsha.
+        """
+        return repo.rev_parse(str(id))
+
+    @classmethod
+    def new_from_sha(cls, repo: "Repo", sha1: bytes) -> AnyGitObject:
+        """
+        :return:
+            New object instance of a type appropriate to represent the given binary sha1
+
+        :param sha1:
+            20 byte binary sha1.
+        """
+        if sha1 == cls.NULL_BIN_SHA:
+            # The NULL binsha is always the root commit.
+            return get_object_type_by_name(b"commit")(repo, sha1)
+        # END handle special case
+        oinfo = repo.odb.info(sha1)
+        inst = get_object_type_by_name(oinfo.type)(repo, oinfo.binsha)
+        inst.size = oinfo.size
+        return inst
+
+    def _set_cache_(self, attr: str) -> None:
+        """Retrieve object information."""
+        if attr == "size":
+            oinfo = self.repo.odb.info(self.binsha)
+            self.size = oinfo.size  # type: int
+        else:
+            super()._set_cache_(attr)
+
+    def __eq__(self, other: Any) -> bool:
+        """:return: ``True`` if the objects have the same SHA1"""
+        if not hasattr(other, "binsha"):
+            return False
+        return self.binsha == other.binsha
+
+    def __ne__(self, other: Any) -> bool:
+        """:return: ``True`` if the objects do not have the same SHA1"""
+        if not hasattr(other, "binsha"):
+            return True
+        return self.binsha != other.binsha
+
+    def __hash__(self) -> int:
+        """:return: Hash of our id allowing objects to be used in dicts and sets"""
+        return hash(self.binsha)
+
+    def __str__(self) -> str:
+        """:return: String of our SHA1 as understood by all git commands"""
+        return self.hexsha
+
+    def __repr__(self) -> str:
+        """:return: String with pythonic representation of our object"""
+        return '<git.%s "%s">' % (self.__class__.__name__, self.hexsha)
+
+    @property
+    def hexsha(self) -> str:
+        """:return: 40 byte hex version of our 20 byte binary sha"""
+        # b2a_hex produces bytes.
+        return bin_to_hex(self.binsha).decode("ascii")
+
+    @property
+    def data_stream(self) -> "OStream":
+        """
+        :return:
+            File-object compatible stream to the uncompressed raw data of the object
+
+        :note:
+            Returned streams must be read in order.
+        """
+        return self.repo.odb.stream(self.binsha)
+
+    def stream_data(self, ostream: "OStream") -> "Object":
+        """Write our data directly to the given output stream.
+
+        :param ostream:
+            File-object compatible stream object.
+
+        :return:
+            self
+        """
+        istream = self.repo.odb.stream(self.binsha)
+        stream_copy(istream, ostream)
+        return self
+
+
+class IndexObject(Object):
+    """Base for all objects that can be part of the index file.
+
+    The classes representing git object types that can be part of the index file are
+    :class:`~git.objects.tree.Tree and :class:`~git.objects.blob.Blob`. In addition,
+    :class:`~git.objects.submodule.base.Submodule`, which is not really a git object
+    type but can be part of an index file, is also a subclass.
+    """
+
+    __slots__ = ("path", "mode")
+
+    # For compatibility with iterable lists.
+    _id_attribute_ = "path"
+
+    def __init__(
+        self,
+        repo: "Repo",
+        binsha: bytes,
+        mode: Union[None, int] = None,
+        path: Union[None, PathLike] = None,
+    ) -> None:
+        """Initialize a newly instanced :class:`IndexObject`.
+
+        :param repo:
+            The :class:`~git.repo.base.Repo` we are located in.
+
+        :param binsha:
+            20 byte sha1.
+
+        :param mode:
+            The stat-compatible file mode as :class:`int`.
+            Use the :mod:`stat` module to evaluate the information.
+
+        :param path:
+            The path to the file in the file system, relative to the git repository
+            root, like ``file.ext`` or ``folder/other.ext``.
+
+        :note:
+            Path may not be set if the index object has been created directly, as it
+            cannot be retrieved without knowing the parent tree.
+        """
+        super().__init__(repo, binsha)
+        if mode is not None:
+            self.mode = mode
+        if path is not None:
+            self.path = path
+
+    def __hash__(self) -> int:
+        """
+        :return:
+            Hash of our path as index items are uniquely identifiable by path, not by
+            their data!
+        """
+        return hash(self.path)
+
+    def _set_cache_(self, attr: str) -> None:
+        if attr in IndexObject.__slots__:
+            # They cannot be retrieved later on (not without searching for them).
+            raise AttributeError(
+                "Attribute '%s' unset: path and mode attributes must have been set during %s object creation"
+                % (attr, type(self).__name__)
+            )
+        else:
+            super()._set_cache_(attr)
+        # END handle slot attribute
+
+    @property
+    def name(self) -> str:
+        """:return: Name portion of the path, effectively being the basename"""
+        return osp.basename(self.path)
+
+    @property
+    def abspath(self) -> PathLike:
+        R"""
+        :return:
+            Absolute path to this index object in the file system (as opposed to the
+            :attr:`path` field which is a path relative to the git repository).
+
+            The returned path will be native to the system and contains ``\`` on
+            Windows.
+        """
+        if self.repo.working_tree_dir is not None:
+            return join_path_native(self.repo.working_tree_dir, self.path)
+        else:
+            raise WorkTreeRepositoryUnsupported("working_tree_dir was None or empty")
diff --git a/parrot/lib/python3.10/site-packages/git/objects/blob.py b/parrot/lib/python3.10/site-packages/git/objects/blob.py
new file mode 100644
index 0000000000000000000000000000000000000000..58de59642da7f7b70a217fc28b85a488a81cfae0
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/objects/blob.py
@@ -0,0 +1,48 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+__all__ = ["Blob"]
+
+from mimetypes import guess_type
+import sys
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+from . import base
+
+
+class Blob(base.IndexObject):
+    """A Blob encapsulates a git blob object.
+
+    See :manpage:`gitglossary(7)` on "blob":
+    https://git-scm.com/docs/gitglossary#def_blob_object
+    """
+
+    DEFAULT_MIME_TYPE = "text/plain"
+    type: Literal["blob"] = "blob"
+
+    # Valid blob modes
+    executable_mode = 0o100755
+    file_mode = 0o100644
+    link_mode = 0o120000
+
+    __slots__ = ()
+
+    @property
+    def mime_type(self) -> str:
+        """
+        :return:
+            String describing the mime type of this file (based on the filename)
+
+        :note:
+            Defaults to ``text/plain`` in case the actual file type is unknown.
+        """
+        guesses = None
+        if self.path:
+            guesses = guess_type(str(self.path))
+        return guesses and guesses[0] or self.DEFAULT_MIME_TYPE
diff --git a/parrot/lib/python3.10/site-packages/git/objects/commit.py b/parrot/lib/python3.10/site-packages/git/objects/commit.py
new file mode 100644
index 0000000000000000000000000000000000000000..d957c90514989c34f4bfd343b0061e6e8c3b8d2c
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/objects/commit.py
@@ -0,0 +1,899 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+__all__ = ["Commit"]
+
+from collections import defaultdict
+import datetime
+from io import BytesIO
+import logging
+import os
+import re
+from subprocess import Popen, PIPE
+import sys
+from time import altzone, daylight, localtime, time, timezone
+import warnings
+
+from gitdb import IStream
+
+from git.cmd import Git
+from git.diff import Diffable
+from git.util import Actor, Stats, finalize_process, hex_to_bin
+
+from . import base
+from .tree import Tree
+from .util import (
+    Serializable,
+    TraversableIterableObj,
+    altz_to_utctz_str,
+    from_timestamp,
+    parse_actor_and_date,
+    parse_date,
+)
+
+# typing ------------------------------------------------------------------
+
+from typing import (
+    Any,
+    Dict,
+    IO,
+    Iterator,
+    List,
+    Sequence,
+    Tuple,
+    TYPE_CHECKING,
+    Union,
+    cast,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+from git.types import PathLike
+
+if TYPE_CHECKING:
+    from git.refs import SymbolicReference
+    from git.repo import Repo
+
+# ------------------------------------------------------------------------
+
+_logger = logging.getLogger(__name__)
+
+
+class Commit(base.Object, TraversableIterableObj, Diffable, Serializable):
+    """Wraps a git commit object.
+
+    See :manpage:`gitglossary(7)` on "commit object":
+    https://git-scm.com/docs/gitglossary#def_commit_object
+
+    :note:
+        This class will act lazily on some of its attributes and will query the value on
+        demand only if it involves calling the git binary.
+    """
+
+    # ENVIRONMENT VARIABLES
+    # Read when creating new commits.
+    env_author_date = "GIT_AUTHOR_DATE"
+    env_committer_date = "GIT_COMMITTER_DATE"
+
+    # CONFIGURATION KEYS
+    conf_encoding = "i18n.commitencoding"
+
+    # INVARIANTS
+    default_encoding = "UTF-8"
+
+    type: Literal["commit"] = "commit"
+
+    __slots__ = (
+        "tree",
+        "author",
+        "authored_date",
+        "author_tz_offset",
+        "committer",
+        "committed_date",
+        "committer_tz_offset",
+        "message",
+        "parents",
+        "encoding",
+        "gpgsig",
+    )
+
+    _id_attribute_ = "hexsha"
+
+    parents: Sequence["Commit"]
+
+    def __init__(
+        self,
+        repo: "Repo",
+        binsha: bytes,
+        tree: Union[Tree, None] = None,
+        author: Union[Actor, None] = None,
+        authored_date: Union[int, None] = None,
+        author_tz_offset: Union[None, float] = None,
+        committer: Union[Actor, None] = None,
+        committed_date: Union[int, None] = None,
+        committer_tz_offset: Union[None, float] = None,
+        message: Union[str, bytes, None] = None,
+        parents: Union[Sequence["Commit"], None] = None,
+        encoding: Union[str, None] = None,
+        gpgsig: Union[str, None] = None,
+    ) -> None:
+        """Instantiate a new :class:`Commit`. All keyword arguments taking ``None`` as
+        default will be implicitly set on first query.
+
+        :param binsha:
+            20 byte sha1.
+
+        :param tree:
+            A :class:`~git.objects.tree.Tree` object.
+
+        :param author:
+            The author :class:`~git.util.Actor` object.
+
+        :param authored_date: int_seconds_since_epoch
+            The authored DateTime - use :func:`time.gmtime` to convert it into a
+            different format.
+
+        :param author_tz_offset: int_seconds_west_of_utc
+            The timezone that the `authored_date` is in.
+
+        :param committer:
+            The committer string, as an :class:`~git.util.Actor` object.
+
+        :param committed_date: int_seconds_since_epoch
+            The committed DateTime - use :func:`time.gmtime` to convert it into a
+            different format.
+
+        :param committer_tz_offset: int_seconds_west_of_utc
+            The timezone that the `committed_date` is in.
+
+        :param message: string
+            The commit message.
+
+        :param encoding: string
+            Encoding of the message, defaults to UTF-8.
+
+        :param parents:
+            List or tuple of :class:`Commit` objects which are our parent(s) in the
+            commit dependency graph.
+
+        :return:
+            :class:`Commit`
+
+        :note:
+            Timezone information is in the same format and in the same sign as what
+            :func:`time.altzone` returns. The sign is inverted compared to git's UTC
+            timezone.
+        """
+        super().__init__(repo, binsha)
+        self.binsha = binsha
+        if tree is not None:
+            assert isinstance(tree, Tree), "Tree needs to be a Tree instance, was %s" % type(tree)
+        if tree is not None:
+            self.tree = tree
+        if author is not None:
+            self.author = author
+        if authored_date is not None:
+            self.authored_date = authored_date
+        if author_tz_offset is not None:
+            self.author_tz_offset = author_tz_offset
+        if committer is not None:
+            self.committer = committer
+        if committed_date is not None:
+            self.committed_date = committed_date
+        if committer_tz_offset is not None:
+            self.committer_tz_offset = committer_tz_offset
+        if message is not None:
+            self.message = message
+        if parents is not None:
+            self.parents = parents
+        if encoding is not None:
+            self.encoding = encoding
+        if gpgsig is not None:
+            self.gpgsig = gpgsig
+
+    @classmethod
+    def _get_intermediate_items(cls, commit: "Commit") -> Tuple["Commit", ...]:
+        return tuple(commit.parents)
+
+    @classmethod
+    def _calculate_sha_(cls, repo: "Repo", commit: "Commit") -> bytes:
+        """Calculate the sha of a commit.
+
+        :param repo:
+            :class:`~git.repo.base.Repo` object the commit should be part of.
+
+        :param commit:
+            :class:`Commit` object for which to generate the sha.
+        """
+
+        stream = BytesIO()
+        commit._serialize(stream)
+        streamlen = stream.tell()
+        stream.seek(0)
+
+        istream = repo.odb.store(IStream(cls.type, streamlen, stream))
+        return istream.binsha
+
+    def replace(self, **kwargs: Any) -> "Commit":
+        """Create new commit object from an existing commit object.
+
+        Any values provided as keyword arguments will replace the corresponding
+        attribute in the new object.
+        """
+
+        attrs = {k: getattr(self, k) for k in self.__slots__}
+
+        for attrname in kwargs:
+            if attrname not in self.__slots__:
+                raise ValueError("invalid attribute name")
+
+        attrs.update(kwargs)
+        new_commit = self.__class__(self.repo, self.NULL_BIN_SHA, **attrs)
+        new_commit.binsha = self._calculate_sha_(self.repo, new_commit)
+
+        return new_commit
+
+    def _set_cache_(self, attr: str) -> None:
+        if attr in Commit.__slots__:
+            # Read the data in a chunk, its faster - then provide a file wrapper.
+            _binsha, _typename, self.size, stream = self.repo.odb.stream(self.binsha)
+            self._deserialize(BytesIO(stream.read()))
+        else:
+            super()._set_cache_(attr)
+        # END handle attrs
+
+    @property
+    def authored_datetime(self) -> datetime.datetime:
+        return from_timestamp(self.authored_date, self.author_tz_offset)
+
+    @property
+    def committed_datetime(self) -> datetime.datetime:
+        return from_timestamp(self.committed_date, self.committer_tz_offset)
+
+    @property
+    def summary(self) -> Union[str, bytes]:
+        """:return: First line of the commit message"""
+        if isinstance(self.message, str):
+            return self.message.split("\n", 1)[0]
+        else:
+            return self.message.split(b"\n", 1)[0]
+
+    def count(self, paths: Union[PathLike, Sequence[PathLike]] = "", **kwargs: Any) -> int:
+        """Count the number of commits reachable from this commit.
+
+        :param paths:
+            An optional path or a list of paths restricting the return value to commits
+            actually containing the paths.
+
+        :param kwargs:
+            Additional options to be passed to :manpage:`git-rev-list(1)`. They must not
+            alter the output style of the command, or parsing will yield incorrect
+            results.
+
+        :return:
+            An int defining the number of reachable commits
+        """
+        # Yes, it makes a difference whether empty paths are given or not in our case as
+        # the empty paths version will ignore merge commits for some reason.
+        if paths:
+            return len(self.repo.git.rev_list(self.hexsha, "--", paths, **kwargs).splitlines())
+        return len(self.repo.git.rev_list(self.hexsha, **kwargs).splitlines())
+
+    @property
+    def name_rev(self) -> str:
+        """
+        :return:
+            String describing the commits hex sha based on the closest
+            `~git.refs.reference.Reference`.
+
+        :note:
+            Mostly useful for UI purposes.
+        """
+        return self.repo.git.name_rev(self)
+
+    @classmethod
+    def iter_items(
+        cls,
+        repo: "Repo",
+        rev: Union[str, "Commit", "SymbolicReference"],
+        paths: Union[PathLike, Sequence[PathLike]] = "",
+        **kwargs: Any,
+    ) -> Iterator["Commit"]:
+        R"""Find all commits matching the given criteria.
+
+        :param repo:
+            The :class:`~git.repo.base.Repo`.
+
+        :param rev:
+            Revision specifier. See :manpage:`git-rev-parse(1)` for viable options.
+
+        :param paths:
+            An optional path or list of paths. If set only :class:`Commit`\s that
+            include the path or paths will be considered.
+
+        :param kwargs:
+            Optional keyword arguments to :manpage:`git-rev-list(1)` where:
+
+            * ``max_count`` is the maximum number of commits to fetch.
+            * ``skip`` is the number of commits to skip.
+            * ``since`` selects all commits since some date, e.g. ``"1970-01-01"``.
+
+        :return:
+            Iterator yielding :class:`Commit` items.
+        """
+        if "pretty" in kwargs:
+            raise ValueError("--pretty cannot be used as parsing expects single sha's only")
+        # END handle pretty
+
+        # Use -- in all cases, to prevent possibility of ambiguous arguments.
+        # See https://github.com/gitpython-developers/GitPython/issues/264.
+
+        args_list: List[PathLike] = ["--"]
+
+        if paths:
+            paths_tup: Tuple[PathLike, ...]
+            if isinstance(paths, (str, os.PathLike)):
+                paths_tup = (paths,)
+            else:
+                paths_tup = tuple(paths)
+
+            args_list.extend(paths_tup)
+        # END if paths
+
+        proc = repo.git.rev_list(rev, args_list, as_process=True, **kwargs)
+        return cls._iter_from_process_or_stream(repo, proc)
+
+    def iter_parents(self, paths: Union[PathLike, Sequence[PathLike]] = "", **kwargs: Any) -> Iterator["Commit"]:
+        R"""Iterate _all_ parents of this commit.
+
+        :param paths:
+            Optional path or list of paths limiting the :class:`Commit`\s to those that
+            contain at least one of the paths.
+
+        :param kwargs:
+            All arguments allowed by :manpage:`git-rev-list(1)`.
+
+        :return:
+            Iterator yielding :class:`Commit` objects which are parents of ``self``
+        """
+        # skip ourselves
+        skip = kwargs.get("skip", 1)
+        if skip == 0:  # skip ourselves
+            skip = 1
+        kwargs["skip"] = skip
+
+        return self.iter_items(self.repo, self, paths, **kwargs)
+
+    @property
+    def stats(self) -> Stats:
+        """Create a git stat from changes between this commit and its first parent
+        or from all changes done if this is the very first commit.
+
+        :return:
+            :class:`Stats`
+        """
+        if not self.parents:
+            text = self.repo.git.diff_tree(self.hexsha, "--", numstat=True, no_renames=True, root=True)
+            text2 = ""
+            for line in text.splitlines()[1:]:
+                (insertions, deletions, filename) = line.split("\t")
+                text2 += "%s\t%s\t%s\n" % (insertions, deletions, filename)
+            text = text2
+        else:
+            text = self.repo.git.diff(self.parents[0].hexsha, self.hexsha, "--", numstat=True, no_renames=True)
+        return Stats._list_from_string(self.repo, text)
+
+    @property
+    def trailers(self) -> Dict[str, str]:
+        """Deprecated. Get the trailers of the message as a dictionary.
+
+        :note:
+            This property is deprecated, please use either :attr:`trailers_list` or
+            :attr:`trailers_dict`.
+
+        :return:
+            Dictionary containing whitespace stripped trailer information.
+            Only contains the latest instance of each trailer key.
+        """
+        warnings.warn(
+            "Commit.trailers is deprecated, use Commit.trailers_list or Commit.trailers_dict instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return {k: v[0] for k, v in self.trailers_dict.items()}
+
+    @property
+    def trailers_list(self) -> List[Tuple[str, str]]:
+        """Get the trailers of the message as a list.
+
+        Git messages can contain trailer information that are similar to :rfc:`822`
+        e-mail headers. See :manpage:`git-interpret-trailers(1)`.
+
+        This function calls ``git interpret-trailers --parse`` onto the message to
+        extract the trailer information, returns the raw trailer data as a list.
+
+        Valid message with trailer::
+
+            Subject line
+
+            some body information
+
+            another information
+
+            key1: value1.1
+            key1: value1.2
+            key2 :    value 2 with inner spaces
+
+        Returned list will look like this::
+
+            [
+                ("key1", "value1.1"),
+                ("key1", "value1.2"),
+                ("key2", "value 2 with inner spaces"),
+            ]
+
+        :return:
+            List containing key-value tuples of whitespace stripped trailer information.
+        """
+        cmd = ["git", "interpret-trailers", "--parse"]
+        proc: Git.AutoInterrupt = self.repo.git.execute(  # type: ignore[call-overload]
+            cmd,
+            as_process=True,
+            istream=PIPE,
+        )
+        trailer: str = proc.communicate(str(self.message).encode())[0].decode("utf8")
+        trailer = trailer.strip()
+
+        if not trailer:
+            return []
+
+        trailer_list = []
+        for t in trailer.split("\n"):
+            key, val = t.split(":", 1)
+            trailer_list.append((key.strip(), val.strip()))
+
+        return trailer_list
+
+    @property
+    def trailers_dict(self) -> Dict[str, List[str]]:
+        """Get the trailers of the message as a dictionary.
+
+        Git messages can contain trailer information that are similar to :rfc:`822`
+        e-mail headers. See :manpage:`git-interpret-trailers(1)`.
+
+        This function calls ``git interpret-trailers --parse`` onto the message to
+        extract the trailer information. The key value pairs are stripped of leading and
+        trailing whitespaces before they get saved into a dictionary.
+
+        Valid message with trailer::
+
+            Subject line
+
+            some body information
+
+            another information
+
+            key1: value1.1
+            key1: value1.2
+            key2 :    value 2 with inner spaces
+
+        Returned dictionary will look like this::
+
+            {
+                "key1": ["value1.1", "value1.2"],
+                "key2": ["value 2 with inner spaces"],
+            }
+
+
+        :return:
+            Dictionary containing whitespace stripped trailer information, mapping
+            trailer keys to a list of their corresponding values.
+        """
+        d = defaultdict(list)
+        for key, val in self.trailers_list:
+            d[key].append(val)
+        return dict(d)
+
+    @classmethod
+    def _iter_from_process_or_stream(cls, repo: "Repo", proc_or_stream: Union[Popen, IO]) -> Iterator["Commit"]:
+        """Parse out commit information into a list of :class:`Commit` objects.
+
+        We expect one line per commit, and parse the actual commit information directly
+        from our lighting fast object database.
+
+        :param proc:
+            :manpage:`git-rev-list(1)` process instance - one sha per line.
+
+        :return:
+            Iterator supplying :class:`Commit` objects
+        """
+
+        # def is_proc(inp) -> TypeGuard[Popen]:
+        #     return hasattr(proc_or_stream, 'wait') and not hasattr(proc_or_stream, 'readline')
+
+        # def is_stream(inp) -> TypeGuard[IO]:
+        #     return hasattr(proc_or_stream, 'readline')
+
+        if hasattr(proc_or_stream, "wait"):
+            proc_or_stream = cast(Popen, proc_or_stream)
+            if proc_or_stream.stdout is not None:
+                stream = proc_or_stream.stdout
+        elif hasattr(proc_or_stream, "readline"):
+            proc_or_stream = cast(IO, proc_or_stream)  # type: ignore[redundant-cast]
+            stream = proc_or_stream
+
+        readline = stream.readline
+        while True:
+            line = readline()
+            if not line:
+                break
+            hexsha = line.strip()
+            if len(hexsha) > 40:
+                # Split additional information, as returned by bisect for instance.
+                hexsha, _ = line.split(None, 1)
+            # END handle extra info
+
+            assert len(hexsha) == 40, "Invalid line: %s" % hexsha
+            yield cls(repo, hex_to_bin(hexsha))
+        # END for each line in stream
+
+        # TODO: Review this - it seems process handling got a bit out of control due to
+        # many developers trying to fix the open file handles issue.
+        if hasattr(proc_or_stream, "wait"):
+            proc_or_stream = cast(Popen, proc_or_stream)
+            finalize_process(proc_or_stream)
+
+    @classmethod
+    def create_from_tree(
+        cls,
+        repo: "Repo",
+        tree: Union[Tree, str],
+        message: str,
+        parent_commits: Union[None, List["Commit"]] = None,
+        head: bool = False,
+        author: Union[None, Actor] = None,
+        committer: Union[None, Actor] = None,
+        author_date: Union[None, str, datetime.datetime] = None,
+        commit_date: Union[None, str, datetime.datetime] = None,
+    ) -> "Commit":
+        """Commit the given tree, creating a :class:`Commit` object.
+
+        :param repo:
+            :class:`~git.repo.base.Repo` object the commit should be part of.
+
+        :param tree:
+            :class:`~git.objects.tree.Tree` object or hex or bin sha.
+            The tree of the new commit.
+
+        :param message:
+            Commit message. It may be an empty string if no message is provided. It will
+            be converted to a string, in any case.
+
+        :param parent_commits:
+            Optional :class:`Commit` objects to use as parents for the new commit. If
+            empty list, the commit will have no parents at all and become a root commit.
+            If ``None``, the current head commit will be the parent of the new commit
+            object.
+
+        :param head:
+            If ``True``, the HEAD will be advanced to the new commit automatically.
+            Otherwise the HEAD will remain pointing on the previous commit. This could
+            lead to undesired results when diffing files.
+
+        :param author:
+            The name of the author, optional.
+            If unset, the repository configuration is used to obtain this value.
+
+        :param committer:
+            The name of the committer, optional.
+            If unset, the repository configuration is used to obtain this value.
+
+        :param author_date:
+            The timestamp for the author field.
+
+        :param commit_date:
+            The timestamp for the committer field.
+
+        :return:
+            :class:`Commit` object representing the new commit.
+
+        :note:
+            Additional information about the committer and author are taken from the
+            environment or from the git configuration. See :manpage:`git-commit-tree(1)`
+            for more information.
+        """
+        if parent_commits is None:
+            try:
+                parent_commits = [repo.head.commit]
+            except ValueError:
+                # Empty repositories have no head commit.
+                parent_commits = []
+            # END handle parent commits
+        else:
+            for p in parent_commits:
+                if not isinstance(p, cls):
+                    raise ValueError(f"Parent commit '{p!r}' must be of type {cls}")
+            # END check parent commit types
+        # END if parent commits are unset
+
+        # Retrieve all additional information, create a commit object, and serialize it.
+        # Generally:
+        # * Environment variables override configuration values.
+        # * Sensible defaults are set according to the git documentation.
+
+        # COMMITTER AND AUTHOR INFO
+        cr = repo.config_reader()
+        env = os.environ
+
+        committer = committer or Actor.committer(cr)
+        author = author or Actor.author(cr)
+
+        # PARSE THE DATES
+        unix_time = int(time())
+        is_dst = daylight and localtime().tm_isdst > 0
+        offset = altzone if is_dst else timezone
+
+        author_date_str = env.get(cls.env_author_date, "")
+        if author_date:
+            author_time, author_offset = parse_date(author_date)
+        elif author_date_str:
+            author_time, author_offset = parse_date(author_date_str)
+        else:
+            author_time, author_offset = unix_time, offset
+        # END set author time
+
+        committer_date_str = env.get(cls.env_committer_date, "")
+        if commit_date:
+            committer_time, committer_offset = parse_date(commit_date)
+        elif committer_date_str:
+            committer_time, committer_offset = parse_date(committer_date_str)
+        else:
+            committer_time, committer_offset = unix_time, offset
+        # END set committer time
+
+        # Assume UTF-8 encoding.
+        enc_section, enc_option = cls.conf_encoding.split(".")
+        conf_encoding = cr.get_value(enc_section, enc_option, cls.default_encoding)
+        if not isinstance(conf_encoding, str):
+            raise TypeError("conf_encoding could not be coerced to str")
+
+        # If the tree is no object, make sure we create one - otherwise the created
+        # commit object is invalid.
+        if isinstance(tree, str):
+            tree = repo.tree(tree)
+        # END tree conversion
+
+        # CREATE NEW COMMIT
+        new_commit = cls(
+            repo,
+            cls.NULL_BIN_SHA,
+            tree,
+            author,
+            author_time,
+            author_offset,
+            committer,
+            committer_time,
+            committer_offset,
+            message,
+            parent_commits,
+            conf_encoding,
+        )
+
+        new_commit.binsha = cls._calculate_sha_(repo, new_commit)
+
+        if head:
+            # Need late import here, importing git at the very beginning throws as
+            # well...
+            import git.refs
+
+            try:
+                repo.head.set_commit(new_commit, logmsg=message)
+            except ValueError:
+                # head is not yet set to the ref our HEAD points to.
+                # Happens on first commit.
+                master = git.refs.Head.create(
+                    repo,
+                    repo.head.ref,
+                    new_commit,
+                    logmsg="commit (initial): %s" % message,
+                )
+                repo.head.set_reference(master, logmsg="commit: Switching to %s" % master)
+            # END handle empty repositories
+        # END advance head handling
+
+        return new_commit
+
+    # { Serializable Implementation
+
+    def _serialize(self, stream: BytesIO) -> "Commit":
+        write = stream.write
+        write(("tree %s\n" % self.tree).encode("ascii"))
+        for p in self.parents:
+            write(("parent %s\n" % p).encode("ascii"))
+
+        a = self.author
+        aname = a.name
+        c = self.committer
+        fmt = "%s %s <%s> %s %s\n"
+        write(
+            (
+                fmt
+                % (
+                    "author",
+                    aname,
+                    a.email,
+                    self.authored_date,
+                    altz_to_utctz_str(self.author_tz_offset),
+                )
+            ).encode(self.encoding)
+        )
+
+        # Encode committer.
+        aname = c.name
+        write(
+            (
+                fmt
+                % (
+                    "committer",
+                    aname,
+                    c.email,
+                    self.committed_date,
+                    altz_to_utctz_str(self.committer_tz_offset),
+                )
+            ).encode(self.encoding)
+        )
+
+        if self.encoding != self.default_encoding:
+            write(("encoding %s\n" % self.encoding).encode("ascii"))
+
+        try:
+            if self.__getattribute__("gpgsig"):
+                write(b"gpgsig")
+                for sigline in self.gpgsig.rstrip("\n").split("\n"):
+                    write((" " + sigline + "\n").encode("ascii"))
+        except AttributeError:
+            pass
+
+        write(b"\n")
+
+        # Write plain bytes, be sure its encoded according to our encoding.
+        if isinstance(self.message, str):
+            write(self.message.encode(self.encoding))
+        else:
+            write(self.message)
+        # END handle encoding
+        return self
+
+    def _deserialize(self, stream: BytesIO) -> "Commit":
+        readline = stream.readline
+        self.tree = Tree(self.repo, hex_to_bin(readline().split()[1]), Tree.tree_id << 12, "")
+
+        self.parents = []
+        next_line = None
+        while True:
+            parent_line = readline()
+            if not parent_line.startswith(b"parent"):
+                next_line = parent_line
+                break
+            # END abort reading parents
+            self.parents.append(type(self)(self.repo, hex_to_bin(parent_line.split()[-1].decode("ascii"))))
+        # END for each parent line
+        self.parents = tuple(self.parents)
+
+        # We don't know actual author encoding before we have parsed it, so keep the
+        # lines around.
+        author_line = next_line
+        committer_line = readline()
+
+        # We might run into one or more mergetag blocks, skip those for now.
+        next_line = readline()
+        while next_line.startswith(b"mergetag "):
+            next_line = readline()
+            while next_line.startswith(b" "):
+                next_line = readline()
+        # END skip mergetags
+
+        # Now we can have the encoding line, or an empty line followed by the optional
+        # message.
+        self.encoding = self.default_encoding
+        self.gpgsig = ""
+
+        # Read headers.
+        enc = next_line
+        buf = enc.strip()
+        while buf:
+            if buf[0:10] == b"encoding ":
+                self.encoding = buf[buf.find(b" ") + 1 :].decode(self.encoding, "ignore")
+            elif buf[0:7] == b"gpgsig ":
+                sig = buf[buf.find(b" ") + 1 :] + b"\n"
+                is_next_header = False
+                while True:
+                    sigbuf = readline()
+                    if not sigbuf:
+                        break
+                    if sigbuf[0:1] != b" ":
+                        buf = sigbuf.strip()
+                        is_next_header = True
+                        break
+                    sig += sigbuf[1:]
+                # END read all signature
+                self.gpgsig = sig.rstrip(b"\n").decode(self.encoding, "ignore")
+                if is_next_header:
+                    continue
+            buf = readline().strip()
+
+        # Decode the author's name.
+        try:
+            (
+                self.author,
+                self.authored_date,
+                self.author_tz_offset,
+            ) = parse_actor_and_date(author_line.decode(self.encoding, "replace"))
+        except UnicodeDecodeError:
+            _logger.error(
+                "Failed to decode author line '%s' using encoding %s",
+                author_line,
+                self.encoding,
+                exc_info=True,
+            )
+
+        try:
+            (
+                self.committer,
+                self.committed_date,
+                self.committer_tz_offset,
+            ) = parse_actor_and_date(committer_line.decode(self.encoding, "replace"))
+        except UnicodeDecodeError:
+            _logger.error(
+                "Failed to decode committer line '%s' using encoding %s",
+                committer_line,
+                self.encoding,
+                exc_info=True,
+            )
+        # END handle author's encoding
+
+        # A stream from our data simply gives us the plain message.
+        # The end of our message stream is marked with a newline that we strip.
+        self.message = stream.read()
+        try:
+            self.message = self.message.decode(self.encoding, "replace")
+        except UnicodeDecodeError:
+            _logger.error(
+                "Failed to decode message '%s' using encoding %s",
+                self.message,
+                self.encoding,
+                exc_info=True,
+            )
+        # END exception handling
+
+        return self
+
+    # } END serializable implementation
+
+    @property
+    def co_authors(self) -> List[Actor]:
+        """Search the commit message for any co-authors of this commit.
+
+        Details on co-authors:
+        https://github.blog/2018-01-29-commit-together-with-co-authors/
+
+        :return:
+            List of co-authors for this commit (as :class:`~git.util.Actor` objects).
+        """
+        co_authors = []
+
+        if self.message:
+            results = re.findall(
+                r"^Co-authored-by: (.*) <(.*?)>$",
+                self.message,
+                re.MULTILINE,
+            )
+            for author in results:
+                co_authors.append(Actor(*author))
+
+        return co_authors
diff --git a/parrot/lib/python3.10/site-packages/git/objects/fun.py b/parrot/lib/python3.10/site-packages/git/objects/fun.py
new file mode 100644
index 0000000000000000000000000000000000000000..fe57da13ae4599368b9ebb396c2be1dfdb3d6a83
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/objects/fun.py
@@ -0,0 +1,281 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Functions that are supposed to be as fast as possible."""
+
+__all__ = [
+    "tree_to_stream",
+    "tree_entries_from_data",
+    "traverse_trees_recursive",
+    "traverse_tree_recursive",
+]
+
+from stat import S_ISDIR
+
+from git.compat import safe_decode, defenc
+
+# typing ----------------------------------------------
+
+from typing import (
+    Callable,
+    List,
+    MutableSequence,
+    Sequence,
+    Tuple,
+    TYPE_CHECKING,
+    Union,
+    overload,
+)
+
+if TYPE_CHECKING:
+    from _typeshed import ReadableBuffer
+
+    from git import GitCmdObjectDB
+
+EntryTup = Tuple[bytes, int, str]  # Same as TreeCacheTup in tree.py.
+EntryTupOrNone = Union[EntryTup, None]
+
+# ---------------------------------------------------
+
+
+def tree_to_stream(entries: Sequence[EntryTup], write: Callable[["ReadableBuffer"], Union[int, None]]) -> None:
+    """Write the given list of entries into a stream using its ``write`` method.
+
+    :param entries:
+        **Sorted** list of tuples with (binsha, mode, name).
+
+    :param write:
+        A ``write`` method which takes a data string.
+    """
+    ord_zero = ord("0")
+    bit_mask = 7  # 3 bits set.
+
+    for binsha, mode, name in entries:
+        mode_str = b""
+        for i in range(6):
+            mode_str = bytes([((mode >> (i * 3)) & bit_mask) + ord_zero]) + mode_str
+        # END for each 8 octal value
+
+        # git slices away the first octal if it's zero.
+        if mode_str[0] == ord_zero:
+            mode_str = mode_str[1:]
+        # END save a byte
+
+        # Here it comes: If the name is actually unicode, the replacement below will not
+        # work as the binsha is not part of the ascii unicode encoding - hence we must
+        # convert to an UTF-8 string for it to work properly. According to my tests,
+        # this is exactly what git does, that is it just takes the input literally,
+        # which appears to be UTF-8 on linux.
+        if isinstance(name, str):
+            name_bytes = name.encode(defenc)
+        else:
+            name_bytes = name  # type: ignore[unreachable]  # check runtime types - is always str?
+        write(b"".join((mode_str, b" ", name_bytes, b"\0", binsha)))
+    # END for each item
+
+
+def tree_entries_from_data(data: bytes) -> List[EntryTup]:
+    """Read the binary representation of a tree and returns tuples of
+    :class:`~git.objects.tree.Tree` items.
+
+    :param data:
+        Data block with tree data (as bytes).
+
+    :return:
+        list(tuple(binsha, mode, tree_relative_path), ...)
+    """
+    ord_zero = ord("0")
+    space_ord = ord(" ")
+    len_data = len(data)
+    i = 0
+    out = []
+    while i < len_data:
+        mode = 0
+
+        # Read Mode
+        # Some git versions truncate the leading 0, some don't.
+        # The type will be extracted from the mode later.
+        while data[i] != space_ord:
+            # Move existing mode integer up one level being 3 bits and add the actual
+            # ordinal value of the character.
+            mode = (mode << 3) + (data[i] - ord_zero)
+            i += 1
+        # END while reading mode
+
+        # Byte is space now, skip it.
+        i += 1
+
+        # Parse name, it is NULL separated.
+
+        ns = i
+        while data[i] != 0:
+            i += 1
+        # END while not reached NULL
+
+        # Default encoding for strings in git is UTF-8.
+        # Only use the respective unicode object if the byte stream was encoded.
+        name_bytes = data[ns:i]
+        name = safe_decode(name_bytes)
+
+        # Byte is NULL, get next 20.
+        i += 1
+        sha = data[i : i + 20]
+        i = i + 20
+        out.append((sha, mode, name))
+    # END for each byte in data stream
+    return out
+
+
+def _find_by_name(tree_data: MutableSequence[EntryTupOrNone], name: str, is_dir: bool, start_at: int) -> EntryTupOrNone:
+    """Return data entry matching the given name and tree mode or ``None``.
+
+    Before the item is returned, the respective data item is set None in the `tree_data`
+    list to mark it done.
+    """
+
+    try:
+        item = tree_data[start_at]
+        if item and item[2] == name and S_ISDIR(item[1]) == is_dir:
+            tree_data[start_at] = None
+            return item
+    except IndexError:
+        pass
+    # END exception handling
+    for index, item in enumerate(tree_data):
+        if item and item[2] == name and S_ISDIR(item[1]) == is_dir:
+            tree_data[index] = None
+            return item
+        # END if item matches
+    # END for each item
+    return None
+
+
+@overload
+def _to_full_path(item: None, path_prefix: str) -> None: ...
+
+
+@overload
+def _to_full_path(item: EntryTup, path_prefix: str) -> EntryTup: ...
+
+
+def _to_full_path(item: EntryTupOrNone, path_prefix: str) -> EntryTupOrNone:
+    """Rebuild entry with given path prefix."""
+    if not item:
+        return item
+    return (item[0], item[1], path_prefix + item[2])
+
+
+def traverse_trees_recursive(
+    odb: "GitCmdObjectDB", tree_shas: Sequence[Union[bytes, None]], path_prefix: str
+) -> List[Tuple[EntryTupOrNone, ...]]:
+    """
+    :return:
+        List of list with entries according to the given binary tree-shas.
+
+        The result is encoded in a list
+        of n tuple|None per blob/commit, (n == len(tree_shas)), where:
+
+        * [0] == 20 byte sha
+        * [1] == mode as int
+        * [2] == path relative to working tree root
+
+        The entry tuple is ``None`` if the respective blob/commit did not exist in the
+        given tree.
+
+    :param tree_shas:
+        Iterable of shas pointing to trees. All trees must be on the same level.
+        A tree-sha may be ``None``, in which case ``None``.
+
+    :param path_prefix:
+        A prefix to be added to the returned paths on this level.
+        Set it ``""`` for the first iteration.
+
+    :note:
+        The ordering of the returned items will be partially lost.
+    """
+    trees_data: List[List[EntryTupOrNone]] = []
+
+    nt = len(tree_shas)
+    for tree_sha in tree_shas:
+        if tree_sha is None:
+            data: List[EntryTupOrNone] = []
+        else:
+            # Make new list for typing as list invariant.
+            data = list(tree_entries_from_data(odb.stream(tree_sha).read()))
+        # END handle muted trees
+        trees_data.append(data)
+    # END for each sha to get data for
+
+    out: List[Tuple[EntryTupOrNone, ...]] = []
+
+    # Find all matching entries and recursively process them together if the match is a
+    # tree. If the match is a non-tree item, put it into the result.
+    # Processed items will be set None.
+    for ti, tree_data in enumerate(trees_data):
+        for ii, item in enumerate(tree_data):
+            if not item:
+                continue
+            # END skip already done items
+            entries: List[EntryTupOrNone]
+            entries = [None for _ in range(nt)]
+            entries[ti] = item
+            _sha, mode, name = item
+            is_dir = S_ISDIR(mode)  # Type mode bits
+
+            # Find this item in all other tree data items.
+            # Wrap around, but stop one before our current index, hence ti+nt, not
+            # ti+1+nt.
+            for tio in range(ti + 1, ti + nt):
+                tio = tio % nt
+                entries[tio] = _find_by_name(trees_data[tio], name, is_dir, ii)
+
+            # END for each other item data
+            # If we are a directory, enter recursion.
+            if is_dir:
+                out.extend(
+                    traverse_trees_recursive(
+                        odb,
+                        [((ei and ei[0]) or None) for ei in entries],
+                        path_prefix + name + "/",
+                    )
+                )
+            else:
+                out.append(tuple(_to_full_path(e, path_prefix) for e in entries))
+
+            # END handle recursion
+            # Finally mark it done.
+            tree_data[ii] = None
+        # END for each item
+
+        # We are done with one tree, set all its data empty.
+        del tree_data[:]
+    # END for each tree_data chunk
+    return out
+
+
+def traverse_tree_recursive(odb: "GitCmdObjectDB", tree_sha: bytes, path_prefix: str) -> List[EntryTup]:
+    """
+    :return:
+        List of entries of the tree pointed to by the binary `tree_sha`.
+
+        An entry has the following format:
+
+        * [0] 20 byte sha
+        * [1] mode as int
+        * [2] path relative to the repository
+
+    :param path_prefix:
+        Prefix to prepend to the front of all returned paths.
+    """
+    entries = []
+    data = tree_entries_from_data(odb.stream(tree_sha).read())
+
+    # Unpacking/packing is faster than accessing individual items.
+    for sha, mode, name in data:
+        if S_ISDIR(mode):
+            entries.extend(traverse_tree_recursive(odb, sha, path_prefix + name + "/"))
+        else:
+            entries.append((sha, mode, path_prefix + name))
+    # END for each item
+
+    return entries
diff --git a/parrot/lib/python3.10/site-packages/git/objects/submodule/__pycache__/base.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/objects/submodule/__pycache__/base.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42e28dbc95c26a135235934f5e78b69de564a6a7
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/objects/submodule/__pycache__/base.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/objects/submodule/root.py b/parrot/lib/python3.10/site-packages/git/objects/submodule/root.py
new file mode 100644
index 0000000000000000000000000000000000000000..d93193fa3c92201967af27ea382490eeb01fb95d
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/objects/submodule/root.py
@@ -0,0 +1,467 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+__all__ = ["RootModule", "RootUpdateProgress"]
+
+import logging
+
+import git
+from git.exc import InvalidGitRepositoryError
+
+from .base import Submodule, UpdateProgress
+from .util import find_first_remote_branch
+
+# typing -------------------------------------------------------------------
+
+from typing import TYPE_CHECKING, Union
+
+from git.types import Commit_ish
+
+if TYPE_CHECKING:
+    from git.repo import Repo
+    from git.util import IterableList
+
+# ----------------------------------------------------------------------------
+
+_logger = logging.getLogger(__name__)
+
+
+class RootUpdateProgress(UpdateProgress):
+    """Utility class which adds more opcodes to
+    :class:`~git.objects.submodule.base.UpdateProgress`."""
+
+    REMOVE, PATHCHANGE, BRANCHCHANGE, URLCHANGE = [
+        1 << x for x in range(UpdateProgress._num_op_codes, UpdateProgress._num_op_codes + 4)
+    ]
+    _num_op_codes = UpdateProgress._num_op_codes + 4
+
+    __slots__ = ()
+
+
+BEGIN = RootUpdateProgress.BEGIN
+END = RootUpdateProgress.END
+REMOVE = RootUpdateProgress.REMOVE
+BRANCHCHANGE = RootUpdateProgress.BRANCHCHANGE
+URLCHANGE = RootUpdateProgress.URLCHANGE
+PATHCHANGE = RootUpdateProgress.PATHCHANGE
+
+
+class RootModule(Submodule):
+    """A (virtual) root of all submodules in the given repository.
+
+    This can be used to more easily traverse all submodules of the
+    superproject (master repository).
+    """
+
+    __slots__ = ()
+
+    k_root_name = "__ROOT__"
+
+    def __init__(self, repo: "Repo") -> None:
+        # repo, binsha, mode=None, path=None, name = None, parent_commit=None, url=None, ref=None)
+        super().__init__(
+            repo,
+            binsha=self.NULL_BIN_SHA,
+            mode=self.k_default_mode,
+            path="",
+            name=self.k_root_name,
+            parent_commit=repo.head.commit,
+            url="",
+            branch_path=git.Head.to_full_path(self.k_head_default),
+        )
+
+    def _clear_cache(self) -> None:
+        """May not do anything."""
+        pass
+
+    # { Interface
+
+    def update(  # type: ignore[override]
+        self,
+        previous_commit: Union[Commit_ish, str, None] = None,
+        recursive: bool = True,
+        force_remove: bool = False,
+        init: bool = True,
+        to_latest_revision: bool = False,
+        progress: Union[None, "RootUpdateProgress"] = None,
+        dry_run: bool = False,
+        force_reset: bool = False,
+        keep_going: bool = False,
+    ) -> "RootModule":
+        """Update the submodules of this repository to the current HEAD commit.
+
+        This method behaves smartly by determining changes of the path of a submodule's
+        repository, next to changes to the to-be-checked-out commit or the branch to be
+        checked out. This works if the submodule's ID does not change.
+
+        Additionally it will detect addition and removal of submodules, which will be
+        handled gracefully.
+
+        :param previous_commit:
+            If set to a commit-ish, the commit we should use as the previous commit the
+            HEAD pointed to before it was set to the commit it points to now.
+            If ``None``, it defaults to ``HEAD@{1}`` otherwise.
+
+        :param recursive:
+            If ``True``, the children of submodules will be updated as well using the
+            same technique.
+
+        :param force_remove:
+            If submodules have been deleted, they will be forcibly removed. Otherwise
+            the update may fail if a submodule's repository cannot be deleted as changes
+            have been made to it.
+            (See :meth:`Submodule.update <git.objects.submodule.base.Submodule.update>`
+            for more information.)
+
+        :param init:
+            If we encounter a new module which would need to be initialized, then do it.
+
+        :param to_latest_revision:
+            If ``True``, instead of checking out the revision pointed to by this
+            submodule's sha, the checked out tracking branch will be merged with the
+            latest remote branch fetched from the repository's origin.
+
+            Unless `force_reset` is specified, a local tracking branch will never be
+            reset into its past, therefore the remote branch must be in the future for
+            this to have an effect.
+
+        :param force_reset:
+            If ``True``, submodules may checkout or reset their branch even if the
+            repository has pending changes that would be overwritten, or if the local
+            tracking branch is in the future of the remote tracking branch and would be
+            reset into its past.
+
+        :param progress:
+            :class:`RootUpdateProgress` instance, or ``None`` if no progress should be
+            sent.
+
+        :param dry_run:
+            If ``True``, operations will not actually be performed. Progress messages
+            will change accordingly to indicate the WOULD DO state of the operation.
+
+        :param keep_going:
+            If ``True``, we will ignore but log all errors, and keep going recursively.
+            Unless `dry_run` is set as well, `keep_going` could cause
+            subsequent/inherited errors you wouldn't see otherwise.
+            In conjunction with `dry_run`, this can be useful to anticipate all errors
+            when updating submodules.
+
+        :return:
+            self
+        """
+        if self.repo.bare:
+            raise InvalidGitRepositoryError("Cannot update submodules in bare repositories")
+        # END handle bare
+
+        if progress is None:
+            progress = RootUpdateProgress()
+        # END ensure progress is set
+
+        prefix = ""
+        if dry_run:
+            prefix = "DRY-RUN: "
+
+        repo = self.repo
+
+        try:
+            # SETUP BASE COMMIT
+            ###################
+            cur_commit = repo.head.commit
+            if previous_commit is None:
+                try:
+                    previous_commit = repo.commit(repo.head.log_entry(-1).oldhexsha)
+                    if previous_commit.binsha == previous_commit.NULL_BIN_SHA:
+                        raise IndexError
+                    # END handle initial commit
+                except IndexError:
+                    # In new repositories, there is no previous commit.
+                    previous_commit = cur_commit
+                # END exception handling
+            else:
+                previous_commit = repo.commit(previous_commit)  # Obtain commit object.
+            # END handle previous commit
+
+            psms: "IterableList[Submodule]" = self.list_items(repo, parent_commit=previous_commit)
+            sms: "IterableList[Submodule]" = self.list_items(repo)
+            spsms = set(psms)
+            ssms = set(sms)
+
+            # HANDLE REMOVALS
+            ###################
+            rrsm = spsms - ssms
+            len_rrsm = len(rrsm)
+
+            for i, rsm in enumerate(rrsm):
+                op = REMOVE
+                if i == 0:
+                    op |= BEGIN
+                # END handle begin
+
+                # Fake it into thinking its at the current commit to allow deletion
+                # of previous module. Trigger the cache to be updated before that.
+                progress.update(
+                    op,
+                    i,
+                    len_rrsm,
+                    prefix + "Removing submodule %r at %s" % (rsm.name, rsm.abspath),
+                )
+                rsm._parent_commit = repo.head.commit
+                rsm.remove(
+                    configuration=False,
+                    module=True,
+                    force=force_remove,
+                    dry_run=dry_run,
+                )
+
+                if i == len_rrsm - 1:
+                    op |= END
+                # END handle end
+                progress.update(op, i, len_rrsm, prefix + "Done removing submodule %r" % rsm.name)
+            # END for each removed submodule
+
+            # HANDLE PATH RENAMES
+            #####################
+            # URL changes + branch changes.
+            csms = spsms & ssms
+            len_csms = len(csms)
+            for i, csm in enumerate(csms):
+                psm: "Submodule" = psms[csm.name]
+                sm: "Submodule" = sms[csm.name]
+
+                # PATH CHANGES
+                ##############
+                if sm.path != psm.path and psm.module_exists():
+                    progress.update(
+                        BEGIN | PATHCHANGE,
+                        i,
+                        len_csms,
+                        prefix + "Moving repository of submodule %r from %s to %s" % (sm.name, psm.abspath, sm.abspath),
+                    )
+                    # Move the module to the new path.
+                    if not dry_run:
+                        psm.move(sm.path, module=True, configuration=False)
+                    # END handle dry_run
+                    progress.update(
+                        END | PATHCHANGE,
+                        i,
+                        len_csms,
+                        prefix + "Done moving repository of submodule %r" % sm.name,
+                    )
+                # END handle path changes
+
+                if sm.module_exists():
+                    # HANDLE URL CHANGE
+                    ###################
+                    if sm.url != psm.url:
+                        # Add the new remote, remove the old one.
+                        # This way, if the url just changes, the commits will not have
+                        # to be re-retrieved.
+                        nn = "__new_origin__"
+                        smm = sm.module()
+                        rmts = smm.remotes
+
+                        # Don't do anything if we already have the url we search in
+                        # place.
+                        if len([r for r in rmts if r.url == sm.url]) == 0:
+                            progress.update(
+                                BEGIN | URLCHANGE,
+                                i,
+                                len_csms,
+                                prefix + "Changing url of submodule %r from %s to %s" % (sm.name, psm.url, sm.url),
+                            )
+
+                            if not dry_run:
+                                assert nn not in [r.name for r in rmts]
+                                smr = smm.create_remote(nn, sm.url)
+                                smr.fetch(progress=progress)
+
+                                # If we have a tracking branch, it should be available
+                                # in the new remote as well.
+                                if len([r for r in smr.refs if r.remote_head == sm.branch_name]) == 0:
+                                    raise ValueError(
+                                        "Submodule branch named %r was not available in new submodule remote at %r"
+                                        % (sm.branch_name, sm.url)
+                                    )
+                                # END head is not detached
+
+                                # Now delete the changed one.
+                                rmt_for_deletion = None
+                                for remote in rmts:
+                                    if remote.url == psm.url:
+                                        rmt_for_deletion = remote
+                                        break
+                                    # END if urls match
+                                # END for each remote
+
+                                # If we didn't find a matching remote, but have exactly
+                                # one, we can safely use this one.
+                                if rmt_for_deletion is None:
+                                    if len(rmts) == 1:
+                                        rmt_for_deletion = rmts[0]
+                                    else:
+                                        # If we have not found any remote with the
+                                        # original URL we may not have a name. This is a
+                                        # special case, and its okay to fail here.
+                                        # Alternatively we could just generate a unique
+                                        # name and leave all existing ones in place.
+                                        raise InvalidGitRepositoryError(
+                                            "Couldn't find original remote-repo at url %r" % psm.url
+                                        )
+                                    # END handle one single remote
+                                # END handle check we found a remote
+
+                                orig_name = rmt_for_deletion.name
+                                smm.delete_remote(rmt_for_deletion)
+                                # NOTE: Currently we leave tags from the deleted remotes
+                                # as well as separate tracking branches in the possibly
+                                # totally changed repository (someone could have changed
+                                # the url to another project). At some point, one might
+                                # want to clean it up, but the danger is high to remove
+                                # stuff the user has added explicitly.
+
+                                # Rename the new remote back to what it was.
+                                smr.rename(orig_name)
+
+                                # Early on, we verified that the our current tracking
+                                # branch exists in the remote. Now we have to ensure
+                                # that the sha we point to is still contained in the new
+                                # remote tracking branch.
+                                smsha = sm.binsha
+                                found = False
+                                rref = smr.refs[self.branch_name]
+                                for c in rref.commit.traverse():
+                                    if c.binsha == smsha:
+                                        found = True
+                                        break
+                                    # END traverse all commits in search for sha
+                                # END for each commit
+
+                                if not found:
+                                    # Adjust our internal binsha to use the one of the
+                                    # remote this way, it will be checked out in the
+                                    # next step. This will change the submodule relative
+                                    # to us, so the user will be able to commit the
+                                    # change easily.
+                                    _logger.warning(
+                                        "Current sha %s was not contained in the tracking\
+             branch at the new remote, setting it the the remote's tracking branch",
+                                        sm.hexsha,
+                                    )
+                                    sm.binsha = rref.commit.binsha
+                                # END reset binsha
+
+                                # NOTE: All checkout is performed by the base
+                                # implementation of update.
+                            # END handle dry_run
+                            progress.update(
+                                END | URLCHANGE,
+                                i,
+                                len_csms,
+                                prefix + "Done adjusting url of submodule %r" % (sm.name),
+                            )
+                        # END skip remote handling if new url already exists in module
+                    # END handle url
+
+                    # HANDLE PATH CHANGES
+                    #####################
+                    if sm.branch_path != psm.branch_path:
+                        # Finally, create a new tracking branch which tracks the new
+                        # remote branch.
+                        progress.update(
+                            BEGIN | BRANCHCHANGE,
+                            i,
+                            len_csms,
+                            prefix
+                            + "Changing branch of submodule %r from %s to %s"
+                            % (sm.name, psm.branch_path, sm.branch_path),
+                        )
+                        if not dry_run:
+                            smm = sm.module()
+                            smmr = smm.remotes
+                            # As the branch might not exist yet, we will have to fetch
+                            # all remotes to be sure...
+                            for remote in smmr:
+                                remote.fetch(progress=progress)
+                            # END for each remote
+
+                            try:
+                                tbr = git.Head.create(
+                                    smm,
+                                    sm.branch_name,
+                                    logmsg="branch: Created from HEAD",
+                                )
+                            except OSError:
+                                # ...or reuse the existing one.
+                                tbr = git.Head(smm, sm.branch_path)
+                            # END ensure tracking branch exists
+
+                            tbr.set_tracking_branch(find_first_remote_branch(smmr, sm.branch_name))
+                            # NOTE: All head-resetting is done in the base
+                            # implementation of update but we will have to checkout the
+                            # new branch here. As it still points to the currently
+                            # checked out commit, we don't do any harm.
+                            # As we don't want to update working-tree or index, changing
+                            # the ref is all there is to do.
+                            smm.head.reference = tbr
+                        # END handle dry_run
+
+                        progress.update(
+                            END | BRANCHCHANGE,
+                            i,
+                            len_csms,
+                            prefix + "Done changing branch of submodule %r" % sm.name,
+                        )
+                    # END handle branch
+                # END handle
+            # END for each common submodule
+        except Exception as err:
+            if not keep_going:
+                raise
+            _logger.error(str(err))
+        # END handle keep_going
+
+        # FINALLY UPDATE ALL ACTUAL SUBMODULES
+        ######################################
+        for sm in sms:
+            # Update the submodule using the default method.
+            sm.update(
+                recursive=False,
+                init=init,
+                to_latest_revision=to_latest_revision,
+                progress=progress,
+                dry_run=dry_run,
+                force=force_reset,
+                keep_going=keep_going,
+            )
+
+            # Update recursively depth first - question is which inconsistent state will
+            # be better in case it fails somewhere. Defective branch or defective depth.
+            # The RootSubmodule type will never process itself, which was done in the
+            # previous expression.
+            if recursive:
+                # The module would exist by now if we are not in dry_run mode.
+                if sm.module_exists():
+                    type(self)(sm.module()).update(
+                        recursive=True,
+                        force_remove=force_remove,
+                        init=init,
+                        to_latest_revision=to_latest_revision,
+                        progress=progress,
+                        dry_run=dry_run,
+                        force_reset=force_reset,
+                        keep_going=keep_going,
+                    )
+                # END handle dry_run
+            # END handle recursive
+        # END for each submodule to update
+
+        return self
+
+    def module(self) -> "Repo":
+        """:return: The actual repository containing the submodules"""
+        return self.repo
+
+    # } END interface
+
+
+# } END classes
diff --git a/parrot/lib/python3.10/site-packages/git/objects/tag.py b/parrot/lib/python3.10/site-packages/git/objects/tag.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3bb0b882b8341e335f76354f1f40d5998f48090
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/objects/tag.py
@@ -0,0 +1,141 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Provides an :class:`~git.objects.base.Object`-based type for annotated tags.
+
+This defines the :class:`TagObject` class, which represents annotated tags.
+For lightweight tags, see the :mod:`git.refs.tag` module.
+"""
+
+__all__ = ["TagObject"]
+
+import sys
+
+from git.compat import defenc
+from git.util import hex_to_bin
+
+from . import base
+from .util import get_object_type_by_name, parse_actor_and_date
+
+# typing ----------------------------------------------
+
+from typing import List, TYPE_CHECKING, Union
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+if TYPE_CHECKING:
+    from git.repo import Repo
+    from git.util import Actor
+
+    from .blob import Blob
+    from .commit import Commit
+    from .tree import Tree
+
+# ---------------------------------------------------
+
+
+class TagObject(base.Object):
+    """Annotated (i.e. non-lightweight) tag carrying additional information about an
+    object we are pointing to.
+
+    See :manpage:`gitglossary(7)` on "tag object":
+    https://git-scm.com/docs/gitglossary#def_tag_object
+    """
+
+    type: Literal["tag"] = "tag"
+
+    __slots__ = (
+        "object",
+        "tag",
+        "tagger",
+        "tagged_date",
+        "tagger_tz_offset",
+        "message",
+    )
+
+    def __init__(
+        self,
+        repo: "Repo",
+        binsha: bytes,
+        object: Union[None, base.Object] = None,
+        tag: Union[None, str] = None,
+        tagger: Union[None, "Actor"] = None,
+        tagged_date: Union[int, None] = None,
+        tagger_tz_offset: Union[int, None] = None,
+        message: Union[str, None] = None,
+    ) -> None:  # @ReservedAssignment
+        """Initialize a tag object with additional data.
+
+        :param repo:
+            Repository this object is located in.
+
+        :param binsha:
+            20 byte SHA1.
+
+        :param object:
+            :class:`~git.objects.base.Object` instance of object we are pointing to.
+
+        :param tag:
+            Name of this tag.
+
+        :param tagger:
+            :class:`~git.util.Actor` identifying the tagger.
+
+        :param tagged_date: int_seconds_since_epoch
+            The DateTime of the tag creation.
+            Use :func:`time.gmtime` to convert it into a different format.
+
+        :param tagger_tz_offset: int_seconds_west_of_utc
+            The timezone that the `tagged_date` is in, in a format similar to
+            :attr:`time.altzone`.
+        """
+        super().__init__(repo, binsha)
+        if object is not None:
+            self.object: Union["Commit", "Blob", "Tree", "TagObject"] = object
+        if tag is not None:
+            self.tag = tag
+        if tagger is not None:
+            self.tagger = tagger
+        if tagged_date is not None:
+            self.tagged_date = tagged_date
+        if tagger_tz_offset is not None:
+            self.tagger_tz_offset = tagger_tz_offset
+        if message is not None:
+            self.message = message
+
+    def _set_cache_(self, attr: str) -> None:
+        """Cache all our attributes at once."""
+        if attr in TagObject.__slots__:
+            ostream = self.repo.odb.stream(self.binsha)
+            lines: List[str] = ostream.read().decode(defenc, "replace").splitlines()
+
+            _obj, hexsha = lines[0].split(" ")
+            _type_token, type_name = lines[1].split(" ")
+            object_type = get_object_type_by_name(type_name.encode("ascii"))
+            self.object = object_type(self.repo, hex_to_bin(hexsha))
+
+            self.tag = lines[2][4:]  # tag <tag name>
+
+            if len(lines) > 3:
+                tagger_info = lines[3]  # tagger <actor> <date>
+                (
+                    self.tagger,
+                    self.tagged_date,
+                    self.tagger_tz_offset,
+                ) = parse_actor_and_date(tagger_info)
+
+            # Line 4 empty - it could mark the beginning of the next header.
+            # In case there really is no message, it would not exist.
+            # Otherwise a newline separates header from message.
+            if len(lines) > 5:
+                self.message = "\n".join(lines[5:])
+            else:
+                self.message = ""
+        # END check our attributes
+        else:
+            super()._set_cache_(attr)
diff --git a/parrot/lib/python3.10/site-packages/git/objects/tree.py b/parrot/lib/python3.10/site-packages/git/objects/tree.py
new file mode 100644
index 0000000000000000000000000000000000000000..09184a78155e4ae7317ae33830b0461ba089a4d0
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/objects/tree.py
@@ -0,0 +1,414 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+__all__ = ["TreeModifier", "Tree"]
+
+import sys
+
+import git.diff as git_diff
+from git.util import IterableList, join_path, to_bin_sha
+
+from . import util
+from .base import IndexObjUnion, IndexObject
+from .blob import Blob
+from .fun import tree_entries_from_data, tree_to_stream
+from .submodule.base import Submodule
+
+# typing -------------------------------------------------
+
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Tuple,
+    TYPE_CHECKING,
+    Type,
+    Union,
+    cast,
+)
+
+if sys.version_info >= (3, 8):
+    from typing import Literal
+else:
+    from typing_extensions import Literal
+
+from git.types import PathLike
+
+if TYPE_CHECKING:
+    from io import BytesIO
+
+    from git.repo import Repo
+
+TreeCacheTup = Tuple[bytes, int, str]
+
+TraversedTreeTup = Union[Tuple[Union["Tree", None], IndexObjUnion, Tuple["Submodule", "Submodule"]]]
+
+# --------------------------------------------------------
+
+cmp: Callable[[str, str], int] = lambda a, b: (a > b) - (a < b)
+
+
+class TreeModifier:
+    """A utility class providing methods to alter the underlying cache in a list-like
+    fashion.
+
+    Once all adjustments are complete, the :attr:`_cache`, which really is a reference
+    to the cache of a tree, will be sorted. This ensures it will be in a serializable
+    state.
+    """
+
+    __slots__ = ("_cache",)
+
+    def __init__(self, cache: List[TreeCacheTup]) -> None:
+        self._cache = cache
+
+    def _index_by_name(self, name: str) -> int:
+        """:return: index of an item with name, or -1 if not found"""
+        for i, t in enumerate(self._cache):
+            if t[2] == name:
+                return i
+            # END found item
+        # END for each item in cache
+        return -1
+
+    # { Interface
+    def set_done(self) -> "TreeModifier":
+        """Call this method once you are done modifying the tree information.
+
+        This may be called several times, but be aware that each call will cause a sort
+        operation.
+
+        :return:
+            self
+        """
+        self._cache.sort(key=lambda x: (x[2] + "/") if x[1] == Tree.tree_id << 12 else x[2])
+        return self
+
+    # } END interface
+
+    # { Mutators
+    def add(self, sha: bytes, mode: int, name: str, force: bool = False) -> "TreeModifier":
+        """Add the given item to the tree.
+
+        If an item with the given name already exists, nothing will be done, but a
+        :exc:`ValueError` will be raised if the sha and mode of the existing item do not
+        match the one you add, unless `force` is ``True``.
+
+        :param sha:
+            The 20 or 40 byte sha of the item to add.
+
+        :param mode:
+            :class:`int` representing the stat-compatible mode of the item.
+
+        :param force:
+            If ``True``, an item with your name and information will overwrite any
+            existing item with the same name, no matter which information it has.
+
+        :return:
+            self
+        """
+        if "/" in name:
+            raise ValueError("Name must not contain '/' characters")
+        if (mode >> 12) not in Tree._map_id_to_type:
+            raise ValueError("Invalid object type according to mode %o" % mode)
+
+        sha = to_bin_sha(sha)
+        index = self._index_by_name(name)
+
+        item = (sha, mode, name)
+
+        if index == -1:
+            self._cache.append(item)
+        else:
+            if force:
+                self._cache[index] = item
+            else:
+                ex_item = self._cache[index]
+                if ex_item[0] != sha or ex_item[1] != mode:
+                    raise ValueError("Item %r existed with different properties" % name)
+                # END handle mismatch
+            # END handle force
+        # END handle name exists
+        return self
+
+    def add_unchecked(self, binsha: bytes, mode: int, name: str) -> None:
+        """Add the given item to the tree. Its correctness is assumed, so it is the
+        caller's responsibility to ensure that the input is correct.
+
+        For more information on the parameters, see :meth:`add`.
+
+        :param binsha:
+            20 byte binary sha.
+        """
+        assert isinstance(binsha, bytes) and isinstance(mode, int) and isinstance(name, str)
+        tree_cache = (binsha, mode, name)
+
+        self._cache.append(tree_cache)
+
+    def __delitem__(self, name: str) -> None:
+        """Delete an item with the given name if it exists."""
+        index = self._index_by_name(name)
+        if index > -1:
+            del self._cache[index]
+
+    # } END mutators
+
+
+class Tree(IndexObject, git_diff.Diffable, util.Traversable, util.Serializable):
+    R"""Tree objects represent an ordered list of :class:`~git.objects.blob.Blob`\s and
+    other :class:`Tree`\s.
+
+    See :manpage:`gitglossary(7)` on "tree object":
+    https://git-scm.com/docs/gitglossary#def_tree_object
+
+    Subscripting is supported, as with a list or dict:
+
+    * Access a specific blob using the ``tree["filename"]`` notation.
+    * You may likewise access by index, like ``blob = tree[0]``.
+    """
+
+    type: Literal["tree"] = "tree"
+
+    __slots__ = ("_cache",)
+
+    # Actual integer IDs for comparison.
+    commit_id = 0o16  # Equals stat.S_IFDIR | stat.S_IFLNK - a directory link.
+    blob_id = 0o10
+    symlink_id = 0o12
+    tree_id = 0o04
+
+    _map_id_to_type: Dict[int, Type[IndexObjUnion]] = {
+        commit_id: Submodule,
+        blob_id: Blob,
+        symlink_id: Blob,
+        # Tree ID added once Tree is defined.
+    }
+
+    def __init__(
+        self,
+        repo: "Repo",
+        binsha: bytes,
+        mode: int = tree_id << 12,
+        path: Union[PathLike, None] = None,
+    ):
+        super().__init__(repo, binsha, mode, path)
+
+    @classmethod
+    def _get_intermediate_items(
+        cls,
+        index_object: IndexObjUnion,
+    ) -> Union[Tuple["Tree", ...], Tuple[()]]:
+        if index_object.type == "tree":
+            return tuple(index_object._iter_convert_to_object(index_object._cache))
+        return ()
+
+    def _set_cache_(self, attr: str) -> None:
+        if attr == "_cache":
+            # Set the data when we need it.
+            ostream = self.repo.odb.stream(self.binsha)
+            self._cache: List[TreeCacheTup] = tree_entries_from_data(ostream.read())
+        else:
+            super()._set_cache_(attr)
+        # END handle attribute
+
+    def _iter_convert_to_object(self, iterable: Iterable[TreeCacheTup]) -> Iterator[IndexObjUnion]:
+        """Iterable yields tuples of (binsha, mode, name), which will be converted to
+        the respective object representation.
+        """
+        for binsha, mode, name in iterable:
+            path = join_path(self.path, name)
+            try:
+                yield self._map_id_to_type[mode >> 12](self.repo, binsha, mode, path)
+            except KeyError as e:
+                raise TypeError("Unknown mode %o found in tree data for path '%s'" % (mode, path)) from e
+        # END for each item
+
+    def join(self, file: str) -> IndexObjUnion:
+        """Find the named object in this tree's contents.
+
+        :return:
+            :class:`~git.objects.blob.Blob`, :class:`Tree`, or
+            :class:`~git.objects.submodule.base.Submodule`
+
+        :raise KeyError:
+            If the given file or tree does not exist in this tree.
+        """
+        msg = "Blob or Tree named %r not found"
+        if "/" in file:
+            tree = self
+            item = self
+            tokens = file.split("/")
+            for i, token in enumerate(tokens):
+                item = tree[token]
+                if item.type == "tree":
+                    tree = item
+                else:
+                    # Safety assertion - blobs are at the end of the path.
+                    if i != len(tokens) - 1:
+                        raise KeyError(msg % file)
+                    return item
+                # END handle item type
+            # END for each token of split path
+            if item == self:
+                raise KeyError(msg % file)
+            return item
+        else:
+            for info in self._cache:
+                if info[2] == file:  # [2] == name
+                    return self._map_id_to_type[info[1] >> 12](
+                        self.repo, info[0], info[1], join_path(self.path, info[2])
+                    )
+            # END for each obj
+            raise KeyError(msg % file)
+        # END handle long paths
+
+    def __truediv__(self, file: str) -> IndexObjUnion:
+        """The ``/`` operator is another syntax for joining.
+
+        See :meth:`join` for details.
+        """
+        return self.join(file)
+
+    @property
+    def trees(self) -> List["Tree"]:
+        """:return: list(Tree, ...) List of trees directly below this tree"""
+        return [i for i in self if i.type == "tree"]
+
+    @property
+    def blobs(self) -> List[Blob]:
+        """:return: list(Blob, ...) List of blobs directly below this tree"""
+        return [i for i in self if i.type == "blob"]
+
+    @property
+    def cache(self) -> TreeModifier:
+        """
+        :return:
+            An object allowing modification of the internal cache. This can be used to
+            change the tree's contents. When done, make sure you call
+            :meth:`~TreeModifier.set_done` on the tree modifier, or serialization
+            behaviour will be incorrect.
+
+        :note:
+            See :class:`TreeModifier` for more information on how to alter the cache.
+        """
+        return TreeModifier(self._cache)
+
+    def traverse(
+        self,
+        predicate: Callable[[Union[IndexObjUnion, TraversedTreeTup], int], bool] = lambda i, d: True,
+        prune: Callable[[Union[IndexObjUnion, TraversedTreeTup], int], bool] = lambda i, d: False,
+        depth: int = -1,
+        branch_first: bool = True,
+        visit_once: bool = False,
+        ignore_self: int = 1,
+        as_edge: bool = False,
+    ) -> Union[Iterator[IndexObjUnion], Iterator[TraversedTreeTup]]:
+        """For documentation, see
+        `Traversable._traverse() <git.objects.util.Traversable._traverse>`.
+
+        Trees are set to ``visit_once = False`` to gain more performance in the
+        traversal.
+        """
+
+        # # To typecheck instead of using cast.
+        # import itertools
+        # def is_tree_traversed(inp: Tuple) -> TypeGuard[Tuple[Iterator[Union['Tree', 'Blob', 'Submodule']]]]:
+        #     return all(isinstance(x, (Blob, Tree, Submodule)) for x in inp[1])
+
+        # ret = super().traverse(predicate, prune, depth, branch_first, visit_once, ignore_self)
+        # ret_tup = itertools.tee(ret, 2)
+        # assert is_tree_traversed(ret_tup), f"Type is {[type(x) for x in list(ret_tup[0])]}"
+        # return ret_tup[0]
+
+        return cast(
+            Union[Iterator[IndexObjUnion], Iterator[TraversedTreeTup]],
+            super()._traverse(
+                predicate,  # type: ignore[arg-type]
+                prune,  # type: ignore[arg-type]
+                depth,
+                branch_first,
+                visit_once,
+                ignore_self,
+            ),
+        )
+
+    def list_traverse(self, *args: Any, **kwargs: Any) -> IterableList[IndexObjUnion]:
+        """
+        :return:
+            :class:`~git.util.IterableList` with the results of the traversal as
+            produced by :meth:`traverse`
+
+            Tree -> IterableList[Union[Submodule, Tree, Blob]]
+        """
+        return super()._list_traverse(*args, **kwargs)
+
+    # List protocol
+
+    def __getslice__(self, i: int, j: int) -> List[IndexObjUnion]:
+        return list(self._iter_convert_to_object(self._cache[i:j]))
+
+    def __iter__(self) -> Iterator[IndexObjUnion]:
+        return self._iter_convert_to_object(self._cache)
+
+    def __len__(self) -> int:
+        return len(self._cache)
+
+    def __getitem__(self, item: Union[str, int, slice]) -> IndexObjUnion:
+        if isinstance(item, int):
+            info = self._cache[item]
+            return self._map_id_to_type[info[1] >> 12](self.repo, info[0], info[1], join_path(self.path, info[2]))
+
+        if isinstance(item, str):
+            # compatibility
+            return self.join(item)
+        # END index is basestring
+
+        raise TypeError("Invalid index type: %r" % item)
+
+    def __contains__(self, item: Union[IndexObjUnion, PathLike]) -> bool:
+        if isinstance(item, IndexObject):
+            for info in self._cache:
+                if item.binsha == info[0]:
+                    return True
+                # END compare sha
+            # END for each entry
+        # END handle item is index object
+        # compatibility
+
+        # Treat item as repo-relative path.
+        else:
+            path = self.path
+            for info in self._cache:
+                if item == join_path(path, info[2]):
+                    return True
+        # END for each item
+        return False
+
+    def __reversed__(self) -> Iterator[IndexObjUnion]:
+        return reversed(self._iter_convert_to_object(self._cache))  # type: ignore[call-overload]
+
+    def _serialize(self, stream: "BytesIO") -> "Tree":
+        """Serialize this tree into the stream. Assumes sorted tree data.
+
+        :note:
+            We will assume our tree data to be in a sorted state. If this is not the
+            case, serialization will not generate a correct tree representation as these
+            are assumed to be sorted by algorithms.
+        """
+        tree_to_stream(self._cache, stream.write)
+        return self
+
+    def _deserialize(self, stream: "BytesIO") -> "Tree":
+        self._cache = tree_entries_from_data(stream.read())
+        return self
+
+
+# END tree
+
+# Finalize map definition.
+Tree._map_id_to_type[Tree.tree_id] = Tree
diff --git a/parrot/lib/python3.10/site-packages/git/objects/util.py b/parrot/lib/python3.10/site-packages/git/objects/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c56e61349d992364c00d23e370b8cc386748b75
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/objects/util.py
@@ -0,0 +1,700 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Utility functions for working with git objects."""
+
+__all__ = [
+    "get_object_type_by_name",
+    "parse_date",
+    "parse_actor_and_date",
+    "ProcessStreamAdapter",
+    "Traversable",
+    "altz_to_utctz_str",
+    "utctz_to_altz",
+    "verify_utctz",
+    "Actor",
+    "tzoffset",
+    "utc",
+]
+
+from abc import ABC, abstractmethod
+import calendar
+from collections import deque
+from datetime import datetime, timedelta, tzinfo
+import re
+from string import digits
+import time
+import warnings
+
+from git.util import Actor, IterableList, IterableObj
+
+# typing ------------------------------------------------------------
+
+from typing import (
+    Any,
+    Callable,
+    Deque,
+    Iterator,
+    NamedTuple,
+    Sequence,
+    TYPE_CHECKING,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+
+from git.types import Has_id_attribute, Literal
+
+if TYPE_CHECKING:
+    from io import BytesIO, StringIO
+    from subprocess import Popen
+
+    from git.types import Protocol, runtime_checkable
+
+    from .blob import Blob
+    from .commit import Commit
+    from .submodule.base import Submodule
+    from .tag import TagObject
+    from .tree import TraversedTreeTup, Tree
+else:
+    Protocol = ABC
+
+    def runtime_checkable(f):
+        return f
+
+
+class TraverseNT(NamedTuple):
+    depth: int
+    item: Union["Traversable", "Blob"]
+    src: Union["Traversable", None]
+
+
+T_TIobj = TypeVar("T_TIobj", bound="TraversableIterableObj")  # For TraversableIterableObj.traverse()
+
+TraversedTup = Union[
+    Tuple[Union["Traversable", None], "Traversable"],  # For Commit, Submodule.
+    "TraversedTreeTup",  # For Tree.traverse().
+]
+
+# --------------------------------------------------------------------
+
+ZERO = timedelta(0)
+
+# { Functions
+
+
+def mode_str_to_int(modestr: Union[bytes, str]) -> int:
+    """Convert mode bits from an octal mode string to an integer mode for git.
+
+    :param modestr:
+        String like ``755`` or ``644`` or ``100644`` - only the last 6 chars will be
+        used.
+
+    :return:
+        String identifying a mode compatible to the mode methods ids of the :mod:`stat`
+        module regarding the rwx permissions for user, group and other, special flags
+        and file system flags, such as whether it is a symlink.
+    """
+    mode = 0
+    for iteration, char in enumerate(reversed(modestr[-6:])):
+        char = cast(Union[str, int], char)
+        mode += int(char) << iteration * 3
+    # END for each char
+    return mode
+
+
+def get_object_type_by_name(
+    object_type_name: bytes,
+) -> Union[Type["Commit"], Type["TagObject"], Type["Tree"], Type["Blob"]]:
+    """Retrieve the Python class GitPython uses to represent a kind of Git object.
+
+    :return:
+        A type suitable to handle the given as `object_type_name`.
+        This type can be called create new instances.
+
+    :param object_type_name:
+        Member of :attr:`Object.TYPES <git.objects.base.Object.TYPES>`.
+
+    :raise ValueError:
+        If `object_type_name` is unknown.
+    """
+    if object_type_name == b"commit":
+        from . import commit
+
+        return commit.Commit
+    elif object_type_name == b"tag":
+        from . import tag
+
+        return tag.TagObject
+    elif object_type_name == b"blob":
+        from . import blob
+
+        return blob.Blob
+    elif object_type_name == b"tree":
+        from . import tree
+
+        return tree.Tree
+    else:
+        raise ValueError("Cannot handle unknown object type: %s" % object_type_name.decode())
+
+
+def utctz_to_altz(utctz: str) -> int:
+    """Convert a git timezone offset into a timezone offset west of UTC in seconds
+    (compatible with :attr:`time.altzone`).
+
+    :param utctz:
+        git utc timezone string, e.g. +0200
+    """
+    int_utctz = int(utctz)
+    seconds = (abs(int_utctz) // 100) * 3600 + (abs(int_utctz) % 100) * 60
+    return seconds if int_utctz < 0 else -seconds
+
+
+def altz_to_utctz_str(altz: float) -> str:
+    """Convert a timezone offset west of UTC in seconds into a Git timezone offset
+    string.
+
+    :param altz:
+        Timezone offset in seconds west of UTC.
+    """
+    hours = abs(altz) // 3600
+    minutes = (abs(altz) % 3600) // 60
+    sign = "-" if altz >= 60 else "+"
+    return "{}{:02}{:02}".format(sign, hours, minutes)
+
+
+def verify_utctz(offset: str) -> str:
+    """
+    :raise ValueError:
+        If `offset` is incorrect.
+
+    :return:
+        `offset`
+    """
+    fmt_exc = ValueError("Invalid timezone offset format: %s" % offset)
+    if len(offset) != 5:
+        raise fmt_exc
+    if offset[0] not in "+-":
+        raise fmt_exc
+    if offset[1] not in digits or offset[2] not in digits or offset[3] not in digits or offset[4] not in digits:
+        raise fmt_exc
+    # END for each char
+    return offset
+
+
+class tzoffset(tzinfo):
+    def __init__(self, secs_west_of_utc: float, name: Union[None, str] = None) -> None:
+        self._offset = timedelta(seconds=-secs_west_of_utc)
+        self._name = name or "fixed"
+
+    def __reduce__(self) -> Tuple[Type["tzoffset"], Tuple[float, str]]:
+        return tzoffset, (-self._offset.total_seconds(), self._name)
+
+    def utcoffset(self, dt: Union[datetime, None]) -> timedelta:
+        return self._offset
+
+    def tzname(self, dt: Union[datetime, None]) -> str:
+        return self._name
+
+    def dst(self, dt: Union[datetime, None]) -> timedelta:
+        return ZERO
+
+
+utc = tzoffset(0, "UTC")
+
+
+def from_timestamp(timestamp: float, tz_offset: float) -> datetime:
+    """Convert a `timestamp` + `tz_offset` into an aware :class:`~datetime.datetime`
+    instance."""
+    utc_dt = datetime.fromtimestamp(timestamp, utc)
+    try:
+        local_dt = utc_dt.astimezone(tzoffset(tz_offset))
+        return local_dt
+    except ValueError:
+        return utc_dt
+
+
+def parse_date(string_date: Union[str, datetime]) -> Tuple[int, int]:
+    """Parse the given date as one of the following:
+
+        * Aware datetime instance
+        * Git internal format: timestamp offset
+        * :rfc:`2822`: ``Thu, 07 Apr 2005 22:13:13 +0200``
+        * ISO 8601: ``2005-04-07T22:13:13`` - The ``T`` can be a space as well.
+
+    :return:
+        Tuple(int(timestamp_UTC), int(offset)), both in seconds since epoch
+
+    :raise ValueError:
+        If the format could not be understood.
+
+    :note:
+        Date can also be ``YYYY.MM.DD``, ``MM/DD/YYYY`` and ``DD.MM.YYYY``.
+    """
+    if isinstance(string_date, datetime):
+        if string_date.tzinfo:
+            utcoffset = cast(timedelta, string_date.utcoffset())  # typeguard, if tzinfoand is not None
+            offset = -int(utcoffset.total_seconds())
+            return int(string_date.astimezone(utc).timestamp()), offset
+        else:
+            raise ValueError(f"string_date datetime object without tzinfo, {string_date}")
+
+    # Git time
+    try:
+        if string_date.count(" ") == 1 and string_date.rfind(":") == -1:
+            timestamp, offset_str = string_date.split()
+            if timestamp.startswith("@"):
+                timestamp = timestamp[1:]
+            timestamp_int = int(timestamp)
+            return timestamp_int, utctz_to_altz(verify_utctz(offset_str))
+        else:
+            offset_str = "+0000"  # Local time by default.
+            if string_date[-5] in "-+":
+                offset_str = verify_utctz(string_date[-5:])
+                string_date = string_date[:-6]  # skip space as well
+            # END split timezone info
+            offset = utctz_to_altz(offset_str)
+
+            # Now figure out the date and time portion - split time.
+            date_formats = []
+            splitter = -1
+            if "," in string_date:
+                date_formats.append("%a, %d %b %Y")
+                splitter = string_date.rfind(" ")
+            else:
+                # ISO plus additional
+                date_formats.append("%Y-%m-%d")
+                date_formats.append("%Y.%m.%d")
+                date_formats.append("%m/%d/%Y")
+                date_formats.append("%d.%m.%Y")
+
+                splitter = string_date.rfind("T")
+                if splitter == -1:
+                    splitter = string_date.rfind(" ")
+                # END handle 'T' and ' '
+            # END handle RFC or ISO
+
+            assert splitter > -1
+
+            # Split date and time.
+            time_part = string_date[splitter + 1 :]  # Skip space.
+            date_part = string_date[:splitter]
+
+            # Parse time.
+            tstruct = time.strptime(time_part, "%H:%M:%S")
+
+            for fmt in date_formats:
+                try:
+                    dtstruct = time.strptime(date_part, fmt)
+                    utctime = calendar.timegm(
+                        (
+                            dtstruct.tm_year,
+                            dtstruct.tm_mon,
+                            dtstruct.tm_mday,
+                            tstruct.tm_hour,
+                            tstruct.tm_min,
+                            tstruct.tm_sec,
+                            dtstruct.tm_wday,
+                            dtstruct.tm_yday,
+                            tstruct.tm_isdst,
+                        )
+                    )
+                    return int(utctime), offset
+                except ValueError:
+                    continue
+                # END exception handling
+            # END for each fmt
+
+            # Still here ? fail.
+            raise ValueError("no format matched")
+        # END handle format
+    except Exception as e:
+        raise ValueError(f"Unsupported date format or type: {string_date}, type={type(string_date)}") from e
+    # END handle exceptions
+
+
+# Precompiled regexes
+_re_actor_epoch = re.compile(r"^.+? (.*) (\d+) ([+-]\d+).*$")
+_re_only_actor = re.compile(r"^.+? (.*)$")
+
+
+def parse_actor_and_date(line: str) -> Tuple[Actor, int, int]:
+    """Parse out the actor (author or committer) info from a line like::
+
+        author Tom Preston-Werner <tom@mojombo.com> 1191999972 -0700
+
+    :return:
+        [Actor, int_seconds_since_epoch, int_timezone_offset]
+    """
+    actor, epoch, offset = "", "0", "0"
+    m = _re_actor_epoch.search(line)
+    if m:
+        actor, epoch, offset = m.groups()
+    else:
+        m = _re_only_actor.search(line)
+        actor = m.group(1) if m else line or ""
+    return (Actor._from_string(actor), int(epoch), utctz_to_altz(offset))
+
+
+# } END functions
+
+
+# { Classes
+
+
+class ProcessStreamAdapter:
+    """Class wiring all calls to the contained Process instance.
+
+    Use this type to hide the underlying process to provide access only to a specified
+    stream. The process is usually wrapped into an :class:`~git.cmd.Git.AutoInterrupt`
+    class to kill it if the instance goes out of scope.
+    """
+
+    __slots__ = ("_proc", "_stream")
+
+    def __init__(self, process: "Popen", stream_name: str) -> None:
+        self._proc = process
+        self._stream: StringIO = getattr(process, stream_name)  # guessed type
+
+    def __getattr__(self, attr: str) -> Any:
+        return getattr(self._stream, attr)
+
+
+@runtime_checkable
+class Traversable(Protocol):
+    """Simple interface to perform depth-first or breadth-first traversals in one
+    direction.
+
+    Subclasses only need to implement one function.
+
+    Instances of the subclass must be hashable.
+
+    Defined subclasses:
+
+    * :class:`Commit <git.objects.Commit>`
+    * :class:`Tree <git.objects.tree.Tree>`
+    * :class:`Submodule <git.objects.submodule.base.Submodule>`
+    """
+
+    __slots__ = ()
+
+    @classmethod
+    @abstractmethod
+    def _get_intermediate_items(cls, item: Any) -> Sequence["Traversable"]:
+        """
+        :return:
+            Tuple of items connected to the given item.
+            Must be implemented in subclass.
+
+        class Commit::     (cls, Commit) -> Tuple[Commit, ...]
+        class Submodule::  (cls, Submodule) -> Iterablelist[Submodule]
+        class Tree::       (cls, Tree) -> Tuple[Tree, ...]
+        """
+        raise NotImplementedError("To be implemented in subclass")
+
+    @abstractmethod
+    def list_traverse(self, *args: Any, **kwargs: Any) -> Any:
+        """Traverse self and collect all items found.
+
+        Calling this directly on the abstract base class, including via a ``super()``
+        proxy, is deprecated. Only overridden implementations should be called.
+        """
+        warnings.warn(
+            "list_traverse() method should only be called from subclasses."
+            " Calling from Traversable abstract class will raise NotImplementedError in 4.0.0."
+            " The concrete subclasses in GitPython itself are 'Commit', 'RootModule', 'Submodule', and 'Tree'.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._list_traverse(*args, **kwargs)
+
+    def _list_traverse(
+        self, as_edge: bool = False, *args: Any, **kwargs: Any
+    ) -> IterableList[Union["Commit", "Submodule", "Tree", "Blob"]]:
+        """Traverse self and collect all items found.
+
+        :return:
+            :class:`~git.util.IterableList` with the results of the traversal as
+            produced by :meth:`traverse`::
+
+                Commit -> IterableList[Commit]
+                Submodule ->  IterableList[Submodule]
+                Tree -> IterableList[Union[Submodule, Tree, Blob]]
+        """
+        # Commit and Submodule have id.__attribute__ as IterableObj.
+        # Tree has id.__attribute__ inherited from IndexObject.
+        if isinstance(self, Has_id_attribute):
+            id = self._id_attribute_
+        else:
+            # Shouldn't reach here, unless Traversable subclass created with no
+            # _id_attribute_.
+            id = ""
+            # Could add _id_attribute_ to Traversable, or make all Traversable also
+            # Iterable?
+
+        if not as_edge:
+            out: IterableList[Union["Commit", "Submodule", "Tree", "Blob"]] = IterableList(id)
+            out.extend(self.traverse(as_edge=as_edge, *args, **kwargs))  # noqa: B026
+            return out
+            # Overloads in subclasses (mypy doesn't allow typing self: subclass).
+            # Union[IterableList['Commit'], IterableList['Submodule'], IterableList[Union['Submodule', 'Tree', 'Blob']]]
+        else:
+            # Raise DeprecationWarning, it doesn't make sense to use this.
+            out_list: IterableList = IterableList(self.traverse(*args, **kwargs))
+            return out_list
+
+    @abstractmethod
+    def traverse(self, *args: Any, **kwargs: Any) -> Any:
+        """Iterator yielding items found when traversing self.
+
+        Calling this directly on the abstract base class, including via a ``super()``
+        proxy, is deprecated. Only overridden implementations should be called.
+        """
+        warnings.warn(
+            "traverse() method should only be called from subclasses."
+            " Calling from Traversable abstract class will raise NotImplementedError in 4.0.0."
+            " The concrete subclasses in GitPython itself are 'Commit', 'RootModule', 'Submodule', and 'Tree'.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._traverse(*args, **kwargs)
+
+    def _traverse(
+        self,
+        predicate: Callable[[Union["Traversable", "Blob", TraversedTup], int], bool] = lambda i, d: True,
+        prune: Callable[[Union["Traversable", "Blob", TraversedTup], int], bool] = lambda i, d: False,
+        depth: int = -1,
+        branch_first: bool = True,
+        visit_once: bool = True,
+        ignore_self: int = 1,
+        as_edge: bool = False,
+    ) -> Union[Iterator[Union["Traversable", "Blob"]], Iterator[TraversedTup]]:
+        """Iterator yielding items found when traversing `self`.
+
+        :param predicate:
+            A function ``f(i,d)`` that returns ``False`` if item i at depth ``d`` should
+            not be included in the result.
+
+        :param prune:
+            A function ``f(i,d)`` that returns ``True`` if the search should stop at
+            item ``i`` at depth ``d``. Item ``i`` will not be returned.
+
+        :param depth:
+            Defines at which level the iteration should not go deeper if -1. There is no
+            limit if 0, you would effectively only get `self`, the root of the
+            iteration. If 1, you would only get the first level of
+            predecessors/successors.
+
+        :param branch_first:
+            If ``True``, items will be returned branch first, otherwise depth first.
+
+        :param visit_once:
+            If ``True``, items will only be returned once, although they might be
+            encountered several times. Loops are prevented that way.
+
+        :param ignore_self:
+            If ``True``, `self` will be ignored and automatically pruned from the
+            result. Otherwise it will be the first item to be returned. If `as_edge` is
+            ``True``, the source of the first edge is ``None``.
+
+        :param as_edge:
+            If ``True``, return a pair of items, first being the source, second the
+            destination, i.e. tuple(src, dest) with the edge spanning from source to
+            destination.
+
+        :return:
+            Iterator yielding items found when traversing `self`::
+
+                Commit -> Iterator[Union[Commit, Tuple[Commit, Commit]] Submodule ->
+                Iterator[Submodule, Tuple[Submodule, Submodule]] Tree ->
+                Iterator[Union[Blob, Tree, Submodule,
+                                        Tuple[Union[Submodule, Tree], Union[Blob, Tree,
+                                        Submodule]]]
+
+                ignore_self=True is_edge=True -> Iterator[item] ignore_self=True
+                is_edge=False --> Iterator[item] ignore_self=False is_edge=True ->
+                Iterator[item] | Iterator[Tuple[src, item]] ignore_self=False
+                is_edge=False -> Iterator[Tuple[src, item]]
+        """
+
+        visited = set()
+        stack: Deque[TraverseNT] = deque()
+        stack.append(TraverseNT(0, self, None))  # self is always depth level 0.
+
+        def addToStack(
+            stack: Deque[TraverseNT],
+            src_item: "Traversable",
+            branch_first: bool,
+            depth: int,
+        ) -> None:
+            lst = self._get_intermediate_items(item)
+            if not lst:  # Empty list
+                return
+            if branch_first:
+                stack.extendleft(TraverseNT(depth, i, src_item) for i in lst)
+            else:
+                reviter = (TraverseNT(depth, lst[i], src_item) for i in range(len(lst) - 1, -1, -1))
+                stack.extend(reviter)
+
+        # END addToStack local method
+
+        while stack:
+            d, item, src = stack.pop()  # Depth of item, item, item_source
+
+            if visit_once and item in visited:
+                continue
+
+            if visit_once:
+                visited.add(item)
+
+            rval: Union[TraversedTup, "Traversable", "Blob"]
+            if as_edge:
+                # If as_edge return (src, item) unless rrc is None
+                # (e.g. for first item).
+                rval = (src, item)
+            else:
+                rval = item
+
+            if prune(rval, d):
+                continue
+
+            skipStartItem = ignore_self and (item is self)
+            if not skipStartItem and predicate(rval, d):
+                yield rval
+
+            # Only continue to next level if this is appropriate!
+            nd = d + 1
+            if depth > -1 and nd > depth:
+                continue
+
+            addToStack(stack, item, branch_first, nd)
+        # END for each item on work stack
+
+
+@runtime_checkable
+class Serializable(Protocol):
+    """Defines methods to serialize and deserialize objects from and into a data
+    stream."""
+
+    __slots__ = ()
+
+    # @abstractmethod
+    def _serialize(self, stream: "BytesIO") -> "Serializable":
+        """Serialize the data of this object into the given data stream.
+
+        :note:
+            A serialized object would :meth:`_deserialize` into the same object.
+
+        :param stream:
+            A file-like object.
+
+        :return:
+            self
+        """
+        raise NotImplementedError("To be implemented in subclass")
+
+    # @abstractmethod
+    def _deserialize(self, stream: "BytesIO") -> "Serializable":
+        """Deserialize all information regarding this object from the stream.
+
+        :param stream:
+            A file-like object.
+
+        :return:
+            self
+        """
+        raise NotImplementedError("To be implemented in subclass")
+
+
+class TraversableIterableObj(IterableObj, Traversable):
+    __slots__ = ()
+
+    TIobj_tuple = Tuple[Union[T_TIobj, None], T_TIobj]
+
+    def list_traverse(self: T_TIobj, *args: Any, **kwargs: Any) -> IterableList[T_TIobj]:
+        return super()._list_traverse(*args, **kwargs)
+
+    @overload
+    def traverse(self: T_TIobj) -> Iterator[T_TIobj]: ...
+
+    @overload
+    def traverse(
+        self: T_TIobj,
+        predicate: Callable[[Union[T_TIobj, Tuple[Union[T_TIobj, None], T_TIobj]], int], bool],
+        prune: Callable[[Union[T_TIobj, Tuple[Union[T_TIobj, None], T_TIobj]], int], bool],
+        depth: int,
+        branch_first: bool,
+        visit_once: bool,
+        ignore_self: Literal[True],
+        as_edge: Literal[False],
+    ) -> Iterator[T_TIobj]: ...
+
+    @overload
+    def traverse(
+        self: T_TIobj,
+        predicate: Callable[[Union[T_TIobj, Tuple[Union[T_TIobj, None], T_TIobj]], int], bool],
+        prune: Callable[[Union[T_TIobj, Tuple[Union[T_TIobj, None], T_TIobj]], int], bool],
+        depth: int,
+        branch_first: bool,
+        visit_once: bool,
+        ignore_self: Literal[False],
+        as_edge: Literal[True],
+    ) -> Iterator[Tuple[Union[T_TIobj, None], T_TIobj]]: ...
+
+    @overload
+    def traverse(
+        self: T_TIobj,
+        predicate: Callable[[Union[T_TIobj, TIobj_tuple], int], bool],
+        prune: Callable[[Union[T_TIobj, TIobj_tuple], int], bool],
+        depth: int,
+        branch_first: bool,
+        visit_once: bool,
+        ignore_self: Literal[True],
+        as_edge: Literal[True],
+    ) -> Iterator[Tuple[T_TIobj, T_TIobj]]: ...
+
+    def traverse(
+        self: T_TIobj,
+        predicate: Callable[[Union[T_TIobj, TIobj_tuple], int], bool] = lambda i, d: True,
+        prune: Callable[[Union[T_TIobj, TIobj_tuple], int], bool] = lambda i, d: False,
+        depth: int = -1,
+        branch_first: bool = True,
+        visit_once: bool = True,
+        ignore_self: int = 1,
+        as_edge: bool = False,
+    ) -> Union[Iterator[T_TIobj], Iterator[Tuple[T_TIobj, T_TIobj]], Iterator[TIobj_tuple]]:
+        """For documentation, see :meth:`Traversable._traverse`."""
+
+        ## To typecheck instead of using cast:
+        #
+        # import itertools
+        # from git.types import TypeGuard
+        # def is_commit_traversed(inp: Tuple) -> TypeGuard[Tuple[Iterator[Tuple['Commit', 'Commit']]]]:
+        #     for x in inp[1]:
+        #         if not isinstance(x, tuple) and len(x) != 2:
+        #             if all(isinstance(inner, Commit) for inner in x):
+        #                 continue
+        #     return True
+        #
+        # ret = super(Commit, self).traverse(predicate, prune, depth, branch_first, visit_once, ignore_self, as_edge)
+        # ret_tup = itertools.tee(ret, 2)
+        # assert is_commit_traversed(ret_tup), f"{[type(x) for x in list(ret_tup[0])]}"
+        # return ret_tup[0]
+
+        return cast(
+            Union[Iterator[T_TIobj], Iterator[Tuple[Union[None, T_TIobj], T_TIobj]]],
+            super()._traverse(
+                predicate,  # type: ignore[arg-type]
+                prune,  # type: ignore[arg-type]
+                depth,
+                branch_first,
+                visit_once,
+                ignore_self,
+                as_edge,
+            ),
+        )
diff --git a/parrot/lib/python3.10/site-packages/git/refs/__init__.py b/parrot/lib/python3.10/site-packages/git/refs/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6157e6f37422c85b3f2c62479e68da888a8f598
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/refs/__init__.py
@@ -0,0 +1,21 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+__all__ = [
+    "HEAD",
+    "Head",
+    "RefLog",
+    "RefLogEntry",
+    "Reference",
+    "RemoteReference",
+    "SymbolicReference",
+    "Tag",
+    "TagReference",
+]
+
+from .head import HEAD, Head
+from .log import RefLog, RefLogEntry
+from .reference import Reference
+from .remote import RemoteReference
+from .symbolic import SymbolicReference
+from .tag import Tag, TagReference
diff --git a/parrot/lib/python3.10/site-packages/git/refs/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c685b73d319ab662231932674ddfcd0ab42308f
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/refs/__pycache__/head.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/head.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d3d1518e33dd5714d50a0265593d5ceb37447f59
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/head.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/refs/__pycache__/log.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/log.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6fecc5054f207ce0dc18d2f630acfc557c0334e5
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/log.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/refs/__pycache__/reference.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/reference.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b05332205f6e8b3b432e2e4f46a4f6b8405df38f
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/reference.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/refs/__pycache__/remote.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/remote.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e5353535f4921d627c44fd972a53432c6c93afa
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/remote.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/refs/__pycache__/symbolic.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/symbolic.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..364a05d7f62d964391dac36a04da4922341626c1
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/symbolic.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/refs/__pycache__/tag.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/tag.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..034e0afc3847505cc13fc19ab6c9d30b7d3d486c
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/refs/__pycache__/tag.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/refs/head.py b/parrot/lib/python3.10/site-packages/git/refs/head.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e6fc3377ac7d42906f80d0e91f0e8c4e7117838
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/refs/head.py
@@ -0,0 +1,304 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Some ref-based objects.
+
+Note the distinction between the :class:`HEAD` and :class:`Head` classes.
+"""
+
+__all__ = ["HEAD", "Head"]
+
+from git.config import GitConfigParser, SectionConstraint
+from git.exc import GitCommandError
+from git.util import join_path
+
+from .reference import Reference
+from .symbolic import SymbolicReference
+
+# typing ---------------------------------------------------
+
+from typing import Any, Sequence, TYPE_CHECKING, Union
+
+from git.types import Commit_ish, PathLike
+
+if TYPE_CHECKING:
+    from git.objects import Commit
+    from git.refs import RemoteReference
+    from git.repo import Repo
+
+# -------------------------------------------------------------------
+
+
+def strip_quotes(string: str) -> str:
+    if string.startswith('"') and string.endswith('"'):
+        return string[1:-1]
+    return string
+
+
+class HEAD(SymbolicReference):
+    """Special case of a :class:`~git.refs.symbolic.SymbolicReference` representing the
+    repository's HEAD reference."""
+
+    _HEAD_NAME = "HEAD"
+    _ORIG_HEAD_NAME = "ORIG_HEAD"
+
+    __slots__ = ()
+
+    # TODO: This can be removed once SymbolicReference.commit has static type hints.
+    commit: "Commit"
+
+    def __init__(self, repo: "Repo", path: PathLike = _HEAD_NAME) -> None:
+        if path != self._HEAD_NAME:
+            raise ValueError("HEAD instance must point to %r, got %r" % (self._HEAD_NAME, path))
+        super().__init__(repo, path)
+
+    def orig_head(self) -> SymbolicReference:
+        """
+        :return:
+            :class:`~git.refs.symbolic.SymbolicReference` pointing at the ORIG_HEAD,
+            which is maintained to contain the previous value of HEAD.
+        """
+        return SymbolicReference(self.repo, self._ORIG_HEAD_NAME)
+
+    def reset(
+        self,
+        commit: Union[Commit_ish, SymbolicReference, str] = "HEAD",
+        index: bool = True,
+        working_tree: bool = False,
+        paths: Union[PathLike, Sequence[PathLike], None] = None,
+        **kwargs: Any,
+    ) -> "HEAD":
+        """Reset our HEAD to the given commit optionally synchronizing the index and
+        working tree. The reference we refer to will be set to commit as well.
+
+        :param commit:
+            :class:`~git.objects.commit.Commit`, :class:`~git.refs.reference.Reference`,
+            or string identifying a revision we should reset HEAD to.
+
+        :param index:
+            If ``True``, the index will be set to match the given commit.
+            Otherwise it will not be touched.
+
+        :param working_tree:
+            If ``True``, the working tree will be forcefully adjusted to match the given
+            commit, possibly overwriting uncommitted changes without warning.
+            If `working_tree` is ``True``, `index` must be ``True`` as well.
+
+        :param paths:
+            Single path or list of paths relative to the git root directory
+            that are to be reset. This allows to partially reset individual files.
+
+        :param kwargs:
+            Additional arguments passed to :manpage:`git-reset(1)`.
+
+        :return:
+            self
+        """
+        mode: Union[str, None]
+        mode = "--soft"
+        if index:
+            mode = "--mixed"
+
+            # It appears some git versions declare mixed and paths deprecated.
+            # See http://github.com/Byron/GitPython/issues#issue/2.
+            if paths:
+                mode = None
+            # END special case
+        # END handle index
+
+        if working_tree:
+            mode = "--hard"
+            if not index:
+                raise ValueError("Cannot reset the working tree if the index is not reset as well")
+
+        # END working tree handling
+
+        try:
+            self.repo.git.reset(mode, commit, "--", paths, **kwargs)
+        except GitCommandError as e:
+            # git nowadays may use 1 as status to indicate there are still unstaged
+            # modifications after the reset.
+            if e.status != 1:
+                raise
+        # END handle exception
+
+        return self
+
+
+class Head(Reference):
+    """A Head is a named reference to a :class:`~git.objects.commit.Commit`. Every Head
+    instance contains a name and a :class:`~git.objects.commit.Commit` object.
+
+    Examples::
+
+        >>> repo = Repo("/path/to/repo")
+        >>> head = repo.heads[0]
+
+        >>> head.name
+        'master'
+
+        >>> head.commit
+        <git.Commit "1c09f116cbc2cb4100fb6935bb162daa4723f455">
+
+        >>> head.commit.hexsha
+        '1c09f116cbc2cb4100fb6935bb162daa4723f455'
+    """
+
+    _common_path_default = "refs/heads"
+    k_config_remote = "remote"
+    k_config_remote_ref = "merge"  # Branch to merge from remote.
+
+    @classmethod
+    def delete(cls, repo: "Repo", *heads: "Union[Head, str]", force: bool = False, **kwargs: Any) -> None:
+        """Delete the given heads.
+
+        :param force:
+            If ``True``, the heads will be deleted even if they are not yet merged into
+            the main development stream. Default ``False``.
+        """
+        flag = "-d"
+        if force:
+            flag = "-D"
+        repo.git.branch(flag, *heads)
+
+    def set_tracking_branch(self, remote_reference: Union["RemoteReference", None]) -> "Head":
+        """Configure this branch to track the given remote reference. This will
+        alter this branch's configuration accordingly.
+
+        :param remote_reference:
+            The remote reference to track or None to untrack any references.
+
+        :return:
+            self
+        """
+        from .remote import RemoteReference
+
+        if remote_reference is not None and not isinstance(remote_reference, RemoteReference):
+            raise ValueError("Incorrect parameter type: %r" % remote_reference)
+        # END handle type
+
+        with self.config_writer() as writer:
+            if remote_reference is None:
+                writer.remove_option(self.k_config_remote)
+                writer.remove_option(self.k_config_remote_ref)
+                if len(writer.options()) == 0:
+                    writer.remove_section()
+            else:
+                writer.set_value(self.k_config_remote, remote_reference.remote_name)
+                writer.set_value(
+                    self.k_config_remote_ref,
+                    Head.to_full_path(remote_reference.remote_head),
+                )
+
+        return self
+
+    def tracking_branch(self) -> Union["RemoteReference", None]:
+        """
+        :return:
+            The remote reference we are tracking, or ``None`` if we are not a tracking
+            branch.
+        """
+        from .remote import RemoteReference
+
+        reader = self.config_reader()
+        if reader.has_option(self.k_config_remote) and reader.has_option(self.k_config_remote_ref):
+            ref = Head(
+                self.repo,
+                Head.to_full_path(strip_quotes(reader.get_value(self.k_config_remote_ref))),
+            )
+            remote_refpath = RemoteReference.to_full_path(join_path(reader.get_value(self.k_config_remote), ref.name))
+            return RemoteReference(self.repo, remote_refpath)
+        # END handle have tracking branch
+
+        # We are not a tracking branch.
+        return None
+
+    def rename(self, new_path: PathLike, force: bool = False) -> "Head":
+        """Rename self to a new path.
+
+        :param new_path:
+            Either a simple name or a path, e.g. ``new_name`` or ``features/new_name``.
+            The prefix ``refs/heads`` is implied.
+
+        :param force:
+            If ``True``, the rename will succeed even if a head with the target name
+            already exists.
+
+        :return:
+            self
+
+        :note:
+            Respects the ref log, as git commands are used.
+        """
+        flag = "-m"
+        if force:
+            flag = "-M"
+
+        self.repo.git.branch(flag, self, new_path)
+        self.path = "%s/%s" % (self._common_path_default, new_path)
+        return self
+
+    def checkout(self, force: bool = False, **kwargs: Any) -> Union["HEAD", "Head"]:
+        """Check out this head by setting the HEAD to this reference, by updating the
+        index to reflect the tree we point to and by updating the working tree to
+        reflect the latest index.
+
+        The command will fail if changed working tree files would be overwritten.
+
+        :param force:
+            If ``True``, changes to the index and the working tree will be discarded.
+            If ``False``, :exc:`~git.exc.GitCommandError` will be raised in that
+            situation.
+
+        :param kwargs:
+            Additional keyword arguments to be passed to git checkout, e.g.
+            ``b="new_branch"`` to create a new branch at the given spot.
+
+        :return:
+            The active branch after the checkout operation, usually self unless a new
+            branch has been created.
+            If there is no active branch, as the HEAD is now detached, the HEAD
+            reference will be returned instead.
+
+        :note:
+            By default it is only allowed to checkout heads - everything else will leave
+            the HEAD detached which is allowed and possible, but remains a special state
+            that some tools might not be able to handle.
+        """
+        kwargs["f"] = force
+        if kwargs["f"] is False:
+            kwargs.pop("f")
+
+        self.repo.git.checkout(self, **kwargs)
+        if self.repo.head.is_detached:
+            return self.repo.head
+        else:
+            return self.repo.active_branch
+
+    # { Configuration
+    def _config_parser(self, read_only: bool) -> SectionConstraint[GitConfigParser]:
+        if read_only:
+            parser = self.repo.config_reader()
+        else:
+            parser = self.repo.config_writer()
+        # END handle parser instance
+
+        return SectionConstraint(parser, 'branch "%s"' % self.name)
+
+    def config_reader(self) -> SectionConstraint[GitConfigParser]:
+        """
+        :return:
+            A configuration parser instance constrained to only read this instance's
+            values.
+        """
+        return self._config_parser(read_only=True)
+
+    def config_writer(self) -> SectionConstraint[GitConfigParser]:
+        """
+        :return:
+            A configuration writer instance with read-and write access to options of
+            this head.
+        """
+        return self._config_parser(read_only=False)
+
+    # } END configuration
diff --git a/parrot/lib/python3.10/site-packages/git/refs/log.py b/parrot/lib/python3.10/site-packages/git/refs/log.py
new file mode 100644
index 0000000000000000000000000000000000000000..17e3a94b3087b3e82e1be371a7c1d08d7c937040
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/refs/log.py
@@ -0,0 +1,399 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+__all__ = ["RefLog", "RefLogEntry"]
+
+from mmap import mmap
+import os.path as osp
+import re
+import time as _time
+
+from git.compat import defenc
+from git.objects.util import (
+    Serializable,
+    altz_to_utctz_str,
+    parse_date,
+)
+from git.util import (
+    Actor,
+    LockedFD,
+    LockFile,
+    assure_directory_exists,
+    bin_to_hex,
+    file_contents_ro_filepath,
+    to_native_path,
+)
+
+# typing ------------------------------------------------------------------
+
+from typing import Iterator, List, Tuple, TYPE_CHECKING, Union
+
+from git.types import PathLike
+
+if TYPE_CHECKING:
+    from io import BytesIO
+
+    from git.config import GitConfigParser, SectionConstraint
+    from git.refs import SymbolicReference
+
+# ------------------------------------------------------------------------------
+
+
+class RefLogEntry(Tuple[str, str, Actor, Tuple[int, int], str]):
+    """Named tuple allowing easy access to the revlog data fields."""
+
+    _re_hexsha_only = re.compile(r"^[0-9A-Fa-f]{40}$")
+
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        """Representation of ourselves in git reflog format."""
+        return self.format()
+
+    def format(self) -> str:
+        """:return: A string suitable to be placed in a reflog file."""
+        act = self.actor
+        time = self.time
+        return "{} {} {} <{}> {!s} {}\t{}\n".format(
+            self.oldhexsha,
+            self.newhexsha,
+            act.name,
+            act.email,
+            time[0],
+            altz_to_utctz_str(time[1]),
+            self.message,
+        )
+
+    @property
+    def oldhexsha(self) -> str:
+        """The hexsha to the commit the ref pointed to before the change."""
+        return self[0]
+
+    @property
+    def newhexsha(self) -> str:
+        """The hexsha to the commit the ref now points to, after the change."""
+        return self[1]
+
+    @property
+    def actor(self) -> Actor:
+        """Actor instance, providing access."""
+        return self[2]
+
+    @property
+    def time(self) -> Tuple[int, int]:
+        """Time as tuple:
+
+        * [0] = ``int(time)``
+        * [1] = ``int(timezone_offset)`` in :attr:`time.altzone` format
+        """
+        return self[3]
+
+    @property
+    def message(self) -> str:
+        """Message describing the operation that acted on the reference."""
+        return self[4]
+
+    @classmethod
+    def new(
+        cls,
+        oldhexsha: str,
+        newhexsha: str,
+        actor: Actor,
+        time: int,
+        tz_offset: int,
+        message: str,
+    ) -> "RefLogEntry":  # skipcq: PYL-W0621
+        """:return: New instance of a :class:`RefLogEntry`"""
+        if not isinstance(actor, Actor):
+            raise ValueError("Need actor instance, got %s" % actor)
+        # END check types
+        return RefLogEntry((oldhexsha, newhexsha, actor, (time, tz_offset), message))
+
+    @classmethod
+    def from_line(cls, line: bytes) -> "RefLogEntry":
+        """:return: New :class:`RefLogEntry` instance from the given revlog line.
+
+        :param line:
+            Line bytes without trailing newline
+
+        :raise ValueError:
+            If `line` could not be parsed.
+        """
+        line_str = line.decode(defenc)
+        fields = line_str.split("\t", 1)
+        if len(fields) == 1:
+            info, msg = fields[0], None
+        elif len(fields) == 2:
+            info, msg = fields
+        else:
+            raise ValueError("Line must have up to two TAB-separated fields." " Got %s" % repr(line_str))
+        # END handle first split
+
+        oldhexsha = info[:40]
+        newhexsha = info[41:81]
+        for hexsha in (oldhexsha, newhexsha):
+            if not cls._re_hexsha_only.match(hexsha):
+                raise ValueError("Invalid hexsha: %r" % (hexsha,))
+            # END if hexsha re doesn't match
+        # END for each hexsha
+
+        email_end = info.find(">", 82)
+        if email_end == -1:
+            raise ValueError("Missing token: >")
+        # END handle missing end brace
+
+        actor = Actor._from_string(info[82 : email_end + 1])
+        time, tz_offset = parse_date(info[email_end + 2 :])  # skipcq: PYL-W0621
+
+        return RefLogEntry((oldhexsha, newhexsha, actor, (time, tz_offset), msg))
+
+
+class RefLog(List[RefLogEntry], Serializable):
+    R"""A reflog contains :class:`RefLogEntry`\s, each of which defines a certain state
+    of the head in question. Custom query methods allow to retrieve log entries by date
+    or by other criteria.
+
+    Reflog entries are ordered. The first added entry is first in the list. The last
+    entry, i.e. the last change of the head or reference, is last in the list.
+    """
+
+    __slots__ = ("_path",)
+
+    def __new__(cls, filepath: Union[PathLike, None] = None) -> "RefLog":
+        inst = super().__new__(cls)
+        return inst
+
+    def __init__(self, filepath: Union[PathLike, None] = None) -> None:
+        """Initialize this instance with an optional filepath, from which we will
+        initialize our data. The path is also used to write changes back using the
+        :meth:`write` method."""
+        self._path = filepath
+        if filepath is not None:
+            self._read_from_file()
+        # END handle filepath
+
+    def _read_from_file(self) -> None:
+        try:
+            fmap = file_contents_ro_filepath(self._path, stream=True, allow_mmap=True)
+        except OSError:
+            # It is possible and allowed that the file doesn't exist!
+            return
+        # END handle invalid log
+
+        try:
+            self._deserialize(fmap)
+        finally:
+            fmap.close()
+        # END handle closing of handle
+
+    # { Interface
+
+    @classmethod
+    def from_file(cls, filepath: PathLike) -> "RefLog":
+        """
+        :return:
+            A new :class:`RefLog` instance containing all entries from the reflog at the
+            given `filepath`.
+
+        :param filepath:
+            Path to reflog.
+
+        :raise ValueError:
+            If the file could not be read or was corrupted in some way.
+        """
+        return cls(filepath)
+
+    @classmethod
+    def path(cls, ref: "SymbolicReference") -> str:
+        """
+        :return:
+            String to absolute path at which the reflog of the given ref instance would
+            be found. The path is not guaranteed to point to a valid file though.
+
+        :param ref:
+            :class:`~git.refs.symbolic.SymbolicReference` instance
+        """
+        return osp.join(ref.repo.git_dir, "logs", to_native_path(ref.path))
+
+    @classmethod
+    def iter_entries(cls, stream: Union[str, "BytesIO", mmap]) -> Iterator[RefLogEntry]:
+        """
+        :return:
+            Iterator yielding :class:`RefLogEntry` instances, one for each line read
+            from the given stream.
+
+        :param stream:
+            File-like object containing the revlog in its native format or string
+            instance pointing to a file to read.
+        """
+        new_entry = RefLogEntry.from_line
+        if isinstance(stream, str):
+            # Default args return mmap since Python 3.
+            _stream = file_contents_ro_filepath(stream)
+            assert isinstance(_stream, mmap)
+        else:
+            _stream = stream
+        # END handle stream type
+        while True:
+            line = _stream.readline()
+            if not line:
+                return
+            yield new_entry(line.strip())
+        # END endless loop
+
+    @classmethod
+    def entry_at(cls, filepath: PathLike, index: int) -> "RefLogEntry":
+        """
+        :return:
+            :class:`RefLogEntry` at the given index.
+
+        :param filepath:
+            Full path to the index file from which to read the entry.
+
+        :param index:
+            Python list compatible index, i.e. it may be negative to specify an entry
+            counted from the end of the list.
+
+        :raise IndexError:
+            If the entry didn't exist.
+
+        :note:
+            This method is faster as it only parses the entry at index, skipping all
+            other lines. Nonetheless, the whole file has to be read if the index is
+            negative.
+        """
+        with open(filepath, "rb") as fp:
+            if index < 0:
+                return RefLogEntry.from_line(fp.readlines()[index].strip())
+            # Read until index is reached.
+
+            for i in range(index + 1):
+                line = fp.readline()
+                if not line:
+                    raise IndexError(f"Index file ended at line {i + 1}, before given index was reached")
+                # END abort on eof
+            # END handle runup
+
+            return RefLogEntry.from_line(line.strip())
+        # END handle index
+
+    def to_file(self, filepath: PathLike) -> None:
+        """Write the contents of the reflog instance to a file at the given filepath.
+
+        :param filepath:
+            Path to file. Parent directories are assumed to exist.
+        """
+        lfd = LockedFD(filepath)
+        assure_directory_exists(filepath, is_file=True)
+
+        fp = lfd.open(write=True, stream=True)
+        try:
+            self._serialize(fp)
+            lfd.commit()
+        except BaseException:
+            lfd.rollback()
+            raise
+        # END handle change
+
+    @classmethod
+    def append_entry(
+        cls,
+        config_reader: Union[Actor, "GitConfigParser", "SectionConstraint", None],
+        filepath: PathLike,
+        oldbinsha: bytes,
+        newbinsha: bytes,
+        message: str,
+        write: bool = True,
+    ) -> "RefLogEntry":
+        """Append a new log entry to the revlog at filepath.
+
+        :param config_reader:
+            Configuration reader of the repository - used to obtain user information.
+            May also be an :class:`~git.util.Actor` instance identifying the committer
+            directly or ``None``.
+
+        :param filepath:
+            Full path to the log file.
+
+        :param oldbinsha:
+            Binary sha of the previous commit.
+
+        :param newbinsha:
+            Binary sha of the current commit.
+
+        :param message:
+            Message describing the change to the reference.
+
+        :param write:
+            If ``True``, the changes will be written right away.
+            Otherwise the change will not be written.
+
+        :return:
+            :class:`RefLogEntry` objects which was appended to the log.
+
+        :note:
+            As we are append-only, concurrent access is not a problem as we do not
+            interfere with readers.
+        """
+
+        if len(oldbinsha) != 20 or len(newbinsha) != 20:
+            raise ValueError("Shas need to be given in binary format")
+        # END handle sha type
+        assure_directory_exists(filepath, is_file=True)
+        first_line = message.split("\n")[0]
+        if isinstance(config_reader, Actor):
+            committer = config_reader  # mypy thinks this is Actor | Gitconfigparser, but why?
+        else:
+            committer = Actor.committer(config_reader)
+        entry = RefLogEntry(
+            (
+                bin_to_hex(oldbinsha).decode("ascii"),
+                bin_to_hex(newbinsha).decode("ascii"),
+                committer,
+                (int(_time.time()), _time.altzone),
+                first_line,
+            )
+        )
+
+        if write:
+            lf = LockFile(filepath)
+            lf._obtain_lock_or_raise()
+            fd = open(filepath, "ab")
+            try:
+                fd.write(entry.format().encode(defenc))
+            finally:
+                fd.close()
+                lf._release_lock()
+            # END handle write operation
+        return entry
+
+    def write(self) -> "RefLog":
+        """Write this instance's data to the file we are originating from.
+
+        :return:
+            self
+        """
+        if self._path is None:
+            raise ValueError("Instance was not initialized with a path, use to_file(...) instead")
+        # END assert path
+        self.to_file(self._path)
+        return self
+
+    # } END interface
+
+    # { Serializable Interface
+
+    def _serialize(self, stream: "BytesIO") -> "RefLog":
+        write = stream.write
+
+        # Write all entries.
+        for e in self:
+            write(e.format().encode(defenc))
+        # END for each entry
+        return self
+
+    def _deserialize(self, stream: "BytesIO") -> "RefLog":
+        self.extend(self.iter_entries(stream))
+        return self
+
+    # } END serializable interface
diff --git a/parrot/lib/python3.10/site-packages/git/refs/reference.py b/parrot/lib/python3.10/site-packages/git/refs/reference.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5d473779165482ef8ca920edad1174d29060ce8
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/refs/reference.py
@@ -0,0 +1,176 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+__all__ = ["Reference"]
+
+from git.util import IterableObj, LazyMixin
+
+from .symbolic import SymbolicReference, T_References
+
+# typing ------------------------------------------------------------------
+
+from typing import Any, Callable, Iterator, TYPE_CHECKING, Type, Union
+
+from git.types import AnyGitObject, PathLike, _T
+
+if TYPE_CHECKING:
+    from git.repo import Repo
+
+# ------------------------------------------------------------------------------
+
+# { Utilities
+
+
+def require_remote_ref_path(func: Callable[..., _T]) -> Callable[..., _T]:
+    """A decorator raising :exc:`ValueError` if we are not a valid remote, based on the
+    path."""
+
+    def wrapper(self: T_References, *args: Any) -> _T:
+        if not self.is_remote():
+            raise ValueError("ref path does not point to a remote reference: %s" % self.path)
+        return func(self, *args)
+
+    # END wrapper
+    wrapper.__name__ = func.__name__
+    return wrapper
+
+
+# } END utilities
+
+
+class Reference(SymbolicReference, LazyMixin, IterableObj):
+    """A named reference to any object.
+
+    Subclasses may apply restrictions though, e.g., a :class:`~git.refs.head.Head` can
+    only point to commits.
+    """
+
+    __slots__ = ()
+
+    _points_to_commits_only = False
+    _resolve_ref_on_create = True
+    _common_path_default = "refs"
+
+    def __init__(self, repo: "Repo", path: PathLike, check_path: bool = True) -> None:
+        """Initialize this instance.
+
+        :param repo:
+            Our parent repository.
+
+        :param path:
+            Path relative to the ``.git/`` directory pointing to the ref in question,
+            e.g. ``refs/heads/master``.
+
+        :param check_path:
+            If ``False``, you can provide any path.
+            Otherwise the path must start with the default path prefix of this type.
+        """
+        if check_path and not str(path).startswith(self._common_path_default + "/"):
+            raise ValueError(f"Cannot instantiate {self.__class__.__name__!r} from path {path}")
+        self.path: str  # SymbolicReference converts to string at the moment.
+        super().__init__(repo, path)
+
+    def __str__(self) -> str:
+        return self.name
+
+    # { Interface
+
+    # @ReservedAssignment
+    def set_object(
+        self,
+        object: Union[AnyGitObject, "SymbolicReference", str],
+        logmsg: Union[str, None] = None,
+    ) -> "Reference":
+        """Special version which checks if the head-log needs an update as well.
+
+        :return:
+            self
+        """
+        oldbinsha = None
+        if logmsg is not None:
+            head = self.repo.head
+            if not head.is_detached and head.ref == self:
+                oldbinsha = self.commit.binsha
+            # END handle commit retrieval
+        # END handle message is set
+
+        super().set_object(object, logmsg)
+
+        if oldbinsha is not None:
+            # From refs/files-backend.c in git-source:
+            # /*
+            #  * Special hack: If a branch is updated directly and HEAD
+            #  * points to it (may happen on the remote side of a push
+            #  * for example) then logically the HEAD reflog should be
+            #  * updated too.
+            #  * A generic solution implies reverse symref information,
+            #  * but finding all symrefs pointing to the given branch
+            #  * would be rather costly for this rare event (the direct
+            #  * update of a branch) to be worth it.  So let's cheat and
+            #  * check with HEAD only which should cover 99% of all usage
+            #  * scenarios (even 100% of the default ones).
+            #  */
+            self.repo.head.log_append(oldbinsha, logmsg)
+        # END check if the head
+
+        return self
+
+    # NOTE: No need to overwrite properties, as the will only work without a the log.
+
+    @property
+    def name(self) -> str:
+        """
+        :return:
+            (shortest) Name of this reference - it may contain path components
+        """
+        # The first two path tokens can be removed as they are
+        # refs/heads or refs/tags or refs/remotes.
+        tokens = self.path.split("/")
+        if len(tokens) < 3:
+            return self.path  # could be refs/HEAD
+        return "/".join(tokens[2:])
+
+    @classmethod
+    def iter_items(
+        cls: Type[T_References],
+        repo: "Repo",
+        common_path: Union[PathLike, None] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Iterator[T_References]:
+        """Equivalent to
+        :meth:`SymbolicReference.iter_items <git.refs.symbolic.SymbolicReference.iter_items>`,
+        but will return non-detached references as well."""
+        return cls._iter_items(repo, common_path)
+
+    # } END interface
+
+    # { Remote Interface
+
+    @property
+    @require_remote_ref_path
+    def remote_name(self) -> str:
+        """
+        :return:
+            Name of the remote we are a reference of, such as ``origin`` for a reference
+            named ``origin/master``.
+        """
+        tokens = self.path.split("/")
+        # /refs/remotes/<remote name>/<branch_name>
+        return tokens[2]
+
+    @property
+    @require_remote_ref_path
+    def remote_head(self) -> str:
+        """
+        :return:
+            Name of the remote head itself, e.g. ``master``.
+
+        :note:
+            The returned name is usually not qualified enough to uniquely identify a
+            branch.
+        """
+        tokens = self.path.split("/")
+        return "/".join(tokens[3:])
+
+    # } END remote interface
diff --git a/parrot/lib/python3.10/site-packages/git/refs/remote.py b/parrot/lib/python3.10/site-packages/git/refs/remote.py
new file mode 100644
index 0000000000000000000000000000000000000000..b4f4f7b366282695cf2676de246758edd631b1ca
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/refs/remote.py
@@ -0,0 +1,79 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Module implementing a remote object allowing easy access to git remotes."""
+
+__all__ = ["RemoteReference"]
+
+import os
+
+from git.util import join_path
+
+from .head import Head
+
+# typing ------------------------------------------------------------------
+
+from typing import Any, Iterator, NoReturn, TYPE_CHECKING, Union
+
+from git.types import PathLike
+
+if TYPE_CHECKING:
+    from git.remote import Remote
+    from git.repo import Repo
+
+# ------------------------------------------------------------------------------
+
+
+class RemoteReference(Head):
+    """A reference pointing to a remote head."""
+
+    _common_path_default = Head._remote_common_path_default
+
+    @classmethod
+    def iter_items(
+        cls,
+        repo: "Repo",
+        common_path: Union[PathLike, None] = None,
+        remote: Union["Remote", None] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Iterator["RemoteReference"]:
+        """Iterate remote references, and if given, constrain them to the given remote."""
+        common_path = common_path or cls._common_path_default
+        if remote is not None:
+            common_path = join_path(common_path, str(remote))
+        # END handle remote constraint
+        # super is Reference
+        return super().iter_items(repo, common_path)
+
+    # The Head implementation of delete also accepts strs, but this implementation does
+    # not. mypy doesn't have a way of representing tightening the types of arguments in
+    # subclasses and recommends Any or "type: ignore".
+    # (See: https://github.com/python/typing/issues/241)
+    @classmethod
+    def delete(cls, repo: "Repo", *refs: "RemoteReference", **kwargs: Any) -> None:  # type: ignore[override]
+        """Delete the given remote references.
+
+        :note:
+            `kwargs` are given for comparability with the base class method as we
+            should not narrow the signature.
+        """
+        repo.git.branch("-d", "-r", *refs)
+        # The official deletion method will ignore remote symbolic refs - these are
+        # generally ignored in the refs/ folder. We don't though and delete remainders
+        # manually.
+        for ref in refs:
+            try:
+                os.remove(os.path.join(repo.common_dir, ref.path))
+            except OSError:
+                pass
+            try:
+                os.remove(os.path.join(repo.git_dir, ref.path))
+            except OSError:
+                pass
+        # END for each ref
+
+    @classmethod
+    def create(cls, *args: Any, **kwargs: Any) -> NoReturn:
+        """Raise :exc:`TypeError`. Defined so the ``create`` method is disabled."""
+        raise TypeError("Cannot explicitly create remote references")
diff --git a/parrot/lib/python3.10/site-packages/git/refs/symbolic.py b/parrot/lib/python3.10/site-packages/git/refs/symbolic.py
new file mode 100644
index 0000000000000000000000000000000000000000..510850b2e62f96fefa1782cf5e9637d7d6abd0f2
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/refs/symbolic.py
@@ -0,0 +1,926 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+__all__ = ["SymbolicReference"]
+
+import os
+
+from gitdb.exc import BadName, BadObject
+
+from git.compat import defenc
+from git.objects.base import Object
+from git.objects.commit import Commit
+from git.refs.log import RefLog
+from git.util import (
+    LockedFD,
+    assure_directory_exists,
+    hex_to_bin,
+    join_path,
+    join_path_native,
+    to_native_path_linux,
+)
+
+# typing ------------------------------------------------------------------
+
+from typing import (
+    Any,
+    Iterator,
+    List,
+    TYPE_CHECKING,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from git.types import AnyGitObject, PathLike
+
+if TYPE_CHECKING:
+    from git.config import GitConfigParser
+    from git.objects.commit import Actor
+    from git.refs import Head, TagReference, RemoteReference, Reference
+    from git.refs.log import RefLogEntry
+    from git.repo import Repo
+
+
+T_References = TypeVar("T_References", bound="SymbolicReference")
+
+# ------------------------------------------------------------------------------
+
+
+def _git_dir(repo: "Repo", path: Union[PathLike, None]) -> PathLike:
+    """Find the git dir that is appropriate for the path."""
+    name = f"{path}"
+    if name in ["HEAD", "ORIG_HEAD", "FETCH_HEAD", "index", "logs"]:
+        return repo.git_dir
+    return repo.common_dir
+
+
+class SymbolicReference:
+    """Special case of a reference that is symbolic.
+
+    This does not point to a specific commit, but to another
+    :class:`~git.refs.head.Head`, which itself specifies a commit.
+
+    A typical example for a symbolic reference is :class:`~git.refs.head.HEAD`.
+    """
+
+    __slots__ = ("repo", "path")
+
+    _resolve_ref_on_create = False
+    _points_to_commits_only = True
+    _common_path_default = ""
+    _remote_common_path_default = "refs/remotes"
+    _id_attribute_ = "name"
+
+    def __init__(self, repo: "Repo", path: PathLike, check_path: bool = False) -> None:
+        self.repo = repo
+        self.path = path
+
+    def __str__(self) -> str:
+        return str(self.path)
+
+    def __repr__(self) -> str:
+        return '<git.%s "%s">' % (self.__class__.__name__, self.path)
+
+    def __eq__(self, other: object) -> bool:
+        if hasattr(other, "path"):
+            other = cast(SymbolicReference, other)
+            return self.path == other.path
+        return False
+
+    def __ne__(self, other: object) -> bool:
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash(self.path)
+
+    @property
+    def name(self) -> str:
+        """
+        :return:
+            In case of symbolic references, the shortest assumable name is the path
+            itself.
+        """
+        return str(self.path)
+
+    @property
+    def abspath(self) -> PathLike:
+        return join_path_native(_git_dir(self.repo, self.path), self.path)
+
+    @classmethod
+    def _get_packed_refs_path(cls, repo: "Repo") -> str:
+        return os.path.join(repo.common_dir, "packed-refs")
+
+    @classmethod
+    def _iter_packed_refs(cls, repo: "Repo") -> Iterator[Tuple[str, str]]:
+        """Return an iterator yielding pairs of sha1/path pairs (as strings) for the
+        corresponding refs.
+
+        :note:
+            The packed refs file will be kept open as long as we iterate.
+        """
+        try:
+            with open(cls._get_packed_refs_path(repo), "rt", encoding="UTF-8") as fp:
+                for line in fp:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    if line.startswith("#"):
+                        # "# pack-refs with: peeled fully-peeled sorted"
+                        # the git source code shows "peeled",
+                        # "fully-peeled" and "sorted" as the keywords
+                        # that can go on this line, as per comments in git file
+                        # refs/packed-backend.c
+                        # I looked at master on 2017-10-11,
+                        # commit 111ef79afe, after tag v2.15.0-rc1
+                        # from repo https://github.com/git/git.git
+                        if line.startswith("# pack-refs with:") and "peeled" not in line:
+                            raise TypeError("PackingType of packed-Refs not understood: %r" % line)
+                        # END abort if we do not understand the packing scheme
+                        continue
+                    # END parse comment
+
+                    # Skip dereferenced tag object entries - previous line was actual
+                    # tag reference for it.
+                    if line[0] == "^":
+                        continue
+
+                    yield cast(Tuple[str, str], tuple(line.split(" ", 1)))
+                # END for each line
+        except OSError:
+            return None
+        # END no packed-refs file handling
+
+    @classmethod
+    def dereference_recursive(cls, repo: "Repo", ref_path: Union[PathLike, None]) -> str:
+        """
+        :return:
+            hexsha stored in the reference at the given `ref_path`, recursively
+            dereferencing all intermediate references as required
+
+        :param repo:
+            The repository containing the reference at `ref_path`.
+        """
+
+        while True:
+            hexsha, ref_path = cls._get_ref_info(repo, ref_path)
+            if hexsha is not None:
+                return hexsha
+        # END recursive dereferencing
+
+    @staticmethod
+    def _check_ref_name_valid(ref_path: PathLike) -> None:
+        """Check a ref name for validity.
+
+        This is based on the rules described in :manpage:`git-check-ref-format(1)`.
+        """
+        previous: Union[str, None] = None
+        one_before_previous: Union[str, None] = None
+        for c in str(ref_path):
+            if c in " ~^:?*[\\":
+                raise ValueError(
+                    f"Invalid reference '{ref_path}': references cannot contain spaces, tildes (~), carets (^),"
+                    f" colons (:), question marks (?), asterisks (*), open brackets ([) or backslashes (\\)"
+                )
+            elif c == ".":
+                if previous is None or previous == "/":
+                    raise ValueError(
+                        f"Invalid reference '{ref_path}': references cannot start with a period (.) or contain '/.'"
+                    )
+                elif previous == ".":
+                    raise ValueError(f"Invalid reference '{ref_path}': references cannot contain '..'")
+            elif c == "/":
+                if previous == "/":
+                    raise ValueError(f"Invalid reference '{ref_path}': references cannot contain '//'")
+                elif previous is None:
+                    raise ValueError(
+                        f"Invalid reference '{ref_path}': references cannot start with forward slashes '/'"
+                    )
+            elif c == "{" and previous == "@":
+                raise ValueError(f"Invalid reference '{ref_path}': references cannot contain '@{{'")
+            elif ord(c) < 32 or ord(c) == 127:
+                raise ValueError(f"Invalid reference '{ref_path}': references cannot contain ASCII control characters")
+
+            one_before_previous = previous
+            previous = c
+
+        if previous == ".":
+            raise ValueError(f"Invalid reference '{ref_path}': references cannot end with a period (.)")
+        elif previous == "/":
+            raise ValueError(f"Invalid reference '{ref_path}': references cannot end with a forward slash (/)")
+        elif previous == "@" and one_before_previous is None:
+            raise ValueError(f"Invalid reference '{ref_path}': references cannot be '@'")
+        elif any(component.endswith(".lock") for component in str(ref_path).split("/")):
+            raise ValueError(
+                f"Invalid reference '{ref_path}': references cannot have slash-separated components that end with"
+                " '.lock'"
+            )
+
+    @classmethod
+    def _get_ref_info_helper(
+        cls, repo: "Repo", ref_path: Union[PathLike, None]
+    ) -> Union[Tuple[str, None], Tuple[None, str]]:
+        """
+        :return:
+            *(str(sha), str(target_ref_path))*, where:
+
+            * *sha* is of the file at rela_path points to if available, or ``None``.
+            * *target_ref_path* is the reference we point to, or ``None``.
+        """
+        if ref_path:
+            cls._check_ref_name_valid(ref_path)
+
+        tokens: Union[None, List[str], Tuple[str, str]] = None
+        repodir = _git_dir(repo, ref_path)
+        try:
+            with open(os.path.join(repodir, str(ref_path)), "rt", encoding="UTF-8") as fp:
+                value = fp.read().rstrip()
+            # Don't only split on spaces, but on whitespace, which allows to parse lines like:
+            # 60b64ef992065e2600bfef6187a97f92398a9144                branch 'master' of git-server:/path/to/repo
+            tokens = value.split()
+            assert len(tokens) != 0
+        except OSError:
+            # Probably we are just packed. Find our entry in the packed refs file.
+            # NOTE: We are not a symbolic ref if we are in a packed file, as these
+            # are excluded explicitly.
+            for sha, path in cls._iter_packed_refs(repo):
+                if path != ref_path:
+                    continue
+                # sha will be used.
+                tokens = sha, path
+                break
+            # END for each packed ref
+        # END handle packed refs
+        if tokens is None:
+            raise ValueError("Reference at %r does not exist" % ref_path)
+
+        # Is it a reference?
+        if tokens[0] == "ref:":
+            return (None, tokens[1])
+
+        # It's a commit.
+        if repo.re_hexsha_only.match(tokens[0]):
+            return (tokens[0], None)
+
+        raise ValueError("Failed to parse reference information from %r" % ref_path)
+
+    @classmethod
+    def _get_ref_info(cls, repo: "Repo", ref_path: Union[PathLike, None]) -> Union[Tuple[str, None], Tuple[None, str]]:
+        """
+        :return:
+            *(str(sha), str(target_ref_path))*, where:
+
+            * *sha* is of the file at rela_path points to if available, or ``None``.
+            * *target_ref_path* is the reference we point to, or ``None``.
+        """
+        return cls._get_ref_info_helper(repo, ref_path)
+
+    def _get_object(self) -> AnyGitObject:
+        """
+        :return:
+            The object our ref currently refers to. Refs can be cached, they will always
+            point to the actual object as it gets re-created on each query.
+        """
+        # We have to be dynamic here as we may be a tag which can point to anything.
+        # Our path will be resolved to the hexsha which will be used accordingly.
+        return Object.new_from_sha(self.repo, hex_to_bin(self.dereference_recursive(self.repo, self.path)))
+
+    def _get_commit(self) -> "Commit":
+        """
+        :return:
+            :class:`~git.objects.commit.Commit` object we point to. This works for
+            detached and non-detached :class:`SymbolicReference` instances. The symbolic
+            reference will be dereferenced recursively.
+        """
+        obj = self._get_object()
+        if obj.type == "tag":
+            obj = obj.object
+        # END dereference tag
+
+        if obj.type != Commit.type:
+            raise TypeError("Symbolic Reference pointed to object %r, commit was required" % obj)
+        # END handle type
+        return obj
+
+    def set_commit(
+        self,
+        commit: Union[Commit, "SymbolicReference", str],
+        logmsg: Union[str, None] = None,
+    ) -> "SymbolicReference":
+        """Like :meth:`set_object`, but restricts the type of object to be a
+        :class:`~git.objects.commit.Commit`.
+
+        :raise ValueError:
+            If `commit` is not a :class:`~git.objects.commit.Commit` object, nor does it
+            point to a commit.
+
+        :return:
+            self
+        """
+        # Check the type - assume the best if it is a base-string.
+        invalid_type = False
+        if isinstance(commit, Object):
+            invalid_type = commit.type != Commit.type
+        elif isinstance(commit, SymbolicReference):
+            invalid_type = commit.object.type != Commit.type
+        else:
+            try:
+                invalid_type = self.repo.rev_parse(commit).type != Commit.type
+            except (BadObject, BadName) as e:
+                raise ValueError("Invalid object: %s" % commit) from e
+            # END handle exception
+        # END verify type
+
+        if invalid_type:
+            raise ValueError("Need commit, got %r" % commit)
+        # END handle raise
+
+        # We leave strings to the rev-parse method below.
+        self.set_object(commit, logmsg)
+
+        return self
+
+    def set_object(
+        self,
+        object: Union[AnyGitObject, "SymbolicReference", str],
+        logmsg: Union[str, None] = None,
+    ) -> "SymbolicReference":
+        """Set the object we point to, possibly dereference our symbolic reference
+        first. If the reference does not exist, it will be created.
+
+        :param object:
+            A refspec, a :class:`SymbolicReference` or an
+            :class:`~git.objects.base.Object` instance.
+
+            * :class:`SymbolicReference` instances will be dereferenced beforehand to
+              obtain the git object they point to.
+            * :class:`~git.objects.base.Object` instances must represent git objects
+              (:class:`~git.types.AnyGitObject`).
+
+        :param logmsg:
+            If not ``None``, the message will be used in the reflog entry to be written.
+            Otherwise the reflog is not altered.
+
+        :note:
+            Plain :class:`SymbolicReference` instances may not actually point to objects
+            by convention.
+
+        :return:
+            self
+        """
+        if isinstance(object, SymbolicReference):
+            object = object.object  # @ReservedAssignment
+        # END resolve references
+
+        is_detached = True
+        try:
+            is_detached = self.is_detached
+        except ValueError:
+            pass
+        # END handle non-existing ones
+
+        if is_detached:
+            return self.set_reference(object, logmsg)
+
+        # set the commit on our reference
+        return self._get_reference().set_object(object, logmsg)
+
+    commit = property(
+        _get_commit,
+        set_commit,  # type: ignore[arg-type]
+        doc="Query or set commits directly",
+    )
+
+    object = property(
+        _get_object,
+        set_object,  # type: ignore[arg-type]
+        doc="Return the object our ref currently refers to",
+    )
+
+    def _get_reference(self) -> "SymbolicReference":
+        """
+        :return:
+            :class:`~git.refs.reference.Reference` object we point to
+
+        :raise TypeError:
+            If this symbolic reference is detached, hence it doesn't point to a
+            reference, but to a commit.
+        """
+        sha, target_ref_path = self._get_ref_info(self.repo, self.path)
+        if target_ref_path is None:
+            raise TypeError("%s is a detached symbolic reference as it points to %r" % (self, sha))
+        return self.from_path(self.repo, target_ref_path)
+
+    def set_reference(
+        self,
+        ref: Union[AnyGitObject, "SymbolicReference", str],
+        logmsg: Union[str, None] = None,
+    ) -> "SymbolicReference":
+        """Set ourselves to the given `ref`.
+
+        It will stay a symbol if the `ref` is a :class:`~git.refs.reference.Reference`.
+
+        Otherwise a git object, specified as a :class:`~git.objects.base.Object`
+        instance or refspec, is assumed. If it is valid, this reference will be set to
+        it, which effectively detaches the reference if it was a purely symbolic one.
+
+        :param ref:
+            A :class:`SymbolicReference` instance, an :class:`~git.objects.base.Object`
+            instance (specifically an :class:`~git.types.AnyGitObject`), or a refspec
+            string. Only if the ref is a :class:`SymbolicReference` instance, we will
+            point to it. Everything else is dereferenced to obtain the actual object.
+
+        :param logmsg:
+            If set to a string, the message will be used in the reflog.
+            Otherwise, a reflog entry is not written for the changed reference.
+            The previous commit of the entry will be the commit we point to now.
+
+            See also: :meth:`log_append`
+
+        :return:
+            self
+
+        :note:
+            This symbolic reference will not be dereferenced. For that, see
+            :meth:`set_object`.
+        """
+        write_value = None
+        obj = None
+        if isinstance(ref, SymbolicReference):
+            write_value = "ref: %s" % ref.path
+        elif isinstance(ref, Object):
+            obj = ref
+            write_value = ref.hexsha
+        elif isinstance(ref, str):
+            try:
+                obj = self.repo.rev_parse(ref + "^{}")  # Optionally dereference tags.
+                write_value = obj.hexsha
+            except (BadObject, BadName) as e:
+                raise ValueError("Could not extract object from %s" % ref) from e
+            # END end try string
+        else:
+            raise ValueError("Unrecognized Value: %r" % ref)
+        # END try commit attribute
+
+        # typecheck
+        if obj is not None and self._points_to_commits_only and obj.type != Commit.type:
+            raise TypeError("Require commit, got %r" % obj)
+        # END verify type
+
+        oldbinsha: bytes = b""
+        if logmsg is not None:
+            try:
+                oldbinsha = self.commit.binsha
+            except ValueError:
+                oldbinsha = Commit.NULL_BIN_SHA
+            # END handle non-existing
+        # END retrieve old hexsha
+
+        fpath = self.abspath
+        assure_directory_exists(fpath, is_file=True)
+
+        lfd = LockedFD(fpath)
+        fd = lfd.open(write=True, stream=True)
+        try:
+            fd.write(write_value.encode("utf-8") + b"\n")
+            lfd.commit()
+        except BaseException:
+            lfd.rollback()
+            raise
+        # Adjust the reflog
+        if logmsg is not None:
+            self.log_append(oldbinsha, logmsg)
+
+        return self
+
+    # Aliased reference
+    reference: Union["Head", "TagReference", "RemoteReference", "Reference"]
+    reference = property(  # type: ignore[assignment]
+        _get_reference,
+        set_reference,  # type: ignore[arg-type]
+        doc="Returns the Reference we point to",
+    )
+    ref = reference
+
+    def is_valid(self) -> bool:
+        """
+        :return:
+            ``True`` if the reference is valid, hence it can be read and points to a
+            valid object or reference.
+        """
+        try:
+            self.object  # noqa: B018
+        except (OSError, ValueError):
+            return False
+        else:
+            return True
+
+    @property
+    def is_detached(self) -> bool:
+        """
+        :return:
+            ``True`` if we are a detached reference, hence we point to a specific commit
+            instead to another reference.
+        """
+        try:
+            self.ref  # noqa: B018
+            return False
+        except TypeError:
+            return True
+
+    def log(self) -> "RefLog":
+        """
+        :return:
+            :class:`~git.refs.log.RefLog` for this reference.
+            Its last entry reflects the latest change applied to this reference.
+
+        :note:
+            As the log is parsed every time, its recommended to cache it for use instead
+            of calling this method repeatedly. It should be considered read-only.
+        """
+        return RefLog.from_file(RefLog.path(self))
+
+    def log_append(
+        self,
+        oldbinsha: bytes,
+        message: Union[str, None],
+        newbinsha: Union[bytes, None] = None,
+    ) -> "RefLogEntry":
+        """Append a logentry to the logfile of this ref.
+
+        :param oldbinsha:
+            Binary sha this ref used to point to.
+
+        :param message:
+            A message describing the change.
+
+        :param newbinsha:
+            The sha the ref points to now. If None, our current commit sha will be used.
+
+        :return:
+            The added :class:`~git.refs.log.RefLogEntry` instance.
+        """
+        # NOTE: We use the committer of the currently active commit - this should be
+        # correct to allow overriding the committer on a per-commit level.
+        # See https://github.com/gitpython-developers/GitPython/pull/146.
+        try:
+            committer_or_reader: Union["Actor", "GitConfigParser"] = self.commit.committer
+        except ValueError:
+            committer_or_reader = self.repo.config_reader()
+        # END handle newly cloned repositories
+        if newbinsha is None:
+            newbinsha = self.commit.binsha
+
+        if message is None:
+            message = ""
+
+        return RefLog.append_entry(committer_or_reader, RefLog.path(self), oldbinsha, newbinsha, message)
+
+    def log_entry(self, index: int) -> "RefLogEntry":
+        """
+        :return:
+            :class:`~git.refs.log.RefLogEntry` at the given index
+
+        :param index:
+            Python list compatible positive or negative index.
+
+        :note:
+            This method must read part of the reflog during execution, hence it should
+            be used sparingly, or only if you need just one index. In that case, it will
+            be faster than the :meth:`log` method.
+        """
+        return RefLog.entry_at(RefLog.path(self), index)
+
+    @classmethod
+    def to_full_path(cls, path: Union[PathLike, "SymbolicReference"]) -> PathLike:
+        """
+        :return:
+            String with a full repository-relative path which can be used to initialize
+            a :class:`~git.refs.reference.Reference` instance, for instance by using
+            :meth:`Reference.from_path <git.refs.reference.Reference.from_path>`.
+        """
+        if isinstance(path, SymbolicReference):
+            path = path.path
+        full_ref_path = path
+        if not cls._common_path_default:
+            return full_ref_path
+        if not str(path).startswith(cls._common_path_default + "/"):
+            full_ref_path = "%s/%s" % (cls._common_path_default, path)
+        return full_ref_path
+
+    @classmethod
+    def delete(cls, repo: "Repo", path: PathLike) -> None:
+        """Delete the reference at the given path.
+
+        :param repo:
+            Repository to delete the reference from.
+
+        :param path:
+            Short or full path pointing to the reference, e.g. ``refs/myreference`` or
+            just ``myreference``, hence ``refs/`` is implied.
+            Alternatively the symbolic reference to be deleted.
+        """
+        full_ref_path = cls.to_full_path(path)
+        abs_path = os.path.join(repo.common_dir, full_ref_path)
+        if os.path.exists(abs_path):
+            os.remove(abs_path)
+        else:
+            # Check packed refs.
+            pack_file_path = cls._get_packed_refs_path(repo)
+            try:
+                with open(pack_file_path, "rb") as reader:
+                    new_lines = []
+                    made_change = False
+                    dropped_last_line = False
+                    for line_bytes in reader:
+                        line = line_bytes.decode(defenc)
+                        _, _, line_ref = line.partition(" ")
+                        line_ref = line_ref.strip()
+                        # Keep line if it is a comment or if the ref to delete is not in
+                        # the line.
+                        # If we deleted the last line and this one is a tag-reference
+                        # object, we drop it as well.
+                        if (line.startswith("#") or full_ref_path != line_ref) and (
+                            not dropped_last_line or dropped_last_line and not line.startswith("^")
+                        ):
+                            new_lines.append(line)
+                            dropped_last_line = False
+                            continue
+                        # END skip comments and lines without our path
+
+                        # Drop this line.
+                        made_change = True
+                        dropped_last_line = True
+
+                # Write the new lines.
+                if made_change:
+                    # Binary writing is required, otherwise Windows will open the file
+                    # in text mode and change LF to CRLF!
+                    with open(pack_file_path, "wb") as fd:
+                        fd.writelines(line.encode(defenc) for line in new_lines)
+
+            except OSError:
+                pass  # It didn't exist at all.
+
+        # Delete the reflog.
+        reflog_path = RefLog.path(cls(repo, full_ref_path))
+        if os.path.isfile(reflog_path):
+            os.remove(reflog_path)
+        # END remove reflog
+
+    @classmethod
+    def _create(
+        cls: Type[T_References],
+        repo: "Repo",
+        path: PathLike,
+        resolve: bool,
+        reference: Union["SymbolicReference", str],
+        force: bool,
+        logmsg: Union[str, None] = None,
+    ) -> T_References:
+        """Internal method used to create a new symbolic reference.
+
+        If `resolve` is ``False``, the reference will be taken as is, creating a proper
+        symbolic reference. Otherwise it will be resolved to the corresponding object
+        and a detached symbolic reference will be created instead.
+        """
+        git_dir = _git_dir(repo, path)
+        full_ref_path = cls.to_full_path(path)
+        abs_ref_path = os.path.join(git_dir, full_ref_path)
+
+        # Figure out target data.
+        target = reference
+        if resolve:
+            target = repo.rev_parse(str(reference))
+
+        if not force and os.path.isfile(abs_ref_path):
+            target_data = str(target)
+            if isinstance(target, SymbolicReference):
+                target_data = str(target.path)
+            if not resolve:
+                target_data = "ref: " + target_data
+            with open(abs_ref_path, "rb") as fd:
+                existing_data = fd.read().decode(defenc).strip()
+            if existing_data != target_data:
+                raise OSError(
+                    "Reference at %r does already exist, pointing to %r, requested was %r"
+                    % (full_ref_path, existing_data, target_data)
+                )
+        # END no force handling
+
+        ref = cls(repo, full_ref_path)
+        ref.set_reference(target, logmsg)
+        return ref
+
+    @classmethod
+    def create(
+        cls: Type[T_References],
+        repo: "Repo",
+        path: PathLike,
+        reference: Union["SymbolicReference", str] = "HEAD",
+        logmsg: Union[str, None] = None,
+        force: bool = False,
+        **kwargs: Any,
+    ) -> T_References:
+        """Create a new symbolic reference: a reference pointing to another reference.
+
+        :param repo:
+            Repository to create the reference in.
+
+        :param path:
+            Full path at which the new symbolic reference is supposed to be created at,
+            e.g. ``NEW_HEAD`` or ``symrefs/my_new_symref``.
+
+        :param reference:
+            The reference which the new symbolic reference should point to.
+            If it is a commit-ish, the symbolic ref will be detached.
+
+        :param force:
+            If ``True``, force creation even if a symbolic reference with that name
+            already exists. Raise :exc:`OSError` otherwise.
+
+        :param logmsg:
+            If not ``None``, the message to append to the reflog.
+            If ``None``, no reflog entry is written.
+
+        :return:
+            Newly created symbolic reference
+
+        :raise OSError:
+            If a (Symbolic)Reference with the same name but different contents already
+            exists.
+
+        :note:
+            This does not alter the current HEAD, index or working tree.
+        """
+        return cls._create(repo, path, cls._resolve_ref_on_create, reference, force, logmsg)
+
+    def rename(self, new_path: PathLike, force: bool = False) -> "SymbolicReference":
+        """Rename self to a new path.
+
+        :param new_path:
+            Either a simple name or a full path, e.g. ``new_name`` or
+            ``features/new_name``.
+            The prefix ``refs/`` is implied for references and will be set as needed.
+            In case this is a symbolic ref, there is no implied prefix.
+
+        :param force:
+            If ``True``, the rename will succeed even if a head with the target name
+            already exists. It will be overwritten in that case.
+
+        :return:
+            self
+
+        :raise OSError:
+            If a file at path but with different contents already exists.
+        """
+        new_path = self.to_full_path(new_path)
+        if self.path == new_path:
+            return self
+
+        new_abs_path = os.path.join(_git_dir(self.repo, new_path), new_path)
+        cur_abs_path = os.path.join(_git_dir(self.repo, self.path), self.path)
+        if os.path.isfile(new_abs_path):
+            if not force:
+                # If they point to the same file, it's not an error.
+                with open(new_abs_path, "rb") as fd1:
+                    f1 = fd1.read().strip()
+                with open(cur_abs_path, "rb") as fd2:
+                    f2 = fd2.read().strip()
+                if f1 != f2:
+                    raise OSError("File at path %r already exists" % new_abs_path)
+                # else: We could remove ourselves and use the other one, but...
+                # ...for clarity, we just continue as usual.
+            # END not force handling
+            os.remove(new_abs_path)
+        # END handle existing target file
+
+        dname = os.path.dirname(new_abs_path)
+        if not os.path.isdir(dname):
+            os.makedirs(dname)
+        # END create directory
+
+        os.rename(cur_abs_path, new_abs_path)
+        self.path = new_path
+
+        return self
+
+    @classmethod
+    def _iter_items(
+        cls: Type[T_References], repo: "Repo", common_path: Union[PathLike, None] = None
+    ) -> Iterator[T_References]:
+        if common_path is None:
+            common_path = cls._common_path_default
+        rela_paths = set()
+
+        # Walk loose refs.
+        # Currently we do not follow links.
+        for root, dirs, files in os.walk(join_path_native(repo.common_dir, common_path)):
+            if "refs" not in root.split(os.sep):  # Skip non-refs subfolders.
+                refs_id = [d for d in dirs if d == "refs"]
+                if refs_id:
+                    dirs[0:] = ["refs"]
+            # END prune non-refs folders
+
+            for f in files:
+                if f == "packed-refs":
+                    continue
+                abs_path = to_native_path_linux(join_path(root, f))
+                rela_paths.add(abs_path.replace(to_native_path_linux(repo.common_dir) + "/", ""))
+            # END for each file in root directory
+        # END for each directory to walk
+
+        # Read packed refs.
+        for _sha, rela_path in cls._iter_packed_refs(repo):
+            if rela_path.startswith(str(common_path)):
+                rela_paths.add(rela_path)
+            # END relative path matches common path
+        # END packed refs reading
+
+        # Yield paths in sorted order.
+        for path in sorted(rela_paths):
+            try:
+                yield cls.from_path(repo, path)
+            except ValueError:
+                continue
+        # END for each sorted relative refpath
+
+    @classmethod
+    def iter_items(
+        cls: Type[T_References],
+        repo: "Repo",
+        common_path: Union[PathLike, None] = None,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Iterator[T_References]:
+        """Find all refs in the repository.
+
+        :param repo:
+            The :class:`~git.repo.base.Repo`.
+
+        :param common_path:
+            Optional keyword argument to the path which is to be shared by all returned
+            Ref objects.
+            Defaults to class specific portion if ``None``, ensuring that only refs
+            suitable for the actual class are returned.
+
+        :return:
+            A list of :class:`SymbolicReference`, each guaranteed to be a symbolic ref
+            which is not detached and pointing to a valid ref.
+
+            The list is lexicographically sorted. The returned objects are instances of
+            concrete subclasses, such as :class:`~git.refs.head.Head` or
+            :class:`~git.refs.tag.TagReference`.
+        """
+        return (r for r in cls._iter_items(repo, common_path) if r.__class__ is SymbolicReference or not r.is_detached)
+
+    @classmethod
+    def from_path(cls: Type[T_References], repo: "Repo", path: PathLike) -> T_References:
+        """Make a symbolic reference from a path.
+
+        :param path:
+            Full ``.git``-directory-relative path name to the Reference to instantiate.
+
+        :note:
+            Use :meth:`to_full_path` if you only have a partial path of a known
+            Reference type.
+
+        :return:
+            Instance of type :class:`~git.refs.reference.Reference`,
+            :class:`~git.refs.head.Head`, or :class:`~git.refs.tag.Tag`, depending on
+            the given path.
+        """
+        if not path:
+            raise ValueError("Cannot create Reference from %r" % path)
+
+        # Names like HEAD are inserted after the refs module is imported - we have an
+        # import dependency cycle and don't want to import these names in-function.
+        from . import HEAD, Head, RemoteReference, TagReference, Reference
+
+        for ref_type in (
+            HEAD,
+            Head,
+            RemoteReference,
+            TagReference,
+            Reference,
+            SymbolicReference,
+        ):
+            try:
+                instance: T_References
+                instance = ref_type(repo, path)
+                if instance.__class__ is SymbolicReference and instance.is_detached:
+                    raise ValueError("SymbolicRef was detached, we drop it")
+                else:
+                    return instance
+
+            except ValueError:
+                pass
+            # END exception handling
+        # END for each type to try
+        raise ValueError("Could not find reference type suitable to handle path %r" % path)
+
+    def is_remote(self) -> bool:
+        """:return: True if this symbolic reference points to a remote branch"""
+        return str(self.path).startswith(self._remote_common_path_default + "/")
diff --git a/parrot/lib/python3.10/site-packages/git/refs/tag.py b/parrot/lib/python3.10/site-packages/git/refs/tag.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e38663ae9a3b43bb43dcff9c493551febf6a38e
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/refs/tag.py
@@ -0,0 +1,155 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Provides a :class:`~git.refs.reference.Reference`-based type for lightweight tags.
+
+This defines the :class:`TagReference` class (and its alias :class:`Tag`), which
+represents lightweight tags. For annotated tags (which are git objects), see the
+:mod:`git.objects.tag` module.
+"""
+
+__all__ = ["TagReference", "Tag"]
+
+from .reference import Reference
+
+# typing ------------------------------------------------------------------
+
+from typing import Any, TYPE_CHECKING, Type, Union
+
+from git.types import AnyGitObject, PathLike
+
+if TYPE_CHECKING:
+    from git.objects import Commit, TagObject
+    from git.refs import SymbolicReference
+    from git.repo import Repo
+
+# ------------------------------------------------------------------------------
+
+
+class TagReference(Reference):
+    """A lightweight tag reference which either points to a commit, a tag object or any
+    other object. In the latter case additional information, like the signature or the
+    tag-creator, is available.
+
+    This tag object will always point to a commit object, but may carry additional
+    information in a tag object::
+
+     tagref = TagReference.list_items(repo)[0]
+     print(tagref.commit.message)
+     if tagref.tag is not None:
+        print(tagref.tag.message)
+    """
+
+    __slots__ = ()
+
+    _common_default = "tags"
+    _common_path_default = Reference._common_path_default + "/" + _common_default
+
+    @property
+    def commit(self) -> "Commit":  # type: ignore[override]  # LazyMixin has unrelated commit method
+        """:return: Commit object the tag ref points to
+
+        :raise ValueError:
+            If the tag points to a tree or blob.
+        """
+        obj = self.object
+        while obj.type != "commit":
+            if obj.type == "tag":
+                # It is a tag object which carries the commit as an object - we can point to anything.
+                obj = obj.object
+            else:
+                raise ValueError(
+                    (
+                        "Cannot resolve commit as tag %s points to a %s object - "
+                        + "use the `.object` property instead to access it"
+                    )
+                    % (self, obj.type)
+                )
+        return obj
+
+    @property
+    def tag(self) -> Union["TagObject", None]:
+        """
+        :return:
+            Tag object this tag ref points to, or ``None`` in case we are a lightweight
+            tag
+        """
+        obj = self.object
+        if obj.type == "tag":
+            return obj
+        return None
+
+    # Make object read-only. It should be reasonably hard to adjust an existing tag.
+    @property
+    def object(self) -> AnyGitObject:  # type: ignore[override]
+        return Reference._get_object(self)
+
+    @classmethod
+    def create(
+        cls: Type["TagReference"],
+        repo: "Repo",
+        path: PathLike,
+        reference: Union[str, "SymbolicReference"] = "HEAD",
+        logmsg: Union[str, None] = None,
+        force: bool = False,
+        **kwargs: Any,
+    ) -> "TagReference":
+        """Create a new tag reference.
+
+        :param repo:
+            The :class:`~git.repo.base.Repo` to create the tag in.
+
+        :param path:
+            The name of the tag, e.g. ``1.0`` or ``releases/1.0``.
+            The prefix ``refs/tags`` is implied.
+
+        :param reference:
+            A reference to the :class:`~git.objects.base.Object` you want to tag.
+            The referenced object can be a commit, tree, or blob.
+
+        :param logmsg:
+            If not ``None``, the message will be used in your tag object. This will also
+            create an additional tag object that allows to obtain that information,
+            e.g.::
+
+                tagref.tag.message
+
+        :param message:
+            Synonym for the `logmsg` parameter. Included for backwards compatibility.
+            `logmsg` takes precedence if both are passed.
+
+        :param force:
+            If ``True``, force creation of a tag even though that tag already exists.
+
+        :param kwargs:
+            Additional keyword arguments to be passed to :manpage:`git-tag(1)`.
+
+        :return:
+            A new :class:`TagReference`.
+        """
+        if "ref" in kwargs and kwargs["ref"]:
+            reference = kwargs["ref"]
+
+        if "message" in kwargs and kwargs["message"]:
+            kwargs["m"] = kwargs["message"]
+            del kwargs["message"]
+
+        if logmsg:
+            kwargs["m"] = logmsg
+
+        if force:
+            kwargs["f"] = True
+
+        args = (path, reference)
+
+        repo.git.tag(*args, **kwargs)
+        return TagReference(repo, "%s/%s" % (cls._common_path_default, path))
+
+    @classmethod
+    def delete(cls, repo: "Repo", *tags: "TagReference") -> None:  # type: ignore[override]
+        """Delete the given existing tag or tags."""
+        repo.git.tag("-d", *tags)
+
+
+# Provide an alias.
+Tag = TagReference
diff --git a/parrot/lib/python3.10/site-packages/git/repo/__init__.py b/parrot/lib/python3.10/site-packages/git/repo/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..66319ef95f5c06956660127d6cb131fa99d3b780
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/repo/__init__.py
@@ -0,0 +1,8 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""Initialize the repo package."""
+
+__all__ = ["Repo"]
+
+from .base import Repo
diff --git a/parrot/lib/python3.10/site-packages/git/repo/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/repo/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..565924fe9eb716182bfc7d5f83d309e006053227
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/repo/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/repo/__pycache__/base.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/repo/__pycache__/base.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa80e7ea7c5321cbf2c66def0f777d7199102226
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/repo/__pycache__/base.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/repo/__pycache__/fun.cpython-310.pyc b/parrot/lib/python3.10/site-packages/git/repo/__pycache__/fun.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..030c9fdc6a6ebc164d133a97dbaf783b85c36b51
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/git/repo/__pycache__/fun.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/git/repo/fun.py b/parrot/lib/python3.10/site-packages/git/repo/fun.py
new file mode 100644
index 0000000000000000000000000000000000000000..e44d9c64401de93aa3de98079ffac46d7a664e46
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/repo/fun.py
@@ -0,0 +1,419 @@
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+"""General repository-related functions."""
+
+from __future__ import annotations
+
+__all__ = [
+    "rev_parse",
+    "is_git_dir",
+    "touch",
+    "find_submodule_git_dir",
+    "name_to_object",
+    "short_to_long",
+    "deref_tag",
+    "to_commit",
+    "find_worktree_git_dir",
+]
+
+import os
+import os.path as osp
+from pathlib import Path
+import stat
+from string import digits
+
+from gitdb.exc import BadName, BadObject
+
+from git.cmd import Git
+from git.exc import WorkTreeRepositoryUnsupported
+from git.objects import Object
+from git.refs import SymbolicReference
+from git.util import cygpath, bin_to_hex, hex_to_bin
+
+# Typing ----------------------------------------------------------------------
+
+from typing import Optional, TYPE_CHECKING, Union, cast, overload
+
+from git.types import AnyGitObject, Literal, PathLike
+
+if TYPE_CHECKING:
+    from git.db import GitCmdObjectDB
+    from git.objects import Commit, TagObject
+    from git.refs.reference import Reference
+    from git.refs.tag import Tag
+
+    from .base import Repo
+
+# ----------------------------------------------------------------------------
+
+
+def touch(filename: str) -> str:
+    with open(filename, "ab"):
+        pass
+    return filename
+
+
+def is_git_dir(d: PathLike) -> bool:
+    """This is taken from the git setup.c:is_git_directory function.
+
+    :raise git.exc.WorkTreeRepositoryUnsupported:
+        If it sees a worktree directory. It's quite hacky to do that here, but at least
+        clearly indicates that we don't support it. There is the unlikely danger to
+        throw if we see directories which just look like a worktree dir, but are none.
+    """
+    if osp.isdir(d):
+        if (osp.isdir(osp.join(d, "objects")) or "GIT_OBJECT_DIRECTORY" in os.environ) and osp.isdir(
+            osp.join(d, "refs")
+        ):
+            headref = osp.join(d, "HEAD")
+            return osp.isfile(headref) or (osp.islink(headref) and os.readlink(headref).startswith("refs"))
+        elif (
+            osp.isfile(osp.join(d, "gitdir"))
+            and osp.isfile(osp.join(d, "commondir"))
+            and osp.isfile(osp.join(d, "gitfile"))
+        ):
+            raise WorkTreeRepositoryUnsupported(d)
+    return False
+
+
+def find_worktree_git_dir(dotgit: PathLike) -> Optional[str]:
+    """Search for a gitdir for this worktree."""
+    try:
+        statbuf = os.stat(dotgit)
+    except OSError:
+        return None
+    if not stat.S_ISREG(statbuf.st_mode):
+        return None
+
+    try:
+        lines = Path(dotgit).read_text().splitlines()
+        for key, value in [line.strip().split(": ") for line in lines]:
+            if key == "gitdir":
+                return value
+    except ValueError:
+        pass
+    return None
+
+
+def find_submodule_git_dir(d: PathLike) -> Optional[PathLike]:
+    """Search for a submodule repo."""
+    if is_git_dir(d):
+        return d
+
+    try:
+        with open(d) as fp:
+            content = fp.read().rstrip()
+    except IOError:
+        # It's probably not a file.
+        pass
+    else:
+        if content.startswith("gitdir: "):
+            path = content[8:]
+
+            if Git.is_cygwin():
+                # Cygwin creates submodules prefixed with `/cygdrive/...` suffixes.
+                # Cygwin git understands Cygwin paths much better than Windows ones.
+                # Also the Cygwin tests are assuming Cygwin paths.
+                path = cygpath(path)
+            if not osp.isabs(path):
+                path = osp.normpath(osp.join(osp.dirname(d), path))
+            return find_submodule_git_dir(path)
+    # END handle exception
+    return None
+
+
+def short_to_long(odb: "GitCmdObjectDB", hexsha: str) -> Optional[bytes]:
+    """
+    :return:
+        Long hexadecimal sha1 from the given less than 40 byte hexsha, or ``None`` if no
+        candidate could be found.
+
+    :param hexsha:
+        hexsha with less than 40 bytes.
+    """
+    try:
+        return bin_to_hex(odb.partial_to_complete_sha_hex(hexsha))
+    except BadObject:
+        return None
+    # END exception handling
+
+
+@overload
+def name_to_object(repo: "Repo", name: str, return_ref: Literal[False] = ...) -> AnyGitObject: ...
+
+
+@overload
+def name_to_object(repo: "Repo", name: str, return_ref: Literal[True]) -> Union[AnyGitObject, SymbolicReference]: ...
+
+
+def name_to_object(repo: "Repo", name: str, return_ref: bool = False) -> Union[AnyGitObject, SymbolicReference]:
+    """
+    :return:
+        Object specified by the given name - hexshas (short and long) as well as
+        references are supported.
+
+    :param return_ref:
+        If ``True``, and name specifies a reference, we will return the reference
+        instead of the object. Otherwise it will raise :exc:`~gitdb.exc.BadObject` or
+        :exc:`~gitdb.exc.BadName`.
+    """
+    hexsha: Union[None, str, bytes] = None
+
+    # Is it a hexsha? Try the most common ones, which is 7 to 40.
+    if repo.re_hexsha_shortened.match(name):
+        if len(name) != 40:
+            # Find long sha for short sha.
+            hexsha = short_to_long(repo.odb, name)
+        else:
+            hexsha = name
+        # END handle short shas
+    # END find sha if it matches
+
+    # If we couldn't find an object for what seemed to be a short hexsha, try to find it
+    # as reference anyway, it could be named 'aaa' for instance.
+    if hexsha is None:
+        for base in (
+            "%s",
+            "refs/%s",
+            "refs/tags/%s",
+            "refs/heads/%s",
+            "refs/remotes/%s",
+            "refs/remotes/%s/HEAD",
+        ):
+            try:
+                hexsha = SymbolicReference.dereference_recursive(repo, base % name)
+                if return_ref:
+                    return SymbolicReference(repo, base % name)
+                # END handle symbolic ref
+                break
+            except ValueError:
+                pass
+        # END for each base
+    # END handle hexsha
+
+    # Didn't find any ref, this is an error.
+    if return_ref:
+        raise BadObject("Couldn't find reference named %r" % name)
+    # END handle return ref
+
+    # Tried everything ? fail.
+    if hexsha is None:
+        raise BadName(name)
+    # END assert hexsha was found
+
+    return Object.new_from_sha(repo, hex_to_bin(hexsha))
+
+
+def deref_tag(tag: "Tag") -> AnyGitObject:
+    """Recursively dereference a tag and return the resulting object."""
+    while True:
+        try:
+            tag = tag.object
+        except AttributeError:
+            break
+    # END dereference tag
+    return tag
+
+
+def to_commit(obj: Object) -> "Commit":
+    """Convert the given object to a commit if possible and return it."""
+    if obj.type == "tag":
+        obj = deref_tag(obj)
+
+    if obj.type != "commit":
+        raise ValueError("Cannot convert object %r to type commit" % obj)
+    # END verify type
+    return obj
+
+
+def rev_parse(repo: "Repo", rev: str) -> AnyGitObject:
+    """Parse a revision string. Like :manpage:`git-rev-parse(1)`.
+
+    :return:
+        `~git.objects.base.Object` at the given revision.
+
+        This may be any type of git object:
+
+        * :class:`Commit <git.objects.commit.Commit>`
+        * :class:`TagObject <git.objects.tag.TagObject>`
+        * :class:`Tree <git.objects.tree.Tree>`
+        * :class:`Blob <git.objects.blob.Blob>`
+
+    :param rev:
+        :manpage:`git-rev-parse(1)`-compatible revision specification as string.
+        Please see :manpage:`git-rev-parse(1)` for details.
+
+    :raise gitdb.exc.BadObject:
+        If the given revision could not be found.
+
+    :raise ValueError:
+        If `rev` couldn't be parsed.
+
+    :raise IndexError:
+        If an invalid reflog index is specified.
+    """
+    # Are we in colon search mode?
+    if rev.startswith(":/"):
+        # Colon search mode
+        raise NotImplementedError("commit by message search (regex)")
+    # END handle search
+
+    obj: Optional[AnyGitObject] = None
+    ref = None
+    output_type = "commit"
+    start = 0
+    parsed_to = 0
+    lr = len(rev)
+    while start < lr:
+        if rev[start] not in "^~:@":
+            start += 1
+            continue
+        # END handle start
+
+        token = rev[start]
+
+        if obj is None:
+            # token is a rev name.
+            if start == 0:
+                ref = repo.head.ref
+            else:
+                if token == "@":
+                    ref = cast("Reference", name_to_object(repo, rev[:start], return_ref=True))
+                else:
+                    obj = name_to_object(repo, rev[:start])
+                # END handle token
+            # END handle refname
+        else:
+            if ref is not None:
+                obj = cast("Commit", ref.commit)
+            # END handle ref
+        # END initialize obj on first token
+
+        start += 1
+
+        # Try to parse {type}.
+        if start < lr and rev[start] == "{":
+            end = rev.find("}", start)
+            if end == -1:
+                raise ValueError("Missing closing brace to define type in %s" % rev)
+            output_type = rev[start + 1 : end]  # Exclude brace.
+
+            # Handle type.
+            if output_type == "commit":
+                pass  # Default.
+            elif output_type == "tree":
+                try:
+                    obj = cast(AnyGitObject, obj)
+                    obj = to_commit(obj).tree
+                except (AttributeError, ValueError):
+                    pass  # Error raised later.
+                # END exception handling
+            elif output_type in ("", "blob"):
+                obj = cast("TagObject", obj)
+                if obj and obj.type == "tag":
+                    obj = deref_tag(obj)
+                else:
+                    # Cannot do anything for non-tags.
+                    pass
+                # END handle tag
+            elif token == "@":
+                # try single int
+                assert ref is not None, "Require Reference to access reflog"
+                revlog_index = None
+                try:
+                    # Transform reversed index into the format of our revlog.
+                    revlog_index = -(int(output_type) + 1)
+                except ValueError as e:
+                    # TODO: Try to parse the other date options, using parse_date maybe.
+                    raise NotImplementedError("Support for additional @{...} modes not implemented") from e
+                # END handle revlog index
+
+                try:
+                    entry = ref.log_entry(revlog_index)
+                except IndexError as e:
+                    raise IndexError("Invalid revlog index: %i" % revlog_index) from e
+                # END handle index out of bound
+
+                obj = Object.new_from_sha(repo, hex_to_bin(entry.newhexsha))
+
+                # Make it pass the following checks.
+                output_type = ""
+            else:
+                raise ValueError("Invalid output type: %s ( in %s )" % (output_type, rev))
+            # END handle output type
+
+            # Empty output types don't require any specific type, its just about
+            # dereferencing tags.
+            if output_type and obj and obj.type != output_type:
+                raise ValueError("Could not accommodate requested object type %r, got %s" % (output_type, obj.type))
+            # END verify output type
+
+            start = end + 1  # Skip brace.
+            parsed_to = start
+            continue
+        # END parse type
+
+        # Try to parse a number.
+        num = 0
+        if token != ":":
+            found_digit = False
+            while start < lr:
+                if rev[start] in digits:
+                    num = num * 10 + int(rev[start])
+                    start += 1
+                    found_digit = True
+                else:
+                    break
+                # END handle number
+            # END number parse loop
+
+            # No explicit number given, 1 is the default. It could be 0 though.
+            if not found_digit:
+                num = 1
+            # END set default num
+        # END number parsing only if non-blob mode
+
+        parsed_to = start
+        # Handle hierarchy walk.
+        try:
+            obj = cast(AnyGitObject, obj)
+            if token == "~":
+                obj = to_commit(obj)
+                for _ in range(num):
+                    obj = obj.parents[0]
+                # END for each history item to walk
+            elif token == "^":
+                obj = to_commit(obj)
+                # Must be n'th parent.
+                if num:
+                    obj = obj.parents[num - 1]
+            elif token == ":":
+                if obj.type != "tree":
+                    obj = obj.tree
+                # END get tree type
+                obj = obj[rev[start:]]
+                parsed_to = lr
+            else:
+                raise ValueError("Invalid token: %r" % token)
+            # END end handle tag
+        except (IndexError, AttributeError) as e:
+            raise BadName(
+                f"Invalid revision spec '{rev}' - not enough " f"parent commits to reach '{token}{int(num)}'"
+            ) from e
+        # END exception handling
+    # END parse loop
+
+    # Still no obj? It's probably a simple name.
+    if obj is None:
+        obj = name_to_object(repo, rev)
+        parsed_to = lr
+    # END handle simple name
+
+    if obj is None:
+        raise ValueError("Revision specifier could not be parsed: %s" % rev)
+
+    if parsed_to != lr:
+        raise ValueError("Didn't consume complete rev spec %s, consumed part: %s" % (rev, rev[:parsed_to]))
+
+    return obj
diff --git a/parrot/lib/python3.10/site-packages/git/util.py b/parrot/lib/python3.10/site-packages/git/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c1c26012e2e8a19f265480a9011a46e26d010dd
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/git/util.py
@@ -0,0 +1,1344 @@
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under the
+# 3-Clause BSD License: https://opensource.org/license/bsd-3-clause/
+
+import sys
+
+__all__ = [
+    "stream_copy",
+    "join_path",
+    "to_native_path_linux",
+    "join_path_native",
+    "Stats",
+    "IndexFileSHA1Writer",
+    "IterableObj",
+    "IterableList",
+    "BlockingLockFile",
+    "LockFile",
+    "Actor",
+    "get_user_id",
+    "assure_directory_exists",
+    "RemoteProgress",
+    "CallableRemoteProgress",
+    "rmtree",
+    "unbare_repo",
+    "HIDE_WINDOWS_KNOWN_ERRORS",
+]
+
+if sys.platform == "win32":
+    __all__.append("to_native_path_windows")
+
+from abc import abstractmethod
+import contextlib
+from functools import wraps
+import getpass
+import logging
+import os
+import os.path as osp
+import pathlib
+import platform
+import re
+import shutil
+import stat
+import subprocess
+import time
+from urllib.parse import urlsplit, urlunsplit
+import warnings
+
+# NOTE: Unused imports can be improved now that CI testing has fully resumed. Some of
+# these be used indirectly through other GitPython modules, which avoids having to write
+# gitdb all the time in their imports. They are not in __all__, at least currently,
+# because they could be removed or changed at any time, and so should not be considered
+# conceptually public to code outside GitPython. Linters of course do not like it.
+from gitdb.util import (
+    LazyMixin,  # noqa: F401
+    LockedFD,  # noqa: F401
+    bin_to_hex,  # noqa: F401
+    file_contents_ro,  # noqa: F401
+    file_contents_ro_filepath,  # noqa: F401
+    hex_to_bin,  # noqa: F401
+    make_sha,
+    to_bin_sha,  # noqa: F401
+    to_hex_sha,  # noqa: F401
+)
+
+# typing ---------------------------------------------------------
+
+from typing import (
+    Any,
+    AnyStr,
+    BinaryIO,
+    Callable,
+    Dict,
+    Generator,
+    IO,
+    Iterator,
+    List,
+    Optional,
+    Pattern,
+    Sequence,
+    Tuple,
+    TYPE_CHECKING,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+
+if TYPE_CHECKING:
+    from git.cmd import Git
+    from git.config import GitConfigParser, SectionConstraint
+    from git.remote import Remote
+    from git.repo.base import Repo
+
+from git.types import (
+    Files_TD,
+    Has_id_attribute,
+    HSH_TD,
+    Literal,
+    PathLike,
+    Protocol,
+    SupportsIndex,
+    Total_TD,
+    runtime_checkable,
+)
+
+# ---------------------------------------------------------------------
+
+T_IterableObj = TypeVar("T_IterableObj", bound=Union["IterableObj", "Has_id_attribute"], covariant=True)
+# So IterableList[Head] is subtype of IterableList[IterableObj].
+
+_logger = logging.getLogger(__name__)
+
+
+def _read_env_flag(name: str, default: bool) -> bool:
+    """Read a boolean flag from an environment variable.
+
+    :return:
+        The flag, or the `default` value if absent or ambiguous.
+    """
+    try:
+        value = os.environ[name]
+    except KeyError:
+        return default
+
+    _logger.warning(
+        "The %s environment variable is deprecated. Its effect has never been documented and changes without warning.",
+        name,
+    )
+
+    adjusted_value = value.strip().lower()
+
+    if adjusted_value in {"", "0", "false", "no"}:
+        return False
+    if adjusted_value in {"1", "true", "yes"}:
+        return True
+    _logger.warning("%s has unrecognized value %r, treating as %r.", name, value, default)
+    return default
+
+
+def _read_win_env_flag(name: str, default: bool) -> bool:
+    """Read a boolean flag from an environment variable on Windows.
+
+    :return:
+        On Windows, the flag, or the `default` value if absent or ambiguous.
+        On all other operating systems, ``False``.
+
+    :note:
+        This only accesses the environment on Windows.
+    """
+    return sys.platform == "win32" and _read_env_flag(name, default)
+
+
+#: We need an easy way to see if Appveyor TCs start failing,
+#: so the errors marked with this var are considered "acknowledged" ones, awaiting remedy,
+#: till then, we wish to hide them.
+HIDE_WINDOWS_KNOWN_ERRORS = _read_win_env_flag("HIDE_WINDOWS_KNOWN_ERRORS", True)
+HIDE_WINDOWS_FREEZE_ERRORS = _read_win_env_flag("HIDE_WINDOWS_FREEZE_ERRORS", True)
+
+# { Utility Methods
+
+T = TypeVar("T")
+
+
+def unbare_repo(func: Callable[..., T]) -> Callable[..., T]:
+    """Methods with this decorator raise :exc:`~git.exc.InvalidGitRepositoryError` if
+    they encounter a bare repository."""
+
+    from .exc import InvalidGitRepositoryError
+
+    @wraps(func)
+    def wrapper(self: "Remote", *args: Any, **kwargs: Any) -> T:
+        if self.repo.bare:
+            raise InvalidGitRepositoryError("Method '%s' cannot operate on bare repositories" % func.__name__)
+        # END bare method
+        return func(self, *args, **kwargs)
+
+    # END wrapper
+
+    return wrapper
+
+
+@contextlib.contextmanager
+def cwd(new_dir: PathLike) -> Generator[PathLike, None, None]:
+    """Context manager to temporarily change directory.
+
+    This is similar to :func:`contextlib.chdir` introduced in Python 3.11, but the
+    context manager object returned by a single call to this function is not reentrant.
+    """
+    old_dir = os.getcwd()
+    os.chdir(new_dir)
+    try:
+        yield new_dir
+    finally:
+        os.chdir(old_dir)
+
+
+@contextlib.contextmanager
+def patch_env(name: str, value: str) -> Generator[None, None, None]:
+    """Context manager to temporarily patch an environment variable."""
+    old_value = os.getenv(name)
+    os.environ[name] = value
+    try:
+        yield
+    finally:
+        if old_value is None:
+            del os.environ[name]
+        else:
+            os.environ[name] = old_value
+
+
+def rmtree(path: PathLike) -> None:
+    """Remove the given directory tree recursively.
+
+    :note:
+        We use :func:`shutil.rmtree` but adjust its behaviour to see whether files that
+        couldn't be deleted are read-only. Windows will not remove them in that case.
+    """
+
+    def handler(function: Callable, path: PathLike, _excinfo: Any) -> None:
+        """Callback for :func:`shutil.rmtree`.
+
+        This works as either a ``onexc`` or ``onerror`` style callback.
+        """
+        # Is the error an access error?
+        os.chmod(path, stat.S_IWUSR)
+
+        try:
+            function(path)
+        except PermissionError as ex:
+            if HIDE_WINDOWS_KNOWN_ERRORS:
+                from unittest import SkipTest
+
+                raise SkipTest(f"FIXME: fails with: PermissionError\n  {ex}") from ex
+            raise
+
+    if sys.platform != "win32":
+        shutil.rmtree(path)
+    elif sys.version_info >= (3, 12):
+        shutil.rmtree(path, onexc=handler)
+    else:
+        shutil.rmtree(path, onerror=handler)
+
+
+def rmfile(path: PathLike) -> None:
+    """Ensure file deleted also on *Windows* where read-only files need special
+    treatment."""
+    if osp.isfile(path):
+        if sys.platform == "win32":
+            os.chmod(path, 0o777)
+        os.remove(path)
+
+
+def stream_copy(source: BinaryIO, destination: BinaryIO, chunk_size: int = 512 * 1024) -> int:
+    """Copy all data from the `source` stream into the `destination` stream in chunks
+    of size `chunk_size`.
+
+    :return:
+        Number of bytes written
+    """
+    br = 0
+    while True:
+        chunk = source.read(chunk_size)
+        destination.write(chunk)
+        br += len(chunk)
+        if len(chunk) < chunk_size:
+            break
+    # END reading output stream
+    return br
+
+
+def join_path(a: PathLike, *p: PathLike) -> PathLike:
+    R"""Join path tokens together similar to osp.join, but always use ``/`` instead of
+    possibly ``\`` on Windows."""
+    path = str(a)
+    for b in p:
+        b = str(b)
+        if not b:
+            continue
+        if b.startswith("/"):
+            path += b[1:]
+        elif path == "" or path.endswith("/"):
+            path += b
+        else:
+            path += "/" + b
+    # END for each path token to add
+    return path
+
+
+if sys.platform == "win32":
+
+    def to_native_path_windows(path: PathLike) -> PathLike:
+        path = str(path)
+        return path.replace("/", "\\")
+
+    def to_native_path_linux(path: PathLike) -> str:
+        path = str(path)
+        return path.replace("\\", "/")
+
+    to_native_path = to_native_path_windows
+else:
+    # No need for any work on Linux.
+    def to_native_path_linux(path: PathLike) -> str:
+        return str(path)
+
+    to_native_path = to_native_path_linux
+
+
+def join_path_native(a: PathLike, *p: PathLike) -> PathLike:
+    R"""Like :func:`join_path`, but makes sure an OS native path is returned.
+
+    This is only needed to play it safe on Windows and to ensure nice paths that only
+    use ``\``.
+    """
+    return to_native_path(join_path(a, *p))
+
+
+def assure_directory_exists(path: PathLike, is_file: bool = False) -> bool:
+    """Make sure that the directory pointed to by path exists.
+
+    :param is_file:
+        If ``True``, `path` is assumed to be a file and handled correctly.
+        Otherwise it must be a directory.
+
+    :return:
+        ``True`` if the directory was created, ``False`` if it already existed.
+    """
+    if is_file:
+        path = osp.dirname(path)
+    # END handle file
+    if not osp.isdir(path):
+        os.makedirs(path, exist_ok=True)
+        return True
+    return False
+
+
+def _get_exe_extensions() -> Sequence[str]:
+    PATHEXT = os.environ.get("PATHEXT", None)
+    if PATHEXT:
+        return tuple(p.upper() for p in PATHEXT.split(os.pathsep))
+    elif sys.platform == "win32":
+        return (".BAT", "COM", ".EXE")
+    else:
+        return ()
+
+
+def py_where(program: str, path: Optional[PathLike] = None) -> List[str]:
+    """Perform a path search to assist :func:`is_cygwin_git`.
+
+    This is not robust for general use. It is an implementation detail of
+    :func:`is_cygwin_git`. When a search following all shell rules is needed,
+    :func:`shutil.which` can be used instead.
+
+    :note:
+        Neither this function nor :func:`shutil.which` will predict the effect of an
+        executable search on a native Windows system due to a :class:`subprocess.Popen`
+        call without ``shell=True``, because shell and non-shell executable search on
+        Windows differ considerably.
+    """
+    # From: http://stackoverflow.com/a/377028/548792
+    winprog_exts = _get_exe_extensions()
+
+    def is_exec(fpath: str) -> bool:
+        return (
+            osp.isfile(fpath)
+            and os.access(fpath, os.X_OK)
+            and (
+                sys.platform != "win32" or not winprog_exts or any(fpath.upper().endswith(ext) for ext in winprog_exts)
+            )
+        )
+
+    progs = []
+    if not path:
+        path = os.environ["PATH"]
+    for folder in str(path).split(os.pathsep):
+        folder = folder.strip('"')
+        if folder:
+            exe_path = osp.join(folder, program)
+            for f in [exe_path] + ["%s%s" % (exe_path, e) for e in winprog_exts]:
+                if is_exec(f):
+                    progs.append(f)
+    return progs
+
+
+def _cygexpath(drive: Optional[str], path: str) -> str:
+    if osp.isabs(path) and not drive:
+        # Invoked from `cygpath()` directly with `D:Apps\123`?
+        #  It's an error, leave it alone just slashes)
+        p = path  # convert to str if AnyPath given
+    else:
+        p = path and osp.normpath(osp.expandvars(osp.expanduser(path)))
+        if osp.isabs(p):
+            if drive:
+                # Confusing, maybe a remote system should expand vars.
+                p = path
+            else:
+                p = cygpath(p)
+        elif drive:
+            p = "/proc/cygdrive/%s/%s" % (drive.lower(), p)
+    p_str = str(p)  # ensure it is a str and not AnyPath
+    return p_str.replace("\\", "/")
+
+
+_cygpath_parsers: Tuple[Tuple[Pattern[str], Callable, bool], ...] = (
+    # See: https://msdn.microsoft.com/en-us/library/windows/desktop/aa365247(v=vs.85).aspx
+    # and: https://www.cygwin.com/cygwin-ug-net/using.html#unc-paths
+    (
+        re.compile(r"\\\\\?\\UNC\\([^\\]+)\\([^\\]+)(?:\\(.*))?"),
+        (lambda server, share, rest_path: "//%s/%s/%s" % (server, share, rest_path.replace("\\", "/"))),
+        False,
+    ),
+    (re.compile(r"\\\\\?\\(\w):[/\\](.*)"), (_cygexpath), False),
+    (re.compile(r"(\w):[/\\](.*)"), (_cygexpath), False),
+    (re.compile(r"file:(.*)", re.I), (lambda rest_path: rest_path), True),
+    (re.compile(r"(\w{2,}:.*)"), (lambda url: url), False),  # remote URL, do nothing
+)
+
+
+def cygpath(path: str) -> str:
+    """Use :meth:`git.cmd.Git.polish_url` instead, that works on any environment."""
+    path = str(path)  # Ensure is str and not AnyPath.
+    # Fix to use Paths when 3.5 dropped. Or to be just str if only for URLs?
+    if not path.startswith(("/cygdrive", "//", "/proc/cygdrive")):
+        for regex, parser, recurse in _cygpath_parsers:
+            match = regex.match(path)
+            if match:
+                path = parser(*match.groups())
+                if recurse:
+                    path = cygpath(path)
+                break
+        else:
+            path = _cygexpath(None, path)
+
+    return path
+
+
+_decygpath_regex = re.compile(r"(?:/proc)?/cygdrive/(\w)(/.*)?")
+
+
+def decygpath(path: PathLike) -> str:
+    path = str(path)
+    m = _decygpath_regex.match(path)
+    if m:
+        drive, rest_path = m.groups()
+        path = "%s:%s" % (drive.upper(), rest_path or "")
+
+    return path.replace("/", "\\")
+
+
+#: Store boolean flags denoting if a specific Git executable
+#: is from a Cygwin installation (since `cache_lru()` unsupported on PY2).
+_is_cygwin_cache: Dict[str, Optional[bool]] = {}
+
+
+def _is_cygwin_git(git_executable: str) -> bool:
+    is_cygwin = _is_cygwin_cache.get(git_executable)  # type: Optional[bool]
+    if is_cygwin is None:
+        is_cygwin = False
+        try:
+            git_dir = osp.dirname(git_executable)
+            if not git_dir:
+                res = py_where(git_executable)
+                git_dir = osp.dirname(res[0]) if res else ""
+
+            # Just a name given, not a real path.
+            uname_cmd = osp.join(git_dir, "uname")
+            process = subprocess.Popen([uname_cmd], stdout=subprocess.PIPE, universal_newlines=True)
+            uname_out, _ = process.communicate()
+            # retcode = process.poll()
+            is_cygwin = "CYGWIN" in uname_out
+        except Exception as ex:
+            _logger.debug("Failed checking if running in CYGWIN due to: %r", ex)
+        _is_cygwin_cache[git_executable] = is_cygwin
+
+    return is_cygwin
+
+
+@overload
+def is_cygwin_git(git_executable: None) -> Literal[False]: ...
+
+
+@overload
+def is_cygwin_git(git_executable: PathLike) -> bool: ...
+
+
+def is_cygwin_git(git_executable: Union[None, PathLike]) -> bool:
+    if sys.platform == "win32":  # TODO: See if we can use `sys.platform != "cygwin"`.
+        return False
+    elif git_executable is None:
+        return False
+    else:
+        return _is_cygwin_git(str(git_executable))
+
+
+def get_user_id() -> str:
+    """:return: String identifying the currently active system user as ``name@node``"""
+    return "%s@%s" % (getpass.getuser(), platform.node())
+
+
+def finalize_process(proc: Union[subprocess.Popen, "Git.AutoInterrupt"], **kwargs: Any) -> None:
+    """Wait for the process (clone, fetch, pull or push) and handle its errors
+    accordingly."""
+    # TODO: No close proc-streams??
+    proc.wait(**kwargs)
+
+
+@overload
+def expand_path(p: None, expand_vars: bool = ...) -> None: ...
+
+
+@overload
+def expand_path(p: PathLike, expand_vars: bool = ...) -> str:
+    # TODO: Support for Python 3.5 has been dropped, so these overloads can be improved.
+    ...
+
+
+def expand_path(p: Union[None, PathLike], expand_vars: bool = True) -> Optional[PathLike]:
+    if isinstance(p, pathlib.Path):
+        return p.resolve()
+    try:
+        p = osp.expanduser(p)  # type: ignore[arg-type]
+        if expand_vars:
+            p = osp.expandvars(p)
+        return osp.normpath(osp.abspath(p))
+    except Exception:
+        return None
+
+
+def remove_password_if_present(cmdline: Sequence[str]) -> List[str]:
+    """Parse any command line argument and if one of the elements is an URL with a
+    username and/or password, replace them by stars (in-place).
+
+    If nothing is found, this just returns the command line as-is.
+
+    This should be used for every log line that print a command line, as well as
+    exception messages.
+    """
+    new_cmdline = []
+    for index, to_parse in enumerate(cmdline):
+        new_cmdline.append(to_parse)
+        try:
+            url = urlsplit(to_parse)
+            # Remove password from the URL if present.
+            if url.password is None and url.username is None:
+                continue
+
+            if url.password is not None:
+                url = url._replace(netloc=url.netloc.replace(url.password, "*****"))
+            if url.username is not None:
+                url = url._replace(netloc=url.netloc.replace(url.username, "*****"))
+            new_cmdline[index] = urlunsplit(url)
+        except ValueError:
+            # This is not a valid URL.
+            continue
+    return new_cmdline
+
+
+# } END utilities
+
+# { Classes
+
+
+class RemoteProgress:
+    """Handler providing an interface to parse progress information emitted by
+    :manpage:`git-push(1)` and :manpage:`git-fetch(1)` and to dispatch callbacks
+    allowing subclasses to react to the progress."""
+
+    _num_op_codes: int = 9
+    (
+        BEGIN,
+        END,
+        COUNTING,
+        COMPRESSING,
+        WRITING,
+        RECEIVING,
+        RESOLVING,
+        FINDING_SOURCES,
+        CHECKING_OUT,
+    ) = [1 << x for x in range(_num_op_codes)]
+    STAGE_MASK = BEGIN | END
+    OP_MASK = ~STAGE_MASK
+
+    DONE_TOKEN = "done."
+    TOKEN_SEPARATOR = ", "
+
+    __slots__ = (
+        "_cur_line",
+        "_seen_ops",
+        "error_lines",  # Lines that started with 'error:' or 'fatal:'.
+        "other_lines",  # Lines not denoting progress (i.e.g. push-infos).
+    )
+    re_op_absolute = re.compile(r"(remote: )?([\w\s]+):\s+()(\d+)()(.*)")
+    re_op_relative = re.compile(r"(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)")
+
+    def __init__(self) -> None:
+        self._seen_ops: List[int] = []
+        self._cur_line: Optional[str] = None
+        self.error_lines: List[str] = []
+        self.other_lines: List[str] = []
+
+    def _parse_progress_line(self, line: AnyStr) -> None:
+        """Parse progress information from the given line as retrieved by
+        :manpage:`git-push(1)` or :manpage:`git-fetch(1)`.
+
+        - Lines that do not contain progress info are stored in :attr:`other_lines`.
+        - Lines that seem to contain an error (i.e. start with ``error:`` or ``fatal:``)
+          are stored in :attr:`error_lines`.
+        """
+        # handle
+        # Counting objects: 4, done.
+        # Compressing objects:  50% (1/2)
+        # Compressing objects: 100% (2/2)
+        # Compressing objects: 100% (2/2), done.
+        if isinstance(line, bytes):  # mypy argues about ternary assignment.
+            line_str = line.decode("utf-8")
+        else:
+            line_str = line
+        self._cur_line = line_str
+
+        if self._cur_line.startswith(("error:", "fatal:")):
+            self.error_lines.append(self._cur_line)
+            return
+
+        cur_count, max_count = None, None
+        match = self.re_op_relative.match(line_str)
+        if match is None:
+            match = self.re_op_absolute.match(line_str)
+
+        if not match:
+            self.line_dropped(line_str)
+            self.other_lines.append(line_str)
+            return
+        # END could not get match
+
+        op_code = 0
+        _remote, op_name, _percent, cur_count, max_count, message = match.groups()
+
+        # Get operation ID.
+        if op_name == "Counting objects":
+            op_code |= self.COUNTING
+        elif op_name == "Compressing objects":
+            op_code |= self.COMPRESSING
+        elif op_name == "Writing objects":
+            op_code |= self.WRITING
+        elif op_name == "Receiving objects":
+            op_code |= self.RECEIVING
+        elif op_name == "Resolving deltas":
+            op_code |= self.RESOLVING
+        elif op_name == "Finding sources":
+            op_code |= self.FINDING_SOURCES
+        elif op_name == "Checking out files":
+            op_code |= self.CHECKING_OUT
+        else:
+            # Note: On Windows it can happen that partial lines are sent.
+            # Hence we get something like "CompreReceiving objects", which is
+            # a blend of "Compressing objects" and "Receiving objects".
+            # This can't really be prevented, so we drop the line verbosely
+            # to make sure we get informed in case the process spits out new
+            # commands at some point.
+            self.line_dropped(line_str)
+            # Note: Don't add this line to the other lines, as we have to silently
+            # drop it.
+            return
+        # END handle op code
+
+        # Figure out stage.
+        if op_code not in self._seen_ops:
+            self._seen_ops.append(op_code)
+            op_code |= self.BEGIN
+        # END begin opcode
+
+        if message is None:
+            message = ""
+        # END message handling
+
+        message = message.strip()
+        if message.endswith(self.DONE_TOKEN):
+            op_code |= self.END
+            message = message[: -len(self.DONE_TOKEN)]
+        # END end message handling
+        message = message.strip(self.TOKEN_SEPARATOR)
+
+        self.update(
+            op_code,
+            cur_count and float(cur_count),
+            max_count and float(max_count),
+            message,
+        )
+
+    def new_message_handler(self) -> Callable[[str], None]:
+        """
+        :return:
+            A progress handler suitable for :func:`~git.cmd.handle_process_output`,
+            passing lines on to this progress handler in a suitable format.
+        """
+
+        def handler(line: AnyStr) -> None:
+            return self._parse_progress_line(line.rstrip())
+
+        # END handler
+
+        return handler
+
+    def line_dropped(self, line: str) -> None:
+        """Called whenever a line could not be understood and was therefore dropped."""
+        pass
+
+    def update(
+        self,
+        op_code: int,
+        cur_count: Union[str, float],
+        max_count: Union[str, float, None] = None,
+        message: str = "",
+    ) -> None:
+        """Called whenever the progress changes.
+
+        :param op_code:
+            Integer allowing to be compared against Operation IDs and stage IDs.
+
+            Stage IDs are :const:`BEGIN` and :const:`END`. :const:`BEGIN` will only be
+            set once for each Operation ID as well as :const:`END`. It may be that
+            :const:`BEGIN` and :const:`END` are set at once in case only one progress
+            message was emitted due to the speed of the operation. Between
+            :const:`BEGIN` and :const:`END`, none of these flags will be set.
+
+            Operation IDs are all held within the :const:`OP_MASK`. Only one Operation
+            ID will be active per call.
+
+        :param cur_count:
+            Current absolute count of items.
+
+        :param max_count:
+            The maximum count of items we expect. It may be ``None`` in case there is no
+            maximum number of items or if it is (yet) unknown.
+
+        :param message:
+            In case of the :const:`WRITING` operation, it contains the amount of bytes
+            transferred. It may possibly be used for other purposes as well.
+
+        :note:
+            You may read the contents of the current line in
+            :attr:`self._cur_line <_cur_line>`.
+        """
+        pass
+
+
+class CallableRemoteProgress(RemoteProgress):
+    """A :class:`RemoteProgress` implementation forwarding updates to any callable.
+
+    :note:
+        Like direct instances of :class:`RemoteProgress`, instances of this
+        :class:`CallableRemoteProgress` class are not themselves directly callable.
+        Rather, instances of this class wrap a callable and forward to it. This should
+        therefore not be confused with :class:`git.types.CallableProgress`.
+    """
+
+    __slots__ = ("_callable",)
+
+    def __init__(self, fn: Callable) -> None:
+        self._callable = fn
+        super().__init__()
+
+    def update(self, *args: Any, **kwargs: Any) -> None:
+        self._callable(*args, **kwargs)
+
+
+class Actor:
+    """Actors hold information about a person acting on the repository. They can be
+    committers and authors or anything with a name and an email as mentioned in the git
+    log entries."""
+
+    # PRECOMPILED REGEX
+    name_only_regex = re.compile(r"<(.*)>")
+    name_email_regex = re.compile(r"(.*) <(.*?)>")
+
+    # ENVIRONMENT VARIABLES
+    # These are read when creating new commits.
+    env_author_name = "GIT_AUTHOR_NAME"
+    env_author_email = "GIT_AUTHOR_EMAIL"
+    env_committer_name = "GIT_COMMITTER_NAME"
+    env_committer_email = "GIT_COMMITTER_EMAIL"
+
+    # CONFIGURATION KEYS
+    conf_name = "name"
+    conf_email = "email"
+
+    __slots__ = ("name", "email")
+
+    def __init__(self, name: Optional[str], email: Optional[str]) -> None:
+        self.name = name
+        self.email = email
+
+    def __eq__(self, other: Any) -> bool:
+        return self.name == other.name and self.email == other.email
+
+    def __ne__(self, other: Any) -> bool:
+        return not (self == other)
+
+    def __hash__(self) -> int:
+        return hash((self.name, self.email))
+
+    def __str__(self) -> str:
+        return self.name if self.name else ""
+
+    def __repr__(self) -> str:
+        return '<git.Actor "%s <%s>">' % (self.name, self.email)
+
+    @classmethod
+    def _from_string(cls, string: str) -> "Actor":
+        """Create an :class:`Actor` from a string.
+
+        :param string:
+            The string, which is expected to be in regular git format::
+
+                John Doe <jdoe@example.com>
+
+        :return:
+            :class:`Actor`
+        """
+        m = cls.name_email_regex.search(string)
+        if m:
+            name, email = m.groups()
+            return Actor(name, email)
+        else:
+            m = cls.name_only_regex.search(string)
+            if m:
+                return Actor(m.group(1), None)
+            # Assume the best and use the whole string as name.
+            return Actor(string, None)
+            # END special case name
+        # END handle name/email matching
+
+    @classmethod
+    def _main_actor(
+        cls,
+        env_name: str,
+        env_email: str,
+        config_reader: Union[None, "GitConfigParser", "SectionConstraint"] = None,
+    ) -> "Actor":
+        actor = Actor("", "")
+        user_id = None  # We use this to avoid multiple calls to getpass.getuser().
+
+        def default_email() -> str:
+            nonlocal user_id
+            if not user_id:
+                user_id = get_user_id()
+            return user_id
+
+        def default_name() -> str:
+            return default_email().split("@")[0]
+
+        for attr, evar, cvar, default in (
+            ("name", env_name, cls.conf_name, default_name),
+            ("email", env_email, cls.conf_email, default_email),
+        ):
+            try:
+                val = os.environ[evar]
+                setattr(actor, attr, val)
+            except KeyError:
+                if config_reader is not None:
+                    try:
+                        val = config_reader.get("user", cvar)
+                    except Exception:
+                        val = default()
+                    setattr(actor, attr, val)
+                # END config-reader handling
+                if not getattr(actor, attr):
+                    setattr(actor, attr, default())
+            # END handle name
+        # END for each item to retrieve
+        return actor
+
+    @classmethod
+    def committer(cls, config_reader: Union[None, "GitConfigParser", "SectionConstraint"] = None) -> "Actor":
+        """
+        :return:
+            :class:`Actor` instance corresponding to the configured committer. It
+            behaves similar to the git implementation, such that the environment will
+            override configuration values of `config_reader`. If no value is set at all,
+            it will be generated.
+
+        :param config_reader:
+            ConfigReader to use to retrieve the values from in case they are not set in
+            the environment.
+        """
+        return cls._main_actor(cls.env_committer_name, cls.env_committer_email, config_reader)
+
+    @classmethod
+    def author(cls, config_reader: Union[None, "GitConfigParser", "SectionConstraint"] = None) -> "Actor":
+        """Same as :meth:`committer`, but defines the main author. It may be specified
+        in the environment, but defaults to the committer."""
+        return cls._main_actor(cls.env_author_name, cls.env_author_email, config_reader)
+
+
+class Stats:
+    """Represents stat information as presented by git at the end of a merge. It is
+    created from the output of a diff operation.
+
+    Example::
+
+     c = Commit( sha1 )
+     s = c.stats
+     s.total         # full-stat-dict
+     s.files         # dict( filepath : stat-dict )
+
+    ``stat-dict``
+
+    A dictionary with the following keys and values::
+
+      deletions = number of deleted lines as int
+      insertions = number of inserted lines as int
+      lines = total number of lines changed as int, or deletions + insertions
+
+    ``full-stat-dict``
+
+    In addition to the items in the stat-dict, it features additional information::
+
+     files = number of changed files as int
+    """
+
+    __slots__ = ("total", "files")
+
+    def __init__(self, total: Total_TD, files: Dict[PathLike, Files_TD]) -> None:
+        self.total = total
+        self.files = files
+
+    @classmethod
+    def _list_from_string(cls, repo: "Repo", text: str) -> "Stats":
+        """Create a :class:`Stats` object from output retrieved by
+        :manpage:`git-diff(1)`.
+
+        :return:
+            :class:`git.Stats`
+        """
+
+        hsh: HSH_TD = {
+            "total": {"insertions": 0, "deletions": 0, "lines": 0, "files": 0},
+            "files": {},
+        }
+        for line in text.splitlines():
+            (raw_insertions, raw_deletions, filename) = line.split("\t")
+            insertions = raw_insertions != "-" and int(raw_insertions) or 0
+            deletions = raw_deletions != "-" and int(raw_deletions) or 0
+            hsh["total"]["insertions"] += insertions
+            hsh["total"]["deletions"] += deletions
+            hsh["total"]["lines"] += insertions + deletions
+            hsh["total"]["files"] += 1
+            files_dict: Files_TD = {
+                "insertions": insertions,
+                "deletions": deletions,
+                "lines": insertions + deletions,
+            }
+            hsh["files"][filename.strip()] = files_dict
+        return Stats(hsh["total"], hsh["files"])
+
+
+class IndexFileSHA1Writer:
+    """Wrapper around a file-like object that remembers the SHA1 of the data written to
+    it. It will write a sha when the stream is closed or if asked for explicitly using
+    :meth:`write_sha`.
+
+    Only useful to the index file.
+
+    :note:
+        Based on the dulwich project.
+    """
+
+    __slots__ = ("f", "sha1")
+
+    def __init__(self, f: IO) -> None:
+        self.f = f
+        self.sha1 = make_sha(b"")
+
+    def write(self, data: AnyStr) -> int:
+        self.sha1.update(data)
+        return self.f.write(data)
+
+    def write_sha(self) -> bytes:
+        sha = self.sha1.digest()
+        self.f.write(sha)
+        return sha
+
+    def close(self) -> bytes:
+        sha = self.write_sha()
+        self.f.close()
+        return sha
+
+    def tell(self) -> int:
+        return self.f.tell()
+
+
+class LockFile:
+    """Provides methods to obtain, check for, and release a file based lock which
+    should be used to handle concurrent access to the same file.
+
+    As we are a utility class to be derived from, we only use protected methods.
+
+    Locks will automatically be released on destruction.
+    """
+
+    __slots__ = ("_file_path", "_owns_lock")
+
+    def __init__(self, file_path: PathLike) -> None:
+        self._file_path = file_path
+        self._owns_lock = False
+
+    def __del__(self) -> None:
+        self._release_lock()
+
+    def _lock_file_path(self) -> str:
+        """:return: Path to lockfile"""
+        return "%s.lock" % (self._file_path)
+
+    def _has_lock(self) -> bool:
+        """
+        :return:
+            True if we have a lock and if the lockfile still exists
+
+        :raise AssertionError:
+            If our lock-file does not exist.
+        """
+        return self._owns_lock
+
+    def _obtain_lock_or_raise(self) -> None:
+        """Create a lock file as flag for other instances, mark our instance as
+        lock-holder.
+
+        :raise IOError:
+            If a lock was already present or a lock file could not be written.
+        """
+        if self._has_lock():
+            return
+        lock_file = self._lock_file_path()
+        if osp.isfile(lock_file):
+            raise IOError(
+                "Lock for file %r did already exist, delete %r in case the lock is illegal"
+                % (self._file_path, lock_file)
+            )
+
+        try:
+            with open(lock_file, mode="w"):
+                pass
+        except OSError as e:
+            raise IOError(str(e)) from e
+
+        self._owns_lock = True
+
+    def _obtain_lock(self) -> None:
+        """The default implementation will raise if a lock cannot be obtained.
+
+        Subclasses may override this method to provide a different implementation.
+        """
+        return self._obtain_lock_or_raise()
+
+    def _release_lock(self) -> None:
+        """Release our lock if we have one."""
+        if not self._has_lock():
+            return
+
+        # If someone removed our file beforehand, lets just flag this issue instead of
+        # failing, to make it more usable.
+        lfp = self._lock_file_path()
+        try:
+            rmfile(lfp)
+        except OSError:
+            pass
+        self._owns_lock = False
+
+
+class BlockingLockFile(LockFile):
+    """The lock file will block until a lock could be obtained, or fail after a
+    specified timeout.
+
+    :note:
+        If the directory containing the lock was removed, an exception will be raised
+        during the blocking period, preventing hangs as the lock can never be obtained.
+    """
+
+    __slots__ = ("_check_interval", "_max_block_time")
+
+    def __init__(
+        self,
+        file_path: PathLike,
+        check_interval_s: float = 0.3,
+        max_block_time_s: int = sys.maxsize,
+    ) -> None:
+        """Configure the instance.
+
+        :param check_interval_s:
+            Period of time to sleep until the lock is checked the next time.
+            By default, it waits a nearly unlimited time.
+
+        :param max_block_time_s:
+            Maximum amount of seconds we may lock.
+        """
+        super().__init__(file_path)
+        self._check_interval = check_interval_s
+        self._max_block_time = max_block_time_s
+
+    def _obtain_lock(self) -> None:
+        """This method blocks until it obtained the lock, or raises :exc:`IOError` if it
+        ran out of time or if the parent directory was not available anymore.
+
+        If this method returns, you are guaranteed to own the lock.
+        """
+        starttime = time.time()
+        maxtime = starttime + float(self._max_block_time)
+        while True:
+            try:
+                super()._obtain_lock()
+            except IOError as e:
+                # synity check: if the directory leading to the lockfile is not
+                # readable anymore, raise an exception
+                curtime = time.time()
+                if not osp.isdir(osp.dirname(self._lock_file_path())):
+                    msg = "Directory containing the lockfile %r was not readable anymore after waiting %g seconds" % (
+                        self._lock_file_path(),
+                        curtime - starttime,
+                    )
+                    raise IOError(msg) from e
+                # END handle missing directory
+
+                if curtime >= maxtime:
+                    msg = "Waited %g seconds for lock at %r" % (
+                        maxtime - starttime,
+                        self._lock_file_path(),
+                    )
+                    raise IOError(msg) from e
+                # END abort if we wait too long
+                time.sleep(self._check_interval)
+            else:
+                break
+        # END endless loop
+
+
+class IterableList(List[T_IterableObj]):
+    """List of iterable objects allowing to query an object by id or by named index::
+
+     heads = repo.heads
+     heads.master
+     heads['master']
+     heads[0]
+
+    Iterable parent objects:
+
+    * :class:`Commit <git.objects.Commit>`
+    * :class:`Submodule <git.objects.submodule.base.Submodule>`
+    * :class:`Reference <git.refs.reference.Reference>`
+    * :class:`FetchInfo <git.remote.FetchInfo>`
+    * :class:`PushInfo <git.remote.PushInfo>`
+
+    Iterable via inheritance:
+
+    * :class:`Head <git.refs.head.Head>`
+    * :class:`TagReference <git.refs.tag.TagReference>`
+    * :class:`RemoteReference <git.refs.remote.RemoteReference>`
+
+    This requires an ``id_attribute`` name to be set which will be queried from its
+    contained items to have a means for comparison.
+
+    A prefix can be specified which is to be used in case the id returned by the items
+    always contains a prefix that does not matter to the user, so it can be left out.
+    """
+
+    __slots__ = ("_id_attr", "_prefix")
+
+    def __new__(cls, id_attr: str, prefix: str = "") -> "IterableList[T_IterableObj]":
+        return super().__new__(cls)
+
+    def __init__(self, id_attr: str, prefix: str = "") -> None:
+        self._id_attr = id_attr
+        self._prefix = prefix
+
+    def __contains__(self, attr: object) -> bool:
+        # First try identity match for performance.
+        try:
+            rval = list.__contains__(self, attr)
+            if rval:
+                return rval
+        except (AttributeError, TypeError):
+            pass
+        # END handle match
+
+        # Otherwise make a full name search.
+        try:
+            getattr(self, cast(str, attr))  # Use cast to silence mypy.
+            return True
+        except (AttributeError, TypeError):
+            return False
+        # END handle membership
+
+    def __getattr__(self, attr: str) -> T_IterableObj:
+        attr = self._prefix + attr
+        for item in self:
+            if getattr(item, self._id_attr) == attr:
+                return item
+        # END for each item
+        return list.__getattribute__(self, attr)
+
+    def __getitem__(self, index: Union[SupportsIndex, int, slice, str]) -> T_IterableObj:  # type: ignore[override]
+        assert isinstance(index, (int, str, slice)), "Index of IterableList should be an int or str"
+
+        if isinstance(index, int):
+            return list.__getitem__(self, index)
+        elif isinstance(index, slice):
+            raise ValueError("Index should be an int or str")
+        else:
+            try:
+                return getattr(self, index)
+            except AttributeError as e:
+                raise IndexError("No item found with id %r" % (self._prefix + index)) from e
+        # END handle getattr
+
+    def __delitem__(self, index: Union[SupportsIndex, int, slice, str]) -> None:
+        assert isinstance(index, (int, str)), "Index of IterableList should be an int or str"
+
+        delindex = cast(int, index)
+        if not isinstance(index, int):
+            delindex = -1
+            name = self._prefix + index
+            for i, item in enumerate(self):
+                if getattr(item, self._id_attr) == name:
+                    delindex = i
+                    break
+                # END search index
+            # END for each item
+            if delindex == -1:
+                raise IndexError("Item with name %s not found" % name)
+            # END handle error
+        # END get index to delete
+        list.__delitem__(self, delindex)
+
+
+@runtime_checkable
+class IterableObj(Protocol):
+    """Defines an interface for iterable items, so there is a uniform way to retrieve
+    and iterate items within the git repository.
+
+    Subclasses:
+
+    * :class:`Submodule <git.objects.submodule.base.Submodule>`
+    * :class:`Commit <git.objects.Commit>`
+    * :class:`Reference <git.refs.reference.Reference>`
+    * :class:`PushInfo <git.remote.PushInfo>`
+    * :class:`FetchInfo <git.remote.FetchInfo>`
+    * :class:`Remote <git.remote.Remote>`
+    """
+
+    __slots__ = ()
+
+    _id_attribute_: str
+
+    @classmethod
+    @abstractmethod
+    def iter_items(cls, repo: "Repo", *args: Any, **kwargs: Any) -> Iterator[T_IterableObj]:
+        # Return-typed to be compatible with subtypes e.g. Remote.
+        """Find (all) items of this type.
+
+        Subclasses can specify `args` and `kwargs` differently, and may use them for
+        filtering. However, when the method is called with no additional positional or
+        keyword arguments, subclasses are obliged to to yield all items.
+
+        :return:
+            Iterator yielding Items
+        """
+        raise NotImplementedError("To be implemented by Subclass")
+
+    @classmethod
+    def list_items(cls, repo: "Repo", *args: Any, **kwargs: Any) -> IterableList[T_IterableObj]:
+        """Find (all) items of this type and collect them into a list.
+
+        For more information about the arguments, see :meth:`iter_items`.
+
+        :note:
+            Favor the :meth:`iter_items` method as it will avoid eagerly collecting all
+            items. When there are many items, that can slow performance and increase
+            memory usage.
+
+        :return:
+            list(Item,...) list of item instances
+        """
+        out_list: IterableList = IterableList(cls._id_attribute_)
+        out_list.extend(cls.iter_items(repo, *args, **kwargs))
+        return out_list
+
+
+class IterableClassWatcher(type):
+    """Metaclass that issues :exc:`DeprecationWarning` when :class:`git.util.Iterable`
+    is subclassed."""
+
+    def __init__(cls, name: str, bases: Tuple, clsdict: Dict) -> None:
+        for base in bases:
+            if type(base) is IterableClassWatcher:
+                warnings.warn(
+                    f"GitPython Iterable subclassed by {name}."
+                    " Iterable is deprecated due to naming clash since v3.1.18"
+                    " and will be removed in 4.0.0."
+                    " Use IterableObj instead.",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+
+
+class Iterable(metaclass=IterableClassWatcher):
+    """Deprecated, use :class:`IterableObj` instead.
+
+    Defines an interface for iterable items, so there is a uniform way to retrieve
+    and iterate items within the git repository.
+    """
+
+    __slots__ = ()
+
+    _id_attribute_ = "attribute that most suitably identifies your instance"
+
+    @classmethod
+    def iter_items(cls, repo: "Repo", *args: Any, **kwargs: Any) -> Any:
+        """Deprecated, use :class:`IterableObj` instead.
+
+        Find (all) items of this type.
+
+        See :meth:`IterableObj.iter_items` for details on usage.
+
+        :return:
+            Iterator yielding Items
+        """
+        raise NotImplementedError("To be implemented by Subclass")
+
+    @classmethod
+    def list_items(cls, repo: "Repo", *args: Any, **kwargs: Any) -> Any:
+        """Deprecated, use :class:`IterableObj` instead.
+
+        Find (all) items of this type and collect them into a list.
+
+        See :meth:`IterableObj.list_items` for details on usage.
+
+        :return:
+            list(Item,...) list of item instances
+        """
+        out_list: Any = IterableList(cls._id_attribute_)
+        out_list.extend(cls.iter_items(repo, *args, **kwargs))
+        return out_list
+
+
+# } END classes
diff --git a/parrot/lib/python3.10/site-packages/imageio/v2.pyi b/parrot/lib/python3.10/site-packages/imageio/v2.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..19adc32ef07c8864679a9d70578342bfd7823037
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/imageio/v2.pyi
@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+# imageio is distributed under the terms of the (new) BSD License.
+
+from typing import Dict, Literal, Union, List, overload
+
+import numpy as np
+
+from .core.imopen import imopen
+from .core import RETURN_BYTES, Array
+from .typing import ImageResource, ArrayLike
+from .core.format import Format
+
+MEMTEST_DEFAULT_MIM = "256MB"
+MEMTEST_DEFAULT_MVOL = "1GB"
+
+def to_nbytes(arg: float = None, default=None) -> float: ...
+def help(name=None) -> None: ...
+def decypher_format_arg(format_name: Union[str, None]) -> Dict[str, str]: ...
+def get_reader(
+    uri: ImageResource, format: Format = None, mode: str = "?", **kwargs
+) -> Format.Reader: ...
+def get_writer(
+    uri: ImageResource, format: Format = None, mode: str = "?", **kwargs
+) -> Format.Writer: ...
+def imread(uri: ImageResource, format: Format = None, **kwargs) -> Array: ...
+@overload
+def imwrite(
+    uri: Literal["<bytes>"], im: ArrayLike, format: Format = None, **kwargs
+) -> bytes: ...
+@overload
+def imwrite(
+    uri: ImageResource, im: ArrayLike, format: Format = None, **kwargs
+) -> None: ...
+def mimread(
+    uri: ImageResource, format: Format = None, memtest=MEMTEST_DEFAULT_MIM, **kwargs
+) -> List[Array]: ...
+@overload
+def mimwrite(
+    uri: Literal["<bytes>"], ims: List[ArrayLike], format: Format = None, **kwargs
+) -> bytes: ...
+@overload
+def mimwrite(
+    uri: ImageResource, ims: List[ArrayLike], format: Format = None, **kwargs
+) -> None: ...
+def volread(uri: ImageResource, format: Format = None, **kwargs) -> Array: ...
+@overload
+def volwrite(
+    uri: Literal["<bytes>"], im: ArrayLike, format: Format = None, **kwargs
+) -> bytes: ...
+@overload
+def volwrite(
+    uri: ImageResource, im: ArrayLike, format: Format = None, **kwargs
+) -> None: ...
+def mvolread(
+    uri: ImageResource,
+    format: Format = None,
+    memtest: float = MEMTEST_DEFAULT_MVOL,
+    **kwargs
+) -> List[Array]: ...
+@overload
+def mvolwrite(
+    uri: Literal["<bytes>"], ims: List[ArrayLike], format: Format = None, **kwargs
+) -> bytes: ...
+@overload
+def mvolwrite(
+    uri: ImageResource, ims: List[ArrayLike], format: Format = None, **kwargs
+) -> None: ...
+
+# aliases
+read = get_reader
+save = get_writer
+imsave = imwrite
+mimsave = mimwrite
+volsave = volwrite
+mvolsave = mvolwrite
diff --git a/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/__init__.cpython-310.pyc b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb25454e54aeb74add9a85b87cbdb7a8432a800c
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/__init__.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/gammazeta.cpython-310.pyc b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/gammazeta.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cea9e1397ffae9e7385e70605911a999c9485d73
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/gammazeta.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/libintmath.cpython-310.pyc b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/libintmath.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63120a7a88f4ed0500a17e777c88388777caecab
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/libintmath.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/libmpf.cpython-310.pyc b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/libmpf.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9409271a2b0a7afbc6c017fbccbc6813dbbcc5c3
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/libmpf.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/libmpi.cpython-310.pyc b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/libmpi.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ddf60857f2439e6337b0db50f2ed10fbd55ea6ea
Binary files /dev/null and b/parrot/lib/python3.10/site-packages/mpmath/libmp/__pycache__/libmpi.cpython-310.pyc differ
diff --git a/parrot/lib/python3.10/site-packages/mpmath/libmp/libelefun.py b/parrot/lib/python3.10/site-packages/mpmath/libmp/libelefun.py
new file mode 100644
index 0000000000000000000000000000000000000000..3de2e5aaef02296ed03dec3df3021b56823f3728
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/mpmath/libmp/libelefun.py
@@ -0,0 +1,1428 @@
+"""
+This module implements computation of elementary transcendental
+functions (powers, logarithms, trigonometric and hyperbolic
+functions, inverse trigonometric and hyperbolic) for real
+floating-point numbers.
+
+For complex and interval implementations of the same functions,
+see libmpc and libmpi.
+
+"""
+
+import math
+from bisect import bisect
+
+from .backend import xrange
+from .backend import MPZ, MPZ_ZERO, MPZ_ONE, MPZ_TWO, MPZ_FIVE, BACKEND
+
+from .libmpf import (
+    round_floor, round_ceiling, round_down, round_up,
+    round_nearest, round_fast,
+    ComplexResult,
+    bitcount, bctable, lshift, rshift, giant_steps, sqrt_fixed,
+    from_int, to_int, from_man_exp, to_fixed, to_float, from_float,
+    from_rational, normalize,
+    fzero, fone, fnone, fhalf, finf, fninf, fnan,
+    mpf_cmp, mpf_sign, mpf_abs,
+    mpf_pos, mpf_neg, mpf_add, mpf_sub, mpf_mul, mpf_div, mpf_shift,
+    mpf_rdiv_int, mpf_pow_int, mpf_sqrt,
+    reciprocal_rnd, negative_rnd, mpf_perturb,
+    isqrt_fast
+)
+
+from .libintmath import ifib
+
+
+#-------------------------------------------------------------------------------
+# Tuning parameters
+#-------------------------------------------------------------------------------
+
+# Cutoff for computing exp from cosh+sinh. This reduces the
+# number of terms by half, but also requires a square root which
+# is expensive with the pure-Python square root code.
+if BACKEND == 'python':
+    EXP_COSH_CUTOFF = 600
+else:
+    EXP_COSH_CUTOFF = 400
+# Cutoff for using more than 2 series
+EXP_SERIES_U_CUTOFF = 1500
+
+# Also basically determined by sqrt
+if BACKEND == 'python':
+    COS_SIN_CACHE_PREC = 400
+else:
+    COS_SIN_CACHE_PREC = 200
+COS_SIN_CACHE_STEP = 8
+cos_sin_cache = {}
+
+# Number of integer logarithms to cache (for zeta sums)
+MAX_LOG_INT_CACHE = 2000
+log_int_cache = {}
+
+LOG_TAYLOR_PREC = 2500  # Use Taylor series with caching up to this prec
+LOG_TAYLOR_SHIFT = 9    # Cache log values in steps of size 2^-N
+log_taylor_cache = {}
+# prec/size ratio of x for fastest convergence in AGM formula
+LOG_AGM_MAG_PREC_RATIO = 20
+
+ATAN_TAYLOR_PREC = 3000  # Same as for log
+ATAN_TAYLOR_SHIFT = 7   # steps of size 2^-N
+atan_taylor_cache = {}
+
+
+# ~= next power of two + 20
+cache_prec_steps = [22,22]
+for k in xrange(1, bitcount(LOG_TAYLOR_PREC)+1):
+    cache_prec_steps += [min(2**k,LOG_TAYLOR_PREC)+20] * 2**(k-1)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                   Elementary mathematical constants                        #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def constant_memo(f):
+    """
+    Decorator for caching computed values of mathematical
+    constants. This decorator should be applied to a
+    function taking a single argument prec as input and
+    returning a fixed-point value with the given precision.
+    """
+    f.memo_prec = -1
+    f.memo_val = None
+    def g(prec, **kwargs):
+        memo_prec = f.memo_prec
+        if prec <= memo_prec:
+            return f.memo_val >> (memo_prec-prec)
+        newprec = int(prec*1.05+10)
+        f.memo_val = f(newprec, **kwargs)
+        f.memo_prec = newprec
+        return f.memo_val >> (newprec-prec)
+    g.__name__ = f.__name__
+    g.__doc__ = f.__doc__
+    return g
+
+def def_mpf_constant(fixed):
+    """
+    Create a function that computes the mpf value for a mathematical
+    constant, given a function that computes the fixed-point value.
+
+    Assumptions: the constant is positive and has magnitude ~= 1;
+    the fixed-point function rounds to floor.
+    """
+    def f(prec, rnd=round_fast):
+        wp = prec + 20
+        v = fixed(wp)
+        if rnd in (round_up, round_ceiling):
+            v += 1
+        return normalize(0, v, -wp, bitcount(v), prec, rnd)
+    f.__doc__ = fixed.__doc__
+    return f
+
+def bsp_acot(q, a, b, hyperbolic):
+    if b - a == 1:
+        a1 = MPZ(2*a + 3)
+        if hyperbolic or a&1:
+            return MPZ_ONE, a1 * q**2, a1
+        else:
+            return -MPZ_ONE, a1 * q**2, a1
+    m = (a+b)//2
+    p1, q1, r1 = bsp_acot(q, a, m, hyperbolic)
+    p2, q2, r2 = bsp_acot(q, m, b, hyperbolic)
+    return q2*p1 + r1*p2, q1*q2, r1*r2
+
+# the acoth(x) series converges like the geometric series for x^2
+# N = ceil(p*log(2)/(2*log(x)))
+def acot_fixed(a, prec, hyperbolic):
+    """
+    Compute acot(a) or acoth(a) for an integer a with binary splitting; see
+    http://numbers.computation.free.fr/Constants/Algorithms/splitting.html
+    """
+    N = int(0.35 * prec/math.log(a) + 20)
+    p, q, r = bsp_acot(a, 0,N, hyperbolic)
+    return ((p+q)<<prec)//(q*a)
+
+def machin(coefs, prec, hyperbolic=False):
+    """
+    Evaluate a Machin-like formula, i.e., a linear combination of
+    acot(n) or acoth(n) for specific integer values of n, using fixed-
+    point arithmetic. The input should be a list [(c, n), ...], giving
+    c*acot[h](n) + ...
+    """
+    extraprec = 10
+    s = MPZ_ZERO
+    for a, b in coefs:
+        s += MPZ(a) * acot_fixed(MPZ(b), prec+extraprec, hyperbolic)
+    return (s >> extraprec)
+
+# Logarithms of integers are needed for various computations involving
+# logarithms, powers, radix conversion, etc
+
+@constant_memo
+def ln2_fixed(prec):
+    """
+    Computes ln(2). This is done with a hyperbolic Machin-type formula,
+    with binary splitting at high precision.
+    """
+    return machin([(18, 26), (-2, 4801), (8, 8749)], prec, True)
+
+@constant_memo
+def ln10_fixed(prec):
+    """
+    Computes ln(10). This is done with a hyperbolic Machin-type formula.
+    """
+    return machin([(46, 31), (34, 49), (20, 161)], prec, True)
+
+
+r"""
+For computation of pi, we use the Chudnovsky series:
+
+             oo
+             ___        k
+      1     \       (-1)  (6 k)! (A + B k)
+    ----- =  )     -----------------------
+    12 pi   /___               3  3k+3/2
+                    (3 k)! (k!)  C
+            k = 0
+
+where A, B, and C are certain integer constants. This series adds roughly
+14 digits per term. Note that C^(3/2) can be extracted so that the
+series contains only rational terms. This makes binary splitting very
+efficient.
+
+The recurrence formulas for the binary splitting were taken from
+ftp://ftp.gmplib.org/pub/src/gmp-chudnovsky.c
+
+Previously, Machin's formula was used at low precision and the AGM iteration
+was used at high precision. However, the Chudnovsky series is essentially as
+fast as the Machin formula at low precision and in practice about 3x faster
+than the AGM at high precision (despite theoretically having a worse
+asymptotic complexity), so there is no reason not to use it in all cases.
+
+"""
+
+# Constants in Chudnovsky's series
+CHUD_A = MPZ(13591409)
+CHUD_B = MPZ(545140134)
+CHUD_C = MPZ(640320)
+CHUD_D = MPZ(12)
+
+def bs_chudnovsky(a, b, level, verbose):
+    """
+    Computes the sum from a to b of the series in the Chudnovsky
+    formula. Returns g, p, q where p/q is the sum as an exact
+    fraction and g is a temporary value used to save work
+    for recursive calls.
+    """
+    if b-a == 1:
+        g = MPZ((6*b-5)*(2*b-1)*(6*b-1))
+        p = b**3 * CHUD_C**3 // 24
+        q = (-1)**b * g * (CHUD_A+CHUD_B*b)
+    else:
+        if verbose and level < 4:
+            print("  binary splitting", a, b)
+        mid = (a+b)//2
+        g1, p1, q1 = bs_chudnovsky(a, mid, level+1, verbose)
+        g2, p2, q2 = bs_chudnovsky(mid, b, level+1, verbose)
+        p = p1*p2
+        g = g1*g2
+        q = q1*p2 + q2*g1
+    return g, p, q
+
+@constant_memo
+def pi_fixed(prec, verbose=False, verbose_base=None):
+    """
+    Compute floor(pi * 2**prec) as a big integer.
+
+    This is done using Chudnovsky's series (see comments in
+    libelefun.py for details).
+    """
+    # The Chudnovsky series gives 14.18 digits per term
+    N = int(prec/3.3219280948/14.181647462 + 2)
+    if verbose:
+        print("binary splitting with N =", N)
+    g, p, q = bs_chudnovsky(0, N, 0, verbose)
+    sqrtC = isqrt_fast(CHUD_C<<(2*prec))
+    v = p*CHUD_C*sqrtC//((q+CHUD_A*p)*CHUD_D)
+    return v
+
+def degree_fixed(prec):
+    return pi_fixed(prec)//180
+
+def bspe(a, b):
+    """
+    Sum series for exp(1)-1 between a, b, returning the result
+    as an exact fraction (p, q).
+    """
+    if b-a == 1:
+        return MPZ_ONE, MPZ(b)
+    m = (a+b)//2
+    p1, q1 = bspe(a, m)
+    p2, q2 = bspe(m, b)
+    return p1*q2+p2, q1*q2
+
+@constant_memo
+def e_fixed(prec):
+    """
+    Computes exp(1). This is done using the ordinary Taylor series for
+    exp, with binary splitting. For a description of the algorithm,
+    see:
+
+        http://numbers.computation.free.fr/Constants/
+            Algorithms/splitting.html
+    """
+    # Slight overestimate of N needed for 1/N! < 2**(-prec)
+    # This could be tightened for large N.
+    N = int(1.1*prec/math.log(prec) + 20)
+    p, q = bspe(0,N)
+    return ((p+q)<<prec)//q
+
+@constant_memo
+def phi_fixed(prec):
+    """
+    Computes the golden ratio, (1+sqrt(5))/2
+    """
+    prec += 10
+    a = isqrt_fast(MPZ_FIVE<<(2*prec)) + (MPZ_ONE << prec)
+    return a >> 11
+
+mpf_phi    = def_mpf_constant(phi_fixed)
+mpf_pi     = def_mpf_constant(pi_fixed)
+mpf_e      = def_mpf_constant(e_fixed)
+mpf_degree = def_mpf_constant(degree_fixed)
+mpf_ln2    = def_mpf_constant(ln2_fixed)
+mpf_ln10   = def_mpf_constant(ln10_fixed)
+
+
+@constant_memo
+def ln_sqrt2pi_fixed(prec):
+    wp = prec + 10
+    # ln(sqrt(2*pi)) = ln(2*pi)/2
+    return to_fixed(mpf_log(mpf_shift(mpf_pi(wp), 1), wp), prec-1)
+
+@constant_memo
+def sqrtpi_fixed(prec):
+    return sqrt_fixed(pi_fixed(prec), prec)
+
+mpf_sqrtpi   = def_mpf_constant(sqrtpi_fixed)
+mpf_ln_sqrt2pi   = def_mpf_constant(ln_sqrt2pi_fixed)
+
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                                    Powers                                  #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+def mpf_pow(s, t, prec, rnd=round_fast):
+    """
+    Compute s**t. Raises ComplexResult if s is negative and t is
+    fractional.
+    """
+    ssign, sman, sexp, sbc = s
+    tsign, tman, texp, tbc = t
+    if ssign and texp < 0:
+        raise ComplexResult("negative number raised to a fractional power")
+    if texp >= 0:
+        return mpf_pow_int(s, (-1)**tsign * (tman<<texp), prec, rnd)
+    # s**(n/2) = sqrt(s)**n
+    if texp == -1:
+        if tman == 1:
+            if tsign:
+                return mpf_div(fone, mpf_sqrt(s, prec+10,
+                    reciprocal_rnd[rnd]), prec, rnd)
+            return mpf_sqrt(s, prec, rnd)
+        else:
+            if tsign:
+                return mpf_pow_int(mpf_sqrt(s, prec+10,
+                    reciprocal_rnd[rnd]), -tman, prec, rnd)
+            return mpf_pow_int(mpf_sqrt(s, prec+10, rnd), tman, prec, rnd)
+    # General formula: s**t = exp(t*log(s))
+    # TODO: handle rnd direction of the logarithm carefully
+    c = mpf_log(s, prec+10, rnd)
+    return mpf_exp(mpf_mul(t, c), prec, rnd)
+
+def int_pow_fixed(y, n, prec):
+    """n-th power of a fixed point number with precision prec
+
+       Returns the power in the form man, exp,
+       man * 2**exp ~= y**n
+    """
+    if n == 2:
+        return (y*y), 0
+    bc = bitcount(y)
+    exp = 0
+    workprec = 2 * (prec + 4*bitcount(n) + 4)
+    _, pm, pe, pbc = fone
+    while 1:
+        if n & 1:
+            pm = pm*y
+            pe = pe+exp
+            pbc += bc - 2
+            pbc = pbc + bctable[int(pm >> pbc)]
+            if pbc > workprec:
+                pm = pm >> (pbc-workprec)
+                pe += pbc - workprec
+                pbc = workprec
+            n -= 1
+            if not n:
+                break
+        y = y*y
+        exp = exp+exp
+        bc = bc + bc - 2
+        bc = bc + bctable[int(y >> bc)]
+        if bc > workprec:
+            y = y >> (bc-workprec)
+            exp += bc - workprec
+            bc = workprec
+        n = n // 2
+    return pm, pe
+
+# froot(s, n, prec, rnd) computes the real n-th root of a
+# positive mpf tuple s.
+# To compute the root we start from a 50-bit estimate for r
+# generated with ordinary floating-point arithmetic, and then refine
+# the value to full accuracy using the iteration
+
+#            1  /                     y       \
+#   r     = --- | (n-1)  * r   +  ----------  |
+#    n+1     n  \           n     r_n**(n-1)  /
+
+# which is simply Newton's method applied to the equation r**n = y.
+# With giant_steps(start, prec+extra) = [p0,...,pm, prec+extra]
+# and y = man * 2**-shift  one has
+# (man * 2**exp)**(1/n) =
+# y**(1/n) * 2**(start-prec/n) * 2**(p0-start) * ... * 2**(prec+extra-pm) *
+# 2**((exp+shift-(n-1)*prec)/n -extra))
+# The last factor is accounted for in the last line of froot.
+
+def nthroot_fixed(y, n, prec, exp1):
+    start = 50
+    try:
+        y1 = rshift(y, prec - n*start)
+        r = MPZ(int(y1**(1.0/n)))
+    except OverflowError:
+        y1 = from_int(y1, start)
+        fn = from_int(n)
+        fn = mpf_rdiv_int(1, fn, start)
+        r = mpf_pow(y1, fn, start)
+        r = to_int(r)
+    extra = 10
+    extra1 = n
+    prevp = start
+    for p in giant_steps(start, prec+extra):
+        pm, pe = int_pow_fixed(r, n-1, prevp)
+        r2 = rshift(pm, (n-1)*prevp - p - pe - extra1)
+        B = lshift(y, 2*p-prec+extra1)//r2
+        r = (B + (n-1) * lshift(r, p-prevp))//n
+        prevp = p
+    return r
+
+def mpf_nthroot(s, n, prec, rnd=round_fast):
+    """nth-root of a positive number
+
+    Use the Newton method when faster, otherwise use x**(1/n)
+    """
+    sign, man, exp, bc = s
+    if sign:
+        raise ComplexResult("nth root of a negative number")
+    if not man:
+        if s == fnan:
+            return fnan
+        if s == fzero:
+            if n > 0:
+                return fzero
+            if n == 0:
+                return fone
+            return finf
+        # Infinity
+        if not n:
+            return fnan
+        if n < 0:
+            return fzero
+        return finf
+    flag_inverse = False
+    if n < 2:
+        if n == 0:
+            return fone
+        if n == 1:
+            return mpf_pos(s, prec, rnd)
+        if n == -1:
+            return mpf_div(fone, s, prec, rnd)
+        # n < 0
+        rnd = reciprocal_rnd[rnd]
+        flag_inverse = True
+        extra_inverse = 5
+        prec += extra_inverse
+        n = -n
+    if n > 20 and (n >= 20000 or prec < int(233 + 28.3 * n**0.62)):
+        prec2 = prec + 10
+        fn = from_int(n)
+        nth = mpf_rdiv_int(1, fn, prec2)
+        r = mpf_pow(s, nth, prec2, rnd)
+        s = normalize(r[0], r[1], r[2], r[3], prec, rnd)
+        if flag_inverse:
+            return mpf_div(fone, s, prec-extra_inverse, rnd)
+        else:
+            return s
+    # Convert to a fixed-point number with prec2 bits.
+    prec2 = prec + 2*n - (prec%n)
+    # a few tests indicate that
+    # for 10 < n < 10**4 a bit more precision is needed
+    if n > 10:
+        prec2 += prec2//10
+        prec2 = prec2 - prec2%n
+    # Mantissa may have more bits than we need. Trim it down.
+    shift = bc - prec2
+    # Adjust exponents to make prec2 and exp+shift multiples of n.
+    sign1 = 0
+    es = exp+shift
+    if es < 0:
+        sign1 = 1
+        es = -es
+    if sign1:
+        shift += es%n
+    else:
+        shift -= es%n
+    man = rshift(man, shift)
+    extra = 10
+    exp1 = ((exp+shift-(n-1)*prec2)//n) - extra
+    rnd_shift = 0
+    if flag_inverse:
+        if rnd == 'u' or rnd == 'c':
+            rnd_shift = 1
+    else:
+        if rnd == 'd' or rnd == 'f':
+            rnd_shift = 1
+    man = nthroot_fixed(man+rnd_shift, n, prec2, exp1)
+    s = from_man_exp(man, exp1, prec, rnd)
+    if flag_inverse:
+        return mpf_div(fone, s, prec-extra_inverse, rnd)
+    else:
+        return s
+
+def mpf_cbrt(s, prec, rnd=round_fast):
+    """cubic root of a positive number"""
+    return mpf_nthroot(s, 3, prec, rnd)
+
+#----------------------------------------------------------------------------#
+#                                                                            #
+#                                Logarithms                                  #
+#                                                                            #
+#----------------------------------------------------------------------------#
+
+
+def log_int_fixed(n, prec, ln2=None):
+    """
+    Fast computation of log(n), caching the value for small n,
+    intended for zeta sums.
+    """
+    if n in log_int_cache:
+        value, vprec = log_int_cache[n]
+        if vprec >= prec:
+            return value >> (vprec - prec)
+    wp = prec + 10
+    if wp <= LOG_TAYLOR_SHIFT:
+        if ln2 is None:
+            ln2 = ln2_fixed(wp)
+        r = bitcount(n)
+        x = n << (wp-r)
+        v = log_taylor_cached(x, wp) + r*ln2
+    else:
+        v = to_fixed(mpf_log(from_int(n), wp+5), wp)
+    if n < MAX_LOG_INT_CACHE:
+        log_int_cache[n] = (v, wp)
+    return v >> (wp-prec)
+
+def agm_fixed(a, b, prec):
+    """
+    Fixed-point computation of agm(a,b), assuming
+    a, b both close to unit magnitude.
+    """
+    i = 0
+    while 1:
+        anew = (a+b)>>1
+        if i > 4 and abs(a-anew) < 8:
+            return a
+        b = isqrt_fast(a*b)
+        a = anew
+        i += 1
+    return a
+
+def log_agm(x, prec):
+    """
+    Fixed-point computation of -log(x) = log(1/x), suitable
+    for large precision. It is required that 0 < x < 1. The
+    algorithm used is the Sasaki-Kanada formula
+
+        -log(x) = pi/agm(theta2(x)^2,theta3(x)^2). [1]
+
+    For faster convergence in the theta functions, x should
+    be chosen closer to 0.
+
+    Guard bits must be added by the caller.
+
+    HYPOTHESIS: if x = 2^(-n), n bits need to be added to
+    account for the truncation to a fixed-point number,
+    and this is the only significant cancellation error.
+
+    The number of bits lost to roundoff is small and can be
+    considered constant.
+
+    [1] Richard P. Brent, "Fast Algorithms for High-Precision
+        Computation of Elementary Functions (extended abstract)",
+        http://wwwmaths.anu.edu.au/~brent/pd/RNC7-Brent.pdf
+
+    """
+    x2 = (x*x) >> prec
+    # Compute jtheta2(x)**2
+    s = a = b = x2
+    while a:
+        b = (b*x2) >> prec
+        a = (a*b) >> prec
+        s += a
+    s += (MPZ_ONE<<prec)
+    s = (s*s)>>(prec-2)
+    s = (s*isqrt_fast(x<<prec))>>prec
+    # Compute jtheta3(x)**2
+    t = a = b = x
+    while a:
+        b = (b*x2) >> prec
+        a = (a*b) >> prec
+        t += a
+    t = (MPZ_ONE<<prec) + (t<<1)
+    t = (t*t)>>prec
+    # Final formula
+    p = agm_fixed(s, t, prec)
+    return (pi_fixed(prec) << prec) // p
+
+def log_taylor(x, prec, r=0):
+    """
+    Fixed-point calculation of log(x). It is assumed that x is close
+    enough to 1 for the Taylor series to converge quickly. Convergence
+    can be improved by specifying r > 0 to compute
+    log(x^(1/2^r))*2^r, at the cost of performing r square roots.
+
+    The caller must provide sufficient guard bits.
+    """
+    for i in xrange(r):
+        x = isqrt_fast(x<<prec)
+    one = MPZ_ONE << prec
+    v = ((x-one)<<prec)//(x+one)
+    sign = v < 0
+    if sign:
+        v = -v
+    v2 = (v*v) >> prec
+    v4 = (v2*v2) >> prec
+    s0 = v
+    s1 = v//3
+    v = (v*v4) >> prec
+    k = 5
+    while v:
+        s0 += v // k
+        k += 2
+        s1 += v // k
+        v = (v*v4) >> prec
+        k += 2
+    s1 = (s1*v2) >> prec
+    s = (s0+s1) << (1+r)
+    if sign:
+        return -s
+    return s
+
+def log_taylor_cached(x, prec):
+    """
+    Fixed-point computation of log(x), assuming x in (0.5, 2)
+    and prec <= LOG_TAYLOR_PREC.
+    """
+    n = x >> (prec-LOG_TAYLOR_SHIFT)
+    cached_prec = cache_prec_steps[prec]
+    dprec = cached_prec - prec
+    if (n, cached_prec) in log_taylor_cache:
+        a, log_a = log_taylor_cache[n, cached_prec]
+    else:
+        a = n << (cached_prec - LOG_TAYLOR_SHIFT)
+        log_a = log_taylor(a, cached_prec, 8)
+        log_taylor_cache[n, cached_prec] = (a, log_a)
+    a >>= dprec
+    log_a >>= dprec
+    u = ((x - a) << prec) // a
+    v = (u << prec) // ((MPZ_TWO << prec) + u)
+    v2 = (v*v) >> prec
+    v4 = (v2*v2) >> prec
+    s0 = v
+    s1 = v//3
+    v = (v*v4) >> prec
+    k = 5
+    while v:
+        s0 += v//k
+        k += 2
+        s1 += v//k
+        v = (v*v4) >> prec
+        k += 2
+    s1 = (s1*v2) >> prec
+    s = (s0+s1) << 1
+    return log_a + s
+
+def mpf_log(x, prec, rnd=round_fast):
+    """
+    Compute the natural logarithm of the mpf value x. If x is negative,
+    ComplexResult is raised.
+    """
+    sign, man, exp, bc = x
+    #------------------------------------------------------------------
+    # Handle special values
+    if not man:
+        if x == fzero: return fninf
+        if x == finf: return finf
+        if x == fnan: return fnan
+    if sign:
+        raise ComplexResult("logarithm of a negative number")
+    wp = prec + 20
+    #------------------------------------------------------------------
+    # Handle log(2^n) = log(n)*2.
+    # Here we catch the only possible exact value, log(1) = 0
+    if man == 1:
+        if not exp:
+            return fzero
+        return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)
+    mag = exp+bc
+    abs_mag = abs(mag)
+    #------------------------------------------------------------------
+    # Handle x = 1+eps, where log(x) ~ x. We need to check for
+    # cancellation when moving to fixed-point math and compensate
+    # by increasing the precision. Note that abs_mag in (0, 1) <=>
+    # 0.5 < x < 2 and x != 1
+    if abs_mag <= 1:
+        # Calculate t = x-1 to measure distance from 1 in bits
+        tsign = 1-abs_mag
+        if tsign:
+            tman = (MPZ_ONE<<bc) - man
+        else:
+            tman = man - (MPZ_ONE<<(bc-1))
+        tbc = bitcount(tman)
+        cancellation = bc - tbc
+        if cancellation > wp:
+            t = normalize(tsign, tman, abs_mag-bc, tbc, tbc, 'n')
+            return mpf_perturb(t, tsign, prec, rnd)
+        else:
+            wp += cancellation
+        # TODO: if close enough to 1, we could use Taylor series
+        # even in the AGM precision range, since the Taylor series
+        # converges rapidly
+    #------------------------------------------------------------------
+    # Another special case:
+    # n*log(2) is a good enough approximation
+    if abs_mag > 10000:
+        if bitcount(abs_mag) > wp:
+            return from_man_exp(exp*ln2_fixed(wp), -wp, prec, rnd)
+    #------------------------------------------------------------------
+    # General case.
+    # Perform argument reduction using log(x) = log(x*2^n) - n*log(2):
+    # If we are in the Taylor precision range, choose magnitude 0 or 1.
+    # If we are in the AGM precision range, choose magnitude -m for
+    # some large m; benchmarking on one machine showed m = prec/20 to be
+    # optimal between 1000 and 100,000 digits.
+    if wp <= LOG_TAYLOR_PREC:
+        m = log_taylor_cached(lshift(man, wp-bc), wp)
+        if mag:
+            m += mag*ln2_fixed(wp)
+    else:
+        optimal_mag = -wp//LOG_AGM_MAG_PREC_RATIO
+        n = optimal_mag - mag
+        x = mpf_shift(x, n)
+        wp += (-optimal_mag)
+        m = -log_agm(to_fixed(x, wp), wp)
+        m -= n*ln2_fixed(wp)
+    return from_man_exp(m, -wp, prec, rnd)
+
+def mpf_log_hypot(a, b, prec, rnd):
+    """
+    Computes log(sqrt(a^2+b^2)) accurately.
+    """
+    # If either a or b is inf/nan/0, assume it to be a
+    if not b[1]:
+        a, b = b, a
+    # a is inf/nan/0
+    if not a[1]:
+        # both are inf/nan/0
+        if not b[1]:
+            if a == b == fzero:
+                return fninf
+            if fnan in (a, b):
+                return fnan
+            # at least one term is (+/- inf)^2
+            return finf
+        # only a is inf/nan/0
+        if a == fzero:
+            # log(sqrt(0+b^2)) = log(|b|)
+            return mpf_log(mpf_abs(b), prec, rnd)
+        if a == fnan:
+            return fnan
+        return finf
+    # Exact
+    a2 = mpf_mul(a,a)
+    b2 = mpf_mul(b,b)
+    extra = 20
+    # Not exact
+    h2 = mpf_add(a2, b2, prec+extra)
+    cancelled = mpf_add(h2, fnone, 10)
+    mag_cancelled = cancelled[2]+cancelled[3]
+    # Just redo the sum exactly if necessary (could be smarter
+    # and avoid memory allocation when a or b is precisely 1
+    # and the other is tiny...)
+    if cancelled == fzero or mag_cancelled < -extra//2:
+        h2 = mpf_add(a2, b2, prec+extra-min(a2[2],b2[2]))
+    return mpf_shift(mpf_log(h2, prec, rnd), -1)
+
+
+#----------------------------------------------------------------------
+# Inverse tangent
+#
+
+def atan_newton(x, prec):
+    if prec >= 100:
+        r = math.atan(int((x>>(prec-53)))/2.0**53)
+    else:
+        r = math.atan(int(x)/2.0**prec)
+    prevp = 50
+    r = MPZ(int(r * 2.0**53) >> (53-prevp))
+    extra_p = 50
+    for wp in giant_steps(prevp, prec):
+        wp += extra_p
+        r = r << (wp-prevp)
+        cos, sin = cos_sin_fixed(r, wp)
+        tan = (sin << wp) // cos
+        a = ((tan-rshift(x, prec-wp)) << wp) // ((MPZ_ONE<<wp) + ((tan**2)>>wp))
+        r = r - a
+        prevp = wp
+    return rshift(r, prevp-prec)
+
+def atan_taylor_get_cached(n, prec):
+    # Taylor series with caching wins up to huge precisions
+    # To avoid unnecessary precomputation at low precision, we
+    # do it in steps
+    # Round to next power of 2
+    prec2 = (1<<(bitcount(prec-1))) + 20
+    dprec = prec2 - prec
+    if (n, prec2) in atan_taylor_cache:
+        a, atan_a = atan_taylor_cache[n, prec2]
+    else:
+        a = n << (prec2 - ATAN_TAYLOR_SHIFT)
+        atan_a = atan_newton(a, prec2)
+        atan_taylor_cache[n, prec2] = (a, atan_a)
+    return (a >> dprec), (atan_a >> dprec)
+
+def atan_taylor(x, prec):
+    n = (x >> (prec-ATAN_TAYLOR_SHIFT))
+    a, atan_a = atan_taylor_get_cached(n, prec)
+    d = x - a
+    s0 = v = (d << prec) // ((a**2 >> prec) + (a*d >> prec) + (MPZ_ONE << prec))
+    v2 = (v**2 >> prec)
+    v4 = (v2 * v2) >> prec
+    s1 = v//3
+    v = (v * v4) >> prec
+    k = 5
+    while v:
+        s0 += v // k
+        k += 2
+        s1 += v // k
+        v = (v * v4) >> prec
+        k += 2
+    s1 = (s1 * v2) >> prec
+    s = s0 - s1
+    return atan_a + s
+
+def atan_inf(sign, prec, rnd):
+    if not sign:
+        return mpf_shift(mpf_pi(prec, rnd), -1)
+    return mpf_neg(mpf_shift(mpf_pi(prec, negative_rnd[rnd]), -1))
+
+def mpf_atan(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fzero: return fzero
+        if x == finf: return atan_inf(0, prec, rnd)
+        if x == fninf: return atan_inf(1, prec, rnd)
+        return fnan
+    mag = exp + bc
+    # Essentially infinity
+    if mag > prec+20:
+        return atan_inf(sign, prec, rnd)
+    # Essentially ~ x
+    if -mag > prec+20:
+        return mpf_perturb(x, 1-sign, prec, rnd)
+    wp = prec + 30 + abs(mag)
+    # For large x, use atan(x) = pi/2 - atan(1/x)
+    if mag >= 2:
+        x = mpf_rdiv_int(1, x, wp)
+        reciprocal = True
+    else:
+        reciprocal = False
+    t = to_fixed(x, wp)
+    if sign:
+        t = -t
+    if wp < ATAN_TAYLOR_PREC:
+        a = atan_taylor(t, wp)
+    else:
+        a = atan_newton(t, wp)
+    if reciprocal:
+        a = ((pi_fixed(wp)>>1)+1) - a
+    if sign:
+        a = -a
+    return from_man_exp(a, -wp, prec, rnd)
+
+# TODO: cleanup the special cases
+def mpf_atan2(y, x, prec, rnd=round_fast):
+    xsign, xman, xexp, xbc = x
+    ysign, yman, yexp, ybc = y
+    if not yman:
+        if y == fzero and x != fnan:
+            if mpf_sign(x) >= 0:
+                return fzero
+            return mpf_pi(prec, rnd)
+        if y in (finf, fninf):
+            if x in (finf, fninf):
+                return fnan
+            # pi/2
+            if y == finf:
+                return mpf_shift(mpf_pi(prec, rnd), -1)
+            # -pi/2
+            return mpf_neg(mpf_shift(mpf_pi(prec, negative_rnd[rnd]), -1))
+        return fnan
+    if ysign:
+        return mpf_neg(mpf_atan2(mpf_neg(y), x, prec, negative_rnd[rnd]))
+    if not xman:
+        if x == fnan:
+            return fnan
+        if x == finf:
+            return fzero
+        if x == fninf:
+            return mpf_pi(prec, rnd)
+        if y == fzero:
+            return fzero
+        return mpf_shift(mpf_pi(prec, rnd), -1)
+    tquo = mpf_atan(mpf_div(y, x, prec+4), prec+4)
+    if xsign:
+        return mpf_add(mpf_pi(prec+4), tquo, prec, rnd)
+    else:
+        return mpf_pos(tquo, prec, rnd)
+
+def mpf_asin(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if bc+exp > 0 and x not in (fone, fnone):
+        raise ComplexResult("asin(x) is real only for -1 <= x <= 1")
+    # asin(x) = 2*atan(x/(1+sqrt(1-x**2)))
+    wp = prec + 15
+    a = mpf_mul(x, x)
+    b = mpf_add(fone, mpf_sqrt(mpf_sub(fone, a, wp), wp), wp)
+    c = mpf_div(x, b, wp)
+    return mpf_shift(mpf_atan(c, prec, rnd), 1)
+
+def mpf_acos(x, prec, rnd=round_fast):
+    # acos(x) = 2*atan(sqrt(1-x**2)/(1+x))
+    sign, man, exp, bc = x
+    if bc + exp > 0:
+        if x not in (fone, fnone):
+            raise ComplexResult("acos(x) is real only for -1 <= x <= 1")
+        if x == fnone:
+            return mpf_pi(prec, rnd)
+    wp = prec + 15
+    a = mpf_mul(x, x)
+    b = mpf_sqrt(mpf_sub(fone, a, wp), wp)
+    c = mpf_div(b, mpf_add(fone, x, wp), wp)
+    return mpf_shift(mpf_atan(c, prec, rnd), 1)
+
+def mpf_asinh(x, prec, rnd=round_fast):
+    wp = prec + 20
+    sign, man, exp, bc = x
+    mag = exp+bc
+    if mag < -8:
+        if mag < -wp:
+            return mpf_perturb(x, 1-sign, prec, rnd)
+        wp += (-mag)
+    # asinh(x) = log(x+sqrt(x**2+1))
+    # use reflection symmetry to avoid cancellation
+    q = mpf_sqrt(mpf_add(mpf_mul(x, x), fone, wp), wp)
+    q = mpf_add(mpf_abs(x), q, wp)
+    if sign:
+        return mpf_neg(mpf_log(q, prec, negative_rnd[rnd]))
+    else:
+        return mpf_log(q, prec, rnd)
+
+def mpf_acosh(x, prec, rnd=round_fast):
+    # acosh(x) = log(x+sqrt(x**2-1))
+    wp = prec + 15
+    if mpf_cmp(x, fone) == -1:
+        raise ComplexResult("acosh(x) is real only for x >= 1")
+    q = mpf_sqrt(mpf_add(mpf_mul(x,x), fnone, wp), wp)
+    return mpf_log(mpf_add(x, q, wp), prec, rnd)
+
+def mpf_atanh(x, prec, rnd=round_fast):
+    # atanh(x) = log((1+x)/(1-x))/2
+    sign, man, exp, bc = x
+    if (not man) and exp:
+        if x in (fzero, fnan):
+            return x
+        raise ComplexResult("atanh(x) is real only for -1 <= x <= 1")
+    mag = bc + exp
+    if mag > 0:
+        if mag == 1 and man == 1:
+            return [finf, fninf][sign]
+        raise ComplexResult("atanh(x) is real only for -1 <= x <= 1")
+    wp = prec + 15
+    if mag < -8:
+        if mag < -wp:
+            return mpf_perturb(x, sign, prec, rnd)
+        wp += (-mag)
+    a = mpf_add(x, fone, wp)
+    b = mpf_sub(fone, x, wp)
+    return mpf_shift(mpf_log(mpf_div(a, b, wp), prec, rnd), -1)
+
+def mpf_fibonacci(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if not man:
+        if x == fninf:
+            return fnan
+        return x
+    # F(2^n) ~= 2^(2^n)
+    size = abs(exp+bc)
+    if exp >= 0:
+        # Exact
+        if size < 10 or size <= bitcount(prec):
+            return from_int(ifib(to_int(x)), prec, rnd)
+    # Use the modified Binet formula
+    wp = prec + size + 20
+    a = mpf_phi(wp)
+    b = mpf_add(mpf_shift(a, 1), fnone, wp)
+    u = mpf_pow(a, x, wp)
+    v = mpf_cos_pi(x, wp)
+    v = mpf_div(v, u, wp)
+    u = mpf_sub(u, v, wp)
+    u = mpf_div(u, b, prec, rnd)
+    return u
+
+
+#-------------------------------------------------------------------------------
+# Exponential-type functions
+#-------------------------------------------------------------------------------
+
+def exponential_series(x, prec, type=0):
+    """
+    Taylor series for cosh/sinh or cos/sin.
+
+    type = 0 -- returns exp(x)  (slightly faster than cosh+sinh)
+    type = 1 -- returns (cosh(x), sinh(x))
+    type = 2 -- returns (cos(x), sin(x))
+    """
+    if x < 0:
+        x = -x
+        sign = 1
+    else:
+        sign = 0
+    r = int(0.5*prec**0.5)
+    xmag = bitcount(x) - prec
+    r = max(0, xmag + r)
+    extra = 10 + 2*max(r,-xmag)
+    wp = prec + extra
+    x <<= (extra - r)
+    one = MPZ_ONE << wp
+    alt = (type == 2)
+    if prec < EXP_SERIES_U_CUTOFF:
+        x2 = a = (x*x) >> wp
+        x4 = (x2*x2) >> wp
+        s0 = s1 = MPZ_ZERO
+        k = 2
+        while a:
+            a //= (k-1)*k; s0 += a; k += 2
+            a //= (k-1)*k; s1 += a; k += 2
+            a = (a*x4) >> wp
+        s1 = (x2*s1) >> wp
+        if alt:
+            c = s1 - s0 + one
+        else:
+            c = s1 + s0 + one
+    else:
+        u = int(0.3*prec**0.35)
+        x2 = a = (x*x) >> wp
+        xpowers = [one, x2]
+        for i in xrange(1, u):
+            xpowers.append((xpowers[-1]*x2)>>wp)
+        sums = [MPZ_ZERO] * u
+        k = 2
+        while a:
+            for i in xrange(u):
+                a //= (k-1)*k
+                if alt and k & 2: sums[i] -= a
+                else:             sums[i] += a
+                k += 2
+            a = (a*xpowers[-1]) >> wp
+        for i in xrange(1, u):
+            sums[i] = (sums[i]*xpowers[i]) >> wp
+        c = sum(sums) + one
+    if type == 0:
+        s = isqrt_fast(c*c - (one<<wp))
+        if sign:
+            v = c - s
+        else:
+            v = c + s
+        for i in xrange(r):
+            v = (v*v) >> wp
+        return v >> extra
+    else:
+        # Repeatedly apply the double-angle formula
+        # cosh(2*x) = 2*cosh(x)^2 - 1
+        # cos(2*x) = 2*cos(x)^2 - 1
+        pshift = wp-1
+        for i in xrange(r):
+            c = ((c*c) >> pshift) - one
+        # With the abs, this is the same for sinh and sin
+        s = isqrt_fast(abs((one<<wp) - c*c))
+        if sign:
+            s = -s
+        return (c>>extra), (s>>extra)
+
+def exp_basecase(x, prec):
+    """
+    Compute exp(x) as a fixed-point number. Works for any x,
+    but for speed should have |x| < 1. For an arbitrary number,
+    use exp(x) = exp(x-m*log(2)) * 2^m where m = floor(x/log(2)).
+    """
+    if prec > EXP_COSH_CUTOFF:
+        return exponential_series(x, prec, 0)
+    r = int(prec**0.5)
+    prec += r
+    s0 = s1 = (MPZ_ONE << prec)
+    k = 2
+    a = x2 = (x*x) >> prec
+    while a:
+        a //= k; s0 += a; k += 1
+        a //= k; s1 += a; k += 1
+        a = (a*x2) >> prec
+    s1 = (s1*x) >> prec
+    s = s0 + s1
+    u = r
+    while r:
+        s = (s*s) >> prec
+        r -= 1
+    return s >> u
+
+def exp_expneg_basecase(x, prec):
+    """
+    Computation of exp(x), exp(-x)
+    """
+    if prec > EXP_COSH_CUTOFF:
+        cosh, sinh = exponential_series(x, prec, 1)
+        return cosh+sinh, cosh-sinh
+    a = exp_basecase(x, prec)
+    b = (MPZ_ONE << (prec+prec)) // a
+    return a, b
+
+def cos_sin_basecase(x, prec):
+    """
+    Compute cos(x), sin(x) as fixed-point numbers, assuming x
+    in [0, pi/2). For an arbitrary number, use x' = x - m*(pi/2)
+    where m = floor(x/(pi/2)) along with quarter-period symmetries.
+    """
+    if prec > COS_SIN_CACHE_PREC:
+        return exponential_series(x, prec, 2)
+    precs = prec - COS_SIN_CACHE_STEP
+    t = x >> precs
+    n = int(t)
+    if n not in cos_sin_cache:
+        w = t<<(10+COS_SIN_CACHE_PREC-COS_SIN_CACHE_STEP)
+        cos_t, sin_t = exponential_series(w, 10+COS_SIN_CACHE_PREC, 2)
+        cos_sin_cache[n] = (cos_t>>10), (sin_t>>10)
+    cos_t, sin_t = cos_sin_cache[n]
+    offset = COS_SIN_CACHE_PREC - prec
+    cos_t >>= offset
+    sin_t >>= offset
+    x -= t << precs
+    cos = MPZ_ONE << prec
+    sin = x
+    k = 2
+    a = -((x*x) >> prec)
+    while a:
+        a //= k; cos += a; k += 1; a = (a*x) >> prec
+        a //= k; sin += a; k += 1; a = -((a*x) >> prec)
+    return ((cos*cos_t-sin*sin_t) >> prec), ((sin*cos_t+cos*sin_t) >> prec)
+
+def mpf_exp(x, prec, rnd=round_fast):
+    sign, man, exp, bc = x
+    if man:
+        mag = bc + exp
+        wp = prec + 14
+        if sign:
+            man = -man
+        # TODO: the best cutoff depends on both x and the precision.
+        if prec > 600 and exp >= 0:
+            # Need about log2(exp(n)) ~= 1.45*mag extra precision
+            e = mpf_e(wp+int(1.45*mag))
+            return mpf_pow_int(e, man<<exp, prec, rnd)
+        if mag < -wp:
+            return mpf_perturb(fone, sign, prec, rnd)
+        # |x| >= 2
+        if mag > 1:
+            # For large arguments: exp(2^mag*(1+eps)) =
+            # exp(2^mag)*exp(2^mag*eps) = exp(2^mag)*(1 + 2^mag*eps + ...)
+            # so about mag extra bits is required.
+            wpmod = wp + mag
+            offset = exp + wpmod
+            if offset >= 0:
+                t = man << offset
+            else:
+                t = man >> (-offset)
+            lg2 = ln2_fixed(wpmod)
+            n, t = divmod(t, lg2)
+            n = int(n)
+            t >>= mag
+        else:
+            offset = exp + wp
+            if offset >= 0:
+                t = man << offset
+            else:
+                t = man >> (-offset)
+            n = 0
+        man = exp_basecase(t, wp)
+        return from_man_exp(man, n-wp, prec, rnd)
+    if not exp:
+        return fone
+    if x == fninf:
+        return fzero
+    return x
+
+
+def mpf_cosh_sinh(x, prec, rnd=round_fast, tanh=0):
+    """Simultaneously compute (cosh(x), sinh(x)) for real x"""
+    sign, man, exp, bc = x
+    if (not man) and exp:
+        if tanh:
+            if x == finf: return fone
+            if x == fninf: return fnone
+            return fnan
+        if x == finf: return (finf, finf)
+        if x == fninf: return (finf, fninf)
+        return fnan, fnan
+    mag = exp+bc
+    wp = prec+14
+    if mag < -4:
+        # Extremely close to 0, sinh(x) ~= x and cosh(x) ~= 1
+        if mag < -wp:
+            if tanh:
+                return mpf_perturb(x, 1-sign, prec, rnd)
+            cosh = mpf_perturb(fone, 0, prec, rnd)
+            sinh = mpf_perturb(x, sign, prec, rnd)
+            return cosh, sinh
+        # Fix for cancellation when computing sinh
+        wp += (-mag)
+    # Does exp(-2*x) vanish?
+    if mag > 10:
+        if 3*(1<<(mag-1)) > wp:
+            # XXX: rounding
+            if tanh:
+                return mpf_perturb([fone,fnone][sign], 1-sign, prec, rnd)
+            c = s = mpf_shift(mpf_exp(mpf_abs(x), prec, rnd), -1)
+            if sign:
+                s = mpf_neg(s)
+            return c, s
+    # |x| > 1
+    if mag > 1:
+        wpmod = wp + mag
+        offset = exp + wpmod
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        lg2 = ln2_fixed(wpmod)
+        n, t = divmod(t, lg2)
+        n = int(n)
+        t >>= mag
+    else:
+        offset = exp + wp
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        n = 0
+    a, b = exp_expneg_basecase(t, wp)
+    # TODO: optimize division precision
+    cosh = a + (b>>(2*n))
+    sinh = a - (b>>(2*n))
+    if sign:
+        sinh = -sinh
+    if tanh:
+        man = (sinh << wp) // cosh
+        return from_man_exp(man, -wp, prec, rnd)
+    else:
+        cosh = from_man_exp(cosh, n-wp-1, prec, rnd)
+        sinh = from_man_exp(sinh, n-wp-1, prec, rnd)
+        return cosh, sinh
+
+
+def mod_pi2(man, exp, mag, wp):
+    # Reduce to standard interval
+    if mag > 0:
+        i = 0
+        while 1:
+            cancellation_prec = 20 << i
+            wpmod = wp + mag + cancellation_prec
+            pi2 = pi_fixed(wpmod-1)
+            pi4 = pi2 >> 1
+            offset = wpmod + exp
+            if offset >= 0:
+                t = man << offset
+            else:
+                t = man >> (-offset)
+            n, y = divmod(t, pi2)
+            if y > pi4:
+                small = pi2 - y
+            else:
+                small = y
+            if small >> (wp+mag-10):
+                n = int(n)
+                t = y >> mag
+                wp = wpmod - mag
+                break
+            i += 1
+    else:
+        wp += (-mag)
+        offset = exp + wp
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        n = 0
+    return t, n, wp
+
+
+def mpf_cos_sin(x, prec, rnd=round_fast, which=0, pi=False):
+    """
+    which:
+    0 -- return cos(x), sin(x)
+    1 -- return cos(x)
+    2 -- return sin(x)
+    3 -- return tan(x)
+
+    if pi=True, compute for pi*x
+    """
+    sign, man, exp, bc = x
+    if not man:
+        if exp:
+            c, s = fnan, fnan
+        else:
+            c, s = fone, fzero
+        if which == 0: return c, s
+        if which == 1: return c
+        if which == 2: return s
+        if which == 3: return s
+
+    mag = bc + exp
+    wp = prec + 10
+
+    # Extremely small?
+    if mag < 0:
+        if mag < -wp:
+            if pi:
+                x = mpf_mul(x, mpf_pi(wp))
+            c = mpf_perturb(fone, 1, prec, rnd)
+            s = mpf_perturb(x, 1-sign, prec, rnd)
+            if which == 0: return c, s
+            if which == 1: return c
+            if which == 2: return s
+            if which == 3: return mpf_perturb(x, sign, prec, rnd)
+    if pi:
+        if exp >= -1:
+            if exp == -1:
+                c = fzero
+                s = (fone, fnone)[bool(man & 2) ^ sign]
+            elif exp == 0:
+                c, s = (fnone, fzero)
+            else:
+                c, s = (fone, fzero)
+            if which == 0: return c, s
+            if which == 1: return c
+            if which == 2: return s
+            if which == 3: return mpf_div(s, c, prec, rnd)
+        # Subtract nearest half-integer (= mod by pi/2)
+        n = ((man >> (-exp-2)) + 1) >> 1
+        man = man - (n << (-exp-1))
+        mag2 = bitcount(man) + exp
+        wp = prec + 10 - mag2
+        offset = exp + wp
+        if offset >= 0:
+            t = man << offset
+        else:
+            t = man >> (-offset)
+        t = (t*pi_fixed(wp)) >> wp
+    else:
+        t, n, wp = mod_pi2(man, exp, mag, wp)
+    c, s = cos_sin_basecase(t, wp)
+    m = n & 3
+    if   m == 1: c, s = -s, c
+    elif m == 2: c, s = -c, -s
+    elif m == 3: c, s = s, -c
+    if sign:
+        s = -s
+    if which == 0:
+        c = from_man_exp(c, -wp, prec, rnd)
+        s = from_man_exp(s, -wp, prec, rnd)
+        return c, s
+    if which == 1:
+        return from_man_exp(c, -wp, prec, rnd)
+    if which == 2:
+        return from_man_exp(s, -wp, prec, rnd)
+    if which == 3:
+        return from_rational(s, c, prec, rnd)
+
+def mpf_cos(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 1)
+def mpf_sin(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 2)
+def mpf_tan(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 3)
+def mpf_cos_sin_pi(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 0, 1)
+def mpf_cos_pi(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 1, 1)
+def mpf_sin_pi(x, prec, rnd=round_fast): return mpf_cos_sin(x, prec, rnd, 2, 1)
+def mpf_cosh(x, prec, rnd=round_fast): return mpf_cosh_sinh(x, prec, rnd)[0]
+def mpf_sinh(x, prec, rnd=round_fast): return mpf_cosh_sinh(x, prec, rnd)[1]
+def mpf_tanh(x, prec, rnd=round_fast): return mpf_cosh_sinh(x, prec, rnd, tanh=1)
+
+
+# Low-overhead fixed-point versions
+
+def cos_sin_fixed(x, prec, pi2=None):
+    if pi2 is None:
+        pi2 = pi_fixed(prec-1)
+    n, t = divmod(x, pi2)
+    n = int(n)
+    c, s = cos_sin_basecase(t, prec)
+    m = n & 3
+    if m == 0: return c, s
+    if m == 1: return -s, c
+    if m == 2: return -c, -s
+    if m == 3: return s, -c
+
+def exp_fixed(x, prec, ln2=None):
+    if ln2 is None:
+        ln2 = ln2_fixed(prec)
+    n, t = divmod(x, ln2)
+    n = int(n)
+    v = exp_basecase(t, prec)
+    if n >= 0:
+        return v << n
+    else:
+        return v >> (-n)
+
+
+if BACKEND == 'sage':
+    try:
+        import sage.libs.mpmath.ext_libmp as _lbmp
+        mpf_sqrt = _lbmp.mpf_sqrt
+        mpf_exp = _lbmp.mpf_exp
+        mpf_log = _lbmp.mpf_log
+        mpf_cos = _lbmp.mpf_cos
+        mpf_sin = _lbmp.mpf_sin
+        mpf_pow = _lbmp.mpf_pow
+        exp_fixed = _lbmp.exp_fixed
+        cos_sin_fixed = _lbmp.cos_sin_fixed
+        log_int_fixed = _lbmp.log_int_fixed
+    except (ImportError, AttributeError):
+        print("Warning: Sage imports in libelefun failed")
diff --git a/parrot/lib/python3.10/site-packages/mpmath/libmp/libintmath.py b/parrot/lib/python3.10/site-packages/mpmath/libmp/libintmath.py
new file mode 100644
index 0000000000000000000000000000000000000000..7880546e135639208d136488408b102ad41682a2
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/mpmath/libmp/libintmath.py
@@ -0,0 +1,584 @@
+"""
+Utility functions for integer math.
+
+TODO: rename, cleanup, perhaps move the gmpy wrapper code
+here from settings.py
+
+"""
+
+import math
+from bisect import bisect
+
+from .backend import xrange
+from .backend import BACKEND, gmpy, sage, sage_utils, MPZ, MPZ_ONE, MPZ_ZERO
+
+small_trailing = [0] * 256
+for j in range(1,8):
+    small_trailing[1<<j::1<<(j+1)] = [j] * (1<<(7-j))
+
+def giant_steps(start, target, n=2):
+    """
+    Return a list of integers ~=
+
+    [start, n*start, ..., target/n^2, target/n, target]
+
+    but conservatively rounded so that the quotient between two
+    successive elements is actually slightly less than n.
+
+    With n = 2, this describes suitable precision steps for a
+    quadratically convergent algorithm such as Newton's method;
+    with n = 3 steps for cubic convergence (Halley's method), etc.
+
+        >>> giant_steps(50,1000)
+        [66, 128, 253, 502, 1000]
+        >>> giant_steps(50,1000,4)
+        [65, 252, 1000]
+
+    """
+    L = [target]
+    while L[-1] > start*n:
+        L = L + [L[-1]//n + 2]
+    return L[::-1]
+
+def rshift(x, n):
+    """For an integer x, calculate x >> n with the fastest (floor)
+    rounding. Unlike the plain Python expression (x >> n), n is
+    allowed to be negative, in which case a left shift is performed."""
+    if n >= 0: return x >> n
+    else:      return x << (-n)
+
+def lshift(x, n):
+    """For an integer x, calculate x << n. Unlike the plain Python
+    expression (x << n), n is allowed to be negative, in which case a
+    right shift with default (floor) rounding is performed."""
+    if n >= 0: return x << n
+    else:      return x >> (-n)
+
+if BACKEND == 'sage':
+    import operator
+    rshift = operator.rshift
+    lshift = operator.lshift
+
+def python_trailing(n):
+    """Count the number of trailing zero bits in abs(n)."""
+    if not n:
+        return 0
+    low_byte = n & 0xff
+    if low_byte:
+        return small_trailing[low_byte]
+    t = 8
+    n >>= 8
+    while not n & 0xff:
+        n >>= 8
+        t += 8
+    return t + small_trailing[n & 0xff]
+
+if BACKEND == 'gmpy':
+    if gmpy.version() >= '2':
+        def gmpy_trailing(n):
+            """Count the number of trailing zero bits in abs(n) using gmpy."""
+            if n: return MPZ(n).bit_scan1()
+            else: return 0
+    else:
+        def gmpy_trailing(n):
+            """Count the number of trailing zero bits in abs(n) using gmpy."""
+            if n: return MPZ(n).scan1()
+            else: return 0
+
+# Small powers of 2
+powers = [1<<_ for _ in range(300)]
+
+def python_bitcount(n):
+    """Calculate bit size of the nonnegative integer n."""
+    bc = bisect(powers, n)
+    if bc != 300:
+        return bc
+    bc = int(math.log(n, 2)) - 4
+    return bc + bctable[n>>bc]
+
+def gmpy_bitcount(n):
+    """Calculate bit size of the nonnegative integer n."""
+    if n: return MPZ(n).numdigits(2)
+    else: return 0
+
+#def sage_bitcount(n):
+#    if n: return MPZ(n).nbits()
+#    else: return 0
+
+def sage_trailing(n):
+    return MPZ(n).trailing_zero_bits()
+
+if BACKEND == 'gmpy':
+    bitcount = gmpy_bitcount
+    trailing = gmpy_trailing
+elif BACKEND == 'sage':
+    sage_bitcount = sage_utils.bitcount
+    bitcount = sage_bitcount
+    trailing = sage_trailing
+else:
+    bitcount = python_bitcount
+    trailing = python_trailing
+
+if BACKEND == 'gmpy' and 'bit_length' in dir(gmpy):
+    bitcount = gmpy.bit_length
+
+# Used to avoid slow function calls as far as possible
+trailtable = [trailing(n) for n in range(256)]
+bctable = [bitcount(n) for n in range(1024)]
+
+# TODO: speed up for bases 2, 4, 8, 16, ...
+
+def bin_to_radix(x, xbits, base, bdigits):
+    """Changes radix of a fixed-point number; i.e., converts
+    x * 2**xbits to floor(x * 10**bdigits)."""
+    return x * (MPZ(base)**bdigits) >> xbits
+
+stddigits = '0123456789abcdefghijklmnopqrstuvwxyz'
+
+def small_numeral(n, base=10, digits=stddigits):
+    """Return the string numeral of a positive integer in an arbitrary
+    base. Most efficient for small input."""
+    if base == 10:
+        return str(n)
+    digs = []
+    while n:
+        n, digit = divmod(n, base)
+        digs.append(digits[digit])
+    return "".join(digs[::-1])
+
+def numeral_python(n, base=10, size=0, digits=stddigits):
+    """Represent the integer n as a string of digits in the given base.
+    Recursive division is used to make this function about 3x faster
+    than Python's str() for converting integers to decimal strings.
+
+    The 'size' parameters specifies the number of digits in n; this
+    number is only used to determine splitting points and need not be
+    exact."""
+    if n <= 0:
+        if not n:
+            return "0"
+        return "-" + numeral(-n, base, size, digits)
+    # Fast enough to do directly
+    if size < 250:
+        return small_numeral(n, base, digits)
+    # Divide in half
+    half = (size // 2) + (size & 1)
+    A, B = divmod(n, base**half)
+    ad = numeral(A, base, half, digits)
+    bd = numeral(B, base, half, digits).rjust(half, "0")
+    return ad + bd
+
+def numeral_gmpy(n, base=10, size=0, digits=stddigits):
+    """Represent the integer n as a string of digits in the given base.
+    Recursive division is used to make this function about 3x faster
+    than Python's str() for converting integers to decimal strings.
+
+    The 'size' parameters specifies the number of digits in n; this
+    number is only used to determine splitting points and need not be
+    exact."""
+    if n < 0:
+        return "-" + numeral(-n, base, size, digits)
+    # gmpy.digits() may cause a segmentation fault when trying to convert
+    # extremely large values to a string. The size limit may need to be
+    # adjusted on some platforms, but 1500000 works on Windows and Linux.
+    if size < 1500000:
+        return gmpy.digits(n, base)
+    # Divide in half
+    half = (size // 2) + (size & 1)
+    A, B = divmod(n, MPZ(base)**half)
+    ad = numeral(A, base, half, digits)
+    bd = numeral(B, base, half, digits).rjust(half, "0")
+    return ad + bd
+
+if BACKEND == "gmpy":
+    numeral = numeral_gmpy
+else:
+    numeral = numeral_python
+
+_1_800 = 1<<800
+_1_600 = 1<<600
+_1_400 = 1<<400
+_1_200 = 1<<200
+_1_100 = 1<<100
+_1_50 = 1<<50
+
+def isqrt_small_python(x):
+    """
+    Correctly (floor) rounded integer square root, using
+    division. Fast up to ~200 digits.
+    """
+    if not x:
+        return x
+    if x < _1_800:
+        # Exact with IEEE double precision arithmetic
+        if x < _1_50:
+            return int(x**0.5)
+        # Initial estimate can be any integer >= the true root; round up
+        r = int(x**0.5 * 1.00000000000001) + 1
+    else:
+        bc = bitcount(x)
+        n = bc//2
+        r = int((x>>(2*n-100))**0.5+2)<<(n-50)  # +2 is to round up
+    # The following iteration now precisely computes floor(sqrt(x))
+    # See e.g. Crandall & Pomerance, "Prime Numbers: A Computational
+    # Perspective"
+    while 1:
+        y = (r+x//r)>>1
+        if y >= r:
+            return r
+        r = y
+
+def isqrt_fast_python(x):
+    """
+    Fast approximate integer square root, computed using division-free
+    Newton iteration for large x. For random integers the result is almost
+    always correct (floor(sqrt(x))), but is 1 ulp too small with a roughly
+    0.1% probability. If x is very close to an exact square, the answer is
+    1 ulp wrong with high probability.
+
+    With 0 guard bits, the largest error over a set of 10^5 random
+    inputs of size 1-10^5 bits was 3 ulp. The use of 10 guard bits
+    almost certainly guarantees a max 1 ulp error.
+    """
+    # Use direct division-based iteration if sqrt(x) < 2^400
+    # Assume floating-point square root accurate to within 1 ulp, then:
+    # 0 Newton iterations good to 52 bits
+    # 1 Newton iterations good to 104 bits
+    # 2 Newton iterations good to 208 bits
+    # 3 Newton iterations good to 416 bits
+    if x < _1_800:
+        y = int(x**0.5)
+        if x >= _1_100:
+            y = (y + x//y) >> 1
+            if x >= _1_200:
+                y = (y + x//y) >> 1
+                if x >= _1_400:
+                    y = (y + x//y) >> 1
+        return y
+    bc = bitcount(x)
+    guard_bits = 10
+    x <<= 2*guard_bits
+    bc += 2*guard_bits
+    bc += (bc&1)
+    hbc = bc//2
+    startprec = min(50, hbc)
+    # Newton iteration for 1/sqrt(x), with floating-point starting value
+    r = int(2.0**(2*startprec) * (x >> (bc-2*startprec)) ** -0.5)
+    pp = startprec
+    for p in giant_steps(startprec, hbc):
+        # r**2, scaled from real size 2**(-bc) to 2**p
+        r2 = (r*r) >> (2*pp - p)
+        # x*r**2, scaled from real size ~1.0 to 2**p
+        xr2 = ((x >> (bc-p)) * r2) >> p
+        # New value of r, scaled from real size 2**(-bc/2) to 2**p
+        r = (r * ((3<<p) - xr2)) >> (pp+1)
+        pp = p
+    # (1/sqrt(x))*x = sqrt(x)
+    return (r*(x>>hbc)) >> (p+guard_bits)
+
+def sqrtrem_python(x):
+    """Correctly rounded integer (floor) square root with remainder."""
+    # to check cutoff:
+    # plot(lambda x: timing(isqrt, 2**int(x)), [0,2000])
+    if x < _1_600:
+        y = isqrt_small_python(x)
+        return y, x - y*y
+    y = isqrt_fast_python(x) + 1
+    rem = x - y*y
+    # Correct remainder
+    while rem < 0:
+        y -= 1
+        rem += (1+2*y)
+    else:
+        if rem:
+            while rem > 2*(1+y):
+                y += 1
+                rem -= (1+2*y)
+    return y, rem
+
+def isqrt_python(x):
+    """Integer square root with correct (floor) rounding."""
+    return sqrtrem_python(x)[0]
+
+def sqrt_fixed(x, prec):
+    return isqrt_fast(x<<prec)
+
+sqrt_fixed2 = sqrt_fixed
+
+if BACKEND == 'gmpy':
+    if gmpy.version() >= '2':
+        isqrt_small = isqrt_fast = isqrt = gmpy.isqrt
+        sqrtrem = gmpy.isqrt_rem
+    else:
+        isqrt_small = isqrt_fast = isqrt = gmpy.sqrt
+        sqrtrem = gmpy.sqrtrem
+elif BACKEND == 'sage':
+    isqrt_small = isqrt_fast = isqrt = \
+        getattr(sage_utils, "isqrt", lambda n: MPZ(n).isqrt())
+    sqrtrem = lambda n: MPZ(n).sqrtrem()
+else:
+    isqrt_small = isqrt_small_python
+    isqrt_fast = isqrt_fast_python
+    isqrt = isqrt_python
+    sqrtrem = sqrtrem_python
+
+
+def ifib(n, _cache={}):
+    """Computes the nth Fibonacci number as an integer, for
+    integer n."""
+    if n < 0:
+        return (-1)**(-n+1) * ifib(-n)
+    if n in _cache:
+        return _cache[n]
+    m = n
+    # Use Dijkstra's logarithmic algorithm
+    # The following implementation is basically equivalent to
+    # http://en.literateprograms.org/Fibonacci_numbers_(Scheme)
+    a, b, p, q = MPZ_ONE, MPZ_ZERO, MPZ_ZERO, MPZ_ONE
+    while n:
+        if n & 1:
+            aq = a*q
+            a, b = b*q+aq+a*p, b*p+aq
+            n -= 1
+        else:
+            qq = q*q
+            p, q = p*p+qq, qq+2*p*q
+            n >>= 1
+    if m < 250:
+        _cache[m] = b
+    return b
+
+MAX_FACTORIAL_CACHE = 1000
+
+def ifac(n, memo={0:1, 1:1}):
+    """Return n factorial (for integers n >= 0 only)."""
+    f = memo.get(n)
+    if f:
+        return f
+    k = len(memo)
+    p = memo[k-1]
+    MAX = MAX_FACTORIAL_CACHE
+    while k <= n:
+        p *= k
+        if k <= MAX:
+            memo[k] = p
+        k += 1
+    return p
+
+def ifac2(n, memo_pair=[{0:1}, {1:1}]):
+    """Return n!! (double factorial), integers n >= 0 only."""
+    memo = memo_pair[n&1]
+    f = memo.get(n)
+    if f:
+        return f
+    k = max(memo)
+    p = memo[k]
+    MAX = MAX_FACTORIAL_CACHE
+    while k < n:
+        k += 2
+        p *= k
+        if k <= MAX:
+            memo[k] = p
+    return p
+
+if BACKEND == 'gmpy':
+    ifac = gmpy.fac
+elif BACKEND == 'sage':
+    ifac = lambda n: int(sage.factorial(n))
+    ifib = sage.fibonacci
+
+def list_primes(n):
+    n = n + 1
+    sieve = list(xrange(n))
+    sieve[:2] = [0, 0]
+    for i in xrange(2, int(n**0.5)+1):
+        if sieve[i]:
+            for j in xrange(i**2, n, i):
+                sieve[j] = 0
+    return [p for p in sieve if p]
+
+if BACKEND == 'sage':
+    # Note: it is *VERY* important for performance that we convert
+    # the list to Python ints.
+    def list_primes(n):
+        return [int(_) for _ in sage.primes(n+1)]
+
+small_odd_primes = (3,5,7,11,13,17,19,23,29,31,37,41,43,47)
+small_odd_primes_set = set(small_odd_primes)
+
+def isprime(n):
+    """
+    Determines whether n is a prime number. A probabilistic test is
+    performed if n is very large. No special trick is used for detecting
+    perfect powers.
+
+        >>> sum(list_primes(100000))
+        454396537
+        >>> sum(n*isprime(n) for n in range(100000))
+        454396537
+
+    """
+    n = int(n)
+    if not n & 1:
+        return n == 2
+    if n < 50:
+        return n in small_odd_primes_set
+    for p in small_odd_primes:
+        if not n % p:
+            return False
+    m = n-1
+    s = trailing(m)
+    d = m >> s
+    def test(a):
+        x = pow(a,d,n)
+        if x == 1 or x == m:
+            return True
+        for r in xrange(1,s):
+            x = x**2 % n
+            if x == m:
+                return True
+        return False
+    # See http://primes.utm.edu/prove/prove2_3.html
+    if n < 1373653:
+        witnesses = [2,3]
+    elif n < 341550071728321:
+        witnesses = [2,3,5,7,11,13,17]
+    else:
+        witnesses = small_odd_primes
+    for a in witnesses:
+        if not test(a):
+            return False
+    return True
+
+def moebius(n):
+    """
+    Evaluates the Moebius function which is `mu(n) = (-1)^k` if `n`
+    is a product of `k` distinct primes and `mu(n) = 0` otherwise.
+
+    TODO: speed up using factorization
+    """
+    n = abs(int(n))
+    if n < 2:
+        return n
+    factors = []
+    for p in xrange(2, n+1):
+        if not (n % p):
+            if not (n % p**2):
+                return 0
+            if not sum(p % f for f in factors):
+                factors.append(p)
+    return (-1)**len(factors)
+
+def gcd(*args):
+    a = 0
+    for b in args:
+        if a:
+            while b:
+                a, b = b, a % b
+        else:
+            a = b
+    return a
+
+
+#  Comment by Juan Arias de Reyna:
+#
+#  I learn this method to compute EulerE[2n] from van de Lune.
+#
+#  We apply the formula   EulerE[2n] = (-1)^n 2**(-2n) sum_{j=0}^n a(2n,2j+1)
+#
+#  where the numbers a(n,j) vanish for  j > n+1 or j <= -1  and satisfies
+#
+#  a(0,-1) = a(0,0) = 0;  a(0,1)= 1; a(0,2) = a(0,3) = 0
+#
+#  a(n,j) = a(n-1,j)                              when n+j is even
+#  a(n,j) = (j-1) a(n-1,j-1) + (j+1) a(n-1,j+1)   when n+j is odd
+#
+#
+#  But we can use only one array unidimensional a(j) since to compute
+#  a(n,j) we only need to know a(n-1,k) where k and j are of different parity
+#  and we have not to conserve the used values.
+#
+#  We cached up the values of Euler numbers to sufficiently high order.
+#
+#  Important Observation: If we pretend to use the numbers
+#     EulerE[1], EulerE[2], ... , EulerE[n]
+#     it is convenient to compute first EulerE[n], since the algorithm
+#     computes first all
+#     the previous ones, and keeps them in the CACHE
+
+MAX_EULER_CACHE = 500
+
+def eulernum(m, _cache={0:MPZ_ONE}):
+    r"""
+    Computes the Euler numbers `E(n)`, which can be defined as
+    coefficients of the Taylor expansion of `1/cosh x`:
+
+    .. math ::
+
+        \frac{1}{\cosh x} = \sum_{n=0}^\infty \frac{E_n}{n!} x^n
+
+    Example::
+
+        >>> [int(eulernum(n)) for n in range(11)]
+        [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]
+        >>> [int(eulernum(n)) for n in range(11)]   # test cache
+        [1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]
+
+    """
+    # for odd m > 1, the Euler numbers are zero
+    if m & 1:
+        return MPZ_ZERO
+    f = _cache.get(m)
+    if f:
+        return f
+    MAX = MAX_EULER_CACHE
+    n = m
+    a = [MPZ(_) for _ in [0,0,1,0,0,0]]
+    for  n in range(1, m+1):
+        for j in range(n+1, -1, -2):
+            a[j+1] = (j-1)*a[j] + (j+1)*a[j+2]
+        a.append(0)
+        suma = 0
+        for k in range(n+1, -1, -2):
+            suma += a[k+1]
+            if n <= MAX:
+                _cache[n] = ((-1)**(n//2))*(suma // 2**n)
+        if n == m:
+            return ((-1)**(n//2))*suma // 2**n
+
+def stirling1(n, k):
+    """
+    Stirling number of the first kind.
+    """
+    if n < 0 or k < 0:
+        raise ValueError
+    if k >= n:
+        return MPZ(n == k)
+    if k < 1:
+        return MPZ_ZERO
+    L = [MPZ_ZERO] * (k+1)
+    L[1] = MPZ_ONE
+    for m in xrange(2, n+1):
+        for j in xrange(min(k, m), 0, -1):
+            L[j] = (m-1) * L[j] + L[j-1]
+    return (-1)**(n+k) * L[k]
+
+def stirling2(n, k):
+    """
+    Stirling number of the second kind.
+    """
+    if n < 0 or k < 0:
+        raise ValueError
+    if k >= n:
+        return MPZ(n == k)
+    if k <= 1:
+        return MPZ(k == 1)
+    s = MPZ_ZERO
+    t = MPZ_ONE
+    for j in xrange(k+1):
+        if (k + j) & 1:
+            s -= t * MPZ(j)**n
+        else:
+            s += t * MPZ(j)**n
+        t = t * (k - j) // (j + 1)
+    return s // ifac(k)
diff --git a/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/License.txt b/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/License.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b491c70e0aef319022ded661e111ddbd45b8a17f
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/License.txt
@@ -0,0 +1,1568 @@
+End User License Agreement
+--------------------------
+
+
+Preface
+-------
+
+The Software License Agreement in Chapter 1 and the Supplement
+in Chapter 2 contain license terms and conditions that govern
+the use of NVIDIA software. By accepting this agreement, you
+agree to comply with all the terms and conditions applicable
+to the product(s) included herein.
+
+
+NVIDIA Driver
+
+
+Description
+
+This package contains the operating system driver and
+fundamental system software components for NVIDIA GPUs.
+
+
+NVIDIA CUDA Toolkit
+
+
+Description
+
+The NVIDIA CUDA Toolkit provides command-line and graphical
+tools for building, debugging and optimizing the performance
+of applications accelerated by NVIDIA GPUs, runtime and math
+libraries, and documentation including programming guides,
+user manuals, and API references.
+
+
+Default Install Location of CUDA Toolkit
+
+Windows platform:
+
+%ProgramFiles%\NVIDIA GPU Computing Toolkit\CUDA\v#.#
+
+Linux platform:
+
+/usr/local/cuda-#.#
+
+Mac platform:
+
+/Developer/NVIDIA/CUDA-#.#
+
+
+NVIDIA CUDA Samples
+
+
+Description
+
+This package includes over 100+ CUDA examples that demonstrate
+various CUDA programming principles, and efficient CUDA
+implementation of algorithms in specific application domains.
+
+
+Default Install Location of CUDA Samples
+
+Windows platform:
+
+%ProgramData%\NVIDIA Corporation\CUDA Samples\v#.#
+
+Linux platform:
+
+/usr/local/cuda-#.#/samples
+
+and
+
+$HOME/NVIDIA_CUDA-#.#_Samples
+
+Mac platform:
+
+/Developer/NVIDIA/CUDA-#.#/samples
+
+
+NVIDIA Nsight Visual Studio Edition (Windows only)
+
+
+Description
+
+NVIDIA Nsight Development Platform, Visual Studio Edition is a
+development environment integrated into Microsoft Visual
+Studio that provides tools for debugging, profiling, analyzing
+and optimizing your GPU computing and graphics applications.
+
+
+Default Install Location of Nsight Visual Studio Edition
+
+Windows platform:
+
+%ProgramFiles(x86)%\NVIDIA Corporation\Nsight Visual Studio Edition #.#
+
+
+1. License Agreement for NVIDIA Software Development Kits
+---------------------------------------------------------
+
+
+Release Date: July 26, 2018
+---------------------------
+
+
+Important NoticeRead before downloading, installing,
+copying or using the licensed software:
+-------------------------------------------------------
+
+This license agreement, including exhibits attached
+("Agreement”) is a legal agreement between you and NVIDIA
+Corporation ("NVIDIA") and governs your use of a NVIDIA
+software development kit (“SDK”).
+
+Each SDK has its own set of software and materials, but here
+is a description of the types of items that may be included in
+a SDK: source code, header files, APIs, data sets and assets
+(examples include images, textures, models, scenes, videos,
+native API input/output files), binary software, sample code,
+libraries, utility programs, programming code and
+documentation.
+
+This Agreement can be accepted only by an adult of legal age
+of majority in the country in which the SDK is used.
+
+If you are entering into this Agreement on behalf of a company
+or other legal entity, you represent that you have the legal
+authority to bind the entity to this Agreement, in which case
+“you” will mean the entity you represent.
+
+If you don’t have the required age or authority to accept
+this Agreement, or if you don’t accept all the terms and
+conditions of this Agreement, do not download, install or use
+the SDK.
+
+You agree to use the SDK only for purposes that are permitted
+by (a) this Agreement, and (b) any applicable law, regulation
+or generally accepted practices or guidelines in the relevant
+jurisdictions.
+
+
+1.1. License
+
+
+1.1.1. License Grant
+
+Subject to the terms of this Agreement, NVIDIA hereby grants
+you a non-exclusive, non-transferable license, without the
+right to sublicense (except as expressly provided in this
+Agreement) to:
+
+  1. Install and use the SDK,
+
+  2. Modify and create derivative works of sample source code
+    delivered in the SDK, and
+
+  3. Distribute those portions of the SDK that are identified
+    in this Agreement as distributable, as incorporated in
+    object code format into a software application that meets
+    the distribution requirements indicated in this Agreement.
+
+
+1.1.2. Distribution Requirements
+
+These are the distribution requirements for you to exercise
+the distribution grant:
+
+  1. Your application must have material additional
+    functionality, beyond the included portions of the SDK.
+
+  2. The distributable portions of the SDK shall only be
+    accessed by your application.
+
+  3. The following notice shall be included in modifications
+    and derivative works of sample source code distributed:
+    “This software contains source code provided by NVIDIA
+    Corporation.”
+
+  4. Unless a developer tool is identified in this Agreement
+    as distributable, it is delivered for your internal use
+    only.
+
+  5. The terms under which you distribute your application
+    must be consistent with the terms of this Agreement,
+    including (without limitation) terms relating to the
+    license grant and license restrictions and protection of
+    NVIDIA’s intellectual property rights. Additionally, you
+    agree that you will protect the privacy, security and
+    legal rights of your application users.
+
+  6. You agree to notify NVIDIA in writing of any known or
+    suspected distribution or use of the SDK not in compliance
+    with the requirements of this Agreement, and to enforce
+    the terms of your agreements with respect to distributed
+    SDK.
+
+
+1.1.3. Authorized Users
+
+You may allow employees and contractors of your entity or of
+your subsidiary(ies) to access and use the SDK from your
+secure network to perform work on your behalf.
+
+If you are an academic institution you may allow users
+enrolled or employed by the academic institution to access and
+use the SDK from your secure network.
+
+You are responsible for the compliance with the terms of this
+Agreement by your authorized users. If you become aware that
+your authorized users didn’t follow the terms of this
+Agreement, you agree to take reasonable steps to resolve the
+non-compliance and prevent new occurrences.
+
+
+1.1.4. Pre-Release SDK
+
+The SDK versions identified as alpha, beta, preview or
+otherwise as pre-release, may not be fully functional, may
+contain errors or design flaws, and may have reduced or
+different security, privacy, accessibility, availability, and
+reliability standards relative to commercial versions of
+NVIDIA software and materials. Use of a pre-release SDK may
+result in unexpected results, loss of data, project delays or
+other unpredictable damage or loss.
+
+You may use a pre-release SDK at your own risk, understanding
+that pre-release SDKs are not intended for use in production
+or business-critical systems.
+
+NVIDIA may choose not to make available a commercial version
+of any pre-release SDK. NVIDIA may also choose to abandon
+development and terminate the availability of a pre-release
+SDK at any time without liability.
+
+
+1.1.5. Updates
+
+NVIDIA may, at its option, make available patches, workarounds
+or other updates to this SDK. Unless the updates are provided
+with their separate governing terms, they are deemed part of
+the SDK licensed to you as provided in this Agreement. You
+agree that the form and content of the SDK that NVIDIA
+provides may change without prior notice to you. While NVIDIA
+generally maintains compatibility between versions, NVIDIA may
+in some cases make changes that introduce incompatibilities in
+future versions of the SDK.
+
+
+1.1.6. Third Party Licenses
+
+The SDK may come bundled with, or otherwise include or be
+distributed with, third party software licensed by a NVIDIA
+supplier and/or open source software provided under an open
+source license. Use of third party software is subject to the
+third-party license terms, or in the absence of third party
+terms, the terms of this Agreement. Copyright to third party
+software is held by the copyright holders indicated in the
+third-party software or license.
+
+
+1.1.7. Reservation of Rights
+
+NVIDIA reserves all rights, title, and interest in and to the
+SDK, not expressly granted to you under this Agreement.
+
+
+1.2. Limitations
+
+The following license limitations apply to your use of the
+SDK:
+
+  1. You may not reverse engineer, decompile or disassemble,
+    or remove copyright or other proprietary notices from any
+    portion of the SDK or copies of the SDK.
+
+  2. Except as expressly provided in this Agreement, you may
+    not copy, sell, rent, sublicense, transfer, distribute,
+    modify, or create derivative works of any portion of the
+    SDK. For clarity, you may not distribute or sublicense the
+    SDK as a stand-alone product.
+
+  3. Unless you have an agreement with NVIDIA for this
+    purpose, you may not indicate that an application created
+    with the SDK is sponsored or endorsed by NVIDIA.
+
+  4. You may not bypass, disable, or circumvent any
+    encryption, security, digital rights management or
+    authentication mechanism in the SDK.
+
+  5. You may not use the SDK in any manner that would cause it
+    to become subject to an open source software license. As
+    examples, licenses that require as a condition of use,
+    modification, and/or distribution that the SDK be:
+
+      a. Disclosed or distributed in source code form;
+
+      b. Licensed for the purpose of making derivative works;
+        or
+
+      c. Redistributable at no charge.
+
+  6. Unless you have an agreement with NVIDIA for this
+    purpose, you may not use the SDK with any system or
+    application where the use or failure of the system or
+    application can reasonably be expected to threaten or
+    result in personal injury, death, or catastrophic loss.
+    Examples include use in avionics, navigation, military,
+    medical, life support or other life critical applications.
+    NVIDIA does not design, test or manufacture the SDK for
+    these critical uses and NVIDIA shall not be liable to you
+    or any third party, in whole or in part, for any claims or
+    damages arising from such uses.
+
+  7. You agree to defend, indemnify and hold harmless NVIDIA
+    and its affiliates, and their respective employees,
+    contractors, agents, officers and directors, from and
+    against any and all claims, damages, obligations, losses,
+    liabilities, costs or debt, fines, restitutions and
+    expenses (including but not limited to attorney’s fees
+    and costs incident to establishing the right of
+    indemnification) arising out of or related to your use of
+    the SDK outside of the scope of this Agreement, or not in
+    compliance with its terms.
+
+
+1.3. Ownership
+
+  1.  NVIDIA or its licensors hold all rights, title and
+    interest in and to the SDK and its modifications and
+    derivative works, including their respective intellectual
+    property rights, subject to your rights described in this
+    section. This SDK may include software and materials from
+    NVIDIA’s licensors, and these licensors are intended
+    third party beneficiaries that may enforce this Agreement
+    with respect to their intellectual property rights.
+
+  2.  You hold all rights, title and interest in and to your
+    applications and your derivative works of the sample
+    source code delivered in the SDK, including their
+    respective intellectual property rights, subject to
+    NVIDIA’s rights described in this section.
+
+  3. You may, but don’t have to, provide to NVIDIA
+    suggestions, feature requests or other feedback regarding
+    the SDK, including possible enhancements or modifications
+    to the SDK. For any feedback that you voluntarily provide,
+    you hereby grant NVIDIA and its affiliates a perpetual,
+    non-exclusive, worldwide, irrevocable license to use,
+    reproduce, modify, license, sublicense (through multiple
+    tiers of sublicensees), and distribute (through multiple
+    tiers of distributors) it without the payment of any
+    royalties or fees to you. NVIDIA will use feedback at its
+    choice. NVIDIA is constantly looking for ways to improve
+    its products, so you may send feedback to NVIDIA through
+    the developer portal at https://developer.nvidia.com.
+
+
+1.4. No Warranties
+
+THE SDK IS PROVIDED BY NVIDIA “AS IS” AND “WITH ALL
+FAULTS.” TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND
+ITS AFFILIATES EXPRESSLY DISCLAIM ALL WARRANTIES OF ANY KIND
+OR NATURE, WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING,
+BUT NOT LIMITED TO, ANY WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE, TITLE, NON-INFRINGEMENT, OR THE
+ABSENCE OF ANY DEFECTS THEREIN, WHETHER LATENT OR PATENT. NO
+WARRANTY IS MADE ON THE BASIS OF TRADE USAGE, COURSE OF
+DEALING OR COURSE OF TRADE.
+
+
+1.5. Limitation of Liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, NVIDIA AND ITS
+AFFILIATES SHALL NOT BE LIABLE FOR ANY SPECIAL, INCIDENTAL,
+PUNITIVE OR CONSEQUENTIAL DAMAGES, OR ANY LOST PROFITS, LOSS
+OF USE, LOSS OF DATA OR LOSS OF GOODWILL, OR THE COSTS OF
+PROCURING SUBSTITUTE PRODUCTS, ARISING OUT OF OR IN CONNECTION
+WITH THIS AGREEMENT OR THE USE OR PERFORMANCE OF THE SDK,
+WHETHER SUCH LIABILITY ARISES FROM ANY CLAIM BASED UPON BREACH
+OF CONTRACT, BREACH OF WARRANTY, TORT (INCLUDING NEGLIGENCE),
+PRODUCT LIABILITY OR ANY OTHER CAUSE OF ACTION OR THEORY OF
+LIABILITY. IN NO EVENT WILL NVIDIA’S AND ITS AFFILIATES
+TOTAL CUMULATIVE LIABILITY UNDER OR ARISING OUT OF THIS
+AGREEMENT EXCEED US$10.00. THE NATURE OF THE LIABILITY OR THE
+NUMBER OF CLAIMS OR SUITS SHALL NOT ENLARGE OR EXTEND THIS
+LIMIT.
+
+These exclusions and limitations of liability shall apply
+regardless if NVIDIA or its affiliates have been advised of
+the possibility of such damages, and regardless of whether a
+remedy fails its essential purpose. These exclusions and
+limitations of liability form an essential basis of the
+bargain between the parties, and, absent any of these
+exclusions or limitations of liability, the provisions of this
+Agreement, including, without limitation, the economic terms,
+would be substantially different.
+
+
+1.6. Termination
+
+  1. This Agreement will continue to apply until terminated by
+    either you or NVIDIA as described below.
+
+  2. If you want to terminate this Agreement, you may do so by
+    stopping to use the SDK.
+
+  3. NVIDIA may, at any time, terminate this Agreement if:
+
+      a. (i) you fail to comply with any term of this
+        Agreement and the non-compliance is not fixed within
+        thirty (30) days following notice from NVIDIA (or
+        immediately if you violate NVIDIA’s intellectual
+        property rights);
+
+      b. (ii) you commence or participate in any legal
+        proceeding against NVIDIA with respect to the SDK; or
+
+      c. (iii) NVIDIA decides to no longer provide the SDK in
+        a country or, in NVIDIA’s sole discretion, the
+        continued use of it is no longer commercially viable.
+
+  4. Upon any termination of this Agreement, you agree to
+    promptly discontinue use of the SDK and destroy all copies
+    in your possession or control. Your prior distributions in
+    accordance with this Agreement are not affected by the
+    termination of this Agreement. Upon written request, you
+    will certify in writing that you have complied with your
+    commitments under this section. Upon any termination of
+    this Agreement all provisions survive except for the
+    license grant provisions.
+
+
+1.7. General
+
+If you wish to assign this Agreement or your rights and
+obligations, including by merger, consolidation, dissolution
+or operation of law, contact NVIDIA to ask for permission. Any
+attempted assignment not approved by NVIDIA in writing shall
+be void and of no effect. NVIDIA may assign, delegate or
+transfer this Agreement and its rights and obligations, and if
+to a non-affiliate you will be notified.
+
+You agree to cooperate with NVIDIA and provide reasonably
+requested information to verify your compliance with this
+Agreement.
+
+This Agreement will be governed in all respects by the laws of
+the United States and of the State of Delaware as those laws
+are applied to contracts entered into and performed entirely
+within Delaware by Delaware residents, without regard to the
+conflicts of laws principles. The United Nations Convention on
+Contracts for the International Sale of Goods is specifically
+disclaimed. You agree to all terms of this Agreement in the
+English language.
+
+The state or federal courts residing in Santa Clara County,
+California shall have exclusive jurisdiction over any dispute
+or claim arising out of this Agreement. Notwithstanding this,
+you agree that NVIDIA shall still be allowed to apply for
+injunctive remedies or an equivalent type of urgent legal
+relief in any jurisdiction.
+
+If any court of competent jurisdiction determines that any
+provision of this Agreement is illegal, invalid or
+unenforceable, such provision will be construed as limited to
+the extent necessary to be consistent with and fully
+enforceable under the law and the remaining provisions will
+remain in full force and effect. Unless otherwise specified,
+remedies are cumulative.
+
+Each party acknowledges and agrees that the other is an
+independent contractor in the performance of this Agreement.
+
+The SDK has been developed entirely at private expense and is
+“commercial items” consisting of “commercial computer
+software” and “commercial computer software
+documentation” provided with RESTRICTED RIGHTS. Use,
+duplication or disclosure by the U.S. Government or a U.S.
+Government subcontractor is subject to the restrictions in
+this Agreement pursuant to DFARS 227.7202-3(a) or as set forth
+in subparagraphs (c)(1) and (2) of the Commercial Computer
+Software - Restricted Rights clause at FAR 52.227-19, as
+applicable. Contractor/manufacturer is NVIDIA, 2788 San Tomas
+Expressway, Santa Clara, CA 95051.
+
+The SDK is subject to United States export laws and
+regulations. You agree that you will not ship, transfer or
+export the SDK into any country, or use the SDK in any manner,
+prohibited by the United States Bureau of Industry and
+Security or economic sanctions regulations administered by the
+U.S. Department of Treasury’s Office of Foreign Assets
+Control (OFAC), or any applicable export laws, restrictions or
+regulations. These laws include restrictions on destinations,
+end users and end use. By accepting this Agreement, you
+confirm that you are not a resident or citizen of any country
+currently embargoed by the U.S. and that you are not otherwise
+prohibited from receiving the SDK.
+
+Any notice delivered by NVIDIA to you under this Agreement
+will be delivered via mail, email or fax. You agree that any
+notices that NVIDIA sends you electronically will satisfy any
+legal communication requirements. Please direct your legal
+notices or other correspondence to NVIDIA Corporation, 2788
+San Tomas Expressway, Santa Clara, California 95051, United
+States of America, Attention: Legal Department.
+
+This Agreement and any exhibits incorporated into this
+Agreement constitute the entire agreement of the parties with
+respect to the subject matter of this Agreement and supersede
+all prior negotiations or documentation exchanged between the
+parties relating to this SDK license. Any additional and/or
+conflicting terms on documents issued by you are null, void,
+and invalid. Any amendment or waiver under this Agreement
+shall be in writing and signed by representatives of both
+parties.
+
+
+2. CUDA Toolkit Supplement to Software License Agreement for
+NVIDIA Software Development Kits
+------------------------------------------------------------
+
+
+Release date: August 16, 2018
+-----------------------------
+
+The terms in this supplement govern your use of the NVIDIA
+CUDA Toolkit SDK under the terms of your license agreement
+(“Agreement”) as modified by this supplement. Capitalized
+terms used but not defined below have the meaning assigned to
+them in the Agreement.
+
+This supplement is an exhibit to the Agreement and is
+incorporated as an integral part of the Agreement. In the
+event of conflict between the terms in this supplement and the
+terms in the Agreement, the terms in this supplement govern.
+
+
+2.1. License Scope
+
+The SDK is licensed for you to develop applications only for
+use in systems with NVIDIA GPUs.
+
+
+2.2. Distribution
+
+The portions of the SDK that are distributable under the
+Agreement are listed in Attachment A.
+
+
+2.3. Operating Systems
+
+Those portions of the SDK designed exclusively for use on the
+Linux or FreeBSD operating systems, or other operating systems
+derived from the source code to these operating systems, may
+be copied and redistributed for use in accordance with this
+Agreement, provided that the object code files are not
+modified in any way (except for unzipping of compressed
+files).
+
+
+2.4. Audio and Video Encoders and Decoders
+
+You acknowledge and agree that it is your sole responsibility
+to obtain any additional third-party licenses required to
+make, have made, use, have used, sell, import, and offer for
+sale your products or services that include or incorporate any
+third-party software and content relating to audio and/or
+video encoders and decoders from, including but not limited
+to, Microsoft, Thomson, Fraunhofer IIS, Sisvel S.p.A.,
+MPEG-LA, and Coding Technologies. NVIDIA does not grant to you
+under this Agreement any necessary patent or other rights with
+respect to any audio and/or video encoders and decoders.
+
+
+2.5. Licensing
+
+If the distribution terms in this Agreement are not suitable
+for your organization, or for any questions regarding this
+Agreement, please contact NVIDIA at
+nvidia-compute-license-questions@nvidia.com.
+
+
+2.6. Attachment A
+
+The following portions of the SDK are distributable under the
+Agreement:
+
+Component
+
+CUDA Runtime
+
+Windows
+
+cudart.dll, cudart_static.lib, cudadevrt.lib
+
+Mac OSX
+
+libcudart.dylib, libcudart_static.a, libcudadevrt.a
+
+Linux
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Android
+
+libcudart.so, libcudart_static.a, libcudadevrt.a
+
+Component
+
+CUDA FFT Library
+
+Windows
+
+cufft.dll, cufftw.dll, cufft.lib, cufftw.lib
+
+Mac OSX
+
+libcufft.dylib, libcufft_static.a, libcufftw.dylib,
+libcufftw_static.a
+
+Linux
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Android
+
+libcufft.so, libcufft_static.a, libcufftw.so,
+libcufftw_static.a
+
+Component
+
+CUDA BLAS Library
+
+Windows
+
+cublas.dll, cublasLt.dll
+
+Mac OSX
+
+libcublas.dylib, libcublasLt.dylib, libcublas_static.a,
+libcublasLt_static.a
+
+Linux
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Android
+
+libcublas.so, libcublasLt.so, libcublas_static.a,
+libcublasLt_static.a
+
+Component
+
+NVIDIA "Drop-in" BLAS Library
+
+Windows
+
+nvblas.dll
+
+Mac OSX
+
+libnvblas.dylib
+
+Linux
+
+libnvblas.so
+
+Component
+
+CUDA Sparse Matrix Library
+
+Windows
+
+cusparse.dll, cusparse.lib
+
+Mac OSX
+
+libcusparse.dylib, libcusparse_static.a
+
+Linux
+
+libcusparse.so, libcusparse_static.a
+
+Android
+
+libcusparse.so, libcusparse_static.a
+
+Component
+
+CUDA Linear Solver Library
+
+Windows
+
+cusolver.dll, cusolver.lib
+
+Mac OSX
+
+libcusolver.dylib, libcusolver_static.a
+
+Linux
+
+libcusolver.so, libcusolver_static.a
+
+Android
+
+libcusolver.so, libcusolver_static.a
+
+Component
+
+CUDA Random Number Generation Library
+
+Windows
+
+curand.dll, curand.lib
+
+Mac OSX
+
+libcurand.dylib, libcurand_static.a
+
+Linux
+
+libcurand.so, libcurand_static.a
+
+Android
+
+libcurand.so, libcurand_static.a
+
+Component
+
+CUDA Accelerated Graph Library
+
+Component
+
+NVIDIA Performance Primitives Library
+
+Windows
+
+nppc.dll, nppc.lib, nppial.dll, nppial.lib, nppicc.dll,
+nppicc.lib, nppicom.dll, nppicom.lib, nppidei.dll,
+nppidei.lib, nppif.dll, nppif.lib, nppig.dll, nppig.lib,
+nppim.dll, nppim.lib, nppist.dll, nppist.lib, nppisu.dll,
+nppisu.lib, nppitc.dll, nppitc.lib, npps.dll, npps.lib
+
+Mac OSX
+
+libnppc.dylib, libnppc_static.a, libnppial.dylib,
+libnppial_static.a, libnppicc.dylib, libnppicc_static.a,
+libnppicom.dylib, libnppicom_static.a, libnppidei.dylib,
+libnppidei_static.a, libnppif.dylib, libnppif_static.a,
+libnppig.dylib, libnppig_static.a, libnppim.dylib,
+libnppisu_static.a, libnppitc.dylib, libnppitc_static.a,
+libnpps.dylib, libnpps_static.a
+
+Linux
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Android
+
+libnppc.so, libnppc_static.a, libnppial.so,
+libnppial_static.a, libnppicc.so, libnppicc_static.a,
+libnppicom.so, libnppicom_static.a, libnppidei.so,
+libnppidei_static.a, libnppif.so, libnppif_static.a
+libnppig.so, libnppig_static.a, libnppim.so,
+libnppim_static.a, libnppist.so, libnppist_static.a,
+libnppisu.so, libnppisu_static.a, libnppitc.so
+libnppitc_static.a, libnpps.so, libnpps_static.a
+
+Component
+
+NVIDIA JPEG Library
+
+Linux
+
+libnvjpeg.so, libnvjpeg_static.a
+
+Component
+
+Internal common library required for statically linking to
+cuBLAS, cuSPARSE, cuFFT, cuRAND, nvJPEG and NPP
+
+Mac OSX
+
+libculibos.a
+
+Linux
+
+libculibos.a
+
+Component
+
+NVIDIA Runtime Compilation Library and Header
+
+All
+
+nvrtc.h
+
+Windows
+
+nvrtc.dll, nvrtc-builtins.dll
+
+Mac OSX
+
+libnvrtc.dylib, libnvrtc-builtins.dylib
+
+Linux
+
+libnvrtc.so, libnvrtc-builtins.so
+
+Component
+
+NVIDIA Optimizing Compiler Library
+
+Windows
+
+nvvm.dll
+
+Mac OSX
+
+libnvvm.dylib
+
+Linux
+
+libnvvm.so
+
+Component
+
+NVIDIA Common Device Math Functions Library
+
+Windows
+
+libdevice.10.bc
+
+Mac OSX
+
+libdevice.10.bc
+
+Linux
+
+libdevice.10.bc
+
+Component
+
+CUDA Occupancy Calculation Header Library
+
+All
+
+cuda_occupancy.h
+
+Component
+
+CUDA Half Precision Headers
+
+All
+
+cuda_fp16.h, cuda_fp16.hpp
+
+Component
+
+CUDA Profiling Tools Interface (CUPTI) Library
+
+Windows
+
+cupti.dll
+
+Mac OSX
+
+libcupti.dylib
+
+Linux
+
+libcupti.so
+
+Component
+
+NVIDIA Tools Extension Library
+
+Windows
+
+nvToolsExt.dll, nvToolsExt.lib
+
+Mac OSX
+
+libnvToolsExt.dylib
+
+Linux
+
+libnvToolsExt.so
+
+Component
+
+NVIDIA CUDA Driver Libraries
+
+Linux
+
+libcuda.so, libnvidia-fatbinaryloader.so,
+libnvidia-ptxjitcompiler.so
+
+The NVIDIA CUDA Driver Libraries are only distributable in
+applications that meet this criteria:
+
+  1. The application was developed starting from a NVIDIA CUDA
+    container obtained from Docker Hub or the NVIDIA GPU
+    Cloud, and
+
+  2. The resulting application is packaged as a Docker
+    container and distributed to users on Docker Hub or the
+    NVIDIA GPU Cloud only.
+
+
+2.7. Attachment B
+
+
+Additional Licensing Obligations
+
+The following third party components included in the SOFTWARE
+are licensed to Licensee pursuant to the following terms and
+conditions:
+
+  1. Licensee's use of the GDB third party component is
+    subject to the terms and conditions of GNU GPL v3:
+
+    This product includes copyrighted third-party software licensed
+    under the terms of the GNU General Public License v3 ("GPL v3").
+    All third-party software packages are copyright by their respective
+    authors. GPL v3 terms and conditions are hereby incorporated into
+    the Agreement by this reference:     http://www.gnu.org/licenses/gpl.txt
+
+    Consistent with these licensing requirements, the software
+    listed below is provided under the terms of the specified
+    open source software licenses. To obtain source code for
+    software provided under licenses that require
+    redistribution of source code, including the GNU General
+    Public License (GPL) and GNU Lesser General Public License
+    (LGPL), contact oss-requests@nvidia.com. This offer is
+    valid for a period of three (3) years from the date of the
+    distribution of this product by NVIDIA CORPORATION.
+
+    Component          License
+    CUDA-GDB           GPL v3
+
+  2. Licensee represents and warrants that any and all third
+    party licensing and/or royalty payment obligations in
+    connection with Licensee's use of the H.264 video codecs
+    are solely the responsibility of Licensee.
+
+  3. Licensee's use of the Thrust library is subject to the
+    terms and conditions of the Apache License Version 2.0.
+    All third-party software packages are copyright by their
+    respective authors. Apache License Version 2.0 terms and
+    conditions are hereby incorporated into the Agreement by
+    this reference.
+    http://www.apache.org/licenses/LICENSE-2.0.html
+
+    In addition, Licensee acknowledges the following notice:
+    Thrust includes source code from the Boost Iterator,
+    Tuple, System, and Random Number libraries.
+
+    Boost Software License - Version 1.0 - August 17th, 2003
+    . . . .
+
+    Permission is hereby granted, free of charge, to any person or
+    organization obtaining a copy of the software and accompanying
+    documentation covered by this license (the "Software") to use,
+    reproduce, display, distribute, execute, and transmit the Software,
+    and to prepare derivative works of the Software, and to permit
+    third-parties to whom the Software is furnished to do so, all
+    subject to the following:
+
+    The copyright notices in the Software and this entire statement,
+    including the above license grant, this restriction and the following
+    disclaimer, must be included in all copies of the Software, in whole
+    or in part, and all derivative works of the Software, unless such
+    copies or derivative works are solely in the form of machine-executable
+    object code generated by a source language processor.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+    NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+    ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
+    OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+    OTHER DEALINGS IN THE SOFTWARE.
+
+  4. Licensee's use of the LLVM third party component is
+    subject to the following terms and conditions:
+
+    ======================================================
+    LLVM Release License
+    ======================================================
+    University of Illinois/NCSA
+    Open Source License
+
+    Copyright (c) 2003-2010 University of Illinois at Urbana-Champaign.
+    All rights reserved.
+
+    Developed by:
+
+        LLVM Team
+
+        University of Illinois at Urbana-Champaign
+
+        http://llvm.org
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to
+    deal with the Software without restriction, including without limitation the
+    rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+    sell copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    *  Redistributions of source code must retain the above copyright notice,
+       this list of conditions and the following disclaimers.
+
+    *  Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimers in the
+       documentation and/or other materials provided with the distribution.
+
+    *  Neither the names of the LLVM Team, University of Illinois at Urbana-
+       Champaign, nor the names of its contributors may be used to endorse or
+       promote products derived from this Software without specific prior
+       written permission.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+    THE CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+    OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+    ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+    DEALINGS WITH THE SOFTWARE.
+
+  5. Licensee's use (e.g. nvprof) of the PCRE third party
+    component is subject to the following terms and
+    conditions:
+
+    ------------
+    PCRE LICENCE
+    ------------
+    PCRE is a library of functions to support regular expressions whose syntax
+    and semantics are as close as possible to those of the Perl 5 language.
+    Release 8 of PCRE is distributed under the terms of the "BSD" licence, as
+    specified below. The documentation for PCRE, supplied in the "doc"
+    directory, is distributed under the same terms as the software itself. The
+    basic library functions are written in C and are freestanding. Also
+    included in the distribution is a set of C++ wrapper functions, and a just-
+    in-time compiler that can be used to optimize pattern matching. These are
+    both optional features that can be omitted when the library is built.
+
+    THE BASIC LIBRARY FUNCTIONS
+    ---------------------------
+    Written by:       Philip Hazel
+    Email local part: ph10
+    Email domain:     cam.ac.uk
+    University of Cambridge Computing Service,
+    Cambridge, England.
+    Copyright (c) 1997-2012 University of Cambridge
+    All rights reserved.
+
+    PCRE JUST-IN-TIME COMPILATION SUPPORT
+    -------------------------------------
+    Written by:       Zoltan Herczeg
+    Email local part: hzmester
+    Emain domain:     freemail.hu
+    Copyright(c) 2010-2012 Zoltan Herczeg
+    All rights reserved.
+
+    STACK-LESS JUST-IN-TIME COMPILER
+    --------------------------------
+    Written by:       Zoltan Herczeg
+    Email local part: hzmester
+    Emain domain:     freemail.hu
+    Copyright(c) 2009-2012 Zoltan Herczeg
+    All rights reserved.
+
+    THE C++ WRAPPER FUNCTIONS
+    -------------------------
+    Contributed by:   Google Inc.
+    Copyright (c) 2007-2012, Google Inc.
+    All rights reserved.
+
+    THE "BSD" LICENCE
+    -----------------
+    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 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.
+
+      * Neither the name of the University of Cambridge nor the name of Google
+        Inc. nor the names of their contributors may be used to endorse or
+        promote products derived from this software without specific prior
+        written permission.
+
+    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 OWNER 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.
+
+  6. Some of the cuBLAS library routines were written by or
+    derived from code written by Vasily Volkov and are subject
+    to the Modified Berkeley Software Distribution License as
+    follows:
+
+    Copyright (c) 2007-2009, Regents of the University of California
+
+    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 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.
+        * Neither the name of the University of California, Berkeley nor
+          the names of its contributors may 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.
+
+  7. Some of the cuBLAS library routines were written by or
+    derived from code written by Davide Barbieri and are
+    subject to the Modified Berkeley Software Distribution
+    License as follows:
+
+    Copyright (c) 2008-2009 Davide Barbieri @ University of Rome Tor Vergata.
+
+    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 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.
+        * 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.
+
+  8. Some of the cuBLAS library routines were derived from
+    code developed by the University of Tennessee and are
+    subject to the Modified Berkeley Software Distribution
+    License as follows:
+
+    Copyright (c) 2010 The University of Tennessee.
+
+    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 binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimer listed in this license in the documentation and/or
+          other materials provided with the distribution.
+        * Neither the name of the copyright holders nor the names of its
+          contributors may be used to endorse or promote products derived
+          from this software without specific prior written permission.
+
+    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
+    OWNER 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.
+
+  9. Some of the cuBLAS library routines were written by or
+    derived from code written by Jonathan Hogg and are subject
+    to the Modified Berkeley Software Distribution License as
+    follows:
+
+    Copyright (c) 2012, The Science and Technology Facilities Council (STFC).
+
+    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 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.
+        * Neither the name of the STFC nor the names of its contributors
+          may be used to endorse or promote products derived from this
+          software without specific prior written permission.
+
+    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 STFC 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.
+
+  10. Some of the cuBLAS library routines were written by or
+    derived from code written by Ahmad M. Abdelfattah, David
+    Keyes, and Hatem Ltaief, and are subject to the Apache
+    License, Version 2.0, as follows:
+
+     -- (C) Copyright 2013 King Abdullah University of Science and Technology
+      Authors:
+      Ahmad Abdelfattah (ahmad.ahmad@kaust.edu.sa)
+      David Keyes (david.keyes@kaust.edu.sa)
+      Hatem Ltaief (hatem.ltaief@kaust.edu.sa)
+
+      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  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.
+      * Neither  the  name of the King Abdullah University of Science and
+        Technology nor the names of its contributors may be used to endorse
+        or promote products derived from this software without specific prior
+        written permission.
+
+      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
+
+  11. Some of the cuSPARSE library routines were written by or
+    derived from code written by Li-Wen Chang and are subject
+    to the NCSA Open Source License as follows:
+
+    Copyright (c) 2012, University of Illinois.
+
+    All rights reserved.
+
+    Developed by: IMPACT Group, University of Illinois, http://impact.crhc.illinois.edu
+
+    Permission is hereby granted, free of charge, to any person obtaining
+    a copy of this software and associated documentation files (the
+    "Software"), to deal with the Software without restriction, including
+    without limitation the rights to use, copy, modify, merge, publish,
+    distribute, sublicense, and/or sell copies of the Software, and to
+    permit persons to whom the Software is furnished to do so, subject to
+    the following conditions:
+        * Redistributions of source code must retain the above copyright
+          notice, this list of conditions and the following disclaimer.
+        * Redistributions in binary form must reproduce the above
+          copyright notice, this list of conditions and the following
+          disclaimers in the documentation and/or other materials provided
+          with the distribution.
+        * Neither the names of IMPACT Group, University of Illinois, nor
+          the names of its contributors may be used to endorse or promote
+          products derived from this Software without specific prior
+          written permission.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+    NONINFRINGEMENT. IN NO EVENT SHALL THE CONTRIBUTORS OR COPYRIGHT
+    HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+    IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+    IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+    SOFTWARE.
+
+  12. Some of the cuRAND library routines were written by or
+    derived from code written by Mutsuo Saito and Makoto
+    Matsumoto and are subject to the following license:
+
+    Copyright (c) 2009, 2010 Mutsuo Saito, Makoto Matsumoto and Hiroshima
+    University. All rights reserved.
+
+    Copyright (c) 2011 Mutsuo Saito, Makoto Matsumoto, Hiroshima
+    University and University of Tokyo.  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 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.
+        * Neither the name of the Hiroshima University nor the names of
+          its contributors may be used to endorse or promote products
+          derived from this software without specific prior written
+          permission.
+
+    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
+    OWNER 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.
+
+  13. Some of the cuRAND library routines were derived from
+    code developed by D. E. Shaw Research and are subject to
+    the following license:
+
+    Copyright 2010-2011, D. E. Shaw Research.
+
+    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 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.
+        * Neither the name of D. E. Shaw Research nor the names of its
+          contributors may be used to endorse or promote products derived
+          from this software without specific prior written permission.
+
+    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
+    OWNER 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.
+
+  14. Some of the Math library routines were written by or
+    derived from code developed by Norbert Juffa and are
+    subject to the following license:
+
+    Copyright (c) 2015-2017, Norbert Juffa
+    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.
+
+    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
+    HOLDER 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.
+
+  15. Licensee's use of the lz4 third party component is
+    subject to the following terms and conditions:
+
+    Copyright (C) 2011-2013, Yann Collet.
+    BSD 2-Clause License (http://www.opensource.org/licenses/bsd-license.php)
+
+    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 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.
+
+    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
+    OWNER 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.
+
+  16. The NPP library uses code from the Boost Math Toolkit,
+    and is subject to the following license:
+
+    Boost Software License - Version 1.0 - August 17th, 2003
+    . . . .
+
+    Permission is hereby granted, free of charge, to any person or
+    organization obtaining a copy of the software and accompanying
+    documentation covered by this license (the "Software") to use,
+    reproduce, display, distribute, execute, and transmit the Software,
+    and to prepare derivative works of the Software, and to permit
+    third-parties to whom the Software is furnished to do so, all
+    subject to the following:
+
+    The copyright notices in the Software and this entire statement,
+    including the above license grant, this restriction and the following
+    disclaimer, must be included in all copies of the Software, in whole
+    or in part, and all derivative works of the Software, unless such
+    copies or derivative works are solely in the form of machine-executable
+    object code generated by a source language processor.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+    EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+    NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+    ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR
+    OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING
+    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+    OTHER DEALINGS IN THE SOFTWARE.
+
+  17. Portions of the Nsight Eclipse Edition is subject to the
+    following license:
+
+    The Eclipse Foundation makes available all content in this plug-in
+    ("Content"). Unless otherwise indicated below, the Content is provided
+    to you under the terms and conditions of the Eclipse Public License
+    Version 1.0 ("EPL"). A copy of the EPL is available at http://
+    www.eclipse.org/legal/epl-v10.html. For purposes of the EPL, "Program"
+    will mean the Content.
+
+    If you did not receive this Content directly from the Eclipse
+    Foundation, the Content is being redistributed by another party
+    ("Redistributor") and different terms and conditions may apply to your
+    use of any object code in the Content. Check the Redistributor's
+    license that was provided with the Content. If no such license exists,
+    contact the Redistributor. Unless otherwise indicated below, the terms
+    and conditions of the EPL still apply to any source code in the
+    Content and such source code may be obtained at http://www.eclipse.org.
+
+  18. Some of the cuBLAS library routines uses code from
+    OpenAI, which is subject to the following license:
+
+    License URL
+    https://github.com/openai/openai-gemm/blob/master/LICENSE
+
+    License Text
+    The MIT License
+
+    Copyright (c) 2016 OpenAI (http://openai.com), 2016 Google Inc.
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.
+
+  19. Licensee's use of the Visual Studio Setup Configuration
+    Samples is subject to the following license:
+
+    The MIT License (MIT)
+    Copyright (C) Microsoft Corporation. All rights reserved.
+
+    Permission is hereby granted, free of charge, to any person
+    obtaining a copy of this software and associated documentation
+    files (the "Software"), to deal in the Software without restriction,
+    including without limitation the rights to use, copy, modify, merge,
+    publish, distribute, sublicense, and/or sell copies of the Software,
+    and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included
+    in all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+  20. Licensee's use of linmath.h header for CPU functions for
+    GL vector/matrix operations from lunarG is subject to the
+    Apache License Version 2.0.
+
+  21. The DX12-CUDA sample uses the d3dx12.h header, which is
+    subject to the MIT license .
+
+-----------------
diff --git a/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/METADATA b/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..f68ecd51e33433972513aa313409942fd0752924
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/METADATA
@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: nvidia-cuda-runtime-cu12
+Version: 12.1.105
+Summary: CUDA Runtime native Libraries
+Home-page: https://developer.nvidia.com/cuda-zone
+Author: Nvidia CUDA Installer Team
+Author-email: cuda_installer@nvidia.com
+License: NVIDIA Proprietary Software
+Keywords: cuda,nvidia,runtime,machine learning,deep learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3
+License-File: License.txt
+
+CUDA Runtime native Libraries
diff --git a/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/RECORD b/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..f4e985d9e076d856208058012edfc95d35751fa8
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/RECORD
@@ -0,0 +1,107 @@
+nvidia/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/__pycache__/__init__.cpython-310.pyc,,
+nvidia/cuda_runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/cuda_runtime/__pycache__/__init__.cpython-310.pyc,,
+nvidia/cuda_runtime/include/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/cuda_runtime/include/__pycache__/__init__.cpython-310.pyc,,
+nvidia/cuda_runtime/include/builtin_types.h,sha256=JxT9Vf2q2snxTBOL9ACzNmYzTWACO2VOVUu1KdFt7_g,3150
+nvidia/cuda_runtime/include/channel_descriptor.h,sha256=no_vNky02LeMLI0CF8GDVGHaPm_uRUGcVUMYdt_Xn4U,21482
+nvidia/cuda_runtime/include/common_functions.h,sha256=22LTZRVcPZzEH6MJda7nNMCvMgIjSTe0OKR7sEQj6kc,3410
+nvidia/cuda_runtime/include/cooperative_groups.h,sha256=JCMxtl4cNUFnymguM4_bTywhcfyxGqu_zOQIUh_Tc_g,59328
+nvidia/cuda_runtime/include/cooperative_groups/details/async.h,sha256=xsEHCZP3nuEY3l2p8SU2d1226XiXumUvDP_Gyh8PdVY,19122
+nvidia/cuda_runtime/include/cooperative_groups/details/coalesced_reduce.h,sha256=vWv1tyxMjSMM2Oc0SdxXhCug_PwaBM6u8iMLjKyeqjE,4561
+nvidia/cuda_runtime/include/cooperative_groups/details/coalesced_scan.h,sha256=DfZv5d5W0XJv-tZVhgrIdjLjs6aCx_u0oy1lDIpjo1Q,7314
+nvidia/cuda_runtime/include/cooperative_groups/details/driver_abi.h,sha256=v-ZUb4UgGKJk6NR2WCWHD3x_42y-togI1urFn70Gi-g,3964
+nvidia/cuda_runtime/include/cooperative_groups/details/functional.h,sha256=2BV8i8Bidz0kgxuYkJCAbwFxOIZRyzHgG-c_rVKhRzc,8905
+nvidia/cuda_runtime/include/cooperative_groups/details/helpers.h,sha256=GHIy-8awPZObSmP_FFWAnX7RQG9s1SD6L3yw5dNzhlM,23569
+nvidia/cuda_runtime/include/cooperative_groups/details/info.h,sha256=LSrEe6iTHuQRfc7RD3EHQbNqpED8eAbX4HLNyxXgKFA,12286
+nvidia/cuda_runtime/include/cooperative_groups/details/invoke.h,sha256=Osq3K-tZuXHVCMQJ708PjPo-BwMhjhjApO4b0TYLFJg,8616
+nvidia/cuda_runtime/include/cooperative_groups/details/memory.h,sha256=WU28eUcYLA1z131VYGulR4eVCSN9xK9KSxbV656YPs0,5484
+nvidia/cuda_runtime/include/cooperative_groups/details/partitioning.h,sha256=8hCh6F8sfkyfRgMirC37Nqv-b-gIY3A_J0eMYqmD2zU,6001
+nvidia/cuda_runtime/include/cooperative_groups/details/reduce.h,sha256=cbDjVSJVQ2_2pf2aP-X_rBkRVEWEFSYkc6oCx1fRQsQ,22744
+nvidia/cuda_runtime/include/cooperative_groups/details/scan.h,sha256=-Ttwb2AfEEY_tsmqJjR2dojkPpoRx387SoqxgvfdBtQ,17166
+nvidia/cuda_runtime/include/cooperative_groups/details/sync.h,sha256=fIEOjj7h3MoPqSOP3rkTNeedgS-0ZRkAHkzTAJDwJUA,10340
+nvidia/cuda_runtime/include/cooperative_groups/memcpy_async.h,sha256=erOIHuObdfxRhBWfrXE3wsZF4B2GUuqwzQrsPwKPpbg,2960
+nvidia/cuda_runtime/include/cooperative_groups/reduce.h,sha256=B0hgDkqM-6ueqTTgb3b34A0RH4vGz8mBf5e2jT1dJ1o,2949
+nvidia/cuda_runtime/include/cooperative_groups/scan.h,sha256=2EU6T5cWNwftm2B7FicV31PojoI61yo5fHXGRYkGk40,2940
+nvidia/cuda_runtime/include/cuComplex.h,sha256=WpcgpaiPhU_o9sTPMcNTEZuyXDIc8x3sz4dUWSztL2g,12186
+nvidia/cuda_runtime/include/cuda.h,sha256=CAY_j4D9qgEVLDxRftRObCI-vCpTTkSrLq9zBRVNwJI,933009
+nvidia/cuda_runtime/include/cudaEGL.h,sha256=_CwaQ4cEP1vfNyBSSd5qFxznPCYOovF6Cpj-QWSIBq4,39544
+nvidia/cuda_runtime/include/cudaEGLTypedefs.h,sha256=xF_FAN1Kar9oyHJ3cCU7jztTpxX8WylpiuYyYpGGHek,5645
+nvidia/cuda_runtime/include/cudaGL.h,sha256=gMT1HPGa-siuji0gAsKYr4X45Lc29HKglC_ttNSGyUM,22501
+nvidia/cuda_runtime/include/cudaGLTypedefs.h,sha256=dClpQI-LuXgF9rPSBsj7OkIg8g_fXDjT0hLZS8TGpOg,6576
+nvidia/cuda_runtime/include/cudaProfilerTypedefs.h,sha256=F2aWLIKv_AhNbxNOaZVcRsxIh0kuscnV8UMWWxkBAlY,3297
+nvidia/cuda_runtime/include/cudaTypedefs.h,sha256=guPSBrr4jNU6WBaBCqRiTuCbOYQDLMqYoz7bemoofWI,101855
+nvidia/cuda_runtime/include/cudaVDPAU.h,sha256=Np7Nc2Wjaz--hkpbhW6f9aapr-NbcPDAgkot0sJerco,12694
+nvidia/cuda_runtime/include/cudaVDPAUTypedefs.h,sha256=wz8nyOUdwM9mH9JO3QZW-A9dyxt-IufSX7nggSXpCNs,4144
+nvidia/cuda_runtime/include/cuda_awbarrier.h,sha256=3ZH-ZlXODhSiwSY9rqSni_EQwi25QMHP6Tm-zOdxBwE,9340
+nvidia/cuda_runtime/include/cuda_awbarrier_helpers.h,sha256=OCskCts5bCKl_RKBe9M74zKSIsVpePn44S_aJp1tFXE,12489
+nvidia/cuda_runtime/include/cuda_awbarrier_primitives.h,sha256=n5__E1jYYDhlgH-f3u8MQjtz57UZ7v5VshhMye1eicM,4699
+nvidia/cuda_runtime/include/cuda_bf16.h,sha256=zQ2idK7w0w7tRlgL_5Nyvy3FSrsOnu2W9Ya2YSFFT-E,149245
+nvidia/cuda_runtime/include/cuda_bf16.hpp,sha256=JlKs0yOZvJQPM6yFO3klxrhPTNN83e7um3ZFHMlYOKI,104876
+nvidia/cuda_runtime/include/cuda_device_runtime_api.h,sha256=2ZuNnXkRON3VchHM-OcKCdhljApIlfh-xKwupEfp5N4,39755
+nvidia/cuda_runtime/include/cuda_egl_interop.h,sha256=PNWYns30MIytJQHSOh7UbZYlaTX5e0bavzK14tde_C8,37109
+nvidia/cuda_runtime/include/cuda_fp16.h,sha256=aFLciB3o9QH3trYFl_P_dX58342UPfHXZGy2OeqEv1s,141782
+nvidia/cuda_runtime/include/cuda_fp16.hpp,sha256=kyHQA_rvZWpGq7sb2k3iTT3Zs1KYtr7TlEVvkGbQ61E,98606
+nvidia/cuda_runtime/include/cuda_fp8.h,sha256=Q3OP5o_3rSYbKtVIlcXVr_CncU3SPM-09j605e2Zegw,13833
+nvidia/cuda_runtime/include/cuda_fp8.hpp,sha256=pgYF_hzC2uAr7KNVyxBqrHTuM2bMaUPMUj7cY0kG3OU,56491
+nvidia/cuda_runtime/include/cuda_gl_interop.h,sha256=VQEswFeOBF6JN6Q0pdlkvc5WT7bD1FnTfKewvANulCc,19150
+nvidia/cuda_runtime/include/cuda_occupancy.h,sha256=Kr9HyOe-hlRjBAzbINwUYkNgbbIgIjuvKs09UZhMYQo,67179
+nvidia/cuda_runtime/include/cuda_pipeline.h,sha256=0enXG49wN4JajlQi3ahbp2ei_ufTY_Mznic7zfWmKHM,8130
+nvidia/cuda_runtime/include/cuda_pipeline_helpers.h,sha256=bo1L7e6vCuM-K3Il8K1z4wJUja5DyXQKdo_hSWUME-E,13852
+nvidia/cuda_runtime/include/cuda_pipeline_primitives.h,sha256=FnJJtuV6rHr6LgL56XDwilcSbFr6W1Hj6mf1AJaMI20,8675
+nvidia/cuda_runtime/include/cuda_runtime.h,sha256=NKUshOJapRWSe0CPJx-KllF9y3ZibUd9bM1OVUU52H4,88281
+nvidia/cuda_runtime/include/cuda_runtime_api.h,sha256=rUQw7deoB1R5LKEgLKwqFdoX6eke4bcp98CJ6iCk_uk,560622
+nvidia/cuda_runtime/include/cuda_surface_types.h,sha256=Mw5Lo4b8Q-f9mogOvATGyHhu9d2t2K6XOxuqtZrSh3A,3688
+nvidia/cuda_runtime/include/cuda_texture_types.h,sha256=ITbX-JNnP7Rm-JSgNVdJ9pq6k8FVor8RbnruDsKq6sk,3688
+nvidia/cuda_runtime/include/cuda_vdpau_interop.h,sha256=bXQanWc2IFXZAKWNGl2xAz9nLvFmQpWyGrsDvfeS9FA,7727
+nvidia/cuda_runtime/include/cudart_platform.h,sha256=YN6sKhB0b9w5tGX1IYL7ulJVPrWAiX9A44qLv4EtW5Q,2717
+nvidia/cuda_runtime/include/device_atomic_functions.h,sha256=o448l6Ep35UHnqcPSQXICvK4Vusc9mVjkyQDq0vV14E,11883
+nvidia/cuda_runtime/include/device_atomic_functions.hpp,sha256=_UsoVsyP7U-9CUUCbC1QLw6IbFFkKzxk458vLbAXzOY,8149
+nvidia/cuda_runtime/include/device_double_functions.h,sha256=KUxId5Z1fx8SWfLRTxPD7RB-zN7zslzb4n7JaJLfL3I,3452
+nvidia/cuda_runtime/include/device_functions.h,sha256=bWSrhTYE9NQlss7xMSMEVusvto9j2fgUDXWVH2W_cOA,3410
+nvidia/cuda_runtime/include/device_launch_parameters.h,sha256=H1_CC-vvAaS26ys4XsTFkMgTxUTciAjdjswjizkisvQ,3846
+nvidia/cuda_runtime/include/device_types.h,sha256=2LFxoZBJPoA5V0H1EbKTEaXDi3GDJPtzOPdRHDaucIQ,3588
+nvidia/cuda_runtime/include/driver_functions.h,sha256=cN3IjRAz2Mj2Pj35SyxJIkZNDDusnJqaqzBdMzpQKbA,4625
+nvidia/cuda_runtime/include/driver_types.h,sha256=Oti6YeNU-DHsXp6r1wu5JSIGOUWgCXiED-N0DEWVlK0,144785
+nvidia/cuda_runtime/include/host_config.h,sha256=BscH_GazAZbbotddVzL5RmafbQ-QjRx8f-I1O01IBW8,3380
+nvidia/cuda_runtime/include/host_defines.h,sha256=bBQwQF5C1N1c2qpLV56g1c-weu9Ysgz-gIf2Kn3uz_A,3386
+nvidia/cuda_runtime/include/library_types.h,sha256=yJvoLFw5oBdRqkQgEhIaX-stsMGlxQW9sZoJ4vbQHwI,4766
+nvidia/cuda_runtime/include/math_constants.h,sha256=cV6hAyQe8X7f7MBtaKjjIJq3BycOUDp6I5cizJX5HLw,7608
+nvidia/cuda_runtime/include/math_functions.h,sha256=5XcC6j-fJKttvhwc4hZNoLHNw808a2ZYIOtZ7ry7yd0,3398
+nvidia/cuda_runtime/include/mma.h,sha256=IY_VenxuEncwGq92MhrWUb-Xswh0ekAXLy9Rbxhxa2Y,2932
+nvidia/cuda_runtime/include/sm_20_atomic_functions.h,sha256=j5zuwIb71KmDLf43RoOjwiudGYvBk_k2PRsj8sy5xXI,4942
+nvidia/cuda_runtime/include/sm_20_atomic_functions.hpp,sha256=Cx__BPJKUPeG5qMxZs9ztfIyqWqt0wZDZi4V_5EV4LQ,3929
+nvidia/cuda_runtime/include/sm_20_intrinsics.h,sha256=cQbeg-K9zWgOI4jAVeUmV1WiWOMF5sHPz_nb3CWdAjU,51052
+nvidia/cuda_runtime/include/sm_20_intrinsics.hpp,sha256=BhEBuXSKBsNGJDBJDtYL0cGRI3wX_w_OIgA5D-YxIWk,7694
+nvidia/cuda_runtime/include/sm_30_intrinsics.h,sha256=kafRv2e_iMvwNfGEP5yIyjRBFx97tdkpT5me9RvbOuo,16375
+nvidia/cuda_runtime/include/sm_30_intrinsics.hpp,sha256=yX0ebd265tJ-BDhvluP2BhadPuWXpRZPI2eeQFFt5ys,24567
+nvidia/cuda_runtime/include/sm_32_atomic_functions.h,sha256=V1VteWKbW09qoItfQp0DbHj7R_e3bxX24NRGnd18Jc4,6812
+nvidia/cuda_runtime/include/sm_32_atomic_functions.hpp,sha256=HcKoB3ujG_AVTzIaD_MjRCaaRZL8khqI_cJqHwCaP5g,5416
+nvidia/cuda_runtime/include/sm_32_intrinsics.h,sha256=o7IwBBKu2lDZwzHHb2pOLAvyCNpCoEKSHPt0dFaSspI,33390
+nvidia/cuda_runtime/include/sm_32_intrinsics.hpp,sha256=Gl8aSLDLcit4W3pKQS19GsDG8RYcwD65HwYB_CeZe8M,70616
+nvidia/cuda_runtime/include/sm_35_atomic_functions.h,sha256=a3XoEsKRCEOf0Q_5Y__rMfmC4pScv4VkUggVgVJVn44,2909
+nvidia/cuda_runtime/include/sm_35_intrinsics.h,sha256=BEiPNO03ZSv5XtMMul5jiTH4oLWlOu3CYkIAgrWslnk,2952
+nvidia/cuda_runtime/include/sm_60_atomic_functions.h,sha256=E5nwZxyIL48AMUIFxZmwzfWaPXOMpjJsoEIQcY7LzPM,20902
+nvidia/cuda_runtime/include/sm_60_atomic_functions.hpp,sha256=bSnj2_G8asEbiu8aPuf3OACDuT_-kw6TuBlU1QtLLfY,15081
+nvidia/cuda_runtime/include/sm_61_intrinsics.h,sha256=eEL9MmGSOpD9DohErXPflc0k2loEcMzDVKZYiUZx7hY,6030
+nvidia/cuda_runtime/include/sm_61_intrinsics.hpp,sha256=N-nQvcBsPMT2Umy5zR69c9K1q366W-Jqe7NpoLTqTmg,6787
+nvidia/cuda_runtime/include/surface_functions.h,sha256=b1O82SAvEgWWxA9uZTWQcGimzZUoem2QbAET3wh3fZc,6782
+nvidia/cuda_runtime/include/surface_indirect_functions.h,sha256=vy9QuFVV-ezZP-x2RT9RLp2qIUgdngACOCmalSfVFPA,10877
+nvidia/cuda_runtime/include/surface_types.h,sha256=Di766cyRUqNN4JkOnYM3teFqrwMZ02hXMDB_R_2_vz4,4460
+nvidia/cuda_runtime/include/texture_fetch_functions.h,sha256=KLCmUxf5aY5_UalX8tSFB6e4TrjA8hyUPxLOkMFltAo,12468
+nvidia/cuda_runtime/include/texture_indirect_functions.h,sha256=lH_y3Ni-hq4RZ0_PMFbBM0th5-OmTn3TtqtpkHHhA8w,21163
+nvidia/cuda_runtime/include/texture_types.h,sha256=cFqQ6sC4y79Q6YxjLSY_bknwMgKJAOwPdKDARLPFrDI,6290
+nvidia/cuda_runtime/include/vector_functions.h,sha256=R5plWOkFciltO_AS5if8NcmsgDp3cFNq6zFFDd3oofk,7847
+nvidia/cuda_runtime/include/vector_functions.hpp,sha256=afXhNSd3LFTZo96EPtesTLfvxd4nTmLVzgkj967rTRg,10060
+nvidia/cuda_runtime/include/vector_types.h,sha256=ruVFRp8RioWR9mrvLXX9S15ZSJ97wqTjA8ORCJKKzOQ,13206
+nvidia/cuda_runtime/lib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia/cuda_runtime/lib/__pycache__/__init__.cpython-310.pyc,,
+nvidia/cuda_runtime/lib/libcudart.so.12,sha256=kzX2opypEBDi2p9A6C-0so46SuIv04XhKT6TvzxGyeY,679264
+nvidia_cuda_runtime_cu12-12.1.105.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+nvidia_cuda_runtime_cu12-12.1.105.dist-info/License.txt,sha256=rW9YU_ugyg0VnQ9Y1JrkmDDC-Mk_epJki5zpCttMbM0,59262
+nvidia_cuda_runtime_cu12-12.1.105.dist-info/METADATA,sha256=9_P2cqjEZ020xhA9HzY1klL7YVuIjKETxs1wKAXeYoQ,1507
+nvidia_cuda_runtime_cu12-12.1.105.dist-info/RECORD,,
+nvidia_cuda_runtime_cu12-12.1.105.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia_cuda_runtime_cu12-12.1.105.dist-info/WHEEL,sha256=-kQi_VMfvRQozZJT7HUPMfY-5vLo0LVTmAylNJ3Ft98,106
+nvidia_cuda_runtime_cu12-12.1.105.dist-info/top_level.txt,sha256=fTkAtiFuL16nUrB9ytDDtpytz2t0B4NvYTnRzwAhO14,7
diff --git a/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/REQUESTED b/parrot/lib/python3.10/site-packages/nvidia_cuda_runtime_cu12-12.1.105.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/INSTALLER b/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/LICENSE b/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/REQUESTED b/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/WHEEL b/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..becc9a66ea739ba941d48a749e248761cc6e658a
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/top_level.txt b/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..dc89ba063e639dfa24fd7f53340bc368adbebb7a
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/peft-0.4.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+peft
diff --git a/parrot/lib/python3.10/site-packages/sty/__init__.py b/parrot/lib/python3.10/site-packages/sty/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1aa433eef9f273de2caaf87a3c8a6c4f418c12be
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/sty/__init__.py
@@ -0,0 +1,51 @@
+"""
+String styling for your terminal.
+
+Documentation: https://sty.mewo.dev
+Source Code: https://github.com/feluxe/sty
+
+Example: Print bold text with red foreground, green background and reset:
+
+    from sty import fg, bg, ef, rs
+
+    print(f"{ef.b}{fg.red}{bg.green}My String{rs.all}")
+
+Example: Create custom style:
+
+    from sty import RgbFg, Style
+
+    fg.orange = Style(RgbFg(255, 150, 50))
+
+Example: Create your own register:
+
+    from sty import FgRegister, RgbFg, Sgr
+
+    class MyFgRegister(FgRegister):
+        def __init__(self):
+            super().__init__()
+
+            self.purple = Style(Sgr(35))
+            self.blue = Style(Sgr(34))
+            # ...
+
+    fg = MyFgRegister()
+
+For more info see the docs.
+"""
+
+# NOTE: These are PEP-484 compatible exports using "*" and "... as ...".
+from sty.lib import *
+
+from sty.primitive import Register as Register
+from sty.primitive import Style as Style
+
+from sty.register import BgRegister as BgRegister
+from sty.register import EfRegister as EfRegister
+from sty.register import FgRegister as FgRegister
+from sty.register import RsRegister as RsRegister
+from sty.register import bg as bg
+from sty.register import ef as ef
+from sty.register import fg as fg
+from sty.register import rs as rs
+
+from sty.rendertype import *
diff --git a/parrot/lib/python3.10/site-packages/sty/lib.py b/parrot/lib/python3.10/site-packages/sty/lib.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d29b8cb404c1758241021e63057e5f2748c79cb
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/sty/lib.py
@@ -0,0 +1,37 @@
+"""
+Utility funcitons go here.
+This module is private. You shouldn't import it when using sty.
+"""
+from sty.primitive import Register
+
+
+def mute(*objects: Register) -> None:
+    """
+    Use this function to mute multiple register-objects at once.
+
+    :param objects: Pass multiple register-objects to the function.
+    """
+    err = ValueError(
+        "The mute() method can only be used with objects that inherit "
+        "from the 'Register class'."
+    )
+    for obj in objects:
+        if not isinstance(obj, Register):
+            raise err
+        obj.mute()
+
+
+def unmute(*objects: Register) -> None:
+    """
+    Use this function to unmute multiple register-objects at once.
+
+    :param objects: Pass multiple register-objects to the function.
+    """
+    err = ValueError(
+        "The unmute() method can only be used with objects that inherit "
+        "from the 'Register class'."
+    )
+    for obj in objects:
+        if not isinstance(obj, Register):
+            raise err
+        obj.unmute()
diff --git a/parrot/lib/python3.10/site-packages/sty/renderfunc.py b/parrot/lib/python3.10/site-packages/sty/renderfunc.py
new file mode 100644
index 0000000000000000000000000000000000000000..ddb0b57695ffb42499c9f62e9b1d0ea6b3dedc6e
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/sty/renderfunc.py
@@ -0,0 +1,41 @@
+"""
+A selection of render functions.
+
+These functions generate the escape-sequences that trigger certain colors/effects in
+the terminals.
+"""
+
+
+def sgr(num: int) -> str:
+    """
+    Create a SGR escape sequence.
+    """
+    return "\033[" + str(num) + "m"
+
+
+def eightbit_fg(num: int) -> str:
+    """
+    Create a 8bit (256-color) foreground escape sequence.
+    """
+    return "\033[38;5;" + str(num) + "m"
+
+
+def eightbit_bg(num: int) -> str:
+    """
+    Create a 8bit (256-color) background escape sequence.
+    """
+    return "\033[48;5;" + str(num) + "m"
+
+
+def rgb_fg(r: int, g: int, b: int) -> str:
+    """
+    Create a 24bit (true color) foreground escape sequence.
+    """
+    return "\x1b[38;2;" + str(r) + ";" + str(g) + ";" + str(b) + "m"
+
+
+def rgb_bg(r: int, g: int, b: int) -> str:
+    """
+    Create a 24bit (true color) background escape sequence.
+    """
+    return "\x1b[48;2;" + str(r) + ";" + str(g) + ";" + str(b) + "m"
diff --git a/parrot/lib/python3.10/site-packages/sty/rendertype.py b/parrot/lib/python3.10/site-packages/sty/rendertype.py
new file mode 100644
index 0000000000000000000000000000000000000000..00e77bc3fdc5c60cbbf6d5e9e0bd8c3bf905f430
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/sty/rendertype.py
@@ -0,0 +1,78 @@
+"""
+This module contains the default render types.
+
+These can be used to create register classes and custom styling rules.
+"""
+
+
+class RenderType:
+    args: list = []
+
+
+class Sgr(RenderType):
+    """
+    Define SGR styling rule.
+
+    More info about SGR parameters: https://en.wikipedia.org/wiki/ANSI_escape_code#SGR
+
+    :param num: A SGR number.
+    """
+
+    def __init__(self, num: int):
+        self.args = [num]
+
+
+class EightbitFg(RenderType):
+    """
+    Define Eightbit Foreground.
+
+    More info about 8-bit terminal colors: https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+
+    :param num: Eightbit number.
+    """
+
+    def __init__(self, num: int):
+        self.args = [num]
+
+
+class EightbitBg(RenderType):
+    """
+    Define Eightbit Background.
+
+    More info about 8-bit terminal colors: https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit
+
+    :param num: Eightbit number.
+    """
+
+    def __init__(self, num: int):
+        self.args = [num]
+
+
+class RgbFg(RenderType):
+    """
+    Define RGB Foreground.
+
+    More info about 24-bit terminal colors: https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit
+
+    :param r: Red.
+    :param g: Green.
+    :param b: Blue.
+    """
+
+    def __init__(self, r: int, g: int, b: int):
+        self.args = [r, g, b]
+
+
+class RgbBg(RenderType):
+    """
+    Define RGB Background.
+
+    More info about 24-bit terminal colors: https://en.wikipedia.org/wiki/ANSI_escape_code#24-bit
+
+    :param r: Red.
+    :param g: Green.
+    :param b: Blue.
+    """
+
+    def __init__(self, r: int, g: int, b: int):
+        self.args = [r, g, b]
diff --git a/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/INSTALLER b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/LICENSE b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..83ed1036f70d4f419307e8a044a35e163cc35201
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 OpenAI, Shantanu Jain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/METADATA b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..2ce2821db9cf48809352a36d15aa6c4fdac490ca
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/METADATA
@@ -0,0 +1,169 @@
+Metadata-Version: 2.1
+Name: tiktoken
+Version: 0.7.0
+Summary: tiktoken is a fast BPE tokeniser for use with OpenAI's models
+Author: Shantanu Jain
+Author-email: shantanu@openai.com
+License: MIT License
+        
+        Copyright (c) 2022 OpenAI, Shantanu Jain
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: homepage, https://github.com/openai/tiktoken
+Project-URL: repository, https://github.com/openai/tiktoken
+Project-URL: changelog, https://github.com/openai/tiktoken/blob/main/CHANGELOG.md
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: regex >=2022.1.18
+Requires-Dist: requests >=2.26.0
+Provides-Extra: blobfile
+Requires-Dist: blobfile >=2 ; extra == 'blobfile'
+
+# ⏳ tiktoken
+
+tiktoken is a fast [BPE](https://en.wikipedia.org/wiki/Byte_pair_encoding) tokeniser for use with
+OpenAI's models.
+
+```python
+import tiktoken
+enc = tiktoken.get_encoding("cl100k_base")
+assert enc.decode(enc.encode("hello world")) == "hello world"
+
+# To get the tokeniser corresponding to a specific model in the OpenAI API:
+enc = tiktoken.encoding_for_model("gpt-4")
+```
+
+The open source version of `tiktoken` can be installed from PyPI:
+```
+pip install tiktoken
+```
+
+The tokeniser API is documented in `tiktoken/core.py`.
+
+Example code using `tiktoken` can be found in the
+[OpenAI Cookbook](https://github.com/openai/openai-cookbook/blob/main/examples/How_to_count_tokens_with_tiktoken.ipynb).
+
+
+## Performance
+
+`tiktoken` is between 3-6x faster than a comparable open source tokeniser:
+
+![image](https://raw.githubusercontent.com/openai/tiktoken/main/perf.svg)
+
+Performance measured on 1GB of text using the GPT-2 tokeniser, using `GPT2TokenizerFast` from
+`tokenizers==0.13.2`, `transformers==4.24.0` and `tiktoken==0.2.0`.
+
+
+## Getting help
+
+Please post questions in the [issue tracker](https://github.com/openai/tiktoken/issues).
+
+If you work at OpenAI, make sure to check the internal documentation or feel free to contact
+@shantanu.
+
+## What is BPE anyway?
+
+Language models don't see text like you and I, instead they see a sequence of numbers (known as tokens).
+Byte pair encoding (BPE) is a way of converting text into tokens. It has a couple desirable
+properties:
+1) It's reversible and lossless, so you can convert tokens back into the original text
+2) It works on arbitrary text, even text that is not in the tokeniser's training data
+3) It compresses the text: the token sequence is shorter than the bytes corresponding to the
+   original text. On average, in practice, each token corresponds to about 4 bytes.
+4) It attempts to let the model see common subwords. For instance, "ing" is a common subword in
+   English, so BPE encodings will often split "encoding" into tokens like "encod" and "ing"
+   (instead of e.g. "enc" and "oding"). Because the model will then see the "ing" token again and
+   again in different contexts, it helps models generalise and better understand grammar.
+
+`tiktoken` contains an educational submodule that is friendlier if you want to learn more about
+the details of BPE, including code that helps visualise the BPE procedure:
+```python
+from tiktoken._educational import *
+
+# Train a BPE tokeniser on a small amount of text
+enc = train_simple_encoding()
+
+# Visualise how the GPT-4 encoder encodes text
+enc = SimpleBytePairEncoding.from_tiktoken("cl100k_base")
+enc.encode("hello world aaaaaaaaaaaa")
+```
+
+
+## Extending tiktoken
+
+You may wish to extend `tiktoken` to support new encodings. There are two ways to do this.
+
+
+**Create your `Encoding` object exactly the way you want and simply pass it around.**
+
+```python
+cl100k_base = tiktoken.get_encoding("cl100k_base")
+
+# In production, load the arguments directly instead of accessing private attributes
+# See openai_public.py for examples of arguments for specific encodings
+enc = tiktoken.Encoding(
+    # If you're changing the set of special tokens, make sure to use a different name
+    # It should be clear from the name what behaviour to expect.
+    name="cl100k_im",
+    pat_str=cl100k_base._pat_str,
+    mergeable_ranks=cl100k_base._mergeable_ranks,
+    special_tokens={
+        **cl100k_base._special_tokens,
+        "<|im_start|>": 100264,
+        "<|im_end|>": 100265,
+    }
+)
+```
+
+**Use the `tiktoken_ext` plugin mechanism to register your `Encoding` objects with `tiktoken`.**
+
+This is only useful if you need `tiktoken.get_encoding` to find your encoding, otherwise prefer
+option 1.
+
+To do this, you'll need to create a namespace package under `tiktoken_ext`.
+
+Layout your project like this, making sure to omit the `tiktoken_ext/__init__.py` file:
+```
+my_tiktoken_extension
+├── tiktoken_ext
+│   └── my_encodings.py
+└── setup.py
+```
+
+`my_encodings.py` should be a module that contains a variable named `ENCODING_CONSTRUCTORS`.
+This is a dictionary from an encoding name to a function that takes no arguments and returns
+arguments that can be passed to `tiktoken.Encoding` to construct that encoding. For an example, see
+`tiktoken_ext/openai_public.py`. For precise details, see `tiktoken/registry.py`.
+
+Your `setup.py` should look something like this:
+```python
+from setuptools import setup, find_namespace_packages
+
+setup(
+    name="my_tiktoken_extension",
+    packages=find_namespace_packages(include=['tiktoken_ext*']),
+    install_requires=["tiktoken"],
+    ...
+)
+```
+
+Then simply `pip install ./my_tiktoken_extension` and you should be able to use your
+custom encodings! Make sure **not** to use an editable install.
diff --git a/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/RECORD b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..588d319b6746c33b3fc76f9bb6fec2f9effd784b
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/RECORD
@@ -0,0 +1,23 @@
+tiktoken-0.7.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+tiktoken-0.7.0.dist-info/LICENSE,sha256=QYy0mbQ2Eo1lPXmUEzOlQ3t74uqSE9zC8E0V1dLFHYY,1078
+tiktoken-0.7.0.dist-info/METADATA,sha256=06FiLYxR04FjaYa53wsIdDvuJtP_FBaU0d4DnUcRpYg,6631
+tiktoken-0.7.0.dist-info/RECORD,,
+tiktoken-0.7.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tiktoken-0.7.0.dist-info/WHEEL,sha256=CzQQWV-lNyM92gr3iaBk8dvO35YDHRxgzkZ-dxumUIM,152
+tiktoken-0.7.0.dist-info/top_level.txt,sha256=54G5MceQnuD7EXvp7jzGxDDapA1iOwsh77jhCN9WKkc,22
+tiktoken/__init__.py,sha256=FNmz8KgZfaG62vRgMMkTL9jj0a2AI7JGV1b-RZ29_tY,322
+tiktoken/__pycache__/__init__.cpython-310.pyc,,
+tiktoken/__pycache__/_educational.cpython-310.pyc,,
+tiktoken/__pycache__/core.cpython-310.pyc,,
+tiktoken/__pycache__/load.cpython-310.pyc,,
+tiktoken/__pycache__/model.cpython-310.pyc,,
+tiktoken/__pycache__/registry.cpython-310.pyc,,
+tiktoken/_educational.py,sha256=l_bTeohxYJ2RHrXDFT2QfRF7aD89S38VFZndzZTI_cM,8234
+tiktoken/_tiktoken.cpython-310-x86_64-linux-gnu.so,sha256=M4aPWFqCCHSS2T98pmHsQM_5DFEU5ePuFAl9GMHobpo,3202496
+tiktoken/core.py,sha256=MlhBCfE5WLR1i8rokHqYz7u4GdTF_dfpnSuOwmtHj2A,16123
+tiktoken/load.py,sha256=YDbOfHhKn1MEWn9cWc1cVqDxZNwpGifWnuvfEcKeJ4w,5351
+tiktoken/model.py,sha256=fCcuegWlKwFFmD1crVXHxFQBlBV6BGWCfwYTIhUcADs,3647
+tiktoken/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tiktoken/registry.py,sha256=ksP_k8jlqLyefL1sr5OAc-yOK0McOFaHZM4oF8KQdYg,2811
+tiktoken_ext/__pycache__/openai_public.cpython-310.pyc,,
+tiktoken_ext/openai_public.py,sha256=3gckU-7LqtjkwKbVp5M6ZktECFdr7Tw5Ii8aDiFQKto,4634
diff --git a/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/REQUESTED b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/REQUESTED
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/WHEEL b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..9bb86cf30c63df9170e9af3dd246ce6f41270402
--- /dev/null
+++ b/parrot/lib/python3.10/site-packages/tiktoken-0.7.0.dist-info/WHEEL
@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+