Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/dill/tests/__init__.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2018-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+to run this test suite, first build and install `dill`.
+
+  $ python -m pip install ../..
+
+
+then run the tests with:
+
+  $ python -m dill.tests
+
+
+or, if `nose` is installed:
+
+  $ nosetests  
+
+"""

.venv/lib/python3.11/site-packages/dill/tests/test_abc.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2023-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+test dill's ability to pickle abstract base class objects
+"""
+import dill
+import abc
+from abc import ABC
+import warnings
+
+from types import FunctionType
+
+dill.settings['recurse'] = True
+
+class OneTwoThree(ABC):
+    @abc.abstractmethod
+    def foo(self):
+        """A method"""
+        pass
+
+    @property
+    @abc.abstractmethod
+    def bar(self):
+        """Property getter"""
+        pass
+
+    @bar.setter
+    @abc.abstractmethod
+    def bar(self, value):
+        """Property setter"""
+        pass
+
+    @classmethod
+    @abc.abstractmethod
+    def cfoo(cls):
+        """Class method"""
+        pass
+
+    @staticmethod
+    @abc.abstractmethod
+    def sfoo():
+        """Static method"""
+        pass
+
+class EasyAsAbc(OneTwoThree):
+    def __init__(self):
+        self._bar = None
+
+    def foo(self):
+        return "Instance Method FOO"
+
+    @property
+    def bar(self):
+        return self._bar
+
+    @bar.setter
+    def bar(self, value):
+        self._bar = value
+
+    @classmethod
+    def cfoo(cls):
+        return "Class Method CFOO"
+
+    @staticmethod
+    def sfoo():
+        return "Static Method SFOO"
+
+def test_abc_non_local():
+    assert dill.copy(OneTwoThree) is not OneTwoThree
+    assert dill.copy(EasyAsAbc) is not EasyAsAbc
+
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", dill.PicklingWarning)
+        assert dill.copy(OneTwoThree, byref=True) is OneTwoThree
+        assert dill.copy(EasyAsAbc, byref=True) is EasyAsAbc
+
+    instance = EasyAsAbc()
+    # Set a property that StockPickle can't preserve
+    instance.bar = lambda x: x**2
+    depickled = dill.copy(instance)
+    assert type(depickled) is type(instance) #NOTE: issue #612, test_abc_local
+    #NOTE: dill.copy of local (or non-local) classes should (not) be the same?
+    assert type(depickled.bar) is FunctionType
+    assert depickled.bar(3) == 9
+    assert depickled.sfoo() == "Static Method SFOO"
+    assert depickled.cfoo() == "Class Method CFOO"
+    assert depickled.foo() == "Instance Method FOO"
+
+def test_abc_local():
+    """
+    Test using locally scoped ABC class
+    """
+    class LocalABC(ABC):
+        @abc.abstractmethod
+        def foo(self):
+            pass
+
+        def baz(self):
+            return repr(self)
+
+    labc = dill.copy(LocalABC)
+    assert labc is not LocalABC
+    assert type(labc) is type(LocalABC)
+    #NOTE: dill.copy of local (or non-local) classes should (not) be the same?
+    # <class '__main__.LocalABC'>
+    # <class '__main__.test_abc_local.<locals>.LocalABC'>
+
+    class Real(labc):
+        def foo(self):
+            return "True!"
+
+        def baz(self):
+            return "My " + super(Real, self).baz()
+
+    real = Real()
+    assert real.foo() == "True!"
+
+    try:
+        labc()
+    except TypeError as e:
+        # Expected error
+        pass
+    else:
+        print('Failed to raise type error')
+        assert False
+
+    labc2, pik = dill.copy((labc, Real()))
+    assert 'Real' == type(pik).__name__
+    assert '.Real' in type(pik).__qualname__
+    assert type(pik) is not Real
+    assert labc2 is not LocalABC
+    assert labc2 is not labc
+    assert isinstance(pik, labc2)
+    assert not isinstance(pik, labc)
+    assert not isinstance(pik, LocalABC)
+    assert pik.baz() == "My " + repr(pik)
+
+def test_meta_local_no_cache():
+    """
+    Test calling metaclass and cache registration
+    """
+    LocalMetaABC = abc.ABCMeta('LocalMetaABC', (), {})
+
+    class ClassyClass:
+        pass
+
+    class KlassyClass:
+      pass
+
+    LocalMetaABC.register(ClassyClass)
+
+    assert not issubclass(KlassyClass, LocalMetaABC)
+    assert issubclass(ClassyClass, LocalMetaABC)
+
+    res = dill.dumps((LocalMetaABC, ClassyClass, KlassyClass))
+
+    lmabc, cc, kc = dill.loads(res)
+    assert type(lmabc) == type(LocalMetaABC)
+    assert not issubclass(kc, lmabc)
+    assert issubclass(cc, lmabc)
+
+if __name__ == '__main__':
+    test_abc_non_local()
+    test_abc_local()
+    test_meta_local_no_cache()

.venv/lib/python3.11/site-packages/dill/tests/test_dataclasses.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Author: Anirudh Vegesana (avegesan@cs.stanford.edu)
+# Copyright (c) 2022-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+test pickling a dataclass
+"""
+
+import dill
+import dataclasses
+
+def test_dataclasses():
+    # Issue #500
+    @dataclasses.dataclass
+    class A:
+        x: int
+        y: str
+
+    @dataclasses.dataclass
+    class B:
+        a: A
+
+    a = A(1, "test")
+    before = B(a)
+    save = dill.dumps(before)
+    after = dill.loads(save)
+    assert before != after # classes don't match
+    assert before == B(A(**dataclasses.asdict(after.a)))
+    assert dataclasses.asdict(before) == dataclasses.asdict(after)
+
+if __name__ == '__main__':
+    test_dataclasses()

.venv/lib/python3.11/site-packages/dill/tests/test_dictviews.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Author: Anirudh Vegesana (avegesan@cs.stanford.edu)
+# Copyright (c) 2021-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+from dill._dill import OLD310, MAPPING_PROXY_TRICK, DictProxyType
+
+def test_dictproxy():
+    assert dill.copy(DictProxyType({'a': 2}))
+
+def test_dictviews():
+    x = {'a': 1}
+    assert dill.copy(x.keys())
+    assert dill.copy(x.values())
+    assert dill.copy(x.items())
+
+def test_dictproxy_trick():
+    if not OLD310 and MAPPING_PROXY_TRICK:
+        x = {'a': 1}
+        all_views = (x.values(), x.items(), x.keys(), x)
+        seperate_views = dill.copy(all_views)
+        new_x = seperate_views[-1]
+        new_x['b'] = 2
+        new_x['c'] = 1
+        assert len(new_x) == 3 and len(x) == 1
+        assert len(seperate_views[0]) == 3 and len(all_views[0]) == 1
+        assert len(seperate_views[1]) == 3 and len(all_views[1]) == 1
+        assert len(seperate_views[2]) == 3 and len(all_views[2]) == 1
+        assert dict(all_views[1]) == x
+        assert dict(seperate_views[1]) == new_x
+
+if __name__ == '__main__':
+    test_dictproxy()
+    test_dictviews()
+    test_dictproxy_trick()

.venv/lib/python3.11/site-packages/dill/tests/test_functions.py

@@ -0,0 +1,141 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2019-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import functools
+import dill
+import sys
+dill.settings['recurse'] = True
+
+
+def function_a(a):
+    return a
+
+
+def function_b(b, b1):
+    return b + b1
+
+
+def function_c(c, c1=1):
+    return c + c1
+
+
+def function_d(d, d1, d2=1):
+    """doc string"""
+    return d + d1 + d2
+
+function_d.__module__ = 'a module'
+
+
+exec('''
+def function_e(e, *e1, e2=1, e3=2):
+    return e + sum(e1) + e2 + e3''')
+
+globalvar = 0
+
+@functools.lru_cache(None)
+def function_with_cache(x):
+    global globalvar
+    globalvar += x
+    return globalvar
+
+
+def function_with_unassigned_variable():
+    if False:
+        value = None
+    return (lambda: value)
+
+
+def test_issue_510():
+    # A very bizzare use of functions and methods that pickle doesn't get
+    # correctly for odd reasons.
+    class Foo:
+        def __init__(self):
+                def f2(self):
+                        return self
+                self.f2 = f2.__get__(self)
+
+    import dill, pickletools
+    f = Foo()
+    f1 = dill.copy(f)
+    assert f1.f2() is f1
+
+
+def test_functions():
+    dumped_func_a = dill.dumps(function_a)
+    assert dill.loads(dumped_func_a)(0) == 0
+
+    dumped_func_b = dill.dumps(function_b)
+    assert dill.loads(dumped_func_b)(1,2) == 3
+
+    dumped_func_c = dill.dumps(function_c)
+    assert dill.loads(dumped_func_c)(1) == 2
+    assert dill.loads(dumped_func_c)(1, 2) == 3
+
+    dumped_func_d = dill.dumps(function_d)
+    assert dill.loads(dumped_func_d).__doc__ == function_d.__doc__
+    assert dill.loads(dumped_func_d).__module__ == function_d.__module__
+    assert dill.loads(dumped_func_d)(1, 2) == 4
+    assert dill.loads(dumped_func_d)(1, 2, 3) == 6
+    assert dill.loads(dumped_func_d)(1, 2, d2=3) == 6
+
+    function_with_cache(1)
+    globalvar = 0
+    dumped_func_cache = dill.dumps(function_with_cache)
+    assert function_with_cache(2) == 3
+    assert function_with_cache(1) == 1
+    assert function_with_cache(3) == 6
+    assert function_with_cache(2) == 3
+
+    empty_cell = function_with_unassigned_variable()
+    cell_copy = dill.loads(dill.dumps(empty_cell))
+    assert 'empty' in str(cell_copy.__closure__[0])
+    try:
+        cell_copy()
+    except Exception:
+        # this is good
+        pass
+    else:
+        raise AssertionError('cell_copy() did not read an empty cell')
+
+    exec('''
+dumped_func_e = dill.dumps(function_e)
+assert dill.loads(dumped_func_e)(1, 2) == 6
+assert dill.loads(dumped_func_e)(1, 2, 3) == 9
+assert dill.loads(dumped_func_e)(1, 2, e2=3) == 8
+assert dill.loads(dumped_func_e)(1, 2, e2=3, e3=4) == 10
+assert dill.loads(dumped_func_e)(1, 2, 3, e2=4) == 12
+assert dill.loads(dumped_func_e)(1, 2, 3, e2=4, e3=5) == 15''')
+
+def test_code_object():
+    import warnings
+    from dill._dill import ALL_CODE_PARAMS, CODE_PARAMS, CODE_VERSION, _create_code
+    code = function_c.__code__
+    warnings.filterwarnings('ignore', category=DeprecationWarning) # issue 597
+    LNOTAB = getattr(code, 'co_lnotab', b'')
+    if warnings.filters: del warnings.filters[0]
+    fields = {f: getattr(code, 'co_'+f) for f in CODE_PARAMS}
+    fields.setdefault('posonlyargcount', 0)         # python >= 3.8
+    fields.setdefault('lnotab', LNOTAB)             # python <= 3.9
+    fields.setdefault('linetable', b'')             # python >= 3.10
+    fields.setdefault('qualname', fields['name'])   # python >= 3.11
+    fields.setdefault('exceptiontable', b'')        # python >= 3.11
+    fields.setdefault('endlinetable', None)         # python == 3.11a
+    fields.setdefault('columntable', None)          # python == 3.11a
+
+    for version, _, params in ALL_CODE_PARAMS:
+        args = tuple(fields[p] for p in params.split())
+        try:
+            _create_code(*args)
+            if version >= (3,10):
+                _create_code(fields['lnotab'], *args)
+        except Exception as error:
+            raise Exception("failed to construct code object with format version {}".format(version)) from error
+
+if __name__ == '__main__':
+    test_functions()
+    test_issue_510()
+    test_code_object()

.venv/lib/python3.11/site-packages/dill/tests/test_recursive.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2019-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+from functools import partial
+import warnings
+
+
+def copy(obj, byref=False, recurse=False):
+    if byref:
+        try:
+            return dill.copy(obj, byref=byref, recurse=recurse)
+        except Exception:
+            pass
+        else:
+            raise AssertionError('Copy of %s with byref=True should have given a warning!' % (obj,))
+
+        warnings.simplefilter('ignore')
+        val = dill.copy(obj, byref=byref, recurse=recurse)
+        warnings.simplefilter('error')
+        return val
+    else:
+        return dill.copy(obj, byref=byref, recurse=recurse)
+
+
+class obj1(object):
+    def __init__(self):
+        super(obj1, self).__init__()
+
+class obj2(object):
+    def __init__(self):
+        super(obj2, self).__init__()
+
+class obj3(object):
+    super_ = super
+    def __init__(self):
+        obj3.super_(obj3, self).__init__()
+
+
+def test_super():
+    assert copy(obj1(), byref=True)
+    assert copy(obj1(), byref=True, recurse=True)
+    assert copy(obj1(), recurse=True)
+    assert copy(obj1())
+
+    assert copy(obj2(), byref=True)
+    assert copy(obj2(), byref=True, recurse=True)
+    assert copy(obj2(), recurse=True)
+    assert copy(obj2())
+
+    assert copy(obj3(), byref=True)
+    assert copy(obj3(), byref=True, recurse=True)
+    assert copy(obj3(), recurse=True)
+    assert copy(obj3())
+
+
+def get_trigger(model):
+    pass
+
+class Machine(object):
+    def __init__(self):
+        self.child = Model()
+        self.trigger = partial(get_trigger, self)
+        self.child.trigger = partial(get_trigger, self.child)
+
+class Model(object):
+    pass
+
+
+
+def test_partial():
+    assert copy(Machine(), byref=True)
+    assert copy(Machine(), byref=True, recurse=True)
+    assert copy(Machine(), recurse=True)
+    assert copy(Machine())
+
+
+class Machine2(object):
+    def __init__(self):
+        self.go = partial(self.member, self)
+    def member(self, model):
+        pass
+
+
+class SubMachine(Machine2):
+    def __init__(self):
+        super(SubMachine, self).__init__()
+
+
+def test_partials():
+    assert copy(SubMachine(), byref=True)
+    assert copy(SubMachine(), byref=True, recurse=True)
+    assert copy(SubMachine(), recurse=True)
+    assert copy(SubMachine())
+
+
+class obj4(object):
+    def __init__(self):
+        super(obj4, self).__init__()
+        a = self
+        class obj5(object):
+            def __init__(self):
+                super(obj5, self).__init__()
+                self.a = a
+        self.b = obj5()
+
+
+def test_circular_reference():
+    assert copy(obj4())
+    obj4_copy = dill.loads(dill.dumps(obj4()))
+    assert type(obj4_copy) is type(obj4_copy).__init__.__closure__[0].cell_contents
+    assert type(obj4_copy.b) is type(obj4_copy.b).__init__.__closure__[0].cell_contents
+
+
+def f():
+    def g():
+       return g
+    return g
+
+
+def test_function_cells():
+    assert copy(f())
+
+
+def fib(n):
+    assert n >= 0
+    if n <= 1:
+        return n
+    else:
+        return fib(n-1) + fib(n-2)
+
+
+def test_recursive_function():
+    global fib
+    fib2 = copy(fib, recurse=True)
+    fib3 = copy(fib)
+    fib4 = fib
+    del fib
+    assert fib2(5) == 5
+    for _fib in (fib3, fib4):
+        try:
+            _fib(5)
+        except Exception:
+            # This is expected to fail because fib no longer exists
+            pass
+        else:
+            raise AssertionError("Function fib shouldn't have been found")
+    fib = fib4
+
+
+def collection_function_recursion():
+    d = {}
+    def g():
+        return d
+    d['g'] = g
+    return g
+
+
+def test_collection_function_recursion():
+    g = copy(collection_function_recursion())
+    assert g()['g'] is g
+
+
+if __name__ == '__main__':
+    with warnings.catch_warnings():
+        warnings.simplefilter('error')
+        test_super()
+        test_partial()
+        test_partials()
+        test_circular_reference()
+        test_function_cells()
+        test_recursive_function()
+        test_collection_function_recursion()

.venv/lib/python3.11/site-packages/dill/tests/test_restricted.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+#
+# Author: Kirill Makhonin (@kirillmakhonin)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+
+class RestrictedType:
+    def __bool__(*args, **kwargs):
+        raise Exception('Restricted function')
+
+    __eq__ = __lt__ = __le__ = __ne__ = __gt__ = __ge__ = __hash__ = __bool__
+
+glob_obj = RestrictedType()
+
+def restricted_func():
+    a = glob_obj
+
+def test_function_with_restricted_object():
+    deserialized = dill.loads(dill.dumps(restricted_func, recurse=True))
+
+
+if __name__ == '__main__':
+    test_function_with_restricted_object()

.venv/lib/python3.11/site-packages/dill/tests/test_selected.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+testing some selected object types
+"""
+
+import dill
+dill.settings['recurse'] = True
+
+verbose = False
+
+def test_dict_contents():
+  c = type.__dict__
+  for i,j in c.items():
+   #try:
+    ok = dill.pickles(j)
+   #except Exception:
+   #  print ("FAIL: %s with %s" % (i, dill.detect.errors(j)))
+    if verbose: print ("%s: %s, %s" % (ok, type(j), j))
+    assert ok
+  if verbose: print ("")
+
+def _g(x): yield x;
+
+def _f():
+  try: raise
+  except Exception:
+    from sys import exc_info
+    e, er, tb = exc_info()
+    return er, tb
+
+class _d(object):
+  def _method(self):
+    pass
+
+from dill import objects
+from dill import load_types
+load_types(pickleable=True,unpickleable=False)
+_newclass = objects['ClassObjectType']
+# some clean-up #FIXME: should happen internal to dill
+objects['TemporaryFileType'].close()
+objects['TextWrapperType'].close()
+if 'BufferedRandomType' in objects:
+    objects['BufferedRandomType'].close()
+objects['BufferedReaderType'].close()
+objects['BufferedWriterType'].close()
+objects['FileType'].close()
+del objects
+
+# getset_descriptor for new-style classes (fails on '_method', if not __main__)
+def test_class_descriptors():
+  d = _d.__dict__
+  for i in d.values():
+    ok = dill.pickles(i)
+    if verbose: print ("%s: %s, %s" % (ok, type(i), i))
+    assert ok
+  if verbose: print ("")
+  od = _newclass.__dict__
+  for i in od.values():
+    ok = dill.pickles(i)
+    if verbose: print ("%s: %s, %s" % (ok, type(i), i))
+    assert ok
+  if verbose: print ("")
+
+# (__main__) class instance for new-style classes
+def test_class():
+  o = _d()
+  oo = _newclass()
+  ok = dill.pickles(o)
+  if verbose: print ("%s: %s, %s" % (ok, type(o), o))
+  assert ok
+  ok = dill.pickles(oo)
+  if verbose: print ("%s: %s, %s" % (ok, type(oo), oo))
+  assert ok
+  if verbose: print ("")
+
+# frames, generators, and tracebacks (all depend on frame)
+def test_frame_related():
+  g = _g(1)
+  f = g.gi_frame
+  e,t = _f()
+  _is = lambda ok: ok
+  ok = dill.pickles(f)
+  if verbose: print ("%s: %s, %s" % (ok, type(f), f))
+  assert not ok
+  ok = dill.pickles(g)
+  if verbose: print ("%s: %s, %s" % (ok, type(g), g))
+  assert _is(not ok) #XXX: dill fails
+  ok = dill.pickles(t)
+  if verbose: print ("%s: %s, %s" % (ok, type(t), t))
+  assert not ok #XXX: dill fails
+  ok = dill.pickles(e)
+  if verbose: print ("%s: %s, %s" % (ok, type(e), e))
+  assert ok
+  if verbose: print ("")
+
+def test_typing():
+  import typing
+  x = typing.Any
+  assert x == dill.copy(x)
+  x = typing.Dict[int, str]
+  assert x == dill.copy(x)
+  x = typing.List[int]
+  assert x == dill.copy(x)
+  x = typing.Tuple[int, str]
+  assert x == dill.copy(x)
+  x = typing.Tuple[int]
+  assert x == dill.copy(x)
+  x = typing.Tuple[()]
+  assert x == dill.copy(x)
+  x = typing.Tuple[()].copy_with(())
+  assert x == dill.copy(x)
+  return
+
+
+if __name__ == '__main__':
+  test_frame_related()
+  test_dict_contents()
+  test_class()
+  test_class_descriptors()
+  test_typing()

.venv/lib/python3.11/site-packages/dill/tests/test_threads.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+dill.settings['recurse'] = True
+
+
+def test_new_thread():
+    import threading
+    t = threading.Thread()
+    t_ = dill.copy(t)
+    assert t.is_alive() == t_.is_alive()
+    for i in ['daemon','name','ident','native_id']:
+        if hasattr(t, i):
+            assert getattr(t, i) == getattr(t_, i)
+
+def test_run_thread():
+    import threading
+    t = threading.Thread()
+    t.start()
+    t_ = dill.copy(t)
+    assert t.is_alive() == t_.is_alive()
+    for i in ['daemon','name','ident','native_id']:
+        if hasattr(t, i):
+            assert getattr(t, i) == getattr(t_, i)
+
+def test_join_thread():
+    import threading
+    t = threading.Thread()
+    t.start()
+    t.join()
+    t_ = dill.copy(t)
+    assert t.is_alive() == t_.is_alive()
+    for i in ['daemon','name','ident','native_id']:
+        if hasattr(t, i):
+            assert getattr(t, i) == getattr(t_, i)
+
+
+if __name__ == '__main__':
+    test_new_thread()
+    test_run_thread()
+    test_join_thread()

.venv/lib/python3.11/site-packages/virtualenv/activation/__init__.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from .bash import BashActivator
+from .batch import BatchActivator
+from .cshell import CShellActivator
+from .fish import FishActivator
+from .nushell import NushellActivator
+from .powershell import PowerShellActivator
+from .python import PythonActivator
+
+__all__ = [
+    "BashActivator",
+    "BatchActivator",
+    "CShellActivator",
+    "FishActivator",
+    "NushellActivator",
+    "PowerShellActivator",
+    "PythonActivator",
+]

.venv/lib/python3.11/site-packages/virtualenv/activation/activator.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import os
+from abc import ABC, abstractmethod
+
+
+class Activator(ABC):
+    """Generates activate script for the virtual environment."""
+
+    def __init__(self, options) -> None:
+        """
+        Create a new activator generator.
+
+        :param options: the parsed options as defined within :meth:`add_parser_arguments`
+        """
+        self.flag_prompt = os.path.basename(os.getcwd()) if options.prompt == "." else options.prompt
+
+    @classmethod
+    def supports(cls, interpreter):  # noqa: ARG003
+        """
+        Check if the activation script is supported in the given interpreter.
+
+        :param interpreter: the interpreter we need to support
+        :return: ``True`` if supported, ``False`` otherwise
+        """
+        return True
+
+    @classmethod  # noqa: B027
+    def add_parser_arguments(cls, parser, interpreter):
+        """
+        Add CLI arguments for this activation script.
+
+        :param parser: the CLI parser
+        :param interpreter: the interpreter this virtual environment is based of
+        """
+
+    @abstractmethod
+    def generate(self, creator):
+        """
+        Generate activate script for the given creator.
+
+        :param creator: the creator (based of :class:`virtualenv.create.creator.Creator`) we used to create this \
+        virtual environment
+        """
+        raise NotImplementedError
+
+
+__all__ = [
+    "Activator",
+]

.venv/lib/python3.11/site-packages/virtualenv/activation/bash/__init__.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from virtualenv.activation.via_template import ViaTemplateActivator
+
+
+class BashActivator(ViaTemplateActivator):
+    def templates(self):
+        yield "activate.sh"
+
+    def as_name(self, template):
+        return Path(template).stem
+
+
+__all__ = [
+    "BashActivator",
+]

.venv/lib/python3.11/site-packages/virtualenv/activation/bash/activate.sh

@@ -0,0 +1,87 @@
+# This file must be used with "source bin/activate" *from bash*
+# you cannot run it directly
+
+
+if [ "${BASH_SOURCE-}" = "$0" ]; then
+    echo "You must source this script: \$ source $0" >&2
+    exit 33
+fi
+
+deactivate () {
+    unset -f pydoc >/dev/null 2>&1 || true
+
+    # reset old environment variables
+    # ! [ -z ${VAR+_} ] returns true if VAR is declared at all
+    if ! [ -z "${_OLD_VIRTUAL_PATH:+_}" ] ; then
+        PATH="$_OLD_VIRTUAL_PATH"
+        export PATH
+        unset _OLD_VIRTUAL_PATH
+    fi
+    if ! [ -z "${_OLD_VIRTUAL_PYTHONHOME+_}" ] ; then
+        PYTHONHOME="$_OLD_VIRTUAL_PYTHONHOME"
+        export PYTHONHOME
+        unset _OLD_VIRTUAL_PYTHONHOME
+    fi
+
+    # The hash command must be called to get it to forget past
+    # commands. Without forgetting past commands the $PATH changes
+    # we made may not be respected
+    hash -r 2>/dev/null
+
+    if ! [ -z "${_OLD_VIRTUAL_PS1+_}" ] ; then
+        PS1="$_OLD_VIRTUAL_PS1"
+        export PS1
+        unset _OLD_VIRTUAL_PS1
+    fi
+
+    unset VIRTUAL_ENV
+    unset VIRTUAL_ENV_PROMPT
+    if [ ! "${1-}" = "nondestructive" ] ; then
+    # Self destruct!
+        unset -f deactivate
+    fi
+}
+
+# unset irrelevant variables
+deactivate nondestructive
+
+VIRTUAL_ENV=__VIRTUAL_ENV__
+if ([ "$OSTYPE" = "cygwin" ] || [ "$OSTYPE" = "msys" ]) && $(command -v cygpath &> /dev/null) ; then
+    VIRTUAL_ENV=$(cygpath -u "$VIRTUAL_ENV")
+fi
+export VIRTUAL_ENV
+
+_OLD_VIRTUAL_PATH="$PATH"
+PATH="$VIRTUAL_ENV/"__BIN_NAME__":$PATH"
+export PATH
+
+if [ "x"__VIRTUAL_PROMPT__ != x ] ; then
+    VIRTUAL_ENV_PROMPT=__VIRTUAL_PROMPT__
+else
+    VIRTUAL_ENV_PROMPT=$(basename "$VIRTUAL_ENV")
+fi
+export VIRTUAL_ENV_PROMPT
+
+# unset PYTHONHOME if set
+if ! [ -z "${PYTHONHOME+_}" ] ; then
+    _OLD_VIRTUAL_PYTHONHOME="$PYTHONHOME"
+    unset PYTHONHOME
+fi
+
+if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT-}" ] ; then
+    _OLD_VIRTUAL_PS1="${PS1-}"
+    PS1="(${VIRTUAL_ENV_PROMPT}) ${PS1-}"
+    export PS1
+fi
+
+# Make sure to unalias pydoc if it's already there
+alias pydoc 2>/dev/null >/dev/null && unalias pydoc || true
+
+pydoc () {
+    python -m pydoc "$@"
+}
+
+# The hash command must be called to get it to forget past
+# commands. Without forgetting past commands the $PATH changes
+# we made may not be respected
+hash -r 2>/dev/null || true

.venv/lib/python3.11/site-packages/virtualenv/activation/batch/__init__.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import os
+
+from virtualenv.activation.via_template import ViaTemplateActivator
+
+
+class BatchActivator(ViaTemplateActivator):
+    @classmethod
+    def supports(cls, interpreter):
+        return interpreter.os == "nt"
+
+    def templates(self):
+        yield "activate.bat"
+        yield "deactivate.bat"
+        yield "pydoc.bat"
+
+    @staticmethod
+    def quote(string):
+        return string
+
+    def instantiate_template(self, replacements, template, creator):
+        # ensure the text has all newlines as \r\n - required by batch
+        base = super().instantiate_template(replacements, template, creator)
+        return base.replace(os.linesep, "\n").replace("\n", os.linesep)
+
+
+__all__ = [
+    "BatchActivator",
+]

.venv/lib/python3.11/site-packages/virtualenv/activation/batch/activate.bat

@@ -0,0 +1,50 @@
+@REM This file is UTF-8 encoded, so we need to update the current code page while executing it
+@for /f "tokens=2 delims=:." %%a in ('"%SystemRoot%\System32\chcp.com"') do @set _OLD_CODEPAGE=%%a
+
+@if defined _OLD_CODEPAGE (
+    "%SystemRoot%\System32\chcp.com" 65001 > nul
+)
+
+@set "VIRTUAL_ENV=__VIRTUAL_ENV__"
+
+@set "VIRTUAL_ENV_PROMPT=__VIRTUAL_PROMPT__"
+@if NOT DEFINED VIRTUAL_ENV_PROMPT (
+    @for %%d in ("%VIRTUAL_ENV%") do @set "VIRTUAL_ENV_PROMPT=%%~nxd"
+)
+
+@if defined _OLD_VIRTUAL_PROMPT (
+    @set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
+) else (
+    @if not defined PROMPT (
+        @set "PROMPT=$P$G"
+    )
+    @if not defined VIRTUAL_ENV_DISABLE_PROMPT (
+        @set "_OLD_VIRTUAL_PROMPT=%PROMPT%"
+    )
+)
+@if not defined VIRTUAL_ENV_DISABLE_PROMPT (
+    @set "PROMPT=(%VIRTUAL_ENV_PROMPT%) %PROMPT%"
+)
+
+@REM Don't use () to avoid problems with them in %PATH%
+@if defined _OLD_VIRTUAL_PYTHONHOME @goto ENDIFVHOME
+    @set "_OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%"
+:ENDIFVHOME
+
+@set PYTHONHOME=
+
+@REM if defined _OLD_VIRTUAL_PATH (
+@if not defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH1
+    @set "PATH=%_OLD_VIRTUAL_PATH%"
+:ENDIFVPATH1
+@REM ) else (
+@if defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH2
+    @set "_OLD_VIRTUAL_PATH=%PATH%"
+:ENDIFVPATH2
+
+@set "PATH=%VIRTUAL_ENV%\__BIN_NAME__;%PATH%"
+
+@if defined _OLD_CODEPAGE (
+    "%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul
+    @set _OLD_CODEPAGE=
+)

.venv/lib/python3.11/site-packages/virtualenv/activation/batch/deactivate.bat

@@ -0,0 +1,18 @@
+@set VIRTUAL_ENV=
+@set VIRTUAL_ENV_PROMPT=
+
+@REM Don't use () to avoid problems with them in %PATH%
+@if not defined _OLD_VIRTUAL_PROMPT @goto ENDIFVPROMPT
+    @set "PROMPT=%_OLD_VIRTUAL_PROMPT%"
+    @set _OLD_VIRTUAL_PROMPT=
+:ENDIFVPROMPT
+
+@if not defined _OLD_VIRTUAL_PYTHONHOME @goto ENDIFVHOME
+    @set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%"
+    @set _OLD_VIRTUAL_PYTHONHOME=
+:ENDIFVHOME
+
+@if not defined _OLD_VIRTUAL_PATH @goto ENDIFVPATH
+    @set "PATH=%_OLD_VIRTUAL_PATH%"
+    @set _OLD_VIRTUAL_PATH=
+:ENDIFVPATH

.venv/lib/python3.11/site-packages/virtualenv/activation/batch/pydoc.bat

@@ -0,0 +1 @@
+python.exe -m pydoc %*

.venv/lib/python3.11/site-packages/virtualenv/activation/cshell/__init__.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from virtualenv.activation.via_template import ViaTemplateActivator
+
+
+class CShellActivator(ViaTemplateActivator):
+    @classmethod
+    def supports(cls, interpreter):
+        return interpreter.os != "nt"
+
+    def templates(self):
+        yield "activate.csh"
+
+
+__all__ = [
+    "CShellActivator",
+]

.venv/lib/python3.11/site-packages/virtualenv/activation/cshell/activate.csh

@@ -0,0 +1,55 @@
+# This file must be used with "source bin/activate.csh" *from csh*.
+# You cannot run it directly.
+# Created by Davide Di Blasi <davidedb@gmail.com>.
+
+set newline='\
+'
+
+alias deactivate 'test $?_OLD_VIRTUAL_PATH != 0 && setenv PATH "$_OLD_VIRTUAL_PATH:q" && unset _OLD_VIRTUAL_PATH; rehash; test $?_OLD_VIRTUAL_PROMPT != 0 && set prompt="$_OLD_VIRTUAL_PROMPT:q" && unset _OLD_VIRTUAL_PROMPT; unsetenv VIRTUAL_ENV; unsetenv VIRTUAL_ENV_PROMPT; test "\!:*" != "nondestructive" && unalias deactivate && unalias pydoc'
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+setenv VIRTUAL_ENV __VIRTUAL_ENV__
+
+set _OLD_VIRTUAL_PATH="$PATH:q"
+setenv PATH "$VIRTUAL_ENV:q/"__BIN_NAME__":$PATH:q"
+
+
+
+if (__VIRTUAL_PROMPT__ != "") then
+    setenv VIRTUAL_ENV_PROMPT __VIRTUAL_PROMPT__
+else
+    setenv VIRTUAL_ENV_PROMPT "$VIRTUAL_ENV:t:q"
+endif
+
+if ( $?VIRTUAL_ENV_DISABLE_PROMPT ) then
+    if ( $VIRTUAL_ENV_DISABLE_PROMPT == "" ) then
+        set do_prompt = "1"
+    else
+        set do_prompt = "0"
+    endif
+else
+    set do_prompt = "1"
+endif
+
+if ( $do_prompt == "1" ) then
+    # Could be in a non-interactive environment,
+    # in which case, $prompt is undefined and we wouldn't
+    # care about the prompt anyway.
+    if ( $?prompt ) then
+        set _OLD_VIRTUAL_PROMPT="$prompt:q"
+        if ( "$prompt:q" =~ *"$newline:q"* ) then
+            :
+        else
+            set prompt = '('"$VIRTUAL_ENV_PROMPT:q"') '"$prompt:q"
+        endif
+    endif
+endif
+
+unset env_name
+unset do_prompt
+
+alias pydoc python -m pydoc
+
+rehash

.venv/lib/python3.11/site-packages/virtualenv/activation/fish/__init__.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from virtualenv.activation.via_template import ViaTemplateActivator
+
+
+class FishActivator(ViaTemplateActivator):
+    def templates(self):
+        yield "activate.fish"
+
+
+__all__ = [
+    "FishActivator",
+]

.venv/lib/python3.11/site-packages/virtualenv/activation/fish/activate.fish

@@ -0,0 +1,103 @@
+# This file must be used using `source bin/activate.fish` *within a running fish ( http://fishshell.com ) session*.
+# Do not run it directly.
+
+function _bashify_path -d "Converts a fish path to something bash can recognize"
+    set fishy_path $argv
+    set bashy_path $fishy_path[1]
+    for path_part in $fishy_path[2..-1]
+        set bashy_path "$bashy_path:$path_part"
+    end
+    echo $bashy_path
+end
+
+function _fishify_path -d "Converts a bash path to something fish can recognize"
+    echo $argv | tr ':' '\n'
+end
+
+function deactivate -d 'Exit virtualenv mode and return to the normal environment.'
+    # reset old environment variables
+    if test -n "$_OLD_VIRTUAL_PATH"
+        # https://github.com/fish-shell/fish-shell/issues/436 altered PATH handling
+        if test (echo $FISH_VERSION | head -c 1) -lt 3
+            set -gx PATH (_fishify_path "$_OLD_VIRTUAL_PATH")
+        else
+            set -gx PATH $_OLD_VIRTUAL_PATH
+        end
+        set -e _OLD_VIRTUAL_PATH
+    end
+
+    if test -n "$_OLD_VIRTUAL_PYTHONHOME"
+        set -gx PYTHONHOME "$_OLD_VIRTUAL_PYTHONHOME"
+        set -e _OLD_VIRTUAL_PYTHONHOME
+    end
+
+    if test -n "$_OLD_FISH_PROMPT_OVERRIDE"
+       and functions -q _old_fish_prompt
+        # Set an empty local `$fish_function_path` to allow the removal of `fish_prompt` using `functions -e`.
+        set -l fish_function_path
+
+        # Erase virtualenv's `fish_prompt` and restore the original.
+        functions -e fish_prompt
+        functions -c _old_fish_prompt fish_prompt
+        functions -e _old_fish_prompt
+        set -e _OLD_FISH_PROMPT_OVERRIDE
+    end
+
+    set -e VIRTUAL_ENV
+    set -e VIRTUAL_ENV_PROMPT
+
+    if test "$argv[1]" != 'nondestructive'
+        # Self-destruct!
+        functions -e pydoc
+        functions -e deactivate
+        functions -e _bashify_path
+        functions -e _fishify_path
+    end
+end
+
+# Unset irrelevant variables.
+deactivate nondestructive
+
+set -gx VIRTUAL_ENV __VIRTUAL_ENV__
+
+# https://github.com/fish-shell/fish-shell/issues/436 altered PATH handling
+if test (echo $FISH_VERSION | head -c 1) -lt 3
+    set -gx _OLD_VIRTUAL_PATH (_bashify_path $PATH)
+else
+    set -gx _OLD_VIRTUAL_PATH $PATH
+end
+set -gx PATH "$VIRTUAL_ENV"'/'__BIN_NAME__ $PATH
+
+# Prompt override provided?
+# If not, just use the environment name.
+if test -n __VIRTUAL_PROMPT__
+    set -gx VIRTUAL_ENV_PROMPT __VIRTUAL_PROMPT__
+else
+    set -gx VIRTUAL_ENV_PROMPT (basename "$VIRTUAL_ENV")
+end
+
+# Unset `$PYTHONHOME` if set.
+if set -q PYTHONHOME
+    set -gx _OLD_VIRTUAL_PYTHONHOME $PYTHONHOME
+    set -e PYTHONHOME
+end
+
+function pydoc
+    python -m pydoc $argv
+end
+
+if test -z "$VIRTUAL_ENV_DISABLE_PROMPT"
+    # Copy the current `fish_prompt` function as `_old_fish_prompt`.
+    functions -c fish_prompt _old_fish_prompt
+
+    function fish_prompt
+        # Run the user's prompt first; it might depend on (pipe)status.
+        set -l prompt (_old_fish_prompt)
+
+        printf '(%s) ' $VIRTUAL_ENV_PROMPT
+
+        string join -- \n $prompt # handle multi-line prompts
+    end
+
+    set -gx _OLD_FISH_PROMPT_OVERRIDE "$VIRTUAL_ENV"
+end

.venv/lib/python3.11/site-packages/virtualenv/activation/nushell/__init__.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from virtualenv.activation.via_template import ViaTemplateActivator
+
+
+class NushellActivator(ViaTemplateActivator):
+    def templates(self):
+        yield "activate.nu"
+
+    @staticmethod
+    def quote(string):
+        """
+        Nushell supports raw strings like: r###'this is a string'###.
+
+        This method finds the maximum continuous sharps in the string and then
+        quote it with an extra sharp.
+        """
+        max_sharps = 0
+        current_sharps = 0
+        for char in string:
+            if char == "#":
+                current_sharps += 1
+                max_sharps = max(current_sharps, max_sharps)
+            else:
+                current_sharps = 0
+        wrapping = "#" * (max_sharps + 1)
+        return f"r{wrapping}'{string}'{wrapping}"
+
+    def replacements(self, creator, dest_folder):  # noqa: ARG002
+        return {
+            "__VIRTUAL_PROMPT__": "" if self.flag_prompt is None else self.flag_prompt,
+            "__VIRTUAL_ENV__": str(creator.dest),
+            "__VIRTUAL_NAME__": creator.env_name,
+            "__BIN_NAME__": str(creator.bin_dir.relative_to(creator.dest)),
+        }
+
+
+__all__ = [
+    "NushellActivator",
+]

.venv/lib/python3.11/site-packages/virtualenv/activation/nushell/activate.nu

@@ -0,0 +1,96 @@
+# virtualenv activation module
+# Activate with `overlay use activate.nu`
+# Deactivate with `deactivate`, as usual
+#
+# To customize the overlay name, you can call `overlay use activate.nu as foo`,
+# but then simply `deactivate` won't work because it is just an alias to hide
+# the "activate" overlay. You'd need to call `overlay hide foo` manually.
+
+export-env {
+    def is-string [x] {
+        ($x | describe) == 'string'
+    }
+
+    def has-env [...names] {
+        $names | each {|n|
+            $n in $env
+        } | all {|i| $i == true}
+    }
+
+    # Emulates a `test -z`, but better as it handles e.g 'false'
+    def is-env-true [name: string] {
+      if (has-env $name) {
+        # Try to parse 'true', '0', '1', and fail if not convertible
+        let parsed = (do -i { $env | get $name | into bool })
+        if ($parsed | describe) == 'bool' {
+          $parsed
+        } else {
+          not ($env | get -i $name | is-empty)
+        }
+      } else {
+        false
+      }
+    }
+
+    let virtual_env = __VIRTUAL_ENV__
+    let bin = __BIN_NAME__
+
+    let is_windows = ($nu.os-info.family) == 'windows'
+    let path_name = (if (has-env 'Path') {
+            'Path'
+        } else {
+            'PATH'
+        }
+    )
+
+    let venv_path = ([$virtual_env $bin] | path join)
+    let new_path = ($env | get $path_name | prepend $venv_path)
+
+    # If there is no default prompt, then use the env name instead
+    let virtual_env_prompt = (if (__VIRTUAL_PROMPT__ | is-empty) {
+        ($virtual_env | path basename)
+    } else {
+        __VIRTUAL_PROMPT__
+    })
+
+    let new_env = {
+        $path_name         : $new_path
+        VIRTUAL_ENV        : $virtual_env
+        VIRTUAL_ENV_PROMPT : $virtual_env_prompt
+    }
+
+    let new_env = (if (is-env-true 'VIRTUAL_ENV_DISABLE_PROMPT') {
+      $new_env
+    } else {
+      # Creating the new prompt for the session
+      let virtual_prefix = $'(char lparen)($virtual_env_prompt)(char rparen) '
+
+      # Back up the old prompt builder
+      let old_prompt_command = (if (has-env 'PROMPT_COMMAND') {
+              $env.PROMPT_COMMAND
+          } else {
+              ''
+        })
+
+      let new_prompt = (if (has-env 'PROMPT_COMMAND') {
+          if 'closure' in ($old_prompt_command | describe) {
+              {|| $'($virtual_prefix)(do $old_prompt_command)' }
+          } else {
+              {|| $'($virtual_prefix)($old_prompt_command)' }
+          }
+      } else {
+          {|| $'($virtual_prefix)' }
+      })
+
+      $new_env | merge {
+        PROMPT_COMMAND      : $new_prompt
+        VIRTUAL_PREFIX      : $virtual_prefix
+      }
+    })
+
+    # Environment variables that will be loaded as the virtual env
+    load-env $new_env
+}
+
+export alias pydoc = python -m pydoc
+export alias deactivate = overlay hide activate

.venv/lib/python3.11/site-packages/virtualenv/activation/powershell/__init__.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from virtualenv.activation.via_template import ViaTemplateActivator
+
+
+class PowerShellActivator(ViaTemplateActivator):
+    def templates(self):
+        yield "activate.ps1"
+
+    @staticmethod
+    def quote(string):
+        """
+        This should satisfy PowerShell quoting rules [1], unless the quoted
+        string is passed directly to Windows native commands [2].
+
+        [1]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_quoting_rules
+        [2]: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_parsing#passing-arguments-that-contain-quote-characters
+        """  # noqa: D205
+        string = string.replace("'", "''")
+        return f"'{string}'"
+
+
+__all__ = [
+    "PowerShellActivator",
+]

.venv/lib/python3.11/site-packages/virtualenv/activation/powershell/activate.ps1

@@ -0,0 +1,61 @@
+$script:THIS_PATH = $myinvocation.mycommand.path
+$script:BASE_DIR = Split-Path (Resolve-Path "$THIS_PATH/..") -Parent
+
+function global:deactivate([switch] $NonDestructive) {
+    if (Test-Path variable:_OLD_VIRTUAL_PATH) {
+        $env:PATH = $variable:_OLD_VIRTUAL_PATH
+        Remove-Variable "_OLD_VIRTUAL_PATH" -Scope global
+    }
+
+    if (Test-Path function:_old_virtual_prompt) {
+        $function:prompt = $function:_old_virtual_prompt
+        Remove-Item function:\_old_virtual_prompt
+    }
+
+    if ($env:VIRTUAL_ENV) {
+        Remove-Item env:VIRTUAL_ENV -ErrorAction SilentlyContinue
+    }
+
+    if ($env:VIRTUAL_ENV_PROMPT) {
+        Remove-Item env:VIRTUAL_ENV_PROMPT -ErrorAction SilentlyContinue
+    }
+
+    if (!$NonDestructive) {
+        # Self destruct!
+        Remove-Item function:deactivate
+        Remove-Item function:pydoc
+    }
+}
+
+function global:pydoc {
+    python -m pydoc $args
+}
+
+# unset irrelevant variables
+deactivate -nondestructive
+
+$VIRTUAL_ENV = $BASE_DIR
+$env:VIRTUAL_ENV = $VIRTUAL_ENV
+
+if (__VIRTUAL_PROMPT__ -ne "") {
+    $env:VIRTUAL_ENV_PROMPT = __VIRTUAL_PROMPT__
+}
+else {
+    $env:VIRTUAL_ENV_PROMPT = $( Split-Path $env:VIRTUAL_ENV -Leaf )
+}
+
+New-Variable -Scope global -Name _OLD_VIRTUAL_PATH -Value $env:PATH
+
+$env:PATH = "$env:VIRTUAL_ENV/" + __BIN_NAME__ + __PATH_SEP__ + $env:PATH
+if (!$env:VIRTUAL_ENV_DISABLE_PROMPT) {
+    function global:_old_virtual_prompt {
+        ""
+    }
+    $function:_old_virtual_prompt = $function:prompt
+
+    function global:prompt {
+        # Add the custom prefix to the existing prompt
+        $previous_prompt_value = & $function:_old_virtual_prompt
+        ("(" + $env:VIRTUAL_ENV_PROMPT + ") " + $previous_prompt_value)
+    }
+}

.venv/lib/python3.11/site-packages/virtualenv/activation/python/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+import os
+from collections import OrderedDict
+
+from virtualenv.activation.via_template import ViaTemplateActivator
+
+
+class PythonActivator(ViaTemplateActivator):
+    def templates(self):
+        yield "activate_this.py"
+
+    @staticmethod
+    def quote(string):
+        return repr(string)
+
+    def replacements(self, creator, dest_folder):
+        replacements = super().replacements(creator, dest_folder)
+        lib_folders = OrderedDict((os.path.relpath(str(i), str(dest_folder)), None) for i in creator.libs)
+        lib_folders = os.pathsep.join(lib_folders.keys())
+        replacements.update(
+            {
+                "__LIB_FOLDERS__": lib_folders,
+                "__DECODE_PATH__": "",
+            },
+        )
+        return replacements
+
+
+__all__ = [
+    "PythonActivator",
+]

.venv/lib/python3.11/site-packages/virtualenv/activation/python/activate_this.py

@@ -0,0 +1,38 @@
+"""
+Activate virtualenv for current interpreter:
+
+import runpy
+runpy.run_path(this_file)
+
+This can be used when you must use an existing Python interpreter, not the virtualenv bin/python.
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import os
+import site
+import sys
+
+try:
+    abs_file = os.path.abspath(__file__)
+except NameError as exc:
+    msg = "You must use import runpy; runpy.run_path(this_file)"
+    raise AssertionError(msg) from exc
+
+bin_dir = os.path.dirname(abs_file)
+base = bin_dir[: -len(__BIN_NAME__) - 1]  # strip away the bin part from the __file__, plus the path separator
+
+# prepend bin to PATH (this file is inside the bin directory)
+os.environ["PATH"] = os.pathsep.join([bin_dir, *os.environ.get("PATH", "").split(os.pathsep)])
+os.environ["VIRTUAL_ENV"] = base  # virtual env is right above bin directory
+os.environ["VIRTUAL_ENV_PROMPT"] = __VIRTUAL_PROMPT__ or os.path.basename(base)
+
+# add the virtual environments libraries to the host python import mechanism
+prev_length = len(sys.path)
+for lib in __LIB_FOLDERS__.split(os.pathsep):
+    path = os.path.realpath(os.path.join(bin_dir, lib))
+    site.addsitedir(path.decode("utf-8") if __DECODE_PATH__ else path)
+sys.path[:] = sys.path[prev_length:] + sys.path[0:prev_length]
+
+sys.real_prefix = sys.prefix
+sys.prefix = base

.venv/lib/python3.11/site-packages/virtualenv/activation/via_template.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import os
+import shlex
+import sys
+from abc import ABC, abstractmethod
+
+from .activator import Activator
+
+if sys.version_info >= (3, 10):
+    from importlib.resources import files
+
+    def read_binary(module_name: str, filename: str) -> bytes:
+        return (files(module_name) / filename).read_bytes()
+
+else:
+    from importlib.resources import read_binary
+
+
+class ViaTemplateActivator(Activator, ABC):
+    @abstractmethod
+    def templates(self):
+        raise NotImplementedError
+
+    @staticmethod
+    def quote(string):
+        """
+        Quote strings in the activation script.
+
+        :param string: the string to quote
+        :return: quoted string that works in the activation script
+        """
+        return shlex.quote(string)
+
+    def generate(self, creator):
+        dest_folder = creator.bin_dir
+        replacements = self.replacements(creator, dest_folder)
+        generated = self._generate(replacements, self.templates(), dest_folder, creator)
+        if self.flag_prompt is not None:
+            creator.pyenv_cfg["prompt"] = self.flag_prompt
+        return generated
+
+    def replacements(self, creator, dest_folder):  # noqa: ARG002
+        return {
+            "__VIRTUAL_PROMPT__": "" if self.flag_prompt is None else self.flag_prompt,
+            "__VIRTUAL_ENV__": str(creator.dest),
+            "__VIRTUAL_NAME__": creator.env_name,
+            "__BIN_NAME__": str(creator.bin_dir.relative_to(creator.dest)),
+            "__PATH_SEP__": os.pathsep,
+        }
+
+    def _generate(self, replacements, templates, to_folder, creator):
+        generated = []
+        for template in templates:
+            text = self.instantiate_template(replacements, template, creator)
+            dest = to_folder / self.as_name(template)
+            # remove the file if it already exists - this prevents permission
+            # errors when the dest is not writable
+            if dest.exists():
+                dest.unlink()
+            # Powershell assumes Windows 1252 encoding when reading files without BOM
+            encoding = "utf-8-sig" if str(template).endswith(".ps1") else "utf-8"
+            # use write_bytes to avoid platform specific line normalization (\n -> \r\n)
+            dest.write_bytes(text.encode(encoding))
+            generated.append(dest)
+        return generated
+
+    def as_name(self, template):
+        return template
+
+    def instantiate_template(self, replacements, template, creator):
+        # read content as binary to avoid platform specific line normalization (\n -> \r\n)
+        binary = read_binary(self.__module__, template)
+        text = binary.decode("utf-8", errors="strict")
+        for key, value in replacements.items():
+            value_uni = self._repr_unicode(creator, value)
+            text = text.replace(key, self.quote(value_uni))
+        return text
+
+    @staticmethod
+    def _repr_unicode(creator, value):  # noqa: ARG004
+        return value  # by default, we just let it be unicode
+
+
+__all__ = [
+    "ViaTemplateActivator",
+]

.venv/lib/python3.11/site-packages/virtualenv/app_data/__init__.py

@@ -0,0 +1,58 @@
+"""Application data stored by virtualenv."""
+
+from __future__ import annotations
+
+import logging
+import os
+
+from platformdirs import user_data_dir
+
+from .na import AppDataDisabled
+from .read_only import ReadOnlyAppData
+from .via_disk_folder import AppDataDiskFolder
+from .via_tempdir import TempAppData
+
+LOGGER = logging.getLogger(__name__)
+
+
+def _default_app_data_dir(env):
+    key = "VIRTUALENV_OVERRIDE_APP_DATA"
+    if key in env:
+        return env[key]
+    return user_data_dir(appname="virtualenv", appauthor="pypa")
+
+
+def make_app_data(folder, **kwargs):
+    is_read_only = kwargs.pop("read_only")
+    env = kwargs.pop("env")
+    if kwargs:  # py3+ kwonly
+        msg = "unexpected keywords: {}"
+        raise TypeError(msg)
+
+    if folder is None:
+        folder = _default_app_data_dir(env)
+    folder = os.path.abspath(folder)
+
+    if is_read_only:
+        return ReadOnlyAppData(folder)
+
+    if not os.path.isdir(folder):
+        try:
+            os.makedirs(folder)
+            LOGGER.debug("created app data folder %s", folder)
+        except OSError as exception:
+            LOGGER.info("could not create app data folder %s due to %r", folder, exception)
+
+    if os.access(folder, os.W_OK):
+        return AppDataDiskFolder(folder)
+    LOGGER.debug("app data folder %s has no write access", folder)
+    return TempAppData()
+
+
+__all__ = (
+    "AppDataDisabled",
+    "AppDataDiskFolder",
+    "ReadOnlyAppData",
+    "TempAppData",
+    "make_app_data",
+)