Add files using upload-large-folder tool

.gitattributes

@@ -4082,3 +4082,4 @@ tool_server/.venv/lib/python3.12/site-packages/nvidia/cusolver/lib/libcusolver.s
 tool_server/.venv/lib/python3.12/site-packages/nvidia/cusolver/lib/libcusolverMg.so.11 filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/httptools/parser/parser.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/httptools/parser/url_parser.cpython-312-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/dill/__pycache__/_dill.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

tool_server/.venv/lib/python3.12/site-packages/dill/__pycache__/_dill.cpython-312.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:073c8c67521dd43059935fb5278ddf889af845e97e8e8f4cc40a1704102c7123
+size 103684

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_module.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2025 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import sys
+import dill
+import test_mixins as module
+from importlib import reload
+dill.settings['recurse'] = True
+
+cached = (module.__cached__ if hasattr(module, "__cached__")
+          else module.__file__.split(".", 1)[0] + ".pyc")
+
+module.a = 1234
+
+pik_mod = dill.dumps(module)
+
+module.a = 0
+
+# remove module
+del sys.modules[module.__name__]
+del module
+
+module = dill.loads(pik_mod)
+def test_attributes():
+   #assert hasattr(module, "a") and module.a == 1234  #FIXME: -m dill.tests
+    assert module.double_add(1, 2, 3) == 2 * module.fx
+
+# Restart, and test use_diff
+
+reload(module)
+
+try:
+    dill.use_diff()
+
+    module.a = 1234
+
+    pik_mod = dill.dumps(module)
+
+    module.a = 0
+
+    # remove module
+    del sys.modules[module.__name__]
+    del module
+
+    module = dill.loads(pik_mod)
+    def test_diff_attributes():
+        assert hasattr(module, "a") and module.a == 1234
+        assert module.double_add(1, 2, 3) == 2 * module.fx
+
+except AttributeError:
+    def test_diff_attributes():
+        pass
+
+# clean up
+import os
+if os.path.exists(cached):
+    os.remove(cached)
+pycache = os.path.join(os.path.dirname(module.__file__), "__pycache__")
+if os.path.exists(pycache) and not os.listdir(pycache):
+    os.removedirs(pycache)
+
+
+# test when module is None
+import math
+
+def get_lambda(str, **kwarg):
+    return eval(str, kwarg, None)
+
+obj = get_lambda('lambda x: math.exp(x)', math=math)
+
+def test_module_is_none():
+    assert obj.__module__ is None
+    assert dill.copy(obj)(3) == obj(3)
+
+
+if __name__ == '__main__':
+    test_attributes()
+    test_diff_attributes()
+    test_module_is_none()

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_moduledict.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2025 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 f(func):
+  def w(*args):
+    return f(*args)
+  return w
+
+@f
+def f2(): pass
+
+# check when __main__ and on import
+def test_decorated():
+  assert dill.pickles(f2)
+
+
+import doctest
+import logging
+logging.basicConfig(level=logging.DEBUG)
+
+class SomeUnreferencedUnpicklableClass(object):
+    def __reduce__(self):
+        raise Exception
+
+unpicklable = SomeUnreferencedUnpicklableClass()
+
+# This works fine outside of Doctest:
+def test_normal():
+    serialized = dill.dumps(lambda x: x)
+
+# should not try to pickle unpicklable object in __globals__
+def tests():
+    """
+    >>> serialized = dill.dumps(lambda x: x)
+    """
+    return
+
+#print("\n\nRunning Doctest:")
+def test_doctest():
+    doctest.testmod()
+
+
+if __name__ == '__main__':
+    test_decorated()
+    test_normal()
+    test_doctest()

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_nested.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2025 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 handle nested functions
+"""
+
+import os
+import math
+
+import dill as pickle
+pickle.settings['recurse'] = True
+
+
+# the nested function: pickle should fail here, but dill is ok.
+def adder(augend):
+    zero = [0]
+
+    def inner(addend):
+        return addend + augend + zero[0]
+    return inner
+
+
+# rewrite the nested function using a class: standard pickle should work here.
+class cadder(object):
+    def __init__(self, augend):
+        self.augend = augend
+        self.zero = [0]
+
+    def __call__(self, addend):
+        return addend + self.augend + self.zero[0]
+
+
+# rewrite again, but as an old-style class
+class c2adder:
+    def __init__(self, augend):
+        self.augend = augend
+        self.zero = [0]
+
+    def __call__(self, addend):
+        return addend + self.augend + self.zero[0]
+
+
+# some basic class stuff
+class basic(object):
+    pass
+
+
+class basic2:
+    pass
+
+
+x = 5
+y = 1
+
+
+def test_basic():
+    a = [0, 1, 2]
+    pa = pickle.dumps(a)
+    pmath = pickle.dumps(math) #XXX: FAILS in pickle
+    pmap = pickle.dumps(map)
+    # ...
+    la = pickle.loads(pa)
+    lmath = pickle.loads(pmath)
+    lmap = pickle.loads(pmap)
+    assert list(map(math.sin, a)) == list(lmap(lmath.sin, la))
+
+
+def test_basic_class():
+    pbasic2 = pickle.dumps(basic2)
+    _pbasic2 = pickle.loads(pbasic2)()
+    pbasic = pickle.dumps(basic)
+    _pbasic = pickle.loads(pbasic)()
+
+
+def test_c2adder():
+    pc2adder = pickle.dumps(c2adder)
+    pc2add5 = pickle.loads(pc2adder)(x)
+    assert pc2add5(y) == x+y
+
+
+def test_pickled_cadder():
+    pcadder = pickle.dumps(cadder)
+    pcadd5 = pickle.loads(pcadder)(x)
+    assert pcadd5(y) == x+y
+
+
+def test_raw_adder_and_inner():
+    add5 = adder(x)
+    assert add5(y) == x+y
+
+
+def test_pickled_adder():
+    padder = pickle.dumps(adder)
+    padd5 = pickle.loads(padder)(x)
+    assert padd5(y) == x+y
+
+
+def test_pickled_inner():
+    add5 = adder(x)
+    pinner = pickle.dumps(add5) #XXX: FAILS in pickle
+    p5add = pickle.loads(pinner)
+    assert p5add(y) == x+y
+
+
+def test_moduledict_where_not_main():
+    try:
+        from . import test_moduledict
+    except ImportError:
+        import test_moduledict
+    name = 'test_moduledict.py'
+    if os.path.exists(name) and os.path.exists(name+'c'):
+        os.remove(name+'c')
+
+    if os.path.exists(name) and hasattr(test_moduledict, "__cached__") \
+       and os.path.exists(test_moduledict.__cached__):
+        os.remove(getattr(test_moduledict, "__cached__"))
+
+    if os.path.exists("__pycache__") and not os.listdir("__pycache__"):
+        os.removedirs("__pycache__")
+
+
+if __name__ == '__main__':
+    test_basic()
+    test_basic_class()
+    test_c2adder()
+    test_pickled_cadder()
+    test_raw_adder_and_inner()
+    test_pickled_adder()
+    test_pickled_inner()
+    test_moduledict_where_not_main()

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_objects.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2025 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+demonstrate dill's ability to pickle different python types
+test pickling of all Python Standard Library objects (currently: CH 1-14 @ 2.7)
+"""
+
+import dill as pickle
+pickle.settings['recurse'] = True
+#pickle.detect.trace(True)
+#import pickle
+
+# get all objects for testing
+from dill import load_types, objects, extend
+load_types(pickleable=True,unpickleable=False)
+
+# uncomment the next two lines to test cloudpickle
+#extend(False)
+#import cloudpickle as pickle
+
+# helper objects
+class _class:
+    def _method(self):
+        pass
+
+# objects that *fail* if imported
+special = {}
+special['LambdaType'] = _lambda = lambda x: lambda y: x
+special['MethodType'] = _method = _class()._method
+special['UnboundMethodType'] = _class._method
+objects.update(special)
+
+def pickles(name, exact=False, verbose=True):
+    """quick check if object pickles with dill"""
+    obj = objects[name]
+    try:
+        pik = pickle.loads(pickle.dumps(obj))
+        if exact:
+            try:
+                assert pik == obj
+            except AssertionError:
+                assert type(obj) == type(pik)
+                if verbose: print ("weak: %s %s" % (name, type(obj)))
+        else:
+            assert type(obj) == type(pik)
+    except Exception:
+        if verbose: print ("fails: %s %s" % (name, type(obj)))
+
+
+def test_objects(verbose=True):
+    for member in objects.keys():
+       #pickles(member, exact=True, verbose=verbose)
+        pickles(member, exact=False, verbose=verbose)
+
+if __name__ == '__main__':
+    import warnings
+    warnings.simplefilter('ignore')
+    test_objects(verbose=False)

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_properties.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2025 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import sys
+
+import dill
+dill.settings['recurse'] = True
+
+
+class Foo(object):
+    def __init__(self):
+        self._data = 1
+
+    def _get_data(self):
+        return self._data
+
+    def _set_data(self, x):
+        self._data = x
+
+    data = property(_get_data, _set_data)
+
+
+def test_data_not_none():
+    FooS = dill.copy(Foo)
+    assert FooS.data.fget is not None
+    assert FooS.data.fset is not None
+    assert FooS.data.fdel is None
+
+
+def test_data_unchanged():
+    FooS = dill.copy(Foo)
+    try:
+        res = FooS().data
+    except Exception:
+        e = sys.exc_info()[1]
+        raise AssertionError(str(e))
+    else:
+        assert res == 1
+
+
+def test_data_changed():
+    FooS = dill.copy(Foo)
+    try:
+        f = FooS()
+        f.data = 1024
+        res = f.data
+    except Exception:
+        e = sys.exc_info()[1]
+        raise AssertionError(str(e))
+    else:
+        assert res == 1024
+
+
+if __name__ == '__main__':
+    test_data_not_none()
+    test_data_unchanged()
+    test_data_changed()

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_pycapsule.py

@@ -0,0 +1,45 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Author: Anirudh Vegesana (avegesan@cs.stanford.edu)
+# Copyright (c) 2022-2025 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 PyCapsule object
+"""
+
+import dill
+import warnings
+
+test_pycapsule = None
+
+if dill._dill._testcapsule is not None:
+    import ctypes
+    def test_pycapsule():
+        name = ctypes.create_string_buffer(b'dill._testcapsule')
+        capsule = dill._dill._PyCapsule_New(
+            ctypes.cast(dill._dill._PyCapsule_New, ctypes.c_void_p),
+            name,
+            None
+        )
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            dill.copy(capsule)
+        dill._testcapsule = capsule
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            dill.copy(capsule)
+        dill._testcapsule = None
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore", dill.PicklingWarning)
+                dill.copy(capsule)
+        except dill.UnpicklingError:
+            pass
+        else:
+            raise AssertionError("Expected a different error")
+
+if __name__ == '__main__':
+    if test_pycapsule is not None:
+        test_pycapsule()

tool_server/.venv/lib/python3.12/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-2025 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()

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_registered.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2022-2025 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 registered objects
+"""
+
+import dill
+from dill._objects import failures, registered, succeeds
+import warnings
+warnings.filterwarnings('ignore')
+
+def check(d, ok=True):
+    res = []
+    for k,v in d.items():
+        try:
+            z = dill.copy(v)
+            if ok: res.append(k)
+        except:
+            if not ok: res.append(k)
+    return res
+
+fails = check(failures)
+try:
+    assert not bool(fails)
+except AssertionError as e:
+    print("FAILS: %s" % fails)
+    raise e from None
+
+register = check(registered, ok=False)
+try:
+    assert not bool(register)
+except AssertionError as e:
+    print("REGISTER: %s" % register)
+    raise e from None
+
+success = check(succeeds, ok=False)
+try:
+    assert not bool(success)
+except AssertionError as e:
+    print("SUCCESS: %s" % success)
+    raise e from None
+
+import builtins
+import types
+q = dill._dill._reverse_typemap
+p = {k:v for k,v in q.items() if k not in vars(builtins) and k not in vars(types)}
+
+diff = set(p.keys()).difference(registered.keys())
+try:
+    assert not bool(diff)
+except AssertionError as e:
+    print("DIFF: %s" % diff)
+    raise e from None
+
+miss = set(registered.keys()).difference(p.keys())
+try:
+    assert not bool(miss)
+except AssertionError as e:
+    print("MISS: %s" % miss)
+    raise e from None

tool_server/.venv/lib/python3.12/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-2025 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()

tool_server/.venv/lib/python3.12/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-2025 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()

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_session.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python
+
+# Author: Leonardo Gama (@leogama)
+# Copyright (c) 2022-2025 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import atexit
+import os
+import sys
+import __main__
+from contextlib import suppress
+from io import BytesIO
+
+import dill
+
+session_file = os.path.join(os.path.dirname(__file__), 'session-refimported-%s.pkl')
+
+###################
+#  Child process  #
+###################
+
+def _error_line(error, obj, refimported):
+    import traceback
+    line = traceback.format_exc().splitlines()[-2].replace('[obj]', '['+repr(obj)+']')
+    return "while testing (with refimported=%s):  %s" % (refimported, line.lstrip())
+
+if __name__ == '__main__' and len(sys.argv) >= 3 and sys.argv[1] == '--child':
+    # Test session loading in a fresh interpreter session.
+    refimported = (sys.argv[2] == 'True')
+    dill.load_module(session_file % refimported, module='__main__')
+
+    def test_modules(refimported):
+        # FIXME: In this test setting with CPython 3.7, 'calendar' is not included
+        # in sys.modules, independent of the value of refimported.  Tried to
+        # run garbage collection just before loading the session with no luck. It
+        # fails even when preceding them with 'import calendar'.  Needed to run
+        # these kinds of tests in a supbrocess. Failing test sample:
+        #   assert globals()['day_name'] is sys.modules['calendar'].__dict__['day_name']
+        try:
+            for obj in ('json', 'url', 'local_mod', 'sax', 'dom'):
+                assert globals()[obj].__name__ in sys.modules
+            assert 'calendar' in sys.modules and 'cmath' in sys.modules
+            import calendar, cmath
+
+            for obj in ('Calendar', 'isleap'):
+                assert globals()[obj] is sys.modules['calendar'].__dict__[obj]
+            assert __main__.day_name.__module__ == 'calendar'
+            if refimported:
+                assert __main__.day_name is calendar.day_name
+
+            assert __main__.complex_log is cmath.log
+
+        except AssertionError as error:
+            error.args = (_error_line(error, obj, refimported),)
+            raise
+
+    test_modules(refimported)
+    sys.exit()
+
+####################
+#  Parent process  #
+####################
+
+# Create various kinds of objects to test different internal logics.
+
+## Modules.
+import json                                         # top-level module
+import urllib as url                                # top-level module under alias
+from xml import sax                                 # submodule
+import xml.dom.minidom as dom                       # submodule under alias
+import test_dictviews as local_mod                  # non-builtin top-level module
+
+## Imported objects.
+from calendar import Calendar, isleap, day_name     # class, function, other object
+from cmath import log as complex_log                # imported with alias
+
+## Local objects.
+x = 17
+empty = None
+names = ['Alice', 'Bob', 'Carol']
+def squared(x): return x**2
+cubed = lambda x: x**3
+class Person:
+    def __init__(self, name, age):
+        self.name = name
+        self.age = age
+person = Person(names[0], x)
+class CalendarSubclass(Calendar):
+    def weekdays(self):
+        return [day_name[i] for i in self.iterweekdays()]
+cal = CalendarSubclass()
+selfref = __main__
+
+# Setup global namespace for session saving tests.
+class TestNamespace:
+    test_globals = globals().copy()
+    def __init__(self, **extra):
+        self.extra = extra
+    def __enter__(self):
+        self.backup = globals().copy()
+        globals().clear()
+        globals().update(self.test_globals)
+        globals().update(self.extra)
+        return self
+    def __exit__(self, *exc_info):
+        globals().clear()
+        globals().update(self.backup)
+
+def _clean_up_cache(module):
+    cached = module.__file__.split('.', 1)[0] + '.pyc'
+    cached = module.__cached__ if hasattr(module, '__cached__') else cached
+    pycache = os.path.join(os.path.dirname(module.__file__), '__pycache__')
+    for remove, file in [(os.remove, cached), (os.removedirs, pycache)]:
+        with suppress(OSError):
+            remove(file)
+
+atexit.register(_clean_up_cache, local_mod)
+
+def _test_objects(main, globals_copy, refimported):
+    try:
+        main_dict = __main__.__dict__
+        global Person, person, Calendar, CalendarSubclass, cal, selfref
+
+        for obj in ('json', 'url', 'local_mod', 'sax', 'dom'):
+            assert globals()[obj].__name__ == globals_copy[obj].__name__
+
+        for obj in ('x', 'empty', 'names'):
+            assert main_dict[obj] == globals_copy[obj]
+
+        for obj in ['squared', 'cubed']:
+            assert main_dict[obj].__globals__ is main_dict
+            assert main_dict[obj](3) == globals_copy[obj](3)
+
+        assert Person.__module__ == __main__.__name__
+        assert isinstance(person, Person)
+        assert person.age == globals_copy['person'].age
+
+        assert issubclass(CalendarSubclass, Calendar)
+        assert isinstance(cal, CalendarSubclass)
+        assert cal.weekdays() == globals_copy['cal'].weekdays()
+
+        assert selfref is __main__
+
+    except AssertionError as error:
+        error.args = (_error_line(error, obj, refimported),)
+        raise
+
+def test_session_main(refimported):
+    """test dump/load_module() for __main__, both in this process and in a subprocess"""
+    extra_objects = {}
+    if refimported:
+        # Test unpickleable imported object in main.
+        from sys import flags
+        extra_objects['flags'] = flags
+
+    with TestNamespace(**extra_objects) as ns:
+        try:
+            # Test session loading in a new session.
+            dill.dump_module(session_file % refimported, refimported=refimported)
+            from dill.tests.__main__ import python, shell, sp
+            error = sp.call([python, __file__, '--child', str(refimported)], shell=shell)
+            if error: sys.exit(error)
+        finally:
+            with suppress(OSError):
+                os.remove(session_file % refimported)
+
+        # Test session loading in the same session.
+        session_buffer = BytesIO()
+        dill.dump_module(session_buffer, refimported=refimported)
+        session_buffer.seek(0)
+        dill.load_module(session_buffer, module='__main__')
+        ns.backup['_test_objects'](__main__, ns.backup, refimported)
+
+def test_session_other():
+    """test dump/load_module() for a module other than __main__"""
+    import test_classdef as module
+    atexit.register(_clean_up_cache, module)
+    module.selfref = module
+    dict_objects = [obj for obj in module.__dict__.keys() if not obj.startswith('__')]
+
+    session_buffer = BytesIO()
+    dill.dump_module(session_buffer, module)
+
+    for obj in dict_objects:
+        del module.__dict__[obj]
+
+    session_buffer.seek(0)
+    dill.load_module(session_buffer, module)
+
+    assert all(obj in module.__dict__ for obj in dict_objects)
+    assert module.selfref is module
+
+def test_runtime_module():
+    from types import ModuleType
+    modname = '__runtime__'
+    runtime = ModuleType(modname)
+    runtime.x = 42
+
+    mod = dill.session._stash_modules(runtime)
+    if mod is not runtime:
+        print("There are objects to save by referenece that shouldn't be:",
+              mod.__dill_imported, mod.__dill_imported_as, mod.__dill_imported_top_level,
+              file=sys.stderr)
+
+    # This is also for code coverage, tests the use case of dump_module(refimported=True)
+    # without imported objects in the namespace. It's a contrived example because
+    # even dill can't be in it.  This should work after fixing #462.
+    session_buffer = BytesIO()
+    dill.dump_module(session_buffer, module=runtime, refimported=True)
+    session_dump = session_buffer.getvalue()
+
+    # Pass a new runtime created module with the same name.
+    runtime = ModuleType(modname)  # empty
+    return_val = dill.load_module(BytesIO(session_dump), module=runtime)
+    assert return_val is None
+    assert runtime.__name__ == modname
+    assert runtime.x == 42
+    assert runtime not in sys.modules.values()
+
+    # Pass nothing as main.  load_module() must create it.
+    session_buffer.seek(0)
+    runtime = dill.load_module(BytesIO(session_dump))
+    assert runtime.__name__ == modname
+    assert runtime.x == 42
+    assert runtime not in sys.modules.values()
+
+def test_refimported_imported_as():
+    import collections
+    import concurrent.futures
+    import types
+    import typing
+    mod = sys.modules['__test__'] = types.ModuleType('__test__')
+    dill.executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
+    mod.Dict = collections.UserDict             # select by type
+    mod.AsyncCM = typing.AsyncContextManager    # select by __module__
+    mod.thread_exec = dill.executor             # select by __module__ with regex
+
+    session_buffer = BytesIO()
+    dill.dump_module(session_buffer, mod, refimported=True)
+    session_buffer.seek(0)
+    mod = dill.load(session_buffer)
+    del sys.modules['__test__']
+
+    assert set(mod.__dill_imported_as) == {
+        ('collections', 'UserDict', 'Dict'),
+        ('typing', 'AsyncContextManager', 'AsyncCM'),
+        ('dill', 'executor', 'thread_exec'),
+    }
+
+def test_load_module_asdict():
+    with TestNamespace():
+        session_buffer = BytesIO()
+        dill.dump_module(session_buffer)
+
+        global empty, names, x, y
+        x = y = 0  # change x and create y
+        del empty
+        globals_state = globals().copy()
+
+        session_buffer.seek(0)
+        main_vars = dill.load_module_asdict(session_buffer)
+
+        assert main_vars is not globals()
+        assert globals() == globals_state
+
+        assert main_vars['__name__'] == '__main__'
+        assert main_vars['names'] == names
+        assert main_vars['names'] is not names
+        assert main_vars['x'] != x
+        assert 'y' not in main_vars
+        assert 'empty' in main_vars
+
+if __name__ == '__main__':
+    test_session_main(refimported=False)
+    test_session_main(refimported=True)
+    test_session_other()
+    test_runtime_module()
+    test_refimported_imported_as()
+    test_load_module_asdict()

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_source.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2025 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+from dill.source import getsource, getname, _wrap, getimport
+from dill.source import importable
+from dill._dill import IS_PYPY
+
+import sys
+PY310b = 0x30a00b1
+
+f = lambda x: x**2
+def g(x): return f(x) - x
+
+def h(x):
+  def g(x): return x
+  return g(x) - x
+
+class Foo(object):
+  def bar(self, x):
+    return x*x+x
+_foo = Foo()
+
+def add(x,y):
+  return x+y
+
+# yes, same as 'f', but things are tricky when it comes to pointers
+squared = lambda x:x**2
+
+class Bar:
+  pass
+_bar = Bar()
+
+                       # inspect.getsourcelines # dill.source.getblocks
+def test_getsource():
+  assert getsource(f) == 'f = lambda x: x**2\n'
+  assert getsource(g) == 'def g(x): return f(x) - x\n'
+  assert getsource(h) == 'def h(x):\n  def g(x): return x\n  return g(x) - x\n'
+  assert getname(f) == 'f'
+  assert getname(g) == 'g'
+  assert getname(h) == 'h'
+  assert _wrap(f)(4) == 16
+  assert _wrap(g)(4) == 12
+  assert _wrap(h)(4) == 0
+
+  assert getname(Foo) == 'Foo'
+  assert getname(Bar) == 'Bar'
+  assert getsource(Bar) == 'class Bar:\n  pass\n'
+  assert getsource(Foo) == 'class Foo(object):\n  def bar(self, x):\n    return x*x+x\n'
+  #XXX: add getsource for  _foo, _bar
+
+# test itself
+def test_itself():
+  assert getimport(getimport)=='from dill.source import getimport\n'
+
+# builtin functions and objects
+def test_builtin():
+  assert getimport(pow) == 'pow\n'
+  assert getimport(100) == '100\n'
+  assert getimport(True) == 'True\n'
+  assert getimport(pow, builtin=True) == 'from builtins import pow\n'
+  assert getimport(100, builtin=True) == '100\n'
+  assert getimport(True, builtin=True) == 'True\n'
+  # this is kinda BS... you can't import a None
+  assert getimport(None) == 'None\n'
+  assert getimport(None, builtin=True) == 'None\n'
+
+
+# other imported functions
+def test_imported():
+  from math import sin
+  assert getimport(sin) == 'from math import sin\n'
+
+# interactively defined functions
+def test_dynamic():
+  assert getimport(add) == 'from %s import add\n' % __name__
+  # interactive lambdas
+  assert getimport(squared) == 'from %s import squared\n' % __name__
+
+# classes and class instances
+def test_classes():
+  from io import BytesIO as StringIO
+  y = "from _io import BytesIO\n"
+  x = y if (IS_PYPY or sys.hexversion >= PY310b) else "from io import BytesIO\n"
+  s = StringIO()
+
+  assert getimport(StringIO) == x
+  assert getimport(s) == y
+  # interactively defined classes and class instances
+  assert getimport(Foo) == 'from %s import Foo\n' % __name__
+  assert getimport(_foo) == 'from %s import Foo\n' % __name__
+
+
+# test importable
+def test_importable():
+  assert importable(add, source=False) == 'from %s import add\n' % __name__
+  assert importable(squared, source=False) == 'from %s import squared\n' % __name__
+  assert importable(Foo, source=False) == 'from %s import Foo\n' % __name__
+  assert importable(Foo.bar, source=False) == 'from %s import bar\n' % __name__
+  assert importable(_foo.bar, source=False) == 'from %s import bar\n' % __name__
+  assert importable(None, source=False) == 'None\n'
+  assert importable(100, source=False) == '100\n'
+
+  assert importable(add, source=True) == 'def add(x,y):\n  return x+y\n'
+  assert importable(squared, source=True) == 'squared = lambda x:x**2\n'
+  assert importable(None, source=True) == 'None\n'
+  assert importable(Bar, source=True) == 'class Bar:\n  pass\n'
+  assert importable(Foo, source=True) == 'class Foo(object):\n  def bar(self, x):\n    return x*x+x\n'
+  assert importable(Foo.bar, source=True) == 'def bar(self, x):\n  return x*x+x\n'
+  assert importable(Foo.bar, source=False) == 'from %s import bar\n' % __name__
+  assert importable(Foo.bar, alias='memo', source=False) == 'from %s import bar as memo\n' % __name__
+  assert importable(Foo, alias='memo', source=False) == 'from %s import Foo as memo\n' % __name__
+  assert importable(squared, alias='memo', source=False) == 'from %s import squared as memo\n' % __name__
+  assert importable(squared, alias='memo', source=True) == 'memo = squared = lambda x:x**2\n'
+  assert importable(add, alias='memo', source=True) == 'def add(x,y):\n  return x+y\n\nmemo = add\n'
+  assert importable(None, alias='memo', source=True) == 'memo = None\n'
+  assert importable(100, alias='memo', source=True) == 'memo = 100\n'
+  assert importable(add, builtin=True, source=False) == 'from %s import add\n' % __name__
+  assert importable(squared, builtin=True, source=False) == 'from %s import squared\n' % __name__
+  assert importable(Foo, builtin=True, source=False) == 'from %s import Foo\n' % __name__
+  assert importable(Foo.bar, builtin=True, source=False) == 'from %s import bar\n' % __name__
+  assert importable(_foo.bar, builtin=True, source=False) == 'from %s import bar\n' % __name__
+  assert importable(None, builtin=True, source=False) == 'None\n'
+  assert importable(100, builtin=True, source=False) == '100\n'
+
+
+def test_numpy():
+  try:
+    import numpy as np
+    y = np.array
+    x = y([1,2,3])
+    assert importable(x, source=False) == 'from numpy import array\narray([1, 2, 3])\n'
+    assert importable(y, source=False) == 'from %s import array\n' % y.__module__
+    assert importable(x, source=True) == 'from numpy import array\narray([1, 2, 3])\n'
+    assert importable(y, source=True) == 'from %s import array\n' % y.__module__
+    y = np.int64
+    x = y(0)
+    assert importable(x, source=False) == 'from numpy import int64\nint64(0)\n'
+    assert importable(y, source=False) == 'from %s import int64\n' % y.__module__
+    assert importable(x, source=True) == 'from numpy import int64\nint64(0)\n'
+    assert importable(y, source=True) == 'from %s import int64\n' % y.__module__
+    y = np.bool_
+    x = y(0)
+    import warnings
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', category=FutureWarning)
+        warnings.filterwarnings('ignore', category=DeprecationWarning)
+        if hasattr(np, 'bool'): b = 'bool_' if np.bool is bool else 'bool'
+        else: b = 'bool_'
+    assert importable(x, source=False) == 'from numpy import %s\n%s(False)\n' % (b,b)
+    assert importable(y, source=False) == 'from %s import %s\n' % (y.__module__,b)
+    assert importable(x, source=True) == 'from numpy import %s\n%s(False)\n' % (b,b)
+    assert importable(y, source=True) == 'from %s import %s\n' % (y.__module__,b)
+  except ImportError: pass
+
+#NOTE: if before getimport(pow), will cause pow to throw AssertionError
+def test_foo():
+  assert importable(_foo, source=True).startswith("import dill\nclass Foo(object):\n  def bar(self, x):\n    return x*x+x\ndill.loads(")
+
+if __name__ == '__main__':
+    test_getsource()
+    test_itself()
+    test_builtin()
+    test_imported()
+    test_dynamic()
+    test_classes()
+    test_importable()
+    test_numpy()
+    test_foo()

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_sources.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @uqfoundation)
+# Copyright (c) 2024-2025 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+check that dill.source performs as expected with changes to locals in 3.13.0b1
+see: https://github.com/python/cpython/issues/118888
+"""
+# repeat functions from test_source.py
+f = lambda x: x**2
+def g(x): return f(x) - x
+
+def h(x):
+  def g(x): return x
+  return g(x) - x
+
+class Foo(object):
+  def bar(self, x):
+    return x*x+x
+_foo = Foo()
+
+def add(x,y):
+  return x+y
+
+squared = lambda x:x**2
+
+class Bar:
+  pass
+_bar = Bar()
+
+# repeat, but from test_source.py
+import test_source as ts
+
+# test objects created in other test modules
+import test_mixins as tm
+
+import dill.source as ds
+
+
+def test_isfrommain():
+  assert ds.isfrommain(add) == True
+  assert ds.isfrommain(squared) == True
+  assert ds.isfrommain(Bar) == True
+  assert ds.isfrommain(_bar) == True
+  assert ds.isfrommain(ts.add) == False
+  assert ds.isfrommain(ts.squared) == False
+  assert ds.isfrommain(ts.Bar) == False
+  assert ds.isfrommain(ts._bar) == False
+  assert ds.isfrommain(tm.quad) == False
+  assert ds.isfrommain(tm.double_add) == False
+  assert ds.isfrommain(tm.quadratic) == False
+  assert ds.isdynamic(add) == False
+  assert ds.isdynamic(squared) == False
+  assert ds.isdynamic(ts.add) == False
+  assert ds.isdynamic(ts.squared) == False
+  assert ds.isdynamic(tm.double_add) == False
+  assert ds.isdynamic(tm.quadratic) == False
+
+
+def test_matchlambda():
+  assert ds._matchlambda(f, 'f = lambda x: x**2\n')
+  assert ds._matchlambda(squared, 'squared = lambda x:x**2\n')
+  assert ds._matchlambda(ts.f, 'f = lambda x: x**2\n')
+  assert ds._matchlambda(ts.squared, 'squared = lambda x:x**2\n')
+
+
+def test_findsource():
+  lines, lineno = ds.findsource(add)
+  assert lines[lineno] == 'def add(x,y):\n'
+  lines, lineno = ds.findsource(ts.add)
+  assert lines[lineno] == 'def add(x,y):\n'
+  lines, lineno = ds.findsource(squared)
+  assert lines[lineno] == 'squared = lambda x:x**2\n'
+  lines, lineno = ds.findsource(ts.squared)
+  assert lines[lineno] == 'squared = lambda x:x**2\n'
+  lines, lineno = ds.findsource(Bar)
+  assert lines[lineno] == 'class Bar:\n'
+  lines, lineno = ds.findsource(ts.Bar)
+  assert lines[lineno] == 'class Bar:\n'
+  lines, lineno = ds.findsource(_bar)
+  assert lines[lineno] == 'class Bar:\n'
+  lines, lineno = ds.findsource(ts._bar)
+  assert lines[lineno] == 'class Bar:\n'
+  lines, lineno = ds.findsource(tm.quad)
+  assert lines[lineno] == 'def quad(a=1, b=1, c=0):\n'
+  lines, lineno = ds.findsource(tm.double_add)
+  assert lines[lineno] == '    def func(*args, **kwds):\n'
+  lines, lineno = ds.findsource(tm.quadratic)
+  assert lines[lineno] == '  def dec(f):\n'
+
+
+def test_getsourcelines():
+  assert ''.join(ds.getsourcelines(add)[0]) == 'def add(x,y):\n  return x+y\n'
+  assert ''.join(ds.getsourcelines(ts.add)[0]) == 'def add(x,y):\n  return x+y\n'
+  assert ''.join(ds.getsourcelines(squared)[0]) == 'squared = lambda x:x**2\n'
+  assert ''.join(ds.getsourcelines(ts.squared)[0]) == 'squared = lambda x:x**2\n'
+  assert ''.join(ds.getsourcelines(Bar)[0]) == 'class Bar:\n  pass\n'
+  assert ''.join(ds.getsourcelines(ts.Bar)[0]) == 'class Bar:\n  pass\n'
+  assert ''.join(ds.getsourcelines(_bar)[0]) == 'class Bar:\n  pass\n' #XXX: ?
+  assert ''.join(ds.getsourcelines(ts._bar)[0]) == 'class Bar:\n  pass\n' #XXX: ?
+  assert ''.join(ds.getsourcelines(tm.quad)[0]) == 'def quad(a=1, b=1, c=0):\n  inverted = [False]\n  def invert():\n    inverted[0] = not inverted[0]\n  def dec(f):\n    def func(*args, **kwds):\n      x = f(*args, **kwds)\n      if inverted[0]: x = -x\n      return a*x**2 + b*x + c\n    func.__wrapped__ = f\n    func.invert = invert\n    func.inverted = inverted\n    return func\n  return dec\n'
+  assert ''.join(ds.getsourcelines(tm.quadratic)[0]) == '  def dec(f):\n    def func(*args,**kwds):\n      fx = f(*args,**kwds)\n      return a*fx**2 + b*fx + c\n    return func\n'
+  assert ''.join(ds.getsourcelines(tm.quadratic, lstrip=True)[0]) == 'def dec(f):\n  def func(*args,**kwds):\n    fx = f(*args,**kwds)\n    return a*fx**2 + b*fx + c\n  return func\n'
+  assert ''.join(ds.getsourcelines(tm.quadratic, enclosing=True)[0]) == 'def quad_factory(a=1,b=1,c=0):\n  def dec(f):\n    def func(*args,**kwds):\n      fx = f(*args,**kwds)\n      return a*fx**2 + b*fx + c\n    return func\n  return dec\n'
+  assert ''.join(ds.getsourcelines(tm.double_add)[0]) == '    def func(*args, **kwds):\n      x = f(*args, **kwds)\n      if inverted[0]: x = -x\n      return a*x**2 + b*x + c\n'
+  assert ''.join(ds.getsourcelines(tm.double_add, enclosing=True)[0]) == 'def quad(a=1, b=1, c=0):\n  inverted = [False]\n  def invert():\n    inverted[0] = not inverted[0]\n  def dec(f):\n    def func(*args, **kwds):\n      x = f(*args, **kwds)\n      if inverted[0]: x = -x\n      return a*x**2 + b*x + c\n    func.__wrapped__ = f\n    func.invert = invert\n    func.inverted = inverted\n    return func\n  return dec\n'
+
+
+def test_indent():
+  assert ds.outdent(''.join(ds.getsourcelines(tm.quadratic)[0])) == ''.join(ds.getsourcelines(tm.quadratic, lstrip=True)[0])
+  assert ds.indent(''.join(ds.getsourcelines(tm.quadratic, lstrip=True)[0]), 2) == ''.join(ds.getsourcelines(tm.quadratic)[0])
+
+
+def test_dumpsource():
+  local = {}
+  exec(ds.dumpsource(add, alias='raw'), {}, local)
+  exec(ds.dumpsource(ts.add, alias='mod'), {}, local)
+  assert local['raw'](1,2) == local['mod'](1,2)
+  exec(ds.dumpsource(squared, alias='raw'), {}, local)
+  exec(ds.dumpsource(ts.squared, alias='mod'), {}, local)
+  assert local['raw'](3) == local['mod'](3)
+  assert ds._wrap(add)(1,2) == ds._wrap(ts.add)(1,2)
+  assert ds._wrap(squared)(3) == ds._wrap(ts.squared)(3)
+
+
+def test_name():
+  assert ds._namespace(add) == ds.getname(add, fqn=True).split('.')
+  assert ds._namespace(ts.add) == ds.getname(ts.add, fqn=True).split('.')
+  assert ds._namespace(squared) == ds.getname(squared, fqn=True).split('.')
+  assert ds._namespace(ts.squared) == ds.getname(ts.squared, fqn=True).split('.')
+  assert ds._namespace(Bar) == ds.getname(Bar, fqn=True).split('.')
+  assert ds._namespace(ts.Bar) == ds.getname(ts.Bar, fqn=True).split('.')
+  assert ds._namespace(tm.quad) == ds.getname(tm.quad, fqn=True).split('.')
+  #XXX: the following also works, however behavior may be wrong for nested functions
+  #assert ds._namespace(tm.double_add) == ds.getname(tm.double_add, fqn=True).split('.')
+  #assert ds._namespace(tm.quadratic) == ds.getname(tm.quadratic, fqn=True).split('.')
+  assert ds.getname(add) == 'add'
+  assert ds.getname(ts.add) == 'add'
+  assert ds.getname(squared) == 'squared'
+  assert ds.getname(ts.squared) == 'squared'
+  assert ds.getname(Bar) == 'Bar'
+  assert ds.getname(ts.Bar) == 'Bar'
+  assert ds.getname(tm.quad) == 'quad'
+  assert ds.getname(tm.double_add) == 'func' #XXX: ?
+  assert ds.getname(tm.quadratic) == 'dec' #XXX: ?
+
+
+def test_getimport():
+  local = {}
+  exec(ds.getimport(add, alias='raw'), {}, local)
+  exec(ds.getimport(ts.add, alias='mod'), {}, local)
+  assert local['raw'](1,2) == local['mod'](1,2)
+  exec(ds.getimport(squared, alias='raw'), {}, local)
+  exec(ds.getimport(ts.squared, alias='mod'), {}, local)
+  assert local['raw'](3) == local['mod'](3)
+  exec(ds.getimport(Bar, alias='raw'), {}, local)
+  exec(ds.getimport(ts.Bar, alias='mod'), {}, local)
+  assert ds.getname(local['raw']) == ds.getname(local['mod'])
+  exec(ds.getimport(tm.quad, alias='mod'), {}, local)
+  assert local['mod']()(sum)([1,2,3]) == tm.quad()(sum)([1,2,3])
+  #FIXME: wrong results for nested functions (e.g. tm.double_add, tm.quadratic)
+
+
+def test_importable():
+  assert ds.importable(add, source=False) == ds.getimport(add)
+  assert ds.importable(add) == ds.getsource(add)
+  assert ds.importable(squared, source=False) == ds.getimport(squared)
+  assert ds.importable(squared) == ds.getsource(squared)
+  assert ds.importable(Bar, source=False) == ds.getimport(Bar)
+  assert ds.importable(Bar) == ds.getsource(Bar)
+  assert ds.importable(ts.add) == ds.getimport(ts.add)
+  assert ds.importable(ts.add, source=True) == ds.getsource(ts.add)
+  assert ds.importable(ts.squared) == ds.getimport(ts.squared)
+  assert ds.importable(ts.squared, source=True) == ds.getsource(ts.squared)
+  assert ds.importable(ts.Bar) == ds.getimport(ts.Bar)
+  assert ds.importable(ts.Bar, source=True) == ds.getsource(ts.Bar)
+
+
+if __name__ == '__main__':
+  test_isfrommain()
+  test_matchlambda()
+  test_findsource()
+  test_getsourcelines()
+  test_indent()
+  test_dumpsource()
+  test_name()
+  test_getimport()
+  test_importable()

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_temp.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2025 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import sys
+from dill.temp import dump, dump_source, dumpIO, dumpIO_source
+from dill.temp import load, load_source, loadIO, loadIO_source
+WINDOWS = sys.platform[:3] == 'win'
+
+
+f = lambda x: x**2
+x = [1,2,3,4,5]
+
+# source code to tempfile
+def test_code_to_tempfile():
+    if not WINDOWS:  #see: https://bugs.python.org/issue14243
+        pyfile = dump_source(f, alias='_f')
+        _f = load_source(pyfile)
+        assert _f(4) == f(4)
+
+# source code to stream
+def test_code_to_stream():
+    pyfile = dumpIO_source(f, alias='_f')
+    _f = loadIO_source(pyfile)
+    assert _f(4) == f(4)
+
+# pickle to tempfile
+def test_pickle_to_tempfile():
+    if not WINDOWS:  #see: https://bugs.python.org/issue14243
+        dumpfile = dump(x)
+        _x = load(dumpfile)
+        assert _x == x
+
+# pickle to stream
+def test_pickle_to_stream():
+    dumpfile = dumpIO(x)
+    _x = loadIO(dumpfile)
+    assert _x == x
+
+### now testing the objects ###
+f = lambda x: x**2
+def g(x): return f(x) - x
+
+def h(x):
+  def g(x): return x
+  return g(x) - x 
+
+class Foo(object):
+  def bar(self, x):
+    return x*x+x
+_foo = Foo()
+
+def add(x,y):
+  return x+y
+
+# yes, same as 'f', but things are tricky when it comes to pointers
+squared = lambda x:x**2
+
+class Bar:
+  pass
+_bar = Bar()
+
+
+# test function-type objects that take 2 args
+def test_two_arg_functions():
+  for obj in [add]:
+    pyfile = dumpIO_source(obj, alias='_obj')
+    _obj = loadIO_source(pyfile)
+    assert _obj(4,2) == obj(4,2)
+
+# test function-type objects that take 1 arg
+def test_one_arg_functions():
+  for obj in [g, h, squared]:
+    pyfile = dumpIO_source(obj, alias='_obj')
+    _obj = loadIO_source(pyfile)
+    assert _obj(4) == obj(4)
+
+# test instance-type objects
+#for obj in [_bar, _foo]:
+#  pyfile = dumpIO_source(obj, alias='_obj')
+#  _obj = loadIO_source(pyfile)
+#  assert type(_obj) == type(obj)
+
+# test the rest of the objects
+def test_the_rest():
+  for obj in [Bar, Foo, Foo.bar, _foo.bar]:
+    pyfile = dumpIO_source(obj, alias='_obj')
+    _obj = loadIO_source(pyfile)
+    assert _obj.__name__ == obj.__name__
+
+
+if __name__ == '__main__':
+    test_code_to_tempfile()
+    test_code_to_stream()
+    test_pickle_to_tempfile()
+    test_pickle_to_stream()
+    test_two_arg_functions()
+    test_one_arg_functions()
+    test_the_rest()

tool_server/.venv/lib/python3.12/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-2025 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()