2025-07-01

2026-03-17 14:30:01 -06:00
parent f9a22056dd
commit 62b5978595
4579 changed files with 1257472 additions and 0 deletions
@@ -0,0 +1 @@
+pip
@@ -0,0 +1,28 @@
+Copyright 2010 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder 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
+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.
@@ -0,0 +1,92 @@
+Metadata-Version: 2.1
+Name: MarkupSafe
+Version: 3.0.2
+Summary: Safely add untrusted strings to HTML/XML markup.
+Maintainer-email: Pallets <contact@palletsprojects.com>
+License: Copyright 2010 Pallets
+        
+        Redistribution and use in source and binary forms, with or without
+        modification, are permitted provided that the following conditions are
+        met:
+        
+        1.  Redistributions of source code must retain the above copyright
+            notice, this list of conditions and the following disclaimer.
+        
+        2.  Redistributions in binary form must reproduce the above copyright
+            notice, this list of conditions and the following disclaimer in the
+            documentation and/or other materials provided with the distribution.
+        
+        3.  Neither the name of the copyright holder 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
+        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.
+        
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Documentation, https://markupsafe.palletsprojects.com/
+Project-URL: Changes, https://markupsafe.palletsprojects.com/changes/
+Project-URL: Source, https://github.com/pallets/markupsafe/
+Project-URL: Chat, https://discord.gg/pallets
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+Classifier: Topic :: Text Processing :: Markup :: HTML
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+
+# MarkupSafe
+
+MarkupSafe implements a text object that escapes characters so it is
+safe to use in HTML and XML. Characters that have special meanings are
+replaced so that they display as the actual characters. This mitigates
+injection attacks, meaning untrusted user input can safely be displayed
+on a page.
+
+
+## Examples
+
+```pycon
+>>> from markupsafe import Markup, escape
+
+>>> # escape replaces special characters and wraps in Markup
+>>> escape("<script>alert(document.cookie);</script>")
+Markup('&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
+
+>>> # wrap in Markup to mark text "safe" and prevent escaping
+>>> Markup("<strong>Hello</strong>")
+Markup('<strong>hello</strong>')
+
+>>> escape(Markup("<strong>Hello</strong>"))
+Markup('<strong>hello</strong>')
+
+>>> # Markup is a str subclass
+>>> # methods and operators escape their arguments
+>>> template = Markup("Hello <em>{name}</em>")
+>>> template.format(name='"World"')
+Markup('Hello <em>&#34;World&#34;</em>')
+```
+
+## Donate
+
+The Pallets organization develops and supports MarkupSafe and other
+popular packages. In order to grow the community of contributors and
+users, and allow the maintainers to devote more time to the projects,
+[please donate today][].
+
+[please donate today]: https://palletsprojects.com/donate
@@ -0,0 +1,14 @@
+MarkupSafe-3.0.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+MarkupSafe-3.0.2.dist-info/LICENSE.txt,sha256=RjHsDbX9kKVH4zaBcmTGeYIUM4FG-KyUtKV_lu6MnsQ,1503
+MarkupSafe-3.0.2.dist-info/METADATA,sha256=nhoabjupBG41j_JxPCJ3ylgrZ6Fx8oMCFbiLF9Kafqc,4067
+MarkupSafe-3.0.2.dist-info/RECORD,,
+MarkupSafe-3.0.2.dist-info/WHEEL,sha256=tE2EWZPEv-G0fjAlUUz7IGM64246YKD9fpv4HcsDMkk,101
+MarkupSafe-3.0.2.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
+markupsafe/__init__.py,sha256=pREerPwvinB62tNCMOwqxBS2YHV6R52Wcq1d-rB4Z5o,13609
+markupsafe/__pycache__/__init__.cpython-311.pyc,,
+markupsafe/__pycache__/_native.cpython-311.pyc,,
+markupsafe/_native.py,sha256=2ptkJ40yCcp9kq3L1NqpgjfpZB-obniYKFFKUOkHh4Q,218
+markupsafe/_speedups.c,sha256=SglUjn40ti9YgQAO--OgkSyv9tXq9vvaHyVhQows4Ok,4353
+markupsafe/_speedups.cp311-win_amd64.pyd,sha256=-5qfBr0xMpiTRlH9hFg_7Go9PHi7z5guMzmbbmZI3Xw,13312
+markupsafe/_speedups.pyi,sha256=LSDmXYOefH4HVpAXuL8sl7AttLw0oXh1njVoVZp2wqQ,42
+markupsafe/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.2.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+
@@ -0,0 +1 @@
+markupsafe
@@ -0,0 +1 @@
+pip
@@ -0,0 +1,20 @@
+Copyright 2010 Jason Kirtland
+
+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.
@@ -0,0 +1,60 @@
+Metadata-Version: 2.3
+Name: blinker
+Version: 1.9.0
+Summary: Fast, simple object-to-object and broadcast signaling
+Author: Jason Kirtland
+Maintainer-email: Pallets Ecosystem <contact@palletsprojects.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Typing :: Typed
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://blinker.readthedocs.io
+Project-URL: Source, https://github.com/pallets-eco/blinker/
+
+# Blinker
+
+Blinker provides a fast dispatching system that allows any number of
+interested parties to subscribe to events, or "signals".
+
+
+## Pallets Community Ecosystem
+
+> [!IMPORTANT]\
+> This project is part of the Pallets Community Ecosystem. Pallets is the open
+> source organization that maintains Flask; Pallets-Eco enables community
+> maintenance of related projects. If you are interested in helping maintain
+> this project, please reach out on [the Pallets Discord server][discord].
+>
+> [discord]: https://discord.gg/pallets
+
+
+## Example
+
+Signal receivers can subscribe to specific senders or receive signals
+sent by any sender.
+
+```pycon
+>>> from blinker import signal
+>>> started = signal('round-started')
+>>> def each(round):
+...     print(f"Round {round}")
+...
+>>> started.connect(each)
+
+>>> def round_two(round):
+...     print("This is round two.")
+...
+>>> started.connect(round_two, sender=2)
+
+>>> for round in range(1, 4):
+...     started.send(round)
+...
+Round 1!
+Round 2!
+This is round two.
+Round 3!
+```
+
@@ -0,0 +1,12 @@
+blinker-1.9.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+blinker-1.9.0.dist-info/LICENSE.txt,sha256=nrc6HzhZekqhcCXSrhvjg5Ykx5XphdTw6Xac4p-spGc,1054
+blinker-1.9.0.dist-info/METADATA,sha256=uIRiM8wjjbHkCtbCyTvctU37IAZk0kEe5kxAld1dvzA,1633
+blinker-1.9.0.dist-info/RECORD,,
+blinker-1.9.0.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+blinker/__init__.py,sha256=I2EdZqpy4LyjX17Hn1yzJGWCjeLaVaPzsMgHkLfj_cQ,317
+blinker/__pycache__/__init__.cpython-311.pyc,,
+blinker/__pycache__/_utilities.cpython-311.pyc,,
+blinker/__pycache__/base.cpython-311.pyc,,
+blinker/_utilities.py,sha256=0J7eeXXTUx0Ivf8asfpx0ycVkp0Eqfqnj117x2mYX9E,1675
+blinker/base.py,sha256=QpDuvXXcwJF49lUBcH5BiST46Rz9wSG7VW_p7N_027M,19132
+blinker/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.10.1
+Root-Is-Purelib: true
+Tag: py3-none-any
@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from .base import ANY
+from .base import default_namespace
+from .base import NamedSignal
+from .base import Namespace
+from .base import Signal
+from .base import signal
+
+__all__ = [
+    "ANY",
+    "default_namespace",
+    "NamedSignal",
+    "Namespace",
+    "Signal",
+    "signal",
+]
@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+import collections.abc as c
+import inspect
+import typing as t
+from weakref import ref
+from weakref import WeakMethod
+
+T = t.TypeVar("T")
+
+
+class Symbol:
+    """A constant symbol, nicer than ``object()``. Repeated calls return the
+    same instance.
+
+    >>> Symbol('foo') is Symbol('foo')
+    True
+    >>> Symbol('foo')
+    foo
+    """
+
+    symbols: t.ClassVar[dict[str, Symbol]] = {}
+
+    def __new__(cls, name: str) -> Symbol:
+        if name in cls.symbols:
+            return cls.symbols[name]
+
+        obj = super().__new__(cls)
+        cls.symbols[name] = obj
+        return obj
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+
+    def __repr__(self) -> str:
+        return self.name
+
+    def __getnewargs__(self) -> tuple[t.Any, ...]:
+        return (self.name,)
+
+
+def make_id(obj: object) -> c.Hashable:
+    """Get a stable identifier for a receiver or sender, to be used as a dict
+    key or in a set.
+    """
+    if inspect.ismethod(obj):
+        # The id of a bound method is not stable, but the id of the unbound
+        # function and instance are.
+        return id(obj.__func__), id(obj.__self__)
+
+    if isinstance(obj, (str, int)):
+        # Instances with the same value always compare equal and have the same
+        # hash, even if the id may change.
+        return obj
+
+    # Assume other types are not hashable but will always be the same instance.
+    return id(obj)
+
+
+def make_ref(obj: T, callback: c.Callable[[ref[T]], None] | None = None) -> ref[T]:
+    if inspect.ismethod(obj):
+        return WeakMethod(obj, callback)  # type: ignore[arg-type, return-value]
+
+    return ref(obj, callback)
@@ -0,0 +1,512 @@
+from __future__ import annotations
+
+import collections.abc as c
+import sys
+import typing as t
+import weakref
+from collections import defaultdict
+from contextlib import contextmanager
+from functools import cached_property
+from inspect import iscoroutinefunction
+
+from ._utilities import make_id
+from ._utilities import make_ref
+from ._utilities import Symbol
+
+F = t.TypeVar("F", bound=c.Callable[..., t.Any])
+
+ANY = Symbol("ANY")
+"""Symbol for "any sender"."""
+
+ANY_ID = 0
+
+
+class Signal:
+    """A notification emitter.
+
+    :param doc: The docstring for the signal.
+    """
+
+    ANY = ANY
+    """An alias for the :data:`~blinker.ANY` sender symbol."""
+
+    set_class: type[set[t.Any]] = set
+    """The set class to use for tracking connected receivers and senders.
+    Python's ``set`` is unordered. If receivers must be dispatched in the order
+    they were connected, an ordered set implementation can be used.
+
+    .. versionadded:: 1.7
+    """
+
+    @cached_property
+    def receiver_connected(self) -> Signal:
+        """Emitted at the end of each :meth:`connect` call.
+
+        The signal sender is the signal instance, and the :meth:`connect`
+        arguments are passed through: ``receiver``, ``sender``, and ``weak``.
+
+        .. versionadded:: 1.2
+        """
+        return Signal(doc="Emitted after a receiver connects.")
+
+    @cached_property
+    def receiver_disconnected(self) -> Signal:
+        """Emitted at the end of each :meth:`disconnect` call.
+
+        The sender is the signal instance, and the :meth:`disconnect` arguments
+        are passed through: ``receiver`` and ``sender``.
+
+        This signal is emitted **only** when :meth:`disconnect` is called
+        explicitly. This signal cannot be emitted by an automatic disconnect
+        when a weakly referenced receiver or sender goes out of scope, as the
+        instance is no longer be available to be used as the sender for this
+        signal.
+
+        An alternative approach is available by subscribing to
+        :attr:`receiver_connected` and setting up a custom weakref cleanup
+        callback on weak receivers and senders.
+
+        .. versionadded:: 1.2
+        """
+        return Signal(doc="Emitted after a receiver disconnects.")
+
+    def __init__(self, doc: str | None = None) -> None:
+        if doc:
+            self.__doc__ = doc
+
+        self.receivers: dict[
+            t.Any, weakref.ref[c.Callable[..., t.Any]] | c.Callable[..., t.Any]
+        ] = {}
+        """The map of connected receivers. Useful to quickly check if any
+        receivers are connected to the signal: ``if s.receivers:``. The
+        structure and data is not part of the public API, but checking its
+        boolean value is.
+        """
+
+        self.is_muted: bool = False
+        self._by_receiver: dict[t.Any, set[t.Any]] = defaultdict(self.set_class)
+        self._by_sender: dict[t.Any, set[t.Any]] = defaultdict(self.set_class)
+        self._weak_senders: dict[t.Any, weakref.ref[t.Any]] = {}
+
+    def connect(self, receiver: F, sender: t.Any = ANY, weak: bool = True) -> F:
+        """Connect ``receiver`` to be called when the signal is sent by
+        ``sender``.
+
+        :param receiver: The callable to call when :meth:`send` is called with
+            the given ``sender``, passing ``sender`` as a positional argument
+            along with any extra keyword arguments.
+        :param sender: Any object or :data:`ANY`. ``receiver`` will only be
+            called when :meth:`send` is called with this sender. If ``ANY``, the
+            receiver will be called for any sender. A receiver may be connected
+            to multiple senders by calling :meth:`connect` multiple times.
+        :param weak: Track the receiver with a :mod:`weakref`. The receiver will
+            be automatically disconnected when it is garbage collected. When
+            connecting a receiver defined within a function, set to ``False``,
+            otherwise it will be disconnected when the function scope ends.
+        """
+        receiver_id = make_id(receiver)
+        sender_id = ANY_ID if sender is ANY else make_id(sender)
+
+        if weak:
+            self.receivers[receiver_id] = make_ref(
+                receiver, self._make_cleanup_receiver(receiver_id)
+            )
+        else:
+            self.receivers[receiver_id] = receiver
+
+        self._by_sender[sender_id].add(receiver_id)
+        self._by_receiver[receiver_id].add(sender_id)
+
+        if sender is not ANY and sender_id not in self._weak_senders:
+            # store a cleanup for weakref-able senders
+            try:
+                self._weak_senders[sender_id] = make_ref(
+                    sender, self._make_cleanup_sender(sender_id)
+                )
+            except TypeError:
+                pass
+
+        if "receiver_connected" in self.__dict__ and self.receiver_connected.receivers:
+            try:
+                self.receiver_connected.send(
+                    self, receiver=receiver, sender=sender, weak=weak
+                )
+            except TypeError:
+                # TODO no explanation or test for this
+                self.disconnect(receiver, sender)
+                raise
+
+        return receiver
+
+    def connect_via(self, sender: t.Any, weak: bool = False) -> c.Callable[[F], F]:
+        """Connect the decorated function to be called when the signal is sent
+        by ``sender``.
+
+        The decorated function will be called when :meth:`send` is called with
+        the given ``sender``, passing ``sender`` as a positional argument along
+        with any extra keyword arguments.
+
+        :param sender: Any object or :data:`ANY`. ``receiver`` will only be
+            called when :meth:`send` is called with this sender. If ``ANY``, the
+            receiver will be called for any sender. A receiver may be connected
+            to multiple senders by calling :meth:`connect` multiple times.
+        :param weak: Track the receiver with a :mod:`weakref`. The receiver will
+            be automatically disconnected when it is garbage collected. When
+            connecting a receiver defined within a function, set to ``False``,
+            otherwise it will be disconnected when the function scope ends.=
+
+        .. versionadded:: 1.1
+        """
+
+        def decorator(fn: F) -> F:
+            self.connect(fn, sender, weak)
+            return fn
+
+        return decorator
+
+    @contextmanager
+    def connected_to(
+        self, receiver: c.Callable[..., t.Any], sender: t.Any = ANY
+    ) -> c.Generator[None, None, None]:
+        """A context manager that temporarily connects ``receiver`` to the
+        signal while a ``with`` block executes. When the block exits, the
+        receiver is disconnected. Useful for tests.
+
+        :param receiver: The callable to call when :meth:`send` is called with
+            the given ``sender``, passing ``sender`` as a positional argument
+            along with any extra keyword arguments.
+        :param sender: Any object or :data:`ANY`. ``receiver`` will only be
+            called when :meth:`send` is called with this sender. If ``ANY``, the
+            receiver will be called for any sender.
+
+        .. versionadded:: 1.1
+        """
+        self.connect(receiver, sender=sender, weak=False)
+
+        try:
+            yield None
+        finally:
+            self.disconnect(receiver)
+
+    @contextmanager
+    def muted(self) -> c.Generator[None, None, None]:
+        """A context manager that temporarily disables the signal. No receivers
+        will be called if the signal is sent, until the ``with`` block exits.
+        Useful for tests.
+        """
+        self.is_muted = True
+
+        try:
+            yield None
+        finally:
+            self.is_muted = False
+
+    def send(
+        self,
+        sender: t.Any | None = None,
+        /,
+        *,
+        _async_wrapper: c.Callable[
+            [c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]], c.Callable[..., t.Any]
+        ]
+        | None = None,
+        **kwargs: t.Any,
+    ) -> list[tuple[c.Callable[..., t.Any], t.Any]]:
+        """Call all receivers that are connected to the given ``sender``
+        or :data:`ANY`. Each receiver is called with ``sender`` as a positional
+        argument along with any extra keyword arguments. Return a list of
+        ``(receiver, return value)`` tuples.
+
+        The order receivers are called is undefined, but can be influenced by
+        setting :attr:`set_class`.
+
+        If a receiver raises an exception, that exception will propagate up.
+        This makes debugging straightforward, with an assumption that correctly
+        implemented receivers will not raise.
+
+        :param sender: Call receivers connected to this sender, in addition to
+            those connected to :data:`ANY`.
+        :param _async_wrapper: Will be called on any receivers that are async
+            coroutines to turn them into sync callables. For example, could run
+            the receiver with an event loop.
+        :param kwargs: Extra keyword arguments to pass to each receiver.
+
+        .. versionchanged:: 1.7
+            Added the ``_async_wrapper`` argument.
+        """
+        if self.is_muted:
+            return []
+
+        results = []
+
+        for receiver in self.receivers_for(sender):
+            if iscoroutinefunction(receiver):
+                if _async_wrapper is None:
+                    raise RuntimeError("Cannot send to a coroutine function.")
+
+                result = _async_wrapper(receiver)(sender, **kwargs)
+            else:
+                result = receiver(sender, **kwargs)
+
+            results.append((receiver, result))
+
+        return results
+
+    async def send_async(
+        self,
+        sender: t.Any | None = None,
+        /,
+        *,
+        _sync_wrapper: c.Callable[
+            [c.Callable[..., t.Any]], c.Callable[..., c.Coroutine[t.Any, t.Any, t.Any]]
+        ]
+        | None = None,
+        **kwargs: t.Any,
+    ) -> list[tuple[c.Callable[..., t.Any], t.Any]]:
+        """Await all receivers that are connected to the given ``sender``
+        or :data:`ANY`. Each receiver is called with ``sender`` as a positional
+        argument along with any extra keyword arguments. Return a list of
+        ``(receiver, return value)`` tuples.
+
+        The order receivers are called is undefined, but can be influenced by
+        setting :attr:`set_class`.
+
+        If a receiver raises an exception, that exception will propagate up.
+        This makes debugging straightforward, with an assumption that correctly
+        implemented receivers will not raise.
+
+        :param sender: Call receivers connected to this sender, in addition to
+            those connected to :data:`ANY`.
+        :param _sync_wrapper: Will be called on any receivers that are sync
+            callables to turn them into async coroutines. For example,
+            could call the receiver in a thread.
+        :param kwargs: Extra keyword arguments to pass to each receiver.
+
+        .. versionadded:: 1.7
+        """
+        if self.is_muted:
+            return []
+
+        results = []
+
+        for receiver in self.receivers_for(sender):
+            if not iscoroutinefunction(receiver):
+                if _sync_wrapper is None:
+                    raise RuntimeError("Cannot send to a non-coroutine function.")
+
+                result = await _sync_wrapper(receiver)(sender, **kwargs)
+            else:
+                result = await receiver(sender, **kwargs)
+
+            results.append((receiver, result))
+
+        return results
+
+    def has_receivers_for(self, sender: t.Any) -> bool:
+        """Check if there is at least one receiver that will be called with the
+        given ``sender``. A receiver connected to :data:`ANY` will always be
+        called, regardless of sender. Does not check if weakly referenced
+        receivers are still live. See :meth:`receivers_for` for a stronger
+        search.
+
+        :param sender: Check for receivers connected to this sender, in addition
+            to those connected to :data:`ANY`.
+        """
+        if not self.receivers:
+            return False
+
+        if self._by_sender[ANY_ID]:
+            return True
+
+        if sender is ANY:
+            return False
+
+        return make_id(sender) in self._by_sender
+
+    def receivers_for(
+        self, sender: t.Any
+    ) -> c.Generator[c.Callable[..., t.Any], None, None]:
+        """Yield each receiver to be called for ``sender``, in addition to those
+        to be called for :data:`ANY`. Weakly referenced receivers that are not
+        live will be disconnected and skipped.
+
+        :param sender: Yield receivers connected to this sender, in addition
+            to those connected to :data:`ANY`.
+        """
+        # TODO: test receivers_for(ANY)
+        if not self.receivers:
+            return
+
+        sender_id = make_id(sender)
+
+        if sender_id in self._by_sender:
+            ids = self._by_sender[ANY_ID] | self._by_sender[sender_id]
+        else:
+            ids = self._by_sender[ANY_ID].copy()
+
+        for receiver_id in ids:
+            receiver = self.receivers.get(receiver_id)
+
+            if receiver is None:
+                continue
+
+            if isinstance(receiver, weakref.ref):
+                strong = receiver()
+
+                if strong is None:
+                    self._disconnect(receiver_id, ANY_ID)
+                    continue
+
+                yield strong
+            else:
+                yield receiver
+
+    def disconnect(self, receiver: c.Callable[..., t.Any], sender: t.Any = ANY) -> None:
+        """Disconnect ``receiver`` from being called when the signal is sent by
+        ``sender``.
+
+        :param receiver: A connected receiver callable.
+        :param sender: Disconnect from only this sender. By default, disconnect
+            from all senders.
+        """
+        sender_id: c.Hashable
+
+        if sender is ANY:
+            sender_id = ANY_ID
+        else:
+            sender_id = make_id(sender)
+
+        receiver_id = make_id(receiver)
+        self._disconnect(receiver_id, sender_id)
+
+        if (
+            "receiver_disconnected" in self.__dict__
+            and self.receiver_disconnected.receivers
+        ):
+            self.receiver_disconnected.send(self, receiver=receiver, sender=sender)
+
+    def _disconnect(self, receiver_id: c.Hashable, sender_id: c.Hashable) -> None:
+        if sender_id == ANY_ID:
+            if self._by_receiver.pop(receiver_id, None) is not None:
+                for bucket in self._by_sender.values():
+                    bucket.discard(receiver_id)
+
+            self.receivers.pop(receiver_id, None)
+        else:
+            self._by_sender[sender_id].discard(receiver_id)
+            self._by_receiver[receiver_id].discard(sender_id)
+
+    def _make_cleanup_receiver(
+        self, receiver_id: c.Hashable
+    ) -> c.Callable[[weakref.ref[c.Callable[..., t.Any]]], None]:
+        """Create a callback function to disconnect a weakly referenced
+        receiver when it is garbage collected.
+        """
+
+        def cleanup(ref: weakref.ref[c.Callable[..., t.Any]]) -> None:
+            # If the interpreter is shutting down, disconnecting can result in a
+            # weird ignored exception. Don't call it in that case.
+            if not sys.is_finalizing():
+                self._disconnect(receiver_id, ANY_ID)
+
+        return cleanup
+
+    def _make_cleanup_sender(
+        self, sender_id: c.Hashable
+    ) -> c.Callable[[weakref.ref[t.Any]], None]:
+        """Create a callback function to disconnect all receivers for a weakly
+        referenced sender when it is garbage collected.
+        """
+        assert sender_id != ANY_ID
+
+        def cleanup(ref: weakref.ref[t.Any]) -> None:
+            self._weak_senders.pop(sender_id, None)
+
+            for receiver_id in self._by_sender.pop(sender_id, ()):
+                self._by_receiver[receiver_id].discard(sender_id)
+
+        return cleanup
+
+    def _cleanup_bookkeeping(self) -> None:
+        """Prune unused sender/receiver bookkeeping. Not threadsafe.
+
+        Connecting & disconnecting leaves behind a small amount of bookkeeping
+        data. Typical workloads using Blinker, for example in most web apps,
+        Flask, CLI scripts, etc., are not adversely affected by this
+        bookkeeping.
+
+        With a long-running process performing dynamic signal routing with high
+        volume, e.g. connecting to function closures, senders are all unique
+        object instances. Doing all of this over and over may cause memory usage
+        to grow due to extraneous bookkeeping. (An empty ``set`` for each stale
+        sender/receiver pair.)
+
+        This method will prune that bookkeeping away, with the caveat that such
+        pruning is not threadsafe. The risk is that cleanup of a fully
+        disconnected receiver/sender pair occurs while another thread is
+        connecting that same pair. If you are in the highly dynamic, unique
+        receiver/sender situation that has lead you to this method, that failure
+        mode is perhaps not a big deal for you.
+        """
+        for mapping in (self._by_sender, self._by_receiver):
+            for ident, bucket in list(mapping.items()):
+                if not bucket:
+                    mapping.pop(ident, None)
+
+    def _clear_state(self) -> None:
+        """Disconnect all receivers and senders. Useful for tests."""
+        self._weak_senders.clear()
+        self.receivers.clear()
+        self._by_sender.clear()
+        self._by_receiver.clear()
+
+
+class NamedSignal(Signal):
+    """A named generic notification emitter. The name is not used by the signal
+    itself, but matches the key in the :class:`Namespace` that it belongs to.
+
+    :param name: The name of the signal within the namespace.
+    :param doc: The docstring for the signal.
+    """
+
+    def __init__(self, name: str, doc: str | None = None) -> None:
+        super().__init__(doc)
+
+        #: The name of this signal.
+        self.name: str = name
+
+    def __repr__(self) -> str:
+        base = super().__repr__()
+        return f"{base[:-1]}; {self.name!r}>"  # noqa: E702
+
+
+class Namespace(dict[str, NamedSignal]):
+    """A dict mapping names to signals."""
+
+    def signal(self, name: str, doc: str | None = None) -> NamedSignal:
+        """Return the :class:`NamedSignal` for the given ``name``, creating it
+        if required. Repeated calls with the same name return the same signal.
+
+        :param name: The name of the signal.
+        :param doc: The docstring of the signal.
+        """
+        if name not in self:
+            self[name] = NamedSignal(name, doc)
+
+        return self[name]
+
+
+class _PNamespaceSignal(t.Protocol):
+    def __call__(self, name: str, doc: str | None = None) -> NamedSignal: ...
+
+
+default_namespace: Namespace = Namespace()
+"""A default :class:`Namespace` for creating named signals. :func:`signal`
+creates a :class:`NamedSignal` in this namespace.
+"""
+
+signal: _PNamespaceSignal = default_namespace.signal
+"""Return a :class:`NamedSignal` in :data:`default_namespace` with the given
+``name``, creating it if required. Repeated calls with the same name return the
+same signal.
+"""
@@ -0,0 +1 @@
+pip
@@ -0,0 +1,28 @@
+Copyright 2014 Pallets
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+1.  Redistributions of source code must retain the above copyright
+    notice, this list of conditions and the following disclaimer.
+
+2.  Redistributions in binary form must reproduce the above copyright
+    notice, this list of conditions and the following disclaimer in the
+    documentation and/or other materials provided with the distribution.
+
+3.  Neither the name of the copyright holder 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
+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.
@@ -0,0 +1,74 @@
+Metadata-Version: 2.3
+Name: click
+Version: 8.1.8
+Summary: Composable command line interface toolkit
+Maintainer-email: Pallets <contact@palletsprojects.com>
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Typing :: Typed
+Requires-Dist: colorama; platform_system == 'Windows'
+Requires-Dist: importlib-metadata; python_version < '3.8'
+Project-URL: Changes, https://click.palletsprojects.com/changes/
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://click.palletsprojects.com/
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Source, https://github.com/pallets/click/
+
+# $ click_
+
+Click is a Python package for creating beautiful command line interfaces
+in a composable way with as little code as necessary. It's the "Command
+Line Interface Creation Kit". It's highly configurable but comes with
+sensible defaults out of the box.
+
+It aims to make the process of writing command line tools quick and fun
+while also preventing any frustration caused by the inability to
+implement an intended CLI API.
+
+Click in three points:
+
+-   Arbitrary nesting of commands
+-   Automatic help page generation
+-   Supports lazy loading of subcommands at runtime
+
+
+## A Simple Example
+
+```python
+import click
+
+@click.command()
+@click.option("--count", default=1, help="Number of greetings.")
+@click.option("--name", prompt="Your name", help="The person to greet.")
+def hello(count, name):
+    """Simple program that greets NAME for a total of COUNT times."""
+    for _ in range(count):
+        click.echo(f"Hello, {name}!")
+
+if __name__ == '__main__':
+    hello()
+```
+
+```
+$ python hello.py --count=3
+Your name: Click
+Hello, Click!
+Hello, Click!
+Hello, Click!
+```
+
+
+## Donate
+
+The Pallets organization develops and supports Click and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, [please
+donate today][].
+
+[please donate today]: https://palletsprojects.com/donate
+
@@ -0,0 +1,38 @@
+click-8.1.8.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+click-8.1.8.dist-info/LICENSE.txt,sha256=morRBqOU6FO_4h9C9OctWSgZoigF2ZG18ydQKSkrZY0,1475
+click-8.1.8.dist-info/METADATA,sha256=WJtQ6uGS2ybLfvUE4vC0XIhIBr4yFGwjrMBR2fiCQ-Q,2263
+click-8.1.8.dist-info/RECORD,,
+click-8.1.8.dist-info/WHEEL,sha256=CpUCUxeHQbRN5UGRQHYRJorO5Af-Qy_fHMctcQ8DSGI,82
+click/__init__.py,sha256=j1DJeCbga4ribkv5uyvIAzI0oFN13fW9mevDKShFelo,3188
+click/__pycache__/__init__.cpython-311.pyc,,
+click/__pycache__/_compat.cpython-311.pyc,,
+click/__pycache__/_termui_impl.cpython-311.pyc,,
+click/__pycache__/_textwrap.cpython-311.pyc,,
+click/__pycache__/_winconsole.cpython-311.pyc,,
+click/__pycache__/core.cpython-311.pyc,,
+click/__pycache__/decorators.cpython-311.pyc,,
+click/__pycache__/exceptions.cpython-311.pyc,,
+click/__pycache__/formatting.cpython-311.pyc,,
+click/__pycache__/globals.cpython-311.pyc,,
+click/__pycache__/parser.cpython-311.pyc,,
+click/__pycache__/shell_completion.cpython-311.pyc,,
+click/__pycache__/termui.cpython-311.pyc,,
+click/__pycache__/testing.cpython-311.pyc,,
+click/__pycache__/types.cpython-311.pyc,,
+click/__pycache__/utils.cpython-311.pyc,,
+click/_compat.py,sha256=IGKh_J5QdfKELitnRfTGHneejWxoCw_NX9tfMbdcg3w,18730
+click/_termui_impl.py,sha256=a5z7I9gOFeMmu7Gb6_RPyQ8GPuVP1EeblixcWSPSQPk,24783
+click/_textwrap.py,sha256=10fQ64OcBUMuK7mFvh8363_uoOxPlRItZBmKzRJDgoY,1353
+click/_winconsole.py,sha256=5ju3jQkcZD0W27WEMGqmEP4y_crUVzPCqsX_FYb7BO0,7860
+click/core.py,sha256=Q1nEVdctZwvIPOlt4vfHko0TYnHCeE40UEEul8Wpyvs,114748
+click/decorators.py,sha256=7t6F-QWowtLh6F_6l-4YV4Y4yNTcqFQEu9i37zIz68s,18925
+click/exceptions.py,sha256=V7zDT6emqJ8iNl0kF1P5kpFmLMWQ1T1L7aNNKM4YR0w,9600
+click/formatting.py,sha256=Frf0-5W33-loyY_i9qrwXR8-STnW3m5gvyxLVUdyxyk,9706
+click/globals.py,sha256=cuJ6Bbo073lgEEmhjr394PeM-QFmXM-Ci-wmfsd7H5g,1954
+click/parser.py,sha256=h4sndcpF5OHrZQN8vD8IWb5OByvW7ABbhRToxovrqS8,19067
+click/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+click/shell_completion.py,sha256=TR0dXEGcvWb9Eo3aaQEXGhnvNS3FF4H4QcuLnvAvYo4,18636
+click/termui.py,sha256=dLxiS70UOvIYBda_nEEZaPAFOVDVmRs1sEPMuLDowQo,28310
+click/testing.py,sha256=3RA8anCf7TZ8-5RAF5it2Te-aWXBAL5VLasQnMiC2ZQ,16282
+click/types.py,sha256=BD5Qqq4h-8kawBmOIzJlmq4xzThAf4wCvaOLZSBDNx0,36422
+click/utils.py,sha256=ce-IrO9ilII76LGkU354pOdHbepM8UftfNH7SfMU_28,20330
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.10.1
+Root-Is-Purelib: true
+Tag: py3-none-any
@@ -0,0 +1,75 @@
+"""
+Click is a simple Python module inspired by the stdlib optparse to make
+writing command line scripts fun. Unlike other modules, it's based
+around a simple API that does not come with too much magic and is
+composable.
+"""
+
+from .core import Argument as Argument
+from .core import BaseCommand as BaseCommand
+from .core import Command as Command
+from .core import CommandCollection as CommandCollection
+from .core import Context as Context
+from .core import Group as Group
+from .core import MultiCommand as MultiCommand
+from .core import Option as Option
+from .core import Parameter as Parameter
+from .decorators import argument as argument
+from .decorators import command as command
+from .decorators import confirmation_option as confirmation_option
+from .decorators import group as group
+from .decorators import help_option as help_option
+from .decorators import HelpOption as HelpOption
+from .decorators import make_pass_decorator as make_pass_decorator
+from .decorators import option as option
+from .decorators import pass_context as pass_context
+from .decorators import pass_obj as pass_obj
+from .decorators import password_option as password_option
+from .decorators import version_option as version_option
+from .exceptions import Abort as Abort
+from .exceptions import BadArgumentUsage as BadArgumentUsage
+from .exceptions import BadOptionUsage as BadOptionUsage
+from .exceptions import BadParameter as BadParameter
+from .exceptions import ClickException as ClickException
+from .exceptions import FileError as FileError
+from .exceptions import MissingParameter as MissingParameter
+from .exceptions import NoSuchOption as NoSuchOption
+from .exceptions import UsageError as UsageError
+from .formatting import HelpFormatter as HelpFormatter
+from .formatting import wrap_text as wrap_text
+from .globals import get_current_context as get_current_context
+from .parser import OptionParser as OptionParser
+from .termui import clear as clear
+from .termui import confirm as confirm
+from .termui import echo_via_pager as echo_via_pager
+from .termui import edit as edit
+from .termui import getchar as getchar
+from .termui import launch as launch
+from .termui import pause as pause
+from .termui import progressbar as progressbar
+from .termui import prompt as prompt
+from .termui import secho as secho
+from .termui import style as style
+from .termui import unstyle as unstyle
+from .types import BOOL as BOOL
+from .types import Choice as Choice
+from .types import DateTime as DateTime
+from .types import File as File
+from .types import FLOAT as FLOAT
+from .types import FloatRange as FloatRange
+from .types import INT as INT
+from .types import IntRange as IntRange
+from .types import ParamType as ParamType
+from .types import Path as Path
+from .types import STRING as STRING
+from .types import Tuple as Tuple
+from .types import UNPROCESSED as UNPROCESSED
+from .types import UUID as UUID
+from .utils import echo as echo
+from .utils import format_filename as format_filename
+from .utils import get_app_dir as get_app_dir
+from .utils import get_binary_stream as get_binary_stream
+from .utils import get_text_stream as get_text_stream
+from .utils import open_file as open_file
+
+__version__ = "8.1.8"
@@ -0,0 +1,623 @@
+import codecs
+import io
+import os
+import re
+import sys
+import typing as t
+from weakref import WeakKeyDictionary
+
+CYGWIN = sys.platform.startswith("cygwin")
+WIN = sys.platform.startswith("win")
+auto_wrap_for_ansi: t.Optional[t.Callable[[t.TextIO], t.TextIO]] = None
+_ansi_re = re.compile(r"\033\[[;?0-9]*[a-zA-Z]")
+
+
+def _make_text_stream(
+    stream: t.BinaryIO,
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+    force_readable: bool = False,
+    force_writable: bool = False,
+) -> t.TextIO:
+    if encoding is None:
+        encoding = get_best_encoding(stream)
+    if errors is None:
+        errors = "replace"
+    return _NonClosingTextIOWrapper(
+        stream,
+        encoding,
+        errors,
+        line_buffering=True,
+        force_readable=force_readable,
+        force_writable=force_writable,
+    )
+
+
+def is_ascii_encoding(encoding: str) -> bool:
+    """Checks if a given encoding is ascii."""
+    try:
+        return codecs.lookup(encoding).name == "ascii"
+    except LookupError:
+        return False
+
+
+def get_best_encoding(stream: t.IO[t.Any]) -> str:
+    """Returns the default stream encoding if not found."""
+    rv = getattr(stream, "encoding", None) or sys.getdefaultencoding()
+    if is_ascii_encoding(rv):
+        return "utf-8"
+    return rv
+
+
+class _NonClosingTextIOWrapper(io.TextIOWrapper):
+    def __init__(
+        self,
+        stream: t.BinaryIO,
+        encoding: t.Optional[str],
+        errors: t.Optional[str],
+        force_readable: bool = False,
+        force_writable: bool = False,
+        **extra: t.Any,
+    ) -> None:
+        self._stream = stream = t.cast(
+            t.BinaryIO, _FixupStream(stream, force_readable, force_writable)
+        )
+        super().__init__(stream, encoding, errors, **extra)
+
+    def __del__(self) -> None:
+        try:
+            self.detach()
+        except Exception:
+            pass
+
+    def isatty(self) -> bool:
+        # https://bitbucket.org/pypy/pypy/issue/1803
+        return self._stream.isatty()
+
+
+class _FixupStream:
+    """The new io interface needs more from streams than streams
+    traditionally implement.  As such, this fix-up code is necessary in
+    some circumstances.
+
+    The forcing of readable and writable flags are there because some tools
+    put badly patched objects on sys (one such offender are certain version
+    of jupyter notebook).
+    """
+
+    def __init__(
+        self,
+        stream: t.BinaryIO,
+        force_readable: bool = False,
+        force_writable: bool = False,
+    ):
+        self._stream = stream
+        self._force_readable = force_readable
+        self._force_writable = force_writable
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._stream, name)
+
+    def read1(self, size: int) -> bytes:
+        f = getattr(self._stream, "read1", None)
+
+        if f is not None:
+            return t.cast(bytes, f(size))
+
+        return self._stream.read(size)
+
+    def readable(self) -> bool:
+        if self._force_readable:
+            return True
+        x = getattr(self._stream, "readable", None)
+        if x is not None:
+            return t.cast(bool, x())
+        try:
+            self._stream.read(0)
+        except Exception:
+            return False
+        return True
+
+    def writable(self) -> bool:
+        if self._force_writable:
+            return True
+        x = getattr(self._stream, "writable", None)
+        if x is not None:
+            return t.cast(bool, x())
+        try:
+            self._stream.write("")  # type: ignore
+        except Exception:
+            try:
+                self._stream.write(b"")
+            except Exception:
+                return False
+        return True
+
+    def seekable(self) -> bool:
+        x = getattr(self._stream, "seekable", None)
+        if x is not None:
+            return t.cast(bool, x())
+        try:
+            self._stream.seek(self._stream.tell())
+        except Exception:
+            return False
+        return True
+
+
+def _is_binary_reader(stream: t.IO[t.Any], default: bool = False) -> bool:
+    try:
+        return isinstance(stream.read(0), bytes)
+    except Exception:
+        return default
+        # This happens in some cases where the stream was already
+        # closed.  In this case, we assume the default.
+
+
+def _is_binary_writer(stream: t.IO[t.Any], default: bool = False) -> bool:
+    try:
+        stream.write(b"")
+    except Exception:
+        try:
+            stream.write("")
+            return False
+        except Exception:
+            pass
+        return default
+    return True
+
+
+def _find_binary_reader(stream: t.IO[t.Any]) -> t.Optional[t.BinaryIO]:
+    # We need to figure out if the given stream is already binary.
+    # This can happen because the official docs recommend detaching
+    # the streams to get binary streams.  Some code might do this, so
+    # we need to deal with this case explicitly.
+    if _is_binary_reader(stream, False):
+        return t.cast(t.BinaryIO, stream)
+
+    buf = getattr(stream, "buffer", None)
+
+    # Same situation here; this time we assume that the buffer is
+    # actually binary in case it's closed.
+    if buf is not None and _is_binary_reader(buf, True):
+        return t.cast(t.BinaryIO, buf)
+
+    return None
+
+
+def _find_binary_writer(stream: t.IO[t.Any]) -> t.Optional[t.BinaryIO]:
+    # We need to figure out if the given stream is already binary.
+    # This can happen because the official docs recommend detaching
+    # the streams to get binary streams.  Some code might do this, so
+    # we need to deal with this case explicitly.
+    if _is_binary_writer(stream, False):
+        return t.cast(t.BinaryIO, stream)
+
+    buf = getattr(stream, "buffer", None)
+
+    # Same situation here; this time we assume that the buffer is
+    # actually binary in case it's closed.
+    if buf is not None and _is_binary_writer(buf, True):
+        return t.cast(t.BinaryIO, buf)
+
+    return None
+
+
+def _stream_is_misconfigured(stream: t.TextIO) -> bool:
+    """A stream is misconfigured if its encoding is ASCII."""
+    # If the stream does not have an encoding set, we assume it's set
+    # to ASCII.  This appears to happen in certain unittest
+    # environments.  It's not quite clear what the correct behavior is
+    # but this at least will force Click to recover somehow.
+    return is_ascii_encoding(getattr(stream, "encoding", None) or "ascii")
+
+
+def _is_compat_stream_attr(stream: t.TextIO, attr: str, value: t.Optional[str]) -> bool:
+    """A stream attribute is compatible if it is equal to the
+    desired value or the desired value is unset and the attribute
+    has a value.
+    """
+    stream_value = getattr(stream, attr, None)
+    return stream_value == value or (value is None and stream_value is not None)
+
+
+def _is_compatible_text_stream(
+    stream: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str]
+) -> bool:
+    """Check if a stream's encoding and errors attributes are
+    compatible with the desired values.
+    """
+    return _is_compat_stream_attr(
+        stream, "encoding", encoding
+    ) and _is_compat_stream_attr(stream, "errors", errors)
+
+
+def _force_correct_text_stream(
+    text_stream: t.IO[t.Any],
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+    is_binary: t.Callable[[t.IO[t.Any], bool], bool],
+    find_binary: t.Callable[[t.IO[t.Any]], t.Optional[t.BinaryIO]],
+    force_readable: bool = False,
+    force_writable: bool = False,
+) -> t.TextIO:
+    if is_binary(text_stream, False):
+        binary_reader = t.cast(t.BinaryIO, text_stream)
+    else:
+        text_stream = t.cast(t.TextIO, text_stream)
+        # If the stream looks compatible, and won't default to a
+        # misconfigured ascii encoding, return it as-is.
+        if _is_compatible_text_stream(text_stream, encoding, errors) and not (
+            encoding is None and _stream_is_misconfigured(text_stream)
+        ):
+            return text_stream
+
+        # Otherwise, get the underlying binary reader.
+        possible_binary_reader = find_binary(text_stream)
+
+        # If that's not possible, silently use the original reader
+        # and get mojibake instead of exceptions.
+        if possible_binary_reader is None:
+            return text_stream
+
+        binary_reader = possible_binary_reader
+
+    # Default errors to replace instead of strict in order to get
+    # something that works.
+    if errors is None:
+        errors = "replace"
+
+    # Wrap the binary stream in a text stream with the correct
+    # encoding parameters.
+    return _make_text_stream(
+        binary_reader,
+        encoding,
+        errors,
+        force_readable=force_readable,
+        force_writable=force_writable,
+    )
+
+
+def _force_correct_text_reader(
+    text_reader: t.IO[t.Any],
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+    force_readable: bool = False,
+) -> t.TextIO:
+    return _force_correct_text_stream(
+        text_reader,
+        encoding,
+        errors,
+        _is_binary_reader,
+        _find_binary_reader,
+        force_readable=force_readable,
+    )
+
+
+def _force_correct_text_writer(
+    text_writer: t.IO[t.Any],
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+    force_writable: bool = False,
+) -> t.TextIO:
+    return _force_correct_text_stream(
+        text_writer,
+        encoding,
+        errors,
+        _is_binary_writer,
+        _find_binary_writer,
+        force_writable=force_writable,
+    )
+
+
+def get_binary_stdin() -> t.BinaryIO:
+    reader = _find_binary_reader(sys.stdin)
+    if reader is None:
+        raise RuntimeError("Was not able to determine binary stream for sys.stdin.")
+    return reader
+
+
+def get_binary_stdout() -> t.BinaryIO:
+    writer = _find_binary_writer(sys.stdout)
+    if writer is None:
+        raise RuntimeError("Was not able to determine binary stream for sys.stdout.")
+    return writer
+
+
+def get_binary_stderr() -> t.BinaryIO:
+    writer = _find_binary_writer(sys.stderr)
+    if writer is None:
+        raise RuntimeError("Was not able to determine binary stream for sys.stderr.")
+    return writer
+
+
+def get_text_stdin(
+    encoding: t.Optional[str] = None, errors: t.Optional[str] = None
+) -> t.TextIO:
+    rv = _get_windows_console_stream(sys.stdin, encoding, errors)
+    if rv is not None:
+        return rv
+    return _force_correct_text_reader(sys.stdin, encoding, errors, force_readable=True)
+
+
+def get_text_stdout(
+    encoding: t.Optional[str] = None, errors: t.Optional[str] = None
+) -> t.TextIO:
+    rv = _get_windows_console_stream(sys.stdout, encoding, errors)
+    if rv is not None:
+        return rv
+    return _force_correct_text_writer(sys.stdout, encoding, errors, force_writable=True)
+
+
+def get_text_stderr(
+    encoding: t.Optional[str] = None, errors: t.Optional[str] = None
+) -> t.TextIO:
+    rv = _get_windows_console_stream(sys.stderr, encoding, errors)
+    if rv is not None:
+        return rv
+    return _force_correct_text_writer(sys.stderr, encoding, errors, force_writable=True)
+
+
+def _wrap_io_open(
+    file: t.Union[str, "os.PathLike[str]", int],
+    mode: str,
+    encoding: t.Optional[str],
+    errors: t.Optional[str],
+) -> t.IO[t.Any]:
+    """Handles not passing ``encoding`` and ``errors`` in binary mode."""
+    if "b" in mode:
+        return open(file, mode)
+
+    return open(file, mode, encoding=encoding, errors=errors)
+
+
+def open_stream(
+    filename: "t.Union[str, os.PathLike[str]]",
+    mode: str = "r",
+    encoding: t.Optional[str] = None,
+    errors: t.Optional[str] = "strict",
+    atomic: bool = False,
+) -> t.Tuple[t.IO[t.Any], bool]:
+    binary = "b" in mode
+    filename = os.fspath(filename)
+
+    # Standard streams first. These are simple because they ignore the
+    # atomic flag. Use fsdecode to handle Path("-").
+    if os.fsdecode(filename) == "-":
+        if any(m in mode for m in ["w", "a", "x"]):
+            if binary:
+                return get_binary_stdout(), False
+            return get_text_stdout(encoding=encoding, errors=errors), False
+        if binary:
+            return get_binary_stdin(), False
+        return get_text_stdin(encoding=encoding, errors=errors), False
+
+    # Non-atomic writes directly go out through the regular open functions.
+    if not atomic:
+        return _wrap_io_open(filename, mode, encoding, errors), True
+
+    # Some usability stuff for atomic writes
+    if "a" in mode:
+        raise ValueError(
+            "Appending to an existing file is not supported, because that"
+            " would involve an expensive `copy`-operation to a temporary"
+            " file. Open the file in normal `w`-mode and copy explicitly"
+            " if that's what you're after."
+        )
+    if "x" in mode:
+        raise ValueError("Use the `overwrite`-parameter instead.")
+    if "w" not in mode:
+        raise ValueError("Atomic writes only make sense with `w`-mode.")
+
+    # Atomic writes are more complicated.  They work by opening a file
+    # as a proxy in the same folder and then using the fdopen
+    # functionality to wrap it in a Python file.  Then we wrap it in an
+    # atomic file that moves the file over on close.
+    import errno
+    import random
+
+    try:
+        perm: t.Optional[int] = os.stat(filename).st_mode
+    except OSError:
+        perm = None
+
+    flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
+
+    if binary:
+        flags |= getattr(os, "O_BINARY", 0)
+
+    while True:
+        tmp_filename = os.path.join(
+            os.path.dirname(filename),
+            f".__atomic-write{random.randrange(1 << 32):08x}",
+        )
+        try:
+            fd = os.open(tmp_filename, flags, 0o666 if perm is None else perm)
+            break
+        except OSError as e:
+            if e.errno == errno.EEXIST or (
+                os.name == "nt"
+                and e.errno == errno.EACCES
+                and os.path.isdir(e.filename)
+                and os.access(e.filename, os.W_OK)
+            ):
+                continue
+            raise
+
+    if perm is not None:
+        os.chmod(tmp_filename, perm)  # in case perm includes bits in umask
+
+    f = _wrap_io_open(fd, mode, encoding, errors)
+    af = _AtomicFile(f, tmp_filename, os.path.realpath(filename))
+    return t.cast(t.IO[t.Any], af), True
+
+
+class _AtomicFile:
+    def __init__(self, f: t.IO[t.Any], tmp_filename: str, real_filename: str) -> None:
+        self._f = f
+        self._tmp_filename = tmp_filename
+        self._real_filename = real_filename
+        self.closed = False
+
+    @property
+    def name(self) -> str:
+        return self._real_filename
+
+    def close(self, delete: bool = False) -> None:
+        if self.closed:
+            return
+        self._f.close()
+        os.replace(self._tmp_filename, self._real_filename)
+        self.closed = True
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._f, name)
+
+    def __enter__(self) -> "_AtomicFile":
+        return self
+
+    def __exit__(self, exc_type: t.Optional[t.Type[BaseException]], *_: t.Any) -> None:
+        self.close(delete=exc_type is not None)
+
+    def __repr__(self) -> str:
+        return repr(self._f)
+
+
+def strip_ansi(value: str) -> str:
+    return _ansi_re.sub("", value)
+
+
+def _is_jupyter_kernel_output(stream: t.IO[t.Any]) -> bool:
+    while isinstance(stream, (_FixupStream, _NonClosingTextIOWrapper)):
+        stream = stream._stream
+
+    return stream.__class__.__module__.startswith("ipykernel.")
+
+
+def should_strip_ansi(
+    stream: t.Optional[t.IO[t.Any]] = None, color: t.Optional[bool] = None
+) -> bool:
+    if color is None:
+        if stream is None:
+            stream = sys.stdin
+        return not isatty(stream) and not _is_jupyter_kernel_output(stream)
+    return not color
+
+
+# On Windows, wrap the output streams with colorama to support ANSI
+# color codes.
+# NOTE: double check is needed so mypy does not analyze this on Linux
+if sys.platform.startswith("win") and WIN:
+    from ._winconsole import _get_windows_console_stream
+
+    def _get_argv_encoding() -> str:
+        import locale
+
+        return locale.getpreferredencoding()
+
+    _ansi_stream_wrappers: t.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary()
+
+    def auto_wrap_for_ansi(
+        stream: t.TextIO, color: t.Optional[bool] = None
+    ) -> t.TextIO:
+        """Support ANSI color and style codes on Windows by wrapping a
+        stream with colorama.
+        """
+        try:
+            cached = _ansi_stream_wrappers.get(stream)
+        except Exception:
+            cached = None
+
+        if cached is not None:
+            return cached
+
+        import colorama
+
+        strip = should_strip_ansi(stream, color)
+        ansi_wrapper = colorama.AnsiToWin32(stream, strip=strip)
+        rv = t.cast(t.TextIO, ansi_wrapper.stream)
+        _write = rv.write
+
+        def _safe_write(s):
+            try:
+                return _write(s)
+            except BaseException:
+                ansi_wrapper.reset_all()
+                raise
+
+        rv.write = _safe_write
+
+        try:
+            _ansi_stream_wrappers[stream] = rv
+        except Exception:
+            pass
+
+        return rv
+
+else:
+
+    def _get_argv_encoding() -> str:
+        return getattr(sys.stdin, "encoding", None) or sys.getfilesystemencoding()
+
+    def _get_windows_console_stream(
+        f: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str]
+    ) -> t.Optional[t.TextIO]:
+        return None
+
+
+def term_len(x: str) -> int:
+    return len(strip_ansi(x))
+
+
+def isatty(stream: t.IO[t.Any]) -> bool:
+    try:
+        return stream.isatty()
+    except Exception:
+        return False
+
+
+def _make_cached_stream_func(
+    src_func: t.Callable[[], t.Optional[t.TextIO]],
+    wrapper_func: t.Callable[[], t.TextIO],
+) -> t.Callable[[], t.Optional[t.TextIO]]:
+    cache: t.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary()
+
+    def func() -> t.Optional[t.TextIO]:
+        stream = src_func()
+
+        if stream is None:
+            return None
+
+        try:
+            rv = cache.get(stream)
+        except Exception:
+            rv = None
+        if rv is not None:
+            return rv
+        rv = wrapper_func()
+        try:
+            cache[stream] = rv
+        except Exception:
+            pass
+        return rv
+
+    return func
+
+
+_default_text_stdin = _make_cached_stream_func(lambda: sys.stdin, get_text_stdin)
+_default_text_stdout = _make_cached_stream_func(lambda: sys.stdout, get_text_stdout)
+_default_text_stderr = _make_cached_stream_func(lambda: sys.stderr, get_text_stderr)
+
+
+binary_streams: t.Mapping[str, t.Callable[[], t.BinaryIO]] = {
+    "stdin": get_binary_stdin,
+    "stdout": get_binary_stdout,
+    "stderr": get_binary_stderr,
+}
+
+text_streams: t.Mapping[
+    str, t.Callable[[t.Optional[str], t.Optional[str]], t.TextIO]
+] = {
+    "stdin": get_text_stdin,
+    "stdout": get_text_stdout,
+    "stderr": get_text_stderr,
+}
@@ -0,0 +1,788 @@
+"""
+This module contains implementations for the termui module. To keep the
+import time of Click down, some infrequently used functionality is
+placed in this module and only imported as needed.
+"""
+
+import contextlib
+import math
+import os
+import sys
+import time
+import typing as t
+from gettext import gettext as _
+from io import StringIO
+from shutil import which
+from types import TracebackType
+
+from ._compat import _default_text_stdout
+from ._compat import CYGWIN
+from ._compat import get_best_encoding
+from ._compat import isatty
+from ._compat import open_stream
+from ._compat import strip_ansi
+from ._compat import term_len
+from ._compat import WIN
+from .exceptions import ClickException
+from .utils import echo
+
+V = t.TypeVar("V")
+
+if os.name == "nt":
+    BEFORE_BAR = "\r"
+    AFTER_BAR = "\n"
+else:
+    BEFORE_BAR = "\r\033[?25l"
+    AFTER_BAR = "\033[?25h\n"
+
+
+class ProgressBar(t.Generic[V]):
+    def __init__(
+        self,
+        iterable: t.Optional[t.Iterable[V]],
+        length: t.Optional[int] = None,
+        fill_char: str = "#",
+        empty_char: str = " ",
+        bar_template: str = "%(bar)s",
+        info_sep: str = "  ",
+        show_eta: bool = True,
+        show_percent: t.Optional[bool] = None,
+        show_pos: bool = False,
+        item_show_func: t.Optional[t.Callable[[t.Optional[V]], t.Optional[str]]] = None,
+        label: t.Optional[str] = None,
+        file: t.Optional[t.TextIO] = None,
+        color: t.Optional[bool] = None,
+        update_min_steps: int = 1,
+        width: int = 30,
+    ) -> None:
+        self.fill_char = fill_char
+        self.empty_char = empty_char
+        self.bar_template = bar_template
+        self.info_sep = info_sep
+        self.show_eta = show_eta
+        self.show_percent = show_percent
+        self.show_pos = show_pos
+        self.item_show_func = item_show_func
+        self.label: str = label or ""
+
+        if file is None:
+            file = _default_text_stdout()
+
+            # There are no standard streams attached to write to. For example,
+            # pythonw on Windows.
+            if file is None:
+                file = StringIO()
+
+        self.file = file
+        self.color = color
+        self.update_min_steps = update_min_steps
+        self._completed_intervals = 0
+        self.width: int = width
+        self.autowidth: bool = width == 0
+
+        if length is None:
+            from operator import length_hint
+
+            length = length_hint(iterable, -1)
+
+            if length == -1:
+                length = None
+        if iterable is None:
+            if length is None:
+                raise TypeError("iterable or length is required")
+            iterable = t.cast(t.Iterable[V], range(length))
+        self.iter: t.Iterable[V] = iter(iterable)
+        self.length = length
+        self.pos = 0
+        self.avg: t.List[float] = []
+        self.last_eta: float
+        self.start: float
+        self.start = self.last_eta = time.time()
+        self.eta_known: bool = False
+        self.finished: bool = False
+        self.max_width: t.Optional[int] = None
+        self.entered: bool = False
+        self.current_item: t.Optional[V] = None
+        self.is_hidden: bool = not isatty(self.file)
+        self._last_line: t.Optional[str] = None
+
+    def __enter__(self) -> "ProgressBar[V]":
+        self.entered = True
+        self.render_progress()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: t.Optional[t.Type[BaseException]],
+        exc_value: t.Optional[BaseException],
+        tb: t.Optional[TracebackType],
+    ) -> None:
+        self.render_finish()
+
+    def __iter__(self) -> t.Iterator[V]:
+        if not self.entered:
+            raise RuntimeError("You need to use progress bars in a with block.")
+        self.render_progress()
+        return self.generator()
+
+    def __next__(self) -> V:
+        # Iteration is defined in terms of a generator function,
+        # returned by iter(self); use that to define next(). This works
+        # because `self.iter` is an iterable consumed by that generator,
+        # so it is re-entry safe. Calling `next(self.generator())`
+        # twice works and does "what you want".
+        return next(iter(self))
+
+    def render_finish(self) -> None:
+        if self.is_hidden:
+            return
+        self.file.write(AFTER_BAR)
+        self.file.flush()
+
+    @property
+    def pct(self) -> float:
+        if self.finished:
+            return 1.0
+        return min(self.pos / (float(self.length or 1) or 1), 1.0)
+
+    @property
+    def time_per_iteration(self) -> float:
+        if not self.avg:
+            return 0.0
+        return sum(self.avg) / float(len(self.avg))
+
+    @property
+    def eta(self) -> float:
+        if self.length is not None and not self.finished:
+            return self.time_per_iteration * (self.length - self.pos)
+        return 0.0
+
+    def format_eta(self) -> str:
+        if self.eta_known:
+            t = int(self.eta)
+            seconds = t % 60
+            t //= 60
+            minutes = t % 60
+            t //= 60
+            hours = t % 24
+            t //= 24
+            if t > 0:
+                return f"{t}d {hours:02}:{minutes:02}:{seconds:02}"
+            else:
+                return f"{hours:02}:{minutes:02}:{seconds:02}"
+        return ""
+
+    def format_pos(self) -> str:
+        pos = str(self.pos)
+        if self.length is not None:
+            pos += f"/{self.length}"
+        return pos
+
+    def format_pct(self) -> str:
+        return f"{int(self.pct * 100): 4}%"[1:]
+
+    def format_bar(self) -> str:
+        if self.length is not None:
+            bar_length = int(self.pct * self.width)
+            bar = self.fill_char * bar_length
+            bar += self.empty_char * (self.width - bar_length)
+        elif self.finished:
+            bar = self.fill_char * self.width
+        else:
+            chars = list(self.empty_char * (self.width or 1))
+            if self.time_per_iteration != 0:
+                chars[
+                    int(
+                        (math.cos(self.pos * self.time_per_iteration) / 2.0 + 0.5)
+                        * self.width
+                    )
+                ] = self.fill_char
+            bar = "".join(chars)
+        return bar
+
+    def format_progress_line(self) -> str:
+        show_percent = self.show_percent
+
+        info_bits = []
+        if self.length is not None and show_percent is None:
+            show_percent = not self.show_pos
+
+        if self.show_pos:
+            info_bits.append(self.format_pos())
+        if show_percent:
+            info_bits.append(self.format_pct())
+        if self.show_eta and self.eta_known and not self.finished:
+            info_bits.append(self.format_eta())
+        if self.item_show_func is not None:
+            item_info = self.item_show_func(self.current_item)
+            if item_info is not None:
+                info_bits.append(item_info)
+
+        return (
+            self.bar_template
+            % {
+                "label": self.label,
+                "bar": self.format_bar(),
+                "info": self.info_sep.join(info_bits),
+            }
+        ).rstrip()
+
+    def render_progress(self) -> None:
+        import shutil
+
+        if self.is_hidden:
+            # Only output the label as it changes if the output is not a
+            # TTY. Use file=stderr if you expect to be piping stdout.
+            if self._last_line != self.label:
+                self._last_line = self.label
+                echo(self.label, file=self.file, color=self.color)
+
+            return
+
+        buf = []
+        # Update width in case the terminal has been resized
+        if self.autowidth:
+            old_width = self.width
+            self.width = 0
+            clutter_length = term_len(self.format_progress_line())
+            new_width = max(0, shutil.get_terminal_size().columns - clutter_length)
+            if new_width < old_width:
+                buf.append(BEFORE_BAR)
+                buf.append(" " * self.max_width)  # type: ignore
+                self.max_width = new_width
+            self.width = new_width
+
+        clear_width = self.width
+        if self.max_width is not None:
+            clear_width = self.max_width
+
+        buf.append(BEFORE_BAR)
+        line = self.format_progress_line()
+        line_len = term_len(line)
+        if self.max_width is None or self.max_width < line_len:
+            self.max_width = line_len
+
+        buf.append(line)
+        buf.append(" " * (clear_width - line_len))
+        line = "".join(buf)
+        # Render the line only if it changed.
+
+        if line != self._last_line:
+            self._last_line = line
+            echo(line, file=self.file, color=self.color, nl=False)
+            self.file.flush()
+
+    def make_step(self, n_steps: int) -> None:
+        self.pos += n_steps
+        if self.length is not None and self.pos >= self.length:
+            self.finished = True
+
+        if (time.time() - self.last_eta) < 1.0:
+            return
+
+        self.last_eta = time.time()
+
+        # self.avg is a rolling list of length <= 7 of steps where steps are
+        # defined as time elapsed divided by the total progress through
+        # self.length.
+        if self.pos:
+            step = (time.time() - self.start) / self.pos
+        else:
+            step = time.time() - self.start
+
+        self.avg = self.avg[-6:] + [step]
+
+        self.eta_known = self.length is not None
+
+    def update(self, n_steps: int, current_item: t.Optional[V] = None) -> None:
+        """Update the progress bar by advancing a specified number of
+        steps, and optionally set the ``current_item`` for this new
+        position.
+
+        :param n_steps: Number of steps to advance.
+        :param current_item: Optional item to set as ``current_item``
+            for the updated position.
+
+        .. versionchanged:: 8.0
+            Added the ``current_item`` optional parameter.
+
+        .. versionchanged:: 8.0
+            Only render when the number of steps meets the
+            ``update_min_steps`` threshold.
+        """
+        if current_item is not None:
+            self.current_item = current_item
+
+        self._completed_intervals += n_steps
+
+        if self._completed_intervals >= self.update_min_steps:
+            self.make_step(self._completed_intervals)
+            self.render_progress()
+            self._completed_intervals = 0
+
+    def finish(self) -> None:
+        self.eta_known = False
+        self.current_item = None
+        self.finished = True
+
+    def generator(self) -> t.Iterator[V]:
+        """Return a generator which yields the items added to the bar
+        during construction, and updates the progress bar *after* the
+        yielded block returns.
+        """
+        # WARNING: the iterator interface for `ProgressBar` relies on
+        # this and only works because this is a simple generator which
+        # doesn't create or manage additional state. If this function
+        # changes, the impact should be evaluated both against
+        # `iter(bar)` and `next(bar)`. `next()` in particular may call
+        # `self.generator()` repeatedly, and this must remain safe in
+        # order for that interface to work.
+        if not self.entered:
+            raise RuntimeError("You need to use progress bars in a with block.")
+
+        if self.is_hidden:
+            yield from self.iter
+        else:
+            for rv in self.iter:
+                self.current_item = rv
+
+                # This allows show_item_func to be updated before the
+                # item is processed. Only trigger at the beginning of
+                # the update interval.
+                if self._completed_intervals == 0:
+                    self.render_progress()
+
+                yield rv
+                self.update(1)
+
+            self.finish()
+            self.render_progress()
+
+
+def pager(generator: t.Iterable[str], color: t.Optional[bool] = None) -> None:
+    """Decide what method to use for paging through text."""
+    stdout = _default_text_stdout()
+
+    # There are no standard streams attached to write to. For example,
+    # pythonw on Windows.
+    if stdout is None:
+        stdout = StringIO()
+
+    if not isatty(sys.stdin) or not isatty(stdout):
+        return _nullpager(stdout, generator, color)
+    pager_cmd = (os.environ.get("PAGER", None) or "").strip()
+    if pager_cmd:
+        if WIN:
+            if _tempfilepager(generator, pager_cmd, color):
+                return
+        elif _pipepager(generator, pager_cmd, color):
+            return
+    if os.environ.get("TERM") in ("dumb", "emacs"):
+        return _nullpager(stdout, generator, color)
+    if (WIN or sys.platform.startswith("os2")) and _tempfilepager(
+        generator, "more", color
+    ):
+        return
+    if _pipepager(generator, "less", color):
+        return
+
+    import tempfile
+
+    fd, filename = tempfile.mkstemp()
+    os.close(fd)
+    try:
+        if _pipepager(generator, "more", color):
+            return
+        return _nullpager(stdout, generator, color)
+    finally:
+        os.unlink(filename)
+
+
+def _pipepager(generator: t.Iterable[str], cmd: str, color: t.Optional[bool]) -> bool:
+    """Page through text by feeding it to another program.  Invoking a
+    pager through this might support colors.
+
+    Returns True if the command was found, False otherwise and thus another
+    pager should be attempted.
+    """
+    cmd_absolute = which(cmd)
+    if cmd_absolute is None:
+        return False
+
+    import subprocess
+
+    env = dict(os.environ)
+
+    # If we're piping to less we might support colors under the
+    # condition that
+    cmd_detail = cmd.rsplit("/", 1)[-1].split()
+    if color is None and cmd_detail[0] == "less":
+        less_flags = f"{os.environ.get('LESS', '')}{' '.join(cmd_detail[1:])}"
+        if not less_flags:
+            env["LESS"] = "-R"
+            color = True
+        elif "r" in less_flags or "R" in less_flags:
+            color = True
+
+    c = subprocess.Popen(
+        [cmd_absolute],
+        shell=True,
+        stdin=subprocess.PIPE,
+        env=env,
+        errors="replace",
+        text=True,
+    )
+    assert c.stdin is not None
+    try:
+        for text in generator:
+            if not color:
+                text = strip_ansi(text)
+
+            c.stdin.write(text)
+    except (OSError, KeyboardInterrupt):
+        pass
+    else:
+        c.stdin.close()
+
+    # Less doesn't respect ^C, but catches it for its own UI purposes (aborting
+    # search or other commands inside less).
+    #
+    # That means when the user hits ^C, the parent process (click) terminates,
+    # but less is still alive, paging the output and messing up the terminal.
+    #
+    # If the user wants to make the pager exit on ^C, they should set
+    # `LESS='-K'`. It's not our decision to make.
+    while True:
+        try:
+            c.wait()
+        except KeyboardInterrupt:
+            pass
+        else:
+            break
+
+    return True
+
+
+def _tempfilepager(
+    generator: t.Iterable[str],
+    cmd: str,
+    color: t.Optional[bool],
+) -> bool:
+    """Page through text by invoking a program on a temporary file.
+
+    Returns True if the command was found, False otherwise and thus another
+    pager should be attempted.
+    """
+    # Which is necessary for Windows, it is also recommended in the Popen docs.
+    cmd_absolute = which(cmd)
+    if cmd_absolute is None:
+        return False
+
+    import subprocess
+    import tempfile
+
+    fd, filename = tempfile.mkstemp()
+    # TODO: This never terminates if the passed generator never terminates.
+    text = "".join(generator)
+    if not color:
+        text = strip_ansi(text)
+    encoding = get_best_encoding(sys.stdout)
+    with open_stream(filename, "wb")[0] as f:
+        f.write(text.encode(encoding))
+    try:
+        subprocess.call([cmd_absolute, filename])
+    except OSError:
+        # Command not found
+        pass
+    finally:
+        os.close(fd)
+        os.unlink(filename)
+
+    return True
+
+
+def _nullpager(
+    stream: t.TextIO, generator: t.Iterable[str], color: t.Optional[bool]
+) -> None:
+    """Simply print unformatted text.  This is the ultimate fallback."""
+    for text in generator:
+        if not color:
+            text = strip_ansi(text)
+        stream.write(text)
+
+
+class Editor:
+    def __init__(
+        self,
+        editor: t.Optional[str] = None,
+        env: t.Optional[t.Mapping[str, str]] = None,
+        require_save: bool = True,
+        extension: str = ".txt",
+    ) -> None:
+        self.editor = editor
+        self.env = env
+        self.require_save = require_save
+        self.extension = extension
+
+    def get_editor(self) -> str:
+        if self.editor is not None:
+            return self.editor
+        for key in "VISUAL", "EDITOR":
+            rv = os.environ.get(key)
+            if rv:
+                return rv
+        if WIN:
+            return "notepad"
+        for editor in "sensible-editor", "vim", "nano":
+            if which(editor) is not None:
+                return editor
+        return "vi"
+
+    def edit_file(self, filename: str) -> None:
+        import subprocess
+
+        editor = self.get_editor()
+        environ: t.Optional[t.Dict[str, str]] = None
+
+        if self.env:
+            environ = os.environ.copy()
+            environ.update(self.env)
+
+        try:
+            c = subprocess.Popen(f'{editor} "{filename}"', env=environ, shell=True)
+            exit_code = c.wait()
+            if exit_code != 0:
+                raise ClickException(
+                    _("{editor}: Editing failed").format(editor=editor)
+                )
+        except OSError as e:
+            raise ClickException(
+                _("{editor}: Editing failed: {e}").format(editor=editor, e=e)
+            ) from e
+
+    def edit(self, text: t.Optional[t.AnyStr]) -> t.Optional[t.AnyStr]:
+        import tempfile
+
+        if not text:
+            data = b""
+        elif isinstance(text, (bytes, bytearray)):
+            data = text
+        else:
+            if text and not text.endswith("\n"):
+                text += "\n"
+
+            if WIN:
+                data = text.replace("\n", "\r\n").encode("utf-8-sig")
+            else:
+                data = text.encode("utf-8")
+
+        fd, name = tempfile.mkstemp(prefix="editor-", suffix=self.extension)
+        f: t.BinaryIO
+
+        try:
+            with os.fdopen(fd, "wb") as f:
+                f.write(data)
+
+            # If the filesystem resolution is 1 second, like Mac OS
+            # 10.12 Extended, or 2 seconds, like FAT32, and the editor
+            # closes very fast, require_save can fail. Set the modified
+            # time to be 2 seconds in the past to work around this.
+            os.utime(name, (os.path.getatime(name), os.path.getmtime(name) - 2))
+            # Depending on the resolution, the exact value might not be
+            # recorded, so get the new recorded value.
+            timestamp = os.path.getmtime(name)
+
+            self.edit_file(name)
+
+            if self.require_save and os.path.getmtime(name) == timestamp:
+                return None
+
+            with open(name, "rb") as f:
+                rv = f.read()
+
+            if isinstance(text, (bytes, bytearray)):
+                return rv
+
+            return rv.decode("utf-8-sig").replace("\r\n", "\n")  # type: ignore
+        finally:
+            os.unlink(name)
+
+
+def open_url(url: str, wait: bool = False, locate: bool = False) -> int:
+    import subprocess
+
+    def _unquote_file(url: str) -> str:
+        from urllib.parse import unquote
+
+        if url.startswith("file://"):
+            url = unquote(url[7:])
+
+        return url
+
+    if sys.platform == "darwin":
+        args = ["open"]
+        if wait:
+            args.append("-W")
+        if locate:
+            args.append("-R")
+        args.append(_unquote_file(url))
+        null = open("/dev/null", "w")
+        try:
+            return subprocess.Popen(args, stderr=null).wait()
+        finally:
+            null.close()
+    elif WIN:
+        if locate:
+            url = _unquote_file(url)
+            args = ["explorer", f"/select,{url}"]
+        else:
+            args = ["start"]
+            if wait:
+                args.append("/WAIT")
+            args.append("")
+            args.append(url)
+        try:
+            return subprocess.call(args)
+        except OSError:
+            # Command not found
+            return 127
+    elif CYGWIN:
+        if locate:
+            url = _unquote_file(url)
+            args = ["cygstart", os.path.dirname(url)]
+        else:
+            args = ["cygstart"]
+            if wait:
+                args.append("-w")
+            args.append(url)
+        try:
+            return subprocess.call(args)
+        except OSError:
+            # Command not found
+            return 127
+
+    try:
+        if locate:
+            url = os.path.dirname(_unquote_file(url)) or "."
+        else:
+            url = _unquote_file(url)
+        c = subprocess.Popen(["xdg-open", url])
+        if wait:
+            return c.wait()
+        return 0
+    except OSError:
+        if url.startswith(("http://", "https://")) and not locate and not wait:
+            import webbrowser
+
+            webbrowser.open(url)
+            return 0
+        return 1
+
+
+def _translate_ch_to_exc(ch: str) -> t.Optional[BaseException]:
+    if ch == "\x03":
+        raise KeyboardInterrupt()
+
+    if ch == "\x04" and not WIN:  # Unix-like, Ctrl+D
+        raise EOFError()
+
+    if ch == "\x1a" and WIN:  # Windows, Ctrl+Z
+        raise EOFError()
+
+    return None
+
+
+if WIN:
+    import msvcrt
+
+    @contextlib.contextmanager
+    def raw_terminal() -> t.Iterator[int]:
+        yield -1
+
+    def getchar(echo: bool) -> str:
+        # The function `getch` will return a bytes object corresponding to
+        # the pressed character. Since Windows 10 build 1803, it will also
+        # return \x00 when called a second time after pressing a regular key.
+        #
+        # `getwch` does not share this probably-bugged behavior. Moreover, it
+        # returns a Unicode object by default, which is what we want.
+        #
+        # Either of these functions will return \x00 or \xe0 to indicate
+        # a special key, and you need to call the same function again to get
+        # the "rest" of the code. The fun part is that \u00e0 is
+        # "latin small letter a with grave", so if you type that on a French
+        # keyboard, you _also_ get a \xe0.
+        # E.g., consider the Up arrow. This returns \xe0 and then \x48. The
+        # resulting Unicode string reads as "a with grave" + "capital H".
+        # This is indistinguishable from when the user actually types
+        # "a with grave" and then "capital H".
+        #
+        # When \xe0 is returned, we assume it's part of a special-key sequence
+        # and call `getwch` again, but that means that when the user types
+        # the \u00e0 character, `getchar` doesn't return until a second
+        # character is typed.
+        # The alternative is returning immediately, but that would mess up
+        # cross-platform handling of arrow keys and others that start with
+        # \xe0. Another option is using `getch`, but then we can't reliably
+        # read non-ASCII characters, because return values of `getch` are
+        # limited to the current 8-bit codepage.
+        #
+        # Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
+        # is doing the right thing in more situations than with `getch`.
+        func: t.Callable[[], str]
+
+        if echo:
+            func = msvcrt.getwche  # type: ignore
+        else:
+            func = msvcrt.getwch  # type: ignore
+
+        rv = func()
+
+        if rv in ("\x00", "\xe0"):
+            # \x00 and \xe0 are control characters that indicate special key,
+            # see above.
+            rv += func()
+
+        _translate_ch_to_exc(rv)
+        return rv
+
+else:
+    import termios
+    import tty
+
+    @contextlib.contextmanager
+    def raw_terminal() -> t.Iterator[int]:
+        f: t.Optional[t.TextIO]
+        fd: int
+
+        if not isatty(sys.stdin):
+            f = open("/dev/tty")
+            fd = f.fileno()
+        else:
+            fd = sys.stdin.fileno()
+            f = None
+
+        try:
+            old_settings = termios.tcgetattr(fd)
+
+            try:
+                tty.setraw(fd)
+                yield fd
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+                sys.stdout.flush()
+
+                if f is not None:
+                    f.close()
+        except termios.error:
+            pass
+
+    def getchar(echo: bool) -> str:
+        with raw_terminal() as fd:
+            ch = os.read(fd, 32).decode(get_best_encoding(sys.stdin), "replace")
+
+            if echo and isatty(sys.stdout):
+                sys.stdout.write(ch)
+
+            _translate_ch_to_exc(ch)
+            return ch
@@ -0,0 +1,49 @@
+import textwrap
+import typing as t
+from contextlib import contextmanager
+
+
+class TextWrapper(textwrap.TextWrapper):
+    def _handle_long_word(
+        self,
+        reversed_chunks: t.List[str],
+        cur_line: t.List[str],
+        cur_len: int,
+        width: int,
+    ) -> None:
+        space_left = max(width - cur_len, 1)
+
+        if self.break_long_words:
+            last = reversed_chunks[-1]
+            cut = last[:space_left]
+            res = last[space_left:]
+            cur_line.append(cut)
+            reversed_chunks[-1] = res
+        elif not cur_line:
+            cur_line.append(reversed_chunks.pop())
+
+    @contextmanager
+    def extra_indent(self, indent: str) -> t.Iterator[None]:
+        old_initial_indent = self.initial_indent
+        old_subsequent_indent = self.subsequent_indent
+        self.initial_indent += indent
+        self.subsequent_indent += indent
+
+        try:
+            yield
+        finally:
+            self.initial_indent = old_initial_indent
+            self.subsequent_indent = old_subsequent_indent
+
+    def indent_only(self, text: str) -> str:
+        rv = []
+
+        for idx, line in enumerate(text.splitlines()):
+            indent = self.initial_indent
+
+            if idx > 0:
+                indent = self.subsequent_indent
+
+            rv.append(f"{indent}{line}")
+
+        return "\n".join(rv)
@@ -0,0 +1,279 @@
+# This module is based on the excellent work by Adam Bartoš who
+# provided a lot of what went into the implementation here in
+# the discussion to issue1602 in the Python bug tracker.
+#
+# There are some general differences in regards to how this works
+# compared to the original patches as we do not need to patch
+# the entire interpreter but just work in our little world of
+# echo and prompt.
+import io
+import sys
+import time
+import typing as t
+from ctypes import byref
+from ctypes import c_char
+from ctypes import c_char_p
+from ctypes import c_int
+from ctypes import c_ssize_t
+from ctypes import c_ulong
+from ctypes import c_void_p
+from ctypes import POINTER
+from ctypes import py_object
+from ctypes import Structure
+from ctypes.wintypes import DWORD
+from ctypes.wintypes import HANDLE
+from ctypes.wintypes import LPCWSTR
+from ctypes.wintypes import LPWSTR
+
+from ._compat import _NonClosingTextIOWrapper
+
+assert sys.platform == "win32"
+import msvcrt  # noqa: E402
+from ctypes import windll  # noqa: E402
+from ctypes import WINFUNCTYPE  # noqa: E402
+
+c_ssize_p = POINTER(c_ssize_t)
+
+kernel32 = windll.kernel32
+GetStdHandle = kernel32.GetStdHandle
+ReadConsoleW = kernel32.ReadConsoleW
+WriteConsoleW = kernel32.WriteConsoleW
+GetConsoleMode = kernel32.GetConsoleMode
+GetLastError = kernel32.GetLastError
+GetCommandLineW = WINFUNCTYPE(LPWSTR)(("GetCommandLineW", windll.kernel32))
+CommandLineToArgvW = WINFUNCTYPE(POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
+    ("CommandLineToArgvW", windll.shell32)
+)
+LocalFree = WINFUNCTYPE(c_void_p, c_void_p)(("LocalFree", windll.kernel32))
+
+STDIN_HANDLE = GetStdHandle(-10)
+STDOUT_HANDLE = GetStdHandle(-11)
+STDERR_HANDLE = GetStdHandle(-12)
+
+PyBUF_SIMPLE = 0
+PyBUF_WRITABLE = 1
+
+ERROR_SUCCESS = 0
+ERROR_NOT_ENOUGH_MEMORY = 8
+ERROR_OPERATION_ABORTED = 995
+
+STDIN_FILENO = 0
+STDOUT_FILENO = 1
+STDERR_FILENO = 2
+
+EOF = b"\x1a"
+MAX_BYTES_WRITTEN = 32767
+
+try:
+    from ctypes import pythonapi
+except ImportError:
+    # On PyPy we cannot get buffers so our ability to operate here is
+    # severely limited.
+    get_buffer = None
+else:
+
+    class Py_buffer(Structure):
+        _fields_ = [
+            ("buf", c_void_p),
+            ("obj", py_object),
+            ("len", c_ssize_t),
+            ("itemsize", c_ssize_t),
+            ("readonly", c_int),
+            ("ndim", c_int),
+            ("format", c_char_p),
+            ("shape", c_ssize_p),
+            ("strides", c_ssize_p),
+            ("suboffsets", c_ssize_p),
+            ("internal", c_void_p),
+        ]
+
+    PyObject_GetBuffer = pythonapi.PyObject_GetBuffer
+    PyBuffer_Release = pythonapi.PyBuffer_Release
+
+    def get_buffer(obj, writable=False):
+        buf = Py_buffer()
+        flags = PyBUF_WRITABLE if writable else PyBUF_SIMPLE
+        PyObject_GetBuffer(py_object(obj), byref(buf), flags)
+
+        try:
+            buffer_type = c_char * buf.len
+            return buffer_type.from_address(buf.buf)
+        finally:
+            PyBuffer_Release(byref(buf))
+
+
+class _WindowsConsoleRawIOBase(io.RawIOBase):
+    def __init__(self, handle):
+        self.handle = handle
+
+    def isatty(self):
+        super().isatty()
+        return True
+
+
+class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
+    def readable(self):
+        return True
+
+    def readinto(self, b):
+        bytes_to_be_read = len(b)
+        if not bytes_to_be_read:
+            return 0
+        elif bytes_to_be_read % 2:
+            raise ValueError(
+                "cannot read odd number of bytes from UTF-16-LE encoded console"
+            )
+
+        buffer = get_buffer(b, writable=True)
+        code_units_to_be_read = bytes_to_be_read // 2
+        code_units_read = c_ulong()
+
+        rv = ReadConsoleW(
+            HANDLE(self.handle),
+            buffer,
+            code_units_to_be_read,
+            byref(code_units_read),
+            None,
+        )
+        if GetLastError() == ERROR_OPERATION_ABORTED:
+            # wait for KeyboardInterrupt
+            time.sleep(0.1)
+        if not rv:
+            raise OSError(f"Windows error: {GetLastError()}")
+
+        if buffer[0] == EOF:
+            return 0
+        return 2 * code_units_read.value
+
+
+class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
+    def writable(self):
+        return True
+
+    @staticmethod
+    def _get_error_message(errno):
+        if errno == ERROR_SUCCESS:
+            return "ERROR_SUCCESS"
+        elif errno == ERROR_NOT_ENOUGH_MEMORY:
+            return "ERROR_NOT_ENOUGH_MEMORY"
+        return f"Windows error {errno}"
+
+    def write(self, b):
+        bytes_to_be_written = len(b)
+        buf = get_buffer(b)
+        code_units_to_be_written = min(bytes_to_be_written, MAX_BYTES_WRITTEN) // 2
+        code_units_written = c_ulong()
+
+        WriteConsoleW(
+            HANDLE(self.handle),
+            buf,
+            code_units_to_be_written,
+            byref(code_units_written),
+            None,
+        )
+        bytes_written = 2 * code_units_written.value
+
+        if bytes_written == 0 and bytes_to_be_written > 0:
+            raise OSError(self._get_error_message(GetLastError()))
+        return bytes_written
+
+
+class ConsoleStream:
+    def __init__(self, text_stream: t.TextIO, byte_stream: t.BinaryIO) -> None:
+        self._text_stream = text_stream
+        self.buffer = byte_stream
+
+    @property
+    def name(self) -> str:
+        return self.buffer.name
+
+    def write(self, x: t.AnyStr) -> int:
+        if isinstance(x, str):
+            return self._text_stream.write(x)
+        try:
+            self.flush()
+        except Exception:
+            pass
+        return self.buffer.write(x)
+
+    def writelines(self, lines: t.Iterable[t.AnyStr]) -> None:
+        for line in lines:
+            self.write(line)
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._text_stream, name)
+
+    def isatty(self) -> bool:
+        return self.buffer.isatty()
+
+    def __repr__(self):
+        return f"<ConsoleStream name={self.name!r} encoding={self.encoding!r}>"
+
+
+def _get_text_stdin(buffer_stream: t.BinaryIO) -> t.TextIO:
+    text_stream = _NonClosingTextIOWrapper(
+        io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
+
+
+def _get_text_stdout(buffer_stream: t.BinaryIO) -> t.TextIO:
+    text_stream = _NonClosingTextIOWrapper(
+        io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)),
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
+
+
+def _get_text_stderr(buffer_stream: t.BinaryIO) -> t.TextIO:
+    text_stream = _NonClosingTextIOWrapper(
+        io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)),
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
+
+
+_stream_factories: t.Mapping[int, t.Callable[[t.BinaryIO], t.TextIO]] = {
+    0: _get_text_stdin,
+    1: _get_text_stdout,
+    2: _get_text_stderr,
+}
+
+
+def _is_console(f: t.TextIO) -> bool:
+    if not hasattr(f, "fileno"):
+        return False
+
+    try:
+        fileno = f.fileno()
+    except (OSError, io.UnsupportedOperation):
+        return False
+
+    handle = msvcrt.get_osfhandle(fileno)
+    return bool(GetConsoleMode(handle, byref(DWORD())))
+
+
+def _get_windows_console_stream(
+    f: t.TextIO, encoding: t.Optional[str], errors: t.Optional[str]
+) -> t.Optional[t.TextIO]:
+    if (
+        get_buffer is not None
+        and encoding in {"utf-16-le", None}
+        and errors in {"strict", None}
+        and _is_console(f)
+    ):
+        func = _stream_factories.get(f.fileno())
+        if func is not None:
+            b = getattr(f, "buffer", None)
+
+            if b is None:
+                return None
+
+            return func(b)
@@ -0,0 +1,562 @@
+import inspect
+import types
+import typing as t
+from functools import update_wrapper
+from gettext import gettext as _
+
+from .core import Argument
+from .core import Command
+from .core import Context
+from .core import Group
+from .core import Option
+from .core import Parameter
+from .globals import get_current_context
+from .utils import echo
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    P = te.ParamSpec("P")
+
+R = t.TypeVar("R")
+T = t.TypeVar("T")
+_AnyCallable = t.Callable[..., t.Any]
+FC = t.TypeVar("FC", bound=t.Union[_AnyCallable, Command])
+
+
+def pass_context(f: "t.Callable[te.Concatenate[Context, P], R]") -> "t.Callable[P, R]":
+    """Marks a callback as wanting to receive the current context
+    object as first argument.
+    """
+
+    def new_func(*args: "P.args", **kwargs: "P.kwargs") -> "R":
+        return f(get_current_context(), *args, **kwargs)
+
+    return update_wrapper(new_func, f)
+
+
+def pass_obj(f: "t.Callable[te.Concatenate[t.Any, P], R]") -> "t.Callable[P, R]":
+    """Similar to :func:`pass_context`, but only pass the object on the
+    context onwards (:attr:`Context.obj`).  This is useful if that object
+    represents the state of a nested system.
+    """
+
+    def new_func(*args: "P.args", **kwargs: "P.kwargs") -> "R":
+        return f(get_current_context().obj, *args, **kwargs)
+
+    return update_wrapper(new_func, f)
+
+
+def make_pass_decorator(
+    object_type: t.Type[T], ensure: bool = False
+) -> t.Callable[["t.Callable[te.Concatenate[T, P], R]"], "t.Callable[P, R]"]:
+    """Given an object type this creates a decorator that will work
+    similar to :func:`pass_obj` but instead of passing the object of the
+    current context, it will find the innermost context of type
+    :func:`object_type`.
+
+    This generates a decorator that works roughly like this::
+
+        from functools import update_wrapper
+
+        def decorator(f):
+            @pass_context
+            def new_func(ctx, *args, **kwargs):
+                obj = ctx.find_object(object_type)
+                return ctx.invoke(f, obj, *args, **kwargs)
+            return update_wrapper(new_func, f)
+        return decorator
+
+    :param object_type: the type of the object to pass.
+    :param ensure: if set to `True`, a new object will be created and
+                   remembered on the context if it's not there yet.
+    """
+
+    def decorator(f: "t.Callable[te.Concatenate[T, P], R]") -> "t.Callable[P, R]":
+        def new_func(*args: "P.args", **kwargs: "P.kwargs") -> "R":
+            ctx = get_current_context()
+
+            obj: t.Optional[T]
+            if ensure:
+                obj = ctx.ensure_object(object_type)
+            else:
+                obj = ctx.find_object(object_type)
+
+            if obj is None:
+                raise RuntimeError(
+                    "Managed to invoke callback without a context"
+                    f" object of type {object_type.__name__!r}"
+                    " existing."
+                )
+
+            return ctx.invoke(f, obj, *args, **kwargs)
+
+        return update_wrapper(new_func, f)
+
+    return decorator
+
+
+def pass_meta_key(
+    key: str, *, doc_description: t.Optional[str] = None
+) -> "t.Callable[[t.Callable[te.Concatenate[t.Any, P], R]], t.Callable[P, R]]":
+    """Create a decorator that passes a key from
+    :attr:`click.Context.meta` as the first argument to the decorated
+    function.
+
+    :param key: Key in ``Context.meta`` to pass.
+    :param doc_description: Description of the object being passed,
+        inserted into the decorator's docstring. Defaults to "the 'key'
+        key from Context.meta".
+
+    .. versionadded:: 8.0
+    """
+
+    def decorator(f: "t.Callable[te.Concatenate[t.Any, P], R]") -> "t.Callable[P, R]":
+        def new_func(*args: "P.args", **kwargs: "P.kwargs") -> R:
+            ctx = get_current_context()
+            obj = ctx.meta[key]
+            return ctx.invoke(f, obj, *args, **kwargs)
+
+        return update_wrapper(new_func, f)
+
+    if doc_description is None:
+        doc_description = f"the {key!r} key from :attr:`click.Context.meta`"
+
+    decorator.__doc__ = (
+        f"Decorator that passes {doc_description} as the first argument"
+        " to the decorated function."
+    )
+    return decorator
+
+
+CmdType = t.TypeVar("CmdType", bound=Command)
+
+
+# variant: no call, directly as decorator for a function.
+@t.overload
+def command(name: _AnyCallable) -> Command: ...
+
+
+# variant: with positional name and with positional or keyword cls argument:
+# @command(namearg, CommandCls, ...) or @command(namearg, cls=CommandCls, ...)
+@t.overload
+def command(
+    name: t.Optional[str],
+    cls: t.Type[CmdType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], CmdType]: ...
+
+
+# variant: name omitted, cls _must_ be a keyword argument, @command(cls=CommandCls, ...)
+@t.overload
+def command(
+    name: None = None,
+    *,
+    cls: t.Type[CmdType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], CmdType]: ...
+
+
+# variant: with optional string name, no cls argument provided.
+@t.overload
+def command(
+    name: t.Optional[str] = ..., cls: None = None, **attrs: t.Any
+) -> t.Callable[[_AnyCallable], Command]: ...
+
+
+def command(
+    name: t.Union[t.Optional[str], _AnyCallable] = None,
+    cls: t.Optional[t.Type[CmdType]] = None,
+    **attrs: t.Any,
+) -> t.Union[Command, t.Callable[[_AnyCallable], t.Union[Command, CmdType]]]:
+    r"""Creates a new :class:`Command` and uses the decorated function as
+    callback.  This will also automatically attach all decorated
+    :func:`option`\s and :func:`argument`\s as parameters to the command.
+
+    The name of the command defaults to the name of the function with
+    underscores replaced by dashes.  If you want to change that, you can
+    pass the intended name as the first argument.
+
+    All keyword arguments are forwarded to the underlying command class.
+    For the ``params`` argument, any decorated params are appended to
+    the end of the list.
+
+    Once decorated the function turns into a :class:`Command` instance
+    that can be invoked as a command line utility or be attached to a
+    command :class:`Group`.
+
+    :param name: the name of the command.  This defaults to the function
+                 name with underscores replaced by dashes.
+    :param cls: the command class to instantiate.  This defaults to
+                :class:`Command`.
+
+    .. versionchanged:: 8.1
+        This decorator can be applied without parentheses.
+
+    .. versionchanged:: 8.1
+        The ``params`` argument can be used. Decorated params are
+        appended to the end of the list.
+    """
+
+    func: t.Optional[t.Callable[[_AnyCallable], t.Any]] = None
+
+    if callable(name):
+        func = name
+        name = None
+        assert cls is None, "Use 'command(cls=cls)(callable)' to specify a class."
+        assert not attrs, "Use 'command(**kwargs)(callable)' to provide arguments."
+
+    if cls is None:
+        cls = t.cast(t.Type[CmdType], Command)
+
+    def decorator(f: _AnyCallable) -> CmdType:
+        if isinstance(f, Command):
+            raise TypeError("Attempted to convert a callback into a command twice.")
+
+        attr_params = attrs.pop("params", None)
+        params = attr_params if attr_params is not None else []
+
+        try:
+            decorator_params = f.__click_params__  # type: ignore
+        except AttributeError:
+            pass
+        else:
+            del f.__click_params__  # type: ignore
+            params.extend(reversed(decorator_params))
+
+        if attrs.get("help") is None:
+            attrs["help"] = f.__doc__
+
+        if t.TYPE_CHECKING:
+            assert cls is not None
+            assert not callable(name)
+
+        cmd = cls(
+            name=name or f.__name__.lower().replace("_", "-"),
+            callback=f,
+            params=params,
+            **attrs,
+        )
+        cmd.__doc__ = f.__doc__
+        return cmd
+
+    if func is not None:
+        return decorator(func)
+
+    return decorator
+
+
+GrpType = t.TypeVar("GrpType", bound=Group)
+
+
+# variant: no call, directly as decorator for a function.
+@t.overload
+def group(name: _AnyCallable) -> Group: ...
+
+
+# variant: with positional name and with positional or keyword cls argument:
+# @group(namearg, GroupCls, ...) or @group(namearg, cls=GroupCls, ...)
+@t.overload
+def group(
+    name: t.Optional[str],
+    cls: t.Type[GrpType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], GrpType]: ...
+
+
+# variant: name omitted, cls _must_ be a keyword argument, @group(cmd=GroupCls, ...)
+@t.overload
+def group(
+    name: None = None,
+    *,
+    cls: t.Type[GrpType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], GrpType]: ...
+
+
+# variant: with optional string name, no cls argument provided.
+@t.overload
+def group(
+    name: t.Optional[str] = ..., cls: None = None, **attrs: t.Any
+) -> t.Callable[[_AnyCallable], Group]: ...
+
+
+def group(
+    name: t.Union[str, _AnyCallable, None] = None,
+    cls: t.Optional[t.Type[GrpType]] = None,
+    **attrs: t.Any,
+) -> t.Union[Group, t.Callable[[_AnyCallable], t.Union[Group, GrpType]]]:
+    """Creates a new :class:`Group` with a function as callback.  This
+    works otherwise the same as :func:`command` just that the `cls`
+    parameter is set to :class:`Group`.
+
+    .. versionchanged:: 8.1
+        This decorator can be applied without parentheses.
+    """
+    if cls is None:
+        cls = t.cast(t.Type[GrpType], Group)
+
+    if callable(name):
+        return command(cls=cls, **attrs)(name)
+
+    return command(name, cls, **attrs)
+
+
+def _param_memo(f: t.Callable[..., t.Any], param: Parameter) -> None:
+    if isinstance(f, Command):
+        f.params.append(param)
+    else:
+        if not hasattr(f, "__click_params__"):
+            f.__click_params__ = []  # type: ignore
+
+        f.__click_params__.append(param)  # type: ignore
+
+
+def argument(
+    *param_decls: str, cls: t.Optional[t.Type[Argument]] = None, **attrs: t.Any
+) -> t.Callable[[FC], FC]:
+    """Attaches an argument to the command.  All positional arguments are
+    passed as parameter declarations to :class:`Argument`; all keyword
+    arguments are forwarded unchanged (except ``cls``).
+    This is equivalent to creating an :class:`Argument` instance manually
+    and attaching it to the :attr:`Command.params` list.
+
+    For the default argument class, refer to :class:`Argument` and
+    :class:`Parameter` for descriptions of parameters.
+
+    :param cls: the argument class to instantiate.  This defaults to
+                :class:`Argument`.
+    :param param_decls: Passed as positional arguments to the constructor of
+        ``cls``.
+    :param attrs: Passed as keyword arguments to the constructor of ``cls``.
+    """
+    if cls is None:
+        cls = Argument
+
+    def decorator(f: FC) -> FC:
+        _param_memo(f, cls(param_decls, **attrs))
+        return f
+
+    return decorator
+
+
+def option(
+    *param_decls: str, cls: t.Optional[t.Type[Option]] = None, **attrs: t.Any
+) -> t.Callable[[FC], FC]:
+    """Attaches an option to the command.  All positional arguments are
+    passed as parameter declarations to :class:`Option`; all keyword
+    arguments are forwarded unchanged (except ``cls``).
+    This is equivalent to creating an :class:`Option` instance manually
+    and attaching it to the :attr:`Command.params` list.
+
+    For the default option class, refer to :class:`Option` and
+    :class:`Parameter` for descriptions of parameters.
+
+    :param cls: the option class to instantiate.  This defaults to
+                :class:`Option`.
+    :param param_decls: Passed as positional arguments to the constructor of
+        ``cls``.
+    :param attrs: Passed as keyword arguments to the constructor of ``cls``.
+    """
+    if cls is None:
+        cls = Option
+
+    def decorator(f: FC) -> FC:
+        _param_memo(f, cls(param_decls, **attrs))
+        return f
+
+    return decorator
+
+
+def confirmation_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Add a ``--yes`` option which shows a prompt before continuing if
+    not passed. If the prompt is declined, the program will exit.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--yes"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value:
+            ctx.abort()
+
+    if not param_decls:
+        param_decls = ("--yes",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("callback", callback)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("prompt", "Do you want to continue?")
+    kwargs.setdefault("help", "Confirm the action without prompting.")
+    return option(*param_decls, **kwargs)
+
+
+def password_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Add a ``--password`` option which prompts for a password, hiding
+    input and asking to enter the value again for confirmation.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--password"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+    if not param_decls:
+        param_decls = ("--password",)
+
+    kwargs.setdefault("prompt", True)
+    kwargs.setdefault("confirmation_prompt", True)
+    kwargs.setdefault("hide_input", True)
+    return option(*param_decls, **kwargs)
+
+
+def version_option(
+    version: t.Optional[str] = None,
+    *param_decls: str,
+    package_name: t.Optional[str] = None,
+    prog_name: t.Optional[str] = None,
+    message: t.Optional[str] = None,
+    **kwargs: t.Any,
+) -> t.Callable[[FC], FC]:
+    """Add a ``--version`` option which immediately prints the version
+    number and exits the program.
+
+    If ``version`` is not provided, Click will try to detect it using
+    :func:`importlib.metadata.version` to get the version for the
+    ``package_name``. On Python < 3.8, the ``importlib_metadata``
+    backport must be installed.
+
+    If ``package_name`` is not provided, Click will try to detect it by
+    inspecting the stack frames. This will be used to detect the
+    version, so it must match the name of the installed package.
+
+    :param version: The version number to show. If not provided, Click
+        will try to detect it.
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--version"``.
+    :param package_name: The package name to detect the version from. If
+        not provided, Click will try to detect it.
+    :param prog_name: The name of the CLI to show in the message. If not
+        provided, it will be detected from the command.
+    :param message: The message to show. The values ``%(prog)s``,
+        ``%(package)s``, and ``%(version)s`` are available. Defaults to
+        ``"%(prog)s, version %(version)s"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    :raise RuntimeError: ``version`` could not be detected.
+
+    .. versionchanged:: 8.0
+        Add the ``package_name`` parameter, and the ``%(package)s``
+        value for messages.
+
+    .. versionchanged:: 8.0
+        Use :mod:`importlib.metadata` instead of ``pkg_resources``. The
+        version is detected based on the package name, not the entry
+        point name. The Python package name must match the installed
+        package name, or be passed with ``package_name=``.
+    """
+    if message is None:
+        message = _("%(prog)s, version %(version)s")
+
+    if version is None and package_name is None:
+        frame = inspect.currentframe()
+        f_back = frame.f_back if frame is not None else None
+        f_globals = f_back.f_globals if f_back is not None else None
+        # break reference cycle
+        # https://docs.python.org/3/library/inspect.html#the-interpreter-stack
+        del frame
+
+        if f_globals is not None:
+            package_name = f_globals.get("__name__")
+
+            if package_name == "__main__":
+                package_name = f_globals.get("__package__")
+
+            if package_name:
+                package_name = package_name.partition(".")[0]
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value or ctx.resilient_parsing:
+            return
+
+        nonlocal prog_name
+        nonlocal version
+
+        if prog_name is None:
+            prog_name = ctx.find_root().info_name
+
+        if version is None and package_name is not None:
+            metadata: t.Optional[types.ModuleType]
+
+            try:
+                from importlib import metadata
+            except ImportError:
+                # Python < 3.8
+                import importlib_metadata as metadata  # type: ignore
+
+            try:
+                version = metadata.version(package_name)  # type: ignore
+            except metadata.PackageNotFoundError:  # type: ignore
+                raise RuntimeError(
+                    f"{package_name!r} is not installed. Try passing"
+                    " 'package_name' instead."
+                ) from None
+
+        if version is None:
+            raise RuntimeError(
+                f"Could not determine the version for {package_name!r} automatically."
+            )
+
+        echo(
+            message % {"prog": prog_name, "package": package_name, "version": version},
+            color=ctx.color,
+        )
+        ctx.exit()
+
+    if not param_decls:
+        param_decls = ("--version",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("is_eager", True)
+    kwargs.setdefault("help", _("Show the version and exit."))
+    kwargs["callback"] = callback
+    return option(*param_decls, **kwargs)
+
+
+class HelpOption(Option):
+    """Pre-configured ``--help`` option which immediately prints the help page
+    and exits the program.
+    """
+
+    def __init__(
+        self,
+        param_decls: t.Optional[t.Sequence[str]] = None,
+        **kwargs: t.Any,
+    ) -> None:
+        if not param_decls:
+            param_decls = ("--help",)
+
+        kwargs.setdefault("is_flag", True)
+        kwargs.setdefault("expose_value", False)
+        kwargs.setdefault("is_eager", True)
+        kwargs.setdefault("help", _("Show this message and exit."))
+        kwargs.setdefault("callback", self.show_help)
+
+        super().__init__(param_decls, **kwargs)
+
+    @staticmethod
+    def show_help(ctx: Context, param: Parameter, value: bool) -> None:
+        """Callback that print the help page on ``<stdout>`` and exits."""
+        if value and not ctx.resilient_parsing:
+            echo(ctx.get_help(), color=ctx.color)
+            ctx.exit()
+
+
+def help_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Decorator for the pre-configured ``--help`` option defined above.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--help"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+    kwargs.setdefault("cls", HelpOption)
+    return option(*param_decls, **kwargs)
@@ -0,0 +1,296 @@
+import typing as t
+from gettext import gettext as _
+from gettext import ngettext
+
+from ._compat import get_text_stderr
+from .globals import resolve_color_default
+from .utils import echo
+from .utils import format_filename
+
+if t.TYPE_CHECKING:
+    from .core import Command
+    from .core import Context
+    from .core import Parameter
+
+
+def _join_param_hints(
+    param_hint: t.Optional[t.Union[t.Sequence[str], str]],
+) -> t.Optional[str]:
+    if param_hint is not None and not isinstance(param_hint, str):
+        return " / ".join(repr(x) for x in param_hint)
+
+    return param_hint
+
+
+class ClickException(Exception):
+    """An exception that Click can handle and show to the user."""
+
+    #: The exit code for this exception.
+    exit_code = 1
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        # The context will be removed by the time we print the message, so cache
+        # the color settings here to be used later on (in `show`)
+        self.show_color: t.Optional[bool] = resolve_color_default()
+        self.message = message
+
+    def format_message(self) -> str:
+        return self.message
+
+    def __str__(self) -> str:
+        return self.message
+
+    def show(self, file: t.Optional[t.IO[t.Any]] = None) -> None:
+        if file is None:
+            file = get_text_stderr()
+
+        echo(
+            _("Error: {message}").format(message=self.format_message()),
+            file=file,
+            color=self.show_color,
+        )
+
+
+class UsageError(ClickException):
+    """An internal exception that signals a usage error.  This typically
+    aborts any further handling.
+
+    :param message: the error message to display.
+    :param ctx: optionally the context that caused this error.  Click will
+                fill in the context automatically in some situations.
+    """
+
+    exit_code = 2
+
+    def __init__(self, message: str, ctx: t.Optional["Context"] = None) -> None:
+        super().__init__(message)
+        self.ctx = ctx
+        self.cmd: t.Optional[Command] = self.ctx.command if self.ctx else None
+
+    def show(self, file: t.Optional[t.IO[t.Any]] = None) -> None:
+        if file is None:
+            file = get_text_stderr()
+        color = None
+        hint = ""
+        if (
+            self.ctx is not None
+            and self.ctx.command.get_help_option(self.ctx) is not None
+        ):
+            hint = _("Try '{command} {option}' for help.").format(
+                command=self.ctx.command_path, option=self.ctx.help_option_names[0]
+            )
+            hint = f"{hint}\n"
+        if self.ctx is not None:
+            color = self.ctx.color
+            echo(f"{self.ctx.get_usage()}\n{hint}", file=file, color=color)
+        echo(
+            _("Error: {message}").format(message=self.format_message()),
+            file=file,
+            color=color,
+        )
+
+
+class BadParameter(UsageError):
+    """An exception that formats out a standardized error message for a
+    bad parameter.  This is useful when thrown from a callback or type as
+    Click will attach contextual information to it (for instance, which
+    parameter it is).
+
+    .. versionadded:: 2.0
+
+    :param param: the parameter object that caused this error.  This can
+                  be left out, and Click will attach this info itself
+                  if possible.
+    :param param_hint: a string that shows up as parameter name.  This
+                       can be used as alternative to `param` in cases
+                       where custom validation should happen.  If it is
+                       a string it's used as such, if it's a list then
+                       each item is quoted and separated.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        ctx: t.Optional["Context"] = None,
+        param: t.Optional["Parameter"] = None,
+        param_hint: t.Optional[str] = None,
+    ) -> None:
+        super().__init__(message, ctx)
+        self.param = param
+        self.param_hint = param_hint
+
+    def format_message(self) -> str:
+        if self.param_hint is not None:
+            param_hint = self.param_hint
+        elif self.param is not None:
+            param_hint = self.param.get_error_hint(self.ctx)  # type: ignore
+        else:
+            return _("Invalid value: {message}").format(message=self.message)
+
+        return _("Invalid value for {param_hint}: {message}").format(
+            param_hint=_join_param_hints(param_hint), message=self.message
+        )
+
+
+class MissingParameter(BadParameter):
+    """Raised if click required an option or argument but it was not
+    provided when invoking the script.
+
+    .. versionadded:: 4.0
+
+    :param param_type: a string that indicates the type of the parameter.
+                       The default is to inherit the parameter type from
+                       the given `param`.  Valid values are ``'parameter'``,
+                       ``'option'`` or ``'argument'``.
+    """
+
+    def __init__(
+        self,
+        message: t.Optional[str] = None,
+        ctx: t.Optional["Context"] = None,
+        param: t.Optional["Parameter"] = None,
+        param_hint: t.Optional[str] = None,
+        param_type: t.Optional[str] = None,
+    ) -> None:
+        super().__init__(message or "", ctx, param, param_hint)
+        self.param_type = param_type
+
+    def format_message(self) -> str:
+        if self.param_hint is not None:
+            param_hint: t.Optional[str] = self.param_hint
+        elif self.param is not None:
+            param_hint = self.param.get_error_hint(self.ctx)  # type: ignore
+        else:
+            param_hint = None
+
+        param_hint = _join_param_hints(param_hint)
+        param_hint = f" {param_hint}" if param_hint else ""
+
+        param_type = self.param_type
+        if param_type is None and self.param is not None:
+            param_type = self.param.param_type_name
+
+        msg = self.message
+        if self.param is not None:
+            msg_extra = self.param.type.get_missing_message(self.param)
+            if msg_extra:
+                if msg:
+                    msg += f". {msg_extra}"
+                else:
+                    msg = msg_extra
+
+        msg = f" {msg}" if msg else ""
+
+        # Translate param_type for known types.
+        if param_type == "argument":
+            missing = _("Missing argument")
+        elif param_type == "option":
+            missing = _("Missing option")
+        elif param_type == "parameter":
+            missing = _("Missing parameter")
+        else:
+            missing = _("Missing {param_type}").format(param_type=param_type)
+
+        return f"{missing}{param_hint}.{msg}"
+
+    def __str__(self) -> str:
+        if not self.message:
+            param_name = self.param.name if self.param else None
+            return _("Missing parameter: {param_name}").format(param_name=param_name)
+        else:
+            return self.message
+
+
+class NoSuchOption(UsageError):
+    """Raised if click attempted to handle an option that does not
+    exist.
+
+    .. versionadded:: 4.0
+    """
+
+    def __init__(
+        self,
+        option_name: str,
+        message: t.Optional[str] = None,
+        possibilities: t.Optional[t.Sequence[str]] = None,
+        ctx: t.Optional["Context"] = None,
+    ) -> None:
+        if message is None:
+            message = _("No such option: {name}").format(name=option_name)
+
+        super().__init__(message, ctx)
+        self.option_name = option_name
+        self.possibilities = possibilities
+
+    def format_message(self) -> str:
+        if not self.possibilities:
+            return self.message
+
+        possibility_str = ", ".join(sorted(self.possibilities))
+        suggest = ngettext(
+            "Did you mean {possibility}?",
+            "(Possible options: {possibilities})",
+            len(self.possibilities),
+        ).format(possibility=possibility_str, possibilities=possibility_str)
+        return f"{self.message} {suggest}"
+
+
+class BadOptionUsage(UsageError):
+    """Raised if an option is generally supplied but the use of the option
+    was incorrect.  This is for instance raised if the number of arguments
+    for an option is not correct.
+
+    .. versionadded:: 4.0
+
+    :param option_name: the name of the option being used incorrectly.
+    """
+
+    def __init__(
+        self, option_name: str, message: str, ctx: t.Optional["Context"] = None
+    ) -> None:
+        super().__init__(message, ctx)
+        self.option_name = option_name
+
+
+class BadArgumentUsage(UsageError):
+    """Raised if an argument is generally supplied but the use of the argument
+    was incorrect.  This is for instance raised if the number of values
+    for an argument is not correct.
+
+    .. versionadded:: 6.0
+    """
+
+
+class FileError(ClickException):
+    """Raised if a file cannot be opened."""
+
+    def __init__(self, filename: str, hint: t.Optional[str] = None) -> None:
+        if hint is None:
+            hint = _("unknown error")
+
+        super().__init__(hint)
+        self.ui_filename: str = format_filename(filename)
+        self.filename = filename
+
+    def format_message(self) -> str:
+        return _("Could not open file {filename!r}: {message}").format(
+            filename=self.ui_filename, message=self.message
+        )
+
+
+class Abort(RuntimeError):
+    """An internal signalling exception that signals Click to abort."""
+
+
+class Exit(RuntimeError):
+    """An exception that indicates that the application should exit with some
+    status code.
+
+    :param code: the status code to exit with.
+    """
+
+    __slots__ = ("exit_code",)
+
+    def __init__(self, code: int = 0) -> None:
+        self.exit_code: int = code
@@ -0,0 +1,301 @@
+import typing as t
+from contextlib import contextmanager
+from gettext import gettext as _
+
+from ._compat import term_len
+from .parser import split_opt
+
+# Can force a width.  This is used by the test system
+FORCED_WIDTH: t.Optional[int] = None
+
+
+def measure_table(rows: t.Iterable[t.Tuple[str, str]]) -> t.Tuple[int, ...]:
+    widths: t.Dict[int, int] = {}
+
+    for row in rows:
+        for idx, col in enumerate(row):
+            widths[idx] = max(widths.get(idx, 0), term_len(col))
+
+    return tuple(y for x, y in sorted(widths.items()))
+
+
+def iter_rows(
+    rows: t.Iterable[t.Tuple[str, str]], col_count: int
+) -> t.Iterator[t.Tuple[str, ...]]:
+    for row in rows:
+        yield row + ("",) * (col_count - len(row))
+
+
+def wrap_text(
+    text: str,
+    width: int = 78,
+    initial_indent: str = "",
+    subsequent_indent: str = "",
+    preserve_paragraphs: bool = False,
+) -> str:
+    """A helper function that intelligently wraps text.  By default, it
+    assumes that it operates on a single paragraph of text but if the
+    `preserve_paragraphs` parameter is provided it will intelligently
+    handle paragraphs (defined by two empty lines).
+
+    If paragraphs are handled, a paragraph can be prefixed with an empty
+    line containing the ``\\b`` character (``\\x08``) to indicate that
+    no rewrapping should happen in that block.
+
+    :param text: the text that should be rewrapped.
+    :param width: the maximum width for the text.
+    :param initial_indent: the initial indent that should be placed on the
+                           first line as a string.
+    :param subsequent_indent: the indent string that should be placed on
+                              each consecutive line.
+    :param preserve_paragraphs: if this flag is set then the wrapping will
+                                intelligently handle paragraphs.
+    """
+    from ._textwrap import TextWrapper
+
+    text = text.expandtabs()
+    wrapper = TextWrapper(
+        width,
+        initial_indent=initial_indent,
+        subsequent_indent=subsequent_indent,
+        replace_whitespace=False,
+    )
+    if not preserve_paragraphs:
+        return wrapper.fill(text)
+
+    p: t.List[t.Tuple[int, bool, str]] = []
+    buf: t.List[str] = []
+    indent = None
+
+    def _flush_par() -> None:
+        if not buf:
+            return
+        if buf[0].strip() == "\b":
+            p.append((indent or 0, True, "\n".join(buf[1:])))
+        else:
+            p.append((indent or 0, False, " ".join(buf)))
+        del buf[:]
+
+    for line in text.splitlines():
+        if not line:
+            _flush_par()
+            indent = None
+        else:
+            if indent is None:
+                orig_len = term_len(line)
+                line = line.lstrip()
+                indent = orig_len - term_len(line)
+            buf.append(line)
+    _flush_par()
+
+    rv = []
+    for indent, raw, text in p:
+        with wrapper.extra_indent(" " * indent):
+            if raw:
+                rv.append(wrapper.indent_only(text))
+            else:
+                rv.append(wrapper.fill(text))
+
+    return "\n\n".join(rv)
+
+
+class HelpFormatter:
+    """This class helps with formatting text-based help pages.  It's
+    usually just needed for very special internal cases, but it's also
+    exposed so that developers can write their own fancy outputs.
+
+    At present, it always writes into memory.
+
+    :param indent_increment: the additional increment for each level.
+    :param width: the width for the text.  This defaults to the terminal
+                  width clamped to a maximum of 78.
+    """
+
+    def __init__(
+        self,
+        indent_increment: int = 2,
+        width: t.Optional[int] = None,
+        max_width: t.Optional[int] = None,
+    ) -> None:
+        import shutil
+
+        self.indent_increment = indent_increment
+        if max_width is None:
+            max_width = 80
+        if width is None:
+            width = FORCED_WIDTH
+            if width is None:
+                width = max(min(shutil.get_terminal_size().columns, max_width) - 2, 50)
+        self.width = width
+        self.current_indent = 0
+        self.buffer: t.List[str] = []
+
+    def write(self, string: str) -> None:
+        """Writes a unicode string into the internal buffer."""
+        self.buffer.append(string)
+
+    def indent(self) -> None:
+        """Increases the indentation."""
+        self.current_indent += self.indent_increment
+
+    def dedent(self) -> None:
+        """Decreases the indentation."""
+        self.current_indent -= self.indent_increment
+
+    def write_usage(
+        self, prog: str, args: str = "", prefix: t.Optional[str] = None
+    ) -> None:
+        """Writes a usage line into the buffer.
+
+        :param prog: the program name.
+        :param args: whitespace separated list of arguments.
+        :param prefix: The prefix for the first line. Defaults to
+            ``"Usage: "``.
+        """
+        if prefix is None:
+            prefix = f"{_('Usage:')} "
+
+        usage_prefix = f"{prefix:>{self.current_indent}}{prog} "
+        text_width = self.width - self.current_indent
+
+        if text_width >= (term_len(usage_prefix) + 20):
+            # The arguments will fit to the right of the prefix.
+            indent = " " * term_len(usage_prefix)
+            self.write(
+                wrap_text(
+                    args,
+                    text_width,
+                    initial_indent=usage_prefix,
+                    subsequent_indent=indent,
+                )
+            )
+        else:
+            # The prefix is too long, put the arguments on the next line.
+            self.write(usage_prefix)
+            self.write("\n")
+            indent = " " * (max(self.current_indent, term_len(prefix)) + 4)
+            self.write(
+                wrap_text(
+                    args, text_width, initial_indent=indent, subsequent_indent=indent
+                )
+            )
+
+        self.write("\n")
+
+    def write_heading(self, heading: str) -> None:
+        """Writes a heading into the buffer."""
+        self.write(f"{'':>{self.current_indent}}{heading}:\n")
+
+    def write_paragraph(self) -> None:
+        """Writes a paragraph into the buffer."""
+        if self.buffer:
+            self.write("\n")
+
+    def write_text(self, text: str) -> None:
+        """Writes re-indented text into the buffer.  This rewraps and
+        preserves paragraphs.
+        """
+        indent = " " * self.current_indent
+        self.write(
+            wrap_text(
+                text,
+                self.width,
+                initial_indent=indent,
+                subsequent_indent=indent,
+                preserve_paragraphs=True,
+            )
+        )
+        self.write("\n")
+
+    def write_dl(
+        self,
+        rows: t.Sequence[t.Tuple[str, str]],
+        col_max: int = 30,
+        col_spacing: int = 2,
+    ) -> None:
+        """Writes a definition list into the buffer.  This is how options
+        and commands are usually formatted.
+
+        :param rows: a list of two item tuples for the terms and values.
+        :param col_max: the maximum width of the first column.
+        :param col_spacing: the number of spaces between the first and
+                            second column.
+        """
+        rows = list(rows)
+        widths = measure_table(rows)
+        if len(widths) != 2:
+            raise TypeError("Expected two columns for definition list")
+
+        first_col = min(widths[0], col_max) + col_spacing
+
+        for first, second in iter_rows(rows, len(widths)):
+            self.write(f"{'':>{self.current_indent}}{first}")
+            if not second:
+                self.write("\n")
+                continue
+            if term_len(first) <= first_col - col_spacing:
+                self.write(" " * (first_col - term_len(first)))
+            else:
+                self.write("\n")
+                self.write(" " * (first_col + self.current_indent))
+
+            text_width = max(self.width - first_col - 2, 10)
+            wrapped_text = wrap_text(second, text_width, preserve_paragraphs=True)
+            lines = wrapped_text.splitlines()
+
+            if lines:
+                self.write(f"{lines[0]}\n")
+
+                for line in lines[1:]:
+                    self.write(f"{'':>{first_col + self.current_indent}}{line}\n")
+            else:
+                self.write("\n")
+
+    @contextmanager
+    def section(self, name: str) -> t.Iterator[None]:
+        """Helpful context manager that writes a paragraph, a heading,
+        and the indents.
+
+        :param name: the section name that is written as heading.
+        """
+        self.write_paragraph()
+        self.write_heading(name)
+        self.indent()
+        try:
+            yield
+        finally:
+            self.dedent()
+
+    @contextmanager
+    def indentation(self) -> t.Iterator[None]:
+        """A context manager that increases the indentation."""
+        self.indent()
+        try:
+            yield
+        finally:
+            self.dedent()
+
+    def getvalue(self) -> str:
+        """Returns the buffer contents."""
+        return "".join(self.buffer)
+
+
+def join_options(options: t.Sequence[str]) -> t.Tuple[str, bool]:
+    """Given a list of option strings this joins them in the most appropriate
+    way and returns them in the form ``(formatted_string,
+    any_prefix_is_slash)`` where the second item in the tuple is a flag that
+    indicates if any of the option prefixes was a slash.
+    """
+    rv = []
+    any_prefix_is_slash = False
+
+    for opt in options:
+        prefix = split_opt(opt)[0]
+
+        if prefix == "/":
+            any_prefix_is_slash = True
+
+        rv.append((len(prefix), opt))
+
+    rv.sort(key=lambda x: x[0])
+    return ", ".join(x[1] for x in rv), any_prefix_is_slash
@@ -0,0 +1,67 @@
+import typing as t
+from threading import local
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    from .core import Context
+
+_local = local()
+
+
+@t.overload
+def get_current_context(silent: "te.Literal[False]" = False) -> "Context": ...
+
+
+@t.overload
+def get_current_context(silent: bool = ...) -> t.Optional["Context"]: ...
+
+
+def get_current_context(silent: bool = False) -> t.Optional["Context"]:
+    """Returns the current click context.  This can be used as a way to
+    access the current context object from anywhere.  This is a more implicit
+    alternative to the :func:`pass_context` decorator.  This function is
+    primarily useful for helpers such as :func:`echo` which might be
+    interested in changing its behavior based on the current context.
+
+    To push the current context, :meth:`Context.scope` can be used.
+
+    .. versionadded:: 5.0
+
+    :param silent: if set to `True` the return value is `None` if no context
+                   is available.  The default behavior is to raise a
+                   :exc:`RuntimeError`.
+    """
+    try:
+        return t.cast("Context", _local.stack[-1])
+    except (AttributeError, IndexError) as e:
+        if not silent:
+            raise RuntimeError("There is no active click context.") from e
+
+    return None
+
+
+def push_context(ctx: "Context") -> None:
+    """Pushes a new context to the current stack."""
+    _local.__dict__.setdefault("stack", []).append(ctx)
+
+
+def pop_context() -> None:
+    """Removes the top level from the stack."""
+    _local.stack.pop()
+
+
+def resolve_color_default(color: t.Optional[bool] = None) -> t.Optional[bool]:
+    """Internal helper to get the default value of the color flag.  If a
+    value is passed it's returned unchanged, otherwise it's looked up from
+    the current context.
+    """
+    if color is not None:
+        return color
+
+    ctx = get_current_context(silent=True)
+
+    if ctx is not None:
+        return ctx.color
+
+    return None
@@ -0,0 +1,531 @@
+"""
+This module started out as largely a copy paste from the stdlib's
+optparse module with the features removed that we do not need from
+optparse because we implement them in Click on a higher level (for
+instance type handling, help formatting and a lot more).
+
+The plan is to remove more and more from here over time.
+
+The reason this is a different module and not optparse from the stdlib
+is that there are differences in 2.x and 3.x about the error messages
+generated and optparse in the stdlib uses gettext for no good reason
+and might cause us issues.
+
+Click uses parts of optparse written by Gregory P. Ward and maintained
+by the Python Software Foundation. This is limited to code in parser.py.
+
+Copyright 2001-2006 Gregory P. Ward. All rights reserved.
+Copyright 2002-2006 Python Software Foundation. All rights reserved.
+"""
+
+# This code uses parts of optparse written by Gregory P. Ward and
+# maintained by the Python Software Foundation.
+# Copyright 2001-2006 Gregory P. Ward
+# Copyright 2002-2006 Python Software Foundation
+import typing as t
+from collections import deque
+from gettext import gettext as _
+from gettext import ngettext
+
+from .exceptions import BadArgumentUsage
+from .exceptions import BadOptionUsage
+from .exceptions import NoSuchOption
+from .exceptions import UsageError
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    from .core import Argument as CoreArgument
+    from .core import Context
+    from .core import Option as CoreOption
+    from .core import Parameter as CoreParameter
+
+V = t.TypeVar("V")
+
+# Sentinel value that indicates an option was passed as a flag without a
+# value but is not a flag option. Option.consume_value uses this to
+# prompt or use the flag_value.
+_flag_needs_value = object()
+
+
+def _unpack_args(
+    args: t.Sequence[str], nargs_spec: t.Sequence[int]
+) -> t.Tuple[t.Sequence[t.Union[str, t.Sequence[t.Optional[str]], None]], t.List[str]]:
+    """Given an iterable of arguments and an iterable of nargs specifications,
+    it returns a tuple with all the unpacked arguments at the first index
+    and all remaining arguments as the second.
+
+    The nargs specification is the number of arguments that should be consumed
+    or `-1` to indicate that this position should eat up all the remainders.
+
+    Missing items are filled with `None`.
+    """
+    args = deque(args)
+    nargs_spec = deque(nargs_spec)
+    rv: t.List[t.Union[str, t.Tuple[t.Optional[str], ...], None]] = []
+    spos: t.Optional[int] = None
+
+    def _fetch(c: "te.Deque[V]") -> t.Optional[V]:
+        try:
+            if spos is None:
+                return c.popleft()
+            else:
+                return c.pop()
+        except IndexError:
+            return None
+
+    while nargs_spec:
+        nargs = _fetch(nargs_spec)
+
+        if nargs is None:
+            continue
+
+        if nargs == 1:
+            rv.append(_fetch(args))
+        elif nargs > 1:
+            x = [_fetch(args) for _ in range(nargs)]
+
+            # If we're reversed, we're pulling in the arguments in reverse,
+            # so we need to turn them around.
+            if spos is not None:
+                x.reverse()
+
+            rv.append(tuple(x))
+        elif nargs < 0:
+            if spos is not None:
+                raise TypeError("Cannot have two nargs < 0")
+
+            spos = len(rv)
+            rv.append(None)
+
+    # spos is the position of the wildcard (star).  If it's not `None`,
+    # we fill it with the remainder.
+    if spos is not None:
+        rv[spos] = tuple(args)
+        args = []
+        rv[spos + 1 :] = reversed(rv[spos + 1 :])
+
+    return tuple(rv), list(args)
+
+
+def split_opt(opt: str) -> t.Tuple[str, str]:
+    first = opt[:1]
+    if first.isalnum():
+        return "", opt
+    if opt[1:2] == first:
+        return opt[:2], opt[2:]
+    return first, opt[1:]
+
+
+def normalize_opt(opt: str, ctx: t.Optional["Context"]) -> str:
+    if ctx is None or ctx.token_normalize_func is None:
+        return opt
+    prefix, opt = split_opt(opt)
+    return f"{prefix}{ctx.token_normalize_func(opt)}"
+
+
+def split_arg_string(string: str) -> t.List[str]:
+    """Split an argument string as with :func:`shlex.split`, but don't
+    fail if the string is incomplete. Ignores a missing closing quote or
+    incomplete escape sequence and uses the partial token as-is.
+
+    .. code-block:: python
+
+        split_arg_string("example 'my file")
+        ["example", "my file"]
+
+        split_arg_string("example my\\")
+        ["example", "my"]
+
+    :param string: String to split.
+    """
+    import shlex
+
+    lex = shlex.shlex(string, posix=True)
+    lex.whitespace_split = True
+    lex.commenters = ""
+    out = []
+
+    try:
+        for token in lex:
+            out.append(token)
+    except ValueError:
+        # Raised when end-of-string is reached in an invalid state. Use
+        # the partial token as-is. The quote or escape character is in
+        # lex.state, not lex.token.
+        out.append(lex.token)
+
+    return out
+
+
+class Option:
+    def __init__(
+        self,
+        obj: "CoreOption",
+        opts: t.Sequence[str],
+        dest: t.Optional[str],
+        action: t.Optional[str] = None,
+        nargs: int = 1,
+        const: t.Optional[t.Any] = None,
+    ):
+        self._short_opts = []
+        self._long_opts = []
+        self.prefixes: t.Set[str] = set()
+
+        for opt in opts:
+            prefix, value = split_opt(opt)
+            if not prefix:
+                raise ValueError(f"Invalid start character for option ({opt})")
+            self.prefixes.add(prefix[0])
+            if len(prefix) == 1 and len(value) == 1:
+                self._short_opts.append(opt)
+            else:
+                self._long_opts.append(opt)
+                self.prefixes.add(prefix)
+
+        if action is None:
+            action = "store"
+
+        self.dest = dest
+        self.action = action
+        self.nargs = nargs
+        self.const = const
+        self.obj = obj
+
+    @property
+    def takes_value(self) -> bool:
+        return self.action in ("store", "append")
+
+    def process(self, value: t.Any, state: "ParsingState") -> None:
+        if self.action == "store":
+            state.opts[self.dest] = value  # type: ignore
+        elif self.action == "store_const":
+            state.opts[self.dest] = self.const  # type: ignore
+        elif self.action == "append":
+            state.opts.setdefault(self.dest, []).append(value)  # type: ignore
+        elif self.action == "append_const":
+            state.opts.setdefault(self.dest, []).append(self.const)  # type: ignore
+        elif self.action == "count":
+            state.opts[self.dest] = state.opts.get(self.dest, 0) + 1  # type: ignore
+        else:
+            raise ValueError(f"unknown action '{self.action}'")
+        state.order.append(self.obj)
+
+
+class Argument:
+    def __init__(self, obj: "CoreArgument", dest: t.Optional[str], nargs: int = 1):
+        self.dest = dest
+        self.nargs = nargs
+        self.obj = obj
+
+    def process(
+        self,
+        value: t.Union[t.Optional[str], t.Sequence[t.Optional[str]]],
+        state: "ParsingState",
+    ) -> None:
+        if self.nargs > 1:
+            assert value is not None
+            holes = sum(1 for x in value if x is None)
+            if holes == len(value):
+                value = None
+            elif holes != 0:
+                raise BadArgumentUsage(
+                    _("Argument {name!r} takes {nargs} values.").format(
+                        name=self.dest, nargs=self.nargs
+                    )
+                )
+
+        if self.nargs == -1 and self.obj.envvar is not None and value == ():
+            # Replace empty tuple with None so that a value from the
+            # environment may be tried.
+            value = None
+
+        state.opts[self.dest] = value  # type: ignore
+        state.order.append(self.obj)
+
+
+class ParsingState:
+    def __init__(self, rargs: t.List[str]) -> None:
+        self.opts: t.Dict[str, t.Any] = {}
+        self.largs: t.List[str] = []
+        self.rargs = rargs
+        self.order: t.List[CoreParameter] = []
+
+
+class OptionParser:
+    """The option parser is an internal class that is ultimately used to
+    parse options and arguments.  It's modelled after optparse and brings
+    a similar but vastly simplified API.  It should generally not be used
+    directly as the high level Click classes wrap it for you.
+
+    It's not nearly as extensible as optparse or argparse as it does not
+    implement features that are implemented on a higher level (such as
+    types or defaults).
+
+    :param ctx: optionally the :class:`~click.Context` where this parser
+                should go with.
+    """
+
+    def __init__(self, ctx: t.Optional["Context"] = None) -> None:
+        #: The :class:`~click.Context` for this parser.  This might be
+        #: `None` for some advanced use cases.
+        self.ctx = ctx
+        #: This controls how the parser deals with interspersed arguments.
+        #: If this is set to `False`, the parser will stop on the first
+        #: non-option.  Click uses this to implement nested subcommands
+        #: safely.
+        self.allow_interspersed_args: bool = True
+        #: This tells the parser how to deal with unknown options.  By
+        #: default it will error out (which is sensible), but there is a
+        #: second mode where it will ignore it and continue processing
+        #: after shifting all the unknown options into the resulting args.
+        self.ignore_unknown_options: bool = False
+
+        if ctx is not None:
+            self.allow_interspersed_args = ctx.allow_interspersed_args
+            self.ignore_unknown_options = ctx.ignore_unknown_options
+
+        self._short_opt: t.Dict[str, Option] = {}
+        self._long_opt: t.Dict[str, Option] = {}
+        self._opt_prefixes = {"-", "--"}
+        self._args: t.List[Argument] = []
+
+    def add_option(
+        self,
+        obj: "CoreOption",
+        opts: t.Sequence[str],
+        dest: t.Optional[str],
+        action: t.Optional[str] = None,
+        nargs: int = 1,
+        const: t.Optional[t.Any] = None,
+    ) -> None:
+        """Adds a new option named `dest` to the parser.  The destination
+        is not inferred (unlike with optparse) and needs to be explicitly
+        provided.  Action can be any of ``store``, ``store_const``,
+        ``append``, ``append_const`` or ``count``.
+
+        The `obj` can be used to identify the option in the order list
+        that is returned from the parser.
+        """
+        opts = [normalize_opt(opt, self.ctx) for opt in opts]
+        option = Option(obj, opts, dest, action=action, nargs=nargs, const=const)
+        self._opt_prefixes.update(option.prefixes)
+        for opt in option._short_opts:
+            self._short_opt[opt] = option
+        for opt in option._long_opts:
+            self._long_opt[opt] = option
+
+    def add_argument(
+        self, obj: "CoreArgument", dest: t.Optional[str], nargs: int = 1
+    ) -> None:
+        """Adds a positional argument named `dest` to the parser.
+
+        The `obj` can be used to identify the option in the order list
+        that is returned from the parser.
+        """
+        self._args.append(Argument(obj, dest=dest, nargs=nargs))
+
+    def parse_args(
+        self, args: t.List[str]
+    ) -> t.Tuple[t.Dict[str, t.Any], t.List[str], t.List["CoreParameter"]]:
+        """Parses positional arguments and returns ``(values, args, order)``
+        for the parsed options and arguments as well as the leftover
+        arguments if there are any.  The order is a list of objects as they
+        appear on the command line.  If arguments appear multiple times they
+        will be memorized multiple times as well.
+        """
+        state = ParsingState(args)
+        try:
+            self._process_args_for_options(state)
+            self._process_args_for_args(state)
+        except UsageError:
+            if self.ctx is None or not self.ctx.resilient_parsing:
+                raise
+        return state.opts, state.largs, state.order
+
+    def _process_args_for_args(self, state: ParsingState) -> None:
+        pargs, args = _unpack_args(
+            state.largs + state.rargs, [x.nargs for x in self._args]
+        )
+
+        for idx, arg in enumerate(self._args):
+            arg.process(pargs[idx], state)
+
+        state.largs = args
+        state.rargs = []
+
+    def _process_args_for_options(self, state: ParsingState) -> None:
+        while state.rargs:
+            arg = state.rargs.pop(0)
+            arglen = len(arg)
+            # Double dashes always handled explicitly regardless of what
+            # prefixes are valid.
+            if arg == "--":
+                return
+            elif arg[:1] in self._opt_prefixes and arglen > 1:
+                self._process_opts(arg, state)
+            elif self.allow_interspersed_args:
+                state.largs.append(arg)
+            else:
+                state.rargs.insert(0, arg)
+                return
+
+        # Say this is the original argument list:
+        # [arg0, arg1, ..., arg(i-1), arg(i), arg(i+1), ..., arg(N-1)]
+        #                            ^
+        # (we are about to process arg(i)).
+        #
+        # Then rargs is [arg(i), ..., arg(N-1)] and largs is a *subset* of
+        # [arg0, ..., arg(i-1)] (any options and their arguments will have
+        # been removed from largs).
+        #
+        # The while loop will usually consume 1 or more arguments per pass.
+        # If it consumes 1 (eg. arg is an option that takes no arguments),
+        # then after _process_arg() is done the situation is:
+        #
+        #   largs = subset of [arg0, ..., arg(i)]
+        #   rargs = [arg(i+1), ..., arg(N-1)]
+        #
+        # If allow_interspersed_args is false, largs will always be
+        # *empty* -- still a subset of [arg0, ..., arg(i-1)], but
+        # not a very interesting subset!
+
+    def _match_long_opt(
+        self, opt: str, explicit_value: t.Optional[str], state: ParsingState
+    ) -> None:
+        if opt not in self._long_opt:
+            from difflib import get_close_matches
+
+            possibilities = get_close_matches(opt, self._long_opt)
+            raise NoSuchOption(opt, possibilities=possibilities, ctx=self.ctx)
+
+        option = self._long_opt[opt]
+        if option.takes_value:
+            # At this point it's safe to modify rargs by injecting the
+            # explicit value, because no exception is raised in this
+            # branch.  This means that the inserted value will be fully
+            # consumed.
+            if explicit_value is not None:
+                state.rargs.insert(0, explicit_value)
+
+            value = self._get_value_from_state(opt, option, state)
+
+        elif explicit_value is not None:
+            raise BadOptionUsage(
+                opt, _("Option {name!r} does not take a value.").format(name=opt)
+            )
+
+        else:
+            value = None
+
+        option.process(value, state)
+
+    def _match_short_opt(self, arg: str, state: ParsingState) -> None:
+        stop = False
+        i = 1
+        prefix = arg[0]
+        unknown_options = []
+
+        for ch in arg[1:]:
+            opt = normalize_opt(f"{prefix}{ch}", self.ctx)
+            option = self._short_opt.get(opt)
+            i += 1
+
+            if not option:
+                if self.ignore_unknown_options:
+                    unknown_options.append(ch)
+                    continue
+                raise NoSuchOption(opt, ctx=self.ctx)
+            if option.takes_value:
+                # Any characters left in arg?  Pretend they're the
+                # next arg, and stop consuming characters of arg.
+                if i < len(arg):
+                    state.rargs.insert(0, arg[i:])
+                    stop = True
+
+                value = self._get_value_from_state(opt, option, state)
+
+            else:
+                value = None
+
+            option.process(value, state)
+
+            if stop:
+                break
+
+        # If we got any unknown options we recombine the string of the
+        # remaining options and re-attach the prefix, then report that
+        # to the state as new larg.  This way there is basic combinatorics
+        # that can be achieved while still ignoring unknown arguments.
+        if self.ignore_unknown_options and unknown_options:
+            state.largs.append(f"{prefix}{''.join(unknown_options)}")
+
+    def _get_value_from_state(
+        self, option_name: str, option: Option, state: ParsingState
+    ) -> t.Any:
+        nargs = option.nargs
+
+        if len(state.rargs) < nargs:
+            if option.obj._flag_needs_value:
+                # Option allows omitting the value.
+                value = _flag_needs_value
+            else:
+                raise BadOptionUsage(
+                    option_name,
+                    ngettext(
+                        "Option {name!r} requires an argument.",
+                        "Option {name!r} requires {nargs} arguments.",
+                        nargs,
+                    ).format(name=option_name, nargs=nargs),
+                )
+        elif nargs == 1:
+            next_rarg = state.rargs[0]
+
+            if (
+                option.obj._flag_needs_value
+                and isinstance(next_rarg, str)
+                and next_rarg[:1] in self._opt_prefixes
+                and len(next_rarg) > 1
+            ):
+                # The next arg looks like the start of an option, don't
+                # use it as the value if omitting the value is allowed.
+                value = _flag_needs_value
+            else:
+                value = state.rargs.pop(0)
+        else:
+            value = tuple(state.rargs[:nargs])
+            del state.rargs[:nargs]
+
+        return value
+
+    def _process_opts(self, arg: str, state: ParsingState) -> None:
+        explicit_value = None
+        # Long option handling happens in two parts.  The first part is
+        # supporting explicitly attached values.  In any case, we will try
+        # to long match the option first.
+        if "=" in arg:
+            long_opt, explicit_value = arg.split("=", 1)
+        else:
+            long_opt = arg
+        norm_long_opt = normalize_opt(long_opt, self.ctx)
+
+        # At this point we will match the (assumed) long option through
+        # the long option matching code.  Note that this allows options
+        # like "-foo" to be matched as long options.
+        try:
+            self._match_long_opt(norm_long_opt, explicit_value, state)
+        except NoSuchOption:
+            # At this point the long option matching failed, and we need
+            # to try with short options.  However there is a special rule
+            # which says, that if we have a two character options prefix
+            # (applies to "--foo" for instance), we do not dispatch to the
+            # short option code and will instead raise the no option
+            # error.
+            if arg[:2] not in self._opt_prefixes:
+                self._match_short_opt(arg, state)
+                return
+
+            if not self.ignore_unknown_options:
+                raise
+
+            state.largs.append(arg)
@@ -0,0 +1,603 @@
+import os
+import re
+import typing as t
+from gettext import gettext as _
+
+from .core import Argument
+from .core import BaseCommand
+from .core import Context
+from .core import MultiCommand
+from .core import Option
+from .core import Parameter
+from .core import ParameterSource
+from .parser import split_arg_string
+from .utils import echo
+
+
+def shell_complete(
+    cli: BaseCommand,
+    ctx_args: t.MutableMapping[str, t.Any],
+    prog_name: str,
+    complete_var: str,
+    instruction: str,
+) -> int:
+    """Perform shell completion for the given CLI program.
+
+    :param cli: Command being called.
+    :param ctx_args: Extra arguments to pass to
+        ``cli.make_context``.
+    :param prog_name: Name of the executable in the shell.
+    :param complete_var: Name of the environment variable that holds
+        the completion instruction.
+    :param instruction: Value of ``complete_var`` with the completion
+        instruction and shell, in the form ``instruction_shell``.
+    :return: Status code to exit with.
+    """
+    shell, _, instruction = instruction.partition("_")
+    comp_cls = get_completion_class(shell)
+
+    if comp_cls is None:
+        return 1
+
+    comp = comp_cls(cli, ctx_args, prog_name, complete_var)
+
+    if instruction == "source":
+        echo(comp.source())
+        return 0
+
+    if instruction == "complete":
+        echo(comp.complete())
+        return 0
+
+    return 1
+
+
+class CompletionItem:
+    """Represents a completion value and metadata about the value. The
+    default metadata is ``type`` to indicate special shell handling,
+    and ``help`` if a shell supports showing a help string next to the
+    value.
+
+    Arbitrary parameters can be passed when creating the object, and
+    accessed using ``item.attr``. If an attribute wasn't passed,
+    accessing it returns ``None``.
+
+    :param value: The completion suggestion.
+    :param type: Tells the shell script to provide special completion
+        support for the type. Click uses ``"dir"`` and ``"file"``.
+    :param help: String shown next to the value if supported.
+    :param kwargs: Arbitrary metadata. The built-in implementations
+        don't use this, but custom type completions paired with custom
+        shell support could use it.
+    """
+
+    __slots__ = ("value", "type", "help", "_info")
+
+    def __init__(
+        self,
+        value: t.Any,
+        type: str = "plain",
+        help: t.Optional[str] = None,
+        **kwargs: t.Any,
+    ) -> None:
+        self.value: t.Any = value
+        self.type: str = type
+        self.help: t.Optional[str] = help
+        self._info = kwargs
+
+    def __getattr__(self, name: str) -> t.Any:
+        return self._info.get(name)
+
+
+# Only Bash >= 4.4 has the nosort option.
+_SOURCE_BASH = """\
+%(complete_func)s() {
+    local IFS=$'\\n'
+    local response
+
+    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD \
+%(complete_var)s=bash_complete $1)
+
+    for completion in $response; do
+        IFS=',' read type value <<< "$completion"
+
+        if [[ $type == 'dir' ]]; then
+            COMPREPLY=()
+            compopt -o dirnames
+        elif [[ $type == 'file' ]]; then
+            COMPREPLY=()
+            compopt -o default
+        elif [[ $type == 'plain' ]]; then
+            COMPREPLY+=($value)
+        fi
+    done
+
+    return 0
+}
+
+%(complete_func)s_setup() {
+    complete -o nosort -F %(complete_func)s %(prog_name)s
+}
+
+%(complete_func)s_setup;
+"""
+
+_SOURCE_ZSH = """\
+#compdef %(prog_name)s
+
+%(complete_func)s() {
+    local -a completions
+    local -a completions_with_descriptions
+    local -a response
+    (( ! $+commands[%(prog_name)s] )) && return 1
+
+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) \
+%(complete_var)s=zsh_complete %(prog_name)s)}")
+
+    for type key descr in ${response}; do
+        if [[ "$type" == "plain" ]]; then
+            if [[ "$descr" == "_" ]]; then
+                completions+=("$key")
+            else
+                completions_with_descriptions+=("$key":"$descr")
+            fi
+        elif [[ "$type" == "dir" ]]; then
+            _path_files -/
+        elif [[ "$type" == "file" ]]; then
+            _path_files -f
+        fi
+    done
+
+    if [ -n "$completions_with_descriptions" ]; then
+        _describe -V unsorted completions_with_descriptions -U
+    fi
+
+    if [ -n "$completions" ]; then
+        compadd -U -V unsorted -a completions
+    fi
+}
+
+if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
+    # autoload from fpath, call function directly
+    %(complete_func)s "$@"
+else
+    # eval/source/. command, register function for later
+    compdef %(complete_func)s %(prog_name)s
+fi
+"""
+
+_SOURCE_FISH = """\
+function %(complete_func)s;
+    set -l response (env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) \
+COMP_CWORD=(commandline -t) %(prog_name)s);
+
+    for completion in $response;
+        set -l metadata (string split "," $completion);
+
+        if test $metadata[1] = "dir";
+            __fish_complete_directories $metadata[2];
+        else if test $metadata[1] = "file";
+            __fish_complete_path $metadata[2];
+        else if test $metadata[1] = "plain";
+            echo $metadata[2];
+        end;
+    end;
+end;
+
+complete --no-files --command %(prog_name)s --arguments \
+"(%(complete_func)s)";
+"""
+
+
+class ShellComplete:
+    """Base class for providing shell completion support. A subclass for
+    a given shell will override attributes and methods to implement the
+    completion instructions (``source`` and ``complete``).
+
+    :param cli: Command being called.
+    :param prog_name: Name of the executable in the shell.
+    :param complete_var: Name of the environment variable that holds
+        the completion instruction.
+
+    .. versionadded:: 8.0
+    """
+
+    name: t.ClassVar[str]
+    """Name to register the shell as with :func:`add_completion_class`.
+    This is used in completion instructions (``{name}_source`` and
+    ``{name}_complete``).
+    """
+
+    source_template: t.ClassVar[str]
+    """Completion script template formatted by :meth:`source`. This must
+    be provided by subclasses.
+    """
+
+    def __init__(
+        self,
+        cli: BaseCommand,
+        ctx_args: t.MutableMapping[str, t.Any],
+        prog_name: str,
+        complete_var: str,
+    ) -> None:
+        self.cli = cli
+        self.ctx_args = ctx_args
+        self.prog_name = prog_name
+        self.complete_var = complete_var
+
+    @property
+    def func_name(self) -> str:
+        """The name of the shell function defined by the completion
+        script.
+        """
+        safe_name = re.sub(r"\W*", "", self.prog_name.replace("-", "_"), flags=re.ASCII)
+        return f"_{safe_name}_completion"
+
+    def source_vars(self) -> t.Dict[str, t.Any]:
+        """Vars for formatting :attr:`source_template`.
+
+        By default this provides ``complete_func``, ``complete_var``,
+        and ``prog_name``.
+        """
+        return {
+            "complete_func": self.func_name,
+            "complete_var": self.complete_var,
+            "prog_name": self.prog_name,
+        }
+
+    def source(self) -> str:
+        """Produce the shell script that defines the completion
+        function. By default this ``%``-style formats
+        :attr:`source_template` with the dict returned by
+        :meth:`source_vars`.
+        """
+        return self.source_template % self.source_vars()
+
+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
+        """Use the env vars defined by the shell script to return a
+        tuple of ``args, incomplete``. This must be implemented by
+        subclasses.
+        """
+        raise NotImplementedError
+
+    def get_completions(
+        self, args: t.List[str], incomplete: str
+    ) -> t.List[CompletionItem]:
+        """Determine the context and last complete command or parameter
+        from the complete args. Call that object's ``shell_complete``
+        method to get the completions for the incomplete value.
+
+        :param args: List of complete args before the incomplete value.
+        :param incomplete: Value being completed. May be empty.
+        """
+        ctx = _resolve_context(self.cli, self.ctx_args, self.prog_name, args)
+        obj, incomplete = _resolve_incomplete(ctx, args, incomplete)
+        return obj.shell_complete(ctx, incomplete)
+
+    def format_completion(self, item: CompletionItem) -> str:
+        """Format a completion item into the form recognized by the
+        shell script. This must be implemented by subclasses.
+
+        :param item: Completion item to format.
+        """
+        raise NotImplementedError
+
+    def complete(self) -> str:
+        """Produce the completion data to send back to the shell.
+
+        By default this calls :meth:`get_completion_args`, gets the
+        completions, then calls :meth:`format_completion` for each
+        completion.
+        """
+        args, incomplete = self.get_completion_args()
+        completions = self.get_completions(args, incomplete)
+        out = [self.format_completion(item) for item in completions]
+        return "\n".join(out)
+
+
+class BashComplete(ShellComplete):
+    """Shell completion for Bash."""
+
+    name = "bash"
+    source_template = _SOURCE_BASH
+
+    @staticmethod
+    def _check_version() -> None:
+        import shutil
+        import subprocess
+
+        bash_exe = shutil.which("bash")
+
+        if bash_exe is None:
+            match = None
+        else:
+            output = subprocess.run(
+                [bash_exe, "--norc", "-c", 'echo "${BASH_VERSION}"'],
+                stdout=subprocess.PIPE,
+            )
+            match = re.search(r"^(\d+)\.(\d+)\.\d+", output.stdout.decode())
+
+        if match is not None:
+            major, minor = match.groups()
+
+            if major < "4" or major == "4" and minor < "4":
+                echo(
+                    _(
+                        "Shell completion is not supported for Bash"
+                        " versions older than 4.4."
+                    ),
+                    err=True,
+                )
+        else:
+            echo(
+                _("Couldn't detect Bash version, shell completion is not supported."),
+                err=True,
+            )
+
+    def source(self) -> str:
+        self._check_version()
+        return super().source()
+
+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem) -> str:
+        return f"{item.type},{item.value}"
+
+
+class ZshComplete(ShellComplete):
+    """Shell completion for Zsh."""
+
+    name = "zsh"
+    source_template = _SOURCE_ZSH
+
+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem) -> str:
+        return f"{item.type}\n{item.value}\n{item.help if item.help else '_'}"
+
+
+class FishComplete(ShellComplete):
+    """Shell completion for Fish."""
+
+    name = "fish"
+    source_template = _SOURCE_FISH
+
+    def get_completion_args(self) -> t.Tuple[t.List[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        incomplete = os.environ["COMP_CWORD"]
+        args = cwords[1:]
+
+        # Fish stores the partial word in both COMP_WORDS and
+        # COMP_CWORD, remove it from complete args.
+        if incomplete and args and args[-1] == incomplete:
+            args.pop()
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem) -> str:
+        if item.help:
+            return f"{item.type},{item.value}\t{item.help}"
+
+        return f"{item.type},{item.value}"
+
+
+ShellCompleteType = t.TypeVar("ShellCompleteType", bound=t.Type[ShellComplete])
+
+
+_available_shells: t.Dict[str, t.Type[ShellComplete]] = {
+    "bash": BashComplete,
+    "fish": FishComplete,
+    "zsh": ZshComplete,
+}
+
+
+def add_completion_class(
+    cls: ShellCompleteType, name: t.Optional[str] = None
+) -> ShellCompleteType:
+    """Register a :class:`ShellComplete` subclass under the given name.
+    The name will be provided by the completion instruction environment
+    variable during completion.
+
+    :param cls: The completion class that will handle completion for the
+        shell.
+    :param name: Name to register the class under. Defaults to the
+        class's ``name`` attribute.
+    """
+    if name is None:
+        name = cls.name
+
+    _available_shells[name] = cls
+
+    return cls
+
+
+def get_completion_class(shell: str) -> t.Optional[t.Type[ShellComplete]]:
+    """Look up a registered :class:`ShellComplete` subclass by the name
+    provided by the completion instruction environment variable. If the
+    name isn't registered, returns ``None``.
+
+    :param shell: Name the class is registered under.
+    """
+    return _available_shells.get(shell)
+
+
+def _is_incomplete_argument(ctx: Context, param: Parameter) -> bool:
+    """Determine if the given parameter is an argument that can still
+    accept values.
+
+    :param ctx: Invocation context for the command represented by the
+        parsed complete args.
+    :param param: Argument object being checked.
+    """
+    if not isinstance(param, Argument):
+        return False
+
+    assert param.name is not None
+    # Will be None if expose_value is False.
+    value = ctx.params.get(param.name)
+    return (
+        param.nargs == -1
+        or ctx.get_parameter_source(param.name) is not ParameterSource.COMMANDLINE
+        or (
+            param.nargs > 1
+            and isinstance(value, (tuple, list))
+            and len(value) < param.nargs
+        )
+    )
+
+
+def _start_of_option(ctx: Context, value: str) -> bool:
+    """Check if the value looks like the start of an option."""
+    if not value:
+        return False
+
+    c = value[0]
+    return c in ctx._opt_prefixes
+
+
+def _is_incomplete_option(ctx: Context, args: t.List[str], param: Parameter) -> bool:
+    """Determine if the given parameter is an option that needs a value.
+
+    :param args: List of complete args before the incomplete value.
+    :param param: Option object being checked.
+    """
+    if not isinstance(param, Option):
+        return False
+
+    if param.is_flag or param.count:
+        return False
+
+    last_option = None
+
+    for index, arg in enumerate(reversed(args)):
+        if index + 1 > param.nargs:
+            break
+
+        if _start_of_option(ctx, arg):
+            last_option = arg
+
+    return last_option is not None and last_option in param.opts
+
+
+def _resolve_context(
+    cli: BaseCommand,
+    ctx_args: t.MutableMapping[str, t.Any],
+    prog_name: str,
+    args: t.List[str],
+) -> Context:
+    """Produce the context hierarchy starting with the command and
+    traversing the complete arguments. This only follows the commands,
+    it doesn't trigger input prompts or callbacks.
+
+    :param cli: Command being called.
+    :param prog_name: Name of the executable in the shell.
+    :param args: List of complete args before the incomplete value.
+    """
+    ctx_args["resilient_parsing"] = True
+    ctx = cli.make_context(prog_name, args.copy(), **ctx_args)
+    args = ctx.protected_args + ctx.args
+
+    while args:
+        command = ctx.command
+
+        if isinstance(command, MultiCommand):
+            if not command.chain:
+                name, cmd, args = command.resolve_command(ctx, args)
+
+                if cmd is None:
+                    return ctx
+
+                ctx = cmd.make_context(name, args, parent=ctx, resilient_parsing=True)
+                args = ctx.protected_args + ctx.args
+            else:
+                sub_ctx = ctx
+
+                while args:
+                    name, cmd, args = command.resolve_command(ctx, args)
+
+                    if cmd is None:
+                        return ctx
+
+                    sub_ctx = cmd.make_context(
+                        name,
+                        args,
+                        parent=ctx,
+                        allow_extra_args=True,
+                        allow_interspersed_args=False,
+                        resilient_parsing=True,
+                    )
+                    args = sub_ctx.args
+
+                ctx = sub_ctx
+                args = [*sub_ctx.protected_args, *sub_ctx.args]
+        else:
+            break
+
+    return ctx
+
+
+def _resolve_incomplete(
+    ctx: Context, args: t.List[str], incomplete: str
+) -> t.Tuple[t.Union[BaseCommand, Parameter], str]:
+    """Find the Click object that will handle the completion of the
+    incomplete value. Return the object and the incomplete value.
+
+    :param ctx: Invocation context for the command represented by
+        the parsed complete args.
+    :param args: List of complete args before the incomplete value.
+    :param incomplete: Value being completed. May be empty.
+    """
+    # Different shells treat an "=" between a long option name and
+    # value differently. Might keep the value joined, return the "="
+    # as a separate item, or return the split name and value. Always
+    # split and discard the "=" to make completion easier.
+    if incomplete == "=":
+        incomplete = ""
+    elif "=" in incomplete and _start_of_option(ctx, incomplete):
+        name, _, incomplete = incomplete.partition("=")
+        args.append(name)
+
+    # The "--" marker tells Click to stop treating values as options
+    # even if they start with the option character. If it hasn't been
+    # given and the incomplete arg looks like an option, the current
+    # command will provide option name completions.
+    if "--" not in args and _start_of_option(ctx, incomplete):
+        return ctx.command, incomplete
+
+    params = ctx.command.get_params(ctx)
+
+    # If the last complete arg is an option name with an incomplete
+    # value, the option will provide value completions.
+    for param in params:
+        if _is_incomplete_option(ctx, args, param):
+            return param, incomplete
+
+    # It's not an option name or value. The first argument without a
+    # parsed value will provide value completions.
+    for param in params:
+        if _is_incomplete_argument(ctx, param):
+            return param, incomplete
+
+    # There were no unparsed arguments, the command may be a group that
+    # will provide command name completions.
+    return ctx.command, incomplete
@@ -0,0 +1,784 @@
+import inspect
+import io
+import itertools
+import sys
+import typing as t
+from gettext import gettext as _
+
+from ._compat import isatty
+from ._compat import strip_ansi
+from .exceptions import Abort
+from .exceptions import UsageError
+from .globals import resolve_color_default
+from .types import Choice
+from .types import convert_type
+from .types import ParamType
+from .utils import echo
+from .utils import LazyFile
+
+if t.TYPE_CHECKING:
+    from ._termui_impl import ProgressBar
+
+V = t.TypeVar("V")
+
+# The prompt functions to use.  The doc tools currently override these
+# functions to customize how they work.
+visible_prompt_func: t.Callable[[str], str] = input
+
+_ansi_colors = {
+    "black": 30,
+    "red": 31,
+    "green": 32,
+    "yellow": 33,
+    "blue": 34,
+    "magenta": 35,
+    "cyan": 36,
+    "white": 37,
+    "reset": 39,
+    "bright_black": 90,
+    "bright_red": 91,
+    "bright_green": 92,
+    "bright_yellow": 93,
+    "bright_blue": 94,
+    "bright_magenta": 95,
+    "bright_cyan": 96,
+    "bright_white": 97,
+}
+_ansi_reset_all = "\033[0m"
+
+
+def hidden_prompt_func(prompt: str) -> str:
+    import getpass
+
+    return getpass.getpass(prompt)
+
+
+def _build_prompt(
+    text: str,
+    suffix: str,
+    show_default: bool = False,
+    default: t.Optional[t.Any] = None,
+    show_choices: bool = True,
+    type: t.Optional[ParamType] = None,
+) -> str:
+    prompt = text
+    if type is not None and show_choices and isinstance(type, Choice):
+        prompt += f" ({', '.join(map(str, type.choices))})"
+    if default is not None and show_default:
+        prompt = f"{prompt} [{_format_default(default)}]"
+    return f"{prompt}{suffix}"
+
+
+def _format_default(default: t.Any) -> t.Any:
+    if isinstance(default, (io.IOBase, LazyFile)) and hasattr(default, "name"):
+        return default.name
+
+    return default
+
+
+def prompt(
+    text: str,
+    default: t.Optional[t.Any] = None,
+    hide_input: bool = False,
+    confirmation_prompt: t.Union[bool, str] = False,
+    type: t.Optional[t.Union[ParamType, t.Any]] = None,
+    value_proc: t.Optional[t.Callable[[str], t.Any]] = None,
+    prompt_suffix: str = ": ",
+    show_default: bool = True,
+    err: bool = False,
+    show_choices: bool = True,
+) -> t.Any:
+    """Prompts a user for input.  This is a convenience function that can
+    be used to prompt a user for input later.
+
+    If the user aborts the input by sending an interrupt signal, this
+    function will catch it and raise a :exc:`Abort` exception.
+
+    :param text: the text to show for the prompt.
+    :param default: the default value to use if no input happens.  If this
+                    is not given it will prompt until it's aborted.
+    :param hide_input: if this is set to true then the input value will
+                       be hidden.
+    :param confirmation_prompt: Prompt a second time to confirm the
+        value. Can be set to a string instead of ``True`` to customize
+        the message.
+    :param type: the type to use to check the value against.
+    :param value_proc: if this parameter is provided it's a function that
+                       is invoked instead of the type conversion to
+                       convert a value.
+    :param prompt_suffix: a suffix that should be added to the prompt.
+    :param show_default: shows or hides the default value in the prompt.
+    :param err: if set to true the file defaults to ``stderr`` instead of
+                ``stdout``, the same as with echo.
+    :param show_choices: Show or hide choices if the passed type is a Choice.
+                         For example if type is a Choice of either day or week,
+                         show_choices is true and text is "Group by" then the
+                         prompt will be "Group by (day, week): ".
+
+    .. versionadded:: 8.0
+        ``confirmation_prompt`` can be a custom string.
+
+    .. versionadded:: 7.0
+        Added the ``show_choices`` parameter.
+
+    .. versionadded:: 6.0
+        Added unicode support for cmd.exe on Windows.
+
+    .. versionadded:: 4.0
+        Added the `err` parameter.
+
+    """
+
+    def prompt_func(text: str) -> str:
+        f = hidden_prompt_func if hide_input else visible_prompt_func
+        try:
+            # Write the prompt separately so that we get nice
+            # coloring through colorama on Windows
+            echo(text.rstrip(" "), nl=False, err=err)
+            # Echo a space to stdout to work around an issue where
+            # readline causes backspace to clear the whole line.
+            return f(" ")
+        except (KeyboardInterrupt, EOFError):
+            # getpass doesn't print a newline if the user aborts input with ^C.
+            # Allegedly this behavior is inherited from getpass(3).
+            # A doc bug has been filed at https://bugs.python.org/issue24711
+            if hide_input:
+                echo(None, err=err)
+            raise Abort() from None
+
+    if value_proc is None:
+        value_proc = convert_type(type, default)
+
+    prompt = _build_prompt(
+        text, prompt_suffix, show_default, default, show_choices, type
+    )
+
+    if confirmation_prompt:
+        if confirmation_prompt is True:
+            confirmation_prompt = _("Repeat for confirmation")
+
+        confirmation_prompt = _build_prompt(confirmation_prompt, prompt_suffix)
+
+    while True:
+        while True:
+            value = prompt_func(prompt)
+            if value:
+                break
+            elif default is not None:
+                value = default
+                break
+        try:
+            result = value_proc(value)
+        except UsageError as e:
+            if hide_input:
+                echo(_("Error: The value you entered was invalid."), err=err)
+            else:
+                echo(_("Error: {e.message}").format(e=e), err=err)
+            continue
+        if not confirmation_prompt:
+            return result
+        while True:
+            value2 = prompt_func(confirmation_prompt)
+            is_empty = not value and not value2
+            if value2 or is_empty:
+                break
+        if value == value2:
+            return result
+        echo(_("Error: The two entered values do not match."), err=err)
+
+
+def confirm(
+    text: str,
+    default: t.Optional[bool] = False,
+    abort: bool = False,
+    prompt_suffix: str = ": ",
+    show_default: bool = True,
+    err: bool = False,
+) -> bool:
+    """Prompts for confirmation (yes/no question).
+
+    If the user aborts the input by sending a interrupt signal this
+    function will catch it and raise a :exc:`Abort` exception.
+
+    :param text: the question to ask.
+    :param default: The default value to use when no input is given. If
+        ``None``, repeat until input is given.
+    :param abort: if this is set to `True` a negative answer aborts the
+                  exception by raising :exc:`Abort`.
+    :param prompt_suffix: a suffix that should be added to the prompt.
+    :param show_default: shows or hides the default value in the prompt.
+    :param err: if set to true the file defaults to ``stderr`` instead of
+                ``stdout``, the same as with echo.
+
+    .. versionchanged:: 8.0
+        Repeat until input is given if ``default`` is ``None``.
+
+    .. versionadded:: 4.0
+        Added the ``err`` parameter.
+    """
+    prompt = _build_prompt(
+        text,
+        prompt_suffix,
+        show_default,
+        "y/n" if default is None else ("Y/n" if default else "y/N"),
+    )
+
+    while True:
+        try:
+            # Write the prompt separately so that we get nice
+            # coloring through colorama on Windows
+            echo(prompt.rstrip(" "), nl=False, err=err)
+            # Echo a space to stdout to work around an issue where
+            # readline causes backspace to clear the whole line.
+            value = visible_prompt_func(" ").lower().strip()
+        except (KeyboardInterrupt, EOFError):
+            raise Abort() from None
+        if value in ("y", "yes"):
+            rv = True
+        elif value in ("n", "no"):
+            rv = False
+        elif default is not None and value == "":
+            rv = default
+        else:
+            echo(_("Error: invalid input"), err=err)
+            continue
+        break
+    if abort and not rv:
+        raise Abort()
+    return rv
+
+
+def echo_via_pager(
+    text_or_generator: t.Union[t.Iterable[str], t.Callable[[], t.Iterable[str]], str],
+    color: t.Optional[bool] = None,
+) -> None:
+    """This function takes a text and shows it via an environment specific
+    pager on stdout.
+
+    .. versionchanged:: 3.0
+       Added the `color` flag.
+
+    :param text_or_generator: the text to page, or alternatively, a
+                              generator emitting the text to page.
+    :param color: controls if the pager supports ANSI colors or not.  The
+                  default is autodetection.
+    """
+    color = resolve_color_default(color)
+
+    if inspect.isgeneratorfunction(text_or_generator):
+        i = t.cast(t.Callable[[], t.Iterable[str]], text_or_generator)()
+    elif isinstance(text_or_generator, str):
+        i = [text_or_generator]
+    else:
+        i = iter(t.cast(t.Iterable[str], text_or_generator))
+
+    # convert every element of i to a text type if necessary
+    text_generator = (el if isinstance(el, str) else str(el) for el in i)
+
+    from ._termui_impl import pager
+
+    return pager(itertools.chain(text_generator, "\n"), color)
+
+
+def progressbar(
+    iterable: t.Optional[t.Iterable[V]] = None,
+    length: t.Optional[int] = None,
+    label: t.Optional[str] = None,
+    show_eta: bool = True,
+    show_percent: t.Optional[bool] = None,
+    show_pos: bool = False,
+    item_show_func: t.Optional[t.Callable[[t.Optional[V]], t.Optional[str]]] = None,
+    fill_char: str = "#",
+    empty_char: str = "-",
+    bar_template: str = "%(label)s  [%(bar)s]  %(info)s",
+    info_sep: str = "  ",
+    width: int = 36,
+    file: t.Optional[t.TextIO] = None,
+    color: t.Optional[bool] = None,
+    update_min_steps: int = 1,
+) -> "ProgressBar[V]":
+    """This function creates an iterable context manager that can be used
+    to iterate over something while showing a progress bar.  It will
+    either iterate over the `iterable` or `length` items (that are counted
+    up).  While iteration happens, this function will print a rendered
+    progress bar to the given `file` (defaults to stdout) and will attempt
+    to calculate remaining time and more.  By default, this progress bar
+    will not be rendered if the file is not a terminal.
+
+    The context manager creates the progress bar.  When the context
+    manager is entered the progress bar is already created.  With every
+    iteration over the progress bar, the iterable passed to the bar is
+    advanced and the bar is updated.  When the context manager exits,
+    a newline is printed and the progress bar is finalized on screen.
+
+    Note: The progress bar is currently designed for use cases where the
+    total progress can be expected to take at least several seconds.
+    Because of this, the ProgressBar class object won't display
+    progress that is considered too fast, and progress where the time
+    between steps is less than a second.
+
+    No printing must happen or the progress bar will be unintentionally
+    destroyed.
+
+    Example usage::
+
+        with progressbar(items) as bar:
+            for item in bar:
+                do_something_with(item)
+
+    Alternatively, if no iterable is specified, one can manually update the
+    progress bar through the `update()` method instead of directly
+    iterating over the progress bar.  The update method accepts the number
+    of steps to increment the bar with::
+
+        with progressbar(length=chunks.total_bytes) as bar:
+            for chunk in chunks:
+                process_chunk(chunk)
+                bar.update(chunks.bytes)
+
+    The ``update()`` method also takes an optional value specifying the
+    ``current_item`` at the new position. This is useful when used
+    together with ``item_show_func`` to customize the output for each
+    manual step::
+
+        with click.progressbar(
+            length=total_size,
+            label='Unzipping archive',
+            item_show_func=lambda a: a.filename
+        ) as bar:
+            for archive in zip_file:
+                archive.extract()
+                bar.update(archive.size, archive)
+
+    :param iterable: an iterable to iterate over.  If not provided the length
+                     is required.
+    :param length: the number of items to iterate over.  By default the
+                   progressbar will attempt to ask the iterator about its
+                   length, which might or might not work.  If an iterable is
+                   also provided this parameter can be used to override the
+                   length.  If an iterable is not provided the progress bar
+                   will iterate over a range of that length.
+    :param label: the label to show next to the progress bar.
+    :param show_eta: enables or disables the estimated time display.  This is
+                     automatically disabled if the length cannot be
+                     determined.
+    :param show_percent: enables or disables the percentage display.  The
+                         default is `True` if the iterable has a length or
+                         `False` if not.
+    :param show_pos: enables or disables the absolute position display.  The
+                     default is `False`.
+    :param item_show_func: A function called with the current item which
+        can return a string to show next to the progress bar. If the
+        function returns ``None`` nothing is shown. The current item can
+        be ``None``, such as when entering and exiting the bar.
+    :param fill_char: the character to use to show the filled part of the
+                      progress bar.
+    :param empty_char: the character to use to show the non-filled part of
+                       the progress bar.
+    :param bar_template: the format string to use as template for the bar.
+                         The parameters in it are ``label`` for the label,
+                         ``bar`` for the progress bar and ``info`` for the
+                         info section.
+    :param info_sep: the separator between multiple info items (eta etc.)
+    :param width: the width of the progress bar in characters, 0 means full
+                  terminal width
+    :param file: The file to write to. If this is not a terminal then
+        only the label is printed.
+    :param color: controls if the terminal supports ANSI colors or not.  The
+                  default is autodetection.  This is only needed if ANSI
+                  codes are included anywhere in the progress bar output
+                  which is not the case by default.
+    :param update_min_steps: Render only when this many updates have
+        completed. This allows tuning for very fast iterators.
+
+    .. versionchanged:: 8.0
+        Output is shown even if execution time is less than 0.5 seconds.
+
+    .. versionchanged:: 8.0
+        ``item_show_func`` shows the current item, not the previous one.
+
+    .. versionchanged:: 8.0
+        Labels are echoed if the output is not a TTY. Reverts a change
+        in 7.0 that removed all output.
+
+    .. versionadded:: 8.0
+       Added the ``update_min_steps`` parameter.
+
+    .. versionchanged:: 4.0
+        Added the ``color`` parameter. Added the ``update`` method to
+        the object.
+
+    .. versionadded:: 2.0
+    """
+    from ._termui_impl import ProgressBar
+
+    color = resolve_color_default(color)
+    return ProgressBar(
+        iterable=iterable,
+        length=length,
+        show_eta=show_eta,
+        show_percent=show_percent,
+        show_pos=show_pos,
+        item_show_func=item_show_func,
+        fill_char=fill_char,
+        empty_char=empty_char,
+        bar_template=bar_template,
+        info_sep=info_sep,
+        file=file,
+        label=label,
+        width=width,
+        color=color,
+        update_min_steps=update_min_steps,
+    )
+
+
+def clear() -> None:
+    """Clears the terminal screen.  This will have the effect of clearing
+    the whole visible space of the terminal and moving the cursor to the
+    top left.  This does not do anything if not connected to a terminal.
+
+    .. versionadded:: 2.0
+    """
+    if not isatty(sys.stdout):
+        return
+
+    # ANSI escape \033[2J clears the screen, \033[1;1H moves the cursor
+    echo("\033[2J\033[1;1H", nl=False)
+
+
+def _interpret_color(
+    color: t.Union[int, t.Tuple[int, int, int], str], offset: int = 0
+) -> str:
+    if isinstance(color, int):
+        return f"{38 + offset};5;{color:d}"
+
+    if isinstance(color, (tuple, list)):
+        r, g, b = color
+        return f"{38 + offset};2;{r:d};{g:d};{b:d}"
+
+    return str(_ansi_colors[color] + offset)
+
+
+def style(
+    text: t.Any,
+    fg: t.Optional[t.Union[int, t.Tuple[int, int, int], str]] = None,
+    bg: t.Optional[t.Union[int, t.Tuple[int, int, int], str]] = None,
+    bold: t.Optional[bool] = None,
+    dim: t.Optional[bool] = None,
+    underline: t.Optional[bool] = None,
+    overline: t.Optional[bool] = None,
+    italic: t.Optional[bool] = None,
+    blink: t.Optional[bool] = None,
+    reverse: t.Optional[bool] = None,
+    strikethrough: t.Optional[bool] = None,
+    reset: bool = True,
+) -> str:
+    """Styles a text with ANSI styles and returns the new string.  By
+    default the styling is self contained which means that at the end
+    of the string a reset code is issued.  This can be prevented by
+    passing ``reset=False``.
+
+    Examples::
+
+        click.echo(click.style('Hello World!', fg='green'))
+        click.echo(click.style('ATTENTION!', blink=True))
+        click.echo(click.style('Some things', reverse=True, fg='cyan'))
+        click.echo(click.style('More colors', fg=(255, 12, 128), bg=117))
+
+    Supported color names:
+
+    * ``black`` (might be a gray)
+    * ``red``
+    * ``green``
+    * ``yellow`` (might be an orange)
+    * ``blue``
+    * ``magenta``
+    * ``cyan``
+    * ``white`` (might be light gray)
+    * ``bright_black``
+    * ``bright_red``
+    * ``bright_green``
+    * ``bright_yellow``
+    * ``bright_blue``
+    * ``bright_magenta``
+    * ``bright_cyan``
+    * ``bright_white``
+    * ``reset`` (reset the color code only)
+
+    If the terminal supports it, color may also be specified as:
+
+    -   An integer in the interval [0, 255]. The terminal must support
+        8-bit/256-color mode.
+    -   An RGB tuple of three integers in [0, 255]. The terminal must
+        support 24-bit/true-color mode.
+
+    See https://en.wikipedia.org/wiki/ANSI_color and
+    https://gist.github.com/XVilka/8346728 for more information.
+
+    :param text: the string to style with ansi codes.
+    :param fg: if provided this will become the foreground color.
+    :param bg: if provided this will become the background color.
+    :param bold: if provided this will enable or disable bold mode.
+    :param dim: if provided this will enable or disable dim mode.  This is
+                badly supported.
+    :param underline: if provided this will enable or disable underline.
+    :param overline: if provided this will enable or disable overline.
+    :param italic: if provided this will enable or disable italic.
+    :param blink: if provided this will enable or disable blinking.
+    :param reverse: if provided this will enable or disable inverse
+                    rendering (foreground becomes background and the
+                    other way round).
+    :param strikethrough: if provided this will enable or disable
+        striking through text.
+    :param reset: by default a reset-all code is added at the end of the
+                  string which means that styles do not carry over.  This
+                  can be disabled to compose styles.
+
+    .. versionchanged:: 8.0
+        A non-string ``message`` is converted to a string.
+
+    .. versionchanged:: 8.0
+       Added support for 256 and RGB color codes.
+
+    .. versionchanged:: 8.0
+        Added the ``strikethrough``, ``italic``, and ``overline``
+        parameters.
+
+    .. versionchanged:: 7.0
+        Added support for bright colors.
+
+    .. versionadded:: 2.0
+    """
+    if not isinstance(text, str):
+        text = str(text)
+
+    bits = []
+
+    if fg:
+        try:
+            bits.append(f"\033[{_interpret_color(fg)}m")
+        except KeyError:
+            raise TypeError(f"Unknown color {fg!r}") from None
+
+    if bg:
+        try:
+            bits.append(f"\033[{_interpret_color(bg, 10)}m")
+        except KeyError:
+            raise TypeError(f"Unknown color {bg!r}") from None
+
+    if bold is not None:
+        bits.append(f"\033[{1 if bold else 22}m")
+    if dim is not None:
+        bits.append(f"\033[{2 if dim else 22}m")
+    if underline is not None:
+        bits.append(f"\033[{4 if underline else 24}m")
+    if overline is not None:
+        bits.append(f"\033[{53 if overline else 55}m")
+    if italic is not None:
+        bits.append(f"\033[{3 if italic else 23}m")
+    if blink is not None:
+        bits.append(f"\033[{5 if blink else 25}m")
+    if reverse is not None:
+        bits.append(f"\033[{7 if reverse else 27}m")
+    if strikethrough is not None:
+        bits.append(f"\033[{9 if strikethrough else 29}m")
+    bits.append(text)
+    if reset:
+        bits.append(_ansi_reset_all)
+    return "".join(bits)
+
+
+def unstyle(text: str) -> str:
+    """Removes ANSI styling information from a string.  Usually it's not
+    necessary to use this function as Click's echo function will
+    automatically remove styling if necessary.
+
+    .. versionadded:: 2.0
+
+    :param text: the text to remove style information from.
+    """
+    return strip_ansi(text)
+
+
+def secho(
+    message: t.Optional[t.Any] = None,
+    file: t.Optional[t.IO[t.AnyStr]] = None,
+    nl: bool = True,
+    err: bool = False,
+    color: t.Optional[bool] = None,
+    **styles: t.Any,
+) -> None:
+    """This function combines :func:`echo` and :func:`style` into one
+    call.  As such the following two calls are the same::
+
+        click.secho('Hello World!', fg='green')
+        click.echo(click.style('Hello World!', fg='green'))
+
+    All keyword arguments are forwarded to the underlying functions
+    depending on which one they go with.
+
+    Non-string types will be converted to :class:`str`. However,
+    :class:`bytes` are passed directly to :meth:`echo` without applying
+    style. If you want to style bytes that represent text, call
+    :meth:`bytes.decode` first.
+
+    .. versionchanged:: 8.0
+        A non-string ``message`` is converted to a string. Bytes are
+        passed through without style applied.
+
+    .. versionadded:: 2.0
+    """
+    if message is not None and not isinstance(message, (bytes, bytearray)):
+        message = style(message, **styles)
+
+    return echo(message, file=file, nl=nl, err=err, color=color)
+
+
+def edit(
+    text: t.Optional[t.AnyStr] = None,
+    editor: t.Optional[str] = None,
+    env: t.Optional[t.Mapping[str, str]] = None,
+    require_save: bool = True,
+    extension: str = ".txt",
+    filename: t.Optional[str] = None,
+) -> t.Optional[t.AnyStr]:
+    r"""Edits the given text in the defined editor.  If an editor is given
+    (should be the full path to the executable but the regular operating
+    system search path is used for finding the executable) it overrides
+    the detected editor.  Optionally, some environment variables can be
+    used.  If the editor is closed without changes, `None` is returned.  In
+    case a file is edited directly the return value is always `None` and
+    `require_save` and `extension` are ignored.
+
+    If the editor cannot be opened a :exc:`UsageError` is raised.
+
+    Note for Windows: to simplify cross-platform usage, the newlines are
+    automatically converted from POSIX to Windows and vice versa.  As such,
+    the message here will have ``\n`` as newline markers.
+
+    :param text: the text to edit.
+    :param editor: optionally the editor to use.  Defaults to automatic
+                   detection.
+    :param env: environment variables to forward to the editor.
+    :param require_save: if this is true, then not saving in the editor
+                         will make the return value become `None`.
+    :param extension: the extension to tell the editor about.  This defaults
+                      to `.txt` but changing this might change syntax
+                      highlighting.
+    :param filename: if provided it will edit this file instead of the
+                     provided text contents.  It will not use a temporary
+                     file as an indirection in that case.
+    """
+    from ._termui_impl import Editor
+
+    ed = Editor(editor=editor, env=env, require_save=require_save, extension=extension)
+
+    if filename is None:
+        return ed.edit(text)
+
+    ed.edit_file(filename)
+    return None
+
+
+def launch(url: str, wait: bool = False, locate: bool = False) -> int:
+    """This function launches the given URL (or filename) in the default
+    viewer application for this file type.  If this is an executable, it
+    might launch the executable in a new session.  The return value is
+    the exit code of the launched application.  Usually, ``0`` indicates
+    success.
+
+    Examples::
+
+        click.launch('https://click.palletsprojects.com/')
+        click.launch('/my/downloaded/file', locate=True)
+
+    .. versionadded:: 2.0
+
+    :param url: URL or filename of the thing to launch.
+    :param wait: Wait for the program to exit before returning. This
+        only works if the launched program blocks. In particular,
+        ``xdg-open`` on Linux does not block.
+    :param locate: if this is set to `True` then instead of launching the
+                   application associated with the URL it will attempt to
+                   launch a file manager with the file located.  This
+                   might have weird effects if the URL does not point to
+                   the filesystem.
+    """
+    from ._termui_impl import open_url
+
+    return open_url(url, wait=wait, locate=locate)
+
+
+# If this is provided, getchar() calls into this instead.  This is used
+# for unittesting purposes.
+_getchar: t.Optional[t.Callable[[bool], str]] = None
+
+
+def getchar(echo: bool = False) -> str:
+    """Fetches a single character from the terminal and returns it.  This
+    will always return a unicode character and under certain rare
+    circumstances this might return more than one character.  The
+    situations which more than one character is returned is when for
+    whatever reason multiple characters end up in the terminal buffer or
+    standard input was not actually a terminal.
+
+    Note that this will always read from the terminal, even if something
+    is piped into the standard input.
+
+    Note for Windows: in rare cases when typing non-ASCII characters, this
+    function might wait for a second character and then return both at once.
+    This is because certain Unicode characters look like special-key markers.
+
+    .. versionadded:: 2.0
+
+    :param echo: if set to `True`, the character read will also show up on
+                 the terminal.  The default is to not show it.
+    """
+    global _getchar
+
+    if _getchar is None:
+        from ._termui_impl import getchar as f
+
+        _getchar = f
+
+    return _getchar(echo)
+
+
+def raw_terminal() -> t.ContextManager[int]:
+    from ._termui_impl import raw_terminal as f
+
+    return f()
+
+
+def pause(info: t.Optional[str] = None, err: bool = False) -> None:
+    """This command stops execution and waits for the user to press any
+    key to continue.  This is similar to the Windows batch "pause"
+    command.  If the program is not run through a terminal, this command
+    will instead do nothing.
+
+    .. versionadded:: 2.0
+
+    .. versionadded:: 4.0
+       Added the `err` parameter.
+
+    :param info: The message to print before pausing. Defaults to
+        ``"Press any key to continue..."``.
+    :param err: if set to message goes to ``stderr`` instead of
+                ``stdout``, the same as with echo.
+    """
+    if not isatty(sys.stdin) or not isatty(sys.stdout):
+        return
+
+    if info is None:
+        info = _("Press any key to continue...")
+
+    try:
+        if info:
+            echo(info, nl=False, err=err)
+        try:
+            getchar()
+        except (KeyboardInterrupt, EOFError):
+            pass
+    finally:
+        if info:
+            echo(err=err)
@@ -0,0 +1,483 @@
+import contextlib
+import io
+import os
+import shlex
+import shutil
+import sys
+import tempfile
+import typing as t
+from types import TracebackType
+
+from . import _compat
+from . import formatting
+from . import termui
+from . import utils
+from ._compat import _find_binary_reader
+
+if t.TYPE_CHECKING:
+    from .core import BaseCommand
+
+
+class EchoingStdin:
+    def __init__(self, input: t.BinaryIO, output: t.BinaryIO) -> None:
+        self._input = input
+        self._output = output
+        self._paused = False
+
+    def __getattr__(self, x: str) -> t.Any:
+        return getattr(self._input, x)
+
+    def _echo(self, rv: bytes) -> bytes:
+        if not self._paused:
+            self._output.write(rv)
+
+        return rv
+
+    def read(self, n: int = -1) -> bytes:
+        return self._echo(self._input.read(n))
+
+    def read1(self, n: int = -1) -> bytes:
+        return self._echo(self._input.read1(n))  # type: ignore
+
+    def readline(self, n: int = -1) -> bytes:
+        return self._echo(self._input.readline(n))
+
+    def readlines(self) -> t.List[bytes]:
+        return [self._echo(x) for x in self._input.readlines()]
+
+    def __iter__(self) -> t.Iterator[bytes]:
+        return iter(self._echo(x) for x in self._input)
+
+    def __repr__(self) -> str:
+        return repr(self._input)
+
+
+@contextlib.contextmanager
+def _pause_echo(stream: t.Optional[EchoingStdin]) -> t.Iterator[None]:
+    if stream is None:
+        yield
+    else:
+        stream._paused = True
+        yield
+        stream._paused = False
+
+
+class _NamedTextIOWrapper(io.TextIOWrapper):
+    def __init__(
+        self, buffer: t.BinaryIO, name: str, mode: str, **kwargs: t.Any
+    ) -> None:
+        super().__init__(buffer, **kwargs)
+        self._name = name
+        self._mode = mode
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def mode(self) -> str:
+        return self._mode
+
+
+def make_input_stream(
+    input: t.Optional[t.Union[str, bytes, t.IO[t.Any]]], charset: str
+) -> t.BinaryIO:
+    # Is already an input stream.
+    if hasattr(input, "read"):
+        rv = _find_binary_reader(t.cast(t.IO[t.Any], input))
+
+        if rv is not None:
+            return rv
+
+        raise TypeError("Could not find binary reader for input stream.")
+
+    if input is None:
+        input = b""
+    elif isinstance(input, str):
+        input = input.encode(charset)
+
+    return io.BytesIO(input)
+
+
+class Result:
+    """Holds the captured result of an invoked CLI script."""
+
+    def __init__(
+        self,
+        runner: "CliRunner",
+        stdout_bytes: bytes,
+        stderr_bytes: t.Optional[bytes],
+        return_value: t.Any,
+        exit_code: int,
+        exception: t.Optional[BaseException],
+        exc_info: t.Optional[
+            t.Tuple[t.Type[BaseException], BaseException, TracebackType]
+        ] = None,
+    ):
+        #: The runner that created the result
+        self.runner = runner
+        #: The standard output as bytes.
+        self.stdout_bytes = stdout_bytes
+        #: The standard error as bytes, or None if not available
+        self.stderr_bytes = stderr_bytes
+        #: The value returned from the invoked command.
+        #:
+        #: .. versionadded:: 8.0
+        self.return_value = return_value
+        #: The exit code as integer.
+        self.exit_code = exit_code
+        #: The exception that happened if one did.
+        self.exception = exception
+        #: The traceback
+        self.exc_info = exc_info
+
+    @property
+    def output(self) -> str:
+        """The (standard) output as unicode string."""
+        return self.stdout
+
+    @property
+    def stdout(self) -> str:
+        """The standard output as unicode string."""
+        return self.stdout_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    @property
+    def stderr(self) -> str:
+        """The standard error as unicode string."""
+        if self.stderr_bytes is None:
+            raise ValueError("stderr not separately captured")
+        return self.stderr_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    def __repr__(self) -> str:
+        exc_str = repr(self.exception) if self.exception else "okay"
+        return f"<{type(self).__name__} {exc_str}>"
+
+
+class CliRunner:
+    """The CLI runner provides functionality to invoke a Click command line
+    script for unittesting purposes in a isolated environment.  This only
+    works in single-threaded systems without any concurrency as it changes the
+    global interpreter state.
+
+    :param charset: the character set for the input and output data.
+    :param env: a dictionary with environment variables for overriding.
+    :param echo_stdin: if this is set to `True`, then reading from stdin writes
+                       to stdout.  This is useful for showing examples in
+                       some circumstances.  Note that regular prompts
+                       will automatically echo the input.
+    :param mix_stderr: if this is set to `False`, then stdout and stderr are
+                       preserved as independent streams.  This is useful for
+                       Unix-philosophy apps that have predictable stdout and
+                       noisy stderr, such that each may be measured
+                       independently
+    """
+
+    def __init__(
+        self,
+        charset: str = "utf-8",
+        env: t.Optional[t.Mapping[str, t.Optional[str]]] = None,
+        echo_stdin: bool = False,
+        mix_stderr: bool = True,
+    ) -> None:
+        self.charset = charset
+        self.env: t.Mapping[str, t.Optional[str]] = env or {}
+        self.echo_stdin = echo_stdin
+        self.mix_stderr = mix_stderr
+
+    def get_default_prog_name(self, cli: "BaseCommand") -> str:
+        """Given a command object it will return the default program name
+        for it.  The default is the `name` attribute or ``"root"`` if not
+        set.
+        """
+        return cli.name or "root"
+
+    def make_env(
+        self, overrides: t.Optional[t.Mapping[str, t.Optional[str]]] = None
+    ) -> t.Mapping[str, t.Optional[str]]:
+        """Returns the environment overrides for invoking a script."""
+        rv = dict(self.env)
+        if overrides:
+            rv.update(overrides)
+        return rv
+
+    @contextlib.contextmanager
+    def isolation(
+        self,
+        input: t.Optional[t.Union[str, bytes, t.IO[t.Any]]] = None,
+        env: t.Optional[t.Mapping[str, t.Optional[str]]] = None,
+        color: bool = False,
+    ) -> t.Iterator[t.Tuple[io.BytesIO, t.Optional[io.BytesIO]]]:
+        """A context manager that sets up the isolation for invoking of a
+        command line tool.  This sets up stdin with the given input data
+        and `os.environ` with the overrides from the given dictionary.
+        This also rebinds some internals in Click to be mocked (like the
+        prompt functionality).
+
+        This is automatically done in the :meth:`invoke` method.
+
+        :param input: the input stream to put into sys.stdin.
+        :param env: the environment overrides as dictionary.
+        :param color: whether the output should contain color codes. The
+                      application can still override this explicitly.
+
+        .. versionchanged:: 8.0
+            ``stderr`` is opened with ``errors="backslashreplace"``
+            instead of the default ``"strict"``.
+
+        .. versionchanged:: 4.0
+            Added the ``color`` parameter.
+        """
+        bytes_input = make_input_stream(input, self.charset)
+        echo_input = None
+
+        old_stdin = sys.stdin
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        old_forced_width = formatting.FORCED_WIDTH
+        formatting.FORCED_WIDTH = 80
+
+        env = self.make_env(env)
+
+        bytes_output = io.BytesIO()
+
+        if self.echo_stdin:
+            bytes_input = echo_input = t.cast(
+                t.BinaryIO, EchoingStdin(bytes_input, bytes_output)
+            )
+
+        sys.stdin = text_input = _NamedTextIOWrapper(
+            bytes_input, encoding=self.charset, name="<stdin>", mode="r"
+        )
+
+        if self.echo_stdin:
+            # Force unbuffered reads, otherwise TextIOWrapper reads a
+            # large chunk which is echoed early.
+            text_input._CHUNK_SIZE = 1  # type: ignore
+
+        sys.stdout = _NamedTextIOWrapper(
+            bytes_output, encoding=self.charset, name="<stdout>", mode="w"
+        )
+
+        bytes_error = None
+        if self.mix_stderr:
+            sys.stderr = sys.stdout
+        else:
+            bytes_error = io.BytesIO()
+            sys.stderr = _NamedTextIOWrapper(
+                bytes_error,
+                encoding=self.charset,
+                name="<stderr>",
+                mode="w",
+                errors="backslashreplace",
+            )
+
+        @_pause_echo(echo_input)  # type: ignore
+        def visible_input(prompt: t.Optional[str] = None) -> str:
+            sys.stdout.write(prompt or "")
+            val = text_input.readline().rstrip("\r\n")
+            sys.stdout.write(f"{val}\n")
+            sys.stdout.flush()
+            return val
+
+        @_pause_echo(echo_input)  # type: ignore
+        def hidden_input(prompt: t.Optional[str] = None) -> str:
+            sys.stdout.write(f"{prompt or ''}\n")
+            sys.stdout.flush()
+            return text_input.readline().rstrip("\r\n")
+
+        @_pause_echo(echo_input)  # type: ignore
+        def _getchar(echo: bool) -> str:
+            char = sys.stdin.read(1)
+
+            if echo:
+                sys.stdout.write(char)
+
+            sys.stdout.flush()
+            return char
+
+        default_color = color
+
+        def should_strip_ansi(
+            stream: t.Optional[t.IO[t.Any]] = None, color: t.Optional[bool] = None
+        ) -> bool:
+            if color is None:
+                return not default_color
+            return not color
+
+        old_visible_prompt_func = termui.visible_prompt_func
+        old_hidden_prompt_func = termui.hidden_prompt_func
+        old__getchar_func = termui._getchar
+        old_should_strip_ansi = utils.should_strip_ansi  # type: ignore
+        old__compat_should_strip_ansi = _compat.should_strip_ansi
+        termui.visible_prompt_func = visible_input
+        termui.hidden_prompt_func = hidden_input
+        termui._getchar = _getchar
+        utils.should_strip_ansi = should_strip_ansi  # type: ignore
+        _compat.should_strip_ansi = should_strip_ansi
+
+        old_env = {}
+        try:
+            for key, value in env.items():
+                old_env[key] = os.environ.get(key)
+                if value is None:
+                    try:
+                        del os.environ[key]
+                    except Exception:
+                        pass
+                else:
+                    os.environ[key] = value
+            yield (bytes_output, bytes_error)
+        finally:
+            for key, value in old_env.items():
+                if value is None:
+                    try:
+                        del os.environ[key]
+                    except Exception:
+                        pass
+                else:
+                    os.environ[key] = value
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+            sys.stdin = old_stdin
+            termui.visible_prompt_func = old_visible_prompt_func
+            termui.hidden_prompt_func = old_hidden_prompt_func
+            termui._getchar = old__getchar_func
+            utils.should_strip_ansi = old_should_strip_ansi  # type: ignore
+            _compat.should_strip_ansi = old__compat_should_strip_ansi
+            formatting.FORCED_WIDTH = old_forced_width
+
+    def invoke(
+        self,
+        cli: "BaseCommand",
+        args: t.Optional[t.Union[str, t.Sequence[str]]] = None,
+        input: t.Optional[t.Union[str, bytes, t.IO[t.Any]]] = None,
+        env: t.Optional[t.Mapping[str, t.Optional[str]]] = None,
+        catch_exceptions: bool = True,
+        color: bool = False,
+        **extra: t.Any,
+    ) -> Result:
+        """Invokes a command in an isolated environment.  The arguments are
+        forwarded directly to the command line script, the `extra` keyword
+        arguments are passed to the :meth:`~clickpkg.Command.main` function of
+        the command.
+
+        This returns a :class:`Result` object.
+
+        :param cli: the command to invoke
+        :param args: the arguments to invoke. It may be given as an iterable
+                     or a string. When given as string it will be interpreted
+                     as a Unix shell command. More details at
+                     :func:`shlex.split`.
+        :param input: the input data for `sys.stdin`.
+        :param env: the environment overrides.
+        :param catch_exceptions: Whether to catch any other exceptions than
+                                 ``SystemExit``.
+        :param extra: the keyword arguments to pass to :meth:`main`.
+        :param color: whether the output should contain color codes. The
+                      application can still override this explicitly.
+
+        .. versionchanged:: 8.0
+            The result object has the ``return_value`` attribute with
+            the value returned from the invoked command.
+
+        .. versionchanged:: 4.0
+            Added the ``color`` parameter.
+
+        .. versionchanged:: 3.0
+            Added the ``catch_exceptions`` parameter.
+
+        .. versionchanged:: 3.0
+            The result object has the ``exc_info`` attribute with the
+            traceback if available.
+        """
+        exc_info = None
+        with self.isolation(input=input, env=env, color=color) as outstreams:
+            return_value = None
+            exception: t.Optional[BaseException] = None
+            exit_code = 0
+
+            if isinstance(args, str):
+                args = shlex.split(args)
+
+            try:
+                prog_name = extra.pop("prog_name")
+            except KeyError:
+                prog_name = self.get_default_prog_name(cli)
+
+            try:
+                return_value = cli.main(args=args or (), prog_name=prog_name, **extra)
+            except SystemExit as e:
+                exc_info = sys.exc_info()
+                e_code = t.cast(t.Optional[t.Union[int, t.Any]], e.code)
+
+                if e_code is None:
+                    e_code = 0
+
+                if e_code != 0:
+                    exception = e
+
+                if not isinstance(e_code, int):
+                    sys.stdout.write(str(e_code))
+                    sys.stdout.write("\n")
+                    e_code = 1
+
+                exit_code = e_code
+
+            except Exception as e:
+                if not catch_exceptions:
+                    raise
+                exception = e
+                exit_code = 1
+                exc_info = sys.exc_info()
+            finally:
+                sys.stdout.flush()
+                stdout = outstreams[0].getvalue()
+                if self.mix_stderr:
+                    stderr = None
+                else:
+                    stderr = outstreams[1].getvalue()  # type: ignore
+
+        return Result(
+            runner=self,
+            stdout_bytes=stdout,
+            stderr_bytes=stderr,
+            return_value=return_value,
+            exit_code=exit_code,
+            exception=exception,
+            exc_info=exc_info,  # type: ignore
+        )
+
+    @contextlib.contextmanager
+    def isolated_filesystem(
+        self, temp_dir: t.Optional[t.Union[str, "os.PathLike[str]"]] = None
+    ) -> t.Iterator[str]:
+        """A context manager that creates a temporary directory and
+        changes the current working directory to it. This isolates tests
+        that affect the contents of the CWD to prevent them from
+        interfering with each other.
+
+        :param temp_dir: Create the temporary directory under this
+            directory. If given, the created directory is not removed
+            when exiting.
+
+        .. versionchanged:: 8.0
+            Added the ``temp_dir`` parameter.
+        """
+        cwd = os.getcwd()
+        dt = tempfile.mkdtemp(dir=temp_dir)
+        os.chdir(dt)
+
+        try:
+            yield dt
+        finally:
+            os.chdir(cwd)
+
+            if temp_dir is None:
+                try:
+                    shutil.rmtree(dt)
+                except OSError:
+                    pass
@@ -0,0 +1,624 @@
+import os
+import re
+import sys
+import typing as t
+from functools import update_wrapper
+from types import ModuleType
+from types import TracebackType
+
+from ._compat import _default_text_stderr
+from ._compat import _default_text_stdout
+from ._compat import _find_binary_writer
+from ._compat import auto_wrap_for_ansi
+from ._compat import binary_streams
+from ._compat import open_stream
+from ._compat import should_strip_ansi
+from ._compat import strip_ansi
+from ._compat import text_streams
+from ._compat import WIN
+from .globals import resolve_color_default
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    P = te.ParamSpec("P")
+
+R = t.TypeVar("R")
+
+
+def _posixify(name: str) -> str:
+    return "-".join(name.split()).lower()
+
+
+def safecall(func: "t.Callable[P, R]") -> "t.Callable[P, t.Optional[R]]":
+    """Wraps a function so that it swallows exceptions."""
+
+    def wrapper(*args: "P.args", **kwargs: "P.kwargs") -> t.Optional[R]:
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            pass
+        return None
+
+    return update_wrapper(wrapper, func)
+
+
+def make_str(value: t.Any) -> str:
+    """Converts a value into a valid string."""
+    if isinstance(value, bytes):
+        try:
+            return value.decode(sys.getfilesystemencoding())
+        except UnicodeError:
+            return value.decode("utf-8", "replace")
+    return str(value)
+
+
+def make_default_short_help(help: str, max_length: int = 45) -> str:
+    """Returns a condensed version of help string."""
+    # Consider only the first paragraph.
+    paragraph_end = help.find("\n\n")
+
+    if paragraph_end != -1:
+        help = help[:paragraph_end]
+
+    # Collapse newlines, tabs, and spaces.
+    words = help.split()
+
+    if not words:
+        return ""
+
+    # The first paragraph started with a "no rewrap" marker, ignore it.
+    if words[0] == "\b":
+        words = words[1:]
+
+    total_length = 0
+    last_index = len(words) - 1
+
+    for i, word in enumerate(words):
+        total_length += len(word) + (i > 0)
+
+        if total_length > max_length:  # too long, truncate
+            break
+
+        if word[-1] == ".":  # sentence end, truncate without "..."
+            return " ".join(words[: i + 1])
+
+        if total_length == max_length and i != last_index:
+            break  # not at sentence end, truncate with "..."
+    else:
+        return " ".join(words)  # no truncation needed
+
+    # Account for the length of the suffix.
+    total_length += len("...")
+
+    # remove words until the length is short enough
+    while i > 0:
+        total_length -= len(words[i]) + (i > 0)
+
+        if total_length <= max_length:
+            break
+
+        i -= 1
+
+    return " ".join(words[:i]) + "..."
+
+
+class LazyFile:
+    """A lazy file works like a regular file but it does not fully open
+    the file but it does perform some basic checks early to see if the
+    filename parameter does make sense.  This is useful for safely opening
+    files for writing.
+    """
+
+    def __init__(
+        self,
+        filename: t.Union[str, "os.PathLike[str]"],
+        mode: str = "r",
+        encoding: t.Optional[str] = None,
+        errors: t.Optional[str] = "strict",
+        atomic: bool = False,
+    ):
+        self.name: str = os.fspath(filename)
+        self.mode = mode
+        self.encoding = encoding
+        self.errors = errors
+        self.atomic = atomic
+        self._f: t.Optional[t.IO[t.Any]]
+        self.should_close: bool
+
+        if self.name == "-":
+            self._f, self.should_close = open_stream(filename, mode, encoding, errors)
+        else:
+            if "r" in mode:
+                # Open and close the file in case we're opening it for
+                # reading so that we can catch at least some errors in
+                # some cases early.
+                open(filename, mode).close()
+            self._f = None
+            self.should_close = True
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self.open(), name)
+
+    def __repr__(self) -> str:
+        if self._f is not None:
+            return repr(self._f)
+        return f"<unopened file '{format_filename(self.name)}' {self.mode}>"
+
+    def open(self) -> t.IO[t.Any]:
+        """Opens the file if it's not yet open.  This call might fail with
+        a :exc:`FileError`.  Not handling this error will produce an error
+        that Click shows.
+        """
+        if self._f is not None:
+            return self._f
+        try:
+            rv, self.should_close = open_stream(
+                self.name, self.mode, self.encoding, self.errors, atomic=self.atomic
+            )
+        except OSError as e:
+            from .exceptions import FileError
+
+            raise FileError(self.name, hint=e.strerror) from e
+        self._f = rv
+        return rv
+
+    def close(self) -> None:
+        """Closes the underlying file, no matter what."""
+        if self._f is not None:
+            self._f.close()
+
+    def close_intelligently(self) -> None:
+        """This function only closes the file if it was opened by the lazy
+        file wrapper.  For instance this will never close stdin.
+        """
+        if self.should_close:
+            self.close()
+
+    def __enter__(self) -> "LazyFile":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: t.Optional[t.Type[BaseException]],
+        exc_value: t.Optional[BaseException],
+        tb: t.Optional[TracebackType],
+    ) -> None:
+        self.close_intelligently()
+
+    def __iter__(self) -> t.Iterator[t.AnyStr]:
+        self.open()
+        return iter(self._f)  # type: ignore
+
+
+class KeepOpenFile:
+    def __init__(self, file: t.IO[t.Any]) -> None:
+        self._file: t.IO[t.Any] = file
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._file, name)
+
+    def __enter__(self) -> "KeepOpenFile":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: t.Optional[t.Type[BaseException]],
+        exc_value: t.Optional[BaseException],
+        tb: t.Optional[TracebackType],
+    ) -> None:
+        pass
+
+    def __repr__(self) -> str:
+        return repr(self._file)
+
+    def __iter__(self) -> t.Iterator[t.AnyStr]:
+        return iter(self._file)
+
+
+def echo(
+    message: t.Optional[t.Any] = None,
+    file: t.Optional[t.IO[t.Any]] = None,
+    nl: bool = True,
+    err: bool = False,
+    color: t.Optional[bool] = None,
+) -> None:
+    """Print a message and newline to stdout or a file. This should be
+    used instead of :func:`print` because it provides better support
+    for different data, files, and environments.
+
+    Compared to :func:`print`, this does the following:
+
+    -   Ensures that the output encoding is not misconfigured on Linux.
+    -   Supports Unicode in the Windows console.
+    -   Supports writing to binary outputs, and supports writing bytes
+        to text outputs.
+    -   Supports colors and styles on Windows.
+    -   Removes ANSI color and style codes if the output does not look
+        like an interactive terminal.
+    -   Always flushes the output.
+
+    :param message: The string or bytes to output. Other objects are
+        converted to strings.
+    :param file: The file to write to. Defaults to ``stdout``.
+    :param err: Write to ``stderr`` instead of ``stdout``.
+    :param nl: Print a newline after the message. Enabled by default.
+    :param color: Force showing or hiding colors and other styles. By
+        default Click will remove color if the output does not look like
+        an interactive terminal.
+
+    .. versionchanged:: 6.0
+        Support Unicode output on the Windows console. Click does not
+        modify ``sys.stdout``, so ``sys.stdout.write()`` and ``print()``
+        will still not support Unicode.
+
+    .. versionchanged:: 4.0
+        Added the ``color`` parameter.
+
+    .. versionadded:: 3.0
+        Added the ``err`` parameter.
+
+    .. versionchanged:: 2.0
+        Support colors on Windows if colorama is installed.
+    """
+    if file is None:
+        if err:
+            file = _default_text_stderr()
+        else:
+            file = _default_text_stdout()
+
+        # There are no standard streams attached to write to. For example,
+        # pythonw on Windows.
+        if file is None:
+            return
+
+    # Convert non bytes/text into the native string type.
+    if message is not None and not isinstance(message, (str, bytes, bytearray)):
+        out: t.Optional[t.Union[str, bytes]] = str(message)
+    else:
+        out = message
+
+    if nl:
+        out = out or ""
+        if isinstance(out, str):
+            out += "\n"
+        else:
+            out += b"\n"
+
+    if not out:
+        file.flush()
+        return
+
+    # If there is a message and the value looks like bytes, we manually
+    # need to find the binary stream and write the message in there.
+    # This is done separately so that most stream types will work as you
+    # would expect. Eg: you can write to StringIO for other cases.
+    if isinstance(out, (bytes, bytearray)):
+        binary_file = _find_binary_writer(file)
+
+        if binary_file is not None:
+            file.flush()
+            binary_file.write(out)
+            binary_file.flush()
+            return
+
+    # ANSI style code support. For no message or bytes, nothing happens.
+    # When outputting to a file instead of a terminal, strip codes.
+    else:
+        color = resolve_color_default(color)
+
+        if should_strip_ansi(file, color):
+            out = strip_ansi(out)
+        elif WIN:
+            if auto_wrap_for_ansi is not None:
+                file = auto_wrap_for_ansi(file, color)  # type: ignore
+            elif not color:
+                out = strip_ansi(out)
+
+    file.write(out)  # type: ignore
+    file.flush()
+
+
+def get_binary_stream(name: "te.Literal['stdin', 'stdout', 'stderr']") -> t.BinaryIO:
+    """Returns a system stream for byte processing.
+
+    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
+                 ``'stdout'`` and ``'stderr'``
+    """
+    opener = binary_streams.get(name)
+    if opener is None:
+        raise TypeError(f"Unknown standard stream '{name}'")
+    return opener()
+
+
+def get_text_stream(
+    name: "te.Literal['stdin', 'stdout', 'stderr']",
+    encoding: t.Optional[str] = None,
+    errors: t.Optional[str] = "strict",
+) -> t.TextIO:
+    """Returns a system stream for text processing.  This usually returns
+    a wrapped stream around a binary stream returned from
+    :func:`get_binary_stream` but it also can take shortcuts for already
+    correctly configured streams.
+
+    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
+                 ``'stdout'`` and ``'stderr'``
+    :param encoding: overrides the detected default encoding.
+    :param errors: overrides the default error mode.
+    """
+    opener = text_streams.get(name)
+    if opener is None:
+        raise TypeError(f"Unknown standard stream '{name}'")
+    return opener(encoding, errors)
+
+
+def open_file(
+    filename: t.Union[str, "os.PathLike[str]"],
+    mode: str = "r",
+    encoding: t.Optional[str] = None,
+    errors: t.Optional[str] = "strict",
+    lazy: bool = False,
+    atomic: bool = False,
+) -> t.IO[t.Any]:
+    """Open a file, with extra behavior to handle ``'-'`` to indicate
+    a standard stream, lazy open on write, and atomic write. Similar to
+    the behavior of the :class:`~click.File` param type.
+
+    If ``'-'`` is given to open ``stdout`` or ``stdin``, the stream is
+    wrapped so that using it in a context manager will not close it.
+    This makes it possible to use the function without accidentally
+    closing a standard stream:
+
+    .. code-block:: python
+
+        with open_file(filename) as f:
+            ...
+
+    :param filename: The name or Path of the file to open, or ``'-'`` for
+        ``stdin``/``stdout``.
+    :param mode: The mode in which to open the file.
+    :param encoding: The encoding to decode or encode a file opened in
+        text mode.
+    :param errors: The error handling mode.
+    :param lazy: Wait to open the file until it is accessed. For read
+        mode, the file is temporarily opened to raise access errors
+        early, then closed until it is read again.
+    :param atomic: Write to a temporary file and replace the given file
+        on close.
+
+    .. versionadded:: 3.0
+    """
+    if lazy:
+        return t.cast(
+            t.IO[t.Any], LazyFile(filename, mode, encoding, errors, atomic=atomic)
+        )
+
+    f, should_close = open_stream(filename, mode, encoding, errors, atomic=atomic)
+
+    if not should_close:
+        f = t.cast(t.IO[t.Any], KeepOpenFile(f))
+
+    return f
+
+
+def format_filename(
+    filename: "t.Union[str, bytes, os.PathLike[str], os.PathLike[bytes]]",
+    shorten: bool = False,
+) -> str:
+    """Format a filename as a string for display. Ensures the filename can be
+    displayed by replacing any invalid bytes or surrogate escapes in the name
+    with the replacement character ``�``.
+
+    Invalid bytes or surrogate escapes will raise an error when written to a
+    stream with ``errors="strict"``. This will typically happen with ``stdout``
+    when the locale is something like ``en_GB.UTF-8``.
+
+    Many scenarios *are* safe to write surrogates though, due to PEP 538 and
+    PEP 540, including:
+
+    -   Writing to ``stderr``, which uses ``errors="backslashreplace"``.
+    -   The system has ``LANG=C.UTF-8``, ``C``, or ``POSIX``. Python opens
+        stdout and stderr with ``errors="surrogateescape"``.
+    -   None of ``LANG/LC_*`` are set. Python assumes ``LANG=C.UTF-8``.
+    -   Python is started in UTF-8 mode  with  ``PYTHONUTF8=1`` or ``-X utf8``.
+        Python opens stdout and stderr with ``errors="surrogateescape"``.
+
+    :param filename: formats a filename for UI display.  This will also convert
+                     the filename into unicode without failing.
+    :param shorten: this optionally shortens the filename to strip of the
+                    path that leads up to it.
+    """
+    if shorten:
+        filename = os.path.basename(filename)
+    else:
+        filename = os.fspath(filename)
+
+    if isinstance(filename, bytes):
+        filename = filename.decode(sys.getfilesystemencoding(), "replace")
+    else:
+        filename = filename.encode("utf-8", "surrogateescape").decode(
+            "utf-8", "replace"
+        )
+
+    return filename
+
+
+def get_app_dir(app_name: str, roaming: bool = True, force_posix: bool = False) -> str:
+    r"""Returns the config folder for the application.  The default behavior
+    is to return whatever is most appropriate for the operating system.
+
+    To give you an idea, for an app called ``"Foo Bar"``, something like
+    the following folders could be returned:
+
+    Mac OS X:
+      ``~/Library/Application Support/Foo Bar``
+    Mac OS X (POSIX):
+      ``~/.foo-bar``
+    Unix:
+      ``~/.config/foo-bar``
+    Unix (POSIX):
+      ``~/.foo-bar``
+    Windows (roaming):
+      ``C:\Users\<user>\AppData\Roaming\Foo Bar``
+    Windows (not roaming):
+      ``C:\Users\<user>\AppData\Local\Foo Bar``
+
+    .. versionadded:: 2.0
+
+    :param app_name: the application name.  This should be properly capitalized
+                     and can contain whitespace.
+    :param roaming: controls if the folder should be roaming or not on Windows.
+                    Has no effect otherwise.
+    :param force_posix: if this is set to `True` then on any POSIX system the
+                        folder will be stored in the home folder with a leading
+                        dot instead of the XDG config home or darwin's
+                        application support folder.
+    """
+    if WIN:
+        key = "APPDATA" if roaming else "LOCALAPPDATA"
+        folder = os.environ.get(key)
+        if folder is None:
+            folder = os.path.expanduser("~")
+        return os.path.join(folder, app_name)
+    if force_posix:
+        return os.path.join(os.path.expanduser(f"~/.{_posixify(app_name)}"))
+    if sys.platform == "darwin":
+        return os.path.join(
+            os.path.expanduser("~/Library/Application Support"), app_name
+        )
+    return os.path.join(
+        os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")),
+        _posixify(app_name),
+    )
+
+
+class PacifyFlushWrapper:
+    """This wrapper is used to catch and suppress BrokenPipeErrors resulting
+    from ``.flush()`` being called on broken pipe during the shutdown/final-GC
+    of the Python interpreter. Notably ``.flush()`` is always called on
+    ``sys.stdout`` and ``sys.stderr``. So as to have minimal impact on any
+    other cleanup code, and the case where the underlying file is not a broken
+    pipe, all calls and attributes are proxied.
+    """
+
+    def __init__(self, wrapped: t.IO[t.Any]) -> None:
+        self.wrapped = wrapped
+
+    def flush(self) -> None:
+        try:
+            self.wrapped.flush()
+        except OSError as e:
+            import errno
+
+            if e.errno != errno.EPIPE:
+                raise
+
+    def __getattr__(self, attr: str) -> t.Any:
+        return getattr(self.wrapped, attr)
+
+
+def _detect_program_name(
+    path: t.Optional[str] = None, _main: t.Optional[ModuleType] = None
+) -> str:
+    """Determine the command used to run the program, for use in help
+    text. If a file or entry point was executed, the file name is
+    returned. If ``python -m`` was used to execute a module or package,
+    ``python -m name`` is returned.
+
+    This doesn't try to be too precise, the goal is to give a concise
+    name for help text. Files are only shown as their name without the
+    path. ``python`` is only shown for modules, and the full path to
+    ``sys.executable`` is not shown.
+
+    :param path: The Python file being executed. Python puts this in
+        ``sys.argv[0]``, which is used by default.
+    :param _main: The ``__main__`` module. This should only be passed
+        during internal testing.
+
+    .. versionadded:: 8.0
+        Based on command args detection in the Werkzeug reloader.
+
+    :meta private:
+    """
+    if _main is None:
+        _main = sys.modules["__main__"]
+
+    if not path:
+        path = sys.argv[0]
+
+    # The value of __package__ indicates how Python was called. It may
+    # not exist if a setuptools script is installed as an egg. It may be
+    # set incorrectly for entry points created with pip on Windows.
+    # It is set to "" inside a Shiv or PEX zipapp.
+    if getattr(_main, "__package__", None) in {None, ""} or (
+        os.name == "nt"
+        and _main.__package__ == ""
+        and not os.path.exists(path)
+        and os.path.exists(f"{path}.exe")
+    ):
+        # Executed a file, like "python app.py".
+        return os.path.basename(path)
+
+    # Executed a module, like "python -m example".
+    # Rewritten by Python from "-m script" to "/path/to/script.py".
+    # Need to look at main module to determine how it was executed.
+    py_module = t.cast(str, _main.__package__)
+    name = os.path.splitext(os.path.basename(path))[0]
+
+    # A submodule like "example.cli".
+    if name != "__main__":
+        py_module = f"{py_module}.{name}"
+
+    return f"python -m {py_module.lstrip('.')}"
+
+
+def _expand_args(
+    args: t.Iterable[str],
+    *,
+    user: bool = True,
+    env: bool = True,
+    glob_recursive: bool = True,
+) -> t.List[str]:
+    """Simulate Unix shell expansion with Python functions.
+
+    See :func:`glob.glob`, :func:`os.path.expanduser`, and
+    :func:`os.path.expandvars`.
+
+    This is intended for use on Windows, where the shell does not do any
+    expansion. It may not exactly match what a Unix shell would do.
+
+    :param args: List of command line arguments to expand.
+    :param user: Expand user home directory.
+    :param env: Expand environment variables.
+    :param glob_recursive: ``**`` matches directories recursively.
+
+    .. versionchanged:: 8.1
+        Invalid glob patterns are treated as empty expansions rather
+        than raising an error.
+
+    .. versionadded:: 8.0
+
+    :meta private:
+    """
+    from glob import glob
+
+    out = []
+
+    for arg in args:
+        if user:
+            arg = os.path.expanduser(arg)
+
+        if env:
+            arg = os.path.expandvars(arg)
+
+        try:
+            matches = glob(arg, recursive=glob_recursive)
+        except re.error:
+            matches = []
+
+        if not matches:
+            out.append(arg)
+        else:
+            out.extend(matches)
+
+    return out
@@ -0,0 +1 @@
+pip
@@ -0,0 +1,441 @@
+Metadata-Version: 2.1
+Name: colorama
+Version: 0.4.6
+Summary: Cross-platform colored terminal text.
+Project-URL: Homepage, https://github.com/tartley/colorama
+Author-email: Jonathan Hartley <tartley@tartley.com>
+License-File: LICENSE.txt
+Keywords: ansi,color,colour,crossplatform,terminal,text,windows,xplatform
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+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 :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Terminals
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7
+Description-Content-Type: text/x-rst
+
+.. image:: https://img.shields.io/pypi/v/colorama.svg
+    :target: https://pypi.org/project/colorama/
+    :alt: Latest Version
+
+.. image:: https://img.shields.io/pypi/pyversions/colorama.svg
+    :target: https://pypi.org/project/colorama/
+    :alt: Supported Python versions
+
+.. image:: https://github.com/tartley/colorama/actions/workflows/test.yml/badge.svg
+    :target: https://github.com/tartley/colorama/actions/workflows/test.yml
+    :alt: Build Status
+
+Colorama
+========
+
+Makes ANSI escape character sequences (for producing colored terminal text and
+cursor positioning) work under MS Windows.
+
+.. |donate| image:: https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif
+  :target: https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=2MZ9D2GMLYCUJ&item_name=Colorama&currency_code=USD
+  :alt: Donate with Paypal
+
+`PyPI for releases <https://pypi.org/project/colorama/>`_ |
+`Github for source <https://github.com/tartley/colorama>`_ |
+`Colorama for enterprise on Tidelift <https://github.com/tartley/colorama/blob/master/ENTERPRISE.md>`_
+
+If you find Colorama useful, please |donate| to the authors. Thank you!
+
+Installation
+------------
+
+Tested on CPython 2.7, 3.7, 3.8, 3.9 and 3.10 and Pypy 2.7 and 3.8.
+
+No requirements other than the standard library.
+
+.. code-block:: bash
+
+    pip install colorama
+    # or
+    conda install -c anaconda colorama
+
+Description
+-----------
+
+ANSI escape character sequences have long been used to produce colored terminal
+text and cursor positioning on Unix and Macs. Colorama makes this work on
+Windows, too, by wrapping ``stdout``, stripping ANSI sequences it finds (which
+would appear as gobbledygook in the output), and converting them into the
+appropriate win32 calls to modify the state of the terminal. On other platforms,
+Colorama does nothing.
+
+This has the upshot of providing a simple cross-platform API for printing
+colored terminal text from Python, and has the happy side-effect that existing
+applications or libraries which use ANSI sequences to produce colored output on
+Linux or Macs can now also work on Windows, simply by calling
+``colorama.just_fix_windows_console()`` (since v0.4.6) or ``colorama.init()``
+(all versions, but may have other side-effects – see below).
+
+An alternative approach is to install ``ansi.sys`` on Windows machines, which
+provides the same behaviour for all applications running in terminals. Colorama
+is intended for situations where that isn't easy (e.g., maybe your app doesn't
+have an installer.)
+
+Demo scripts in the source code repository print some colored text using
+ANSI sequences. Compare their output under Gnome-terminal's built in ANSI
+handling, versus on Windows Command-Prompt using Colorama:
+
+.. image:: https://github.com/tartley/colorama/raw/master/screenshots/ubuntu-demo.png
+    :width: 661
+    :height: 357
+    :alt: ANSI sequences on Ubuntu under gnome-terminal.
+
+.. image:: https://github.com/tartley/colorama/raw/master/screenshots/windows-demo.png
+    :width: 668
+    :height: 325
+    :alt: Same ANSI sequences on Windows, using Colorama.
+
+These screenshots show that, on Windows, Colorama does not support ANSI 'dim
+text'; it looks the same as 'normal text'.
+
+Usage
+-----
+
+Initialisation
+..............
+
+If the only thing you want from Colorama is to get ANSI escapes to work on
+Windows, then run:
+
+.. code-block:: python
+
+    from colorama import just_fix_windows_console
+    just_fix_windows_console()
+
+If you're on a recent version of Windows 10 or better, and your stdout/stderr
+are pointing to a Windows console, then this will flip the magic configuration
+switch to enable Windows' built-in ANSI support.
+
+If you're on an older version of Windows, and your stdout/stderr are pointing to
+a Windows console, then this will wrap ``sys.stdout`` and/or ``sys.stderr`` in a
+magic file object that intercepts ANSI escape sequences and issues the
+appropriate Win32 calls to emulate them.
+
+In all other circumstances, it does nothing whatsoever. Basically the idea is
+that this makes Windows act like Unix with respect to ANSI escape handling.
+
+It's safe to call this function multiple times. It's safe to call this function
+on non-Windows platforms, but it won't do anything. It's safe to call this
+function when one or both of your stdout/stderr are redirected to a file – it
+won't do anything to those streams.
+
+Alternatively, you can use the older interface with more features (but also more
+potential footguns):
+
+.. code-block:: python
+
+    from colorama import init
+    init()
+
+This does the same thing as ``just_fix_windows_console``, except for the
+following differences:
+
+- It's not safe to call ``init`` multiple times; you can end up with multiple
+  layers of wrapping and broken ANSI support.
+
+- Colorama will apply a heuristic to guess whether stdout/stderr support ANSI,
+  and if it thinks they don't, then it will wrap ``sys.stdout`` and
+  ``sys.stderr`` in a magic file object that strips out ANSI escape sequences
+  before printing them. This happens on all platforms, and can be convenient if
+  you want to write your code to emit ANSI escape sequences unconditionally, and
+  let Colorama decide whether they should actually be output. But note that
+  Colorama's heuristic is not particularly clever.
+
+- ``init`` also accepts explicit keyword args to enable/disable various
+  functionality – see below.
+
+To stop using Colorama before your program exits, simply call ``deinit()``.
+This will restore ``stdout`` and ``stderr`` to their original values, so that
+Colorama is disabled. To resume using Colorama again, call ``reinit()``; it is
+cheaper than calling ``init()`` again (but does the same thing).
+
+Most users should depend on ``colorama >= 0.4.6``, and use
+``just_fix_windows_console``. The old ``init`` interface will be supported
+indefinitely for backwards compatibility, but we don't plan to fix any issues
+with it, also for backwards compatibility.
+
+Colored Output
+..............
+
+Cross-platform printing of colored text can then be done using Colorama's
+constant shorthand for ANSI escape sequences. These are deliberately
+rudimentary, see below.
+
+.. code-block:: python
+
+    from colorama import Fore, Back, Style
+    print(Fore.RED + 'some red text')
+    print(Back.GREEN + 'and with a green background')
+    print(Style.DIM + 'and in dim text')
+    print(Style.RESET_ALL)
+    print('back to normal now')
+
+...or simply by manually printing ANSI sequences from your own code:
+
+.. code-block:: python
+
+    print('\033[31m' + 'some red text')
+    print('\033[39m') # and reset to default color
+
+...or, Colorama can be used in conjunction with existing ANSI libraries
+such as the venerable `Termcolor <https://pypi.org/project/termcolor/>`_
+the fabulous `Blessings <https://pypi.org/project/blessings/>`_,
+or the incredible `_Rich <https://pypi.org/project/rich/>`_.
+
+If you wish Colorama's Fore, Back and Style constants were more capable,
+then consider using one of the above highly capable libraries to generate
+colors, etc, and use Colorama just for its primary purpose: to convert
+those ANSI sequences to also work on Windows:
+
+SIMILARLY, do not send PRs adding the generation of new ANSI types to Colorama.
+We are only interested in converting ANSI codes to win32 API calls, not
+shortcuts like the above to generate ANSI characters.
+
+.. code-block:: python
+
+    from colorama import just_fix_windows_console
+    from termcolor import colored
+
+    # use Colorama to make Termcolor work on Windows too
+    just_fix_windows_console()
+
+    # then use Termcolor for all colored text output
+    print(colored('Hello, World!', 'green', 'on_red'))
+
+Available formatting constants are::
+
+    Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
+    Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
+    Style: DIM, NORMAL, BRIGHT, RESET_ALL
+
+``Style.RESET_ALL`` resets foreground, background, and brightness. Colorama will
+perform this reset automatically on program exit.
+
+These are fairly well supported, but not part of the standard::
+
+    Fore: LIGHTBLACK_EX, LIGHTRED_EX, LIGHTGREEN_EX, LIGHTYELLOW_EX, LIGHTBLUE_EX, LIGHTMAGENTA_EX, LIGHTCYAN_EX, LIGHTWHITE_EX
+    Back: LIGHTBLACK_EX, LIGHTRED_EX, LIGHTGREEN_EX, LIGHTYELLOW_EX, LIGHTBLUE_EX, LIGHTMAGENTA_EX, LIGHTCYAN_EX, LIGHTWHITE_EX
+
+Cursor Positioning
+..................
+
+ANSI codes to reposition the cursor are supported. See ``demos/demo06.py`` for
+an example of how to generate them.
+
+Init Keyword Args
+.................
+
+``init()`` accepts some ``**kwargs`` to override default behaviour.
+
+init(autoreset=False):
+    If you find yourself repeatedly sending reset sequences to turn off color
+    changes at the end of every print, then ``init(autoreset=True)`` will
+    automate that:
+
+    .. code-block:: python
+
+        from colorama import init
+        init(autoreset=True)
+        print(Fore.RED + 'some red text')
+        print('automatically back to default color again')
+
+init(strip=None):
+    Pass ``True`` or ``False`` to override whether ANSI codes should be
+    stripped from the output. The default behaviour is to strip if on Windows
+    or if output is redirected (not a tty).
+
+init(convert=None):
+    Pass ``True`` or ``False`` to override whether to convert ANSI codes in the
+    output into win32 calls. The default behaviour is to convert if on Windows
+    and output is to a tty (terminal).
+
+init(wrap=True):
+    On Windows, Colorama works by replacing ``sys.stdout`` and ``sys.stderr``
+    with proxy objects, which override the ``.write()`` method to do their work.
+    If this wrapping causes you problems, then this can be disabled by passing
+    ``init(wrap=False)``. The default behaviour is to wrap if ``autoreset`` or
+    ``strip`` or ``convert`` are True.
+
+    When wrapping is disabled, colored printing on non-Windows platforms will
+    continue to work as normal. To do cross-platform colored output, you can
+    use Colorama's ``AnsiToWin32`` proxy directly:
+
+    .. code-block:: python
+
+        import sys
+        from colorama import init, AnsiToWin32
+        init(wrap=False)
+        stream = AnsiToWin32(sys.stderr).stream
+
+        # Python 2
+        print >>stream, Fore.BLUE + 'blue text on stderr'
+
+        # Python 3
+        print(Fore.BLUE + 'blue text on stderr', file=stream)
+
+Recognised ANSI Sequences
+.........................
+
+ANSI sequences generally take the form::
+
+    ESC [ <param> ; <param> ... <command>
+
+Where ``<param>`` is an integer, and ``<command>`` is a single letter. Zero or
+more params are passed to a ``<command>``. If no params are passed, it is
+generally synonymous with passing a single zero. No spaces exist in the
+sequence; they have been inserted here simply to read more easily.
+
+The only ANSI sequences that Colorama converts into win32 calls are::
+
+    ESC [ 0 m       # reset all (colors and brightness)
+    ESC [ 1 m       # bright
+    ESC [ 2 m       # dim (looks same as normal brightness)
+    ESC [ 22 m      # normal brightness
+
+    # FOREGROUND:
+    ESC [ 30 m      # black
+    ESC [ 31 m      # red
+    ESC [ 32 m      # green
+    ESC [ 33 m      # yellow
+    ESC [ 34 m      # blue
+    ESC [ 35 m      # magenta
+    ESC [ 36 m      # cyan
+    ESC [ 37 m      # white
+    ESC [ 39 m      # reset
+
+    # BACKGROUND
+    ESC [ 40 m      # black
+    ESC [ 41 m      # red
+    ESC [ 42 m      # green
+    ESC [ 43 m      # yellow
+    ESC [ 44 m      # blue
+    ESC [ 45 m      # magenta
+    ESC [ 46 m      # cyan
+    ESC [ 47 m      # white
+    ESC [ 49 m      # reset
+
+    # cursor positioning
+    ESC [ y;x H     # position cursor at x across, y down
+    ESC [ y;x f     # position cursor at x across, y down
+    ESC [ n A       # move cursor n lines up
+    ESC [ n B       # move cursor n lines down
+    ESC [ n C       # move cursor n characters forward
+    ESC [ n D       # move cursor n characters backward
+
+    # clear the screen
+    ESC [ mode J    # clear the screen
+
+    # clear the line
+    ESC [ mode K    # clear the line
+
+Multiple numeric params to the ``'m'`` command can be combined into a single
+sequence::
+
+    ESC [ 36 ; 45 ; 1 m     # bright cyan text on magenta background
+
+All other ANSI sequences of the form ``ESC [ <param> ; <param> ... <command>``
+are silently stripped from the output on Windows.
+
+Any other form of ANSI sequence, such as single-character codes or alternative
+initial characters, are not recognised or stripped. It would be cool to add
+them though. Let me know if it would be useful for you, via the Issues on
+GitHub.
+
+Status & Known Problems
+-----------------------
+
+I've personally only tested it on Windows XP (CMD, Console2), Ubuntu
+(gnome-terminal, xterm), and OS X.
+
+Some valid ANSI sequences aren't recognised.
+
+If you're hacking on the code, see `README-hacking.md`_. ESPECIALLY, see the
+explanation there of why we do not want PRs that allow Colorama to generate new
+types of ANSI codes.
+
+See outstanding issues and wish-list:
+https://github.com/tartley/colorama/issues
+
+If anything doesn't work for you, or doesn't do what you expected or hoped for,
+I'd love to hear about it on that issues list, would be delighted by patches,
+and would be happy to grant commit access to anyone who submits a working patch
+or two.
+
+.. _README-hacking.md: README-hacking.md
+
+License
+-------
+
+Copyright Jonathan Hartley & Arnon Yaari, 2013-2020. BSD 3-Clause license; see
+LICENSE file.
+
+Professional support
+--------------------
+
+.. |tideliftlogo| image:: https://cdn2.hubspot.net/hubfs/4008838/website/logos/logos_for_download/Tidelift_primary-shorthand-logo.png
+   :alt: Tidelift
+   :target: https://tidelift.com/subscription/pkg/pypi-colorama?utm_source=pypi-colorama&utm_medium=referral&utm_campaign=readme
+
+.. list-table::
+   :widths: 10 100
+
+   * - |tideliftlogo|
+     - Professional support for colorama is available as part of the
+       `Tidelift Subscription`_.
+       Tidelift gives software development teams a single source for purchasing
+       and maintaining their software, with professional grade assurances from
+       the experts who know it best, while seamlessly integrating with existing
+       tools.
+
+.. _Tidelift Subscription: https://tidelift.com/subscription/pkg/pypi-colorama?utm_source=pypi-colorama&utm_medium=referral&utm_campaign=readme
+
+Thanks
+------
+
+See the CHANGELOG for more thanks!
+
+* Marc Schlaich (schlamar) for a ``setup.py`` fix for Python2.5.
+* Marc Abramowitz, reported & fixed a crash on exit with closed ``stdout``,
+  providing a solution to issue #7's setuptools/distutils debate,
+  and other fixes.
+* User 'eryksun', for guidance on correctly instantiating ``ctypes.windll``.
+* Matthew McCormick for politely pointing out a longstanding crash on non-Win.
+* Ben Hoyt, for a magnificent fix under 64-bit Windows.
+* Jesse at Empty Square for submitting a fix for examples in the README.
+* User 'jamessp', an observant documentation fix for cursor positioning.
+* User 'vaal1239', Dave Mckee & Lackner Kristof for a tiny but much-needed Win7
+  fix.
+* Julien Stuyck, for wisely suggesting Python3 compatible updates to README.
+* Daniel Griffith for multiple fabulous patches.
+* Oscar Lesta for a valuable fix to stop ANSI chars being sent to non-tty
+  output.
+* Roger Binns, for many suggestions, valuable feedback, & bug reports.
+* Tim Golden for thought and much appreciated feedback on the initial idea.
+* User 'Zearin' for updates to the README file.
+* John Szakmeister for adding support for light colors
+* Charles Merriam for adding documentation to demos
+* Jurko for a fix on 64-bit Windows CPython2.5 w/o ctypes
+* Florian Bruhin for a fix when stdout or stderr are None
+* Thomas Weininger for fixing ValueError on Windows
+* Remi Rampin for better Github integration and fixes to the README file
+* Simeon Visser for closing a file handle using 'with' and updating classifiers
+  to include Python 3.3 and 3.4
+* Andy Neff for fixing RESET of LIGHT_EX colors.
+* Jonathan Hartley for the initial idea and implementation.
@@ -0,0 +1,31 @@
+colorama-0.4.6.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+colorama-0.4.6.dist-info/METADATA,sha256=e67SnrUMOym9sz_4TjF3vxvAV4T3aF7NyqRHHH3YEMw,17158
+colorama-0.4.6.dist-info/RECORD,,
+colorama-0.4.6.dist-info/WHEEL,sha256=cdcF4Fbd0FPtw2EMIOwH-3rSOTUdTCeOSXRMD1iLUb8,105
+colorama-0.4.6.dist-info/licenses/LICENSE.txt,sha256=ysNcAmhuXQSlpxQL-zs25zrtSWZW6JEQLkKIhteTAxg,1491
+colorama/__init__.py,sha256=wePQA4U20tKgYARySLEC047ucNX-g8pRLpYBuiHlLb8,266
+colorama/__pycache__/__init__.cpython-311.pyc,,
+colorama/__pycache__/ansi.cpython-311.pyc,,
+colorama/__pycache__/ansitowin32.cpython-311.pyc,,
+colorama/__pycache__/initialise.cpython-311.pyc,,
+colorama/__pycache__/win32.cpython-311.pyc,,
+colorama/__pycache__/winterm.cpython-311.pyc,,
+colorama/ansi.py,sha256=Top4EeEuaQdBWdteKMEcGOTeKeF19Q-Wo_6_Cj5kOzQ,2522
+colorama/ansitowin32.py,sha256=vPNYa3OZbxjbuFyaVo0Tmhmy1FZ1lKMWCnT7odXpItk,11128
+colorama/initialise.py,sha256=-hIny86ClXo39ixh5iSCfUIa2f_h_bgKRDW7gqs-KLU,3325
+colorama/tests/__init__.py,sha256=MkgPAEzGQd-Rq0w0PZXSX2LadRWhUECcisJY8lSrm4Q,75
+colorama/tests/__pycache__/__init__.cpython-311.pyc,,
+colorama/tests/__pycache__/ansi_test.cpython-311.pyc,,
+colorama/tests/__pycache__/ansitowin32_test.cpython-311.pyc,,
+colorama/tests/__pycache__/initialise_test.cpython-311.pyc,,
+colorama/tests/__pycache__/isatty_test.cpython-311.pyc,,
+colorama/tests/__pycache__/utils.cpython-311.pyc,,
+colorama/tests/__pycache__/winterm_test.cpython-311.pyc,,
+colorama/tests/ansi_test.py,sha256=FeViDrUINIZcr505PAxvU4AjXz1asEiALs9GXMhwRaE,2839
+colorama/tests/ansitowin32_test.py,sha256=RN7AIhMJ5EqDsYaCjVo-o4u8JzDD4ukJbmevWKS70rY,10678
+colorama/tests/initialise_test.py,sha256=BbPy-XfyHwJ6zKozuQOvNvQZzsx9vdb_0bYXn7hsBTc,6741
+colorama/tests/isatty_test.py,sha256=Pg26LRpv0yQDB5Ac-sxgVXG7hsA1NYvapFgApZfYzZg,1866
+colorama/tests/utils.py,sha256=1IIRylG39z5-dzq09R_ngufxyPZxgldNbrxKxUGwGKE,1079
+colorama/tests/winterm_test.py,sha256=qoWFPEjym5gm2RuMwpf3pOis3a5r_PJZFCzK254JL8A,3709
+colorama/win32.py,sha256=YQOKwMTwtGBbsY4dL5HYTvwTeP9wIQra5MvPNddpxZs,6181
+colorama/winterm.py,sha256=XCQFDHjPi6AHYNdZwy0tA02H-Jh48Jp-HvCjeLeLp3U,7134
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.11.1
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
@@ -0,0 +1,27 @@
+Copyright (c) 2010 Jonathan Hartley
+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 copyright holders, nor those 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 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.
@@ -0,0 +1,7 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+from .initialise import init, deinit, reinit, colorama_text, just_fix_windows_console
+from .ansi import Fore, Back, Style, Cursor
+from .ansitowin32 import AnsiToWin32
+
+__version__ = '0.4.6'
+
@@ -0,0 +1,102 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+'''
+This module generates ANSI character codes to printing colors to terminals.
+See: http://en.wikipedia.org/wiki/ANSI_escape_code
+'''
+
+CSI = '\033['
+OSC = '\033]'
+BEL = '\a'
+
+
+def code_to_chars(code):
+    return CSI + str(code) + 'm'
+
+def set_title(title):
+    return OSC + '2;' + title + BEL
+
+def clear_screen(mode=2):
+    return CSI + str(mode) + 'J'
+
+def clear_line(mode=2):
+    return CSI + str(mode) + 'K'
+
+
+class AnsiCodes(object):
+    def __init__(self):
+        # the subclasses declare class attributes which are numbers.
+        # Upon instantiation we define instance attributes, which are the same
+        # as the class attributes but wrapped with the ANSI escape sequence
+        for name in dir(self):
+            if not name.startswith('_'):
+                value = getattr(self, name)
+                setattr(self, name, code_to_chars(value))
+
+
+class AnsiCursor(object):
+    def UP(self, n=1):
+        return CSI + str(n) + 'A'
+    def DOWN(self, n=1):
+        return CSI + str(n) + 'B'
+    def FORWARD(self, n=1):
+        return CSI + str(n) + 'C'
+    def BACK(self, n=1):
+        return CSI + str(n) + 'D'
+    def POS(self, x=1, y=1):
+        return CSI + str(y) + ';' + str(x) + 'H'
+
+
+class AnsiFore(AnsiCodes):
+    BLACK           = 30
+    RED             = 31
+    GREEN           = 32
+    YELLOW          = 33
+    BLUE            = 34
+    MAGENTA         = 35
+    CYAN            = 36
+    WHITE           = 37
+    RESET           = 39
+
+    # These are fairly well supported, but not part of the standard.
+    LIGHTBLACK_EX   = 90
+    LIGHTRED_EX     = 91
+    LIGHTGREEN_EX   = 92
+    LIGHTYELLOW_EX  = 93
+    LIGHTBLUE_EX    = 94
+    LIGHTMAGENTA_EX = 95
+    LIGHTCYAN_EX    = 96
+    LIGHTWHITE_EX   = 97
+
+
+class AnsiBack(AnsiCodes):
+    BLACK           = 40
+    RED             = 41
+    GREEN           = 42
+    YELLOW          = 43
+    BLUE            = 44
+    MAGENTA         = 45
+    CYAN            = 46
+    WHITE           = 47
+    RESET           = 49
+
+    # These are fairly well supported, but not part of the standard.
+    LIGHTBLACK_EX   = 100
+    LIGHTRED_EX     = 101
+    LIGHTGREEN_EX   = 102
+    LIGHTYELLOW_EX  = 103
+    LIGHTBLUE_EX    = 104
+    LIGHTMAGENTA_EX = 105
+    LIGHTCYAN_EX    = 106
+    LIGHTWHITE_EX   = 107
+
+
+class AnsiStyle(AnsiCodes):
+    BRIGHT    = 1
+    DIM       = 2
+    NORMAL    = 22
+    RESET_ALL = 0
+
+Fore   = AnsiFore()
+Back   = AnsiBack()
+Style  = AnsiStyle()
+Cursor = AnsiCursor()
@@ -0,0 +1,277 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import re
+import sys
+import os
+
+from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style, BEL
+from .winterm import enable_vt_processing, WinTerm, WinColor, WinStyle
+from .win32 import windll, winapi_test
+
+
+winterm = None
+if windll is not None:
+    winterm = WinTerm()
+
+
+class StreamWrapper(object):
+    '''
+    Wraps a stream (such as stdout), acting as a transparent proxy for all
+    attribute access apart from method 'write()', which is delegated to our
+    Converter instance.
+    '''
+    def __init__(self, wrapped, converter):
+        # double-underscore everything to prevent clashes with names of
+        # attributes on the wrapped stream object.
+        self.__wrapped = wrapped
+        self.__convertor = converter
+
+    def __getattr__(self, name):
+        return getattr(self.__wrapped, name)
+
+    def __enter__(self, *args, **kwargs):
+        # special method lookup bypasses __getattr__/__getattribute__, see
+        # https://stackoverflow.com/questions/12632894/why-doesnt-getattr-work-with-exit
+        # thus, contextlib magic methods are not proxied via __getattr__
+        return self.__wrapped.__enter__(*args, **kwargs)
+
+    def __exit__(self, *args, **kwargs):
+        return self.__wrapped.__exit__(*args, **kwargs)
+
+    def __setstate__(self, state):
+        self.__dict__ = state
+
+    def __getstate__(self):
+        return self.__dict__
+
+    def write(self, text):
+        self.__convertor.write(text)
+
+    def isatty(self):
+        stream = self.__wrapped
+        if 'PYCHARM_HOSTED' in os.environ:
+            if stream is not None and (stream is sys.__stdout__ or stream is sys.__stderr__):
+                return True
+        try:
+            stream_isatty = stream.isatty
+        except AttributeError:
+            return False
+        else:
+            return stream_isatty()
+
+    @property
+    def closed(self):
+        stream = self.__wrapped
+        try:
+            return stream.closed
+        # AttributeError in the case that the stream doesn't support being closed
+        # ValueError for the case that the stream has already been detached when atexit runs
+        except (AttributeError, ValueError):
+            return True
+
+
+class AnsiToWin32(object):
+    '''
+    Implements a 'write()' method which, on Windows, will strip ANSI character
+    sequences from the text, and if outputting to a tty, will convert them into
+    win32 function calls.
+    '''
+    ANSI_CSI_RE = re.compile('\001?\033\\[((?:\\d|;)*)([a-zA-Z])\002?')   # Control Sequence Introducer
+    ANSI_OSC_RE = re.compile('\001?\033\\]([^\a]*)(\a)\002?')             # Operating System Command
+
+    def __init__(self, wrapped, convert=None, strip=None, autoreset=False):
+        # The wrapped stream (normally sys.stdout or sys.stderr)
+        self.wrapped = wrapped
+
+        # should we reset colors to defaults after every .write()
+        self.autoreset = autoreset
+
+        # create the proxy wrapping our output stream
+        self.stream = StreamWrapper(wrapped, self)
+
+        on_windows = os.name == 'nt'
+        # We test if the WinAPI works, because even if we are on Windows
+        # we may be using a terminal that doesn't support the WinAPI
+        # (e.g. Cygwin Terminal). In this case it's up to the terminal
+        # to support the ANSI codes.
+        conversion_supported = on_windows and winapi_test()
+        try:
+            fd = wrapped.fileno()
+        except Exception:
+            fd = -1
+        system_has_native_ansi = not on_windows or enable_vt_processing(fd)
+        have_tty = not self.stream.closed and self.stream.isatty()
+        need_conversion = conversion_supported and not system_has_native_ansi
+
+        # should we strip ANSI sequences from our output?
+        if strip is None:
+            strip = need_conversion or not have_tty
+        self.strip = strip
+
+        # should we should convert ANSI sequences into win32 calls?
+        if convert is None:
+            convert = need_conversion and have_tty
+        self.convert = convert
+
+        # dict of ansi codes to win32 functions and parameters
+        self.win32_calls = self.get_win32_calls()
+
+        # are we wrapping stderr?
+        self.on_stderr = self.wrapped is sys.stderr
+
+    def should_wrap(self):
+        '''
+        True if this class is actually needed. If false, then the output
+        stream will not be affected, nor will win32 calls be issued, so
+        wrapping stdout is not actually required. This will generally be
+        False on non-Windows platforms, unless optional functionality like
+        autoreset has been requested using kwargs to init()
+        '''
+        return self.convert or self.strip or self.autoreset
+
+    def get_win32_calls(self):
+        if self.convert and winterm:
+            return {
+                AnsiStyle.RESET_ALL: (winterm.reset_all, ),
+                AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT),
+                AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL),
+                AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL),
+                AnsiFore.BLACK: (winterm.fore, WinColor.BLACK),
+                AnsiFore.RED: (winterm.fore, WinColor.RED),
+                AnsiFore.GREEN: (winterm.fore, WinColor.GREEN),
+                AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW),
+                AnsiFore.BLUE: (winterm.fore, WinColor.BLUE),
+                AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA),
+                AnsiFore.CYAN: (winterm.fore, WinColor.CYAN),
+                AnsiFore.WHITE: (winterm.fore, WinColor.GREY),
+                AnsiFore.RESET: (winterm.fore, ),
+                AnsiFore.LIGHTBLACK_EX: (winterm.fore, WinColor.BLACK, True),
+                AnsiFore.LIGHTRED_EX: (winterm.fore, WinColor.RED, True),
+                AnsiFore.LIGHTGREEN_EX: (winterm.fore, WinColor.GREEN, True),
+                AnsiFore.LIGHTYELLOW_EX: (winterm.fore, WinColor.YELLOW, True),
+                AnsiFore.LIGHTBLUE_EX: (winterm.fore, WinColor.BLUE, True),
+                AnsiFore.LIGHTMAGENTA_EX: (winterm.fore, WinColor.MAGENTA, True),
+                AnsiFore.LIGHTCYAN_EX: (winterm.fore, WinColor.CYAN, True),
+                AnsiFore.LIGHTWHITE_EX: (winterm.fore, WinColor.GREY, True),
+                AnsiBack.BLACK: (winterm.back, WinColor.BLACK),
+                AnsiBack.RED: (winterm.back, WinColor.RED),
+                AnsiBack.GREEN: (winterm.back, WinColor.GREEN),
+                AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW),
+                AnsiBack.BLUE: (winterm.back, WinColor.BLUE),
+                AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA),
+                AnsiBack.CYAN: (winterm.back, WinColor.CYAN),
+                AnsiBack.WHITE: (winterm.back, WinColor.GREY),
+                AnsiBack.RESET: (winterm.back, ),
+                AnsiBack.LIGHTBLACK_EX: (winterm.back, WinColor.BLACK, True),
+                AnsiBack.LIGHTRED_EX: (winterm.back, WinColor.RED, True),
+                AnsiBack.LIGHTGREEN_EX: (winterm.back, WinColor.GREEN, True),
+                AnsiBack.LIGHTYELLOW_EX: (winterm.back, WinColor.YELLOW, True),
+                AnsiBack.LIGHTBLUE_EX: (winterm.back, WinColor.BLUE, True),
+                AnsiBack.LIGHTMAGENTA_EX: (winterm.back, WinColor.MAGENTA, True),
+                AnsiBack.LIGHTCYAN_EX: (winterm.back, WinColor.CYAN, True),
+                AnsiBack.LIGHTWHITE_EX: (winterm.back, WinColor.GREY, True),
+            }
+        return dict()
+
+    def write(self, text):
+        if self.strip or self.convert:
+            self.write_and_convert(text)
+        else:
+            self.wrapped.write(text)
+            self.wrapped.flush()
+        if self.autoreset:
+            self.reset_all()
+
+
+    def reset_all(self):
+        if self.convert:
+            self.call_win32('m', (0,))
+        elif not self.strip and not self.stream.closed:
+            self.wrapped.write(Style.RESET_ALL)
+
+
+    def write_and_convert(self, text):
+        '''
+        Write the given text to our wrapped stream, stripping any ANSI
+        sequences from the text, and optionally converting them into win32
+        calls.
+        '''
+        cursor = 0
+        text = self.convert_osc(text)
+        for match in self.ANSI_CSI_RE.finditer(text):
+            start, end = match.span()
+            self.write_plain_text(text, cursor, start)
+            self.convert_ansi(*match.groups())
+            cursor = end
+        self.write_plain_text(text, cursor, len(text))
+
+
+    def write_plain_text(self, text, start, end):
+        if start < end:
+            self.wrapped.write(text[start:end])
+            self.wrapped.flush()
+
+
+    def convert_ansi(self, paramstring, command):
+        if self.convert:
+            params = self.extract_params(command, paramstring)
+            self.call_win32(command, params)
+
+
+    def extract_params(self, command, paramstring):
+        if command in 'Hf':
+            params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(';'))
+            while len(params) < 2:
+                # defaults:
+                params = params + (1,)
+        else:
+            params = tuple(int(p) for p in paramstring.split(';') if len(p) != 0)
+            if len(params) == 0:
+                # defaults:
+                if command in 'JKm':
+                    params = (0,)
+                elif command in 'ABCD':
+                    params = (1,)
+
+        return params
+
+
+    def call_win32(self, command, params):
+        if command == 'm':
+            for param in params:
+                if param in self.win32_calls:
+                    func_args = self.win32_calls[param]
+                    func = func_args[0]
+                    args = func_args[1:]
+                    kwargs = dict(on_stderr=self.on_stderr)
+                    func(*args, **kwargs)
+        elif command in 'J':
+            winterm.erase_screen(params[0], on_stderr=self.on_stderr)
+        elif command in 'K':
+            winterm.erase_line(params[0], on_stderr=self.on_stderr)
+        elif command in 'Hf':     # cursor position - absolute
+            winterm.set_cursor_position(params, on_stderr=self.on_stderr)
+        elif command in 'ABCD':   # cursor position - relative
+            n = params[0]
+            # A - up, B - down, C - forward, D - back
+            x, y = {'A': (0, -n), 'B': (0, n), 'C': (n, 0), 'D': (-n, 0)}[command]
+            winterm.cursor_adjust(x, y, on_stderr=self.on_stderr)
+
+
+    def convert_osc(self, text):
+        for match in self.ANSI_OSC_RE.finditer(text):
+            start, end = match.span()
+            text = text[:start] + text[end:]
+            paramstring, command = match.groups()
+            if command == BEL:
+                if paramstring.count(";") == 1:
+                    params = paramstring.split(";")
+                    # 0 - change title and icon (we will only change title)
+                    # 1 - change icon (we don't support this)
+                    # 2 - change title
+                    if params[0] in '02':
+                        winterm.set_title(params[1])
+        return text
+
+
+    def flush(self):
+        self.wrapped.flush()
@@ -0,0 +1,121 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import atexit
+import contextlib
+import sys
+
+from .ansitowin32 import AnsiToWin32
+
+
+def _wipe_internal_state_for_tests():
+    global orig_stdout, orig_stderr
+    orig_stdout = None
+    orig_stderr = None
+
+    global wrapped_stdout, wrapped_stderr
+    wrapped_stdout = None
+    wrapped_stderr = None
+
+    global atexit_done
+    atexit_done = False
+
+    global fixed_windows_console
+    fixed_windows_console = False
+
+    try:
+        # no-op if it wasn't registered
+        atexit.unregister(reset_all)
+    except AttributeError:
+        # python 2: no atexit.unregister. Oh well, we did our best.
+        pass
+
+
+def reset_all():
+    if AnsiToWin32 is not None:    # Issue #74: objects might become None at exit
+        AnsiToWin32(orig_stdout).reset_all()
+
+
+def init(autoreset=False, convert=None, strip=None, wrap=True):
+
+    if not wrap and any([autoreset, convert, strip]):
+        raise ValueError('wrap=False conflicts with any other arg=True')
+
+    global wrapped_stdout, wrapped_stderr
+    global orig_stdout, orig_stderr
+
+    orig_stdout = sys.stdout
+    orig_stderr = sys.stderr
+
+    if sys.stdout is None:
+        wrapped_stdout = None
+    else:
+        sys.stdout = wrapped_stdout = \
+            wrap_stream(orig_stdout, convert, strip, autoreset, wrap)
+    if sys.stderr is None:
+        wrapped_stderr = None
+    else:
+        sys.stderr = wrapped_stderr = \
+            wrap_stream(orig_stderr, convert, strip, autoreset, wrap)
+
+    global atexit_done
+    if not atexit_done:
+        atexit.register(reset_all)
+        atexit_done = True
+
+
+def deinit():
+    if orig_stdout is not None:
+        sys.stdout = orig_stdout
+    if orig_stderr is not None:
+        sys.stderr = orig_stderr
+
+
+def just_fix_windows_console():
+    global fixed_windows_console
+
+    if sys.platform != "win32":
+        return
+    if fixed_windows_console:
+        return
+    if wrapped_stdout is not None or wrapped_stderr is not None:
+        # Someone already ran init() and it did stuff, so we won't second-guess them
+        return
+
+    # On newer versions of Windows, AnsiToWin32.__init__ will implicitly enable the
+    # native ANSI support in the console as a side-effect. We only need to actually
+    # replace sys.stdout/stderr if we're in the old-style conversion mode.
+    new_stdout = AnsiToWin32(sys.stdout, convert=None, strip=None, autoreset=False)
+    if new_stdout.convert:
+        sys.stdout = new_stdout
+    new_stderr = AnsiToWin32(sys.stderr, convert=None, strip=None, autoreset=False)
+    if new_stderr.convert:
+        sys.stderr = new_stderr
+
+    fixed_windows_console = True
+
+@contextlib.contextmanager
+def colorama_text(*args, **kwargs):
+    init(*args, **kwargs)
+    try:
+        yield
+    finally:
+        deinit()
+
+
+def reinit():
+    if wrapped_stdout is not None:
+        sys.stdout = wrapped_stdout
+    if wrapped_stderr is not None:
+        sys.stderr = wrapped_stderr
+
+
+def wrap_stream(stream, convert, strip, autoreset, wrap):
+    if wrap:
+        wrapper = AnsiToWin32(stream,
+            convert=convert, strip=strip, autoreset=autoreset)
+        if wrapper.should_wrap():
+            stream = wrapper.stream
+    return stream
+
+
+# Use this for initial setup as well, to reduce code duplication
+_wipe_internal_state_for_tests()
@@ -0,0 +1 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
@@ -0,0 +1,76 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import sys
+from unittest import TestCase, main
+
+from ..ansi import Back, Fore, Style
+from ..ansitowin32 import AnsiToWin32
+
+stdout_orig = sys.stdout
+stderr_orig = sys.stderr
+
+
+class AnsiTest(TestCase):
+
+    def setUp(self):
+        # sanity check: stdout should be a file or StringIO object.
+        # It will only be AnsiToWin32 if init() has previously wrapped it
+        self.assertNotEqual(type(sys.stdout), AnsiToWin32)
+        self.assertNotEqual(type(sys.stderr), AnsiToWin32)
+
+    def tearDown(self):
+        sys.stdout = stdout_orig
+        sys.stderr = stderr_orig
+
+
+    def testForeAttributes(self):
+        self.assertEqual(Fore.BLACK, '\033[30m')
+        self.assertEqual(Fore.RED, '\033[31m')
+        self.assertEqual(Fore.GREEN, '\033[32m')
+        self.assertEqual(Fore.YELLOW, '\033[33m')
+        self.assertEqual(Fore.BLUE, '\033[34m')
+        self.assertEqual(Fore.MAGENTA, '\033[35m')
+        self.assertEqual(Fore.CYAN, '\033[36m')
+        self.assertEqual(Fore.WHITE, '\033[37m')
+        self.assertEqual(Fore.RESET, '\033[39m')
+
+        # Check the light, extended versions.
+        self.assertEqual(Fore.LIGHTBLACK_EX, '\033[90m')
+        self.assertEqual(Fore.LIGHTRED_EX, '\033[91m')
+        self.assertEqual(Fore.LIGHTGREEN_EX, '\033[92m')
+        self.assertEqual(Fore.LIGHTYELLOW_EX, '\033[93m')
+        self.assertEqual(Fore.LIGHTBLUE_EX, '\033[94m')
+        self.assertEqual(Fore.LIGHTMAGENTA_EX, '\033[95m')
+        self.assertEqual(Fore.LIGHTCYAN_EX, '\033[96m')
+        self.assertEqual(Fore.LIGHTWHITE_EX, '\033[97m')
+
+
+    def testBackAttributes(self):
+        self.assertEqual(Back.BLACK, '\033[40m')
+        self.assertEqual(Back.RED, '\033[41m')
+        self.assertEqual(Back.GREEN, '\033[42m')
+        self.assertEqual(Back.YELLOW, '\033[43m')
+        self.assertEqual(Back.BLUE, '\033[44m')
+        self.assertEqual(Back.MAGENTA, '\033[45m')
+        self.assertEqual(Back.CYAN, '\033[46m')
+        self.assertEqual(Back.WHITE, '\033[47m')
+        self.assertEqual(Back.RESET, '\033[49m')
+
+        # Check the light, extended versions.
+        self.assertEqual(Back.LIGHTBLACK_EX, '\033[100m')
+        self.assertEqual(Back.LIGHTRED_EX, '\033[101m')
+        self.assertEqual(Back.LIGHTGREEN_EX, '\033[102m')
+        self.assertEqual(Back.LIGHTYELLOW_EX, '\033[103m')
+        self.assertEqual(Back.LIGHTBLUE_EX, '\033[104m')
+        self.assertEqual(Back.LIGHTMAGENTA_EX, '\033[105m')
+        self.assertEqual(Back.LIGHTCYAN_EX, '\033[106m')
+        self.assertEqual(Back.LIGHTWHITE_EX, '\033[107m')
+
+
+    def testStyleAttributes(self):
+        self.assertEqual(Style.DIM, '\033[2m')
+        self.assertEqual(Style.NORMAL, '\033[22m')
+        self.assertEqual(Style.BRIGHT, '\033[1m')
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,294 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+from io import StringIO, TextIOWrapper
+from unittest import TestCase, main
+try:
+    from contextlib import ExitStack
+except ImportError:
+    # python 2
+    from contextlib2 import ExitStack
+
+try:
+    from unittest.mock import MagicMock, Mock, patch
+except ImportError:
+    from mock import MagicMock, Mock, patch
+
+from ..ansitowin32 import AnsiToWin32, StreamWrapper
+from ..win32 import ENABLE_VIRTUAL_TERMINAL_PROCESSING
+from .utils import osname
+
+
+class StreamWrapperTest(TestCase):
+
+    def testIsAProxy(self):
+        mockStream = Mock()
+        wrapper = StreamWrapper(mockStream, None)
+        self.assertTrue( wrapper.random_attr is mockStream.random_attr )
+
+    def testDelegatesWrite(self):
+        mockStream = Mock()
+        mockConverter = Mock()
+        wrapper = StreamWrapper(mockStream, mockConverter)
+        wrapper.write('hello')
+        self.assertTrue(mockConverter.write.call_args, (('hello',), {}))
+
+    def testDelegatesContext(self):
+        mockConverter = Mock()
+        s = StringIO()
+        with StreamWrapper(s, mockConverter) as fp:
+            fp.write(u'hello')
+        self.assertTrue(s.closed)
+
+    def testProxyNoContextManager(self):
+        mockStream = MagicMock()
+        mockStream.__enter__.side_effect = AttributeError()
+        mockConverter = Mock()
+        with self.assertRaises(AttributeError) as excinfo:
+            with StreamWrapper(mockStream, mockConverter) as wrapper:
+                wrapper.write('hello')
+
+    def test_closed_shouldnt_raise_on_closed_stream(self):
+        stream = StringIO()
+        stream.close()
+        wrapper = StreamWrapper(stream, None)
+        self.assertEqual(wrapper.closed, True)
+
+    def test_closed_shouldnt_raise_on_detached_stream(self):
+        stream = TextIOWrapper(StringIO())
+        stream.detach()
+        wrapper = StreamWrapper(stream, None)
+        self.assertEqual(wrapper.closed, True)
+
+class AnsiToWin32Test(TestCase):
+
+    def testInit(self):
+        mockStdout = Mock()
+        auto = Mock()
+        stream = AnsiToWin32(mockStdout, autoreset=auto)
+        self.assertEqual(stream.wrapped, mockStdout)
+        self.assertEqual(stream.autoreset, auto)
+
+    @patch('colorama.ansitowin32.winterm', None)
+    @patch('colorama.ansitowin32.winapi_test', lambda *_: True)
+    def testStripIsTrueOnWindows(self):
+        with osname('nt'):
+            mockStdout = Mock()
+            stream = AnsiToWin32(mockStdout)
+            self.assertTrue(stream.strip)
+
+    def testStripIsFalseOffWindows(self):
+        with osname('posix'):
+            mockStdout = Mock(closed=False)
+            stream = AnsiToWin32(mockStdout)
+            self.assertFalse(stream.strip)
+
+    def testWriteStripsAnsi(self):
+        mockStdout = Mock()
+        stream = AnsiToWin32(mockStdout)
+        stream.wrapped = Mock()
+        stream.write_and_convert = Mock()
+        stream.strip = True
+
+        stream.write('abc')
+
+        self.assertFalse(stream.wrapped.write.called)
+        self.assertEqual(stream.write_and_convert.call_args, (('abc',), {}))
+
+    def testWriteDoesNotStripAnsi(self):
+        mockStdout = Mock()
+        stream = AnsiToWin32(mockStdout)
+        stream.wrapped = Mock()
+        stream.write_and_convert = Mock()
+        stream.strip = False
+        stream.convert = False
+
+        stream.write('abc')
+
+        self.assertFalse(stream.write_and_convert.called)
+        self.assertEqual(stream.wrapped.write.call_args, (('abc',), {}))
+
+    def assert_autoresets(self, convert, autoreset=True):
+        stream = AnsiToWin32(Mock())
+        stream.convert = convert
+        stream.reset_all = Mock()
+        stream.autoreset = autoreset
+        stream.winterm = Mock()
+
+        stream.write('abc')
+
+        self.assertEqual(stream.reset_all.called, autoreset)
+
+    def testWriteAutoresets(self):
+        self.assert_autoresets(convert=True)
+        self.assert_autoresets(convert=False)
+        self.assert_autoresets(convert=True, autoreset=False)
+        self.assert_autoresets(convert=False, autoreset=False)
+
+    def testWriteAndConvertWritesPlainText(self):
+        stream = AnsiToWin32(Mock())
+        stream.write_and_convert( 'abc' )
+        self.assertEqual( stream.wrapped.write.call_args, (('abc',), {}) )
+
+    def testWriteAndConvertStripsAllValidAnsi(self):
+        stream = AnsiToWin32(Mock())
+        stream.call_win32 = Mock()
+        data = [
+            'abc\033[mdef',
+            'abc\033[0mdef',
+            'abc\033[2mdef',
+            'abc\033[02mdef',
+            'abc\033[002mdef',
+            'abc\033[40mdef',
+            'abc\033[040mdef',
+            'abc\033[0;1mdef',
+            'abc\033[40;50mdef',
+            'abc\033[50;30;40mdef',
+            'abc\033[Adef',
+            'abc\033[0Gdef',
+            'abc\033[1;20;128Hdef',
+        ]
+        for datum in data:
+            stream.wrapped.write.reset_mock()
+            stream.write_and_convert( datum )
+            self.assertEqual(
+               [args[0] for args in stream.wrapped.write.call_args_list],
+               [ ('abc',), ('def',) ]
+            )
+
+    def testWriteAndConvertSkipsEmptySnippets(self):
+        stream = AnsiToWin32(Mock())
+        stream.call_win32 = Mock()
+        stream.write_and_convert( '\033[40m\033[41m' )
+        self.assertFalse( stream.wrapped.write.called )
+
+    def testWriteAndConvertCallsWin32WithParamsAndCommand(self):
+        stream = AnsiToWin32(Mock())
+        stream.convert = True
+        stream.call_win32 = Mock()
+        stream.extract_params = Mock(return_value='params')
+        data = {
+            'abc\033[adef':         ('a', 'params'),
+            'abc\033[;;bdef':       ('b', 'params'),
+            'abc\033[0cdef':        ('c', 'params'),
+            'abc\033[;;0;;Gdef':    ('G', 'params'),
+            'abc\033[1;20;128Hdef': ('H', 'params'),
+        }
+        for datum, expected in data.items():
+            stream.call_win32.reset_mock()
+            stream.write_and_convert( datum )
+            self.assertEqual( stream.call_win32.call_args[0], expected )
+
+    def test_reset_all_shouldnt_raise_on_closed_orig_stdout(self):
+        stream = StringIO()
+        converter = AnsiToWin32(stream)
+        stream.close()
+
+        converter.reset_all()
+
+    def test_wrap_shouldnt_raise_on_closed_orig_stdout(self):
+        stream = StringIO()
+        stream.close()
+        with \
+            patch("colorama.ansitowin32.os.name", "nt"), \
+            patch("colorama.ansitowin32.winapi_test", lambda: True):
+                converter = AnsiToWin32(stream)
+        self.assertTrue(converter.strip)
+        self.assertFalse(converter.convert)
+
+    def test_wrap_shouldnt_raise_on_missing_closed_attr(self):
+        with \
+            patch("colorama.ansitowin32.os.name", "nt"), \
+            patch("colorama.ansitowin32.winapi_test", lambda: True):
+                converter = AnsiToWin32(object())
+        self.assertTrue(converter.strip)
+        self.assertFalse(converter.convert)
+
+    def testExtractParams(self):
+        stream = AnsiToWin32(Mock())
+        data = {
+            '':               (0,),
+            ';;':             (0,),
+            '2':              (2,),
+            ';;002;;':        (2,),
+            '0;1':            (0, 1),
+            ';;003;;456;;':   (3, 456),
+            '11;22;33;44;55': (11, 22, 33, 44, 55),
+        }
+        for datum, expected in data.items():
+            self.assertEqual(stream.extract_params('m', datum), expected)
+
+    def testCallWin32UsesLookup(self):
+        listener = Mock()
+        stream = AnsiToWin32(listener)
+        stream.win32_calls = {
+            1: (lambda *_, **__: listener(11),),
+            2: (lambda *_, **__: listener(22),),
+            3: (lambda *_, **__: listener(33),),
+        }
+        stream.call_win32('m', (3, 1, 99, 2))
+        self.assertEqual(
+            [a[0][0] for a in listener.call_args_list],
+            [33, 11, 22] )
+
+    def test_osc_codes(self):
+        mockStdout = Mock()
+        stream = AnsiToWin32(mockStdout, convert=True)
+        with patch('colorama.ansitowin32.winterm') as winterm:
+            data = [
+                '\033]0\x07',                      # missing arguments
+                '\033]0;foo\x08',                  # wrong OSC command
+                '\033]0;colorama_test_title\x07',  # should work
+                '\033]1;colorama_test_title\x07',  # wrong set command
+                '\033]2;colorama_test_title\x07',  # should work
+                '\033]' + ';' * 64 + '\x08',       # see issue #247
+            ]
+            for code in data:
+                stream.write(code)
+            self.assertEqual(winterm.set_title.call_count, 2)
+
+    def test_native_windows_ansi(self):
+        with ExitStack() as stack:
+            def p(a, b):
+                stack.enter_context(patch(a, b, create=True))
+            # Pretend to be on Windows
+            p("colorama.ansitowin32.os.name", "nt")
+            p("colorama.ansitowin32.winapi_test", lambda: True)
+            p("colorama.win32.winapi_test", lambda: True)
+            p("colorama.winterm.win32.windll", "non-None")
+            p("colorama.winterm.get_osfhandle", lambda _: 1234)
+
+            # Pretend that our mock stream has native ANSI support
+            p(
+                "colorama.winterm.win32.GetConsoleMode",
+                lambda _: ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+            )
+            SetConsoleMode = Mock()
+            p("colorama.winterm.win32.SetConsoleMode", SetConsoleMode)
+
+            stdout = Mock()
+            stdout.closed = False
+            stdout.isatty.return_value = True
+            stdout.fileno.return_value = 1
+
+            # Our fake console says it has native vt support, so AnsiToWin32 should
+            # enable that support and do nothing else.
+            stream = AnsiToWin32(stdout)
+            SetConsoleMode.assert_called_with(1234, ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+            self.assertFalse(stream.strip)
+            self.assertFalse(stream.convert)
+            self.assertFalse(stream.should_wrap())
+
+            # Now let's pretend we're on an old Windows console, that doesn't have
+            # native ANSI support.
+            p("colorama.winterm.win32.GetConsoleMode", lambda _: 0)
+            SetConsoleMode = Mock()
+            p("colorama.winterm.win32.SetConsoleMode", SetConsoleMode)
+
+            stream = AnsiToWin32(stdout)
+            SetConsoleMode.assert_called_with(1234, ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+            self.assertTrue(stream.strip)
+            self.assertTrue(stream.convert)
+            self.assertTrue(stream.should_wrap())
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,189 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import sys
+from unittest import TestCase, main, skipUnless
+
+try:
+    from unittest.mock import patch, Mock
+except ImportError:
+    from mock import patch, Mock
+
+from ..ansitowin32 import StreamWrapper
+from ..initialise import init, just_fix_windows_console, _wipe_internal_state_for_tests
+from .utils import osname, replace_by
+
+orig_stdout = sys.stdout
+orig_stderr = sys.stderr
+
+
+class InitTest(TestCase):
+
+    @skipUnless(sys.stdout.isatty(), "sys.stdout is not a tty")
+    def setUp(self):
+        # sanity check
+        self.assertNotWrapped()
+
+    def tearDown(self):
+        _wipe_internal_state_for_tests()
+        sys.stdout = orig_stdout
+        sys.stderr = orig_stderr
+
+    def assertWrapped(self):
+        self.assertIsNot(sys.stdout, orig_stdout, 'stdout should be wrapped')
+        self.assertIsNot(sys.stderr, orig_stderr, 'stderr should be wrapped')
+        self.assertTrue(isinstance(sys.stdout, StreamWrapper),
+            'bad stdout wrapper')
+        self.assertTrue(isinstance(sys.stderr, StreamWrapper),
+            'bad stderr wrapper')
+
+    def assertNotWrapped(self):
+        self.assertIs(sys.stdout, orig_stdout, 'stdout should not be wrapped')
+        self.assertIs(sys.stderr, orig_stderr, 'stderr should not be wrapped')
+
+    @patch('colorama.initialise.reset_all')
+    @patch('colorama.ansitowin32.winapi_test', lambda *_: True)
+    @patch('colorama.ansitowin32.enable_vt_processing', lambda *_: False)
+    def testInitWrapsOnWindows(self, _):
+        with osname("nt"):
+            init()
+            self.assertWrapped()
+
+    @patch('colorama.initialise.reset_all')
+    @patch('colorama.ansitowin32.winapi_test', lambda *_: False)
+    def testInitDoesntWrapOnEmulatedWindows(self, _):
+        with osname("nt"):
+            init()
+            self.assertNotWrapped()
+
+    def testInitDoesntWrapOnNonWindows(self):
+        with osname("posix"):
+            init()
+            self.assertNotWrapped()
+
+    def testInitDoesntWrapIfNone(self):
+        with replace_by(None):
+            init()
+            # We can't use assertNotWrapped here because replace_by(None)
+            # changes stdout/stderr already.
+            self.assertIsNone(sys.stdout)
+            self.assertIsNone(sys.stderr)
+
+    def testInitAutoresetOnWrapsOnAllPlatforms(self):
+        with osname("posix"):
+            init(autoreset=True)
+            self.assertWrapped()
+
+    def testInitWrapOffDoesntWrapOnWindows(self):
+        with osname("nt"):
+            init(wrap=False)
+            self.assertNotWrapped()
+
+    def testInitWrapOffIncompatibleWithAutoresetOn(self):
+        self.assertRaises(ValueError, lambda: init(autoreset=True, wrap=False))
+
+    @patch('colorama.win32.SetConsoleTextAttribute')
+    @patch('colorama.initialise.AnsiToWin32')
+    def testAutoResetPassedOn(self, mockATW32, _):
+        with osname("nt"):
+            init(autoreset=True)
+            self.assertEqual(len(mockATW32.call_args_list), 2)
+            self.assertEqual(mockATW32.call_args_list[1][1]['autoreset'], True)
+            self.assertEqual(mockATW32.call_args_list[0][1]['autoreset'], True)
+
+    @patch('colorama.initialise.AnsiToWin32')
+    def testAutoResetChangeable(self, mockATW32):
+        with osname("nt"):
+            init()
+
+            init(autoreset=True)
+            self.assertEqual(len(mockATW32.call_args_list), 4)
+            self.assertEqual(mockATW32.call_args_list[2][1]['autoreset'], True)
+            self.assertEqual(mockATW32.call_args_list[3][1]['autoreset'], True)
+
+            init()
+            self.assertEqual(len(mockATW32.call_args_list), 6)
+            self.assertEqual(
+                mockATW32.call_args_list[4][1]['autoreset'], False)
+            self.assertEqual(
+                mockATW32.call_args_list[5][1]['autoreset'], False)
+
+
+    @patch('colorama.initialise.atexit.register')
+    def testAtexitRegisteredOnlyOnce(self, mockRegister):
+        init()
+        self.assertTrue(mockRegister.called)
+        mockRegister.reset_mock()
+        init()
+        self.assertFalse(mockRegister.called)
+
+
+class JustFixWindowsConsoleTest(TestCase):
+    def _reset(self):
+        _wipe_internal_state_for_tests()
+        sys.stdout = orig_stdout
+        sys.stderr = orig_stderr
+
+    def tearDown(self):
+        self._reset()
+
+    @patch("colorama.ansitowin32.winapi_test", lambda: True)
+    def testJustFixWindowsConsole(self):
+        if sys.platform != "win32":
+            # just_fix_windows_console should be a no-op
+            just_fix_windows_console()
+            self.assertIs(sys.stdout, orig_stdout)
+            self.assertIs(sys.stderr, orig_stderr)
+        else:
+            def fake_std():
+                # Emulate stdout=not a tty, stderr=tty
+                # to check that we handle both cases correctly
+                stdout = Mock()
+                stdout.closed = False
+                stdout.isatty.return_value = False
+                stdout.fileno.return_value = 1
+                sys.stdout = stdout
+
+                stderr = Mock()
+                stderr.closed = False
+                stderr.isatty.return_value = True
+                stderr.fileno.return_value = 2
+                sys.stderr = stderr
+
+            for native_ansi in [False, True]:
+                with patch(
+                    'colorama.ansitowin32.enable_vt_processing',
+                    lambda *_: native_ansi
+                ):
+                    self._reset()
+                    fake_std()
+
+                    # Regular single-call test
+                    prev_stdout = sys.stdout
+                    prev_stderr = sys.stderr
+                    just_fix_windows_console()
+                    self.assertIs(sys.stdout, prev_stdout)
+                    if native_ansi:
+                        self.assertIs(sys.stderr, prev_stderr)
+                    else:
+                        self.assertIsNot(sys.stderr, prev_stderr)
+
+                    # second call without resetting is always a no-op
+                    prev_stdout = sys.stdout
+                    prev_stderr = sys.stderr
+                    just_fix_windows_console()
+                    self.assertIs(sys.stdout, prev_stdout)
+                    self.assertIs(sys.stderr, prev_stderr)
+
+                    self._reset()
+                    fake_std()
+
+                    # If init() runs first, just_fix_windows_console should be a no-op
+                    init()
+                    prev_stdout = sys.stdout
+                    prev_stderr = sys.stderr
+                    just_fix_windows_console()
+                    self.assertIs(prev_stdout, sys.stdout)
+                    self.assertIs(prev_stderr, sys.stderr)
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,57 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import sys
+from unittest import TestCase, main
+
+from ..ansitowin32 import StreamWrapper, AnsiToWin32
+from .utils import pycharm, replace_by, replace_original_by, StreamTTY, StreamNonTTY
+
+
+def is_a_tty(stream):
+    return StreamWrapper(stream, None).isatty()
+
+class IsattyTest(TestCase):
+
+    def test_TTY(self):
+        tty = StreamTTY()
+        self.assertTrue(is_a_tty(tty))
+        with pycharm():
+            self.assertTrue(is_a_tty(tty))
+
+    def test_nonTTY(self):
+        non_tty = StreamNonTTY()
+        self.assertFalse(is_a_tty(non_tty))
+        with pycharm():
+            self.assertFalse(is_a_tty(non_tty))
+
+    def test_withPycharm(self):
+        with pycharm():
+            self.assertTrue(is_a_tty(sys.stderr))
+            self.assertTrue(is_a_tty(sys.stdout))
+
+    def test_withPycharmTTYOverride(self):
+        tty = StreamTTY()
+        with pycharm(), replace_by(tty):
+            self.assertTrue(is_a_tty(tty))
+
+    def test_withPycharmNonTTYOverride(self):
+        non_tty = StreamNonTTY()
+        with pycharm(), replace_by(non_tty):
+            self.assertFalse(is_a_tty(non_tty))
+
+    def test_withPycharmNoneOverride(self):
+        with pycharm():
+            with replace_by(None), replace_original_by(None):
+                self.assertFalse(is_a_tty(None))
+                self.assertFalse(is_a_tty(StreamNonTTY()))
+                self.assertTrue(is_a_tty(StreamTTY()))
+
+    def test_withPycharmStreamWrapped(self):
+        with pycharm():
+            self.assertTrue(AnsiToWin32(StreamTTY()).stream.isatty())
+            self.assertFalse(AnsiToWin32(StreamNonTTY()).stream.isatty())
+            self.assertTrue(AnsiToWin32(sys.stdout).stream.isatty())
+            self.assertTrue(AnsiToWin32(sys.stderr).stream.isatty())
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,49 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+from contextlib import contextmanager
+from io import StringIO
+import sys
+import os
+
+
+class StreamTTY(StringIO):
+    def isatty(self):
+        return True
+
+class StreamNonTTY(StringIO):
+    def isatty(self):
+        return False
+
+@contextmanager
+def osname(name):
+    orig = os.name
+    os.name = name
+    yield
+    os.name = orig
+
+@contextmanager
+def replace_by(stream):
+    orig_stdout = sys.stdout
+    orig_stderr = sys.stderr
+    sys.stdout = stream
+    sys.stderr = stream
+    yield
+    sys.stdout = orig_stdout
+    sys.stderr = orig_stderr
+
+@contextmanager
+def replace_original_by(stream):
+    orig_stdout = sys.__stdout__
+    orig_stderr = sys.__stderr__
+    sys.__stdout__ = stream
+    sys.__stderr__ = stream
+    yield
+    sys.__stdout__ = orig_stdout
+    sys.__stderr__ = orig_stderr
+
+@contextmanager
+def pycharm():
+    os.environ["PYCHARM_HOSTED"] = "1"
+    non_tty = StreamNonTTY()
+    with replace_by(non_tty), replace_original_by(non_tty):
+        yield
+    del os.environ["PYCHARM_HOSTED"]
@@ -0,0 +1,131 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+import sys
+from unittest import TestCase, main, skipUnless
+
+try:
+    from unittest.mock import Mock, patch
+except ImportError:
+    from mock import Mock, patch
+
+from ..winterm import WinColor, WinStyle, WinTerm
+
+
+class WinTermTest(TestCase):
+
+    @patch('colorama.winterm.win32')
+    def testInit(self, mockWin32):
+        mockAttr = Mock()
+        mockAttr.wAttributes = 7 + 6 * 16 + 8
+        mockWin32.GetConsoleScreenBufferInfo.return_value = mockAttr
+        term = WinTerm()
+        self.assertEqual(term._fore, 7)
+        self.assertEqual(term._back, 6)
+        self.assertEqual(term._style, 8)
+
+    @skipUnless(sys.platform.startswith("win"), "requires Windows")
+    def testGetAttrs(self):
+        term = WinTerm()
+
+        term._fore = 0
+        term._back = 0
+        term._style = 0
+        self.assertEqual(term.get_attrs(), 0)
+
+        term._fore = WinColor.YELLOW
+        self.assertEqual(term.get_attrs(), WinColor.YELLOW)
+
+        term._back = WinColor.MAGENTA
+        self.assertEqual(
+            term.get_attrs(),
+            WinColor.YELLOW + WinColor.MAGENTA * 16)
+
+        term._style = WinStyle.BRIGHT
+        self.assertEqual(
+            term.get_attrs(),
+            WinColor.YELLOW + WinColor.MAGENTA * 16 + WinStyle.BRIGHT)
+
+    @patch('colorama.winterm.win32')
+    def testResetAll(self, mockWin32):
+        mockAttr = Mock()
+        mockAttr.wAttributes = 1 + 2 * 16 + 8
+        mockWin32.GetConsoleScreenBufferInfo.return_value = mockAttr
+        term = WinTerm()
+
+        term.set_console = Mock()
+        term._fore = -1
+        term._back = -1
+        term._style = -1
+
+        term.reset_all()
+
+        self.assertEqual(term._fore, 1)
+        self.assertEqual(term._back, 2)
+        self.assertEqual(term._style, 8)
+        self.assertEqual(term.set_console.called, True)
+
+    @skipUnless(sys.platform.startswith("win"), "requires Windows")
+    def testFore(self):
+        term = WinTerm()
+        term.set_console = Mock()
+        term._fore = 0
+
+        term.fore(5)
+
+        self.assertEqual(term._fore, 5)
+        self.assertEqual(term.set_console.called, True)
+
+    @skipUnless(sys.platform.startswith("win"), "requires Windows")
+    def testBack(self):
+        term = WinTerm()
+        term.set_console = Mock()
+        term._back = 0
+
+        term.back(5)
+
+        self.assertEqual(term._back, 5)
+        self.assertEqual(term.set_console.called, True)
+
+    @skipUnless(sys.platform.startswith("win"), "requires Windows")
+    def testStyle(self):
+        term = WinTerm()
+        term.set_console = Mock()
+        term._style = 0
+
+        term.style(22)
+
+        self.assertEqual(term._style, 22)
+        self.assertEqual(term.set_console.called, True)
+
+    @patch('colorama.winterm.win32')
+    def testSetConsole(self, mockWin32):
+        mockAttr = Mock()
+        mockAttr.wAttributes = 0
+        mockWin32.GetConsoleScreenBufferInfo.return_value = mockAttr
+        term = WinTerm()
+        term.windll = Mock()
+
+        term.set_console()
+
+        self.assertEqual(
+            mockWin32.SetConsoleTextAttribute.call_args,
+            ((mockWin32.STDOUT, term.get_attrs()), {})
+        )
+
+    @patch('colorama.winterm.win32')
+    def testSetConsoleOnStderr(self, mockWin32):
+        mockAttr = Mock()
+        mockAttr.wAttributes = 0
+        mockWin32.GetConsoleScreenBufferInfo.return_value = mockAttr
+        term = WinTerm()
+        term.windll = Mock()
+
+        term.set_console(on_stderr=True)
+
+        self.assertEqual(
+            mockWin32.SetConsoleTextAttribute.call_args,
+            ((mockWin32.STDERR, term.get_attrs()), {})
+        )
+
+
+if __name__ == '__main__':
+    main()
@@ -0,0 +1,180 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+
+# from winbase.h
+STDOUT = -11
+STDERR = -12
+
+ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004
+
+try:
+    import ctypes
+    from ctypes import LibraryLoader
+    windll = LibraryLoader(ctypes.WinDLL)
+    from ctypes import wintypes
+except (AttributeError, ImportError):
+    windll = None
+    SetConsoleTextAttribute = lambda *_: None
+    winapi_test = lambda *_: None
+else:
+    from ctypes import byref, Structure, c_char, POINTER
+
+    COORD = wintypes._COORD
+
+    class CONSOLE_SCREEN_BUFFER_INFO(Structure):
+        """struct in wincon.h."""
+        _fields_ = [
+            ("dwSize", COORD),
+            ("dwCursorPosition", COORD),
+            ("wAttributes", wintypes.WORD),
+            ("srWindow", wintypes.SMALL_RECT),
+            ("dwMaximumWindowSize", COORD),
+        ]
+        def __str__(self):
+            return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % (
+                self.dwSize.Y, self.dwSize.X
+                , self.dwCursorPosition.Y, self.dwCursorPosition.X
+                , self.wAttributes
+                , self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right
+                , self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X
+            )
+
+    _GetStdHandle = windll.kernel32.GetStdHandle
+    _GetStdHandle.argtypes = [
+        wintypes.DWORD,
+    ]
+    _GetStdHandle.restype = wintypes.HANDLE
+
+    _GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo
+    _GetConsoleScreenBufferInfo.argtypes = [
+        wintypes.HANDLE,
+        POINTER(CONSOLE_SCREEN_BUFFER_INFO),
+    ]
+    _GetConsoleScreenBufferInfo.restype = wintypes.BOOL
+
+    _SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute
+    _SetConsoleTextAttribute.argtypes = [
+        wintypes.HANDLE,
+        wintypes.WORD,
+    ]
+    _SetConsoleTextAttribute.restype = wintypes.BOOL
+
+    _SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition
+    _SetConsoleCursorPosition.argtypes = [
+        wintypes.HANDLE,
+        COORD,
+    ]
+    _SetConsoleCursorPosition.restype = wintypes.BOOL
+
+    _FillConsoleOutputCharacterA = windll.kernel32.FillConsoleOutputCharacterA
+    _FillConsoleOutputCharacterA.argtypes = [
+        wintypes.HANDLE,
+        c_char,
+        wintypes.DWORD,
+        COORD,
+        POINTER(wintypes.DWORD),
+    ]
+    _FillConsoleOutputCharacterA.restype = wintypes.BOOL
+
+    _FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute
+    _FillConsoleOutputAttribute.argtypes = [
+        wintypes.HANDLE,
+        wintypes.WORD,
+        wintypes.DWORD,
+        COORD,
+        POINTER(wintypes.DWORD),
+    ]
+    _FillConsoleOutputAttribute.restype = wintypes.BOOL
+
+    _SetConsoleTitleW = windll.kernel32.SetConsoleTitleW
+    _SetConsoleTitleW.argtypes = [
+        wintypes.LPCWSTR
+    ]
+    _SetConsoleTitleW.restype = wintypes.BOOL
+
+    _GetConsoleMode = windll.kernel32.GetConsoleMode
+    _GetConsoleMode.argtypes = [
+        wintypes.HANDLE,
+        POINTER(wintypes.DWORD)
+    ]
+    _GetConsoleMode.restype = wintypes.BOOL
+
+    _SetConsoleMode = windll.kernel32.SetConsoleMode
+    _SetConsoleMode.argtypes = [
+        wintypes.HANDLE,
+        wintypes.DWORD
+    ]
+    _SetConsoleMode.restype = wintypes.BOOL
+
+    def _winapi_test(handle):
+        csbi = CONSOLE_SCREEN_BUFFER_INFO()
+        success = _GetConsoleScreenBufferInfo(
+            handle, byref(csbi))
+        return bool(success)
+
+    def winapi_test():
+        return any(_winapi_test(h) for h in
+                   (_GetStdHandle(STDOUT), _GetStdHandle(STDERR)))
+
+    def GetConsoleScreenBufferInfo(stream_id=STDOUT):
+        handle = _GetStdHandle(stream_id)
+        csbi = CONSOLE_SCREEN_BUFFER_INFO()
+        success = _GetConsoleScreenBufferInfo(
+            handle, byref(csbi))
+        return csbi
+
+    def SetConsoleTextAttribute(stream_id, attrs):
+        handle = _GetStdHandle(stream_id)
+        return _SetConsoleTextAttribute(handle, attrs)
+
+    def SetConsoleCursorPosition(stream_id, position, adjust=True):
+        position = COORD(*position)
+        # If the position is out of range, do nothing.
+        if position.Y <= 0 or position.X <= 0:
+            return
+        # Adjust for Windows' SetConsoleCursorPosition:
+        #    1. being 0-based, while ANSI is 1-based.
+        #    2. expecting (x,y), while ANSI uses (y,x).
+        adjusted_position = COORD(position.Y - 1, position.X - 1)
+        if adjust:
+            # Adjust for viewport's scroll position
+            sr = GetConsoleScreenBufferInfo(STDOUT).srWindow
+            adjusted_position.Y += sr.Top
+            adjusted_position.X += sr.Left
+        # Resume normal processing
+        handle = _GetStdHandle(stream_id)
+        return _SetConsoleCursorPosition(handle, adjusted_position)
+
+    def FillConsoleOutputCharacter(stream_id, char, length, start):
+        handle = _GetStdHandle(stream_id)
+        char = c_char(char.encode())
+        length = wintypes.DWORD(length)
+        num_written = wintypes.DWORD(0)
+        # Note that this is hard-coded for ANSI (vs wide) bytes.
+        success = _FillConsoleOutputCharacterA(
+            handle, char, length, start, byref(num_written))
+        return num_written.value
+
+    def FillConsoleOutputAttribute(stream_id, attr, length, start):
+        ''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )'''
+        handle = _GetStdHandle(stream_id)
+        attribute = wintypes.WORD(attr)
+        length = wintypes.DWORD(length)
+        num_written = wintypes.DWORD(0)
+        # Note that this is hard-coded for ANSI (vs wide) bytes.
+        return _FillConsoleOutputAttribute(
+            handle, attribute, length, start, byref(num_written))
+
+    def SetConsoleTitle(title):
+        return _SetConsoleTitleW(title)
+
+    def GetConsoleMode(handle):
+        mode = wintypes.DWORD()
+        success = _GetConsoleMode(handle, byref(mode))
+        if not success:
+            raise ctypes.WinError()
+        return mode.value
+
+    def SetConsoleMode(handle, mode):
+        success = _SetConsoleMode(handle, mode)
+        if not success:
+            raise ctypes.WinError()
@@ -0,0 +1,195 @@
+# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.
+try:
+    from msvcrt import get_osfhandle
+except ImportError:
+    def get_osfhandle(_):
+        raise OSError("This isn't windows!")
+
+
+from . import win32
+
+# from wincon.h
+class WinColor(object):
+    BLACK   = 0
+    BLUE    = 1
+    GREEN   = 2
+    CYAN    = 3
+    RED     = 4
+    MAGENTA = 5
+    YELLOW  = 6
+    GREY    = 7
+
+# from wincon.h
+class WinStyle(object):
+    NORMAL              = 0x00 # dim text, dim background
+    BRIGHT              = 0x08 # bright text, dim background
+    BRIGHT_BACKGROUND   = 0x80 # dim text, bright background
+
+class WinTerm(object):
+
+    def __init__(self):
+        self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes
+        self.set_attrs(self._default)
+        self._default_fore = self._fore
+        self._default_back = self._back
+        self._default_style = self._style
+        # In order to emulate LIGHT_EX in windows, we borrow the BRIGHT style.
+        # So that LIGHT_EX colors and BRIGHT style do not clobber each other,
+        # we track them separately, since LIGHT_EX is overwritten by Fore/Back
+        # and BRIGHT is overwritten by Style codes.
+        self._light = 0
+
+    def get_attrs(self):
+        return self._fore + self._back * 16 + (self._style | self._light)
+
+    def set_attrs(self, value):
+        self._fore = value & 7
+        self._back = (value >> 4) & 7
+        self._style = value & (WinStyle.BRIGHT | WinStyle.BRIGHT_BACKGROUND)
+
+    def reset_all(self, on_stderr=None):
+        self.set_attrs(self._default)
+        self.set_console(attrs=self._default)
+        self._light = 0
+
+    def fore(self, fore=None, light=False, on_stderr=False):
+        if fore is None:
+            fore = self._default_fore
+        self._fore = fore
+        # Emulate LIGHT_EX with BRIGHT Style
+        if light:
+            self._light |= WinStyle.BRIGHT
+        else:
+            self._light &= ~WinStyle.BRIGHT
+        self.set_console(on_stderr=on_stderr)
+
+    def back(self, back=None, light=False, on_stderr=False):
+        if back is None:
+            back = self._default_back
+        self._back = back
+        # Emulate LIGHT_EX with BRIGHT_BACKGROUND Style
+        if light:
+            self._light |= WinStyle.BRIGHT_BACKGROUND
+        else:
+            self._light &= ~WinStyle.BRIGHT_BACKGROUND
+        self.set_console(on_stderr=on_stderr)
+
+    def style(self, style=None, on_stderr=False):
+        if style is None:
+            style = self._default_style
+        self._style = style
+        self.set_console(on_stderr=on_stderr)
+
+    def set_console(self, attrs=None, on_stderr=False):
+        if attrs is None:
+            attrs = self.get_attrs()
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        win32.SetConsoleTextAttribute(handle, attrs)
+
+    def get_position(self, handle):
+        position = win32.GetConsoleScreenBufferInfo(handle).dwCursorPosition
+        # Because Windows coordinates are 0-based,
+        # and win32.SetConsoleCursorPosition expects 1-based.
+        position.X += 1
+        position.Y += 1
+        return position
+
+    def set_cursor_position(self, position=None, on_stderr=False):
+        if position is None:
+            # I'm not currently tracking the position, so there is no default.
+            # position = self.get_position()
+            return
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        win32.SetConsoleCursorPosition(handle, position)
+
+    def cursor_adjust(self, x, y, on_stderr=False):
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        position = self.get_position(handle)
+        adjusted_position = (position.Y + y, position.X + x)
+        win32.SetConsoleCursorPosition(handle, adjusted_position, adjust=False)
+
+    def erase_screen(self, mode=0, on_stderr=False):
+        # 0 should clear from the cursor to the end of the screen.
+        # 1 should clear from the cursor to the beginning of the screen.
+        # 2 should clear the entire screen, and move cursor to (1,1)
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        csbi = win32.GetConsoleScreenBufferInfo(handle)
+        # get the number of character cells in the current buffer
+        cells_in_screen = csbi.dwSize.X * csbi.dwSize.Y
+        # get number of character cells before current cursor position
+        cells_before_cursor = csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X
+        if mode == 0:
+            from_coord = csbi.dwCursorPosition
+            cells_to_erase = cells_in_screen - cells_before_cursor
+        elif mode == 1:
+            from_coord = win32.COORD(0, 0)
+            cells_to_erase = cells_before_cursor
+        elif mode == 2:
+            from_coord = win32.COORD(0, 0)
+            cells_to_erase = cells_in_screen
+        else:
+            # invalid mode
+            return
+        # fill the entire screen with blanks
+        win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+        # now set the buffer's attributes accordingly
+        win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+        if mode == 2:
+            # put the cursor where needed
+            win32.SetConsoleCursorPosition(handle, (1, 1))
+
+    def erase_line(self, mode=0, on_stderr=False):
+        # 0 should clear from the cursor to the end of the line.
+        # 1 should clear from the cursor to the beginning of the line.
+        # 2 should clear the entire line.
+        handle = win32.STDOUT
+        if on_stderr:
+            handle = win32.STDERR
+        csbi = win32.GetConsoleScreenBufferInfo(handle)
+        if mode == 0:
+            from_coord = csbi.dwCursorPosition
+            cells_to_erase = csbi.dwSize.X - csbi.dwCursorPosition.X
+        elif mode == 1:
+            from_coord = win32.COORD(0, csbi.dwCursorPosition.Y)
+            cells_to_erase = csbi.dwCursorPosition.X
+        elif mode == 2:
+            from_coord = win32.COORD(0, csbi.dwCursorPosition.Y)
+            cells_to_erase = csbi.dwSize.X
+        else:
+            # invalid mode
+            return
+        # fill the entire screen with blanks
+        win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord)
+        # now set the buffer's attributes accordingly
+        win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord)
+
+    def set_title(self, title):
+        win32.SetConsoleTitle(title)
+
+
+def enable_vt_processing(fd):
+    if win32.windll is None or not win32.winapi_test():
+        return False
+
+    try:
+        handle = get_osfhandle(fd)
+        mode = win32.GetConsoleMode(handle)
+        win32.SetConsoleMode(
+            handle,
+            mode | win32.ENABLE_VIRTUAL_TERMINAL_PROCESSING,
+        )
+
+        mode = win32.GetConsoleMode(handle)
+        if mode & win32.ENABLE_VIRTUAL_TERMINAL_PROCESSING:
+            return True
+    # Can get TypeError in testsuite where 'fd' is a Mock()
+    except (OSError, TypeError):
+        return False
@@ -0,0 +1 @@
+pip
@@ -0,0 +1,24 @@
+    debugpy
+
+    Copyright (c) Microsoft Corporation
+    All rights reserved.
+
+    MIT License
+
+    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.
+
@@ -0,0 +1,37 @@
+Metadata-Version: 2.2
+Name: debugpy
+Version: 1.8.13
+Summary: An implementation of the Debug Adapter Protocol for Python
+Home-page: https://aka.ms/debugpy
+Author: Microsoft Corporation
+Author-email: ptvshelp@microsoft.com
+License: MIT
+Project-URL: Source, https://github.com/microsoft/debugpy
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Debuggers
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+debugpy is an implementation of the Debug Adapter Protocol for Python.
+
+The source code and the issue tracker is [hosted on GitHub](https://github.com/microsoft/debugpy/).
@@ -0,0 +1,539 @@
+../../bin/debugpy.exe,sha256=G75Ze4edEeu1yYDxNIvydWvHXkZ1KonI521DkiVQirU,108434
+debugpy-1.8.13.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+debugpy-1.8.13.dist-info/LICENSE,sha256=ZJhE9g2hOOVLm8wTM4xixfl76GEstiSawQ-Eu7l__Ig,1200
+debugpy-1.8.13.dist-info/METADATA,sha256=UGfNE6hYttMuQH56acv5VuuO4Cz4fWbYlRmljQXoQfQ,1343
+debugpy-1.8.13.dist-info/RECORD,,
+debugpy-1.8.13.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugpy-1.8.13.dist-info/WHEEL,sha256=lPxm9M09dVYWZ0wAh0Zu0ADFguuSXLRXmaW8X9Lg2rA,101
+debugpy-1.8.13.dist-info/entry_points.txt,sha256=NczeIkyCjwYAaTVWNszVe-gdhF1rXbqCcWqwFtDyhhk,52
+debugpy-1.8.13.dist-info/top_level.txt,sha256=6Om6JTEaqkWnj-9-7kJOJr988sTO6iSuiK4N9X6RLpg,8
+debugpy/ThirdPartyNotices.txt,sha256=47qqUyueIwOxh7GOBd_tSJYdbRbILQrkeXiy_SzkcIQ,34844
+debugpy/__init__.py,sha256=F4V93y2TH7QEsa0RqkyDN32tUyzlCnKAL2xyvdZxNgE,1056
+debugpy/__main__.py,sha256=9b4lASAY-k28C0Qr4tCNK5cLEt9-52UyNrDOuKRxszQ,3258
+debugpy/__pycache__/__init__.cpython-311.pyc,,
+debugpy/__pycache__/__main__.cpython-311.pyc,,
+debugpy/__pycache__/_version.cpython-311.pyc,,
+debugpy/__pycache__/public_api.cpython-311.pyc,,
+debugpy/_vendored/__init__.py,sha256=X2LMEb9UfYzaYGk49Mf1qsmKykFrhhO01bMc-gLyfh0,4004
+debugpy/_vendored/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/__pycache__/_pydevd_packaging.cpython-311.pyc,,
+debugpy/_vendored/__pycache__/_util.cpython-311.pyc,,
+debugpy/_vendored/__pycache__/force_pydevd.cpython-311.pyc,,
+debugpy/_vendored/_pydevd_packaging.py,sha256=ZeQBeeDtG3i75XCQUsyYX3CfI4fANBk9nCOwpLJ1yHE,1293
+debugpy/_vendored/_util.py,sha256=nkfFuyOKwPUY1Mnku-3-SYIQDeUeidEPklaJCyIQgTw,1899
+debugpy/_vendored/force_pydevd.py,sha256=q0Hb3NBYu053_v1LqqwfMnOlJ7VtPWsEnBTSpXALs0g,3253
+debugpy/_vendored/pydevd/__pycache__/pydev_app_engine_debug_startup.cpython-311.pyc,,
+debugpy/_vendored/pydevd/__pycache__/pydev_coverage.cpython-311.pyc,,
+debugpy/_vendored/pydevd/__pycache__/pydev_pysrc.cpython-311.pyc,,
+debugpy/_vendored/pydevd/__pycache__/pydev_run_in_console.cpython-311.pyc,,
+debugpy/_vendored/pydevd/__pycache__/pydevconsole.cpython-311.pyc,,
+debugpy/_vendored/pydevd/__pycache__/pydevd.cpython-311.pyc,,
+debugpy/_vendored/pydevd/__pycache__/pydevd_file_utils.cpython-311.pyc,,
+debugpy/_vendored/pydevd/__pycache__/pydevd_tracing.cpython-311.pyc,,
+debugpy/_vendored/pydevd/__pycache__/setup_pydevd_cython.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_calltip_util.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_completer.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_execfile.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_filesystem_encoding.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_getopt.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_imports_tipper.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_jy_imports_tipper.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_log.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_saved_modules.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_sys_patch.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/_pydev_tipper_common.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_console_utils.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_import_hook.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_imports.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_ipython_console.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_ipython_console_011.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_is_thread_alive.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_localhost.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_log.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_monkey.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_monkey_qt.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_override.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_umd.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/__pycache__/pydev_versioncheck.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_calltip_util.py,sha256=mKCq9Os9C3XcGp8CNnj3DMdOoGhOOIEU4aPkHBYG58E,4837
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_completer.py,sha256=fmhHyF3Ct1OEw6Go_nkr6u3lcuMNA0DDwfRVHL0kDXw,8802
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_execfile.py,sha256=r88arfUo-XRQ0g8AOqVGnLXKV22wLtvR0-uMtKBcZ1k,501
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_filesystem_encoding.py,sha256=5jf71i_CraPZqg24ltOE5a_ONBytxi8Z98MYqyiIsD8,1144
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_getopt.py,sha256=qGGEvnbb7jGGmOiqR8BRv5UuP9g4UrHqiUDApzo8uPw,4562
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_imports_tipper.py,sha256=8T-GeBuqn7YjhVOzkEos3O-Snc2yyPAtIcBK5NMaHzA,12684
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_jy_imports_tipper.py,sha256=P6hcMXp8i2qtKk9AKugBNP68xeW-KgEtXC-ZfK0sPN4,17479
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_log.py,sha256=berDApmD1pPfLbSu1M42lI9w__SgyLGmb4kXPQLHmsA,577
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_saved_modules.py,sha256=ehfr0Ppukfb2VAxVcAYNRhm5bJ6ecu6Zb7VXVoZfnMQ,4874
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_sys_patch.py,sha256=yHqYlL5q9DcmuDrzr-0ABt_cnqi2X0k9iIdD0_Ek9B0,2314
+debugpy/_vendored/pydevd/_pydev_bundle/_pydev_tipper_common.py,sha256=zJRy2W_64GKddZvkm40V_n77bZvn52ItTvgisLwkpa4,1281
+debugpy/_vendored/pydevd/_pydev_bundle/fsnotify/__init__.py,sha256=yXS5G5bolJ9W35oQvw_VjYgS6dIw1TjCr4Po3QUPZhY,13055
+debugpy/_vendored/pydevd/_pydev_bundle/fsnotify/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_console_utils.py,sha256=rAHp-etvzBOGHIhUsZaC4CywT_Ard00_iVI70NGDVMg,24391
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_import_hook.py,sha256=aL_4ExxlPunWfuGMV9UbV67G5cSkOuakwKyezr5Ashg,1358
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_imports.py,sha256=O8e-SDRsxliMo7qTiomW1lMHAtKaA1Atj1pRVAXSTc0,415
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_ipython_console.py,sha256=nnPdCz3OKkPoz6HJGrtAhMp7fYqmi_f6I9uPNBbp9s4,3868
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_ipython_console_011.py,sha256=y4lMQ4IoKfvvgfHt5Qi4_Dorn8MBRF6bcSBA9bkxW44,21267
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_is_thread_alive.py,sha256=acY5u3D25P5O-G9ta9umjSat8Z_h1ZSUrR3BNPu-Pk0,907
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_localhost.py,sha256=pVFtReq7m8ASqzDCoQn6UNJr9WdUIE_2LPBxYC7v3BU,2139
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_log.py,sha256=XTeoga6NfJ2IubIeN1wtN6Sn0j7lpmoFbpR06jpSnsg,9605
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_monkey.py,sha256=EQrEbQ2bOMQIl5_a7ImDnIyLrmOO9D7UWFupCSUbQc8,45356
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_monkey_qt.py,sha256=4ed6XdJ79UE1vzaz09Bnx2clUdlTVpPDr4aRnvaYyM8,7530
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_override.py,sha256=ZGUjBbzV2gsaxi4LXuYzOPZp-Wfb_u0VixHuwfcBAA0,908
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_umd.py,sha256=zoCunk-UenK6mhKWFUMk7ncdOuAkWeFhHDU2Jxo6lB4,6409
+debugpy/_vendored/pydevd/_pydev_bundle/pydev_versioncheck.py,sha256=H044ieOgEG3rfFY3av4cbXo_fJUfgG7WHX8XGNKqoTs,524
+debugpy/_vendored/pydevd/_pydev_runfiles/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugpy/_vendored/pydevd/_pydev_runfiles/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_runfiles/__pycache__/pydev_runfiles.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_runfiles/__pycache__/pydev_runfiles_coverage.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_runfiles/__pycache__/pydev_runfiles_nose.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_runfiles/__pycache__/pydev_runfiles_parallel.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_runfiles/__pycache__/pydev_runfiles_parallel_client.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_runfiles/__pycache__/pydev_runfiles_pytest2.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_runfiles/__pycache__/pydev_runfiles_unittest.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_runfiles/__pycache__/pydev_runfiles_xml_rpc.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles.py,sha256=oWq_BdHZ-fquD6ZPKb2TsmX_yEiv5vLiFPjoBlgunAE,33562
+debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_coverage.py,sha256=zzhvUR99uCNwrmdWUgc4a-u8kqM0BaWiU2kfYnch74k,3485
+debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_nose.py,sha256=ZfhtlyVLOmPHbunir2CUsFsHcsfOMZLamL1yirwMSlI,7762
+debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_parallel.py,sha256=WvGMm7ONerpEzffYtH5tKv5xYTlw7HiOIp1VJItxIV8,9746
+debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_parallel_client.py,sha256=_CNo0g1KVcjNAtEnTytB_dB7kiTcGFy-Fgv-vx3ej0E,7906
+debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_pytest2.py,sha256=dUG2YinG8MXmy1uvpZyKyFqXh56ZNGFG9TbhbHY2oSs,10153
+debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_unittest.py,sha256=HySm3cRPwVV2xCbD94ZNm6I02ScppV6TBgaaWpztJwQ,6707
+debugpy/_vendored/pydevd/_pydev_runfiles/pydev_runfiles_xml_rpc.py,sha256=KKroSy8czV7X7f7DxzKnlt5x3d3YVV8yXVQfstLO4Dw,11093
+debugpy/_vendored/pydevd/_pydevd_bundle/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevconsole_code.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_additional_thread_info.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_additional_thread_info_regular.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_api.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_breakpoints.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_bytecode_utils.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_bytecode_utils_py311.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_code_to_source.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_collect_bytecode_info.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_comm.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_comm_constants.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_command_line_handling.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_console.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_constants.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_custom_frames.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_cython_wrapper.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_daemon_thread.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_defaults.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_dont_trace.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_dont_trace_files.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_exec2.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_extension_api.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_extension_utils.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_filtering.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_frame.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_frame_utils.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_gevent_integration.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_import_class.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_io.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_json_debug_options.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_net_command.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_net_command_factory_json.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_net_command_factory_xml.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_plugin_utils.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_process_net_command.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_process_net_command_json.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_referrers.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_reload.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_resolver.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_runpy.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_safe_repr.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_save_locals.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_signature.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_source_mapping.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_stackless.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_suspended_frames.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_thread_lifecycle.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_timeout.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_trace_dispatch.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_trace_dispatch_regular.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_traceproperty.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_utils.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_vars.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_vm_type.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/__pycache__/pydevd_xml.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/__main__pydevd_gen_debug_adapter_protocol.py,sha256=X3oG0tYDfvZls8w8UeBsGjk-2hDzCPpkQHekGMS1LHM,23959
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/__pycache__/__main__pydevd_gen_debug_adapter_protocol.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/__pycache__/pydevd_base_schema.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/__pycache__/pydevd_schema.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/__pycache__/pydevd_schema_log.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/debugProtocol.json,sha256=GDwhshyO3VxxY-Xt3fEGzwqOEc9i03rBfUejqEcAbJk,174580
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/debugProtocolCustom.json,sha256=q-xmea882cnHWUiyX-nr5KrPe2JItmPJsubiq0-VTC8,10940
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/pydevd_base_schema.py,sha256=xkq1SFSdV-fATabTFfotBLlICCcBGGPHMhLWc7hNMx0,4143
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/pydevd_schema.py,sha256=snrpmyJJ6HdKpilCCtG6PY-MM_TG2yKv0qRB5FOH1tA,860496
+debugpy/_vendored/pydevd/_pydevd_bundle/_debug_adapter/pydevd_schema_log.py,sha256=80Gevuyh7rkHWtORVLeB3KFoy30WI-9DcFLr0varH6w,1299
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevconsole_code.py,sha256=xdFXB6MwtwqVZgI6bKSA_m6WFVesA_6zVGrepdxtlBs,19489
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_additional_thread_info.py,sha256=5FTLYoS550nnKIv2olEPJCXg_lHrmT_veCBYg2AZZWc,1685
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_additional_thread_info_regular.py,sha256=l2Jm44T31FqaS1h6vHYQIJACsBzpYv5-QQLu61-rD9g,11139
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_api.py,sha256=7c2wx1p91eIyA5TUgL7DIzQzbu2CBKfKFYoW4TykEFY,52496
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_breakpoints.py,sha256=9Ne8Lt7MSvtajr9V6twZd580uCYH_jaQBNo8dBNe3Lg,6185
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_bytecode_utils.py,sha256=rYwpcPYHq5Nrzhc7FO6UguLUHdeyOqh5XpGafUQgYLI,29963
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_bytecode_utils_py311.py,sha256=gJSiSB__foZj1-xk6dbFWutbeK_6Gho53vEWx19y3sQ,3705
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_code_to_source.py,sha256=HfWM-ZqUgsPPWVBDwes9IuKaSLG8ZB3lhDfFEuq6hyw,18165
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_collect_bytecode_info.py,sha256=kBsq-pkF5rcRbqVKYbNEqmbtjBaWNZus8In4PhfQYmY,36003
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_comm.py,sha256=blw4naGKnAlvXUh701y9TcX7wc4UX_j8A5AFqH2OByY,81322
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_comm_constants.py,sha256=DzJK0CziD_y-uktAETMsGL-uJtqv02ISEz5U3f-ZNxc,6276
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_command_line_handling.py,sha256=v9aMI1KpIAoDl7Il4J_Eq-xLu9ywXU3uozuycvpm6FM,6283
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_concurrency_analyser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_concurrency_analyser/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_concurrency_analyser/__pycache__/pydevd_concurrency_logger.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_concurrency_analyser/__pycache__/pydevd_thread_wrappers.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_concurrency_analyser/pydevd_concurrency_logger.py,sha256=tQDy9L7rHYppQnxNowO-qB-JCWzb8aT-u-PwhFUS3Hg,21190
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_concurrency_analyser/pydevd_thread_wrappers.py,sha256=RTuWPNE4o7I60icJ_92Q-w3Dr09m5pvmjZTV5WPnVVE,2120
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_console.py,sha256=zpKrmt7t8MDJOQASS3IWV-t0x1q0KKn1jUq9Gmou0co,10434
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_constants.py,sha256=nnWG4RotUi-IPsNgFow5SmisYlNHTk5bOhqtl8AFzQ4,29340
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_custom_frames.py,sha256=HvP6CQt32WPiLpnQFzJJbsVwFkRRvYpDXoqLWnZQ3l0,4538
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_cython.c,sha256=xe7rkSjx4iZwIBTLoKqtS57oGiaCRabKBGfI_usGo24,2676744
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_cython.cp311-win_amd64.pyd,sha256=377itc1isEsMLD6devg4BkzPt33uyMGHLoQAwLWGKck,413248
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_cython.pxd,sha256=P8c7ARyAiL_ZnVrZTWrONzgPriMel8B4_jgIh_8Jq24,1732
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_cython.pyx,sha256=OrdZ3st49zoOyRSPijhwDzueLPyRutO8nzg0ugq5JyI,101046
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_cython_wrapper.py,sha256=E_at26A0Efx4bXGYch2gzqFpDx7KPdu4XNUEMOUpB4E,1913
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_daemon_thread.py,sha256=56eFjY--HXRA00ePMUG9_mQN8CFApQmrgVLorIzIE3M,8579
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_defaults.py,sha256=V2LH9LxI-1G5ZAmzkxGWksooD2sSLjqwm3efnfaffmc,2358
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_dont_trace.py,sha256=VGoDp3gRtMmhqwMUoGSG4XwD5TynynJ45ocbpTQA7Cs,3685
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_dont_trace_files.py,sha256=QeTSug7s2kxreNSg05P-S9DkUXLI16F4fF9Hqgwb_WU,6541
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_exec2.py,sha256=uYH9ICJbViilxNO2eWEatmnlzaKGGPsuzPeDiCV9xsQ,165
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_extension_api.py,sha256=kXiTFjPzx-ck3BRAso-PfVXwmWsowjZFanHb3k82rl4,4013
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_extension_utils.py,sha256=t8ZbhuD5mw1Uk5DDpP3XTmzr0ZTsO5Nu-8tMmshaWVY,2365
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_filtering.py,sha256=S8z8KvD9eGN455dFYDy6SBDPPbFRdz_nnINiJJbknxM,13331
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_frame.py,sha256=XOsZJVwkrpHzS_U0DnuH8y8AucgHSW12YgPvZ8r1xBE,65836
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_frame_utils.py,sha256=lGPHeEtctGs3U1w6Q-LmjVmkdwPyqTs6lJ2h7gtQ5WI,14529
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_gevent_integration.py,sha256=tK5XKFdm9nrng6iahoKXo-qU6cGpx9qfEnTJ_1RQKYI,3957
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_import_class.py,sha256=LvvAc5jF_5xrjlj-hA_AQxgzMylMSWmIKvSJGJzalpc,1849
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_io.py,sha256=WRyJl05XYJbARv5VO4QetA4BGK5du891j17WaqEkuwA,8371
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_json_debug_options.py,sha256=mGpPOb7imeG0LKcPks3XjW1toj6CuAzwTkiTfdQl2XY,6353
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_net_command.py,sha256=nnxWNJftxlGw3NRzxp--lPuOdOOWsEyhEsBB7z6qzZo,4852
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_net_command_factory_json.py,sha256=jZUtfBCTaxhhuX-TYrOKj4iiOGbQg07GoQmI2sDv1Ng,25782
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_net_command_factory_xml.py,sha256=2SnjQ7h34RzWseCPTVrH4wpzN4y7L6wBpSRSMz3Lh7c,24342
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_plugin_utils.py,sha256=gdcHKhOUC2BSmNwUhm8YRd8CBXYsbwHTFSuYaOtOQtE,7408
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_process_net_command.py,sha256=xZ9eJKal4YKofgW4d2bq0FzaMVSGnet7ElFUOyhFYsc,36814
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_process_net_command_json.py,sha256=_6WHEO_nmcTsnBZfHmsxX1cynlwOv2lAhjZ8KRFJzIc,58893
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_referrers.py,sha256=XZyvA2tXMvB06CkU9tIrhWYEUqUYOEWE1vm_s9KAhn4,9930
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_reload.py,sha256=BQWvgpuHn8Onou6Gq52FaH_bovpWFil6Mx6E7rKPbNQ,16212
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_resolver.py,sha256=LzqXGqQvbZU9tWpTztdY7kMEaLuDkhHSOV4UhcEjRPA,30451
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_runpy.py,sha256=5Ym7qspy0L5X5gB644U5Iave888efyImpr6YWO_9T3U,13346
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_safe_repr.py,sha256=peNBidaZd2OtGRzrx6-Sn_uC9XlHU7rdjV4nCkpuGak,14787
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_save_locals.py,sha256=-Gh7L0bQld-ojcZ1sg6SsTFm3dJqf_1awT-L3rJZ0Gk,4290
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_signature.py,sha256=aBdFvHFszxM-Dz7dDA4CqYquy4ceLRKyBVGRiUIE3pY,7078
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_source_mapping.py,sha256=4113H9PCY_MiIqtmch1v8DfzOVTfMvfXKYnJD-EZr9s,6643
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_stackless.py,sha256=jAz6_TjQvJxSthDe_RpYQ4MlN9e0hixUVLZzC75r28I,17333
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_suspended_frames.py,sha256=AP2jS8vwLCpCP7ivyqtUxJeTPb1bo7FrCS72zMFW9z0,21626
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_thread_lifecycle.py,sha256=Ot1OpztHf2BKLhbXG0blh29c55gDSBqmGZi6lTF4Ukg,3960
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_timeout.py,sha256=AyY7WixUnijEaWHR2iQlKuvMWrDoTLjaiJ0jJ8B2_9I,8644
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_trace_dispatch.py,sha256=tBpRaQdSU9OaE-E191bYYCMBHJP8EEw1drxu0mMl7R0,4009
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_trace_dispatch_regular.py,sha256=KP2OzLNsOOZT7RAbl9iUlxj2zMbHwsG0lx_gr30prwg,23908
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_traceproperty.py,sha256=K9TXAgz9kZdhgc-HD0rJ9pXj1FJQgrrWnL0QodvWaic,3345
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_utils.py,sha256=KpUEaRz-VEfPq21igdWH89L1erw9XS4TXGvpd2hkmBM,18336
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_vars.py,sha256=tpEVzNNAgjEYF_EH4aIdVwR15iOHUR4rIMjwrfWvWaM,31981
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_vm_type.py,sha256=cnKHitcZ1U-EgwGp8w5uTSnsn-9NRRkwoJP56Sgsz30,1597
+debugpy/_vendored/pydevd/_pydevd_bundle/pydevd_xml.py,sha256=dDJb-U_1YKAJzn2-ZuOuO3krxLvwFsXaBtIJHBtw0mQ,15933
+debugpy/_vendored/pydevd/_pydevd_frame_eval/.gitignore,sha256=KFTd4SAAJbN6dEYOm9rrBVfyjo5Ht00XH0aWWZSbyBI,90
+debugpy/_vendored/pydevd/_pydevd_frame_eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugpy/_vendored/pydevd/_pydevd_frame_eval/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/__pycache__/pydevd_frame_eval_cython_wrapper.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/__pycache__/pydevd_frame_eval_main.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/__pycache__/pydevd_frame_tracing.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/__pycache__/pydevd_modify_bytecode.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_eval_cython_wrapper.py,sha256=JQiRZ5FGT-BO7P9W6FKN8G4slIJvuOc1KMVqXKpq52E,1384
+debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_eval_main.py,sha256=HHdrAPYCnN7XHBS78HM8arPuWwtUmvJ57nWA-Yi_gBY,2515
+debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_evaluator.c,sha256=yTOhGHpLBW2Ajw3B5uuuXQIx7BuNUSWW111XNsnC4EE,1207712
+debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_evaluator.pxd,sha256=N1G8pucXI-Bu23PtYgFPaP4hB0EYw6ExuMQZJxX0YAw,5455
+debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_evaluator.template.pyx,sha256=n47QB8tJmBm4AEWMN4idVLGc3p4SuxXaf1nMcra1Aj8,25163
+debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_frame_tracing.py,sha256=dHgbbT0xwoSPoKptBUxcQR9KPNK9cn-pBGHzHRb7zS4,4339
+debugpy/_vendored/pydevd/_pydevd_frame_eval/pydevd_modify_bytecode.py,sha256=oSiHPsaL9cDs1mbvc6WPGEPHXzGmEoeO5Zk05WnE3BQ,13908
+debugpy/_vendored/pydevd/_pydevd_frame_eval/release_mem.h,sha256=e4E5UnMBSI4D-EcLFDOU-8kaKQy4u9WgzUZ2kZZxA94,84
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/README.txt,sha256=1djz91cGc8fWy-vFs-pJgftUnsrH_Di_Bfy72e11Fms,717
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/__pycache__/pydevd_fix_code.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/__init__.py,sha256=BQgaAF4JepnryoVyxZni9On7WxXyclcuHMOWpyEUuSw,4284
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/__pycache__/bytecode.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/__pycache__/cfg.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/__pycache__/concrete.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/__pycache__/flags.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/__pycache__/instr.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/__pycache__/peephole_opt.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/bytecode.py,sha256=8Z3TR4lOHJaUCctNUF6RpjULTWfI-cVub_5L_1izwyA,7297
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/cfg.py,sha256=aLIynwn1VvedXPuSiduD92LXdu4Sjl7BpO21XhEv5YI,15549
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/concrete.py,sha256=mQTiY5-ZzQJgPYSKwLk2D02kZ5qPcd0GN2X1LyNOt3Q,22811
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/flags.py,sha256=xMNyCDh_aslsRM-k0VBqW6dPAIjvuPeC98iwB2Y-D4M,6013
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/instr.py,sha256=N3lPvYszv-FJ-GG6JB03YjjIdrWKSCWoAusEFEE74es,11691
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/peephole_opt.py,sha256=Yvb32GEUEzAPru04LU9y3uMa3laTO7mkSB8cLcWUmTY,16182
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__init__.py,sha256=v03b38LiPfE6bXlT_QwW2YgQ0JnnA1hUjfZAqxsrId8,5094
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/test_bytecode.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/test_cfg.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/test_code.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/test_concrete.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/test_flags.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/test_instr.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/test_misc.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/test_peephole_opt.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/__pycache__/util_annotation.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_bytecode.py,sha256=IAzoVQwNR1yKYDJ2u3AfbnmaYHjHDlr-wibJARrRv5M,16365
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_cfg.py,sha256=aua4b2gSoczcC6k7ETLNvLkCHFhdRssp2Gw8UcMO1_U,29127
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_code.py,sha256=JdEIgz886-gxh-JP1xS-Ut1TgV6w0vzce65W0lRXc0s,2518
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_concrete.py,sha256=M4B0tqT7MaHC8wx01vGr9gcep0iI3f-FSWHOqw85AfE,50807
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_flags.py,sha256=ozlYuOMfhyrqq3C0zmCWyDAycX70OI5n_q7C6u9KlWI,6164
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_instr.py,sha256=r00EVajF4OEbuYfT4kkh7XYw2q6AOCwpDA1Dv_Tig6s,11888
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_misc.py,sha256=0e7CaZIUKYyqs6IZNq1VcVjmVQqnmN_MjeyfZ6kchuQ,7275
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/test_peephole_opt.py,sha256=VFgpO_RWQJZtNvCVAM1NraOU4BJSjfkGvwtUyfn3VtA,33840
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/bytecode/tests/util_annotation.py,sha256=xzihFD5dhmc2wC1fElNMnwXK9GnpIqQ69X3iGDo3i7I,478
+debugpy/_vendored/pydevd/_pydevd_frame_eval/vendored/pydevd_fix_code.py,sha256=wji3NsXbIIFRcpi8SwkxQQYpWOvb2CFNS7eYdxGeyy0,1806
+debugpy/_vendored/pydevd/_pydevd_sys_monitoring/__pycache__/_pydevd_sys_monitoring.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_sys_monitoring/__pycache__/pydevd_sys_monitoring.cpython-311.pyc,,
+debugpy/_vendored/pydevd/_pydevd_sys_monitoring/_pydevd_sys_monitoring.py,sha256=o0h1CfJsWQcoMLdihrWiQoTk8hSPqTvqvsPFQyK7e5M,75607
+debugpy/_vendored/pydevd/_pydevd_sys_monitoring/_pydevd_sys_monitoring_cython.c,sha256=VlGWXDx4y8fkQ8vgw9lGWLbArMUPSf8IwLZa1pb1edM,2071663
+debugpy/_vendored/pydevd/_pydevd_sys_monitoring/_pydevd_sys_monitoring_cython.pxd,sha256=8jpSP1Z4wiQs4pFjVCGeN79giMtyVesn7uOcXYXRfUo,2385
+debugpy/_vendored/pydevd/_pydevd_sys_monitoring/_pydevd_sys_monitoring_cython.pyx,sha256=7x5suDhvVM0BgS608-RL20mnymDJUZ3YVzgVVss39fA,77973
+debugpy/_vendored/pydevd/_pydevd_sys_monitoring/pydevd_sys_monitoring.py,sha256=F2vDJ6PFzhyiutISDjDqxKjreaMIqUTQ4hWUnmYe5dA,565
+debugpy/_vendored/pydevd/pydev_app_engine_debug_startup.py,sha256=GB0ctG6n3BSqSMy5jP3gnqUmRmcIQa6e3Y7_1MOJDCY,691
+debugpy/_vendored/pydevd/pydev_coverage.py,sha256=Cyhk-bdOgsRvtA8A1XoDTntUglW7qWcXejliAsz80TI,3204
+debugpy/_vendored/pydevd/pydev_ipython/README,sha256=dl_JsPkjM1T14ZRHZTTvTeaFoyo91C0Ijftfa2GODnc,546
+debugpy/_vendored/pydevd/pydev_ipython/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhook.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhookglut.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhookgtk.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhookgtk3.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhookpyglet.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhookqt4.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhookqt5.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhookqt6.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhooktk.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/inputhookwx.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/matplotlibtools.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/qt.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/qt_for_kernel.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/qt_loaders.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/__pycache__/version.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_ipython/inputhook.py,sha256=OhzStI96H8kZgBpJdlBG_phSC7IgP7VC4eY_HMnt5Gw,20592
+debugpy/_vendored/pydevd/pydev_ipython/inputhookglut.py,sha256=J117nWjw2lboM5WZZfxfqlnSzN1_ZlA2os-aFzyC-uk,5769
+debugpy/_vendored/pydevd/pydev_ipython/inputhookgtk.py,sha256=pcRzFXUe5T23pDyrXH6tem-F1QXXxiW5MeTTXnLcqjs,1151
+debugpy/_vendored/pydevd/pydev_ipython/inputhookgtk3.py,sha256=dfqUk2LUd35FjXRLU2CCYvbAoBFkE40m16bIagjdkVk,1149
+debugpy/_vendored/pydevd/pydev_ipython/inputhookpyglet.py,sha256=0x1SIrqjUE7Mlv-91xzV2rg81gJWdmhPSDPv3rYWVtk,3359
+debugpy/_vendored/pydevd/pydev_ipython/inputhookqt4.py,sha256=mgEqu71Sex9zGrrYVlsrJSrKvTn0sJKq46e-wY-CC_s,7449
+debugpy/_vendored/pydevd/pydev_ipython/inputhookqt5.py,sha256=YH6hNSbAXG6AtgrXXPol7THcjtY35CQmPqcm5mzTjb8,7498
+debugpy/_vendored/pydevd/pydev_ipython/inputhookqt6.py,sha256=wYdtHkBcwZgdhKJhQZlCrV26DKoEVfAgeeY8-IBKbLI,7533
+debugpy/_vendored/pydevd/pydev_ipython/inputhooktk.py,sha256=VVvcY5gMzvy8E7pEUjqoj475N2n9hXr89xQejcofiAw,779
+debugpy/_vendored/pydevd/pydev_ipython/inputhookwx.py,sha256=sAcOH0-D7ivbTTXJzj2w1z1f5fTaogY0IMLxb0Hcvhs,6700
+debugpy/_vendored/pydevd/pydev_ipython/matplotlibtools.py,sha256=r7cS9ritzEcX-YjPeCCOoRLT-R9DG9GKelIwMrdax3E,6700
+debugpy/_vendored/pydevd/pydev_ipython/qt.py,sha256=z2NO2nwCco6XnIoSU0BJZJX48VT-7DtQnEP_nVZu-oQ,896
+debugpy/_vendored/pydevd/pydev_ipython/qt_for_kernel.py,sha256=axKN_DOGg-P2pMRo6DA5QlJASIpKV0B--DtNxUXMC0U,4089
+debugpy/_vendored/pydevd/pydev_ipython/qt_loaders.py,sha256=k9xrl3HKC7JBCZjwFRNLWcOxOC5zvH4kVZaTrvC8uiE,10922
+debugpy/_vendored/pydevd/pydev_ipython/version.py,sha256=qWd6MZZm-_cFDjqHYySRTSSmCAewxCHKhi-4aoyaAB8,1546
+debugpy/_vendored/pydevd/pydev_pysrc.py,sha256=ulsJmWy-lUAcUi5PN5MHLz-igFbiEWRJ3hhlNbYzG6E,102
+debugpy/_vendored/pydevd/pydev_run_in_console.py,sha256=EH5aornfVSnKaeLbnvnIn45dbr7NGSiBRbVQvxPSWvE,4789
+debugpy/_vendored/pydevd/pydev_sitecustomize/__not_in_default_pythonpath.txt,sha256=hnkTAuxSFW_Tilgw0Bt1RVLrfGRE3hYjAmTPm1k-sc8,21
+debugpy/_vendored/pydevd/pydev_sitecustomize/__pycache__/sitecustomize.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydev_sitecustomize/sitecustomize.py,sha256=AQeg7jWAJAAVPiv25JBwOKPbokQgUBDd7c2WCNd0RpQ,9939
+debugpy/_vendored/pydevd/pydevconsole.py,sha256=22zdql8paBpCek_K_nx8fnEf7KpiCRGxtkTDW3x70Mw,21730
+debugpy/_vendored/pydevd/pydevd.py,sha256=bHCuDg5AVAuLNXA8uOrZfTucXrcOGMdQFG21ruoZay4,158883
+debugpy/_vendored/pydevd/pydevd_attach_to_process/README.txt,sha256=NCTzQYbUF9bhwoTz-JWznwLcxcUDu7PmcPuk7p9_nJg,987
+debugpy/_vendored/pydevd/pydevd_attach_to_process/__pycache__/_always_live_program.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/__pycache__/_check.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/__pycache__/_test_attach_to_process.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/__pycache__/_test_attach_to_process_linux.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/__pycache__/add_code_to_python_process.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/__pycache__/attach_pydevd.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/__pycache__/attach_script.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/_always_live_program.py,sha256=ILeoZBiqJzhOGT7fVO5YE5LPcwG2eMaylL3nzqoXPxM,727
+debugpy/_vendored/pydevd/pydevd_attach_to_process/_check.py,sha256=_WfnnRggiYjQZAWEQKpQgJV1LM7KXLP91pidAr4hvyI,139
+debugpy/_vendored/pydevd/pydevd_attach_to_process/_test_attach_to_process.py,sha256=2EjrvtNtEqW0hiEPfKbK-YBnkH4kTNfmBujBeljowRc,310
+debugpy/_vendored/pydevd/pydevd_attach_to_process/_test_attach_to_process_linux.py,sha256=Z0nDMeWbGd64sorYqKim-BD8Z89PVFFjfdKMAt51Hxg,2638
+debugpy/_vendored/pydevd/pydevd_attach_to_process/add_code_to_python_process.py,sha256=ARGEx1rIU1UEeputMDMGX6twms3OCWiH74hXEUizm1A,23194
+debugpy/_vendored/pydevd/pydevd_attach_to_process/attach_amd64.dll,sha256=BcrKCmHunvuaYvQh34CFJ9KUgrEPAgrqZJ1yYAEyvp4,48712
+debugpy/_vendored/pydevd/pydevd_attach_to_process/attach_amd64.pdb,sha256=isBn-NsMO3q9Ja8yDjscblRY-tv6M7dYIMLuRTYVSpk,978944
+debugpy/_vendored/pydevd/pydevd_attach_to_process/attach_pydevd.py,sha256=A7ExNDdK9Nxw6DMv2tZEDD9jlQWhipeOTrO3G4E1oAo,2674
+debugpy/_vendored/pydevd/pydevd_attach_to_process/attach_script.py,sha256=hgDVvUoLlSmK4zkTXwcqUXsCdoDndXyIX552vhZLq4g,8228
+debugpy/_vendored/pydevd/pydevd_attach_to_process/attach_x86.dll,sha256=9hfmiIQy6h_TMFplFvPpCglD1scZgXARDew75zG1Vbg,43080
+debugpy/_vendored/pydevd/pydevd_attach_to_process/attach_x86.pdb,sha256=zwv4dO24E5sEDFmAvVAfFzXU-70uCYLGIcKP1BEHCpw,1003520
+debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_custom_pyeval_settrace.hpp,sha256=eemL6azv2iZFjJTWoZwHG0m4OrnBxwutIaVihSeQS3k,8591
+debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_custom_pyeval_settrace_310.hpp,sha256=gI8IpfCzlIte-YZg1yhRIIQYwoc3d9_zPdu7R6VcTL0,4174
+debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_custom_pyeval_settrace_311.hpp,sha256=SRzM1lO1t2aExbTeatiee2r3WGTX1vFMGMM1699wrs8,4388
+debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_custom_pyeval_settrace_common.hpp,sha256=Vr-8FUB447JXozU7DghmbqcLxUgB1ceRu6RHx1XFnDw,1931
+debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_settrace.hpp,sha256=liXVVbYGAb1TN1i-E9cnWC98fudUxiKFcdrJNMaUiJs,7875
+debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_utils.hpp,sha256=lqUbijXhr_JvHWFugNGOASRsWj0920EYgGmy_OnZM9o,3949
+debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_version.hpp,sha256=xZbrnmXAIv4JTBCYHC0oO-EWLbaPBHVNdup0shPdOlo,3009
+debugpy/_vendored/pydevd/pydevd_attach_to_process/common/python.h,sha256=1vcb0JbN3SPZ5D4XS8ySgfFmuFBe4ij8cddpIZBhNbc,22335
+debugpy/_vendored/pydevd/pydevd_attach_to_process/common/ref_utils.hpp,sha256=QN0XTviEzU1eViwviTsEyg6j8x6gUqbJbzuGsrH1qa8,1537
+debugpy/_vendored/pydevd/pydevd_attach_to_process/inject_dll_amd64.exe,sha256=j_5jTgWjVk_MJ2YlGwTIMwdk8-Ut4OJBfgneuWIXh_M,266312
+debugpy/_vendored/pydevd/pydevd_attach_to_process/inject_dll_amd64.pdb,sha256=6Q-I6sQ4pDdbRjyX4IIvnIGKeZxCwLDKHz8aPFCQoXk,5656576
+debugpy/_vendored/pydevd/pydevd_attach_to_process/inject_dll_x86.exe,sha256=wKrAE8b12ZEgtHTDgxHTG0NTmLfBfRT5R12MgdKPO7A,209496
+debugpy/_vendored/pydevd/pydevd_attach_to_process/inject_dll_x86.pdb,sha256=LwLVm5Ip989ZtIJ8WfiDfwg5sF9zqUDqc9eHMn1HKx0,5771264
+debugpy/_vendored/pydevd/pydevd_attach_to_process/linux_and_mac/.gitignore,sha256=qXNHqGgNv9g_3S6j-4U-1CrEhc0-bnv3Xaz6-07MN8Q,86
+debugpy/_vendored/pydevd/pydevd_attach_to_process/linux_and_mac/__pycache__/lldb_prepare.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/linux_and_mac/attach.cpp,sha256=Ayhl1EB5hFxv6hock7AyIbbU8CUexwMAYpC3HOjA7D4,3814
+debugpy/_vendored/pydevd/pydevd_attach_to_process/linux_and_mac/compile_linux.sh,sha256=oZ02LoUD5ieQMkHlTf4OyBNOcGXcekI6iUiN1-LuzQM,306
+debugpy/_vendored/pydevd/pydevd_attach_to_process/linux_and_mac/compile_mac.sh,sha256=5fKk48tVP0BHIsnSBFlQzXbOjIGtYuMAayIUidJUDig,256
+debugpy/_vendored/pydevd/pydevd_attach_to_process/linux_and_mac/compile_manylinux.cmd,sha256=BXvLii9zXcTb9J_BuwzFttVxZcu_HMHp50dt2ACaEi8,683
+debugpy/_vendored/pydevd/pydevd_attach_to_process/linux_and_mac/lldb_prepare.py,sha256=L760MdJEiX3VLFhRmXHBMPiFH4QOsIN8mlQDtffLiAU,1734
+debugpy/_vendored/pydevd/pydevd_attach_to_process/run_code_on_dllmain_amd64.dll,sha256=mwtWC2n02mH5jAyFZXdU_r6ek5aCelnNmcUdQlIO_JI,29256
+debugpy/_vendored/pydevd/pydevd_attach_to_process/run_code_on_dllmain_amd64.pdb,sha256=Ww6Cz5i_O1ExWrAFOSUUnbmzLpoPG01hjLsfDZW71d4,765952
+debugpy/_vendored/pydevd/pydevd_attach_to_process/run_code_on_dllmain_x86.dll,sha256=gslhogx_7zgY7Piu4-RWoLwRtReIiYo-nn67RxHTsOk,25680
+debugpy/_vendored/pydevd/pydevd_attach_to_process/run_code_on_dllmain_x86.pdb,sha256=IvXl4IcuN1wI1L0Ces7ygkGs43Q7cdsPZlA0lfd0C8k,774144
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__init__.py,sha256=O1PLI6LRmqL4MjpKXZdQ2I0SI0KaNXtQSiShxt13IK0,7129
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/breakpoint.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/compat.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/crash.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/debug.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/disasm.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/event.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/interactive.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/module.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/process.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/registry.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/search.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/sql.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/system.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/textio.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/thread.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/util.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/__pycache__/window.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/breakpoint.py,sha256=TpvUnKu_zuz3_6RdX1JOrjpVjZXsqT4feCVA9aWn_Ic,169903
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/compat.py,sha256=SpGO4mc7sdKDuqhmEb_WRz5N3XTBtziwzalbGyHkqdM,5470
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/crash.py,sha256=sx92VTBorIUR3OZ8pjQQAA81fynhUYLEXA__CrXFFO8,66661
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/debug.py,sha256=jw1EM8D2LHifHU3KRzvjjyNYNen1JsTGaEyR-xaAW_E,59178
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/disasm.py,sha256=o8-wwCNywMFoqhvStzTWY8XQOgbDm9oFF5bDZEu4Pcs,25106
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/event.py,sha256=-9Fp53KuQE6HusZOjdmQZRNxrcAKIXtZZlisuklI4lc,67016
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/interactive.py,sha256=dL3bLfb91ZbbNAm6JyXrNu2-Hntu8LNDrxnzM1RRTgg,85946
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/module.py,sha256=kXX6FVWCYKt-6Uq7Xbw_coL21ieWrSTn71IKswXTWBY,71737
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/process.py,sha256=XrZNbpWY1r1-zNY7VUFjUxFn94uRqNJHL4DU9SufRgc,184598
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/registry.py,sha256=X-hgttnzYjSd1ksxT_5XIVEwLrdQUdctGruvFm5ICp4,22135
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/search.py,sha256=Pv7iKcU4n3nbHTdwhAaJ44P-8RvKoNJ8vc6W1glCQhs,23902
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/sql.py,sha256=WE4Y2l4c9pqzs-wO56u-oBIf1HMYceG2QofumDZNANw,34677
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/system.py,sha256=lWcwWQ27_-n6TdRFIzSYCmHF95efv7C_UWXSItecnGg,45624
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/textio.py,sha256=ibVu862TQiy-0NQ8LZmA8EKbCVKjn6yqQN2uC2DYa_w,61387
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/thread.py,sha256=mrLUu0oJLzYbVKjwrrYqRp7ZGSDSn9MTz3ocjNZxdqI,76790
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/util.py,sha256=fCzpojywCCsGgQVtC3CivOuA8nKZI_hKim_bQnLKI18,36978
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__init__.py,sha256=sNam6ZNOafq8V-Bxl8P4AaSLJ8mXnh0QIH8lJ-7uwMI,2885
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/advapi32.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/context_amd64.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/context_i386.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/dbghelp.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/defines.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/gdi32.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/kernel32.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/ntdll.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/peb_teb.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/psapi.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/shell32.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/shlwapi.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/user32.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/version.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/__pycache__/wtsapi32.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/advapi32.py,sha256=xq9S3AZvG9myE8X7zqHxxetJY3Qm9ih_wkKJgv6wSYg,122129
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/context_amd64.py,sha256=NYCv5nzNCkxMGXV4Lsw_SSgW4cUbxsSwk6kA47vFFWE,24465
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/context_i386.py,sha256=ITxXkkDcvSa_rrTOPSRlK9gZPoJ-sWfj_fHEQbrvDBc,15869
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/dbghelp.py,sha256=RiKxGf8Y5mdpIxgSMCsVqXzFYv72sx_nteKNENW4Mzg,46365
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/defines.py,sha256=mbFEKxTDOqtKSlhCB0sr8kHM9qDGdd--VXYVaGDAxeY,21637
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/gdi32.py,sha256=74qIm3Z_oDz3YslQKMHgFKZhaGgCHdiOUSBvu1_ysWk,14681
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/kernel32.py,sha256=MZw6SpRIYmt1ommJtpF-Fit6Zt1W7W-c1WSCaNZmr4s,163857
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/ntdll.py,sha256=MNlmgSDx41lmLeuoFwDCggFd_DNBHRpAM_qkmPNM1w8,21135
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/peb_teb.py,sha256=sYd_L3RfrshoNQLel-xKGSCKw8ZFxQVCDTIJhivEJxE,139565
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/psapi.py,sha256=AyYm1hulh22zG1Ij7H4Kd2KI_DhOdxWjil4TF5dgfC0,14115
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/shell32.py,sha256=gKCJ_3ZT96mNzWEAsWJbrLrm4Kl0cFP8ewV9Ro6Y478,13176
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/shlwapi.py,sha256=wO6zmcNXxtd-dsvQlpu-OzZWGncLQeku2D-om1PW3xY,26209
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/user32.py,sha256=7T4sovy0k70NRLTvbjNnRHBb77kaxUaBptPillWnG24,53270
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/version.py,sha256=peqsvzAt43_RkG2dLute0HOhzEESjYeBI9QCS8H9nVs,34919
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/wtsapi32.py,sha256=k53SGP7RwETficHSURsonw8s6UYrelTMwVDaM25C8nQ,11136
+debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/window.py,sha256=QMgC_L2yKyhEryRSOXLmtDwXw9ih1W-XdD0WJvaGkys,24770
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/attach.cpp,sha256=p_3Qe8DqmsSfDMIIk7HwsIrkEV9u5a9Sk8xP5cWrAIE,28624
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/attach.h,sha256=DTbYGXw_cNWF4LVQ-vXCUdNsUjnuRA5ZZqillkSiUmM,1902
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/compile_windows.bat,sha256=PU-ReV3_SqfWmnmZCvLRFvCzMr-7X5GlC47P6EnD8Wk,2203
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/inject_dll.cpp,sha256=Mns0bIZBMk7UCWa5G679pjM2Ysf0cIXtzZQ4p_LXJS0,4925
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/py_win_helpers.hpp,sha256=08Pkhx2JZHYew8QJ0KU6PtxUCge9hoemmnD09BzyG0c,2555
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/run_code_in_memory.hpp,sha256=wArnTC7I9dhMXf-Zvk89pL3pS6THPxTeq9Y6JL-i8Aw,3470
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/run_code_on_dllmain.cpp,sha256=J8lP6LyANVEu1j9nbPWoNZElEtrerPDwhAf5s0VNmDM,2594
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/stdafx.cpp,sha256=V7p0gRbf2vbFE56arGZDEEGELAxYLvoVCVCbpuyc1uI,1021
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/stdafx.h,sha256=KpQpPe05GFC_V_oYvtCOvp_-FIe2AwdgXjU1KcOr7do,1198
+debugpy/_vendored/pydevd/pydevd_attach_to_process/windows/targetver.h,sha256=jFkZ1XNv-lhMFbGnmPOc9c0JgYgRxlVZaeoGnvofgvs,1035
+debugpy/_vendored/pydevd/pydevd_file_utils.py,sha256=mmLcTGbvRg95PitLZMewOE0zd846c1gUjW-LWQ6vCwY,37894
+debugpy/_vendored/pydevd/pydevd_plugins/__init__.py,sha256=Y9d1PR_ZXG6Um_fbdrrrYxUd16NKH7dilYrJKM4Tjsk,70
+debugpy/_vendored/pydevd/pydevd_plugins/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/__pycache__/django_debug.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/__pycache__/jinja2_debug.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/__pycache__/pydevd_line_validation.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/django_debug.py,sha256=AIbmvFrIxlafPTKyWR1TByom319jHViczS6ZfiXSzQE,22886
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/README.md,sha256=CI5kXels64qHrhuAj_ur5nM_VWSc5qVdqKK_yxfhEPw,1212
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/__init__.py,sha256=Y9d1PR_ZXG6Um_fbdrrrYxUd16NKH7dilYrJKM4Tjsk,70
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/__init__.py,sha256=Y9d1PR_ZXG6Um_fbdrrrYxUd16NKH7dilYrJKM4Tjsk,70
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/__pycache__/__init__.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/__pycache__/pydevd_helpers.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/__pycache__/pydevd_plugin_numpy_types.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/__pycache__/pydevd_plugin_pandas_types.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/__pycache__/pydevd_plugins_django_form_str.cpython-311.pyc,,
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/pydevd_helpers.py,sha256=tVSLPkkz72XP_oZB65d8g2QSyWw9s_xC6PJWAf4m46w,668
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/pydevd_plugin_numpy_types.py,sha256=fxqg7mU63bmSnufIcr1JTyLzpZ82-LpjCfWE82aG7bQ,3340
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/pydevd_plugin_pandas_types.py,sha256=U38XXWAIWAHqC2Btr3KrdDVfbLnOOAMzSM5ISQ7d5fQ,6753
+debugpy/_vendored/pydevd/pydevd_plugins/extensions/types/pydevd_plugins_django_form_str.py,sha256=vmaeRbzc7EatYQkSf7TlqnsBX7oGd1hAXIhH5PU6-J4,556
+debugpy/_vendored/pydevd/pydevd_plugins/jinja2_debug.py,sha256=yb71a1FePKIGixKw72k9GnnLyJ3w5-3WQEwoxAwPaIs,19546
+debugpy/_vendored/pydevd/pydevd_plugins/pydevd_line_validation.py,sha256=_qfstAYOavoSnILqodUaQFuM8v0zSvIk6JAoTKUg_R8,6774
+debugpy/_vendored/pydevd/pydevd_tracing.py,sha256=QUQB9XH8CR_c4BwKqO9kTb7RQCPoti3B-Vmu1dv_dVM,16186
+debugpy/_vendored/pydevd/setup_pydevd_cython.py,sha256=3eLiBRPDYUlMCP1Ik9kidZsE_HLc4y3nqI9pFuZ8IE8,11842
+debugpy/_version.py,sha256=J2b20uXGygoVIk6NuszgffoyDBA0k-HVBpoqE0stuFg,519
+debugpy/adapter/__init__.py,sha256=9VLYulLGYHJ8oFJejptNs5mvWU2qqAbphIqXGfV87gw,360
+debugpy/adapter/__main__.py,sha256=tP7h_OqcNePjPTFW1KeD_97JLCLLFocWDxAPQSCcYcA,8675
+debugpy/adapter/__pycache__/__init__.cpython-311.pyc,,
+debugpy/adapter/__pycache__/__main__.cpython-311.pyc,,
+debugpy/adapter/__pycache__/clients.cpython-311.pyc,,
+debugpy/adapter/__pycache__/components.cpython-311.pyc,,
+debugpy/adapter/__pycache__/launchers.cpython-311.pyc,,
+debugpy/adapter/__pycache__/servers.cpython-311.pyc,,
+debugpy/adapter/__pycache__/sessions.cpython-311.pyc,,
+debugpy/adapter/clients.py,sha256=0Wf1uLzkQn7zd4vGPrdGTWeqUJhsWe3S75FYvrNMBKw,32175
+debugpy/adapter/components.py,sha256=3iuFqOoHNmbugkjLTJaXKMHO7_Uem7CBQikKNerW-w0,6264
+debugpy/adapter/launchers.py,sha256=M7iFl5trGxMnp_B_uZwwHZznhqVhedx8dkVC7c0u_BA,7198
+debugpy/adapter/servers.py,sha256=8rpQF1QzMrf3oYR7-0npxh5300WQrM1rU-Pr0T7yfRg,24038
+debugpy/adapter/sessions.py,sha256=hR3mtUqsWaOXooSM4Ue2K7Rgn7pm7d2m4A7g2adVEYA,11522
+debugpy/common/__init__.py,sha256=KJPKmTS_6sBWcehBitspx4Mby9DUzq3FOc77G0clV6E,627
+debugpy/common/__pycache__/__init__.cpython-311.pyc,,
+debugpy/common/__pycache__/json.cpython-311.pyc,,
+debugpy/common/__pycache__/log.cpython-311.pyc,,
+debugpy/common/__pycache__/messaging.cpython-311.pyc,,
+debugpy/common/__pycache__/singleton.cpython-311.pyc,,
+debugpy/common/__pycache__/sockets.cpython-311.pyc,,
+debugpy/common/__pycache__/stacks.cpython-311.pyc,,
+debugpy/common/__pycache__/timestamp.cpython-311.pyc,,
+debugpy/common/__pycache__/util.cpython-311.pyc,,
+debugpy/common/json.py,sha256=UnJu4Pe04UKnhf2z9kSi8W06TXP1FS_8pqQFM4VTndc,9966
+debugpy/common/log.py,sha256=MCbcJ0cazhwXedkCTeeT3QboDGRd36QKD9gQy7XtSpk,12117
+debugpy/common/messaging.py,sha256=QcZUJ6Ks1orq7L4xHfLdrJPkiuldnJeYGpnhmI6kVvs,58126
+debugpy/common/singleton.py,sha256=yxPI3MZPFAGG2sR-D0FasyW7quOYgfHZPHBFmJ7k8mM,7851
+debugpy/common/sockets.py,sha256=EwaKwnr51LBw9FlFemhKrG9NAEG_VltgCT6Id_xhNVM,4353
+debugpy/common/stacks.py,sha256=GvTcJ3ZJTP7vzzxpx6JlrHAmHwqy5oz1g-76bU386Qw,1588
+debugpy/common/timestamp.py,sha256=2LWsYfZQcG8W6KZ8qSQ-HKPMfU1hf9Nc-H1pYARGRgI,432
+debugpy/common/util.py,sha256=yniEG6I6317PeYtVtkoJwxBbsjCiFi678VSb-Ygv-yQ,4810
+debugpy/launcher/__init__.py,sha256=bSEVPlO2JT0zlugnosDwCHPWGL_lmNjJNzmtXA2a6zg,922
+debugpy/launcher/__main__.py,sha256=u9Nc4PaX-KkPNfeZmmH8LphH7ZKvbi-VuGJwnIiRVRo,3903
+debugpy/launcher/__pycache__/__init__.cpython-311.pyc,,
+debugpy/launcher/__pycache__/__main__.cpython-311.pyc,,
+debugpy/launcher/__pycache__/debuggee.cpython-311.pyc,,
+debugpy/launcher/__pycache__/handlers.cpython-311.pyc,,
+debugpy/launcher/__pycache__/output.cpython-311.pyc,,
+debugpy/launcher/__pycache__/winapi.cpython-311.pyc,,
+debugpy/launcher/debuggee.py,sha256=VEL5pjpPjdB8zxWgdFbXMO5rCGM0vpYX6RZYN0RjEU8,8939
+debugpy/launcher/handlers.py,sha256=J2KB770M5kKmTVpknHQyyUwTVoG2W6CZB9Ipam0Ls7Y,5880
+debugpy/launcher/output.py,sha256=1y09nznPtkUqqidI6g0frl5d1uif0oQfrPunMCDujU4,3861
+debugpy/launcher/winapi.py,sha256=Tv91QeBxe20DIHvq4nm5xvVsAqXnUWunP4ooonkL8CY,3233
+debugpy/public_api.py,sha256=hb0i5IATZf75YX7rNBO_u6B3UJI3RhI0O2NXeqSIRtg,6571
+debugpy/server/__init__.py,sha256=svouy9JSW9D-Tyq2rACkjvvzhVi-QOHBsJObchqeMh4,330
+debugpy/server/__pycache__/__init__.cpython-311.pyc,,
+debugpy/server/__pycache__/api.cpython-311.pyc,,
+debugpy/server/__pycache__/attach_pid_injected.cpython-311.pyc,,
+debugpy/server/__pycache__/cli.cpython-311.pyc,,
+debugpy/server/api.py,sha256=OwGnr67koBrn6d8vw1c2WaUpIcnzmc4MfoMaEV5gI8U,12152
+debugpy/server/attach_pid_injected.py,sha256=uaeCAnKEFEehZxyFWgMSr_3CM4ELG4H9GCif6o4Xyv8,2826
+debugpy/server/cli.py,sha256=aHWvaGPBivve7CMUmv5pObAbeQu6kLarm6PywmxxA8I,16862
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.2)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+
@@ -0,0 +1,2 @@
+[console_scripts]
+debugpy = debugpy.server.cli:main
@@ -0,0 +1 @@
+debugpy
@@ -0,0 +1,499 @@
+
+THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
+Do Not Translate or Localize
+
+debugpy incorporates third party material from the projects listed below.
+
+
+1.  PyDev.Debugger  (https://github.com/fabioz/PyDev.Debugger)
+        Includes:File copyright Brainwy Software Ltda.
+        Includes:File(s) related to Python, Cpython
+        Includes:File authored by Yuli Fitterman
+        Includes:File copyright Brainwy software Ltda
+        Includes:File with methods from Spyder
+        Includes:File(s) related to IPython
+        Includes:Files copyright Microsoft Corporation
+        Includes:six
+        Includes:WinAppDbg
+        Includes:XML-RPC client interface for Python
+
+
+%% PyDev.Debugger  NOTICES, INFORMATION, AND LICENSE BEGIN HERE
+=========================================
+The source code for the PyDev.Debugger files are provided with debugpy, or you may send a check or money order for US $5.00, including the product name (debugpy), the open source component name (PyDev.Debugger) and version number, to: Source Code Compliance Team, Microsoft Corporation, One Microsoft Way, Redmond, WA 98052, USA.
+
+Eclipse Public License, Version 1.0 (EPL-1.0)
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+1. DEFINITIONS
+"Contribution" means:
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+b) in the case of each subsequent Contributor:
+i) changes to the Program, and
+ii) additions to the Program;
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor. A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not derivative works of the Program.
+"Contributor" means any person or entity that distributes the Program.
+"Licensed Patents" mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of its Contribution alone or when combined with the Program.
+"Program" means the Contributions distributed in accordance with this Agreement.
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+2. GRANT OF RIGHTS
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code form.
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to grant the copyright license set forth in this Agreement.
+3. REQUIREMENTS
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+a) it complies with the terms and conditions of this Agreement; and
+b) its license agreement:
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and fitness for a particular purpose;
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special, incidental and consequential damages, such as lost profits;
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any other party; and
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it in a reasonable manner on or through a medium customarily used for software exchange.
+When the Program is made available in source code form:
+a) it must be made available under this Agreement; and
+b) a copy of this Agreement must be included with each copy of the Program.
+Contributors may not remove or alter any copyright notices contained within the Program.
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows subsequent Recipients to identify the originator of the Contribution.
+4. COMMERCIAL DISTRIBUTION
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes the Program in a commercial product offering should do so in a manner which does not create potential liability for other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor ("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor") against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may participate in any such claim at its own expense.
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone. Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result, the Commercial Contributor must pay those damages.
+5. NO WARRANTY
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED 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. Each Recipient is solely responsible for determining the appropriateness of using and distributing the Program and assumes all risks associated with its exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+6. DISCLAIMER OF LIABILITY
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), 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 OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+7. GENERAL
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such litigation is filed.
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses granted by Recipient relating to the Program shall continue and survive.
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the Agreement will be given a distinguishing version number. The Program (including Contributions) may always be distributed subject to the version of the Agreement under which it was received. In addition, after a new version of the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause of action arose. Each party waives its rights to a jury trial in any resulting litigation.
+=========================================
+Includes File copyright Brainwy Software Ltda.
+
+File includes the following notice:
+
+Copyright: Brainwy Software Ltda.
+
+License: EPL.
+
+=========================================
+Includes file(s) from Python, Python xreload, Cpython and an ActiveState.com Recipe on "NULL OBJECT DESIGN PATTERN (PYTHON RECIPE)"
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+analyze, test, perform and/or display publicly, prepare derivative works,
+distribute, and otherwise use Python alone or in any derivative version,
+provided, however, that PSF's License Agreement and PSF's notice of copyright,
+i.e., "Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+2011, 2012, 2013, 2014, 2015, 2016, 2017 Python Software Foundation; All Rights
+Reserved" are retained in Python alone or in any derivative version prepared by
+Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the Internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the Internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (C) 2006-2010 Python Software Foundation
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+=========================================
+Includes File authored by Yuli Fitterman
+
+Copyright (c) Yuli Fitterman
+
+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.
+=========================================
+Includes file(s):  * Copyright (c) Brainwy software Ltda.
+ *
+ * This source code is subject to terms and conditions of the Apache License, Version 2.0. A
+ * copy of the license can be found in the License.html file at the root of this distribution. If
+ * you cannot locate the Apache License, Version 2.0, please send an email to
+ * vspython@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
+ * by the terms of the Apache License, Version 2.0.
+ *
+ * You must not remove this notice, or any other, from this software.
+=========================================
+Includes file(s): Copyright (c) 2009-2012 Pierre Raybaut
+
+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.
+=========================================
+Includes file(s) from Ipython
+
+Copyright (c) 2008-2010, IPython Development Team
+Copyright (c) 2001-2007, Fernando Perez. <fernando.perez@colorado.edu>
+Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
+Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
+
+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 IPython Development Team 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.
+=========================================
+Includes file(s): * Copyright (c) Microsoft Corporation.
+*
+* This source code is subject to terms and conditions of the Apache License, Version 2.0. A
+* copy of the license can be found in the License.html file at the root of this distribution. If
+* you cannot locate the Apache License, Version 2.0, please send an email to
+* vspython@microsoft.com. By using this source code in any fashion, you are agreeing to be bound
+* by the terms of the Apache License, Version 2.0.
+*
+* You must not remove this notice, or any other, from this software.
+=========================================
+Includes file(s) from https://pythonhosted.org/six/
+
+Copyright (c) 2010-2018 Benjamin Peterson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+=========================================
+Includes WinAppDbg
+
+# Copyright (c) 2009-2014, Mario Vilas
+# 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 copyright holder 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.
+=========================================
+Includes XML-RPC client interface for Python
+# Copyright (c) 1999-2002 by Secret Labs AB
+# Copyright (c) 1999-2002 by Fredrik Lundh
+#
+# By obtaining, using, and/or copying this software and/or its
+# associated documentation, you agree that you have read, understood,
+# and will comply with the following terms and conditions:
+#
+# Permission to use, copy, modify, and distribute this software and
+# its associated documentation for any purpose and without fee is
+# hereby granted, provided that the above copyright notice appears in
+# all copies, and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Secret Labs AB or the author not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
+# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
+# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+=========================================
+Includes https://github.com/vstinner/bytecode e3e77fb690ed05ac171e15694e1c5d0e0dc34e86 - MIT
+
+Copyright (c) 2016 Red Hat.
+
+The MIT License (MIT)
+Copyright (c) 2016 Red Hat.
+
+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.
+=========================================
+Includes https://github.com/benhoyt/scandir 6ed381881bc2fb9de05804e892eeeeb3601a3af2 - BSD 3-Clause "New" or "Revised" License
+
+Copyright (c) 2012, Ben Hoyt
+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 Ben Hoyt 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 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.
+=========================================
+END OF PyDev.Debugger  NOTICES, INFORMATION, AND LICENSE
@@ -0,0 +1,38 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+"""An implementation of the Debug Adapter Protocol (DAP) for Python.
+
+https://microsoft.github.io/debug-adapter-protocol/
+"""
+
+# debugpy stable public API consists solely of members of this module that are
+# enumerated below.
+__all__ = [  # noqa
+    "__version__",
+    "breakpoint",
+    "configure",
+    "connect",
+    "debug_this_thread",
+    "is_client_connected",
+    "listen",
+    "log_to",
+    "trace_this_thread",
+    "wait_for_client",
+]
+
+import sys
+
+assert sys.version_info >= (3, 7), (
+    "Python 3.6 and below is not supported by this version of debugpy; "
+    "use debugpy 1.5.1 or earlier."
+)
+
+
+# Actual definitions are in a separate file to work around parsing issues causing
+# SyntaxError on Python 2 and preventing the above version check from executing.
+from debugpy.public_api import *  # noqa
+from debugpy.public_api import __version__
+
+del sys
@@ -0,0 +1,71 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+import sys
+
+if __name__ == "__main__":
+
+    # There are three ways to run debugpy:
+    #
+    # 1. Installed as a module in the current environment (python -m debugpy ...)
+    # 2. Run as a script from source code (python <repo_root>/src/debugpy ...)
+    # 3. Installed as a module in a random directory
+    #
+    # -----
+    #
+    # In the first case, no extra work is needed. Importing debugpy will work as expected.
+    # Also, running 'debugpy' instead of 'python -m debugpy' will work because of the entry point
+    # defined in setup.py.
+    #
+    # -----
+    #
+    # In the second case, sys.path[0] is the one added automatically by Python for the directory 
+    # containing this file. 'import debugpy' will not work since we need the parent directory 
+    # of debugpy/ to be in sys.path, rather than debugpy/ itself. So we need to modify sys.path[0].
+    # Running 'debugpy' will not work because the entry point is not defined in this case.
+    #
+    # -----
+    #
+    # In the third case, running 'python -m debugpy' will not work because the module is not installed
+    # in any environment. Running 'python <install_dir>/debugpy' will work, just like the second case. 
+    # But running the entry point will not work because python doesn't know where to find the debugpy module.
+    #
+    # In this case, no changes to sys.path are required. You just have to do the following before calling
+    # the entry point:
+    #   1. Add <install_dir> to PYTHONPATH.
+    #       On Windows, this is set PYTHONPATH=%PYTHONPATH%;<install_dir>
+    #   2. Add <install_dir>/bin to PATH. (OPTIONAL)
+    #       On Windows, this is set PATH=%PATH%;<install_dir>\bin
+    #   3. Run the entry point from a command prompt
+    #       On Windows, this is <install_dir>\bin\debugpy.exe, or just 'debugpy' if you did the previous step.
+    #
+    # -----
+    #
+    # If we modify sys.path, 'import debugpy' will work, but it will break other imports
+    # because they will be resolved relative to debugpy/ - e.g. `import debugger` will try
+    # to import debugpy/debugger.py.
+    #
+    # To fix both problems, we need to do the following steps:
+    # 1. Modify sys.path[0] to point at the parent directory of debugpy/ instead of debugpy/ itself.
+    # 2. Import debugpy.
+    # 3. Remove sys.path[0] so that it doesn't affect future imports. 
+    # 
+    # For example, suppose the user did:
+    #
+    #   python /foo/bar/debugpy ...
+    #
+    # At the beginning of this script, sys.path[0] will contain "/foo/bar/debugpy".
+    # We want to replace it with "/foo/bar', then 'import debugpy', then remove the replaced entry.
+    # The imported debugpy module will remain in sys.modules, and thus all future imports of it 
+    # or its submodules will resolve accordingly.
+    if "debugpy" not in sys.modules:
+
+        # Do not use dirname() to walk up - this can be a relative path, e.g. ".".
+        sys.path[0] = sys.path[0] + "/../"
+        import debugpy  # noqa
+        del sys.path[0]
+
+    from debugpy.server import cli
+
+    cli.main()
@@ -0,0 +1,126 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+import contextlib
+from importlib import import_module
+import os
+import sys
+
+from . import _util
+
+
+VENDORED_ROOT = os.path.dirname(os.path.abspath(__file__))
+# TODO: Move the "pydevd" git submodule to the debugpy/_vendored directory
+# and then drop the following fallback.
+if "pydevd" not in os.listdir(VENDORED_ROOT):
+    VENDORED_ROOT = os.path.dirname(VENDORED_ROOT)
+
+
+def list_all(resolve=False):
+    """Return the list of vendored projects."""
+    # TODO: Derive from os.listdir(VENDORED_ROOT)?
+    projects = ["pydevd"]
+    if not resolve:
+        return projects
+    return [project_root(name) for name in projects]
+
+
+def project_root(project):
+    """Return the path the root dir of the vendored project.
+
+    If "project" is an empty string then the path prefix for vendored
+    projects (e.g. "debugpy/_vendored/") will be returned.
+    """
+    if not project:
+        project = ""
+    return os.path.join(VENDORED_ROOT, project)
+
+
+def iter_project_files(project, relative=False, **kwargs):
+    """Yield (dirname, basename, filename) for all files in the project."""
+    if relative:
+        with _util.cwd(VENDORED_ROOT):
+            for result in _util.iter_all_files(project, **kwargs):
+                yield result
+    else:
+        root = project_root(project)
+        for result in _util.iter_all_files(root, **kwargs):
+            yield result
+
+
+def iter_packaging_files(project):
+    """Yield the filenames for all files in the project.
+
+    The filenames are relative to "debugpy/_vendored".  This is most
+    useful for the "package data" in a setup.py.
+    """
+    # TODO: Use default filters?  __pycache__ and .pyc?
+    prune_dir = None
+    exclude_file = None
+    try:
+        mod = import_module("._{}_packaging".format(project), __name__)
+    except ImportError:
+        pass
+    else:
+        prune_dir = getattr(mod, "prune_dir", prune_dir)
+        exclude_file = getattr(mod, "exclude_file", exclude_file)
+    results = iter_project_files(
+        project, relative=True, prune_dir=prune_dir, exclude_file=exclude_file
+    )
+    for _, _, filename in results:
+        yield filename
+
+
+def prefix_matcher(*prefixes):
+    """Return a module match func that matches any of the given prefixes."""
+    assert prefixes
+
+    def match(name, module):
+        for prefix in prefixes:
+            if name.startswith(prefix):
+                return True
+        else:
+            return False
+
+    return match
+
+
+def check_modules(project, match, root=None):
+    """Verify that only vendored modules have been imported."""
+    if root is None:
+        root = project_root(project)
+    extensions = []
+    unvendored = {}
+    for modname, mod in list(sys.modules.items()):
+        if not match(modname, mod):
+            continue
+        try:
+            filename = getattr(mod, "__file__", None)
+        except:  # In theory it's possible that any error is raised when accessing __file__
+            filename = None
+        if not filename:  # extension module
+            extensions.append(modname)
+        elif not filename.startswith(root):
+            unvendored[modname] = filename
+    return unvendored, extensions
+
+
+@contextlib.contextmanager
+def vendored(project, root=None):
+    """A context manager under which the vendored project will be imported."""
+    if root is None:
+        root = project_root(project)
+    # Add the vendored project directory, so that it gets tried first.
+    sys.path.insert(0, root)
+    try:
+        yield root
+    finally:
+        sys.path.remove(root)
+
+
+def preimport(project, modules, **kwargs):
+    """Import each of the named modules out of the vendored project."""
+    with vendored(project, **kwargs):
+        for name in modules:
+            import_module(name)
@@ -0,0 +1,48 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+from . import VENDORED_ROOT
+from ._util import cwd, iter_all_files
+
+
+INCLUDES = [
+    'setup_pydevd_cython.py',
+]
+
+
+def iter_files():
+    # From the root of pydevd repo, we want only scripts and
+    # subdirectories that constitute the package itself (not helper
+    # scripts, tests etc). But when walking down into those
+    # subdirectories, we want everything below.
+
+    with cwd(VENDORED_ROOT):
+        return iter_all_files('pydevd', prune_dir, exclude_file)
+
+
+def prune_dir(dirname, basename):
+    if basename == '__pycache__':
+        return True
+    elif dirname != 'pydevd':
+        return False
+    elif basename.startswith('pydev'):
+        return False
+    elif basename.startswith('_pydev'):
+        return False
+    return True
+
+
+def exclude_file(dirname, basename):
+    if dirname == 'pydevd':
+        if basename in INCLUDES:
+            return False
+        elif not basename.endswith('.py'):
+            return True
+        elif 'pydev' not in basename:
+            return True
+        return False
+
+    if basename.endswith('.pyc'):
+        return True
+    return False
@@ -0,0 +1,59 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+import contextlib
+import os
+
+
+@contextlib.contextmanager
+def cwd(dirname):
+    """A context manager for operating in a different directory."""
+    orig = os.getcwd()
+    os.chdir(dirname)
+    try:
+        yield orig
+    finally:
+        os.chdir(orig)
+
+
+def iter_all_files(root, prune_dir=None, exclude_file=None):
+    """Yield (dirname, basename, filename) for each file in the tree.
+
+    This is an alternative to os.walk() that flattens out the tree and
+    with filtering.
+    """
+    pending = [root]
+    while pending:
+        dirname = pending.pop(0)
+        for result in _iter_files(dirname, pending, prune_dir, exclude_file):
+            yield result
+
+
+def iter_tree(root, prune_dir=None, exclude_file=None):
+    """Yield (dirname, files) for each directory in the tree.
+
+    The list of files is actually a list of (basename, filename).
+
+    This is an alternative to os.walk() with filtering."""
+    pending = [root]
+    while pending:
+        dirname = pending.pop(0)
+        files = []
+        for _, b, f in _iter_files(dirname, pending, prune_dir, exclude_file):
+            files.append((b, f))
+        yield dirname, files
+
+
+def _iter_files(dirname, subdirs, prune_dir, exclude_file):
+    for basename in os.listdir(dirname):
+        filename = os.path.join(dirname, basename)
+        if os.path.isdir(filename):
+            if prune_dir is not None and prune_dir(dirname, basename):
+                continue
+            subdirs.append(filename)
+        else:
+            # TODO: Use os.path.isfile() to narrow it down?
+            if exclude_file is not None and exclude_file(dirname, basename):
+                continue
+            yield dirname, basename, filename
@@ -0,0 +1,81 @@
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE in the project root
+# for license information.
+
+from importlib import import_module
+import os
+import warnings
+
+from . import check_modules, prefix_matcher, preimport, vendored
+
+# Ensure that pydevd is our vendored copy.
+_unvendored, _ = check_modules('pydevd',
+                               prefix_matcher('pydev', '_pydev'))
+if _unvendored:
+    _unvendored = sorted(_unvendored.values())
+    msg = 'incompatible copy of pydevd already imported'
+    # raise ImportError(msg)
+    warnings.warn(msg + ':\n {}'.format('\n  '.join(_unvendored)))
+
+# If debugpy logging is enabled, enable it for pydevd as well
+if "DEBUGPY_LOG_DIR" in os.environ:
+    os.environ[str("PYDEVD_DEBUG")] = str("True")
+    os.environ[str("PYDEVD_DEBUG_FILE")] = os.environ["DEBUGPY_LOG_DIR"] + str("/debugpy.pydevd.log")
+
+# Disable pydevd frame-eval optimizations only if unset, to allow opt-in.
+if "PYDEVD_USE_FRAME_EVAL" not in os.environ:
+    os.environ[str("PYDEVD_USE_FRAME_EVAL")] = str("NO")
+
+# Constants must be set before importing any other pydevd module
+# # due to heavy use of "from" in them.
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", category=DeprecationWarning)
+    with vendored('pydevd'):
+        pydevd_constants = import_module('_pydevd_bundle.pydevd_constants')
+# We limit representation size in our representation provider when needed.
+pydevd_constants.MAXIMUM_VARIABLE_REPRESENTATION_SIZE = 2 ** 32
+
+# Now make sure all the top-level modules and packages in pydevd are
+# loaded.  Any pydevd modules that aren't loaded at this point, will
+# be loaded using their parent package's __path__ (i.e. one of the
+# following).
+with warnings.catch_warnings():
+    warnings.simplefilter("ignore", category=DeprecationWarning)
+    preimport('pydevd', [
+        '_pydev_bundle',
+        '_pydev_runfiles',
+        '_pydevd_bundle',
+        '_pydevd_frame_eval',
+        'pydev_ipython',
+        'pydevd_plugins',
+        'pydevd',
+    ])
+
+# When pydevd is imported it sets the breakpoint behavior, but it needs to be
+# overridden because by default pydevd will connect to the remote debugger using
+# its own custom protocol rather than DAP.
+import pydevd  # noqa
+import debugpy  # noqa
+
+
+def debugpy_breakpointhook():
+    debugpy.breakpoint()
+
+
+pydevd.install_breakpointhook(debugpy_breakpointhook)
+
+# Ensure that pydevd uses JSON protocol
+from _pydevd_bundle import pydevd_constants
+from _pydevd_bundle import pydevd_defaults
+pydevd_defaults.PydevdCustomization.DEFAULT_PROTOCOL = pydevd_constants.HTTP_JSON_PROTOCOL
+
+# Enable some defaults related to debugpy such as sending a single notification when
+# threads pause and stopping on any exception.
+pydevd_defaults.PydevdCustomization.DEBUG_MODE = 'debugpy-dap'
+
+# This is important when pydevd attaches automatically to a subprocess. In this case, we have to
+# make sure that debugpy is properly put back in the game for users to be able to use it.
+pydevd_defaults.PydevdCustomization.PREIMPORT = '%s;%s' % (
+    os.path.dirname(os.path.dirname(debugpy.__file__)), 
+    'debugpy._vendored.force_pydevd'
+)
@@ -0,0 +1,153 @@
+"""
+License: Apache 2.0
+Author: Yuli Fitterman
+"""
+import types
+
+from _pydevd_bundle.pydevd_constants import IS_JYTHON
+
+try:
+    import inspect
+except:
+    import traceback
+
+    traceback.print_exc()  # Ok, no inspect available (search will not work)
+
+from _pydev_bundle._pydev_imports_tipper import signature_from_docstring
+
+
+def is_bound_method(obj):
+    if isinstance(obj, types.MethodType):
+        return getattr(obj, "__self__", getattr(obj, "im_self", None)) is not None
+    else:
+        return False
+
+
+def get_class_name(instance):
+    return getattr(getattr(instance, "__class__", None), "__name__", None)
+
+
+def get_bound_class_name(obj):
+    my_self = getattr(obj, "__self__", getattr(obj, "im_self", None))
+    if my_self is None:
+        return None
+    return get_class_name(my_self)
+
+
+def get_description(obj):
+    try:
+        ob_call = obj.__call__
+    except:
+        ob_call = None
+
+    if isinstance(obj, type) or type(obj).__name__ == "classobj":
+        fob = getattr(obj, "__init__", lambda: None)
+        if not isinstance(fob, (types.FunctionType, types.MethodType)):
+            fob = obj
+    elif is_bound_method(ob_call):
+        fob = ob_call
+    else:
+        fob = obj
+
+    argspec = ""
+    fn_name = None
+    fn_class = None
+    if isinstance(fob, (types.FunctionType, types.MethodType)):
+        spec_info = inspect.getfullargspec(fob)
+        argspec = inspect.formatargspec(*spec_info)
+        fn_name = getattr(fob, "__name__", None)
+        if isinstance(obj, type) or type(obj).__name__ == "classobj":
+            fn_name = "__init__"
+            fn_class = getattr(obj, "__name__", "UnknownClass")
+        elif is_bound_method(obj) or is_bound_method(ob_call):
+            fn_class = get_bound_class_name(obj) or "UnknownClass"
+
+    else:
+        fn_name = getattr(fob, "__name__", None)
+        fn_self = getattr(fob, "__self__", None)
+        if fn_self is not None and not isinstance(fn_self, types.ModuleType):
+            fn_class = get_class_name(fn_self)
+
+    doc_string = get_docstring(ob_call) if is_bound_method(ob_call) else get_docstring(obj)
+    return create_method_stub(fn_name, fn_class, argspec, doc_string)
+
+
+def create_method_stub(fn_name, fn_class, argspec, doc_string):
+    if fn_name and argspec:
+        doc_string = "" if doc_string is None else doc_string
+        fn_stub = create_function_stub(fn_name, argspec, doc_string, indent=1 if fn_class else 0)
+        if fn_class:
+            expr = fn_class if fn_name == "__init__" else fn_class + "()." + fn_name
+            return create_class_stub(fn_class, fn_stub) + "\n" + expr
+        else:
+            expr = fn_name
+            return fn_stub + "\n" + expr
+    elif doc_string:
+        if fn_name:
+            restored_signature, _ = signature_from_docstring(doc_string, fn_name)
+            if restored_signature:
+                return create_method_stub(fn_name, fn_class, restored_signature, doc_string)
+        return create_function_stub("unknown", "(*args, **kwargs)", doc_string) + "\nunknown"
+
+    else:
+        return ""
+
+
+def get_docstring(obj):
+    if obj is not None:
+        try:
+            if IS_JYTHON:
+                # Jython
+                doc = obj.__doc__
+                if doc is not None:
+                    return doc
+
+                from _pydev_bundle import _pydev_jy_imports_tipper
+
+                is_method, infos = _pydev_jy_imports_tipper.ismethod(obj)
+                ret = ""
+                if is_method:
+                    for info in infos:
+                        ret += info.get_as_doc()
+                    return ret
+
+            else:
+                doc = inspect.getdoc(obj)
+                if doc is not None:
+                    return doc
+        except:
+            pass
+    else:
+        return ""
+    try:
+        # if no attempt succeeded, try to return repr()...
+        return repr(obj)
+    except:
+        try:
+            # otherwise the class
+            return str(obj.__class__)
+        except:
+            # if all fails, go to an empty string
+            return ""
+
+
+def create_class_stub(class_name, contents):
+    return "class %s(object):\n%s" % (class_name, contents)
+
+
+def create_function_stub(fn_name, fn_argspec, fn_docstring, indent=0):
+    def shift_right(string, prefix):
+        return "".join(prefix + line for line in string.splitlines(True))
+
+    fn_docstring = shift_right(inspect.cleandoc(fn_docstring), "  " * (indent + 1))
+    ret = '''
+def %s%s:
+    """%s"""
+    pass
+''' % (fn_name, fn_argspec, fn_docstring)
+    ret = ret[1:]  # remove first /n
+    ret = ret.replace("\t", "  ")
+    if indent:
+        prefix = "  " * indent
+        ret = shift_right(ret, prefix)
+    return ret
@@ -0,0 +1,267 @@
+from collections import namedtuple
+from string import ascii_letters, digits
+
+from _pydevd_bundle import pydevd_xml
+import pydevconsole
+
+import builtins as __builtin__  # Py3
+
+try:
+    import java.lang  # @UnusedImport
+    from _pydev_bundle import _pydev_jy_imports_tipper
+
+    _pydev_imports_tipper = _pydev_jy_imports_tipper
+except ImportError:
+    IS_JYTHON = False
+    from _pydev_bundle import _pydev_imports_tipper
+
+dir2 = _pydev_imports_tipper.generate_imports_tip_for_module
+
+
+# =======================================================================================================================
+# _StartsWithFilter
+# =======================================================================================================================
+class _StartsWithFilter:
+    """
+    Used because we can't create a lambda that'll use an outer scope in jython 2.1
+    """
+
+    def __init__(self, start_with):
+        self.start_with = start_with.lower()
+
+    def __call__(self, name):
+        return name.lower().startswith(self.start_with)
+
+
+# =======================================================================================================================
+# Completer
+#
+# This class was gotten from IPython.completer (dir2 was replaced with the completer already in pydev)
+# =======================================================================================================================
+class Completer:
+    def __init__(self, namespace=None, global_namespace=None):
+        """Create a new completer for the command line.
+
+        Completer([namespace,global_namespace]) -> completer instance.
+
+        If unspecified, the default namespace where completions are performed
+        is __main__ (technically, __main__.__dict__). Namespaces should be
+        given as dictionaries.
+
+        An optional second namespace can be given.  This allows the completer
+        to handle cases where both the local and global scopes need to be
+        distinguished.
+
+        Completer instances should be used as the completion mechanism of
+        readline via the set_completer() call:
+
+        readline.set_completer(Completer(my_namespace).complete)
+        """
+
+        # Don't bind to namespace quite yet, but flag whether the user wants a
+        # specific namespace or to use __main__.__dict__. This will allow us
+        # to bind to __main__.__dict__ at completion time, not now.
+        if namespace is None:
+            self.use_main_ns = 1
+        else:
+            self.use_main_ns = 0
+            self.namespace = namespace
+
+        # The global namespace, if given, can be bound directly
+        if global_namespace is None:
+            self.global_namespace = {}
+        else:
+            self.global_namespace = global_namespace
+
+    def complete(self, text):
+        """Return the next possible completion for 'text'.
+
+        This is called successively with state == 0, 1, 2, ... until it
+        returns None.  The completion should begin with 'text'.
+
+        """
+        if self.use_main_ns:
+            # In pydev this option should never be used
+            raise RuntimeError("Namespace must be provided!")
+            self.namespace = __main__.__dict__  # @UndefinedVariable
+
+        if "." in text:
+            return self.attr_matches(text)
+        else:
+            return self.global_matches(text)
+
+    def global_matches(self, text):
+        """Compute matches when text is a simple name.
+
+        Return a list of all keywords, built-in functions and names currently
+        defined in self.namespace or self.global_namespace that match.
+
+        """
+
+        def get_item(obj, attr):
+            return obj[attr]
+
+        a = {}
+
+        for dict_with_comps in [__builtin__.__dict__, self.namespace, self.global_namespace]:  # @UndefinedVariable
+            a.update(dict_with_comps)
+
+        filter = _StartsWithFilter(text)
+
+        return dir2(a, a.keys(), get_item, filter)
+
+    def attr_matches(self, text):
+        """Compute matches when text contains a dot.
+
+        Assuming the text is of the form NAME.NAME....[NAME], and is
+        evaluatable in self.namespace or self.global_namespace, it will be
+        evaluated and its attributes (as revealed by dir()) are used as
+        possible completions.  (For class instances, class members are are
+        also considered.)
+
+        WARNING: this can still invoke arbitrary C code, if an object
+        with a __getattr__ hook is evaluated.
+
+        """
+        import re
+
+        # Another option, seems to work great. Catches things like ''.<tab>
+        m = re.match(r"(\S+(\.\w+)*)\.(\w*)$", text)  # @UndefinedVariable
+
+        if not m:
+            return []
+
+        expr, attr = m.group(1, 3)
+        try:
+            obj = eval(expr, self.namespace)
+        except:
+            try:
+                obj = eval(expr, self.global_namespace)
+            except:
+                return []
+
+        filter = _StartsWithFilter(attr)
+
+        words = dir2(obj, filter=filter)
+
+        return words
+
+
+def generate_completions(frame, act_tok):
+    """
+    :return list(tuple(method_name, docstring, parameters, completion_type))
+
+    method_name: str
+    docstring: str
+    parameters: str -- i.e.: "(a, b)"
+    completion_type is an int
+        See: _pydev_bundle._pydev_imports_tipper for TYPE_ constants
+    """
+    if frame is None:
+        return []
+
+    # Not using frame.f_globals because of https://sourceforge.net/tracker2/?func=detail&aid=2541355&group_id=85796&atid=577329
+    # (Names not resolved in generator expression in method)
+    # See message: http://mail.python.org/pipermail/python-list/2009-January/526522.html
+    updated_globals = {}
+    updated_globals.update(frame.f_globals)
+    updated_globals.update(frame.f_locals)  # locals later because it has precedence over the actual globals
+
+    if pydevconsole.IPYTHON:
+        completions = pydevconsole.get_completions(act_tok, act_tok, updated_globals, frame.f_locals)
+    else:
+        completer = Completer(updated_globals, None)
+        # list(tuple(name, descr, parameters, type))
+        completions = completer.complete(act_tok)
+
+    return completions
+
+
+def generate_completions_as_xml(frame, act_tok):
+    completions = generate_completions(frame, act_tok)
+    return completions_to_xml(completions)
+
+
+def completions_to_xml(completions):
+    valid_xml = pydevd_xml.make_valid_xml_value
+    quote = pydevd_xml.quote
+    msg = ["<xml>"]
+
+    for comp in completions:
+        msg.append('<comp p0="')
+        msg.append(valid_xml(quote(comp[0], "/>_= \t")))
+        msg.append('" p1="')
+        msg.append(valid_xml(quote(comp[1], "/>_= \t")))
+        msg.append('" p2="')
+        msg.append(valid_xml(quote(comp[2], "/>_= \t")))
+        msg.append('" p3="')
+        msg.append(valid_xml(quote(comp[3], "/>_= \t")))
+        msg.append('"/>')
+    msg.append("</xml>")
+
+    return "".join(msg)
+
+
+identifier_start = ascii_letters + "_"
+identifier_part = ascii_letters + "_" + digits
+
+identifier_start = set(identifier_start)
+identifier_part = set(identifier_part)
+
+
+def isidentifier(s):
+    return s.isidentifier()
+
+
+TokenAndQualifier = namedtuple("TokenAndQualifier", "token, qualifier")
+
+
+def extract_token_and_qualifier(text, line=0, column=0):
+    """
+    Extracts the token a qualifier from the text given the line/colum
+    (see test_extract_token_and_qualifier for examples).
+
+    :param unicode text:
+    :param int line: 0-based
+    :param int column: 0-based
+    """
+    # Note: not using the tokenize module because text should be unicode and
+    # line/column refer to the unicode text (otherwise we'd have to know
+    # those ranges after converted to bytes).
+    if line < 0:
+        line = 0
+    if column < 0:
+        column = 0
+
+    if isinstance(text, bytes):
+        text = text.decode("utf-8")
+
+    lines = text.splitlines()
+    try:
+        text = lines[line]
+    except IndexError:
+        return TokenAndQualifier("", "")
+
+    if column >= len(text):
+        column = len(text)
+
+    text = text[:column]
+    token = ""
+    qualifier = ""
+
+    temp_token = []
+    for i in range(column - 1, -1, -1):
+        c = text[i]
+        if c in identifier_part or isidentifier(c) or c == ".":
+            temp_token.append(c)
+        else:
+            break
+    temp_token = "".join(reversed(temp_token))
+    if "." in temp_token:
+        temp_token = temp_token.split(".")
+        token = ".".join(temp_token[:-1])
+        qualifier = temp_token[-1]
+    else:
+        qualifier = temp_token
+
+    return TokenAndQualifier(token, qualifier)
@@ -0,0 +1,16 @@
+# We must redefine it in Py3k if it's not already there
+def execfile(file, glob=None, loc=None):
+    if glob is None:
+        import sys
+
+        glob = sys._getframe().f_back.f_globals
+    if loc is None:
+        loc = glob
+
+    import tokenize
+
+    with tokenize.open(file) as stream:
+        contents = stream.read()
+
+    # execute the script (note: it's important to compile first to have the filename set in debug mode)
+    exec(compile(contents + "\n", file, "exec"), glob, loc)
@@ -0,0 +1,43 @@
+import sys
+
+
+def __getfilesystemencoding():
+    """
+    Note: there's a copy of this method in interpreterInfo.py
+    """
+    try:
+        ret = sys.getfilesystemencoding()
+        if not ret:
+            raise RuntimeError("Unable to get encoding.")
+        return ret
+    except:
+        try:
+            # Handle Jython
+            from java.lang import System  # @UnresolvedImport
+
+            env = System.getProperty("os.name").lower()
+            if env.find("win") != -1:
+                return "ISO-8859-1"  # mbcs does not work on Jython, so, use a (hopefully) suitable replacement
+            return "utf-8"
+        except:
+            pass
+
+        # Only available from 2.3 onwards.
+        if sys.platform == "win32":
+            return "mbcs"
+        return "utf-8"
+
+
+def getfilesystemencoding():
+    try:
+        ret = __getfilesystemencoding()
+
+        # Check if the encoding is actually there to be used!
+        if hasattr("", "encode"):
+            "".encode(ret)
+        if hasattr("", "decode"):
+            "".decode(ret)
+
+        return ret
+    except:
+        return "utf-8"
@@ -0,0 +1,133 @@
+# =======================================================================================================================
+# getopt code copied since gnu_getopt is not available on jython 2.1
+# =======================================================================================================================
+class GetoptError(Exception):
+    opt = ""
+    msg = ""
+
+    def __init__(self, msg, opt=""):
+        self.msg = msg
+        self.opt = opt
+        Exception.__init__(self, msg, opt)
+
+    def __str__(self):
+        return self.msg
+
+
+def gnu_getopt(args, shortopts, longopts=[]):
+    """getopt(args, options[, long_options]) -> opts, args
+
+    This function works like getopt(), except that GNU style scanning
+    mode is used by default. This means that option and non-option
+    arguments may be intermixed. The getopt() function stops
+    processing options as soon as a non-option argument is
+    encountered.
+
+    If the first character of the option string is `+', or if the
+    environment variable POSIXLY_CORRECT is set, then option
+    processing stops as soon as a non-option argument is encountered.
+    """
+
+    opts = []
+    prog_args = []
+    if type("") == type(longopts):
+        longopts = [longopts]
+    else:
+        longopts = list(longopts)
+
+    # Allow options after non-option arguments?
+    all_options_first = False
+    if shortopts.startswith("+"):
+        shortopts = shortopts[1:]
+        all_options_first = True
+
+    while args:
+        if args[0] == "--":
+            prog_args += args[1:]
+            break
+
+        if args[0][:2] == "--":
+            opts, args = do_longs(opts, args[0][2:], longopts, args[1:])
+        elif args[0][:1] == "-":
+            opts, args = do_shorts(opts, args[0][1:], shortopts, args[1:])
+        else:
+            if all_options_first:
+                prog_args += args
+                break
+            else:
+                prog_args.append(args[0])
+                args = args[1:]
+
+    return opts, prog_args
+
+
+def do_longs(opts, opt, longopts, args):
+    try:
+        i = opt.index("=")
+    except ValueError:
+        optarg = None
+    else:
+        opt, optarg = opt[:i], opt[i + 1 :]
+
+    has_arg, opt = long_has_args(opt, longopts)
+    if has_arg:
+        if optarg is None:
+            if not args:
+                raise GetoptError("option --%s requires argument" % opt, opt)
+            optarg, args = args[0], args[1:]
+    elif optarg:
+        raise GetoptError("option --%s must not have an argument" % opt, opt)
+    opts.append(("--" + opt, optarg or ""))
+    return opts, args
+
+
+# Return:
+#   has_arg?
+#   full option name
+def long_has_args(opt, longopts):
+    possibilities = [o for o in longopts if o.startswith(opt)]
+    if not possibilities:
+        raise GetoptError("option --%s not recognized" % opt, opt)
+    # Is there an exact match?
+    if opt in possibilities:
+        return False, opt
+    elif opt + "=" in possibilities:
+        return True, opt
+    # No exact match, so better be unique.
+    if len(possibilities) > 1:
+        # XXX since possibilities contains all valid continuations, might be
+        # nice to work them into the error msg
+        raise GetoptError("option --%s not a unique prefix" % opt, opt)
+    assert len(possibilities) == 1
+    unique_match = possibilities[0]
+    has_arg = unique_match.endswith("=")
+    if has_arg:
+        unique_match = unique_match[:-1]
+    return has_arg, unique_match
+
+
+def do_shorts(opts, optstring, shortopts, args):
+    while optstring != "":
+        opt, optstring = optstring[0], optstring[1:]
+        if short_has_arg(opt, shortopts):
+            if optstring == "":
+                if not args:
+                    raise GetoptError("option -%s requires argument" % opt, opt)
+                optstring, args = args[0], args[1:]
+            optarg, optstring = optstring, ""
+        else:
+            optarg = ""
+        opts.append(("-" + opt, optarg))
+    return opts, args
+
+
+def short_has_arg(opt, shortopts):
+    for i in range(len(shortopts)):
+        if opt == shortopts[i] != ":":
+            return shortopts.startswith(":", i + 1)
+    raise GetoptError("option -%s not recognized" % opt, opt)
+
+
+# =======================================================================================================================
+# End getopt code
+# =======================================================================================================================
@@ -0,0 +1,372 @@
+import inspect
+import os.path
+import sys
+
+from _pydev_bundle._pydev_tipper_common import do_find
+from _pydevd_bundle.pydevd_utils import hasattr_checked, dir_checked
+
+from inspect import getfullargspec
+
+
+def getargspec(*args, **kwargs):
+    arg_spec = getfullargspec(*args, **kwargs)
+    return arg_spec.args, arg_spec.varargs, arg_spec.varkw, arg_spec.defaults, arg_spec.kwonlyargs or [], arg_spec.kwonlydefaults or {}
+
+
+# completion types.
+TYPE_IMPORT = "0"
+TYPE_CLASS = "1"
+TYPE_FUNCTION = "2"
+TYPE_ATTR = "3"
+TYPE_BUILTIN = "4"
+TYPE_PARAM = "5"
+
+
+def _imp(name, log=None):
+    try:
+        return __import__(name)
+    except:
+        if "." in name:
+            sub = name[0 : name.rfind(".")]
+
+            if log is not None:
+                log.add_content("Unable to import", name, "trying with", sub)
+                log.add_exception()
+
+            return _imp(sub, log)
+        else:
+            s = "Unable to import module: %s - sys.path: %s" % (str(name), sys.path)
+            if log is not None:
+                log.add_content(s)
+                log.add_exception()
+
+            raise ImportError(s)
+
+
+IS_IPY = False
+if sys.platform == "cli":
+    IS_IPY = True
+    _old_imp = _imp
+
+    def _imp(name, log=None):
+        # We must add a reference in clr for .Net
+        import clr  # @UnresolvedImport
+
+        initial_name = name
+        while "." in name:
+            try:
+                clr.AddReference(name)
+                break  # If it worked, that's OK.
+            except:
+                name = name[0 : name.rfind(".")]
+        else:
+            try:
+                clr.AddReference(name)
+            except:
+                pass  # That's OK (not dot net module).
+
+        return _old_imp(initial_name, log)
+
+
+def get_file(mod):
+    f = None
+    try:
+        f = inspect.getsourcefile(mod) or inspect.getfile(mod)
+    except:
+        try:
+            f = getattr(mod, "__file__", None)
+        except:
+            f = None
+        if f and f.lower(f[-4:]) in [".pyc", ".pyo"]:
+            filename = f[:-4] + ".py"
+            if os.path.exists(filename):
+                f = filename
+
+    return f
+
+
+def Find(name, log=None):
+    f = None
+
+    mod = _imp(name, log)
+    parent = mod
+    foundAs = ""
+
+    if inspect.ismodule(mod):
+        f = get_file(mod)
+
+    components = name.split(".")
+
+    old_comp = None
+    for comp in components[1:]:
+        try:
+            # this happens in the following case:
+            # we have mx.DateTime.mxDateTime.mxDateTime.pyd
+            # but after importing it, mx.DateTime.mxDateTime shadows access to mxDateTime.pyd
+            mod = getattr(mod, comp)
+        except AttributeError:
+            if old_comp != comp:
+                raise
+
+        if inspect.ismodule(mod):
+            f = get_file(mod)
+        else:
+            if len(foundAs) > 0:
+                foundAs = foundAs + "."
+            foundAs = foundAs + comp
+
+        old_comp = comp
+
+    return f, mod, parent, foundAs
+
+
+def search_definition(data):
+    """@return file, line, col"""
+
+    data = data.replace("\n", "")
+    if data.endswith("."):
+        data = data.rstrip(".")
+    f, mod, parent, foundAs = Find(data)
+    try:
+        return do_find(f, mod), foundAs
+    except:
+        return do_find(f, parent), foundAs
+
+
+def generate_tip(data, log=None):
+    data = data.replace("\n", "")
+    if data.endswith("."):
+        data = data.rstrip(".")
+
+    f, mod, parent, foundAs = Find(data, log)
+    # print_ >> open('temp.txt', 'w'), f
+    tips = generate_imports_tip_for_module(mod)
+    return f, tips
+
+
+def check_char(c):
+    if c == "-" or c == ".":
+        return "_"
+    return c
+
+
+_SENTINEL = object()
+
+
+def generate_imports_tip_for_module(obj_to_complete, dir_comps=None, getattr=getattr, filter=lambda name: True):
+    """
+    @param obj_to_complete: the object from where we should get the completions
+    @param dir_comps: if passed, we should not 'dir' the object and should just iterate those passed as kwonly_arg parameter
+    @param getattr: the way to get kwonly_arg given object from the obj_to_complete (used for the completer)
+    @param filter: kwonly_arg callable that receives the name and decides if it should be appended or not to the results
+    @return: list of tuples, so that each tuple represents kwonly_arg completion with:
+        name, doc, args, type (from the TYPE_* constants)
+    """
+    ret = []
+
+    if dir_comps is None:
+        dir_comps = dir_checked(obj_to_complete)
+        if hasattr_checked(obj_to_complete, "__dict__"):
+            dir_comps.append("__dict__")
+        if hasattr_checked(obj_to_complete, "__class__"):
+            dir_comps.append("__class__")
+
+    get_complete_info = True
+
+    if len(dir_comps) > 1000:
+        # ok, we don't want to let our users wait forever...
+        # no complete info for you...
+
+        get_complete_info = False
+
+    dontGetDocsOn = (float, int, str, tuple, list, dict)
+    dontGetattrOn = (dict, list, set, tuple)
+    for d in dir_comps:
+        if d is None:
+            continue
+
+        if not filter(d):
+            continue
+
+        args = ""
+
+        try:
+            try:
+                if isinstance(obj_to_complete, dontGetattrOn):
+                    raise Exception(
+                        'Since python 3.9, e.g. "dict[str]" will return'
+                        " a dict that's only supposed to take strings. "
+                        'Interestingly, e.g. dict["val"] is also valid '
+                        "and presumably represents a dict that only takes "
+                        'keys that are "val". This breaks our check for '
+                        "class attributes."
+                    )
+                obj = getattr(obj_to_complete.__class__, d)
+            except:
+                obj = getattr(obj_to_complete, d)
+        except:  # just ignore and get it without additional info
+            ret.append((d, "", args, TYPE_BUILTIN))
+        else:
+            if get_complete_info:
+                try:
+                    retType = TYPE_BUILTIN
+
+                    # check if we have to get docs
+                    getDoc = True
+                    for class_ in dontGetDocsOn:
+                        if isinstance(obj, class_):
+                            getDoc = False
+                            break
+
+                    doc = ""
+                    if getDoc:
+                        # no need to get this info... too many constants are defined and
+                        # makes things much slower (passing all that through sockets takes quite some time)
+                        try:
+                            doc = inspect.getdoc(obj)
+                            if doc is None:
+                                doc = ""
+                        except:  # may happen on jython when checking java classes (so, just ignore it)
+                            doc = ""
+
+                    if inspect.ismethod(obj) or inspect.isbuiltin(obj) or inspect.isfunction(obj) or inspect.isroutine(obj):
+                        try:
+                            args, vargs, kwargs, defaults, kwonly_args, kwonly_defaults = getargspec(obj)
+
+                            args = args[:]
+
+                            for kwonly_arg in kwonly_args:
+                                default = kwonly_defaults.get(kwonly_arg, _SENTINEL)
+                                if default is not _SENTINEL:
+                                    args.append("%s=%s" % (kwonly_arg, default))
+                                else:
+                                    args.append(str(kwonly_arg))
+
+                            args = "(%s)" % (", ".join(args))
+                        except TypeError:
+                            # ok, let's see if we can get the arguments from the doc
+                            args, doc = signature_from_docstring(doc, getattr(obj, "__name__", None))
+
+                        retType = TYPE_FUNCTION
+
+                    elif inspect.isclass(obj):
+                        retType = TYPE_CLASS
+
+                    elif inspect.ismodule(obj):
+                        retType = TYPE_IMPORT
+
+                    else:
+                        retType = TYPE_ATTR
+
+                    # add token and doc to return - assure only strings.
+                    ret.append((d, doc, args, retType))
+
+                except:  # just ignore and get it without aditional info
+                    ret.append((d, "", args, TYPE_BUILTIN))
+
+            else:  # get_complete_info == False
+                if inspect.ismethod(obj) or inspect.isbuiltin(obj) or inspect.isfunction(obj) or inspect.isroutine(obj):
+                    retType = TYPE_FUNCTION
+
+                elif inspect.isclass(obj):
+                    retType = TYPE_CLASS
+
+                elif inspect.ismodule(obj):
+                    retType = TYPE_IMPORT
+
+                else:
+                    retType = TYPE_ATTR
+                # ok, no complete info, let's try to do this as fast and clean as possible
+                # so, no docs for this kind of information, only the signatures
+                ret.append((d, "", str(args), retType))
+
+    return ret
+
+
+def signature_from_docstring(doc, obj_name):
+    args = "()"
+    try:
+        found = False
+        if len(doc) > 0:
+            if IS_IPY:
+                # Handle case where we have the situation below
+                # sort(self, object cmp, object key)
+                # sort(self, object cmp, object key, bool reverse)
+                # sort(self)
+                # sort(self, object cmp)
+
+                # Or: sort(self: list, cmp: object, key: object)
+                # sort(self: list, cmp: object, key: object, reverse: bool)
+                # sort(self: list)
+                # sort(self: list, cmp: object)
+                if obj_name:
+                    name = obj_name + "("
+
+                    # Fix issue where it was appearing sort(aa)sort(bb)sort(cc) in the same line.
+                    lines = doc.splitlines()
+                    if len(lines) == 1:
+                        c = doc.count(name)
+                        if c > 1:
+                            doc = ("\n" + name).join(doc.split(name))
+
+                    major = ""
+                    for line in doc.splitlines():
+                        if line.startswith(name) and line.endswith(")"):
+                            if len(line) > len(major):
+                                major = line
+                    if major:
+                        args = major[major.index("(") :]
+                        found = True
+
+            if not found:
+                i = doc.find("->")
+                if i < 0:
+                    i = doc.find("--")
+                    if i < 0:
+                        i = doc.find("\n")
+                        if i < 0:
+                            i = doc.find("\r")
+
+                if i > 0:
+                    s = doc[0:i]
+                    s = s.strip()
+
+                    # let's see if we have a docstring in the first line
+                    if s[-1] == ")":
+                        start = s.find("(")
+                        if start >= 0:
+                            end = s.find("[")
+                            if end <= 0:
+                                end = s.find(")")
+                                if end <= 0:
+                                    end = len(s)
+
+                            args = s[start:end]
+                            if not args[-1] == ")":
+                                args = args + ")"
+
+                            # now, get rid of unwanted chars
+                            l = len(args) - 1
+                            r = []
+                            for i in range(len(args)):
+                                if i == 0 or i == l:
+                                    r.append(args[i])
+                                else:
+                                    r.append(check_char(args[i]))
+
+                            args = "".join(r)
+
+            if IS_IPY:
+                if args.startswith("(self:"):
+                    i = args.find(",")
+                    if i >= 0:
+                        args = "(self" + args[i:]
+                    else:
+                        args = "(self)"
+                i = args.find(")")
+                if i > 0:
+                    args = args[: i + 1]
+
+    except:
+        pass
+    return args, doc
@@ -0,0 +1,485 @@
+import traceback
+from io import StringIO
+from java.lang import StringBuffer  # @UnresolvedImport
+from java.lang import String  # @UnresolvedImport
+import java.lang  # @UnresolvedImport
+import sys
+from _pydev_bundle._pydev_tipper_common import do_find
+
+from org.python.core import PyReflectedFunction  # @UnresolvedImport
+
+from org.python import core  # @UnresolvedImport
+from org.python.core import PyClass  # @UnresolvedImport
+
+# completion types.
+TYPE_IMPORT = "0"
+TYPE_CLASS = "1"
+TYPE_FUNCTION = "2"
+TYPE_ATTR = "3"
+TYPE_BUILTIN = "4"
+TYPE_PARAM = "5"
+
+
+def _imp(name):
+    try:
+        return __import__(name)
+    except:
+        if "." in name:
+            sub = name[0 : name.rfind(".")]
+            return _imp(sub)
+        else:
+            s = "Unable to import module: %s - sys.path: %s" % (str(name), sys.path)
+            raise RuntimeError(s)
+
+
+import java.util
+
+_java_rt_file = getattr(java.util, "__file__", None)
+
+
+def Find(name):
+    f = None
+    if name.startswith("__builtin__"):
+        if name == "__builtin__.str":
+            name = "org.python.core.PyString"
+        elif name == "__builtin__.dict":
+            name = "org.python.core.PyDictionary"
+
+    mod = _imp(name)
+    parent = mod
+    foundAs = ""
+
+    try:
+        f = getattr(mod, "__file__", None)
+    except:
+        f = None
+
+    components = name.split(".")
+    old_comp = None
+    for comp in components[1:]:
+        try:
+            # this happens in the following case:
+            # we have mx.DateTime.mxDateTime.mxDateTime.pyd
+            # but after importing it, mx.DateTime.mxDateTime does shadows access to mxDateTime.pyd
+            mod = getattr(mod, comp)
+        except AttributeError:
+            if old_comp != comp:
+                raise
+
+        if hasattr(mod, "__file__"):
+            f = mod.__file__
+        else:
+            if len(foundAs) > 0:
+                foundAs = foundAs + "."
+            foundAs = foundAs + comp
+
+        old_comp = comp
+
+    if f is None and name.startswith("java.lang"):
+        # Hack: java.lang.__file__ is None on Jython 2.7 (whereas it pointed to rt.jar on Jython 2.5).
+        f = _java_rt_file
+
+    if f is not None:
+        if f.endswith(".pyc"):
+            f = f[:-1]
+        elif f.endswith("$py.class"):
+            f = f[: -len("$py.class")] + ".py"
+    return f, mod, parent, foundAs
+
+
+def format_param_class_name(paramClassName):
+    if paramClassName.startswith("<type '") and paramClassName.endswith("'>"):
+        paramClassName = paramClassName[len("<type '") : -2]
+    if paramClassName.startswith("["):
+        if paramClassName == "[C":
+            paramClassName = "char[]"
+
+        elif paramClassName == "[B":
+            paramClassName = "byte[]"
+
+        elif paramClassName == "[I":
+            paramClassName = "int[]"
+
+        elif paramClassName.startswith("[L") and paramClassName.endswith(";"):
+            paramClassName = paramClassName[2:-1]
+            paramClassName += "[]"
+    return paramClassName
+
+
+def generate_tip(data, log=None):
+    data = data.replace("\n", "")
+    if data.endswith("."):
+        data = data.rstrip(".")
+
+    f, mod, parent, foundAs = Find(data)
+    tips = generate_imports_tip_for_module(mod)
+    return f, tips
+
+
+# =======================================================================================================================
+# Info
+# =======================================================================================================================
+class Info:
+    def __init__(self, name, **kwargs):
+        self.name = name
+        self.doc = kwargs.get("doc", None)
+        self.args = kwargs.get("args", ())  # tuple of strings
+        self.varargs = kwargs.get("varargs", None)  # string
+        self.kwargs = kwargs.get("kwargs", None)  # string
+        self.ret = kwargs.get("ret", None)  # string
+
+    def basic_as_str(self):
+        """@returns this class information as a string (just basic format)"""
+        args = self.args
+        s = "function:%s args=%s, varargs=%s, kwargs=%s, docs:%s" % (self.name, args, self.varargs, self.kwargs, self.doc)
+        return s
+
+    def get_as_doc(self):
+        s = str(self.name)
+        if self.doc:
+            s += "\n@doc %s\n" % str(self.doc)
+
+        if self.args:
+            s += "\n@params "
+            for arg in self.args:
+                s += str(format_param_class_name(arg))
+                s += "  "
+
+        if self.varargs:
+            s += "\n@varargs "
+            s += str(self.varargs)
+
+        if self.kwargs:
+            s += "\n@kwargs "
+            s += str(self.kwargs)
+
+        if self.ret:
+            s += "\n@return "
+            s += str(format_param_class_name(str(self.ret)))
+
+        return str(s)
+
+
+def isclass(cls):
+    return isinstance(cls, core.PyClass) or type(cls) == java.lang.Class
+
+
+def ismethod(func):
+    """this function should return the information gathered on a function
+
+    @param func: this is the function we want to get info on
+    @return a tuple where:
+        0 = indicates whether the parameter passed is a method or not
+        1 = a list of classes 'Info', with the info gathered from the function
+            this is a list because when we have methods from java with the same name and different signatures,
+            we actually have many methods, each with its own set of arguments
+    """
+
+    try:
+        if isinstance(func, core.PyFunction):
+            # ok, this is from python, created by jython
+            # print_ '    PyFunction'
+
+            def getargs(func_code):
+                """Get information about the arguments accepted by a code object.
+
+                Three things are returned: (args, varargs, varkw), where 'args' is
+                a list of argument names (possibly containing nested lists), and
+                'varargs' and 'varkw' are the names of the * and ** arguments or None."""
+
+                nargs = func_code.co_argcount
+                names = func_code.co_varnames
+                args = list(names[:nargs])
+                step = 0
+
+                if not hasattr(func_code, "CO_VARARGS"):
+                    from org.python.core import CodeFlag  # @UnresolvedImport
+
+                    co_varargs_flag = CodeFlag.CO_VARARGS.flag
+                    co_varkeywords_flag = CodeFlag.CO_VARKEYWORDS.flag
+                else:
+                    co_varargs_flag = func_code.CO_VARARGS
+                    co_varkeywords_flag = func_code.CO_VARKEYWORDS
+
+                varargs = None
+                if func_code.co_flags & co_varargs_flag:
+                    varargs = func_code.co_varnames[nargs]
+                    nargs = nargs + 1
+                varkw = None
+                if func_code.co_flags & co_varkeywords_flag:
+                    varkw = func_code.co_varnames[nargs]
+                return args, varargs, varkw
+
+            args = getargs(func.func_code)
+            return 1, [Info(func.func_name, args=args[0], varargs=args[1], kwargs=args[2], doc=func.func_doc)]
+
+        if isinstance(func, core.PyMethod):
+            # this is something from java itself, and jython just wrapped it...
+
+            # things to play in func:
+            # ['__call__', '__class__', '__cmp__', '__delattr__', '__dir__', '__doc__', '__findattr__', '__name__', '_doget', 'im_class',
+            # 'im_func', 'im_self', 'toString']
+            # print_ '    PyMethod'
+            # that's the PyReflectedFunction... keep going to get it
+            func = func.im_func
+
+        if isinstance(func, PyReflectedFunction):
+            # this is something from java itself, and jython just wrapped it...
+
+            # print_ '    PyReflectedFunction'
+
+            infos = []
+            for i in range(len(func.argslist)):
+                # things to play in func.argslist[i]:
+
+                # 'PyArgsCall', 'PyArgsKeywordsCall', 'REPLACE', 'StandardCall', 'args', 'compare', 'compareTo', 'data', 'declaringClass'
+                # 'flags', 'isStatic', 'matches', 'precedence']
+
+                # print_ '        ', func.argslist[i].data.__class__
+                # func.argslist[i].data.__class__ == java.lang.reflect.Method
+
+                if func.argslist[i]:
+                    met = func.argslist[i].data
+                    name = met.getName()
+                    try:
+                        ret = met.getReturnType()
+                    except AttributeError:
+                        ret = ""
+                    parameterTypes = met.getParameterTypes()
+
+                    args = []
+                    for j in range(len(parameterTypes)):
+                        paramTypesClass = parameterTypes[j]
+                        try:
+                            try:
+                                paramClassName = paramTypesClass.getName()
+                            except:
+                                paramClassName = paramTypesClass.getName(paramTypesClass)
+                        except AttributeError:
+                            try:
+                                paramClassName = repr(paramTypesClass)  # should be something like <type 'object'>
+                                paramClassName = paramClassName.split("'")[1]
+                            except:
+                                paramClassName = repr(paramTypesClass)  # just in case something else happens... it will at least be visible
+                        # if the parameter equals [C, it means it it a char array, so, let's change it
+
+                        a = format_param_class_name(paramClassName)
+                        # a = a.replace('[]','Array')
+                        # a = a.replace('Object', 'obj')
+                        # a = a.replace('String', 's')
+                        # a = a.replace('Integer', 'i')
+                        # a = a.replace('Char', 'c')
+                        # a = a.replace('Double', 'd')
+                        args.append(a)  # so we don't leave invalid code
+
+                    info = Info(name, args=args, ret=ret)
+                    # print_ info.basic_as_str()
+                    infos.append(info)
+
+            return 1, infos
+    except Exception:
+        s = StringIO()
+        traceback.print_exc(file=s)
+        return 1, [Info(str("ERROR"), doc=s.getvalue())]
+
+    return 0, None
+
+
+def ismodule(mod):
+    # java modules... do we have other way to know that?
+    if not hasattr(mod, "getClass") and not hasattr(mod, "__class__") and hasattr(mod, "__name__"):
+        return 1
+
+    return isinstance(mod, core.PyModule)
+
+
+def dir_obj(obj):
+    ret = []
+    found = java.util.HashMap()
+    original = obj
+    if hasattr(obj, "__class__"):
+        if obj.__class__ == java.lang.Class:
+            # get info about superclasses
+            classes = []
+            classes.append(obj)
+            try:
+                c = obj.getSuperclass()
+            except TypeError:
+                # may happen on jython when getting the java.lang.Class class
+                c = obj.getSuperclass(obj)
+
+            while c != None:
+                classes.append(c)
+                c = c.getSuperclass()
+
+            # get info about interfaces
+            interfs = []
+            for obj in classes:
+                try:
+                    interfs.extend(obj.getInterfaces())
+                except TypeError:
+                    interfs.extend(obj.getInterfaces(obj))
+            classes.extend(interfs)
+
+            # now is the time when we actually get info on the declared methods and fields
+            for obj in classes:
+                try:
+                    declaredMethods = obj.getDeclaredMethods()
+                except TypeError:
+                    declaredMethods = obj.getDeclaredMethods(obj)
+
+                try:
+                    declaredFields = obj.getDeclaredFields()
+                except TypeError:
+                    declaredFields = obj.getDeclaredFields(obj)
+
+                for i in range(len(declaredMethods)):
+                    name = declaredMethods[i].getName()
+                    ret.append(name)
+                    found.put(name, 1)
+
+                for i in range(len(declaredFields)):
+                    name = declaredFields[i].getName()
+                    ret.append(name)
+                    found.put(name, 1)
+
+        elif isclass(obj.__class__):
+            d = dir(obj.__class__)
+            for name in d:
+                ret.append(name)
+                found.put(name, 1)
+
+    # this simple dir does not always get all the info, that's why we have the part before
+    # (e.g.: if we do a dir on String, some methods that are from other interfaces such as
+    # charAt don't appear)
+    d = dir(original)
+    for name in d:
+        if found.get(name) != 1:
+            ret.append(name)
+
+    return ret
+
+
+def format_arg(arg):
+    """formats an argument to be shown"""
+
+    s = str(arg)
+    dot = s.rfind(".")
+    if dot >= 0:
+        s = s[dot + 1 :]
+
+    s = s.replace(";", "")
+    s = s.replace("[]", "Array")
+    if len(s) > 0:
+        c = s[0].lower()
+        s = c + s[1:]
+
+    return s
+
+
+def search_definition(data):
+    """@return file, line, col"""
+
+    data = data.replace("\n", "")
+    if data.endswith("."):
+        data = data.rstrip(".")
+    f, mod, parent, foundAs = Find(data)
+    try:
+        return do_find(f, mod), foundAs
+    except:
+        return do_find(f, parent), foundAs
+
+
+def generate_imports_tip_for_module(obj_to_complete, dir_comps=None, getattr=getattr, filter=lambda name: True):
+    """
+    @param obj_to_complete: the object from where we should get the completions
+    @param dir_comps: if passed, we should not 'dir' the object and should just iterate those passed as a parameter
+    @param getattr: the way to get a given object from the obj_to_complete (used for the completer)
+    @param filter: a callable that receives the name and decides if it should be appended or not to the results
+    @return: list of tuples, so that each tuple represents a completion with:
+        name, doc, args, type (from the TYPE_* constants)
+    """
+    ret = []
+
+    if dir_comps is None:
+        dir_comps = dir_obj(obj_to_complete)
+
+    for d in dir_comps:
+        if d is None:
+            continue
+
+        if not filter(d):
+            continue
+
+        args = ""
+        doc = ""
+        retType = TYPE_BUILTIN
+
+        try:
+            obj = getattr(obj_to_complete, d)
+        except (AttributeError, java.lang.NoClassDefFoundError):
+            # jython has a bug in its custom classloader that prevents some things from working correctly, so, let's see if
+            # we can fix that... (maybe fixing it in jython itself would be a better idea, as this is clearly a bug)
+            # for that we need a custom classloader... we have references from it in the below places:
+            #
+            # http://mindprod.com/jgloss/classloader.html
+            # http://www.javaworld.com/javaworld/jw-03-2000/jw-03-classload-p2.html
+            # http://freshmeat.net/articles/view/1643/
+            #
+            # note: this only happens when we add things to the sys.path at runtime, if they are added to the classpath
+            # before the run, everything goes fine.
+            #
+            # The code below ilustrates what I mean...
+            #
+            # import sys
+            # sys.path.insert(1, r"C:\bin\eclipse310\plugins\org.junit_3.8.1\junit.jar" )
+            #
+            # import junit.framework
+            # print_ dir(junit.framework) #shows the TestCase class here
+            #
+            # import junit.framework.TestCase
+            #
+            # raises the error:
+            # Traceback (innermost last):
+            #  File "<console>", line 1, in ?
+            # ImportError: No module named TestCase
+            #
+            # whereas if we had added the jar to the classpath before, everything would be fine by now...
+
+            ret.append((d, "", "", retType))
+            # that's ok, private things cannot be gotten...
+            continue
+        else:
+            isMet = ismethod(obj)
+            if isMet[0] and isMet[1]:
+                info = isMet[1][0]
+                try:
+                    args, vargs, kwargs = info.args, info.varargs, info.kwargs
+                    doc = info.get_as_doc()
+                    r = ""
+                    for a in args:
+                        if len(r) > 0:
+                            r += ", "
+                        r += format_arg(a)
+                    args = "(%s)" % (r)
+                except TypeError:
+                    traceback.print_exc()
+                    args = "()"
+
+                retType = TYPE_FUNCTION
+
+            elif isclass(obj):
+                retType = TYPE_CLASS
+
+            elif ismodule(obj):
+                retType = TYPE_IMPORT
+
+        # add token and doc to return - assure only strings.
+        ret.append((d, doc, args, retType))
+
+    return ret
+
+
+if __name__ == "__main__":
+    sys.path.append(r"D:\dev_programs\eclipse_3\310\eclipse\plugins\org.junit_3.8.1\junit.jar")
+    sys.stdout.write("%s\n" % Find("junit.framework.TestCase"))
@@ -0,0 +1,23 @@
+import traceback
+import sys
+from io import StringIO
+
+
+class Log:
+    def __init__(self):
+        self._contents = []
+
+    def add_content(self, *content):
+        self._contents.append(" ".join(content))
+
+    def add_exception(self):
+        s = StringIO()
+        exc_info = sys.exc_info()
+        traceback.print_exception(exc_info[0], exc_info[1], exc_info[2], limit=None, file=s)
+        self._contents.append(s.getvalue())
+
+    def get_contents(self):
+        return "\n".join(self._contents)
+
+    def clear_log(self):
+        del self._contents[:]
@@ -0,0 +1,134 @@
+import sys
+import os
+
+
+def find_in_pythonpath(module_name):
+    # Check all the occurrences where we could match the given module/package in the PYTHONPATH.
+    #
+    # This is a simplistic approach, but probably covers most of the cases we're interested in
+    # (i.e.: this may fail in more elaborate cases of import customization or .zip imports, but
+    # this should be rare in general).
+    found_at = []
+
+    parts = module_name.split(".")  # split because we need to convert mod.name to mod/name
+    for path in sys.path:
+        target = os.path.join(path, *parts)
+        target_py = target + ".py"
+        if os.path.isdir(target):
+            found_at.append(target)
+        if os.path.exists(target_py):
+            found_at.append(target_py)
+    return found_at
+
+
+class DebuggerInitializationError(Exception):
+    pass
+
+
+class VerifyShadowedImport(object):
+    def __init__(self, import_name):
+        self.import_name = import_name
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type is not None:
+            if exc_type == DebuggerInitializationError:
+                return False  # It's already an error we generated.
+
+            # We couldn't even import it...
+            found_at = find_in_pythonpath(self.import_name)
+
+            if len(found_at) <= 1:
+                # It wasn't found anywhere or there was just 1 occurrence.
+                # Let's just return to show the original error.
+                return False
+
+            # We found more than 1 occurrence of the same module in the PYTHONPATH
+            # (the user module and the standard library module).
+            # Let's notify the user as it seems that the module was shadowed.
+            msg = self._generate_shadowed_import_message(found_at)
+            raise DebuggerInitializationError(msg)
+
+    def _generate_shadowed_import_message(self, found_at):
+        msg = """It was not possible to initialize the debugger due to a module name conflict.
+
+i.e.: the module "%(import_name)s" could not be imported because it is shadowed by:
+%(found_at)s
+Please rename this file/folder so that the original module from the standard library can be imported.""" % {
+            "import_name": self.import_name,
+            "found_at": found_at[0],
+        }
+
+        return msg
+
+    def check(self, module, expected_attributes):
+        msg = ""
+        for expected_attribute in expected_attributes:
+            try:
+                getattr(module, expected_attribute)
+            except:
+                msg = self._generate_shadowed_import_message([module.__file__])
+                break
+
+        if msg:
+            raise DebuggerInitializationError(msg)
+
+
+with VerifyShadowedImport("threading") as verify_shadowed:
+    import threading
+
+    verify_shadowed.check(threading, ["Thread", "settrace", "setprofile", "Lock", "RLock", "current_thread"])
+    ThreadingEvent = threading.Event
+    ThreadingLock = threading.Lock
+    threading_current_thread = threading.current_thread
+
+with VerifyShadowedImport("time") as verify_shadowed:
+    import time
+
+    verify_shadowed.check(time, ["sleep", "time", "mktime"])
+
+with VerifyShadowedImport("socket") as verify_shadowed:
+    import socket
+
+    verify_shadowed.check(socket, ["socket", "gethostname", "getaddrinfo"])
+
+with VerifyShadowedImport("select") as verify_shadowed:
+    import select
+
+    verify_shadowed.check(select, ["select"])
+
+with VerifyShadowedImport("code") as verify_shadowed:
+    import code as _code
+
+    verify_shadowed.check(_code, ["compile_command", "InteractiveInterpreter"])
+
+with VerifyShadowedImport("_thread") as verify_shadowed:
+    import _thread as thread
+
+    verify_shadowed.check(thread, ["start_new_thread", "start_new", "allocate_lock"])
+
+with VerifyShadowedImport("queue") as verify_shadowed:
+    import queue as _queue
+
+    verify_shadowed.check(_queue, ["Queue", "LifoQueue", "Empty", "Full", "deque"])
+
+with VerifyShadowedImport("xmlrpclib") as verify_shadowed:
+    import xmlrpc.client as xmlrpclib
+
+    verify_shadowed.check(xmlrpclib, ["ServerProxy", "Marshaller", "Server"])
+
+with VerifyShadowedImport("xmlrpc.server") as verify_shadowed:
+    import xmlrpc.server as xmlrpcserver
+
+    verify_shadowed.check(xmlrpcserver, ["SimpleXMLRPCServer"])
+
+with VerifyShadowedImport("http.server") as verify_shadowed:
+    import http.server as BaseHTTPServer
+
+    verify_shadowed.check(BaseHTTPServer, ["BaseHTTPRequestHandler"])
+
+# If set, this is a version of the threading.enumerate that doesn't have the patching to remove the pydevd threads.
+# Note: as it can't be set during execution, don't import the name (import the module and access it through its name).
+pydevd_saved_threading_enumerate = None
@@ -0,0 +1,77 @@
+import sys
+
+
+def patch_sys_module():
+    def patched_exc_info(fun):
+        def pydev_debugger_exc_info():
+            type, value, traceback = fun()
+            if type == ImportError:
+                # we should not show frame added by plugin_import call
+                if traceback and hasattr(traceback, "tb_next"):
+                    return type, value, traceback.tb_next
+            return type, value, traceback
+
+        return pydev_debugger_exc_info
+
+    system_exc_info = sys.exc_info
+    sys.exc_info = patched_exc_info(system_exc_info)
+    if not hasattr(sys, "system_exc_info"):
+        sys.system_exc_info = system_exc_info
+
+
+def patched_reload(orig_reload):
+    def pydev_debugger_reload(module):
+        orig_reload(module)
+        if module.__name__ == "sys":
+            # if sys module was reloaded we should patch it again
+            patch_sys_module()
+
+    return pydev_debugger_reload
+
+
+def patch_reload():
+    import builtins  # Py3
+
+    if hasattr(builtins, "reload"):
+        sys.builtin_orig_reload = builtins.reload
+        builtins.reload = patched_reload(sys.builtin_orig_reload)  # @UndefinedVariable
+        try:
+            import imp
+
+            sys.imp_orig_reload = imp.reload
+            imp.reload = patched_reload(sys.imp_orig_reload)  # @UndefinedVariable
+        except ImportError:
+            pass  # Ok, imp not available on Python 3.12.
+    else:
+        try:
+            import importlib
+
+            sys.importlib_orig_reload = importlib.reload  # @UndefinedVariable
+            importlib.reload = patched_reload(sys.importlib_orig_reload)  # @UndefinedVariable
+        except:
+            pass
+
+    del builtins
+
+
+def cancel_patches_in_sys_module():
+    sys.exc_info = sys.system_exc_info  # @UndefinedVariable
+    import builtins  # Py3
+
+    if hasattr(sys, "builtin_orig_reload"):
+        builtins.reload = sys.builtin_orig_reload
+
+    if hasattr(sys, "imp_orig_reload"):
+        try:
+            import imp
+
+            imp.reload = sys.imp_orig_reload
+        except ImportError:
+            pass  # Ok, imp not available in Python 3.12.
+
+    if hasattr(sys, "importlib_orig_reload"):
+        import importlib
+
+        importlib.reload = sys.importlib_orig_reload
+
+    del builtins
@@ -0,0 +1,53 @@
+import inspect
+import re
+
+
+def do_find(f, mod):
+    import linecache
+
+    if inspect.ismodule(mod):
+        return f, 0, 0
+
+    lines = linecache.getlines(f)
+
+    if inspect.isclass(mod):
+        name = mod.__name__
+        pat = re.compile(r"^\s*class\s*" + name + r"\b")
+        for i in range(len(lines)):
+            if pat.match(lines[i]):
+                return f, i, 0
+
+        return f, 0, 0
+
+    if inspect.ismethod(mod):
+        mod = mod.im_func
+
+    if inspect.isfunction(mod):
+        try:
+            mod = mod.func_code
+        except AttributeError:
+            mod = mod.__code__  # python 3k
+
+    if inspect.istraceback(mod):
+        mod = mod.tb_frame
+
+    if inspect.isframe(mod):
+        mod = mod.f_code
+
+    if inspect.iscode(mod):
+        if not hasattr(mod, "co_filename"):
+            return None, 0, 0
+
+        if not hasattr(mod, "co_firstlineno"):
+            return mod.co_filename, 0, 0
+
+        lnum = mod.co_firstlineno
+        pat = re.compile(r"^(\s*def\s)|(.*(?<!\w)lambda(:|\s))|^(\s*@)")
+        while lnum > 0:
+            if pat.match(lines[lnum]):
+                break
+            lnum -= 1
+
+        return f, lnum, 0
+
+    raise RuntimeError("Do not know about: " + f + " " + str(mod))
@@ -0,0 +1,349 @@
+"""
+Sample usage to track changes in a thread.
+
+    import threading
+    import time
+    watcher = fsnotify.Watcher()
+    watcher.accepted_file_extensions = {'.py', '.pyw'}
+
+    # Configure target values to compute throttling.
+    # Note: internal sleep times will be updated based on
+    # profiling the actual application runtime to match
+    # those values.
+
+    watcher.target_time_for_single_scan = 2.
+    watcher.target_time_for_notification = 4.
+
+    watcher.set_tracked_paths([target_dir])
+
+    def start_watching():  # Called from thread
+        for change_enum, change_path in watcher.iter_changes():
+            if change_enum == fsnotify.Change.added:
+                print('Added: ', change_path)
+            elif change_enum == fsnotify.Change.modified:
+                print('Modified: ', change_path)
+            elif change_enum == fsnotify.Change.deleted:
+                print('Deleted: ', change_path)
+
+    t = threading.Thread(target=start_watching)
+    t.daemon = True
+    t.start()
+
+    try:
+        ...
+    finally:
+        watcher.dispose()
+
+
+Note: changes are only reported for files (added/modified/deleted), not directories.
+"""
+import sys
+from os.path import basename
+from _pydev_bundle import pydev_log, _pydev_saved_modules
+from os import scandir
+
+try:
+    from enum import IntEnum
+except:
+
+    class IntEnum(object):
+        pass
+
+
+import time
+
+__author__ = "Fabio Zadrozny"
+__email__ = "fabiofz@gmail.com"
+__version__ = "0.1.5"  # Version here and in setup.py
+
+
+class Change(IntEnum):
+    added = 1
+    modified = 2
+    deleted = 3
+
+
+class _SingleVisitInfo(object):
+    def __init__(self):
+        self.count = 0
+        self.visited_dirs = set()
+        self.file_to_mtime = {}
+        self.last_sleep_time = time.time()
+
+
+class _PathWatcher(object):
+    """
+    Helper to watch a single path.
+    """
+
+    def __init__(self, root_path, accept_directory, accept_file, single_visit_info, max_recursion_level, sleep_time=0.0):
+        """
+        :type root_path: str
+        :type accept_directory: Callback[str, bool]
+        :type accept_file: Callback[str, bool]
+        :type max_recursion_level: int
+        :type sleep_time: float
+        """
+        self.accept_directory = accept_directory
+        self.accept_file = accept_file
+        self._max_recursion_level = max_recursion_level
+
+        self._root_path = root_path
+
+        # Initial sleep value for throttling, it'll be auto-updated based on the
+        # Watcher.target_time_for_single_scan.
+        self.sleep_time = sleep_time
+
+        self.sleep_at_elapsed = 1.0 / 30.0
+
+        # When created, do the initial snapshot right away!
+        old_file_to_mtime = {}
+        self._check(single_visit_info, lambda _change: None, old_file_to_mtime)
+
+    def __eq__(self, o):
+        if isinstance(o, _PathWatcher):
+            return self._root_path == o._root_path
+
+        return False
+
+    def __ne__(self, o):
+        return not self == o
+
+    def __hash__(self):
+        return hash(self._root_path)
+
+    def _check_dir(self, dir_path, single_visit_info, append_change, old_file_to_mtime, level):
+        # This is the actual poll loop
+        if dir_path in single_visit_info.visited_dirs or level > self._max_recursion_level:
+            return
+        single_visit_info.visited_dirs.add(dir_path)
+        try:
+            if isinstance(dir_path, bytes):
+                try:
+                    dir_path = dir_path.decode(sys.getfilesystemencoding())
+                except UnicodeDecodeError:
+                    try:
+                        dir_path = dir_path.decode("utf-8")
+                    except UnicodeDecodeError:
+                        return  # Ignore if we can't deal with the path.
+
+            new_files = single_visit_info.file_to_mtime
+
+            for entry in scandir(dir_path):
+                single_visit_info.count += 1
+
+                # Throttle if needed inside the loop
+                # to avoid consuming too much CPU.
+                if single_visit_info.count % 300 == 0:
+                    if self.sleep_time > 0:
+                        t = time.time()
+                        diff = t - single_visit_info.last_sleep_time
+                        if diff > self.sleep_at_elapsed:
+                            time.sleep(self.sleep_time)
+                            single_visit_info.last_sleep_time = time.time()
+
+                if entry.is_dir():
+                    if self.accept_directory(entry.path):
+                        self._check_dir(entry.path, single_visit_info, append_change, old_file_to_mtime, level + 1)
+
+                elif self.accept_file(entry.path):
+                    stat = entry.stat()
+                    mtime = (stat.st_mtime_ns, stat.st_size)
+                    path = entry.path
+                    new_files[path] = mtime
+
+                    old_mtime = old_file_to_mtime.pop(path, None)
+                    if not old_mtime:
+                        append_change((Change.added, path))
+                    elif old_mtime != mtime:
+                        append_change((Change.modified, path))
+
+        except OSError:
+            pass  # Directory was removed in the meanwhile.
+
+    def _check(self, single_visit_info, append_change, old_file_to_mtime):
+        self._check_dir(self._root_path, single_visit_info, append_change, old_file_to_mtime, 0)
+
+
+class Watcher(object):
+    # By default (if accept_directory is not specified), these will be the
+    # ignored directories.
+    ignored_dirs = {".git", "__pycache__", ".idea", "node_modules", ".metadata"}
+
+    # By default (if accept_file is not specified), these will be the
+    # accepted files.
+    accepted_file_extensions = ()
+
+    # Set to the target value for doing full scan of all files (adds a sleep inside the poll loop
+    # which processes files to reach the target time).
+    # Lower values will consume more CPU
+    # Set to 0.0 to have no sleeps (which will result in a higher cpu load).
+    target_time_for_single_scan = 2.0
+
+    # Set the target value from the start of one scan to the start of another scan (adds a
+    # sleep after a full poll is done to reach the target time).
+    # Lower values will consume more CPU.
+    # Set to 0.0 to have a new scan start right away without any sleeps.
+    target_time_for_notification = 4.0
+
+    # Set to True to print the time for a single poll through all the paths.
+    print_poll_time = False
+
+    # This is the maximum recursion level.
+    max_recursion_level = 10
+
+    def __init__(self, accept_directory=None, accept_file=None):
+        """
+        :param Callable[str, bool] accept_directory:
+            Callable that returns whether a directory should be watched.
+            Note: if passed it'll override the `ignored_dirs`
+
+        :param Callable[str, bool] accept_file:
+            Callable that returns whether a file should be watched.
+            Note: if passed it'll override the `accepted_file_extensions`.
+        """
+        self._path_watchers = set()
+        self._disposed = _pydev_saved_modules.ThreadingEvent()
+
+        if accept_directory is None:
+            accept_directory = lambda dir_path: basename(dir_path) not in self.ignored_dirs
+        if accept_file is None:
+            accept_file = lambda path_name: not self.accepted_file_extensions or path_name.endswith(self.accepted_file_extensions)
+        self.accept_file = accept_file
+        self.accept_directory = accept_directory
+        self._single_visit_info = _SingleVisitInfo()
+
+    @property
+    def accept_directory(self):
+        return self._accept_directory
+
+    @accept_directory.setter
+    def accept_directory(self, accept_directory):
+        self._accept_directory = accept_directory
+        for path_watcher in self._path_watchers:
+            path_watcher.accept_directory = accept_directory
+
+    @property
+    def accept_file(self):
+        return self._accept_file
+
+    @accept_file.setter
+    def accept_file(self, accept_file):
+        self._accept_file = accept_file
+        for path_watcher in self._path_watchers:
+            path_watcher.accept_file = accept_file
+
+    def dispose(self):
+        self._disposed.set()
+
+    @property
+    def path_watchers(self):
+        return tuple(self._path_watchers)
+
+    def set_tracked_paths(self, paths):
+        """
+        Note: always resets all path trackers to track the passed paths.
+        """
+        if not isinstance(paths, (list, tuple, set)):
+            paths = (paths,)
+
+        # Sort by the path len so that the bigger paths come first (so,
+        # if there's any nesting we want the nested paths to be visited
+        # before the parent paths so that the max_recursion_level is correct).
+        paths = sorted(set(paths), key=lambda path: -len(path))
+        path_watchers = set()
+
+        self._single_visit_info = _SingleVisitInfo()
+
+        initial_time = time.time()
+        for path in paths:
+            sleep_time = 0.0  # When collecting the first time, sleep_time should be 0!
+            path_watcher = _PathWatcher(
+                path,
+                self.accept_directory,
+                self.accept_file,
+                self._single_visit_info,
+                max_recursion_level=self.max_recursion_level,
+                sleep_time=sleep_time,
+            )
+
+            path_watchers.add(path_watcher)
+
+        actual_time = time.time() - initial_time
+
+        pydev_log.debug("Tracking the following paths for changes: %s", paths)
+        pydev_log.debug("Time to track: %.2fs", actual_time)
+        pydev_log.debug("Folders found: %s", len(self._single_visit_info.visited_dirs))
+        pydev_log.debug("Files found: %s", len(self._single_visit_info.file_to_mtime))
+        self._path_watchers = path_watchers
+
+    def iter_changes(self):
+        """
+        Continuously provides changes (until dispose() is called).
+
+        Changes provided are tuples with the Change enum and filesystem path.
+
+        :rtype: Iterable[Tuple[Change, str]]
+        """
+        while not self._disposed.is_set():
+            initial_time = time.time()
+
+            old_visit_info = self._single_visit_info
+            old_file_to_mtime = old_visit_info.file_to_mtime
+            changes = []
+            append_change = changes.append
+
+            self._single_visit_info = single_visit_info = _SingleVisitInfo()
+            for path_watcher in self._path_watchers:
+                path_watcher._check(single_visit_info, append_change, old_file_to_mtime)
+
+            # Note that we pop entries while visiting, so, what remained is what's deleted.
+            for entry in old_file_to_mtime:
+                append_change((Change.deleted, entry))
+
+            for change in changes:
+                yield change
+
+            actual_time = time.time() - initial_time
+            if self.print_poll_time:
+                print("--- Total poll time: %.3fs" % actual_time)
+
+            if actual_time > 0:
+                if self.target_time_for_single_scan <= 0.0:
+                    for path_watcher in self._path_watchers:
+                        path_watcher.sleep_time = 0.0
+                else:
+                    perc = self.target_time_for_single_scan / actual_time
+
+                    # Prevent from changing the values too much (go slowly into the right
+                    # direction).
+                    # (to prevent from cases where the user puts the machine on sleep and
+                    # values become too skewed).
+                    if perc > 2.0:
+                        perc = 2.0
+                    elif perc < 0.5:
+                        perc = 0.5
+
+                    for path_watcher in self._path_watchers:
+                        if path_watcher.sleep_time <= 0.0:
+                            path_watcher.sleep_time = 0.001
+                        new_sleep_time = path_watcher.sleep_time * perc
+
+                        # Prevent from changing the values too much (go slowly into the right
+                        # direction).
+                        # (to prevent from cases where the user puts the machine on sleep and
+                        # values become too skewed).
+                        diff_sleep_time = new_sleep_time - path_watcher.sleep_time
+                        path_watcher.sleep_time += diff_sleep_time / (3.0 * len(self._path_watchers))
+
+                        if actual_time > 0:
+                            self._disposed.wait(actual_time)
+
+                        if path_watcher.sleep_time < 0.001:
+                            path_watcher.sleep_time = 0.001
+
+            # print('new sleep time: %s' % path_watcher.sleep_time)
+
+            diff = self.target_time_for_notification - actual_time
+            if diff > 0.0:
+                self._disposed.wait(diff)
@@ -0,0 +1,641 @@
+import os
+import sys
+import traceback
+from _pydev_bundle.pydev_imports import xmlrpclib, _queue, Exec
+from _pydev_bundle._pydev_calltip_util import get_description
+from _pydevd_bundle import pydevd_vars
+from _pydevd_bundle import pydevd_xml
+from _pydevd_bundle.pydevd_constants import IS_JYTHON, NEXT_VALUE_SEPARATOR, get_global_debugger, silence_warnings_decorator
+from contextlib import contextmanager
+from _pydev_bundle import pydev_log
+from _pydevd_bundle.pydevd_utils import interrupt_main_thread
+
+from io import StringIO
+
+
+# =======================================================================================================================
+# BaseStdIn
+# =======================================================================================================================
+class BaseStdIn:
+    def __init__(self, original_stdin=sys.stdin, *args, **kwargs):
+        try:
+            self.encoding = sys.stdin.encoding
+        except:
+            # Not sure if it's available in all Python versions...
+            pass
+        self.original_stdin = original_stdin
+
+        try:
+            self.errors = sys.stdin.errors  # Who knew? sys streams have an errors attribute!
+        except:
+            # Not sure if it's available in all Python versions...
+            pass
+
+    def readline(self, *args, **kwargs):
+        # sys.stderr.write('Cannot readline out of the console evaluation\n') -- don't show anything
+        # This could happen if the user had done input('enter number).<-- upon entering this, that message would appear,
+        # which is not something we want.
+        return "\n"
+
+    def write(self, *args, **kwargs):
+        pass  # not available StdIn (but it can be expected to be in the stream interface)
+
+    def flush(self, *args, **kwargs):
+        pass  # not available StdIn (but it can be expected to be in the stream interface)
+
+    def read(self, *args, **kwargs):
+        # in the interactive interpreter, a read and a readline are the same.
+        return self.readline()
+
+    def close(self, *args, **kwargs):
+        pass  # expected in StdIn
+
+    def __iter__(self):
+        # BaseStdIn would not be considered as Iterable in Python 3 without explicit `__iter__` implementation
+        return self.original_stdin.__iter__()
+
+    def __getattr__(self, item):
+        # it's called if the attribute wasn't found
+        if hasattr(self.original_stdin, item):
+            return getattr(self.original_stdin, item)
+        raise AttributeError("%s has no attribute %s" % (self.original_stdin, item))
+
+
+# =======================================================================================================================
+# StdIn
+# =======================================================================================================================
+class StdIn(BaseStdIn):
+    """
+    Object to be added to stdin (to emulate it as non-blocking while the next line arrives)
+    """
+
+    def __init__(self, interpreter, host, client_port, original_stdin=sys.stdin):
+        BaseStdIn.__init__(self, original_stdin)
+        self.interpreter = interpreter
+        self.client_port = client_port
+        self.host = host
+
+    def readline(self, *args, **kwargs):
+        # Ok, callback into the client to get the new input
+        try:
+            server = xmlrpclib.Server("http://%s:%s" % (self.host, self.client_port))
+            requested_input = server.RequestInput()
+            if not requested_input:
+                return "\n"  # Yes, a readline must return something (otherwise we can get an EOFError on the input() call).
+            else:
+                # readline should end with '\n' (not doing so makes IPython 5 remove the last *valid* character).
+                requested_input += "\n"
+            return requested_input
+        except KeyboardInterrupt:
+            raise  # Let KeyboardInterrupt go through -- #PyDev-816: Interrupting infinite loop in the Interactive Console
+        except:
+            return "\n"
+
+    def close(self, *args, **kwargs):
+        pass  # expected in StdIn
+
+
+# =======================================================================================================================
+# DebugConsoleStdIn
+# =======================================================================================================================
+class DebugConsoleStdIn(BaseStdIn):
+    """
+    Object to be added to stdin (to emulate it as non-blocking while the next line arrives)
+    """
+
+    def __init__(self, py_db, original_stdin):
+        """
+        :param py_db:
+            If None, get_global_debugger() is used.
+        """
+        BaseStdIn.__init__(self, original_stdin)
+        self._py_db = py_db
+        self._in_notification = 0
+
+    def __send_input_requested_message(self, is_started):
+        try:
+            py_db = self._py_db
+            if py_db is None:
+                py_db = get_global_debugger()
+
+            if py_db is None:
+                return
+
+            cmd = py_db.cmd_factory.make_input_requested_message(is_started)
+            py_db.writer.add_command(cmd)
+        except Exception:
+            pydev_log.exception()
+
+    @contextmanager
+    def notify_input_requested(self):
+        self._in_notification += 1
+        if self._in_notification == 1:
+            self.__send_input_requested_message(True)
+        try:
+            yield
+        finally:
+            self._in_notification -= 1
+            if self._in_notification == 0:
+                self.__send_input_requested_message(False)
+
+    def readline(self, *args, **kwargs):
+        with self.notify_input_requested():
+            return self.original_stdin.readline(*args, **kwargs)
+
+    def read(self, *args, **kwargs):
+        with self.notify_input_requested():
+            return self.original_stdin.read(*args, **kwargs)
+
+
+class CodeFragment:
+    def __init__(self, text, is_single_line=True):
+        self.text = text
+        self.is_single_line = is_single_line
+
+    def append(self, code_fragment):
+        self.text = self.text + "\n" + code_fragment.text
+        if not code_fragment.is_single_line:
+            self.is_single_line = False
+
+
+# =======================================================================================================================
+# BaseInterpreterInterface
+# =======================================================================================================================
+class BaseInterpreterInterface:
+    def __init__(self, mainThread, connect_status_queue=None):
+        self.mainThread = mainThread
+        self.interruptable = False
+        self.exec_queue = _queue.Queue(0)
+        self.buffer = None
+        self.banner_shown = False
+        self.connect_status_queue = connect_status_queue
+        self.mpl_modules_for_patching = {}
+        self.init_mpl_modules_for_patching()
+
+    def build_banner(self):
+        return "print({0})\n".format(repr(self.get_greeting_msg()))
+
+    def get_greeting_msg(self):
+        return "PyDev console: starting.\n"
+
+    def init_mpl_modules_for_patching(self):
+        from pydev_ipython.matplotlibtools import activate_matplotlib, activate_pylab, activate_pyplot
+
+        self.mpl_modules_for_patching = {
+            "matplotlib": lambda: activate_matplotlib(self.enableGui),
+            "matplotlib.pyplot": activate_pyplot,
+            "pylab": activate_pylab,
+        }
+
+    def need_more_for_code(self, source):
+        # PyDev-502: PyDev 3.9 F2 doesn't support backslash continuations
+
+        # Strangely even the IPython console is_complete said it was complete
+        # even with a continuation char at the end.
+        if source.endswith("\\"):
+            return True
+
+        if hasattr(self.interpreter, "is_complete"):
+            return not self.interpreter.is_complete(source)
+        try:
+            # At this point, it should always be single.
+            # If we don't do this, things as:
+            #
+            #     for i in range(10): print(i)
+            #
+            # (in a single line) don't work.
+            # Note that it won't give an error and code will be None (so, it'll
+            # use execMultipleLines in the next call in this case).
+            symbol = "single"
+            code = self.interpreter.compile(source, "<input>", symbol)
+        except (OverflowError, SyntaxError, ValueError):
+            # Case 1
+            return False
+        if code is None:
+            # Case 2
+            return True
+
+        # Case 3
+        return False
+
+    def need_more(self, code_fragment):
+        if self.buffer is None:
+            self.buffer = code_fragment
+        else:
+            self.buffer.append(code_fragment)
+
+        return self.need_more_for_code(self.buffer.text)
+
+    def create_std_in(self, debugger=None, original_std_in=None):
+        if debugger is None:
+            return StdIn(self, self.host, self.client_port, original_stdin=original_std_in)
+        else:
+            return DebugConsoleStdIn(py_db=debugger, original_stdin=original_std_in)
+
+    def add_exec(self, code_fragment, debugger=None):
+        # In case sys.excepthook called, use original excepthook #PyDev-877: Debug console freezes with Python 3.5+
+        # (showtraceback does it on python 3.5 onwards)
+        sys.excepthook = sys.__excepthook__
+        try:
+            original_in = sys.stdin
+            try:
+                help = None
+                if "pydoc" in sys.modules:
+                    pydoc = sys.modules["pydoc"]  # Don't import it if it still is not there.
+
+                    if hasattr(pydoc, "help"):
+                        # You never know how will the API be changed, so, let's code defensively here
+                        help = pydoc.help
+                        if not hasattr(help, "input"):
+                            help = None
+            except:
+                # Just ignore any error here
+                pass
+
+            more = False
+            try:
+                sys.stdin = self.create_std_in(debugger, original_in)
+                try:
+                    if help is not None:
+                        # This will enable the help() function to work.
+                        try:
+                            try:
+                                help.input = sys.stdin
+                            except AttributeError:
+                                help._input = sys.stdin
+                        except:
+                            help = None
+                            if not self._input_error_printed:
+                                self._input_error_printed = True
+                                sys.stderr.write("\nError when trying to update pydoc.help.input\n")
+                                sys.stderr.write("(help() may not work -- please report this as a bug in the pydev bugtracker).\n\n")
+                                traceback.print_exc()
+
+                    try:
+                        self.start_exec()
+                        if hasattr(self, "debugger"):
+                            self.debugger.enable_tracing()
+
+                        more = self.do_add_exec(code_fragment)
+
+                        if hasattr(self, "debugger"):
+                            self.debugger.disable_tracing()
+
+                        self.finish_exec(more)
+                    finally:
+                        if help is not None:
+                            try:
+                                try:
+                                    help.input = original_in
+                                except AttributeError:
+                                    help._input = original_in
+                            except:
+                                pass
+
+                finally:
+                    sys.stdin = original_in
+            except SystemExit:
+                raise
+            except:
+                traceback.print_exc()
+        finally:
+            sys.__excepthook__ = sys.excepthook
+
+        return more
+
+    def do_add_exec(self, codeFragment):
+        """
+        Subclasses should override.
+
+        @return: more (True if more input is needed to complete the statement and False if the statement is complete).
+        """
+        raise NotImplementedError()
+
+    def get_namespace(self):
+        """
+        Subclasses should override.
+
+        @return: dict with namespace.
+        """
+        raise NotImplementedError()
+
+    def __resolve_reference__(self, text):
+        """
+
+        :type text: str
+        """
+        obj = None
+        if "." not in text:
+            try:
+                obj = self.get_namespace()[text]
+            except KeyError:
+                pass
+
+            if obj is None:
+                try:
+                    obj = self.get_namespace()["__builtins__"][text]
+                except:
+                    pass
+
+            if obj is None:
+                try:
+                    obj = getattr(self.get_namespace()["__builtins__"], text, None)
+                except:
+                    pass
+
+        else:
+            try:
+                last_dot = text.rindex(".")
+                parent_context = text[0:last_dot]
+                res = pydevd_vars.eval_in_context(parent_context, self.get_namespace(), self.get_namespace())
+                obj = getattr(res, text[last_dot + 1 :])
+            except:
+                pass
+        return obj
+
+    def getDescription(self, text):
+        try:
+            obj = self.__resolve_reference__(text)
+            if obj is None:
+                return ""
+            return get_description(obj)
+        except:
+            return ""
+
+    def do_exec_code(self, code, is_single_line):
+        try:
+            code_fragment = CodeFragment(code, is_single_line)
+            more = self.need_more(code_fragment)
+            if not more:
+                code_fragment = self.buffer
+                self.buffer = None
+                self.exec_queue.put(code_fragment)
+
+            return more
+        except:
+            traceback.print_exc()
+            return False
+
+    def execLine(self, line):
+        return self.do_exec_code(line, True)
+
+    def execMultipleLines(self, lines):
+        if IS_JYTHON:
+            more = False
+            for line in lines.split("\n"):
+                more = self.do_exec_code(line, True)
+            return more
+        else:
+            return self.do_exec_code(lines, False)
+
+    def interrupt(self):
+        self.buffer = None  # Also clear the buffer when it's interrupted.
+        try:
+            if self.interruptable:
+                # Fix for #PyDev-500: Console interrupt can't interrupt on sleep
+                interrupt_main_thread(self.mainThread)
+
+            self.finish_exec(False)
+            return True
+        except:
+            traceback.print_exc()
+            return False
+
+    def close(self):
+        sys.exit(0)
+
+    def start_exec(self):
+        self.interruptable = True
+
+    def get_server(self):
+        if getattr(self, "host", None) is not None:
+            return xmlrpclib.Server("http://%s:%s" % (self.host, self.client_port))
+        else:
+            return None
+
+    server = property(get_server)
+
+    def ShowConsole(self):
+        server = self.get_server()
+        if server is not None:
+            server.ShowConsole()
+
+    def finish_exec(self, more):
+        self.interruptable = False
+
+        server = self.get_server()
+
+        if server is not None:
+            return server.NotifyFinished(more)
+        else:
+            return True
+
+    def getFrame(self):
+        xml = StringIO()
+        hidden_ns = self.get_ipython_hidden_vars_dict()
+        xml.write("<xml>")
+        xml.write(pydevd_xml.frame_vars_to_xml(self.get_namespace(), hidden_ns))
+        xml.write("</xml>")
+
+        return xml.getvalue()
+
+    @silence_warnings_decorator
+    def getVariable(self, attributes):
+        xml = StringIO()
+        xml.write("<xml>")
+        val_dict = pydevd_vars.resolve_compound_var_object_fields(self.get_namespace(), attributes)
+        if val_dict is None:
+            val_dict = {}
+
+        for k, val in val_dict.items():
+            val = val_dict[k]
+            evaluate_full_value = pydevd_xml.should_evaluate_full_value(val)
+            xml.write(pydevd_vars.var_to_xml(val, k, evaluate_full_value=evaluate_full_value))
+
+        xml.write("</xml>")
+
+        return xml.getvalue()
+
+    def getArray(self, attr, roffset, coffset, rows, cols, format):
+        name = attr.split("\t")[-1]
+        array = pydevd_vars.eval_in_context(name, self.get_namespace(), self.get_namespace())
+        return pydevd_vars.table_like_struct_to_xml(array, name, roffset, coffset, rows, cols, format)
+
+    def evaluate(self, expression):
+        xml = StringIO()
+        xml.write("<xml>")
+        result = pydevd_vars.eval_in_context(expression, self.get_namespace(), self.get_namespace())
+        xml.write(pydevd_vars.var_to_xml(result, expression))
+        xml.write("</xml>")
+        return xml.getvalue()
+
+    @silence_warnings_decorator
+    def loadFullValue(self, seq, scope_attrs):
+        """
+        Evaluate full value for async Console variables in a separate thread and send results to IDE side
+        :param seq: id of command
+        :param scope_attrs: a sequence of variables with their attributes separated by NEXT_VALUE_SEPARATOR
+        (i.e.: obj\tattr1\tattr2NEXT_VALUE_SEPARATORobj2\attr1\tattr2)
+        :return:
+        """
+        frame_variables = self.get_namespace()
+        var_objects = []
+        vars = scope_attrs.split(NEXT_VALUE_SEPARATOR)
+        for var_attrs in vars:
+            if "\t" in var_attrs:
+                name, attrs = var_attrs.split("\t", 1)
+
+            else:
+                name = var_attrs
+                attrs = None
+            if name in frame_variables:
+                var_object = pydevd_vars.resolve_var_object(frame_variables[name], attrs)
+                var_objects.append((var_object, name))
+            else:
+                var_object = pydevd_vars.eval_in_context(name, frame_variables, frame_variables)
+                var_objects.append((var_object, name))
+
+        from _pydevd_bundle.pydevd_comm import GetValueAsyncThreadConsole
+
+        py_db = getattr(self, "debugger", None)
+
+        if py_db is None:
+            py_db = get_global_debugger()
+
+        if py_db is None:
+            from pydevd import PyDB
+
+            py_db = PyDB()
+
+        t = GetValueAsyncThreadConsole(py_db, self.get_server(), seq, var_objects)
+        t.start()
+
+    def changeVariable(self, attr, value):
+        def do_change_variable():
+            Exec("%s=%s" % (attr, value), self.get_namespace(), self.get_namespace())
+
+        # Important: it has to be really enabled in the main thread, so, schedule
+        # it to run in the main thread.
+        self.exec_queue.put(do_change_variable)
+
+    def connectToDebugger(self, debuggerPort, debugger_options=None):
+        """
+        Used to show console with variables connection.
+        Mainly, monkey-patches things in the debugger structure so that the debugger protocol works.
+        """
+
+        if debugger_options is None:
+            debugger_options = {}
+        env_key = "PYDEVD_EXTRA_ENVS"
+        if env_key in debugger_options:
+            for env_name, value in debugger_options[env_key].items():
+                existing_value = os.environ.get(env_name, None)
+                if existing_value:
+                    os.environ[env_name] = "%s%c%s" % (existing_value, os.path.pathsep, value)
+                else:
+                    os.environ[env_name] = value
+                if env_name == "PYTHONPATH":
+                    sys.path.append(value)
+
+            del debugger_options[env_key]
+
+        def do_connect_to_debugger():
+            try:
+                # Try to import the packages needed to attach the debugger
+                import pydevd
+                from _pydev_bundle._pydev_saved_modules import threading
+            except:
+                # This happens on Jython embedded in host eclipse
+                traceback.print_exc()
+                sys.stderr.write("pydevd is not available, cannot connect\n")
+
+            from _pydevd_bundle.pydevd_constants import set_thread_id
+            from _pydev_bundle import pydev_localhost
+
+            set_thread_id(threading.current_thread(), "console_main")
+
+            VIRTUAL_FRAME_ID = "1"  # matches PyStackFrameConsole.java
+            VIRTUAL_CONSOLE_ID = "console_main"  # matches PyThreadConsole.java
+            f = FakeFrame()
+            f.f_back = None
+            f.f_globals = {}  # As globals=locals here, let's simply let it empty (and save a bit of network traffic).
+            f.f_locals = self.get_namespace()
+
+            self.debugger = pydevd.PyDB()
+            self.debugger.add_fake_frame(thread_id=VIRTUAL_CONSOLE_ID, frame_id=VIRTUAL_FRAME_ID, frame=f)
+            try:
+                pydevd.apply_debugger_options(debugger_options)
+                self.debugger.connect(pydev_localhost.get_localhost(), debuggerPort)
+                self.debugger.prepare_to_run()
+                self.debugger.disable_tracing()
+            except:
+                traceback.print_exc()
+                sys.stderr.write("Failed to connect to target debugger.\n")
+
+            # Register to process commands when idle
+            self.debugrunning = False
+            try:
+                import pydevconsole
+
+                pydevconsole.set_debug_hook(self.debugger.process_internal_commands)
+            except:
+                traceback.print_exc()
+                sys.stderr.write("Version of Python does not support debuggable Interactive Console.\n")
+
+        # Important: it has to be really enabled in the main thread, so, schedule
+        # it to run in the main thread.
+        self.exec_queue.put(do_connect_to_debugger)
+
+        return ("connect complete",)
+
+    def handshake(self):
+        if self.connect_status_queue is not None:
+            self.connect_status_queue.put(True)
+        return "PyCharm"
+
+    def get_connect_status_queue(self):
+        return self.connect_status_queue
+
+    def hello(self, input_str):
+        # Don't care what the input string is
+        return ("Hello eclipse",)
+
+    def enableGui(self, guiname):
+        """Enable the GUI specified in guiname (see inputhook for list).
+        As with IPython, enabling multiple GUIs isn't an error, but
+        only the last one's main loop runs and it may not work
+        """
+
+        def do_enable_gui():
+            from _pydev_bundle.pydev_versioncheck import versionok_for_gui
+
+            if versionok_for_gui():
+                try:
+                    from pydev_ipython.inputhook import enable_gui
+
+                    enable_gui(guiname)
+                except:
+                    sys.stderr.write("Failed to enable GUI event loop integration for '%s'\n" % guiname)
+                    traceback.print_exc()
+            elif guiname not in ["none", "", None]:
+                # Only print a warning if the guiname was going to do something
+                sys.stderr.write("PyDev console: Python version does not support GUI event loop integration for '%s'\n" % guiname)
+            # Return value does not matter, so return back what was sent
+            return guiname
+
+        # Important: it has to be really enabled in the main thread, so, schedule
+        # it to run in the main thread.
+        self.exec_queue.put(do_enable_gui)
+
+    def get_ipython_hidden_vars_dict(self):
+        return None
+
+
+# =======================================================================================================================
+# FakeFrame
+# =======================================================================================================================
+class FakeFrame:
+    """
+    Used to show console with variables connection.
+    A class to be used as a mock of a frame.
+    """
@@ -0,0 +1,38 @@
+import sys
+import traceback
+from types import ModuleType
+from _pydevd_bundle.pydevd_constants import DebugInfoHolder
+
+import builtins
+
+
+class ImportHookManager(ModuleType):
+    def __init__(self, name, system_import):
+        ModuleType.__init__(self, name)
+        self._system_import = system_import
+        self._modules_to_patch = {}
+
+    def add_module_name(self, module_name, activate_function):
+        self._modules_to_patch[module_name] = activate_function
+
+    def do_import(self, name, *args, **kwargs):
+        module = self._system_import(name, *args, **kwargs)
+        try:
+            activate_func = self._modules_to_patch.pop(name, None)
+            if activate_func:
+                activate_func()  # call activate function
+        except:
+            if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 2:
+                traceback.print_exc()
+
+        # Restore normal system importer to reduce performance impact
+        # of calling this method every time an import statement is invoked
+        if not self._modules_to_patch:
+            builtins.__import__ = self._system_import
+
+        return module
+
+
+import_hook_manager = ImportHookManager(__name__ + ".import_hook", builtins.__import__)
+builtins.__import__ = import_hook_manager.do_import
+sys.modules[import_hook_manager.__name__] = import_hook_manager
@@ -0,0 +1,12 @@
+from _pydev_bundle._pydev_saved_modules import xmlrpclib
+from _pydev_bundle._pydev_saved_modules import xmlrpcserver
+
+SimpleXMLRPCServer = xmlrpcserver.SimpleXMLRPCServer
+
+from _pydev_bundle._pydev_execfile import execfile
+
+from _pydev_bundle._pydev_saved_modules import _queue
+
+from _pydevd_bundle.pydevd_exec2 import Exec
+
+from urllib.parse import quote, quote_plus, unquote_plus  # @UnresolvedImport
@@ -0,0 +1,95 @@
+import sys
+from _pydev_bundle.pydev_console_utils import BaseInterpreterInterface
+
+import traceback
+
+# Uncomment to force PyDev standard shell.
+# raise ImportError()
+
+from _pydev_bundle.pydev_ipython_console_011 import get_pydev_frontend
+
+
+# =======================================================================================================================
+# InterpreterInterface
+# =======================================================================================================================
+class InterpreterInterface(BaseInterpreterInterface):
+    """
+    The methods in this class should be registered in the xml-rpc server.
+    """
+
+    def __init__(self, host, client_port, main_thread, show_banner=True, connect_status_queue=None):
+        BaseInterpreterInterface.__init__(self, main_thread, connect_status_queue)
+        self.client_port = client_port
+        self.host = host
+        self.interpreter = get_pydev_frontend(host, client_port)
+        self._input_error_printed = False
+        self.notification_succeeded = False
+        self.notification_tries = 0
+        self.notification_max_tries = 3
+        self.show_banner = show_banner
+
+        self.notify_about_magic()
+
+    def get_greeting_msg(self):
+        if self.show_banner:
+            self.interpreter.show_banner()
+        return self.interpreter.get_greeting_msg()
+
+    def do_add_exec(self, code_fragment):
+        self.notify_about_magic()
+        if code_fragment.text.rstrip().endswith("??"):
+            print("IPython-->")
+        try:
+            res = bool(self.interpreter.add_exec(code_fragment.text))
+        finally:
+            if code_fragment.text.rstrip().endswith("??"):
+                print("<--IPython")
+
+        return res
+
+    def get_namespace(self):
+        return self.interpreter.get_namespace()
+
+    def getCompletions(self, text, act_tok):
+        return self.interpreter.getCompletions(text, act_tok)
+
+    def close(self):
+        sys.exit(0)
+
+    def notify_about_magic(self):
+        if not self.notification_succeeded:
+            self.notification_tries += 1
+            if self.notification_tries > self.notification_max_tries:
+                return
+            completions = self.getCompletions("%", "%")
+            magic_commands = [x[0] for x in completions]
+
+            server = self.get_server()
+
+            if server is not None:
+                try:
+                    server.NotifyAboutMagic(magic_commands, self.interpreter.is_automagic())
+                    self.notification_succeeded = True
+                except:
+                    self.notification_succeeded = False
+
+    def get_ipython_hidden_vars_dict(self):
+        try:
+            if hasattr(self.interpreter, "ipython") and hasattr(self.interpreter.ipython, "user_ns_hidden"):
+                user_ns_hidden = self.interpreter.ipython.user_ns_hidden
+                if isinstance(user_ns_hidden, dict):
+                    # Since IPython 2 dict `user_ns_hidden` contains hidden variables and values
+                    user_hidden_dict = user_ns_hidden.copy()
+                else:
+                    # In IPython 1.x `user_ns_hidden` used to be a set with names of hidden variables
+                    user_hidden_dict = dict([(key, val) for key, val in self.interpreter.ipython.user_ns.items() if key in user_ns_hidden])
+
+                # while `_`, `__` and `___` were not initialized, they are not presented in `user_ns_hidden`
+                user_hidden_dict.setdefault("_", "")
+                user_hidden_dict.setdefault("__", "")
+                user_hidden_dict.setdefault("___", "")
+
+                return user_hidden_dict
+        except:
+            # Getting IPython variables shouldn't break loading frame variables
+            traceback.print_exc()
@@ -0,0 +1,504 @@
+# TODO that would make IPython integration better
+# - show output other times then when enter was pressed
+# - support proper exit to allow IPython to cleanup (e.g. temp files created with %edit)
+# - support Ctrl-D (Ctrl-Z on Windows)
+# - use IPython (numbered) prompts in PyDev
+# - better integration of IPython and PyDev completions
+# - some of the semantics on handling the code completion are not correct:
+#   eg: Start a line with % and then type c should give %cd as a completion by it doesn't
+#       however type %c and request completions and %cd is given as an option
+#   eg: Completing a magic when user typed it without the leading % causes the % to be inserted
+#       to the left of what should be the first colon.
+"""Interface to TerminalInteractiveShell for PyDev Interactive Console frontend
+   for IPython 0.11 to 1.0+.
+"""
+
+from __future__ import print_function
+
+import os
+import sys
+import codeop
+import traceback
+
+from IPython.core.error import UsageError
+from IPython.core.completer import IPCompleter
+from IPython.core.interactiveshell import InteractiveShell, InteractiveShellABC
+from IPython.core.usage import default_banner_parts
+from IPython.utils.strdispatch import StrDispatch
+import IPython.core.release as IPythonRelease
+from IPython.terminal.interactiveshell import TerminalInteractiveShell
+
+try:
+    from traitlets import CBool, Unicode
+except ImportError:
+    from IPython.utils.traitlets import CBool, Unicode
+from IPython.core import release
+
+from _pydev_bundle.pydev_imports import xmlrpclib
+
+default_pydev_banner_parts = default_banner_parts
+
+default_pydev_banner = "".join(default_pydev_banner_parts)
+
+
+def show_in_pager(self, strng, *args, **kwargs):
+    """Run a string through pager"""
+    # On PyDev we just output the string, there are scroll bars in the console
+    # to handle "paging". This is the same behaviour as when TERM==dump (see
+    # page.py)
+    # for compatibility with mime-bundle form:
+    if isinstance(strng, dict):
+        strng = strng.get("text/plain", strng)
+    print(strng)
+
+
+def create_editor_hook(pydev_host, pydev_client_port):
+    def call_editor(filename, line=0, wait=True):
+        """Open an editor in PyDev"""
+        if line is None:
+            line = 0
+
+        # Make sure to send an absolution path because unlike most editor hooks
+        # we don't launch a process. This is more like what happens in the zmqshell
+        filename = os.path.abspath(filename)
+
+        # import sys
+        # sys.__stderr__.write('Calling editor at: %s:%s\n' % (pydev_host, pydev_client_port))
+
+        # Tell PyDev to open the editor
+        server = xmlrpclib.Server("http://%s:%s" % (pydev_host, pydev_client_port))
+        server.IPythonEditor(filename, str(line))
+
+        if wait:
+            input("Press Enter when done editing:")
+
+    return call_editor
+
+
+class PyDevIPCompleter(IPCompleter):
+    def __init__(self, *args, **kwargs):
+        """Create a Completer that reuses the advanced completion support of PyDev
+        in addition to the completion support provided by IPython"""
+        IPCompleter.__init__(self, *args, **kwargs)
+        # Use PyDev for python matches, see getCompletions below
+        if self.python_matches in self.matchers:
+            # `self.python_matches` matches attributes or global python names
+            self.matchers.remove(self.python_matches)
+
+
+class PyDevIPCompleter6(IPCompleter):
+    def __init__(self, *args, **kwargs):
+        """Create a Completer that reuses the advanced completion support of PyDev
+        in addition to the completion support provided by IPython"""
+        IPCompleter.__init__(self, *args, **kwargs)
+
+    @property
+    def matchers(self):
+        """All active matcher routines for completion"""
+        # To remove python_matches we now have to override it as it's now a property in the superclass.
+        return [
+            self.file_matches,
+            self.magic_matches,
+            self.python_func_kw_matches,
+            self.dict_key_matches,
+        ]
+
+    @matchers.setter
+    def matchers(self, value):
+        # To stop the init in IPCompleter raising an AttributeError we now have to specify a setter as it's now a property in the superclass.
+        return
+
+
+class PyDevTerminalInteractiveShell(TerminalInteractiveShell):
+    banner1 = Unicode(default_pydev_banner, config=True, help="""The part of the banner to be printed before the profile""")
+
+    # TODO term_title: (can PyDev's title be changed???, see terminal.py for where to inject code, in particular set_term_title as used by %cd)
+    # for now, just disable term_title
+    term_title = CBool(False)
+
+    # Note in version 0.11 there is no guard in the IPython code about displaying a
+    # warning, so with 0.11 you get:
+    #  WARNING: Readline services not available or not loaded.
+    #  WARNING: The auto-indent feature requires the readline library
+    # Disable readline, readline type code is all handled by PyDev (on Java side)
+    readline_use = CBool(False)
+    # autoindent has no meaning in PyDev (PyDev always handles that on the Java side),
+    # and attempting to enable it will print a warning in the absence of readline.
+    autoindent = CBool(False)
+    # Force console to not give warning about color scheme choice and default to NoColor.
+    # TODO It would be nice to enable colors in PyDev but:
+    # - The PyDev Console (Eclipse Console) does not support the full range of colors, so the
+    #   effect isn't as nice anyway at the command line
+    # - If done, the color scheme should default to LightBG, but actually be dependent on
+    #   any settings the user has (such as if a dark theme is in use, then Linux is probably
+    #   a better theme).
+    colors_force = CBool(True)
+    colors = Unicode("NoColor")
+    # Since IPython 5 the terminal interface is not compatible with Emacs `inferior-shell` and
+    # the `simple_prompt` flag is needed
+    simple_prompt = CBool(True)
+
+    # In the PyDev Console, GUI control is done via hookable XML-RPC server
+    @staticmethod
+    def enable_gui(gui=None, app=None):
+        """Switch amongst GUI input hooks by name."""
+        # Deferred import
+        from pydev_ipython.inputhook import enable_gui as real_enable_gui
+
+        try:
+            return real_enable_gui(gui, app)
+        except ValueError as e:
+            raise UsageError("%s" % e)
+
+    # -------------------------------------------------------------------------
+    # Things related to hooks
+    # -------------------------------------------------------------------------
+
+    def init_history(self):
+        # Disable history so that we don't have an additional thread for that
+        # (and we don't use the history anyways).
+        self.config.HistoryManager.enabled = False
+        super(PyDevTerminalInteractiveShell, self).init_history()
+
+    def init_hooks(self):
+        super(PyDevTerminalInteractiveShell, self).init_hooks()
+        self.set_hook("show_in_pager", show_in_pager)
+
+    # -------------------------------------------------------------------------
+    # Things related to exceptions
+    # -------------------------------------------------------------------------
+
+    def showtraceback(self, exc_tuple=None, *args, **kwargs):
+        # IPython does a lot of clever stuff with Exceptions. However mostly
+        # it is related to IPython running in a terminal instead of an IDE.
+        # (e.g. it prints out snippets of code around the stack trace)
+        # PyDev does a lot of clever stuff too, so leave exception handling
+        # with default print_exc that PyDev can parse and do its clever stuff
+        # with (e.g. it puts links back to the original source code)
+        try:
+            if exc_tuple is None:
+                etype, value, tb = sys.exc_info()
+            else:
+                etype, value, tb = exc_tuple
+        except ValueError:
+            return
+
+        if tb is not None:
+            traceback.print_exception(etype, value, tb)
+
+    # -------------------------------------------------------------------------
+    # Things related to text completion
+    # -------------------------------------------------------------------------
+
+    # The way to construct an IPCompleter changed in most versions,
+    # so we have a custom, per version implementation of the construction
+
+    def _new_completer_100(self):
+        completer = PyDevIPCompleter(
+            shell=self,
+            namespace=self.user_ns,
+            global_namespace=self.user_global_ns,
+            alias_table=self.alias_manager.alias_table,
+            use_readline=self.has_readline,
+            parent=self,
+        )
+        return completer
+
+    def _new_completer_234(self):
+        # correct for IPython versions 2.x, 3.x, 4.x
+        completer = PyDevIPCompleter(
+            shell=self,
+            namespace=self.user_ns,
+            global_namespace=self.user_global_ns,
+            use_readline=self.has_readline,
+            parent=self,
+        )
+        return completer
+
+    def _new_completer_500(self):
+        completer = PyDevIPCompleter(
+            shell=self, namespace=self.user_ns, global_namespace=self.user_global_ns, use_readline=False, parent=self
+        )
+        return completer
+
+    def _new_completer_600(self):
+        completer = PyDevIPCompleter6(
+            shell=self, namespace=self.user_ns, global_namespace=self.user_global_ns, use_readline=False, parent=self
+        )
+        return completer
+
+    def add_completer_hooks(self):
+        from IPython.core.completerlib import module_completer, magic_run_completer, cd_completer
+
+        try:
+            from IPython.core.completerlib import reset_completer
+        except ImportError:
+            # reset_completer was added for rel-0.13
+            reset_completer = None
+        self.configurables.append(self.Completer)
+
+        # Add custom completers to the basic ones built into IPCompleter
+        sdisp = self.strdispatchers.get("complete_command", StrDispatch())
+        self.strdispatchers["complete_command"] = sdisp
+        self.Completer.custom_completers = sdisp
+
+        self.set_hook("complete_command", module_completer, str_key="import")
+        self.set_hook("complete_command", module_completer, str_key="from")
+        self.set_hook("complete_command", magic_run_completer, str_key="%run")
+        self.set_hook("complete_command", cd_completer, str_key="%cd")
+        if reset_completer:
+            self.set_hook("complete_command", reset_completer, str_key="%reset")
+
+    def init_completer(self):
+        """Initialize the completion machinery.
+
+        This creates a completer that provides the completions that are
+        IPython specific. We use this to supplement PyDev's core code
+        completions.
+        """
+        # PyDev uses its own completer and custom hooks so that it uses
+        # most completions from PyDev's core completer which provides
+        # extra information.
+        # See getCompletions for where the two sets of results are merged
+
+        if IPythonRelease._version_major >= 6:
+            self.Completer = self._new_completer_600()
+        elif IPythonRelease._version_major >= 5:
+            self.Completer = self._new_completer_500()
+        elif IPythonRelease._version_major >= 2:
+            self.Completer = self._new_completer_234()
+        elif IPythonRelease._version_major >= 1:
+            self.Completer = self._new_completer_100()
+
+        if hasattr(self.Completer, "use_jedi"):
+            self.Completer.use_jedi = False
+
+        self.add_completer_hooks()
+
+        if IPythonRelease._version_major <= 3:
+            # Only configure readline if we truly are using readline.  IPython can
+            # do tab-completion over the network, in GUIs, etc, where readline
+            # itself may be absent
+            if self.has_readline:
+                self.set_readline_completer()
+
+    # -------------------------------------------------------------------------
+    # Things related to aliases
+    # -------------------------------------------------------------------------
+
+    def init_alias(self):
+        # InteractiveShell defines alias's we want, but TerminalInteractiveShell defines
+        # ones we don't. So don't use super and instead go right to InteractiveShell
+        InteractiveShell.init_alias(self)
+
+    # -------------------------------------------------------------------------
+    # Things related to exiting
+    # -------------------------------------------------------------------------
+    def ask_exit(self):
+        """Ask the shell to exit. Can be overiden and used as a callback."""
+        # TODO PyDev's console does not have support from the Python side to exit
+        # the console. If user forces the exit (with sys.exit()) then the console
+        # simply reports errors. e.g.:
+        # >>> import sys
+        # >>> sys.exit()
+        # Failed to create input stream: Connection refused
+        # >>>
+        # Console already exited with value: 0 while waiting for an answer.
+        # Error stream:
+        # Output stream:
+        # >>>
+        #
+        # Alternatively if you use the non-IPython shell this is what happens
+        # >>> exit()
+        # <type 'exceptions.SystemExit'>:None
+        # >>>
+        # <type 'exceptions.SystemExit'>:None
+        # >>>
+        #
+        super(PyDevTerminalInteractiveShell, self).ask_exit()
+        print("To exit the PyDev Console, terminate the console within IDE.")
+
+    # -------------------------------------------------------------------------
+    # Things related to magics
+    # -------------------------------------------------------------------------
+
+    def init_magics(self):
+        super(PyDevTerminalInteractiveShell, self).init_magics()
+        # TODO Any additional magics for PyDev?
+
+
+InteractiveShellABC.register(PyDevTerminalInteractiveShell)  # @UndefinedVariable
+
+
+# =======================================================================================================================
+# _PyDevFrontEnd
+# =======================================================================================================================
+class _PyDevFrontEnd:
+    version = release.__version__
+
+    def __init__(self):
+        # Create and initialize our IPython instance.
+        if hasattr(PyDevTerminalInteractiveShell, "_instance") and PyDevTerminalInteractiveShell._instance is not None:
+            self.ipython = PyDevTerminalInteractiveShell._instance
+        else:
+            self.ipython = PyDevTerminalInteractiveShell.instance()
+
+        self._curr_exec_line = 0
+        self._curr_exec_lines = []
+
+    def show_banner(self):
+        self.ipython.show_banner()
+
+    def update(self, globals, locals):
+        ns = self.ipython.user_ns
+
+        for key, value in list(ns.items()):
+            if key not in locals:
+                locals[key] = value
+
+        self.ipython.user_global_ns.clear()
+        self.ipython.user_global_ns.update(globals)
+        self.ipython.user_ns = locals
+
+        if hasattr(self.ipython, "history_manager") and hasattr(self.ipython.history_manager, "save_thread"):
+            self.ipython.history_manager.save_thread.pydev_do_not_trace = True  # don't trace ipython history saving thread
+
+    def complete(self, string):
+        try:
+            if string:
+                return self.ipython.complete(None, line=string, cursor_pos=string.__len__())
+            else:
+                return self.ipython.complete(string, string, 0)
+        except:
+            # Silence completer exceptions
+            pass
+
+    def is_complete(self, string):
+        # Based on IPython 0.10.1
+
+        if string in ("", "\n"):
+            # Prefiltering, eg through ipython0, may return an empty
+            # string although some operations have been accomplished. We
+            # thus want to consider an empty string as a complete
+            # statement.
+            return True
+        else:
+            try:
+                # Add line returns here, to make sure that the statement is
+                # complete (except if '\' was used).
+                # This should probably be done in a different place (like
+                # maybe 'prefilter_input' method? For now, this works.
+                clean_string = string.rstrip("\n")
+                if not clean_string.endswith("\\"):
+                    clean_string += "\n\n"
+
+                is_complete = codeop.compile_command(clean_string, "<string>", "exec")
+            except Exception:
+                # XXX: Hack: return True so that the
+                # code gets executed and the error captured.
+                is_complete = True
+            return is_complete
+
+    def getCompletions(self, text, act_tok):
+        # Get completions from IPython and from PyDev and merge the results
+        # IPython only gives context free list of completions, while PyDev
+        # gives detailed information about completions.
+        try:
+            TYPE_IPYTHON = "11"
+            TYPE_IPYTHON_MAGIC = "12"
+            _line, ipython_completions = self.complete(text)
+
+            from _pydev_bundle._pydev_completer import Completer
+
+            completer = Completer(self.get_namespace(), None)
+            ret = completer.complete(act_tok)
+            append = ret.append
+            ip = self.ipython
+            pydev_completions = set([f[0] for f in ret])
+            for ipython_completion in ipython_completions:
+                # PyCharm was not expecting completions with '%'...
+                # Could be fixed in the backend, but it's probably better
+                # fixing it at PyCharm.
+                # if ipython_completion.startswith('%'):
+                #    ipython_completion = ipython_completion[1:]
+
+                if ipython_completion not in pydev_completions:
+                    pydev_completions.add(ipython_completion)
+                    inf = ip.object_inspect(ipython_completion)
+                    if inf["type_name"] == "Magic function":
+                        pydev_type = TYPE_IPYTHON_MAGIC
+                    else:
+                        pydev_type = TYPE_IPYTHON
+                    pydev_doc = inf["docstring"]
+                    if pydev_doc is None:
+                        pydev_doc = ""
+                    append((ipython_completion, pydev_doc, "", pydev_type))
+            return ret
+        except:
+            import traceback
+
+            traceback.print_exc()
+            return []
+
+    def get_namespace(self):
+        return self.ipython.user_ns
+
+    def clear_buffer(self):
+        del self._curr_exec_lines[:]
+
+    def add_exec(self, line):
+        if self._curr_exec_lines:
+            self._curr_exec_lines.append(line)
+
+            buf = "\n".join(self._curr_exec_lines)
+
+            if self.is_complete(buf):
+                self._curr_exec_line += 1
+                self.ipython.run_cell(buf)
+                del self._curr_exec_lines[:]
+                return False  # execute complete (no more)
+
+            return True  # needs more
+        else:
+            if not self.is_complete(line):
+                # Did not execute
+                self._curr_exec_lines.append(line)
+                return True  # needs more
+            else:
+                self._curr_exec_line += 1
+                self.ipython.run_cell(line, store_history=True)
+                # hist = self.ipython.history_manager.output_hist_reprs
+                # rep = hist.get(self._curr_exec_line, None)
+                # if rep is not None:
+                #    print(rep)
+                return False  # execute complete (no more)
+
+    def is_automagic(self):
+        return self.ipython.automagic
+
+    def get_greeting_msg(self):
+        return "PyDev console: using IPython %s\n" % self.version
+
+
+class _PyDevFrontEndContainer:
+    _instance = None
+    _last_host_port = None
+
+
+def get_pydev_frontend(pydev_host, pydev_client_port):
+    if _PyDevFrontEndContainer._instance is None:
+        _PyDevFrontEndContainer._instance = _PyDevFrontEnd()
+
+    if _PyDevFrontEndContainer._last_host_port != (pydev_host, pydev_client_port):
+        _PyDevFrontEndContainer._last_host_port = pydev_host, pydev_client_port
+
+        # Back channel to PyDev to open editors (in the future other
+        # info may go back this way. This is the same channel that is
+        # used to get stdin, see StdIn in pydev_console_utils)
+        _PyDevFrontEndContainer._instance.ipython.hooks["editor"] = create_editor_hook(pydev_host, pydev_client_port)
+
+        # Note: setting the callback directly because setting it with set_hook would actually create a chain instead
+        # of ovewriting at each new call).
+        # _PyDevFrontEndContainer._instance.ipython.set_hook('editor', create_editor_hook(pydev_host, pydev_client_port))
+
+    return _PyDevFrontEndContainer._instance
@@ -0,0 +1,30 @@
+from _pydev_bundle._pydev_saved_modules import threading
+
+# Hack for https://www.brainwy.com/tracker/PyDev/363 (i.e.: calling is_alive() can throw AssertionError under some
+# circumstances).
+# It is required to debug threads started by start_new_thread in Python 3.4
+_temp = threading.Thread()
+
+if hasattr(_temp, "_handle") and hasattr(_temp, "_started"):  # Python 3.13 and later has this
+
+    def is_thread_alive(t):
+        return not t._handle.is_done()
+
+
+elif hasattr(_temp, "_is_stopped"):  # Python 3.12 and earlier has this
+
+    def is_thread_alive(t):
+        return not t._is_stopped
+
+elif hasattr(_temp, "_Thread__stopped"):  # Python 2.x has this
+
+    def is_thread_alive(t):
+        return not t._Thread__stopped
+
+else:
+    # Jython wraps a native java thread and thus only obeys the public API.
+    def is_thread_alive(t):
+        return t.is_alive()
+
+
+del _temp
@@ -0,0 +1,68 @@
+from _pydev_bundle._pydev_saved_modules import socket
+import sys
+
+IS_JYTHON = sys.platform.find("java") != -1
+
+_cache = None
+
+
+def get_localhost():
+    """
+    Should return 127.0.0.1 in ipv4 and ::1 in ipv6
+
+    localhost is not used because on windows vista/windows 7, there can be issues where the resolving doesn't work
+    properly and takes a lot of time (had this issue on the pyunit server).
+
+    Using the IP directly solves the problem.
+    """
+    # TODO: Needs better investigation!
+
+    global _cache
+    if _cache is None:
+        try:
+            for addr_info in socket.getaddrinfo("localhost", 80, 0, 0, socket.SOL_TCP):
+                config = addr_info[4]
+                if config[0] == "127.0.0.1":
+                    _cache = "127.0.0.1"
+                    return _cache
+        except:
+            # Ok, some versions of Python don't have getaddrinfo or SOL_TCP... Just consider it 127.0.0.1 in this case.
+            _cache = "127.0.0.1"
+        else:
+            _cache = "localhost"
+
+    return _cache
+
+
+def get_socket_names(n_sockets, close=False):
+    socket_names = []
+    sockets = []
+    for _ in range(n_sockets):
+        if IS_JYTHON:
+            # Although the option which would be pure java *should* work for Jython, the socket being returned is still 0
+            # (i.e.: it doesn't give the local port bound, only the original port, which was 0).
+            from java.net import ServerSocket
+
+            sock = ServerSocket(0)
+            socket_name = get_localhost(), sock.getLocalPort()
+        else:
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            sock.bind((get_localhost(), 0))
+            socket_name = sock.getsockname()
+
+        sockets.append(sock)
+        socket_names.append(socket_name)
+
+    if close:
+        for s in sockets:
+            s.close()
+    return socket_names
+
+
+def get_socket_name(close=False):
+    return get_socket_names(1, close)[0]
+
+
+if __name__ == "__main__":
+    print(get_socket_name())
@@ -0,0 +1,284 @@
+from _pydevd_bundle.pydevd_constants import DebugInfoHolder, SHOW_COMPILE_CYTHON_COMMAND_LINE, NULL, LOG_TIME, ForkSafeLock
+from contextlib import contextmanager
+import traceback
+import os
+import sys
+
+
+class _LoggingGlobals(object):
+    _warn_once_map = {}
+    _debug_stream_filename = None
+    _debug_stream = NULL
+    _debug_stream_initialized = False
+    _initialize_lock = ForkSafeLock()
+
+
+def initialize_debug_stream(reinitialize=False):
+    """
+    :param bool reinitialize:
+        Reinitialize is used to update the debug stream after a fork (thus, if it wasn't
+        initialized, we don't need to do anything, just wait for the first regular log call
+        to initialize).
+    """
+    if reinitialize:
+        if not _LoggingGlobals._debug_stream_initialized:
+            return
+    else:
+        if _LoggingGlobals._debug_stream_initialized:
+            return
+
+    with _LoggingGlobals._initialize_lock:
+        # Initialization is done lazilly, so, it's possible that multiple threads try to initialize
+        # logging.
+
+        # Check initial conditions again after obtaining the lock.
+        if reinitialize:
+            if not _LoggingGlobals._debug_stream_initialized:
+                return
+        else:
+            if _LoggingGlobals._debug_stream_initialized:
+                return
+
+        _LoggingGlobals._debug_stream_initialized = True
+
+        # Note: we cannot initialize with sys.stderr because when forking we may end up logging things in 'os' calls.
+        _LoggingGlobals._debug_stream = NULL
+        _LoggingGlobals._debug_stream_filename = None
+
+        if not DebugInfoHolder.PYDEVD_DEBUG_FILE:
+            _LoggingGlobals._debug_stream = sys.stderr
+        else:
+            # Add pid to the filename.
+            try:
+                target_file = DebugInfoHolder.PYDEVD_DEBUG_FILE
+                debug_file = _compute_filename_with_pid(target_file)
+                _LoggingGlobals._debug_stream = open(debug_file, "w")
+                _LoggingGlobals._debug_stream_filename = debug_file
+            except Exception:
+                _LoggingGlobals._debug_stream = sys.stderr
+                # Don't fail when trying to setup logging, just show the exception.
+                traceback.print_exc()
+
+
+def _compute_filename_with_pid(target_file, pid=None):
+    # Note: used in tests.
+    dirname = os.path.dirname(target_file)
+    basename = os.path.basename(target_file)
+    try:
+        os.makedirs(dirname)
+    except Exception:
+        pass  # Ignore error if it already exists.
+
+    name, ext = os.path.splitext(basename)
+    if pid is None:
+        pid = os.getpid()
+    return os.path.join(dirname, "%s.%s%s" % (name, pid, ext))
+
+
+def log_to(log_file: str, log_level: int = 3) -> None:
+    with _LoggingGlobals._initialize_lock:
+        # Can be set directly.
+        DebugInfoHolder.DEBUG_TRACE_LEVEL = log_level
+
+        if DebugInfoHolder.PYDEVD_DEBUG_FILE != log_file:
+            # Note that we don't need to reset it unless it actually changed
+            # (would be the case where it's set as an env var in a new process
+            # and a subprocess initializes logging to the same value).
+            _LoggingGlobals._debug_stream = NULL
+            _LoggingGlobals._debug_stream_filename = None
+
+            DebugInfoHolder.PYDEVD_DEBUG_FILE = log_file
+
+            _LoggingGlobals._debug_stream_initialized = False
+
+
+def list_log_files(pydevd_debug_file):
+    log_files = []
+    dirname = os.path.dirname(pydevd_debug_file)
+    basename = os.path.basename(pydevd_debug_file)
+    if os.path.isdir(dirname):
+        name, ext = os.path.splitext(basename)
+        for f in os.listdir(dirname):
+            if f.startswith(name) and f.endswith(ext):
+                log_files.append(os.path.join(dirname, f))
+    return log_files
+
+
+@contextmanager
+def log_context(trace_level, stream):
+    """
+    To be used to temporarily change the logging settings.
+    """
+    with _LoggingGlobals._initialize_lock:
+        original_trace_level = DebugInfoHolder.DEBUG_TRACE_LEVEL
+        original_debug_stream = _LoggingGlobals._debug_stream
+        original_pydevd_debug_file = DebugInfoHolder.PYDEVD_DEBUG_FILE
+        original_debug_stream_filename = _LoggingGlobals._debug_stream_filename
+        original_initialized = _LoggingGlobals._debug_stream_initialized
+
+        DebugInfoHolder.DEBUG_TRACE_LEVEL = trace_level
+        _LoggingGlobals._debug_stream = stream
+        _LoggingGlobals._debug_stream_initialized = True
+    try:
+        yield
+    finally:
+        with _LoggingGlobals._initialize_lock:
+            DebugInfoHolder.DEBUG_TRACE_LEVEL = original_trace_level
+            _LoggingGlobals._debug_stream = original_debug_stream
+            DebugInfoHolder.PYDEVD_DEBUG_FILE = original_pydevd_debug_file
+            _LoggingGlobals._debug_stream_filename = original_debug_stream_filename
+            _LoggingGlobals._debug_stream_initialized = original_initialized
+
+
+import time
+
+_last_log_time = time.time()
+
+# Set to True to show pid in each logged message (usually the file has it, but sometimes it's handy).
+_LOG_PID = False
+
+
+def _pydevd_log(level, msg, *args):
+    """
+    Levels are:
+
+    0 most serious warnings/errors (always printed)
+    1 warnings/significant events
+    2 informational trace
+    3 verbose mode
+    """
+    if level <= DebugInfoHolder.DEBUG_TRACE_LEVEL:
+        # yes, we can have errors printing if the console of the program has been finished (and we're still trying to print something)
+        try:
+            try:
+                if args:
+                    msg = msg % args
+            except:
+                msg = "%s - %s" % (msg, args)
+
+            if LOG_TIME:
+                global _last_log_time
+                new_log_time = time.time()
+                time_diff = new_log_time - _last_log_time
+                _last_log_time = new_log_time
+                msg = "%.2fs - %s\n" % (
+                    time_diff,
+                    msg,
+                )
+            else:
+                msg = "%s\n" % (msg,)
+
+            if _LOG_PID:
+                msg = "<%s> - %s\n" % (
+                    os.getpid(),
+                    msg,
+                )
+
+            try:
+                try:
+                    initialize_debug_stream()  # Do it as late as possible
+                    _LoggingGlobals._debug_stream.write(msg)
+                except TypeError:
+                    if isinstance(msg, bytes):
+                        # Depending on the StringIO flavor, it may only accept unicode.
+                        msg = msg.decode("utf-8", "replace")
+                        _LoggingGlobals._debug_stream.write(msg)
+            except UnicodeEncodeError:
+                # When writing to the stream it's possible that the string can't be represented
+                # in the encoding expected (in this case, convert it to the stream encoding
+                # or ascii if we can't find one suitable using a suitable replace).
+                encoding = getattr(_LoggingGlobals._debug_stream, "encoding", "ascii")
+                msg = msg.encode(encoding, "backslashreplace")
+                msg = msg.decode(encoding)
+                _LoggingGlobals._debug_stream.write(msg)
+
+            _LoggingGlobals._debug_stream.flush()
+        except:
+            pass
+        return True
+
+
+def _pydevd_log_exception(msg="", *args):
+    if msg or args:
+        _pydevd_log(0, msg, *args)
+    try:
+        initialize_debug_stream()  # Do it as late as possible
+        traceback.print_exc(file=_LoggingGlobals._debug_stream)
+        _LoggingGlobals._debug_stream.flush()
+    except:
+        raise
+
+
+def verbose(msg, *args):
+    if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 3:
+        _pydevd_log(3, msg, *args)
+
+
+def debug(msg, *args):
+    if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 2:
+        _pydevd_log(2, msg, *args)
+
+
+def info(msg, *args):
+    if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 1:
+        _pydevd_log(1, msg, *args)
+
+
+warn = info
+
+
+def critical(msg, *args):
+    _pydevd_log(0, msg, *args)
+
+
+def exception(msg="", *args):
+    try:
+        _pydevd_log_exception(msg, *args)
+    except:
+        pass  # Should never fail (even at interpreter shutdown).
+
+
+error = exception
+
+
+def error_once(msg, *args):
+    try:
+        if args:
+            message = msg % args
+        else:
+            message = str(msg)
+    except:
+        message = "%s - %s" % (msg, args)
+
+    if message not in _LoggingGlobals._warn_once_map:
+        _LoggingGlobals._warn_once_map[message] = True
+        critical(message)
+
+
+def exception_once(msg, *args):
+    try:
+        if args:
+            message = msg % args
+        else:
+            message = str(msg)
+    except:
+        message = "%s - %s" % (msg, args)
+
+    if message not in _LoggingGlobals._warn_once_map:
+        _LoggingGlobals._warn_once_map[message] = True
+        exception(message)
+
+
+def debug_once(msg, *args):
+    if DebugInfoHolder.DEBUG_TRACE_LEVEL >= 3:
+        error_once(msg, *args)
+
+
+def show_compile_cython_command_line():
+    if SHOW_COMPILE_CYTHON_COMMAND_LINE:
+        dirname = os.path.dirname(os.path.dirname(__file__))
+        error_once(
+            'warning: Debugger speedups using cython not found. Run \'"%s" "%s" build_ext --inplace\' to build.',
+            sys.executable,
+            os.path.join(dirname, "setup_pydevd_cython.py"),
+        )
@@ -0,0 +1,220 @@
+from __future__ import nested_scopes
+
+from _pydev_bundle._pydev_saved_modules import threading
+import os
+from _pydev_bundle import pydev_log
+
+
+def set_trace_in_qt():
+    from _pydevd_bundle.pydevd_comm import get_global_debugger
+
+    py_db = get_global_debugger()
+    if py_db is not None:
+        threading.current_thread()  # Create the dummy thread for qt.
+        py_db.enable_tracing()
+
+
+_patched_qt = False
+
+
+def patch_qt(qt_support_mode):
+    """
+    This method patches qt (PySide2, PySide, PyQt4, PyQt5) so that we have hooks to set the tracing for QThread.
+    """
+    if not qt_support_mode:
+        return
+
+    if qt_support_mode is True or qt_support_mode == "True":
+        # do not break backward compatibility
+        qt_support_mode = "auto"
+
+    if qt_support_mode == "auto":
+        qt_support_mode = os.getenv("PYDEVD_PYQT_MODE", "auto")
+
+    # Avoid patching more than once
+    global _patched_qt
+    if _patched_qt:
+        return
+
+    pydev_log.debug("Qt support mode: %s", qt_support_mode)
+
+    _patched_qt = True
+
+    if qt_support_mode == "auto":
+        patch_qt_on_import = None
+        try:
+            import PySide2  # @UnresolvedImport @UnusedImport
+
+            qt_support_mode = "pyside2"
+        except:
+            try:
+                import Pyside  # @UnresolvedImport @UnusedImport
+
+                qt_support_mode = "pyside"
+            except:
+                try:
+                    import PyQt5  # @UnresolvedImport @UnusedImport
+
+                    qt_support_mode = "pyqt5"
+                except:
+                    try:
+                        import PyQt4  # @UnresolvedImport @UnusedImport
+
+                        qt_support_mode = "pyqt4"
+                    except:
+                        return
+
+    if qt_support_mode == "pyside2":
+        try:
+            import PySide2.QtCore  # @UnresolvedImport
+
+            _internal_patch_qt(PySide2.QtCore, qt_support_mode)
+        except:
+            return
+
+    elif qt_support_mode == "pyside":
+        try:
+            import PySide.QtCore  # @UnresolvedImport
+
+            _internal_patch_qt(PySide.QtCore, qt_support_mode)
+        except:
+            return
+
+    elif qt_support_mode == "pyqt5":
+        try:
+            import PyQt5.QtCore  # @UnresolvedImport
+
+            _internal_patch_qt(PyQt5.QtCore)
+        except:
+            return
+
+    elif qt_support_mode == "pyqt4":
+        # Ok, we have an issue here:
+        # PyDev-452: Selecting PyQT API version using sip.setapi fails in debug mode
+        # http://pyqt.sourceforge.net/Docs/PyQt4/incompatible_apis.html
+        # Mostly, if the user uses a different API version (i.e.: v2 instead of v1),
+        # that has to be done before importing PyQt4 modules (PySide/PyQt5 don't have this issue
+        # as they only implements v2).
+        patch_qt_on_import = "PyQt4"
+
+        def get_qt_core_module():
+            import PyQt4.QtCore  # @UnresolvedImport
+
+            return PyQt4.QtCore
+
+        _patch_import_to_patch_pyqt_on_import(patch_qt_on_import, get_qt_core_module)
+
+    else:
+        raise ValueError("Unexpected qt support mode: %s" % (qt_support_mode,))
+
+
+def _patch_import_to_patch_pyqt_on_import(patch_qt_on_import, get_qt_core_module):
+    # I don't like this approach very much as we have to patch __import__, but I like even less
+    # asking the user to configure something in the client side...
+    # So, our approach is to patch PyQt4 right before the user tries to import it (at which
+    # point he should've set the sip api version properly already anyways).
+
+    pydev_log.debug("Setting up Qt post-import monkeypatch.")
+
+    dotted = patch_qt_on_import + "."
+    original_import = __import__
+
+    from _pydev_bundle._pydev_sys_patch import patch_sys_module, patch_reload, cancel_patches_in_sys_module
+
+    patch_sys_module()
+    patch_reload()
+
+    def patched_import(name, *args, **kwargs):
+        if patch_qt_on_import == name or name.startswith(dotted):
+            builtins.__import__ = original_import
+            cancel_patches_in_sys_module()
+            _internal_patch_qt(get_qt_core_module())  # Patch it only when the user would import the qt module
+        return original_import(name, *args, **kwargs)
+
+    import builtins  # Py3
+
+    builtins.__import__ = patched_import
+
+
+def _internal_patch_qt(QtCore, qt_support_mode="auto"):
+    pydev_log.debug("Patching Qt: %s", QtCore)
+
+    _original_thread_init = QtCore.QThread.__init__
+    _original_runnable_init = QtCore.QRunnable.__init__
+    _original_QThread = QtCore.QThread
+
+    class FuncWrapper:
+        def __init__(self, original):
+            self._original = original
+
+        def __call__(self, *args, **kwargs):
+            set_trace_in_qt()
+            return self._original(*args, **kwargs)
+
+    class StartedSignalWrapper(QtCore.QObject):  # Wrapper for the QThread.started signal
+        try:
+            _signal = QtCore.Signal()  # @UndefinedVariable
+        except:
+            _signal = QtCore.pyqtSignal()  # @UndefinedVariable
+
+        def __init__(self, thread, original_started):
+            QtCore.QObject.__init__(self)
+            self.thread = thread
+            self.original_started = original_started
+            if qt_support_mode in ("pyside", "pyside2"):
+                self._signal = original_started
+            else:
+                self._signal.connect(self._on_call)
+                self.original_started.connect(self._signal)
+
+        def connect(self, func, *args, **kwargs):
+            if qt_support_mode in ("pyside", "pyside2"):
+                return self._signal.connect(FuncWrapper(func), *args, **kwargs)
+            else:
+                return self._signal.connect(func, *args, **kwargs)
+
+        def disconnect(self, *args, **kwargs):
+            return self._signal.disconnect(*args, **kwargs)
+
+        def emit(self, *args, **kwargs):
+            return self._signal.emit(*args, **kwargs)
+
+        def _on_call(self, *args, **kwargs):
+            set_trace_in_qt()
+
+    class ThreadWrapper(QtCore.QThread):  # Wrapper for QThread
+        def __init__(self, *args, **kwargs):
+            _original_thread_init(self, *args, **kwargs)
+
+            # In PyQt5 the program hangs when we try to call original run method of QThread class.
+            # So we need to distinguish instances of QThread class and instances of QThread inheritors.
+            if self.__class__.run == _original_QThread.run:
+                self.run = self._exec_run
+            else:
+                self._original_run = self.run
+                self.run = self._new_run
+            self._original_started = self.started
+            self.started = StartedSignalWrapper(self, self.started)
+
+        def _exec_run(self):
+            set_trace_in_qt()
+            self.exec_()
+            return None
+
+        def _new_run(self):
+            set_trace_in_qt()
+            return self._original_run()
+
+    class RunnableWrapper(QtCore.QRunnable):  # Wrapper for QRunnable
+        def __init__(self, *args, **kwargs):
+            _original_runnable_init(self, *args, **kwargs)
+
+            self._original_run = self.run
+            self.run = self._new_run
+
+        def _new_run(self):
+            set_trace_in_qt()
+            return self._original_run()
+
+    QtCore.QThread = ThreadWrapper
+    QtCore.QRunnable = RunnableWrapper
@@ -0,0 +1,37 @@
+def overrides(method):
+    """
+    Meant to be used as
+
+    class B:
+        @overrides(A.m1)
+        def m1(self):
+            pass
+    """
+
+    def wrapper(func):
+        if func.__name__ != method.__name__:
+            msg = "Wrong @override: %r expected, but overwriting %r."
+            msg = msg % (func.__name__, method.__name__)
+            raise AssertionError(msg)
+
+        if func.__doc__ is None:
+            func.__doc__ = method.__doc__
+
+        return func
+
+    return wrapper
+
+
+def implements(method):
+    def wrapper(func):
+        if func.__name__ != method.__name__:
+            msg = "Wrong @implements: %r expected, but implementing %r."
+            msg = msg % (func.__name__, method.__name__)
+            raise AssertionError(msg)
+
+        if func.__doc__ is None:
+            func.__doc__ = method.__doc__
+
+        return func
+
+    return wrapper
@@ -0,0 +1,181 @@
+"""
+The UserModuleDeleter and runfile methods are copied from
+Spyder and carry their own license agreement.
+http://code.google.com/p/spyderlib/source/browse/spyderlib/widgets/externalshell/sitecustomize.py
+
+Spyder License Agreement (MIT License)
+--------------------------------------
+
+Copyright (c) 2009-2012 Pierre Raybaut
+
+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.
+"""
+
+import sys
+import os
+from _pydev_bundle._pydev_execfile import execfile
+
+
+# The following classes and functions are mainly intended to be used from
+# an interactive Python session
+class UserModuleDeleter:
+    """
+    User Module Deleter (UMD) aims at deleting user modules
+    to force Python to deeply reload them during import
+
+    pathlist [list]: ignore list in terms of module path
+    namelist [list]: ignore list in terms of module name
+    """
+
+    def __init__(self, namelist=None, pathlist=None):
+        if namelist is None:
+            namelist = []
+        self.namelist = namelist
+        if pathlist is None:
+            pathlist = []
+        self.pathlist = pathlist
+        try:
+            # ignore all files in org.python.pydev/pysrc
+            import pydev_pysrc, inspect
+
+            self.pathlist.append(os.path.dirname(pydev_pysrc.__file__))
+        except:
+            pass
+        self.previous_modules = list(sys.modules.keys())
+
+    def is_module_ignored(self, modname, modpath):
+        for path in [sys.prefix] + self.pathlist:
+            if modpath.startswith(path):
+                return True
+        else:
+            return set(modname.split(".")) & set(self.namelist)
+
+    def run(self, verbose=False):
+        """
+        Del user modules to force Python to deeply reload them
+
+        Do not del modules which are considered as system modules, i.e.
+        modules installed in subdirectories of Python interpreter's binary
+        Do not del C modules
+        """
+        log = []
+        modules_copy = dict(sys.modules)
+        for modname, module in modules_copy.items():
+            if modname == "aaaaa":
+                print(modname, module)
+                print(self.previous_modules)
+            if modname not in self.previous_modules:
+                modpath = getattr(module, "__file__", None)
+                if modpath is None:
+                    # *module* is a C module that is statically linked into the
+                    # interpreter. There is no way to know its path, so we
+                    # choose to ignore it.
+                    continue
+                if not self.is_module_ignored(modname, modpath):
+                    log.append(modname)
+                    del sys.modules[modname]
+        if verbose and log:
+            print("\x1b[4;33m%s\x1b[24m%s\x1b[0m" % ("UMD has deleted", ": " + ", ".join(log)))
+
+
+__umd__ = None
+
+_get_globals_callback = None
+
+
+def _set_globals_function(get_globals):
+    global _get_globals_callback
+    _get_globals_callback = get_globals
+
+
+def _get_globals():
+    """Return current Python interpreter globals namespace"""
+    if _get_globals_callback is not None:
+        return _get_globals_callback()
+    else:
+        try:
+            from __main__ import __dict__ as namespace
+        except ImportError:
+            try:
+                # The import fails on IronPython
+                import __main__
+
+                namespace = __main__.__dict__
+            except:
+                namespace
+        shell = namespace.get("__ipythonshell__")
+        if shell is not None and hasattr(shell, "user_ns"):
+            # IPython 0.12+ kernel
+            return shell.user_ns
+        else:
+            # Python interpreter
+            return namespace
+        return namespace
+
+
+def runfile(filename, args=None, wdir=None, namespace=None):
+    """
+    Run filename
+    args: command line arguments (string)
+    wdir: working directory
+    """
+    try:
+        if hasattr(filename, "decode"):
+            filename = filename.decode("utf-8")
+    except (UnicodeError, TypeError):
+        pass
+    global __umd__
+    if os.environ.get("PYDEV_UMD_ENABLED", "").lower() == "true":
+        if __umd__ is None:
+            namelist = os.environ.get("PYDEV_UMD_NAMELIST", None)
+            if namelist is not None:
+                namelist = namelist.split(",")
+            __umd__ = UserModuleDeleter(namelist=namelist)
+        else:
+            verbose = os.environ.get("PYDEV_UMD_VERBOSE", "").lower() == "true"
+            __umd__.run(verbose=verbose)
+    if args is not None and not isinstance(args, (bytes, str)):
+        raise TypeError("expected a character buffer object")
+    if namespace is None:
+        namespace = _get_globals()
+    if "__file__" in namespace:
+        old_file = namespace["__file__"]
+    else:
+        old_file = None
+    namespace["__file__"] = filename
+    sys.argv = [filename]
+    if args is not None:
+        for arg in args.split():
+            sys.argv.append(arg)
+    if wdir is not None:
+        try:
+            if hasattr(wdir, "decode"):
+                wdir = wdir.decode("utf-8")
+        except (UnicodeError, TypeError):
+            pass
+        os.chdir(wdir)
+    execfile(filename, namespace)
+    sys.argv = [""]
+    if old_file is None:
+        del namespace["__file__"]
+    else:
+        namespace["__file__"] = old_file
@@ -0,0 +1,16 @@
+import sys
+
+
+def versionok_for_gui():
+    """Return True if running Python is suitable for GUI Event Integration and deeper IPython integration"""
+    # We require Python 2.6+ ...
+    if sys.hexversion < 0x02060000:
+        return False
+    # Or Python 3.2+
+    if sys.hexversion >= 0x03000000 and sys.hexversion < 0x03020000:
+        return False
+    # Not supported under Jython nor IronPython
+    if sys.platform.startswith("java") or sys.platform.startswith("cli"):
+        return False
+
+    return True
@@ -0,0 +1,884 @@
+from __future__ import nested_scopes
+
+import fnmatch
+import os.path
+from _pydev_runfiles.pydev_runfiles_coverage import start_coverage_support
+from _pydevd_bundle.pydevd_constants import *  # @UnusedWildImport
+import re
+import time
+import json
+
+
+# =======================================================================================================================
+# Configuration
+# =======================================================================================================================
+class Configuration:
+    def __init__(
+        self,
+        files_or_dirs="",
+        verbosity=2,
+        include_tests=None,
+        tests=None,
+        port=None,
+        files_to_tests=None,
+        jobs=1,
+        split_jobs="tests",
+        coverage_output_dir=None,
+        coverage_include=None,
+        coverage_output_file=None,
+        exclude_files=None,
+        exclude_tests=None,
+        include_files=None,
+        django=False,
+    ):
+        self.files_or_dirs = files_or_dirs
+        self.verbosity = verbosity
+        self.include_tests = include_tests
+        self.tests = tests
+        self.port = port
+        self.files_to_tests = files_to_tests
+        self.jobs = jobs
+        self.split_jobs = split_jobs
+        self.django = django
+
+        if include_tests:
+            assert isinstance(include_tests, (list, tuple))
+
+        if exclude_files:
+            assert isinstance(exclude_files, (list, tuple))
+
+        if exclude_tests:
+            assert isinstance(exclude_tests, (list, tuple))
+
+        self.exclude_files = exclude_files
+        self.include_files = include_files
+        self.exclude_tests = exclude_tests
+
+        self.coverage_output_dir = coverage_output_dir
+        self.coverage_include = coverage_include
+        self.coverage_output_file = coverage_output_file
+
+    def __str__(self):
+        return """Configuration
+ - files_or_dirs: %s
+ - verbosity: %s
+ - tests: %s
+ - port: %s
+ - files_to_tests: %s
+ - jobs: %s
+ - split_jobs: %s
+
+ - include_files: %s
+ - include_tests: %s
+
+ - exclude_files: %s
+ - exclude_tests: %s
+
+ - coverage_output_dir: %s
+ - coverage_include_dir: %s
+ - coverage_output_file: %s
+
+ - django: %s
+""" % (
+            self.files_or_dirs,
+            self.verbosity,
+            self.tests,
+            self.port,
+            self.files_to_tests,
+            self.jobs,
+            self.split_jobs,
+            self.include_files,
+            self.include_tests,
+            self.exclude_files,
+            self.exclude_tests,
+            self.coverage_output_dir,
+            self.coverage_include,
+            self.coverage_output_file,
+            self.django,
+        )
+
+
+# =======================================================================================================================
+# parse_cmdline
+# =======================================================================================================================
+def parse_cmdline(argv=None):
+    """
+    Parses command line and returns test directories, verbosity, test filter and test suites
+
+    usage:
+        runfiles.py  -v|--verbosity <level>  -t|--tests <Test.test1,Test2>  dirs|files
+
+    Multiprocessing options:
+    jobs=number (with the number of jobs to be used to run the tests)
+    split_jobs='module'|'tests'
+        if == module, a given job will always receive all the tests from a module
+        if == tests, the tests will be split independently of their originating module (default)
+
+    --exclude_files  = comma-separated list of patterns with files to exclude (fnmatch style)
+    --include_files = comma-separated list of patterns with files to include (fnmatch style)
+    --exclude_tests = comma-separated list of patterns with test names to exclude (fnmatch style)
+
+    Note: if --tests is given, --exclude_files, --include_files and --exclude_tests are ignored!
+    """
+    if argv is None:
+        argv = sys.argv
+
+    verbosity = 2
+    include_tests = None
+    tests = None
+    port = None
+    jobs = 1
+    split_jobs = "tests"
+    files_to_tests = {}
+    coverage_output_dir = None
+    coverage_include = None
+    exclude_files = None
+    exclude_tests = None
+    include_files = None
+    django = False
+
+    from _pydev_bundle._pydev_getopt import gnu_getopt
+
+    optlist, dirs = gnu_getopt(
+        argv[1:],
+        "",
+        [
+            "verbosity=",
+            "tests=",
+            "port=",
+            "config_file=",
+            "jobs=",
+            "split_jobs=",
+            "include_tests=",
+            "include_files=",
+            "exclude_files=",
+            "exclude_tests=",
+            "coverage_output_dir=",
+            "coverage_include=",
+            "django=",
+        ],
+    )
+
+    for opt, value in optlist:
+        if opt in ("-v", "--verbosity"):
+            verbosity = value
+
+        elif opt in ("-p", "--port"):
+            port = int(value)
+
+        elif opt in ("-j", "--jobs"):
+            jobs = int(value)
+
+        elif opt in ("-s", "--split_jobs"):
+            split_jobs = value
+            if split_jobs not in ("module", "tests"):
+                raise AssertionError('Expected split to be either "module" or "tests". Was :%s' % (split_jobs,))
+
+        elif opt in (
+            "-d",
+            "--coverage_output_dir",
+        ):
+            coverage_output_dir = value.strip()
+
+        elif opt in (
+            "-i",
+            "--coverage_include",
+        ):
+            coverage_include = value.strip()
+
+        elif opt in ("-I", "--include_tests"):
+            include_tests = value.split(",")
+
+        elif opt in ("-E", "--exclude_files"):
+            exclude_files = value.split(",")
+
+        elif opt in ("-F", "--include_files"):
+            include_files = value.split(",")
+
+        elif opt in ("-e", "--exclude_tests"):
+            exclude_tests = value.split(",")
+
+        elif opt in ("-t", "--tests"):
+            tests = value.split(",")
+
+        elif opt in ("--django",):
+            django = value.strip() in ["true", "True", "1"]
+
+        elif opt in ("-c", "--config_file"):
+            config_file = value.strip()
+            if os.path.exists(config_file):
+                f = open(config_file, "r")
+                try:
+                    config_file_contents = f.read()
+                finally:
+                    f.close()
+
+                if config_file_contents:
+                    config_file_contents = config_file_contents.strip()
+
+                if config_file_contents:
+                    for line in config_file_contents.splitlines():
+                        file_and_test = line.split("|")
+                        if len(file_and_test) == 2:
+                            file, test = file_and_test
+                            if file in files_to_tests:
+                                files_to_tests[file].append(test)
+                            else:
+                                files_to_tests[file] = [test]
+
+            else:
+                sys.stderr.write("Could not find config file: %s\n" % (config_file,))
+
+    filter_tests_env_var = os.environ.get("PYDEV_RUNFILES_FILTER_TESTS", None)
+    if filter_tests_env_var:
+        loaded = json.loads(filter_tests_env_var)
+        include = loaded["include"]
+        for path, name in include:
+            existing = files_to_tests.get(path)
+            if not existing:
+                existing = files_to_tests[path] = []
+            existing.append(name)
+        # Note: at this point exclude or `*` is not handled.
+        # Clients need to do all the filtering on their side (could
+        # change to have `exclude` and support `*` entries).
+
+    if type([]) != type(dirs):
+        dirs = [dirs]
+
+    ret_dirs = []
+    for d in dirs:
+        if "|" in d:
+            # paths may come from the ide separated by |
+            ret_dirs.extend(d.split("|"))
+        else:
+            ret_dirs.append(d)
+
+    verbosity = int(verbosity)
+
+    if tests:
+        if verbosity > 4:
+            sys.stdout.write("--tests provided. Ignoring --exclude_files, --exclude_tests and --include_files\n")
+        exclude_files = exclude_tests = include_files = None
+
+    config = Configuration(
+        ret_dirs,
+        verbosity,
+        include_tests,
+        tests,
+        port,
+        files_to_tests,
+        jobs,
+        split_jobs,
+        coverage_output_dir,
+        coverage_include,
+        exclude_files=exclude_files,
+        exclude_tests=exclude_tests,
+        include_files=include_files,
+        django=django,
+    )
+
+    if verbosity > 5:
+        sys.stdout.write(str(config) + "\n")
+    return config
+
+
+# =======================================================================================================================
+# PydevTestRunner
+# =======================================================================================================================
+class PydevTestRunner(object):
+    """finds and runs a file or directory of files as a unit test"""
+
+    __py_extensions = ["*.py", "*.pyw"]
+    __exclude_files = ["__init__.*"]
+
+    # Just to check that only this attributes will be written to this file
+    __slots__ = [
+        "verbosity",  # Always used
+        "files_to_tests",  # If this one is given, the ones below are not used
+        "files_or_dirs",  # Files or directories received in the command line
+        "include_tests",  # The filter used to collect the tests
+        "tests",  # Strings with the tests to be run
+        "jobs",  # Integer with the number of jobs that should be used to run the test cases
+        "split_jobs",  # String with 'tests' or 'module' (how should the jobs be split)
+        "configuration",
+        "coverage",
+    ]
+
+    def __init__(self, configuration):
+        self.verbosity = configuration.verbosity
+
+        self.jobs = configuration.jobs
+        self.split_jobs = configuration.split_jobs
+
+        files_to_tests = configuration.files_to_tests
+        if files_to_tests:
+            self.files_to_tests = files_to_tests
+            self.files_or_dirs = list(files_to_tests.keys())
+            self.tests = None
+        else:
+            self.files_to_tests = {}
+            self.files_or_dirs = configuration.files_or_dirs
+            self.tests = configuration.tests
+
+        self.configuration = configuration
+        self.__adjust_path()
+
+    def __adjust_path(self):
+        """add the current file or directory to the python path"""
+        path_to_append = None
+        for n in range(len(self.files_or_dirs)):
+            dir_name = self.__unixify(self.files_or_dirs[n])
+            if os.path.isdir(dir_name):
+                if not dir_name.endswith("/"):
+                    self.files_or_dirs[n] = dir_name + "/"
+                path_to_append = os.path.normpath(dir_name)
+            elif os.path.isfile(dir_name):
+                path_to_append = os.path.dirname(dir_name)
+            else:
+                if not os.path.exists(dir_name):
+                    block_line = "*" * 120
+                    sys.stderr.write("\n%s\n* PyDev test runner error: %s does not exist.\n%s\n" % (block_line, dir_name, block_line))
+                    return
+                msg = "unknown type. \n%s\nshould be file or a directory.\n" % (dir_name)
+                raise RuntimeError(msg)
+        if path_to_append is not None:
+            # Add it as the last one (so, first things are resolved against the default dirs and
+            # if none resolves, then we try a relative import).
+            sys.path.append(path_to_append)
+
+    def __is_valid_py_file(self, fname):
+        """tests that a particular file contains the proper file extension
+        and is not in the list of files to exclude"""
+        is_valid_fname = 0
+        for invalid_fname in self.__class__.__exclude_files:
+            is_valid_fname += int(not fnmatch.fnmatch(fname, invalid_fname))
+        if_valid_ext = 0
+        for ext in self.__class__.__py_extensions:
+            if_valid_ext += int(fnmatch.fnmatch(fname, ext))
+        return is_valid_fname > 0 and if_valid_ext > 0
+
+    def __unixify(self, s):
+        """stupid windows. converts the backslash to forwardslash for consistency"""
+        return os.path.normpath(s).replace(os.sep, "/")
+
+    def __importify(self, s, dir=False):
+        """turns directory separators into dots and removes the ".py*" extension
+        so the string can be used as import statement"""
+        if not dir:
+            dirname, fname = os.path.split(s)
+
+            if fname.count(".") > 1:
+                # if there's a file named xxx.xx.py, it is not a valid module, so, let's not load it...
+                return
+
+            imp_stmt_pieces = [dirname.replace("\\", "/").replace("/", "."), os.path.splitext(fname)[0]]
+
+            if len(imp_stmt_pieces[0]) == 0:
+                imp_stmt_pieces = imp_stmt_pieces[1:]
+
+            return ".".join(imp_stmt_pieces)
+
+        else:  # handle dir
+            return s.replace("\\", "/").replace("/", ".")
+
+    def __add_files(self, pyfiles, root, files):
+        """if files match, appends them to pyfiles. used by os.path.walk fcn"""
+        for fname in files:
+            if self.__is_valid_py_file(fname):
+                name_without_base_dir = self.__unixify(os.path.join(root, fname))
+                pyfiles.append(name_without_base_dir)
+
+    def find_import_files(self):
+        """return a list of files to import"""
+        if self.files_to_tests:
+            pyfiles = self.files_to_tests.keys()
+        else:
+            pyfiles = []
+
+            for base_dir in self.files_or_dirs:
+                if os.path.isdir(base_dir):
+                    for root, dirs, files in os.walk(base_dir):
+                        # Note: handling directories that should be excluded from the search because
+                        # they don't have __init__.py
+                        exclude = {}
+                        for d in dirs:
+                            for init in ["__init__.py", "__init__.pyo", "__init__.pyc", "__init__.pyw", "__init__$py.class"]:
+                                if os.path.exists(os.path.join(root, d, init).replace("\\", "/")):
+                                    break
+                            else:
+                                exclude[d] = 1
+
+                        if exclude:
+                            new = []
+                            for d in dirs:
+                                if d not in exclude:
+                                    new.append(d)
+
+                            dirs[:] = new
+
+                        self.__add_files(pyfiles, root, files)
+
+                elif os.path.isfile(base_dir):
+                    pyfiles.append(base_dir)
+
+        if self.configuration.exclude_files or self.configuration.include_files:
+            ret = []
+            for f in pyfiles:
+                add = True
+                basename = os.path.basename(f)
+                if self.configuration.include_files:
+                    add = False
+
+                    for pat in self.configuration.include_files:
+                        if fnmatch.fnmatchcase(basename, pat):
+                            add = True
+                            break
+
+                if not add:
+                    if self.verbosity > 3:
+                        sys.stdout.write(
+                            "Skipped file: %s (did not match any include_files pattern: %s)\n" % (f, self.configuration.include_files)
+                        )
+
+                elif self.configuration.exclude_files:
+                    for pat in self.configuration.exclude_files:
+                        if fnmatch.fnmatchcase(basename, pat):
+                            if self.verbosity > 3:
+                                sys.stdout.write("Skipped file: %s (matched exclude_files pattern: %s)\n" % (f, pat))
+
+                            elif self.verbosity > 2:
+                                sys.stdout.write("Skipped file: %s\n" % (f,))
+
+                            add = False
+                            break
+
+                if add:
+                    if self.verbosity > 3:
+                        sys.stdout.write("Adding file: %s for test discovery.\n" % (f,))
+                    ret.append(f)
+
+            pyfiles = ret
+
+        return pyfiles
+
+    def __get_module_from_str(self, modname, print_exception, pyfile):
+        """Import the module in the given import path.
+        * Returns the "final" module, so importing "coilib40.subject.visu"
+        returns the "visu" module, not the "coilib40" as returned by __import__"""
+        try:
+            mod = __import__(modname)
+            for part in modname.split(".")[1:]:
+                mod = getattr(mod, part)
+            return mod
+        except:
+            if print_exception:
+                from _pydev_runfiles import pydev_runfiles_xml_rpc
+                from _pydevd_bundle import pydevd_io
+
+                buf_err = pydevd_io.start_redirect(keep_original_redirection=True, std="stderr")
+                buf_out = pydevd_io.start_redirect(keep_original_redirection=True, std="stdout")
+                try:
+                    import traceback
+
+                    traceback.print_exc()
+                    sys.stderr.write("ERROR: Module: %s could not be imported (file: %s).\n" % (modname, pyfile))
+                finally:
+                    pydevd_io.end_redirect("stderr")
+                    pydevd_io.end_redirect("stdout")
+
+                pydev_runfiles_xml_rpc.notifyTest("error", buf_out.getvalue(), buf_err.getvalue(), pyfile, modname, 0)
+
+            return None
+
+    def remove_duplicates_keeping_order(self, seq):
+        seen = set()
+        seen_add = seen.add
+        return [x for x in seq if not (x in seen or seen_add(x))]
+
+    def find_modules_from_files(self, pyfiles):
+        """returns a list of modules given a list of files"""
+        # let's make sure that the paths we want are in the pythonpath...
+        imports = [(s, self.__importify(s)) for s in pyfiles]
+
+        sys_path = [os.path.normpath(path) for path in sys.path]
+        sys_path = self.remove_duplicates_keeping_order(sys_path)
+
+        system_paths = []
+        for s in sys_path:
+            system_paths.append(self.__importify(s, True))
+
+        ret = []
+        for pyfile, imp in imports:
+            if imp is None:
+                continue  # can happen if a file is not a valid module
+            choices = []
+            for s in system_paths:
+                if imp.startswith(s):
+                    add = imp[len(s) + 1 :]
+                    if add:
+                        choices.append(add)
+                    # sys.stdout.write(' ' + add + ' ')
+
+            if not choices:
+                sys.stdout.write("PYTHONPATH not found for file: %s\n" % imp)
+            else:
+                for i, import_str in enumerate(choices):
+                    print_exception = i == len(choices) - 1
+                    mod = self.__get_module_from_str(import_str, print_exception, pyfile)
+                    if mod is not None:
+                        ret.append((pyfile, mod, import_str))
+                        break
+
+        return ret
+
+    # ===================================================================================================================
+    # GetTestCaseNames
+    # ===================================================================================================================
+    class GetTestCaseNames:
+        """Yes, we need a class for that (cannot use outer context on jython 2.1)"""
+
+        def __init__(self, accepted_classes, accepted_methods):
+            self.accepted_classes = accepted_classes
+            self.accepted_methods = accepted_methods
+
+        def __call__(self, testCaseClass):
+            """Return a sorted sequence of method names found within testCaseClass"""
+            testFnNames = []
+            className = testCaseClass.__name__
+
+            if className in self.accepted_classes:
+                for attrname in dir(testCaseClass):
+                    # If a class is chosen, we select all the 'test' methods'
+                    if attrname.startswith("test") and hasattr(getattr(testCaseClass, attrname), "__call__"):
+                        testFnNames.append(attrname)
+
+            else:
+                for attrname in dir(testCaseClass):
+                    # If we have the class+method name, we must do a full check and have an exact match.
+                    if className + "." + attrname in self.accepted_methods:
+                        if hasattr(getattr(testCaseClass, attrname), "__call__"):
+                            testFnNames.append(attrname)
+
+            # sorted() is not available in jython 2.1
+            testFnNames.sort()
+            return testFnNames
+
+    def _decorate_test_suite(self, suite, pyfile, module_name):
+        import unittest
+
+        if isinstance(suite, unittest.TestSuite):
+            add = False
+            suite.__pydev_pyfile__ = pyfile
+            suite.__pydev_module_name__ = module_name
+
+            for t in suite._tests:
+                t.__pydev_pyfile__ = pyfile
+                t.__pydev_module_name__ = module_name
+                if self._decorate_test_suite(t, pyfile, module_name):
+                    add = True
+
+            return add
+
+        elif isinstance(suite, unittest.TestCase):
+            return True
+
+        else:
+            return False
+
+    def find_tests_from_modules(self, file_and_modules_and_module_name):
+        """returns the unittests given a list of modules"""
+        # Use our own suite!
+        from _pydev_runfiles import pydev_runfiles_unittest
+        import unittest
+
+        unittest.TestLoader.suiteClass = pydev_runfiles_unittest.PydevTestSuite
+        loader = unittest.TestLoader()
+
+        ret = []
+        if self.files_to_tests:
+            for pyfile, m, module_name in file_and_modules_and_module_name:
+                accepted_classes = {}
+                accepted_methods = {}
+                tests = self.files_to_tests[pyfile]
+                for t in tests:
+                    accepted_methods[t] = t
+
+                loader.getTestCaseNames = self.GetTestCaseNames(accepted_classes, accepted_methods)
+
+                suite = loader.loadTestsFromModule(m)
+                if self._decorate_test_suite(suite, pyfile, module_name):
+                    ret.append(suite)
+            return ret
+
+        if self.tests:
+            accepted_classes = {}
+            accepted_methods = {}
+
+            for t in self.tests:
+                splitted = t.split(".")
+                if len(splitted) == 1:
+                    accepted_classes[t] = t
+
+                elif len(splitted) == 2:
+                    accepted_methods[t] = t
+
+            loader.getTestCaseNames = self.GetTestCaseNames(accepted_classes, accepted_methods)
+
+        for pyfile, m, module_name in file_and_modules_and_module_name:
+            suite = loader.loadTestsFromModule(m)
+            if self._decorate_test_suite(suite, pyfile, module_name):
+                ret.append(suite)
+
+        return ret
+
+    def filter_tests(self, test_objs, internal_call=False):
+        """based on a filter name, only return those tests that have
+        the test case names that match"""
+        import unittest
+
+        if not internal_call:
+            if not self.configuration.include_tests and not self.tests and not self.configuration.exclude_tests:
+                # No need to filter if we have nothing to filter!
+                return test_objs
+
+            if self.verbosity > 1:
+                if self.configuration.include_tests:
+                    sys.stdout.write("Tests to include: %s\n" % (self.configuration.include_tests,))
+
+                if self.tests:
+                    sys.stdout.write("Tests to run: %s\n" % (self.tests,))
+
+                if self.configuration.exclude_tests:
+                    sys.stdout.write("Tests to exclude: %s\n" % (self.configuration.exclude_tests,))
+
+        test_suite = []
+        for test_obj in test_objs:
+            if isinstance(test_obj, unittest.TestSuite):
+                # Note: keep the suites as they are and just 'fix' the tests (so, don't use the iter_tests).
+                if test_obj._tests:
+                    test_obj._tests = self.filter_tests(test_obj._tests, True)
+                    if test_obj._tests:  # Only add the suite if we still have tests there.
+                        test_suite.append(test_obj)
+
+            elif isinstance(test_obj, unittest.TestCase):
+                try:
+                    testMethodName = test_obj._TestCase__testMethodName
+                except AttributeError:
+                    # changed in python 2.5
+                    testMethodName = test_obj._testMethodName
+
+                add = True
+                if self.configuration.exclude_tests:
+                    for pat in self.configuration.exclude_tests:
+                        if fnmatch.fnmatchcase(testMethodName, pat):
+                            if self.verbosity > 3:
+                                sys.stdout.write("Skipped test: %s (matched exclude_tests pattern: %s)\n" % (testMethodName, pat))
+
+                            elif self.verbosity > 2:
+                                sys.stdout.write("Skipped test: %s\n" % (testMethodName,))
+
+                            add = False
+                            break
+
+                if add:
+                    if self.__match_tests(self.tests, test_obj, testMethodName):
+                        include = True
+                        if self.configuration.include_tests:
+                            include = False
+                            for pat in self.configuration.include_tests:
+                                if fnmatch.fnmatchcase(testMethodName, pat):
+                                    include = True
+                                    break
+                        if include:
+                            test_suite.append(test_obj)
+                        else:
+                            if self.verbosity > 3:
+                                sys.stdout.write(
+                                    "Skipped test: %s (did not match any include_tests pattern %s)\n"
+                                    % (
+                                        testMethodName,
+                                        self.configuration.include_tests,
+                                    )
+                                )
+        return test_suite
+
+    def iter_tests(self, test_objs):
+        # Note: not using yield because of Jython 2.1.
+        import unittest
+
+        tests = []
+        for test_obj in test_objs:
+            if isinstance(test_obj, unittest.TestSuite):
+                tests.extend(self.iter_tests(test_obj._tests))
+
+            elif isinstance(test_obj, unittest.TestCase):
+                tests.append(test_obj)
+        return tests
+
+    def list_test_names(self, test_objs):
+        names = []
+        for tc in self.iter_tests(test_objs):
+            try:
+                testMethodName = tc._TestCase__testMethodName
+            except AttributeError:
+                # changed in python 2.5
+                testMethodName = tc._testMethodName
+            names.append(testMethodName)
+        return names
+
+    def __match_tests(self, tests, test_case, test_method_name):
+        if not tests:
+            return 1
+
+        for t in tests:
+            class_and_method = t.split(".")
+            if len(class_and_method) == 1:
+                # only class name
+                if class_and_method[0] == test_case.__class__.__name__:
+                    return 1
+
+            elif len(class_and_method) == 2:
+                if class_and_method[0] == test_case.__class__.__name__ and class_and_method[1] == test_method_name:
+                    return 1
+
+        return 0
+
+    def __match(self, filter_list, name):
+        """returns whether a test name matches the test filter"""
+        if filter_list is None:
+            return 1
+        for f in filter_list:
+            if re.match(f, name):
+                return 1
+        return 0
+
+    def run_tests(self, handle_coverage=True):
+        """runs all tests"""
+        sys.stdout.write("Finding files... ")
+        files = self.find_import_files()
+        if self.verbosity > 3:
+            sys.stdout.write("%s ... done.\n" % (self.files_or_dirs))
+        else:
+            sys.stdout.write("done.\n")
+        sys.stdout.write("Importing test modules ... ")
+
+        if self.configuration.django:
+            import django
+
+            if hasattr(django, "setup"):
+                django.setup()
+
+        if handle_coverage:
+            coverage_files, coverage = start_coverage_support(self.configuration)
+
+        file_and_modules_and_module_name = self.find_modules_from_files(files)
+        sys.stdout.write("done.\n")
+
+        all_tests = self.find_tests_from_modules(file_and_modules_and_module_name)
+        all_tests = self.filter_tests(all_tests)
+
+        from _pydev_runfiles import pydev_runfiles_unittest
+
+        test_suite = pydev_runfiles_unittest.PydevTestSuite(all_tests)
+        from _pydev_runfiles import pydev_runfiles_xml_rpc
+
+        pydev_runfiles_xml_rpc.notifyTestsCollected(test_suite.countTestCases())
+
+        start_time = time.time()
+
+        def run_tests():
+            executed_in_parallel = False
+            if self.jobs > 1:
+                from _pydev_runfiles import pydev_runfiles_parallel
+
+                # What may happen is that the number of jobs needed is lower than the number of jobs requested
+                # (e.g.: 2 jobs were requested for running 1 test) -- in which case execute_tests_in_parallel will
+                # return False and won't run any tests.
+                executed_in_parallel = pydev_runfiles_parallel.execute_tests_in_parallel(
+                    all_tests, self.jobs, self.split_jobs, self.verbosity, coverage_files, self.configuration.coverage_include
+                )
+
+            if not executed_in_parallel:
+                # If in coverage, we don't need to pass anything here (coverage is already enabled for this execution).
+                runner = pydev_runfiles_unittest.PydevTextTestRunner(stream=sys.stdout, descriptions=1, verbosity=self.verbosity)
+                sys.stdout.write("\n")
+                runner.run(test_suite)
+
+        if self.configuration.django:
+            get_django_test_suite_runner()(run_tests).run_tests([])
+        else:
+            run_tests()
+
+        if handle_coverage:
+            coverage.stop()
+            coverage.save()
+
+        total_time = "Finished in: %.2f secs." % (time.time() - start_time,)
+        pydev_runfiles_xml_rpc.notifyTestRunFinished(total_time)
+
+
+DJANGO_TEST_SUITE_RUNNER = None
+
+
+def get_django_test_suite_runner():
+    global DJANGO_TEST_SUITE_RUNNER
+    if DJANGO_TEST_SUITE_RUNNER:
+        return DJANGO_TEST_SUITE_RUNNER
+    try:
+        # django >= 1.8
+        import django
+        from django.test.runner import DiscoverRunner
+
+        class MyDjangoTestSuiteRunner(DiscoverRunner):
+            def __init__(self, on_run_suite):
+                django.setup()
+                DiscoverRunner.__init__(self)
+                self.on_run_suite = on_run_suite
+
+            def build_suite(self, *args, **kwargs):
+                pass
+
+            def suite_result(self, *args, **kwargs):
+                pass
+
+            def run_suite(self, *args, **kwargs):
+                self.on_run_suite()
+
+    except:
+        # django < 1.8
+        try:
+            from django.test.simple import DjangoTestSuiteRunner
+        except:
+
+            class DjangoTestSuiteRunner:
+                def __init__(self):
+                    pass
+
+                def run_tests(self, *args, **kwargs):
+                    raise AssertionError(
+                        "Unable to run suite with django.test.runner.DiscoverRunner nor django.test.simple.DjangoTestSuiteRunner because it couldn't be imported."
+                    )
+
+        class MyDjangoTestSuiteRunner(DjangoTestSuiteRunner):
+            def __init__(self, on_run_suite):
+                DjangoTestSuiteRunner.__init__(self)
+                self.on_run_suite = on_run_suite
+
+            def build_suite(self, *args, **kwargs):
+                pass
+
+            def suite_result(self, *args, **kwargs):
+                pass
+
+            def run_suite(self, *args, **kwargs):
+                self.on_run_suite()
+
+    DJANGO_TEST_SUITE_RUNNER = MyDjangoTestSuiteRunner
+    return DJANGO_TEST_SUITE_RUNNER
+
+
+# =======================================================================================================================
+# main
+# =======================================================================================================================
+def main(configuration):
+    PydevTestRunner(configuration).run_tests()
@@ -0,0 +1,77 @@
+import os.path
+import sys
+from _pydevd_bundle.pydevd_constants import Null
+
+
+# =======================================================================================================================
+# get_coverage_files
+# =======================================================================================================================
+def get_coverage_files(coverage_output_dir, number_of_files):
+    base_dir = coverage_output_dir
+    ret = []
+    i = 0
+    while len(ret) < number_of_files:
+        while True:
+            f = os.path.join(base_dir, ".coverage.%s" % i)
+            i += 1
+            if not os.path.exists(f):
+                ret.append(f)
+                break  # Break only inner for.
+    return ret
+
+
+# =======================================================================================================================
+# start_coverage_support
+# =======================================================================================================================
+def start_coverage_support(configuration):
+    return start_coverage_support_from_params(
+        configuration.coverage_output_dir,
+        configuration.coverage_output_file,
+        configuration.jobs,
+        configuration.coverage_include,
+    )
+
+
+# =======================================================================================================================
+# start_coverage_support_from_params
+# =======================================================================================================================
+def start_coverage_support_from_params(coverage_output_dir, coverage_output_file, jobs, coverage_include):
+    coverage_files = []
+    coverage_instance = Null()
+    if coverage_output_dir or coverage_output_file:
+        try:
+            import coverage  # @UnresolvedImport
+        except:
+            sys.stderr.write("Error: coverage module could not be imported\n")
+            sys.stderr.write("Please make sure that the coverage module (http://nedbatchelder.com/code/coverage/)\n")
+            sys.stderr.write("is properly installed in your interpreter: %s\n" % (sys.executable,))
+
+            import traceback
+
+            traceback.print_exc()
+        else:
+            if coverage_output_dir:
+                if not os.path.exists(coverage_output_dir):
+                    sys.stderr.write("Error: directory for coverage output (%s) does not exist.\n" % (coverage_output_dir,))
+
+                elif not os.path.isdir(coverage_output_dir):
+                    sys.stderr.write("Error: expected (%s) to be a directory.\n" % (coverage_output_dir,))
+
+                else:
+                    n = jobs
+                    if n <= 0:
+                        n += 1
+                    n += 1  # Add 1 more for the current process (which will do the initial import).
+                    coverage_files = get_coverage_files(coverage_output_dir, n)
+                    os.environ["COVERAGE_FILE"] = coverage_files.pop(0)
+
+                    coverage_instance = coverage.coverage(source=[coverage_include])
+                    coverage_instance.start()
+
+            elif coverage_output_file:
+                # Client of parallel run.
+                os.environ["COVERAGE_FILE"] = coverage_output_file
+                coverage_instance = coverage.coverage(source=[coverage_include])
+                coverage_instance.start()
+
+    return coverage_files, coverage_instance
--- a/Show More
+++ b/Show More
				`@@ -0,0 +1 @@`
				`# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file.`