Add files using upload-large-folder tool

.gitattributes

@@ -100,3 +100,5 @@ parrot/lib/libncursesw.a filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libncurses.so filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libncursesw.so.6.4 filter=lfs diff=lfs merge=lfs -text
 parrot/lib/libtinfow.so filter=lfs diff=lfs merge=lfs -text
+parrot/lib/libtinfow.so.6 filter=lfs diff=lfs merge=lfs -text
+parrot/lib/python3.10/site-packages/google/protobuf/__pycache__/descriptor_pb2.cpython-310.pyc filter=lfs diff=lfs merge=lfs -text

parrot/lib/libtinfow.so.6

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ff9b333bc4b796b31c188c2dadd7840788cb963dbf4f34567deb3f326326b02
+size 287080

parrot/lib/python3.10/site-packages/aiohappyeyeballs/__init__.py

@@ -0,0 +1,13 @@
+__version__ = "2.4.2"
+
+from .impl import start_connection
+from .types import AddrInfoType
+from .utils import addr_to_addr_infos, pop_addr_infos_interleave, remove_addr_infos
+
+__all__ = (
+    "start_connection",
+    "AddrInfoType",
+    "remove_addr_infos",
+    "pop_addr_infos_interleave",
+    "addr_to_addr_infos",
+)

parrot/lib/python3.10/site-packages/aiohappyeyeballs/_staggered.py

@@ -0,0 +1,101 @@
+import asyncio
+import contextlib
+from typing import Awaitable, Callable, Iterable, List, Optional, Tuple, TypeVar
+
+
+class _Done(Exception):
+    pass
+
+
+_T = TypeVar("_T")
+
+
+async def staggered_race(
+    coro_fns: Iterable[Callable[[], Awaitable[_T]]], delay: Optional[float]
+) -> Tuple[Optional[_T], Optional[int], List[Optional[BaseException]]]:
+    """
+    Run coroutines with staggered start times and take the first to finish.
+
+    This method takes an iterable of coroutine functions. The first one is
+    started immediately. From then on, whenever the immediately preceding one
+    fails (raises an exception), or when *delay* seconds has passed, the next
+    coroutine is started. This continues until one of the coroutines complete
+    successfully, in which case all others are cancelled, or until all
+    coroutines fail.
+
+    The coroutines provided should be well-behaved in the following way:
+
+    * They should only ``return`` if completed successfully.
+
+    * They should always raise an exception if they did not complete
+      successfully. In particular, if they handle cancellation, they should
+      probably reraise, like this::
+
+        try:
+            # do work
+        except asyncio.CancelledError:
+            # undo partially completed work
+            raise
+
+    Args:
+        coro_fns: an iterable of coroutine functions, i.e. callables that
+            return a coroutine object when called. Use ``functools.partial`` or
+            lambdas to pass arguments.
+
+        delay: amount of time, in seconds, between starting coroutines. If
+            ``None``, the coroutines will run sequentially.
+
+    Returns:
+        tuple *(winner_result, winner_index, exceptions)* where
+
+        - *winner_result*: the result of the winning coroutine, or ``None``
+          if no coroutines won.
+
+        - *winner_index*: the index of the winning coroutine in
+          ``coro_fns``, or ``None`` if no coroutines won. If the winning
+          coroutine may return None on success, *winner_index* can be used
+          to definitively determine whether any coroutine won.
+
+        - *exceptions*: list of exceptions returned by the coroutines.
+          ``len(exceptions)`` is equal to the number of coroutines actually
+          started, and the order is the same as in ``coro_fns``. The winning
+          coroutine's entry is ``None``.
+
+    """
+    # TODO: when we have aiter() and anext(), allow async iterables in coro_fns.
+    winner_result = None
+    winner_index = None
+    exceptions: List[Optional[BaseException]] = []
+
+    async def run_one_coro(
+        this_index: int,
+        coro_fn: Callable[[], Awaitable[_T]],
+        this_failed: asyncio.Event,
+    ) -> None:
+        try:
+            result = await coro_fn()
+        except (SystemExit, KeyboardInterrupt):
+            raise
+        except BaseException as e:
+            exceptions[this_index] = e
+            this_failed.set()  # Kickstart the next coroutine
+        else:
+            # Store winner's results
+            nonlocal winner_index, winner_result
+            assert winner_index is None  # noqa: S101
+            winner_index = this_index
+            winner_result = result
+            raise _Done
+
+    try:
+        async with asyncio.TaskGroup() as tg:
+            for this_index, coro_fn in enumerate(coro_fns):
+                this_failed = asyncio.Event()
+                exceptions.append(None)
+                tg.create_task(run_one_coro(this_index, coro_fn, this_failed))
+                with contextlib.suppress(TimeoutError):
+                    await asyncio.wait_for(this_failed.wait(), delay)
+    except* _Done:
+        pass
+
+    return winner_result, winner_index, exceptions

parrot/lib/python3.10/site-packages/aiohappyeyeballs/impl.py

@@ -0,0 +1,204 @@
+"""Base implementation."""
+
+import asyncio
+import collections
+import functools
+import itertools
+import socket
+import sys
+from typing import List, Optional, Sequence
+
+from . import staggered
+from .types import AddrInfoType
+
+if sys.version_info < (3, 8, 2):  # noqa: UP036
+    # asyncio.staggered is broken in Python 3.8.0 and 3.8.1
+    # so it must be patched:
+    # https://github.com/aio-libs/aiohttp/issues/8556
+    # https://bugs.python.org/issue39129
+    # https://github.com/python/cpython/pull/17693
+    import asyncio.futures
+
+    asyncio.futures.TimeoutError = asyncio.TimeoutError  # type: ignore[attr-defined]
+
+
+async def start_connection(
+    addr_infos: Sequence[AddrInfoType],
+    *,
+    local_addr_infos: Optional[Sequence[AddrInfoType]] = None,
+    happy_eyeballs_delay: Optional[float] = None,
+    interleave: Optional[int] = None,
+    loop: Optional[asyncio.AbstractEventLoop] = None,
+) -> socket.socket:
+    """
+    Connect to a TCP server.
+
+    Create a socket connection to a specified destination.  The
+    destination is specified as a list of AddrInfoType tuples as
+    returned from getaddrinfo().
+
+    The arguments are, in order:
+
+    * ``family``: the address family, e.g. ``socket.AF_INET`` or
+        ``socket.AF_INET6``.
+    * ``type``: the socket type, e.g. ``socket.SOCK_STREAM`` or
+        ``socket.SOCK_DGRAM``.
+    * ``proto``: the protocol, e.g. ``socket.IPPROTO_TCP`` or
+        ``socket.IPPROTO_UDP``.
+    * ``canonname``: the canonical name of the address, e.g.
+        ``"www.python.org"``.
+    * ``sockaddr``: the socket address
+
+    This method is a coroutine which will try to establish the connection
+    in the background. When successful, the coroutine returns a
+    socket.
+
+    The expected use case is to use this method in conjunction with
+    loop.create_connection() to establish a connection to a server::
+
+            socket = await start_connection(addr_infos)
+            transport, protocol = await loop.create_connection(
+                MyProtocol, sock=socket, ...)
+    """
+    if not (current_loop := loop):
+        current_loop = asyncio.get_running_loop()
+
+    single_addr_info = len(addr_infos) == 1
+
+    if happy_eyeballs_delay is not None and interleave is None:
+        # If using happy eyeballs, default to interleave addresses by family
+        interleave = 1
+
+    if interleave and not single_addr_info:
+        addr_infos = _interleave_addrinfos(addr_infos, interleave)
+
+    sock: Optional[socket.socket] = None
+    exceptions: List[List[OSError]] = []
+    if happy_eyeballs_delay is None or single_addr_info:
+        # not using happy eyeballs
+        for addrinfo in addr_infos:
+            try:
+                sock = await _connect_sock(
+                    current_loop, exceptions, addrinfo, local_addr_infos
+                )
+                break
+            except OSError:
+                continue
+    else:  # using happy eyeballs
+        sock, _, _ = await staggered.staggered_race(
+            (
+                functools.partial(
+                    _connect_sock, current_loop, exceptions, addrinfo, local_addr_infos
+                )
+                for addrinfo in addr_infos
+            ),
+            happy_eyeballs_delay,
+        )
+
+    if sock is None:
+        all_exceptions = [exc for sub in exceptions for exc in sub]
+        try:
+            first_exception = all_exceptions[0]
+            if len(all_exceptions) == 1:
+                raise first_exception
+            else:
+                # If they all have the same str(), raise one.
+                model = str(first_exception)
+                if all(str(exc) == model for exc in all_exceptions):
+                    raise first_exception
+                # Raise a combined exception so the user can see all
+                # the various error messages.
+                msg = "Multiple exceptions: {}".format(
+                    ", ".join(str(exc) for exc in all_exceptions)
+                )
+                # If the errno is the same for all exceptions, raise
+                # an OSError with that errno.
+                first_errno = first_exception.errno
+                if all(
+                    isinstance(exc, OSError) and exc.errno == first_errno
+                    for exc in all_exceptions
+                ):
+                    raise OSError(first_errno, msg)
+                raise OSError(msg)
+        finally:
+            all_exceptions = None  # type: ignore[assignment]
+            exceptions = None  # type: ignore[assignment]
+
+    return sock
+
+
+async def _connect_sock(
+    loop: asyncio.AbstractEventLoop,
+    exceptions: List[List[OSError]],
+    addr_info: AddrInfoType,
+    local_addr_infos: Optional[Sequence[AddrInfoType]] = None,
+) -> socket.socket:
+    """Create, bind and connect one socket."""
+    my_exceptions: list[OSError] = []
+    exceptions.append(my_exceptions)
+    family, type_, proto, _, address = addr_info
+    sock = None
+    try:
+        sock = socket.socket(family=family, type=type_, proto=proto)
+        sock.setblocking(False)
+        if local_addr_infos is not None:
+            for lfamily, _, _, _, laddr in local_addr_infos:
+                # skip local addresses of different family
+                if lfamily != family:
+                    continue
+                try:
+                    sock.bind(laddr)
+                    break
+                except OSError as exc:
+                    msg = (
+                        f"error while attempting to bind on "
+                        f"address {laddr!r}: "
+                        f"{exc.strerror.lower()}"
+                    )
+                    exc = OSError(exc.errno, msg)
+                    my_exceptions.append(exc)
+            else:  # all bind attempts failed
+                if my_exceptions:
+                    raise my_exceptions.pop()
+                else:
+                    raise OSError(f"no matching local address with {family=} found")
+        await loop.sock_connect(sock, address)
+        return sock
+    except OSError as exc:
+        my_exceptions.append(exc)
+        if sock is not None:
+            sock.close()
+        raise
+    except:
+        if sock is not None:
+            sock.close()
+        raise
+    finally:
+        exceptions = my_exceptions = None  # type: ignore[assignment]
+
+
+def _interleave_addrinfos(
+    addrinfos: Sequence[AddrInfoType], first_address_family_count: int = 1
+) -> List[AddrInfoType]:
+    """Interleave list of addrinfo tuples by family."""
+    # Group addresses by family
+    addrinfos_by_family: collections.OrderedDict[int, List[AddrInfoType]] = (
+        collections.OrderedDict()
+    )
+    for addr in addrinfos:
+        family = addr[0]
+        if family not in addrinfos_by_family:
+            addrinfos_by_family[family] = []
+        addrinfos_by_family[family].append(addr)
+    addrinfos_lists = list(addrinfos_by_family.values())
+
+    reordered: List[AddrInfoType] = []
+    if first_address_family_count > 1:
+        reordered.extend(addrinfos_lists[0][: first_address_family_count - 1])
+        del addrinfos_lists[0][: first_address_family_count - 1]
+    reordered.extend(
+        a
+        for a in itertools.chain.from_iterable(itertools.zip_longest(*addrinfos_lists))
+        if a is not None
+    )
+    return reordered

parrot/lib/python3.10/site-packages/aiohappyeyeballs/staggered.py

@@ -0,0 +1,9 @@
+import sys
+
+if sys.version_info > (3, 11):
+    # https://github.com/python/cpython/issues/124639#issuecomment-2378129834
+    from ._staggered import staggered_race
+else:
+    from asyncio.staggered import staggered_race
+
+__all__ = ["staggered_race"]

parrot/lib/python3.10/site-packages/aiohappyeyeballs/types.py

@@ -0,0 +1,12 @@
+"""Types for aiohappyeyeballs."""
+
+import socket
+from typing import Tuple, Union
+
+AddrInfoType = Tuple[
+    Union[int, socket.AddressFamily],
+    Union[int, socket.SocketKind],
+    int,
+    str,
+    Tuple,  # type: ignore[type-arg]
+]

parrot/lib/python3.10/site-packages/aiohappyeyeballs/utils.py

@@ -0,0 +1,97 @@
+"""Utility functions for aiohappyeyeballs."""
+
+import ipaddress
+import socket
+from typing import Dict, List, Optional, Tuple, Union
+
+from .types import AddrInfoType
+
+
+def addr_to_addr_infos(
+    addr: Optional[
+        Union[Tuple[str, int, int, int], Tuple[str, int, int], Tuple[str, int]]
+    ]
+) -> Optional[List[AddrInfoType]]:
+    """Convert an address tuple to a list of addr_info tuples."""
+    if addr is None:
+        return None
+    host = addr[0]
+    port = addr[1]
+    is_ipv6 = ":" in host
+    if is_ipv6:
+        flowinfo = 0
+        scopeid = 0
+        addr_len = len(addr)
+        if addr_len >= 4:
+            scopeid = addr[3]  # type: ignore[misc]
+        if addr_len >= 3:
+            flowinfo = addr[2]  # type: ignore[misc]
+        addr = (host, port, flowinfo, scopeid)
+        family = socket.AF_INET6
+    else:
+        addr = (host, port)
+        family = socket.AF_INET
+    return [(family, socket.SOCK_STREAM, socket.IPPROTO_TCP, "", addr)]
+
+
+def pop_addr_infos_interleave(
+    addr_infos: List[AddrInfoType], interleave: Optional[int] = None
+) -> None:
+    """
+    Pop addr_info from the list of addr_infos by family up to interleave times.
+
+    The interleave parameter is used to know how many addr_infos for
+    each family should be popped of the top of the list.
+    """
+    seen: Dict[int, int] = {}
+    if interleave is None:
+        interleave = 1
+    to_remove: List[AddrInfoType] = []
+    for addr_info in addr_infos:
+        family = addr_info[0]
+        if family not in seen:
+            seen[family] = 0
+        if seen[family] < interleave:
+            to_remove.append(addr_info)
+        seen[family] += 1
+    for addr_info in to_remove:
+        addr_infos.remove(addr_info)
+
+
+def _addr_tuple_to_ip_address(
+    addr: Union[Tuple[str, int], Tuple[str, int, int, int]]
+) -> Union[
+    Tuple[ipaddress.IPv4Address, int], Tuple[ipaddress.IPv6Address, int, int, int]
+]:
+    """Convert an address tuple to an IPv4Address."""
+    return (ipaddress.ip_address(addr[0]), *addr[1:])
+
+
+def remove_addr_infos(
+    addr_infos: List[AddrInfoType],
+    addr: Union[Tuple[str, int], Tuple[str, int, int, int]],
+) -> None:
+    """
+    Remove an address from the list of addr_infos.
+
+    The addr value is typically the return value of
+    sock.getpeername().
+    """
+    bad_addrs_infos: List[AddrInfoType] = []
+    for addr_info in addr_infos:
+        if addr_info[-1] == addr:
+            bad_addrs_infos.append(addr_info)
+    if bad_addrs_infos:
+        for bad_addr_info in bad_addrs_infos:
+            addr_infos.remove(bad_addr_info)
+        return
+    # Slow path in case addr is formatted differently
+    match_addr = _addr_tuple_to_ip_address(addr)
+    for addr_info in addr_infos:
+        if match_addr == _addr_tuple_to_ip_address(addr_info[-1]):
+            bad_addrs_infos.append(addr_info)
+    if bad_addrs_infos:
+        for bad_addr_info in bad_addrs_infos:
+            addr_infos.remove(bad_addr_info)
+        return
+    raise ValueError(f"Address {addr} not found in addr_infos")

parrot/lib/python3.10/site-packages/google/protobuf/__pycache__/descriptor_pb2.cpython-310.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8f7411f196ab7af30cb03dea4c904d1b55601b6c1dce9a01c94ca0b7fb77aa2d
+size 101191

parrot/lib/python3.10/site-packages/mdit_py_plugins/myst_blocks/index.py

@@ -0,0 +1,153 @@
+import itertools
+
+from markdown_it import MarkdownIt
+from markdown_it.common.utils import escapeHtml, isSpace
+from markdown_it.rules_block import StateBlock
+
+
+def myst_block_plugin(md: MarkdownIt):
+    """Parse MyST targets (``(name)=``), blockquotes (``% comment``) and block breaks (``+++``)."""
+    md.block.ruler.before(
+        "blockquote",
+        "myst_line_comment",
+        line_comment,
+        {"alt": ["paragraph", "reference", "blockquote", "list", "footnote_def"]},
+    )
+    md.block.ruler.before(
+        "hr",
+        "myst_block_break",
+        block_break,
+        {"alt": ["paragraph", "reference", "blockquote", "list", "footnote_def"]},
+    )
+    md.block.ruler.before(
+        "hr",
+        "myst_target",
+        target,
+        {"alt": ["paragraph", "reference", "blockquote", "list", "footnote_def"]},
+    )
+    md.add_render_rule("myst_target", render_myst_target)
+    md.add_render_rule("myst_line_comment", render_myst_line_comment)
+
+
+def line_comment(state: StateBlock, startLine: int, endLine: int, silent: bool):
+
+    pos = state.bMarks[startLine] + state.tShift[startLine]
+    maximum = state.eMarks[startLine]
+
+    # if it's indented more than 3 spaces, it should be a code block
+    if state.sCount[startLine] - state.blkIndent >= 4:
+        return False
+
+    if state.src[pos] != "%":
+        return False
+
+    if silent:
+        return True
+
+    token = state.push("myst_line_comment", "", 0)
+    token.attrSet("class", "myst-line-comment")
+    token.content = state.src[pos + 1 : maximum].rstrip()
+    token.markup = "%"
+
+    # search end of block while appending lines to `token.content`
+    for nextLine in itertools.count(startLine + 1):
+        if nextLine >= endLine:
+            break
+        pos = state.bMarks[nextLine] + state.tShift[nextLine]
+        maximum = state.eMarks[nextLine]
+
+        if state.src[pos] != "%":
+            break
+        token.content += "\n" + state.src[pos + 1 : maximum].rstrip()
+
+    state.line = nextLine
+    token.map = [startLine, nextLine]
+
+    return True
+
+
+def block_break(state: StateBlock, startLine: int, endLine: int, silent: bool):
+
+    pos = state.bMarks[startLine] + state.tShift[startLine]
+    maximum = state.eMarks[startLine]
+
+    # if it's indented more than 3 spaces, it should be a code block
+    if state.sCount[startLine] - state.blkIndent >= 4:
+        return False
+
+    marker = state.srcCharCode[pos]
+    pos += 1
+
+    # Check block marker /* + */
+    if marker != 0x2B:
+        return False
+
+    # markers can be mixed with spaces, but there should be at least 3 of them
+
+    cnt = 1
+    while pos < maximum:
+        ch = state.srcCharCode[pos]
+        if ch != marker and not isSpace(ch):
+            break
+        if ch == marker:
+            cnt += 1
+        pos += 1
+
+    if cnt < 3:
+        return False
+
+    if silent:
+        return True
+
+    state.line = startLine + 1
+
+    token = state.push("myst_block_break", "hr", 0)
+    token.attrSet("class", "myst-block")
+    token.content = state.src[pos:maximum].strip()
+    token.map = [startLine, state.line]
+    token.markup = chr(marker) * cnt
+
+    return True
+
+
+def target(state: StateBlock, startLine: int, endLine: int, silent: bool):
+
+    pos = state.bMarks[startLine] + state.tShift[startLine]
+    maximum = state.eMarks[startLine]
+
+    # if it's indented more than 3 spaces, it should be a code block
+    if state.sCount[startLine] - state.blkIndent >= 4:
+        return False
+
+    text = state.src[pos:maximum].strip()
+    if not text.startswith("("):
+        return False
+    if not text.endswith(")="):
+        return False
+    if not text[1:-2]:
+        return False
+
+    if silent:
+        return True
+
+    state.line = startLine + 1
+
+    token = state.push("myst_target", "", 0)
+    token.attrSet("class", "myst-target")
+    token.content = text[1:-2]
+    token.map = [startLine, state.line]
+
+    return True
+
+
+def render_myst_target(self, tokens, idx, options, env):
+    label = tokens[idx].content
+    class_name = "myst-target"
+    target = f'<a href="#{label}">({label})=</a>'
+    return f'<div class="{class_name}">{target}</div>'
+
+
+def render_myst_line_comment(self, tokens, idx, options, env):
+    # Strip leading whitespace from all lines
+    content = "\n".join(line.lstrip() for line in tokens[idx].content.split("\n"))
+    return f"<!-- {escapeHtml(content)} -->"

parrot/lib/python3.10/site-packages/mdit_py_plugins/texmath/README.md

@@ -0,0 +1,137 @@
+[![License](https://img.shields.io/github/license/goessner/markdown-it-texmath.svg)](https://github.com/goessner/markdown-it-texmath/blob/master/licence.txt)
+[![npm](https://img.shields.io/npm/v/markdown-it-texmath.svg)](https://www.npmjs.com/package/markdown-it-texmath)
+[![npm](https://img.shields.io/npm/dt/markdown-it-texmath.svg)](https://www.npmjs.com/package/markdown-it-texmath)
+
+# markdown-it-texmath
+
+Add TeX math equations to your Markdown documents rendered by [markdown-it](https://github.com/markdown-it/markdown-it) parser. [KaTeX](https://github.com/Khan/KaTeX) is used as a fast math renderer.
+
+## Features
+Simplify the process of authoring markdown documents containing math formulas.
+This extension is a comfortable tool for scientists, engineers and students with markdown as their first choice document format.
+
+* Macro support
+* Simple formula numbering
+* Inline math with tables, lists and blockquote.
+* User setting delimiters:
+  * `'dollars'` (default)
+    * inline: `$...$`
+    * display: `$$...$$`
+    * display + equation number: `$$...$$ (1)`
+  * `'brackets'`
+    * inline: `\(...\)`
+    * display: `\[...\]`
+    * display + equation number: `\[...\] (1)`
+  * `'gitlab'`
+    * inline: ``$`...`$``
+    * display: `` ```math ... ``` ``
+    * display + equation number: `` ```math ... ``` (1)``
+  * `'julia'`
+    * inline: `$...$`  or ``` ``...`` ```
+    * display: `` ```math ... ``` ``
+    * display + equation number: `` ```math ... ``` (1)``
+  * `'kramdown'`
+    * inline: ``$$...$$``
+    * display: `$$...$$`
+    * display + equation number: `$$...$$ (1)`
+
+## Show me
+
+View a [test table](https://goessner.github.io/markdown-it-texmath/index.html).
+
+[try it out ...](https://goessner.github.io/markdown-it-texmath/markdown-it-texmath-demo.html)
+
+## Use with `node.js`
+
+Install the extension. Verify having `markdown-it` and `katex` already installed .
+```
+npm install markdown-it-texmath
+```
+Use it with JavaScript.
+```js
+let kt = require('katex'),
+    tm = require('markdown-it-texmath').use(kt),
+    md = require('markdown-it')().use(tm,{delimiters:'dollars',macros:{"\\RR": "\\mathbb{R}"}});
+
+md.render('Euler\'s identity \(e^{i\pi}+1=0\) is a beautiful formula in $\\RR 2$.')
+```
+
+## Use in Browser
+```html
+<html>
+<head>
+  <meta charset='utf-8'>
+  <link rel="stylesheet" href="katex.min.css">
+  <link rel="stylesheet" href="texmath.css">
+  <script src="markdown-it.min.js"></script>
+  <script src="katex.min.js"></script>
+  <script src="texmath.js"></script>
+</head>
+<body>
+  <div id="out"></div>
+  <script>
+    let md;
+    document.addEventListener("DOMContentLoaded", () => {
+        const tm = texmath.use(katex);
+        md = markdownit().use(tm,{delimiters:'dollars',macros:{"\\RR": "\\mathbb{R}"}});
+        out.innerHTML = md.render('Euler\'s identity $e^{i\pi}+1=0$ is a beautiful formula in //RR 2.');
+    })
+  </script>
+</body>
+</html>
+```
+## CDN
+
+Use following links for `texmath.js` and `texmath.css`
+* `https://gitcdn.xyz/cdn/goessner/markdown-it-texmath/master/texmath.js`
+* `https://gitcdn.xyz/cdn/goessner/markdown-it-texmath/master/texmath.css`
+
+## Dependencies
+
+* [`markdown-it`](https://github.com/markdown-it/markdown-it): Markdown parser done right. Fast and easy to extend.
+* [`katex`](https://github.com/Khan/KaTeX): This is where credits for fast rendering TeX math in HTML go to.
+
+## ToDo
+
+ nothing yet
+
+## FAQ
+
+* __`markdown-it-texmath` with React Native does not work, why ?__
+  * `markdown-it-texmath` is using regular expressions with `y` [(sticky) property](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/sticky) and cannot avoid this. The use of the `y` flag in regular expressions means the plugin is not compatible with React Native (which as of now doesn't support it and throws an error `Invalid flags supplied to RegExp constructor`).
+
+## CHANGELOG
+
+###  [0.6.0] on October 04, 2019
+* Add support for [Julia Markdown](https://docs.julialang.org/en/v1/stdlib/Markdown/) on [request](https://github.com/goessner/markdown-it-texmath/issues/15).
+
+###  [0.5.5] on February 07, 2019
+* Remove [rendering bug with brackets delimiters](https://github.com/goessner/markdown-it-texmath/issues/9).
+
+###  [0.5.4] on January 20, 2019
+* Remove pathological [bug within blockquotes](https://github.com/goessner/mdmath/issues/50).
+
+###  [0.5.3] on November 11, 2018
+* Add support for Tex macros (https://katex.org/docs/supported.html#macros) .
+* Bug with [brackets delimiters](https://github.com/goessner/markdown-it-texmath/issues/9) .
+
+###  [0.5.2] on September 07, 2018
+* Add support for [Kramdown](https://kramdown.gettalong.org/) .
+
+###  [0.5.0] on August 15, 2018
+* Fatal blockquote bug investigated. Implemented workaround to vscode bug, which has finally gone with vscode 1.26.0 .
+
+###  [0.4.6] on January 05, 2018
+* Escaped underscore bug removed.
+
+###  [0.4.5] on November 06, 2017
+* Backslash bug removed.
+
+###  [0.4.4] on September 27, 2017
+* Modifying the `block` mode regular expression with `gitlab` delimiters, so removing the `newline` bug.
+
+## License
+
+`markdown-it-texmath` is licensed under the [MIT License](./license.txt)
+
+ © [Stefan Gössner](https://github.com/goessner)

parrot/lib/python3.10/site-packages/mdit_py_plugins/texmath/__init__.py

@@ -0,0 +1 @@
+from .index import texmath_plugin  # noqa F401

parrot/lib/python3.10/site-packages/simple_parsing/__init__.py

@@ -0,0 +1,60 @@
+"""Simple, Elegant Argument parsing.
+
+@author: Fabrice Normandin
+"""
+from . import helpers, utils, wrappers
+from .conflicts import ConflictResolution
+from .decorators import main
+from .help_formatter import SimpleHelpFormatter
+from .helpers import (
+    Partial,
+    Serializable,
+    choice,
+    config_for,
+    field,
+    flag,
+    list_field,
+    mutable_field,
+    subgroups,
+    subparsers,
+)
+from .parsing import (
+    ArgumentGenerationMode,
+    ArgumentParser,
+    DashVariant,
+    NestedMode,
+    ParsingError,
+    parse,
+    parse_known_args,
+)
+from .replace import replace, replace_subgroups
+from .utils import InconsistentArgumentError
+
+__all__ = [
+    "ArgumentGenerationMode",
+    "ArgumentParser",
+    "choice",
+    "config_for",
+    "ConflictResolution",
+    "DashVariant",
+    "field",
+    "flag",
+    "helpers",
+    "InconsistentArgumentError",
+    "list_field",
+    "main",
+    "mutable_field",
+    "NestedMode",
+    "parse_known_args",
+    "parse",
+    "ParsingError",
+    "Partial",
+    "replace",
+    "replace_subgroups",
+    "Serializable",
+    "SimpleHelpFormatter",
+    "subgroups",
+    "subparsers",
+    "utils",
+    "wrappers",
+]

parrot/lib/python3.10/site-packages/simple_parsing/annotation_utils/get_field_annotations.py

@@ -0,0 +1,251 @@
+import collections
+import inspect
+import sys
+import types
+import typing
+from contextlib import contextmanager
+from dataclasses import InitVar
+from itertools import dropwhile
+from logging import getLogger as get_logger
+from typing import Any, Dict, Iterator, Optional, get_type_hints
+
+logger = get_logger(__name__)
+
+# NOTE: This dict is used to enable forward compatibility with things such as `tuple[int, str]`,
+# `list[float]`, etc. when using `from __future__ import annotations`.
+forward_refs_to_types = {
+    "tuple": typing.Tuple,
+    "set": typing.Set,
+    "dict": typing.Dict,
+    "list": typing.List,
+    "type": typing.Type,
+}
+
+
+@contextmanager
+def _initvar_patcher() -> Iterator[None]:
+    """Patch InitVar to not fail when annotations are postponed.
+
+    `TypeVar('Forward references must evaluate to types. Got dataclasses.InitVar[tp].')` is raised
+    when postponed annotations are enabled and `get_type_hints` is called
+    Bug is mentioned here https://github.com/python/cpython/issues/88962
+    In python 3.11 this is fixed, but backport fix is not planned for old releases
+
+    Workaround is mentioned here https://stackoverflow.com/q/70400639
+    """
+    if sys.version_info[:2] < (3, 11):
+        InitVar.__call__ = lambda *args: None
+    yield
+    if sys.version_info[:2] < (3, 11):
+        del InitVar.__call__
+
+
+def evaluate_string_annotation(annotation: str, containing_class: Optional[type] = None) -> type:
+    """Attempts to evaluate the given annotation string, to get a 'live' type annotation back.
+
+    Any exceptions that are raised when evaluating are raised directly as-is.
+
+    NOTE: This is probably not 100% safe. I mean, if the user code puts urls and stuff in their
+    type annotations, and then uses simple-parsing, then sure, that code might get executed. But
+    I don't think it's my job to prevent them from shooting themselves in the foot, you know what I
+    mean?
+    """
+    # The type of the field might be a string when using `from __future__ import annotations`.
+    # Get the local and global namespaces to pass to the `get_type_hints` function.
+    local_ns: Dict[str, Any] = {"typing": typing, **vars(typing)}
+    local_ns.update(forward_refs_to_types)
+    global_ns = {}
+    if containing_class:
+        # Get the globals in the module where the class was defined.
+        global_ns = sys.modules[containing_class.__module__].__dict__
+
+    if "|" in annotation:
+        annotation = _get_old_style_annotation(annotation)
+    evaluated_t: type = eval(annotation, local_ns, global_ns)
+    return evaluated_t
+
+
+def _replace_UnionType_with_typing_Union(annotation):
+    from simple_parsing.utils import builtin_types, is_dict, is_list, is_tuple
+
+    if sys.version_info[:2] < (3, 10):
+        # This is only useful for python 3.10+ (where UnionTypes exist).
+        # Therefore just return the annotation as-is.
+        return annotation
+
+    if isinstance(annotation, types.UnionType):  # type: ignore
+        union_args = typing.get_args(annotation)
+        new_union_args = tuple(_replace_UnionType_with_typing_Union(arg) for arg in union_args)
+        return typing.Union[new_union_args]  # type: ignore
+    if is_list(annotation):
+        item_annotation = typing.get_args(annotation)[0]
+        new_item_annotation = _replace_UnionType_with_typing_Union(item_annotation)
+        return typing.List[new_item_annotation]
+    if is_tuple(annotation):
+        item_annotations = typing.get_args(annotation)
+        new_item_annotations = tuple(
+            _replace_UnionType_with_typing_Union(arg) for arg in item_annotations
+        )
+        return typing.Tuple[new_item_annotations]  # type: ignore
+    if is_dict(annotation):
+        annotations = typing.get_args(annotation)
+        if not annotations:
+            return typing.Dict
+        assert len(annotations) == 2
+        key_annotation = annotations[0]
+        value_annotation = annotations[1]
+        new_key_annotation = _replace_UnionType_with_typing_Union(key_annotation)
+        new_value_annotation = _replace_UnionType_with_typing_Union(value_annotation)
+        return typing.Dict[new_key_annotation, new_value_annotation]
+    if annotation in builtin_types:
+        return annotation
+    if inspect.isclass(annotation):
+        return annotation
+    raise NotImplementedError(annotation)
+
+
+#     # return forward_refs_to_types.get(ann, local_ns.get(ann, global_ns.get(ann, getattr(builtins, ann, ann))))
+
+
+def _not_supported(annotation) -> typing.NoReturn:
+    raise NotImplementedError(f"Don't yet support annotations like this: {annotation}")
+
+
+def _get_old_style_annotation(annotation: str) -> str:
+    """Replaces A | B with Union[A,B] in the annotation."""
+    # TODO: Add proper support for things like `list[int | float]`, which isn't currently
+    # working, even without the new-style union.
+    if "|" not in annotation:
+        return annotation
+
+    annotation = annotation.strip()
+    if "[" not in annotation:
+        assert "]" not in annotation
+        return "Union[" + ", ".join(v.strip() for v in annotation.split("|")) + "]"
+
+    before, lsep, rest = annotation.partition("[")
+    middle, rsep, after = rest.rpartition("]")
+    # BUG: Need to handle things like bob[int] | None
+    assert (
+        not after.strip()
+    ), f"can't have text at HERE in <something>[<something>]<HERE>!: {annotation}"
+
+    if "|" in before or "|" in after:
+        _not_supported(annotation)
+    assert "|" in middle
+
+    if "," in middle:
+        parts = [v.strip() for v in middle.split(",")]
+        parts = [_get_old_style_annotation(part) for part in parts]
+        middle = ", ".join(parts)
+
+    new_middle = _get_old_style_annotation(annotation=middle)
+    new_annotation = before + lsep + new_middle + rsep + after
+    return new_annotation
+
+
+def _replace_new_union_syntax_with_old_union_syntax(
+    annotations_dict: Dict[str, str], context: collections.ChainMap
+) -> Dict[str, Any]:
+    new_annotations = annotations_dict.copy()
+    for field, annotation_str in annotations_dict.items():
+        updated_annotation = _get_old_style_annotation(annotation_str)
+        new_annotations[field] = updated_annotation
+
+    return new_annotations
+
+
+def get_field_type_from_annotations(some_class: type, field_name: str) -> type:
+    """Get the annotation for the given field, in the 'old-style' format with types from
+    typing.List, typing.Union, etc.
+
+    If the script uses `from __future__ import annotations`, and we are in python<3.9,
+    Then we need to actually first make this forward-compatibility 'patch' so that we
+    don't run into a "`type` object is not subscriptable" error.
+
+    NOTE: If you get errors of this kind from the function below, then you might want to add an
+    entry to the `forward_refs_to_types` dict above.
+    """
+
+    # Pretty hacky: Modify the type annotations of the class (preferably a copy of the class
+    # if possible, to avoid modifying things in-place), and replace  the `a | b`-type
+    # expressions with `Union[a, b]`, so that `get_type_hints` doesn't raise an error.
+    # The type of the field might be a string when using `from __future__ import annotations`.
+
+    # The type of the field might be a string when using `from __future__ import annotations`.
+    # Get the local and global namespaces to pass to the `get_type_hints` function.
+    local_ns: Dict[str, Any] = {"typing": typing, **vars(typing)}
+    local_ns.update(forward_refs_to_types)
+
+    # NOTE: Get the local namespace of the calling function / module where this class is defined,
+    # and use it to get the correct type of the field, if it is a forward reference.
+    frame = inspect.currentframe()
+    # stack = []
+    while frame.f_back is not None and frame.f_locals.get(some_class.__name__) is not some_class:
+        # stack.append(frame)
+        frame = frame.f_back
+    # Found the frame with the dataclass definition. Update the locals. This makes it possible to
+    # use dataclasses defined in local scopes!
+    if frame is not None:
+        local_ns.update(frame.f_locals)
+
+    # Get the global_ns in the module starting from the deepest base until the module with the field_name last definition.
+    global_ns = {}
+    classes_to_iterate = list(
+        dropwhile(
+            lambda cls: field_name not in getattr(cls, "__annotations__", {}), some_class.mro()
+        )
+    )
+    for base_cls in reversed(classes_to_iterate):
+        global_ns.update(sys.modules[base_cls.__module__].__dict__)
+
+    try:
+        with _initvar_patcher():
+            annotations_dict = get_type_hints(some_class, localns=local_ns, globalns=global_ns)
+    except TypeError:
+        annotations_dict = collections.ChainMap(
+            *[getattr(cls, "__annotations__", {}) for cls in some_class.mro()]
+        )
+
+    if field_name not in annotations_dict:
+        raise ValueError(f"Field {field_name} not found in annotations of class {some_class}")
+
+    field_type = annotations_dict[field_name]
+
+    if sys.version_info[:2] >= (3, 7) and isinstance(field_type, typing.ForwardRef):
+        # Weird bug happens when mixing postponed evaluation of type annotations + forward
+        # references: The ForwardRefs are left as-is, and not evaluated!
+        forward_arg = field_type.__forward_arg__
+        field_type = forward_arg
+
+    if sys.version_info >= (3, 10) and isinstance(field_type, types.UnionType):
+        # In python >= 3.10, int | float is allowed. Therefore, just to be consistent, we want
+        # to convert those into the corresponding typing.Union type.
+        # This is necessary for the rest of the code to work, since it's all based on typing.Union.
+        field_type = _replace_UnionType_with_typing_Union(field_type)
+
+    if isinstance(field_type, str) and "|" in field_type:
+        field_type = _get_old_style_annotation(field_type)
+
+        # Pretty hacky:
+        # In order to use `get_type_hints`, we need to pass it a class. We can't just ask it to
+        # evaluate a single annotation. Therefore, we create a temporary class and set it's
+        # __annotation__ attribute, which is introspected by `get_type_hints`.
+
+    try:
+
+        class Temp_:
+            pass
+
+        Temp_.__annotations__ = {field_name: field_type}
+        with _initvar_patcher():
+            annotations_dict = get_type_hints(Temp_, globalns=global_ns, localns=local_ns)
+        field_type = annotations_dict[field_name]
+    except Exception:
+        logger.warning(
+            f"Unable to evaluate forward reference {field_type} for field '{field_name}'.\n"
+            f"Leaving it as-is."
+        )
+        field_type = field_type
+
+    return field_type

parrot/lib/python3.10/site-packages/simple_parsing/conflicts.py

@@ -0,0 +1,389 @@
+from __future__ import annotations
+
+import enum
+from collections import defaultdict
+from logging import getLogger
+from typing import NamedTuple
+
+from .wrappers import DataclassWrapper, FieldWrapper
+
+logger = getLogger(__name__)
+
+
+class ConflictResolution(enum.Enum):
+    """Determines prefixing when adding the same dataclass more than once.
+
+    - NONE:
+        Disallow using the same dataclass in two different destinations without
+        explicitly setting a distinct prefix for at least one of them.
+
+    - EXPLICIT:
+        When adding arguments for a dataclass that is already present, the
+        argparse arguments for each class will use their full absolute path as a
+        prefix.
+
+    - ALWAYS_MERGE:
+        When adding arguments for a dataclass that has previously been added,
+        the arguments for both the old and new destinations will be set using
+        the same option_string, and the passed values for the old and new
+        destinations will correspond to the first and second values,
+        respectively.
+        NOTE: This changes the argparse type for that argument into a list of
+        the original item type.
+
+    - AUTO (default):
+        Prefixes for each destination are created automatically, using the first
+        discriminative prefix that can differentiate between all the conflicting
+        arguments.
+    """
+
+    NONE = -1
+    EXPLICIT = 0
+    ALWAYS_MERGE = 1
+    AUTO = 2
+
+
+class ConflictResolutionError(Exception):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+
+class Conflict(NamedTuple):
+    option_string: str
+    wrappers: list[FieldWrapper]
+
+
+def unflatten(possibly_related_wrappers: list[DataclassWrapper]) -> list[DataclassWrapper]:
+    return [wrapper for wrapper in possibly_related_wrappers if wrapper.parent is None]
+
+
+class ConflictResolver:
+    def __init__(self, conflict_resolution=ConflictResolution.AUTO):
+        self.conflict_resolution = conflict_resolution
+        self.max_attempts = 50
+
+    def resolve_and_flatten(self, wrappers: list[DataclassWrapper]) -> list[DataclassWrapper]:
+        """Given the list of all dataclass wrappers, find and resolve any conflicts between fields.
+
+        Returns the new list of (possibly mutated in-place) dataclass wrappers. This returned list
+        is flattened, i.e. it contains all the dataclass wrappers and their children.
+        """
+        from simple_parsing.parsing import _assert_no_duplicates, _flatten_wrappers
+
+        wrappers = wrappers.copy()
+
+        _assert_no_duplicates(wrappers)
+        wrappers_flat = _flatten_wrappers(wrappers)
+
+        dests = [w.dest for w in wrappers_flat]
+        assert len(dests) == len(set(dests)), f"shouldn't be any duplicates: {wrappers_flat}"
+
+        conflict = self.get_conflict(wrappers_flat)
+
+        # current and maximum number of attempts. When reached, raises an error.
+        cur_attempts = 0
+        while conflict:
+            message: str = (
+                "The following wrappers are in conflict, as they share the "
+                + f"'{conflict.option_string}' option string:"
+                + ("\n".join(str(w) for w in conflict.wrappers))
+                + f"(Conflict Resolution mode is {self.conflict_resolution})"
+            )
+            logger.debug(message)
+
+            if self.conflict_resolution == ConflictResolution.NONE:
+                raise ConflictResolutionError(message)
+
+            elif self.conflict_resolution == ConflictResolution.EXPLICIT:
+                self._fix_conflict_explicit(conflict)
+
+            elif self.conflict_resolution == ConflictResolution.ALWAYS_MERGE:
+                wrappers_flat = self._fix_conflict_merge(conflict, wrappers_flat)
+
+            elif self.conflict_resolution == ConflictResolution.AUTO:
+                self._fix_conflict_auto(conflict)
+
+            conflict = self.get_conflict(wrappers_flat)
+            cur_attempts += 1
+            if cur_attempts == self.max_attempts:
+                raise ConflictResolutionError(
+                    f"Reached maximum number of attempts ({self.max_attempts}) "
+                    "while trying to solve the conflicting argument names. "
+                    "This is either a bug, or there is something weird going "
+                    "on with your class hierarchy/argument names... \n"
+                    "In any case, Please help us by submitting an issue on "
+                    "the Github repo at "
+                    "https://github.com/lebrice/SimpleParsing/issues, "
+                    "or by using the following link: "
+                    "https://github.com/lebrice/SimpleParsing/issues/new?"
+                    "assignees=lebrice&"
+                    "labels=bug"
+                    "&template=bug_report.md"
+                    "&title=BUG: ConflictResolutionError"
+                )
+
+        assert not self._conflict_exists(wrappers_flat)
+        return wrappers_flat
+
+    def resolve(self, wrappers: list[DataclassWrapper]) -> list[DataclassWrapper]:
+        return unflatten(self.resolve_and_flatten(wrappers))
+
+    def get_conflict(
+        self, wrappers: list[DataclassWrapper] | list[FieldWrapper]
+    ) -> Conflict | None:
+        field_wrappers: list[FieldWrapper] = []
+        for w in wrappers:
+            if isinstance(w, DataclassWrapper):
+                field_wrappers.extend(w.fields)
+                # logger.debug(f"Wrapper {w.dest} has fields {w.fields}")
+            else:
+                field_wrappers.append(w)
+
+        assert len(field_wrappers) == len(set(field_wrappers)), "duplicates?"
+
+        # TODO: #49: Also consider the conflicts with regular argparse arguments.
+        conflicts: dict[str, list[FieldWrapper]] = defaultdict(list)
+        for field_wrapper in field_wrappers:
+            for option_string in field_wrapper.option_strings:
+                conflicts[option_string].append(field_wrapper)
+                # logger.debug(f"conflicts[{option_string}].append({repr(field_wrapper)})")
+
+        for option_string, field_wrappers in conflicts.items():
+            if len(field_wrappers) > 1:
+                return Conflict(option_string, field_wrappers)
+        return None
+
+    def _add(
+        self,
+        wrapper: DataclassWrapper | FieldWrapper,
+        wrappers: list[DataclassWrapper],
+    ) -> list[DataclassWrapper]:
+        """Add the given wrapper and all its descendants to the list of wrappers."""
+        if isinstance(wrapper, FieldWrapper):
+            wrapper = wrapper.parent
+        assert isinstance(wrapper, DataclassWrapper)
+        logger.debug(f"Adding new DataclassWrapper: {wrapper}")
+        wrappers.append(wrapper)
+        wrappers.extend(wrapper.descendants)
+
+        return wrappers
+
+    def _remove(
+        self,
+        wrapper: DataclassWrapper | FieldWrapper,
+        wrappers: list[DataclassWrapper],
+    ):
+        """Remove the given wrapper and all its descendants from the list of wrappers."""
+        if isinstance(wrapper, FieldWrapper):
+            wrapper = wrapper.parent
+        assert isinstance(wrapper, DataclassWrapper)
+        logger.debug(f"Removing DataclassWrapper {wrapper}")
+        wrappers.remove(wrapper)
+        for child in wrapper.descendants:
+            logger.debug(f"\tAlso removing Child DataclassWrapper {child}")
+            wrappers.remove(child)
+        # TODO: Should we also remove the reference to this wrapper from its parent?
+        for other_wrapper in wrappers:
+            if wrapper in other_wrapper._children:
+                other_wrapper._children.remove(wrapper)
+        return wrappers
+
+    def _fix_conflict_explicit(self, conflict: Conflict):
+        """Fixes conflicts between arguments following the "Explicit" approach.
+
+        The Explicit approach gives a prefix to each argument which points to
+        exactly where the argument is stored in the resulting Namespace. There
+        can therefore not be any confusion between arguments, at the cost of
+        having lengthy option strings.
+
+        Parameters
+        ----------
+        - conflict : Conflict
+
+            The conflict to hangle/fix.
+
+        Raises
+        ------
+        ConflictResolutionError
+            If its impossibe to fix the conflict.
+        """
+        logger.debug(f"fixing explicit conflict: {conflict}")
+
+        if any(w.prefix for w in conflict.wrappers):
+            raise ConflictResolutionError(
+                "When in 'Explicit' mode, there shouldn't be a need for any user-set prefixes."
+                "Just let the ArgumentParser set the explicit prefixes for all fields, and there won't be a conflict."
+            )
+        # TODO: Only set an explicit prefix on the fields that are in conflict
+
+        # Check that there is no conflict between the fields after setting the explicit prefix.
+        # If there is, that means that this conflict can't be fixed automatically, and a manual prefix should be set by the user.
+        for field_wrapper in conflict.wrappers:
+            explicit_prefix = field_wrapper.parent.dest + "."
+            field_wrapper.prefix = explicit_prefix
+
+        another_conflict = self.get_conflict(conflict.wrappers)
+        if another_conflict and another_conflict.option_string == conflict.option_string:
+            raise ConflictResolutionError(
+                f"There is a conflict over the '{conflict.option_string}' "
+                "option string, even after adding an explicit prefix to all "
+                "the conflicting fields! \n"
+                "To solve this, You can either use a different argument name, "
+                "a different destination, or pass a differentiating prefix to "
+                "`parser.add_arguments(<dataclass>, dest=destination, "
+                "prefix=prefix)`"
+            )
+
+    def _fix_conflict_auto(self, conflict: Conflict):
+        """Fixes a conflict using the AUTO method.
+
+        Tries to find a discriminating prefix of minimal length for all the conflicting fields, using roughly the following pseudocode:
+
+        1.  Sort the field wrappers by ascending nesting level.
+            ("parent/root" wrappers first, children "leaf" wrappers last)
+        2.  If the first wrapper is less nested than the others, remove it from the list (don't change its prefix)
+        3.  For all the remaining wrappers, add one more "word" from their lineage (dest attribute) to their prefix,
+            starting from the end and moving towards the parent.
+        4.  If there is no conflict left, exit, else, return to step 1 with the new conflict.
+            (This is performed implicitly by the method that calls this function, since it loops while there is a conflict).
+
+        Parameters
+        ----------
+        - conflict : Conflict
+
+            The Conflict NamedTuple containing the conflicting option_string, as well as the conflicting `FieldWrapper`s.
+
+        Raises
+        ------
+        ConflictResolutionError
+            If its impossibe to fix the conflict.
+        """
+        field_wrappers = sorted(conflict.wrappers, key=lambda w: w.nesting_level)
+        logger.debug(f"Conflict with options string '{conflict.option_string}':")
+        for i, field in enumerate(field_wrappers):
+            logger.debug(f"Field wrapper #{i+1}: {field} nesting level: {field.nesting_level}.")
+
+        assert (
+            len(set(field_wrappers)) >= 2
+        ), "Need at least 2 (distinct) FieldWrappers to have a conflict..."
+
+        first_wrapper = field_wrappers[0]
+        second_wrapper = field_wrappers[1]
+        if first_wrapper.nesting_level < second_wrapper.nesting_level:
+            # IF the first field_wrapper is a 'parent' of the following field_wrappers, then it maybe doesn't need an additional prefix.
+            logger.debug(
+                f"The first FieldWrapper is less nested than the others, removing it. ({first_wrapper})"
+            )
+            field_wrappers.remove(first_wrapper)
+
+        # add one more word to each of the remaining field_wrappers.
+        for field_wrapper in field_wrappers:
+            # Get the current and explicit (maximum) prefix:
+            current_prefix = field_wrapper.prefix
+            explicit_prefix = field_wrapper.parent.dest + "."
+
+            logger.debug(f"current prefix: {current_prefix}, explicit prefix: {explicit_prefix}")
+            if current_prefix == explicit_prefix:
+                # We can't add any more words to the prefix of this FieldWrapper,
+                # as it has already a prefix equivalent to its full destination...
+                raise ConflictResolutionError(
+                    " ".join(
+                        [
+                            f"Cannot fix the conflict for the Options string {conflict.option_string},",
+                            f"as the field {field_wrapper} already has the most explicit",
+                            "prefix possible, and thus we can't add an additional",
+                            "discriminating word to its prefix.",
+                            "\n Consider modifying either the destination or the prefix",
+                            "passed to `parser.add_arguments(<dataclass>, dest=destination, prefix=prefix)",
+                        ]
+                    )
+                )
+
+            # find the next 'word' to add to the prefix.
+            available_words = list(filter(bool, explicit_prefix.split(".")))
+            used_words = list(filter(bool, current_prefix.split(".")))
+            assert len(available_words) > len(
+                used_words
+            ), "There should at least one word we haven't used yet!"
+            logger.debug(f"Available words: {available_words}, used_words: {used_words}")
+
+            n_available_words = len(available_words)
+            n_used_words = len(used_words)
+            word_to_add = available_words[(n_available_words - 1) - n_used_words]
+            logger.debug(f"Word to be added: {word_to_add}")
+            field_wrapper.prefix = word_to_add + "." + current_prefix
+            logger.debug(f"New prefix: {field_wrapper.prefix}")
+
+    def _fix_conflict_merge(self, conflict: Conflict, wrappers_flat: list[DataclassWrapper]):
+        """Fix conflicts using the merging approach.
+
+        The first wrapper is kept, and the rest of the wrappers are absorbed
+        into the first wrapper.
+
+        # TODO: check that the ordering of arguments is still preserved!
+
+        Parameters
+        ----------
+        conflict : Conflict
+            The conflict NamedTuple.
+        """
+        fields = sorted(conflict.wrappers, key=lambda w: w.nesting_level)
+        logger.debug(f"Conflict with options string '{conflict.option_string}':")
+        for field in fields:
+            logger.debug(f"Field wrapper: {field} nesting level: {field.nesting_level}.")
+
+        assert len(conflict.wrappers) > 1
+
+        # Merge all the fields into the first one.
+        first_wrapper: FieldWrapper = fields[0]
+        wrappers = wrappers_flat.copy()
+
+        first_containing_dataclass: DataclassWrapper = first_wrapper.parent
+        original_parent = first_containing_dataclass.parent
+        wrappers = self._remove(first_containing_dataclass, wrappers)
+
+        for wrapper in conflict.wrappers[1:]:
+            containing_dataclass = wrapper.parent
+            wrappers = self._remove(containing_dataclass, wrappers)
+            first_containing_dataclass.merge(containing_dataclass)
+
+        assert first_containing_dataclass.multiple
+        wrappers = self._add(first_containing_dataclass, wrappers)
+        if original_parent:
+            original_parent._children.append(first_containing_dataclass)
+        return wrappers
+
+    def _get_conflicting_group(self, all_wrappers: list[DataclassWrapper]) -> Conflict | None:
+        """Return the conflicting DataclassWrappers which share argument names.
+
+        TODO: maybe return the list of fields, rather than the dataclasses?
+        """
+        conflicts: dict[str, list[FieldWrapper]] = defaultdict(list)
+        for wrapper in all_wrappers:
+            for field in wrapper.fields:
+                for option in field.option_strings:
+                    conflicts[option].append(field)
+
+        for option_string, fields in conflicts.items():
+            if len(fields) > 1:
+                # the dataclasses of the fields that share the same name.
+                # wrappers: List[DataclassWrapper] = [f.parent for f in fields]
+                # dataclasses = [wrapper.dataclass for wrapper in wrappers]
+                # prefixes = [wrapper.prefix for wrapper in wrappers]
+                # return Conflict(dataclasses[0], prefixes[0], wrappers)
+                return Conflict(option_string, fields)
+        return None
+
+    def _conflict_exists(self, all_wrappers: list[DataclassWrapper]) -> bool:
+        """Return True whenever a conflict exists.
+
+        (option strings overlap).
+        """
+        arg_names: set[str] = set()
+        for wrapper in all_wrappers:
+            for field in wrapper.fields:
+                for option in field.option_strings:
+                    if option in arg_names:
+                        return True
+                    arg_names.add(option)
+        return False

parrot/lib/python3.10/site-packages/simple_parsing/decorators.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+
+import collections
+import dataclasses
+import functools
+import inspect
+import typing
+from typing import Any, Callable, NamedTuple
+
+import docstring_parser as dp
+
+from simple_parsing.docstring import dp_parse, inspect_getdoc
+
+from . import helpers, parsing
+
+
+class _Field(NamedTuple):
+    name: str
+    annotation: type
+    field: dataclasses.Field
+
+
+def _description_from_docstring(docstring: dp.Docstring) -> str:
+    """Construct a description from the short and long description of a docstring."""
+    description = ""
+    if docstring.short_description:
+        description += f"{docstring.short_description}\n"
+        if docstring.blank_after_short_description:
+            description += "\n"
+    if docstring.long_description:
+        description += f"{docstring.long_description}\n"
+        if docstring.blank_after_long_description:
+            description += "\n"
+    return description
+
+
+@typing.overload
+def main(original_function: None = None, **sp_kwargs) -> Callable[..., Callable[..., Any]]:
+    ...
+
+
+@typing.overload
+def main(original_function: Callable[..., Any], **sp_kwargs) -> Callable[..., Any]:
+    ...
+
+
+def main(original_function=None, **sp_kwargs):
+    """Parse a function's arguments using simple-parsing from type annotations."""
+
+    def _decorate_with_cli_args(function: Callable[..., Any]) -> Callable[..., Any]:
+        """Decorate `function` by binding its arguments obtained from simple-parsing."""
+
+        @functools.wraps(function)
+        def _wrapper(*other_args, **other_kwargs) -> Any:
+            # Parse signature and parameters
+            signature = inspect.signature(function, follow_wrapped=True)
+            parameters = signature.parameters
+
+            # Parse docstring to use as help strings
+            docstring = dp_parse(inspect_getdoc(function) or "")
+            docstring_param_description = {
+                param.arg_name: param.description for param in docstring.params
+            }
+
+            # Parse all arguments from the function
+            fields = []
+            for name, parameter in parameters.items():
+                # Replace empty annotation with Any
+                if parameter.annotation == inspect.Parameter.empty:
+                    parameter = parameter.replace(annotation=Any)
+
+                # Parse default or default_factory if the default is callable.
+                default, default_factory = dataclasses.MISSING, dataclasses.MISSING
+                if parameter.default != inspect.Parameter.empty:
+                    if inspect.isfunction(parameter.default):
+                        default_factory = parameter.default
+                    else:
+                        default = parameter.default
+
+                field = _Field(
+                    name,
+                    parameter.annotation,
+                    helpers.field(
+                        name=name,
+                        default=default,
+                        default_factory=default_factory,
+                        help=docstring_param_description.get(name, ""),
+                        positional=parameter.kind == inspect.Parameter.POSITIONAL_ONLY,
+                    ),
+                )
+                fields.append(field)
+
+            # We can have positional arguments with no defaults that come out of order
+            # when parsing the function signature. Therefore, before we construct
+            # the dataclass we have to sort fields according to their default value.
+            # We query fields by name so there's no need to worry about the order.
+            def _field_has_default(field: _Field) -> bool:
+                return (
+                    field.field.default is not dataclasses.MISSING
+                    or field.field.default_factory is not dataclasses.MISSING
+                )
+
+            fields = sorted(fields, key=_field_has_default)
+
+            # Create the dataclass using the fields derived from the function's signature
+            FunctionArgs = dataclasses.make_dataclass(function.__qualname__, fields)
+            FunctionArgs.__doc__ = _description_from_docstring(docstring) or None
+            function_args = parsing.parse(
+                FunctionArgs,
+                dest="args",
+                add_config_path_arg=False,
+                **sp_kwargs,
+            )
+
+            # Construct both positional and keyword arguments.
+            args, kwargs = [], {}
+            for field in dataclasses.fields(function_args):
+                value = getattr(function_args, field.name)
+                if field.metadata.get("positional", False):
+                    args.append(value)
+                else:
+                    # TODO: py39: use union operator (|=)
+                    kwargs.update({field.name: value})
+
+            # Construct positional arguments with CLI and runtime args
+            positionals = (*args, *other_args)
+            # Construct keyword arguments so it can override arguments
+            # so we don't receive multiple value errors.
+            keywords = collections.ChainMap(kwargs, other_kwargs)
+
+            # Call the function
+            return function(*positionals, **keywords)
+
+        return _wrapper
+
+    if original_function:
+        return _decorate_with_cli_args(original_function)
+
+    return _decorate_with_cli_args

parrot/lib/python3.10/site-packages/simple_parsing/docstring.py

@@ -0,0 +1,385 @@
+"""Utility for retrieveing the docstring of a dataclass's attributes.
+
+@author: Fabrice Normandin
+"""
+from __future__ import annotations
+
+import functools
+import inspect
+
+# from inspect import
+from dataclasses import dataclass
+from logging import getLogger
+
+import docstring_parser as dp
+from docstring_parser.common import Docstring
+
+dp_parse = functools.lru_cache(2048)(dp.parse)
+inspect_getsource = functools.lru_cache(2048)(inspect.getsource)
+inspect_getdoc = functools.lru_cache(2048)(inspect.getdoc)
+logger = getLogger(__name__)
+
+
+@dataclass
+class AttributeDocString:
+    """Simple dataclass for holding the comments of a given field."""
+
+    comment_above: str = ""
+    comment_inline: str = ""
+    docstring_below: str = ""
+
+    desc_from_cls_docstring: str = ""
+    """The description of this field from the class docstring."""
+
+    @property
+    def help_string(self) -> str:
+        """Returns the value that will be used for the "--help" string, using the contents of
+        self."""
+        return (
+            self.docstring_below
+            or self.comment_above
+            or self.comment_inline
+            or self.desc_from_cls_docstring
+        )
+
+
+def get_attribute_docstring(
+    dataclass: type, field_name: str, accumulate_from_bases: bool = True
+) -> AttributeDocString:
+    """Returns the docstrings of a dataclass field.
+    NOTE: a docstring can either be:
+    - An inline comment, starting with <#>
+    - A Comment on the preceding line, starting with <#>
+    - A docstring on the following line, starting with either <\"\"\"> or <'''>
+    - The description of a field in the classes's docstring.
+
+    Arguments:
+        some_dataclass: a dataclass
+        field_name: the name of the field.
+        accumulate_from_bases: Whether to accumulate the docstring components by looking through the
+            base classes. When set to `False`, whenever one of the classes has a definition for the
+            field, it is directly returned. Otherwise, we accumulate the parts of the dodc
+    Returns:
+        AttributeDocString -- an object holding the string descriptions of the field.
+    """
+    created_docstring: AttributeDocString | None = None
+
+    mro = inspect.getmro(dataclass)
+    assert mro[0] is dataclass
+    assert mro[-1] is object
+    mro = mro[:-1]
+    for base_class in mro:
+        attribute_docstring = _get_attribute_docstring(base_class, field_name)
+        if not attribute_docstring:
+            continue
+        if not created_docstring:
+            created_docstring = attribute_docstring
+            if not accumulate_from_bases:
+                # We found a definition for that field in that class, so return it directly.
+                return created_docstring
+        else:
+            # Update the fields.
+            created_docstring.comment_above = (
+                created_docstring.comment_above or attribute_docstring.comment_above
+            )
+            created_docstring.comment_inline = (
+                created_docstring.comment_inline or attribute_docstring.comment_inline
+            )
+            created_docstring.docstring_below = (
+                created_docstring.docstring_below or attribute_docstring.docstring_below
+            )
+            created_docstring.desc_from_cls_docstring = (
+                created_docstring.desc_from_cls_docstring
+                or attribute_docstring.desc_from_cls_docstring
+            )
+    if not created_docstring:
+        logger.debug(
+            RuntimeWarning(
+                f"Couldn't find the definition for field '{field_name}' within the dataclass "
+                f"{dataclass} or any of its base classes {','.join(t.__name__ for t in mro[1:])}."
+            )
+        )
+        return AttributeDocString()
+    return created_docstring
+
+
+@functools.lru_cache(2048)
+def _get_attribute_docstring(dataclass: type, field_name: str) -> AttributeDocString | None:
+    """Gets the AttributeDocString of the given field in the given dataclass.
+
+    Doesn't inspect base classes.
+    """
+    try:
+        source = inspect_getsource(dataclass)
+    except (TypeError, OSError) as e:
+        logger.debug(
+            UserWarning(
+                f"Couldn't retrieve the source code of class {dataclass} "
+                f"(in order to retrieve the docstring of field {field_name}): {e}"
+            )
+        )
+        return None
+
+    # Parse docstring to use as help strings
+    desc_from_cls_docstring = ""
+    cls_docstring = inspect_getdoc(dataclass)
+    if cls_docstring:
+        docstring: Docstring = dp_parse(cls_docstring)
+        for param in docstring.params:
+            if param.arg_name == field_name:
+                desc_from_cls_docstring = param.description or ""
+
+    # NOTE: We want to skip the docstring lines.
+    # NOTE: Currently, we just remove the __doc__ from the source. It's perhaps a bit crude,
+    # but it works.
+    if dataclass.__doc__ and dataclass.__doc__ in source:
+        source = source.replace(dataclass.__doc__, "\n", 1)
+        # note: does this remove the whitespace though?
+
+    code_lines: list[str] = source.splitlines()
+    # the first line is the class definition (OR the decorator!), we skip it.
+    start_line_index = 1
+    # starting at the second line, there might be the docstring for the class.
+    # We want to skip over that until we reach an attribute definition.
+    while start_line_index < len(code_lines):
+        if _contains_field_definition(code_lines[start_line_index]):
+            break
+        start_line_index += 1
+
+    lines_with_field_defs = [
+        (index, line) for index, line in enumerate(code_lines) if _contains_field_definition(line)
+    ]
+    for i, line in lines_with_field_defs:
+        if _line_contains_definition_for(line, field_name):
+            # we found the line with the definition of this field.
+            comment_above = _get_comment_ending_at_line(code_lines, i - 1)
+            comment_inline = _get_inline_comment_at_line(code_lines, i)
+            docstring_below = _get_docstring_starting_at_line(code_lines, i + 1)
+            return AttributeDocString(
+                comment_above,
+                comment_inline,
+                docstring_below,
+                desc_from_cls_docstring=desc_from_cls_docstring,
+            )
+    return None
+
+
+def _contains_field_definition(line: str) -> bool:
+    """Returns whether or not a line contains a an dataclass field definition.
+
+    Arguments:
+        line_str {str} -- the line content
+
+    Returns:
+        bool -- True if there is an attribute definition in the line.
+
+    >>> _contains_field_definition("a: int = 0")
+    True
+    >>> _contains_field_definition("a: int")
+    True
+    >>> _contains_field_definition("a: int # comment")
+    True
+    >>> _contains_field_definition("a: int = 0 # comment")
+    True
+    >>> _contains_field_definition("class FooBaz(Foo, Baz):")
+    False
+    >>> _contains_field_definition("a = 4")
+    False
+    >>> _contains_field_definition("fooooooooobar.append(123)")
+    False
+    >>> _contains_field_definition("{a: int}")
+    False
+    >>> _contains_field_definition("        foobaz: int = 123  #: The foobaz property")
+    True
+    >>> _contains_field_definition("a #:= 3")
+    False
+    """
+    # Get rid of any comments first.
+    line, _, _ = line.partition("#")
+
+    if ":" not in line:
+        return False
+
+    if "=" in line:
+        attribute_and_type, _, _ = line.partition("=")
+    else:
+        attribute_and_type = line
+
+    field_name, _, type = attribute_and_type.partition(":")
+    field_name = field_name.strip()
+    if ":" in type:
+        # weird annotation or dictionary?
+        return False
+    if not field_name:
+        # Empty attribute name?
+        return False
+    return field_name.isidentifier()
+
+
+def _line_contains_definition_for(line: str, field_name: str) -> bool:
+    line = line.strip()
+    if not _contains_field_definition(line):
+        return False
+    attribute, _, type_and_value_assignment = line.partition(":")
+    attribute = attribute.strip()  # remove any whitespace after the attribute name.
+    return attribute.isidentifier() and attribute == field_name
+
+
+def _is_empty(line_str: str) -> bool:
+    return line_str.strip() == ""
+
+
+def _is_comment(line_str: str) -> bool:
+    return line_str.strip().startswith("#")
+
+
+def _get_comment_at_line(code_lines: list[str], line: int) -> str:
+    """Gets the comment at line `line` in `code_lines`.
+
+    Arguments:
+        line {int} -- the index of the line in code_lines
+
+    Returns:
+        str -- the comment at the given line. empty string if not present.
+    """
+    line_str = code_lines[line]
+    assert not _contains_field_definition(line_str)
+    if "#" not in line_str:
+        return ""
+    parts = line_str.split("#", maxsplit=1)
+    comment = parts[1].strip()
+    return comment
+
+
+def _get_inline_comment_at_line(code_lines: list[str], line: int) -> str:
+    """Gets the inline comment at line `line`.
+
+    Arguments:
+        line {int} -- the index of the line in code_lines
+
+    Returns:
+        str -- the inline comment at the given line, else an empty string.
+    """
+    assert 0 <= line < len(code_lines)
+    assert _contains_field_definition(code_lines[line])
+    line_str = code_lines[line]
+    parts = line_str.split("#", maxsplit=1)
+    if len(parts) != 2:
+        return ""
+    comment = parts[1].strip()
+    return comment
+
+
+def _get_comment_ending_at_line(code_lines: list[str], line: int) -> str:
+    start_line = line
+    end_line = line
+    # move up the code, one line at a time, while we don't hit the start,
+    # an attribute definition, or the end of a docstring.
+    while start_line > 0:
+        line_str = code_lines[start_line]
+        if _contains_field_definition(line_str):
+            break  # previous line is an assignment
+        if '"""' in line_str or "'''" in line_str:
+            break  # previous line has a docstring
+        start_line -= 1
+    start_line += 1
+
+    lines = []
+    for i in range(start_line, end_line + 1):
+        # print(f"line {i}: {code_lines[i]}")
+        if _is_empty(code_lines[i]):
+            continue
+        assert not _contains_field_definition(code_lines[i])
+        comment = _get_comment_at_line(code_lines, i)
+        lines.append(comment)
+    return "\n".join(lines).strip()
+
+
+def _get_docstring_starting_at_line(code_lines: list[str], line: int) -> str:
+    i = line
+    token: str | None = None
+    triple_single = "'''"
+    triple_double = '"""'
+    # print("finding docstring starting from line", line)
+
+    # if we are looking further down than the end of the code, there is no
+    # docstring.
+    if line >= len(code_lines):
+        return ""
+    # the list of lines making up the docstring.
+    docstring_contents: list[str] = []
+
+    while i < len(code_lines):
+        line_str = code_lines[i]
+        # print(f"(docstring) line {line}: {line_str}")
+
+        # we haven't identified the starting line yet.
+        if token is None:
+            if _is_empty(line_str):
+                i += 1
+                continue
+
+            elif _contains_field_definition(line_str) or _is_comment(line_str):
+                # we haven't reached the start of a docstring yet (since token
+                # is None), and we reached a line with an attribute definition,
+                # or a comment, hence the docstring is empty.
+                return ""
+
+            elif triple_single in line_str and triple_double in line_str:
+                # This handles something stupid like:
+                # @dataclass
+                # class Bob:
+                #     a: int
+                #     """ hello '''
+                #     bob
+                #     ''' bye
+                #     """
+                triple_single_index = line_str.index(triple_single)
+                triple_double_index = line_str.index(triple_double)
+                if triple_single_index < triple_double_index:
+                    token = triple_single
+                else:
+                    token = triple_double
+            elif triple_double in line_str:
+                token = triple_double
+            elif triple_single in line_str:
+                token = triple_single
+            else:
+                # for i, line in enumerate(code_lines):
+                #     print(f"line {i}: <{line}>")
+                # print(f"token: <{token}>")
+                # print(line_str)
+                logger.debug(f"Warning: Unable to parse attribute docstring: {line_str}")
+                return ""
+
+            # get the string portion of the line (after a token or possibly
+            # between two tokens).
+            parts = line_str.split(token, maxsplit=2)
+            if len(parts) == 3:
+                # This takes care of cases like:
+                # @dataclass
+                # class Bob:
+                #     a: int
+                #     """ hello """
+                between_tokens = parts[1].strip()
+                # print("Between tokens:", between_tokens)
+                docstring_contents.append(between_tokens)
+                break
+
+            elif len(parts) == 2:
+                after_token = parts[1].strip()
+                # print("After token:", after_token)
+                docstring_contents.append(after_token)
+        else:
+            # print(f"token is <{token}>")
+            if token in line_str:
+                # print(f"Line {line} End of a docstring:", line_str)
+                before = line_str.split(token, maxsplit=1)[0]
+                docstring_contents.append(before.strip())
+                break
+            else:
+                # intermediate line without the token.
+                docstring_contents.append(line_str.strip())
+        i += 1
+    # print("Docstring contents:", docstring_contents)
+    return "\n".join(docstring_contents)

parrot/lib/python3.10/site-packages/simple_parsing/help_formatter.py

@@ -0,0 +1,88 @@
+import argparse
+from argparse import ONE_OR_MORE, OPTIONAL, PARSER, REMAINDER, ZERO_OR_MORE, Action
+from logging import getLogger
+from typing import Optional, Type
+
+from .wrappers.field_metavar import get_metavar
+
+TEMPORARY_TOKEN = "<__TEMP__>"
+logger = getLogger(__name__)
+
+
+class SimpleHelpFormatter(
+    argparse.ArgumentDefaultsHelpFormatter,
+    argparse.MetavarTypeHelpFormatter,
+    argparse.RawDescriptionHelpFormatter,
+):
+    """Little shorthand for using some useful HelpFormatters from argparse.
+
+    This class inherits from argparse's `ArgumentDefaultHelpFormatter`,
+    `MetavarTypeHelpFormatter` and `RawDescriptionHelpFormatter` classes.
+
+    This produces the following resulting actions:
+    - adds a "(default: xyz)" for each argument with a default
+    - uses the name of the argument type as the metavar. For example, gives
+      "-n int" instead of "-n N" in the usage and description of the arguments.
+    - Conserves the formatting of the class and argument docstrings, if given.
+    """
+
+    def _format_args(self, action: Action, default_metavar: str):
+        _get_metavar = self._metavar_formatter(action, default_metavar)
+        action_type = action.type
+
+        metavar = action.metavar or get_metavar(action_type)
+        if metavar and not action.choices:
+            result = metavar
+        elif action.nargs is None:
+            result = "%s" % _get_metavar(1)
+        elif action.nargs == OPTIONAL:
+            result = "[%s]" % _get_metavar(1)
+        elif action.nargs == ZERO_OR_MORE:
+            result = "[%s [%s ...]]" % _get_metavar(2)  # noqa: UP031
+        elif action.nargs == ONE_OR_MORE:
+            result = "%s [%s ...]" % _get_metavar(2)  # noqa: UP031
+        elif action.nargs == REMAINDER:
+            result = "..."
+        elif action.nargs == PARSER:
+            result = "%s ..." % _get_metavar(1)
+        else:
+            formats = ["%s" for _ in range(action.nargs)]
+            result = " ".join(formats) % _get_metavar(action.nargs)
+
+        # logger.debug(
+        #     f"action type: {action_type}, Result: {result}, nargs: {action.nargs}, default metavar: {default_metavar}"
+        # )
+        return result
+
+    def _get_default_metavar_for_optional(self, action: argparse.Action):
+        try:
+            return super()._get_default_metavar_for_optional(action)
+        except BaseException:
+            logger.debug(f"Getting metavar for action with dest {action.dest}.")
+            metavar = self._get_metavar_for_action(action)
+            logger.debug(f"Result metavar: {metavar}")
+            return metavar
+
+    def _get_default_metavar_for_positional(self, action: argparse.Action):
+        try:
+            return super()._get_default_metavar_for_positional(action)
+        except BaseException:
+            logger.debug(f"Getting metavar for action with dest {action.dest}.")
+            metavar = self._get_metavar_for_action(action)
+            logger.debug(f"Result metavar: {metavar}")
+            return metavar
+
+    def _get_metavar_for_action(self, action: argparse.Action) -> str:
+        return self._get_metavar_for_type(action.type)
+
+    def _get_metavar_for_type(self, t: Type) -> str:
+        return get_metavar(t) or str(t)
+
+    def _get_help_string(self, action: Action) -> Optional[str]:
+        help = super()._get_help_string(action=action)
+        if help is not None:
+            help = help.replace(TEMPORARY_TOKEN, "")
+        return help
+
+
+Formatter = SimpleHelpFormatter

parrot/lib/python3.10/site-packages/simple_parsing/helpers/__init__.py

@@ -0,0 +1,15 @@
+"""Collection of helper classes and functions to reduce boilerplate code."""
+from .fields import *
+from .flatten import FlattenedAccess
+from .hparams import HyperParameters
+from .partial import Partial, config_for
+from .serialization import FrozenSerializable, Serializable, SimpleJsonEncoder, encode
+
+try:
+    from .serialization import YamlSerializable
+except ImportError:
+    pass
+
+# For backward compatibility purposes
+JsonSerializable = Serializable
+SimpleEncoder = SimpleJsonEncoder