Add files using upload-large-folder tool

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

@@ -0,0 +1,22 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2018-2025 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  
+
+"""

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

@@ -0,0 +1,35 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2018-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 glob
+import os
+import sys
+import subprocess as sp
+python = sys.executable
+try:
+    import pox
+    python = pox.which_python(version=True) or python
+except ImportError:
+    pass
+shell = sys.platform[:3] == 'win'
+
+suite = os.path.dirname(__file__) or os.path.curdir
+tests = glob.glob(suite + os.path.sep + 'test_*.py')
+
+
+if __name__ == '__main__':
+
+    failed = 0
+    for test in tests:
+        p = sp.Popen([python, test], shell=shell).wait()
+        if p:
+            print('F', end='', flush=True)
+            failed = 1
+        else:
+            print('.', end='', flush=True)
+    print('')
+    exit(failed)

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

tool_server/.venv/lib/python3.12/site-packages/dill/tests/test_check.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
+
+from dill import check
+import sys
+
+from dill.temp import capture
+
+
+#FIXME: this doesn't catch output... it's from the internal call
+def raise_check(func, **kwds):
+    try:
+        with capture('stdout') as out:
+            check(func, **kwds)
+    except Exception:
+        e = sys.exc_info()[1]
+        raise AssertionError(str(e))
+    else:
+        assert 'Traceback' not in out.getvalue()
+    finally:
+        out.close()
+
+
+f = lambda x:x**2
+
+
+def test_simple(verbose=None):
+    raise_check(f, verbose=verbose)
+
+
+def test_recurse(verbose=None):
+    raise_check(f, recurse=True, verbose=verbose)
+
+
+def test_byref(verbose=None):
+    raise_check(f, byref=True, verbose=verbose)
+
+
+def test_protocol(verbose=None):
+    raise_check(f, protocol=True, verbose=verbose)
+
+
+def test_python(verbose=None):
+    raise_check(f, python=None, verbose=verbose)
+
+
+#TODO: test incompatible versions
+#TODO: test dump failure
+#TODO: test load failure
+
+
+if __name__ == '__main__':
+    test_simple()
+    test_recurse()
+    test_byref()
+    test_protocol()
+    test_python()

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

@@ -0,0 +1,340 @@
+#!/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
+from enum import EnumMeta
+import sys
+dill.settings['recurse'] = True
+
+# test classdefs
+class _class:
+    def _method(self):
+        pass
+    def ok(self):
+        return True
+
+class _class2:
+    def __call__(self):
+        pass
+    def ok(self):
+        return True
+
+class _newclass(object):
+    def _method(self):
+        pass
+    def ok(self):
+        return True
+
+class _newclass2(object):
+    def __call__(self):
+        pass
+    def ok(self):
+        return True
+
+class _meta(type):
+    pass
+
+def __call__(self):
+    pass
+def ok(self):
+    return True
+
+_mclass = _meta("_mclass", (object,), {"__call__": __call__, "ok": ok})
+
+del __call__
+del ok
+
+o = _class()
+oc = _class2()
+n = _newclass()
+nc = _newclass2()
+m = _mclass()
+
+if sys.hexversion < 0x03090000:
+    import typing
+    class customIntList(typing.List[int]):
+        pass
+else:
+    class customIntList(list[int]):
+        pass
+
+# test pickles for class instances
+def test_class_instances():
+    assert dill.pickles(o)
+    assert dill.pickles(oc)
+    assert dill.pickles(n)
+    assert dill.pickles(nc)
+    assert dill.pickles(m)
+
+def test_class_objects():
+    clslist = [_class,_class2,_newclass,_newclass2,_mclass]
+    objlist = [o,oc,n,nc,m]
+    _clslist = [dill.dumps(obj) for obj in clslist]
+    _objlist = [dill.dumps(obj) for obj in objlist]
+
+    for obj in clslist:
+        globals().pop(obj.__name__)
+    del clslist
+    for obj in ['o','oc','n','nc']:
+        globals().pop(obj)
+    del objlist
+    del obj
+
+    for obj,cls in zip(_objlist,_clslist):
+        _cls = dill.loads(cls)
+        _obj = dill.loads(obj)
+        assert _obj.ok()
+        assert _cls.ok(_cls())
+        if _cls.__name__ == "_mclass":
+            assert type(_cls).__name__ == "_meta"
+
+# test NoneType
+def test_specialtypes():
+    assert dill.pickles(type(None))
+    assert dill.pickles(type(NotImplemented))
+    assert dill.pickles(type(Ellipsis))
+    assert dill.pickles(type(EnumMeta))
+
+from collections import namedtuple
+Z = namedtuple("Z", ['a','b'])
+Zi = Z(0,1)
+X = namedtuple("Y", ['a','b'])
+X.__name__ = "X"
+X.__qualname__ = "X" #XXX: name must 'match' or fails to pickle
+Xi = X(0,1)
+Bad = namedtuple("FakeName", ['a','b'])
+Badi = Bad(0,1)
+Defaults = namedtuple('Defaults', ['x', 'y'], defaults=[1])
+Defaultsi = Defaults(2)
+
+# test namedtuple
+def test_namedtuple():
+    assert Z is dill.loads(dill.dumps(Z))
+    assert Zi == dill.loads(dill.dumps(Zi))
+    assert X is dill.loads(dill.dumps(X))
+    assert Xi == dill.loads(dill.dumps(Xi))
+    assert Defaults is dill.loads(dill.dumps(Defaults))
+    assert Defaultsi == dill.loads(dill.dumps(Defaultsi))
+    assert Bad is not dill.loads(dill.dumps(Bad))
+    assert Bad._fields == dill.loads(dill.dumps(Bad))._fields
+    assert tuple(Badi) == tuple(dill.loads(dill.dumps(Badi)))
+
+    class A:
+        class B(namedtuple("C", ["one", "two"])):
+            '''docstring'''
+        B.__module__ = 'testing'
+
+    a = A()
+    assert dill.copy(a)
+
+    assert dill.copy(A.B).__name__ == 'B'
+    assert dill.copy(A.B).__qualname__.endswith('.<locals>.A.B')
+    assert dill.copy(A.B).__doc__ == 'docstring'
+    assert dill.copy(A.B).__module__ == 'testing'
+
+    from typing import NamedTuple
+
+    def A():
+        class B(NamedTuple):
+            x: int
+        return B
+
+    assert type(dill.copy(A()(8))).__qualname__ == type(A()(8)).__qualname__
+
+def test_dtype():
+    try:
+        import numpy as np
+
+        dti = np.dtype('int')
+        assert np.dtype == dill.copy(np.dtype)
+        assert dti == dill.copy(dti)
+    except ImportError: pass
+
+
+def test_array_nested():
+    try:
+        import numpy as np
+
+        x = np.array([1])
+        y = (x,)
+        assert y == dill.copy(y)
+
+    except ImportError: pass
+
+
+def test_array_subclass():
+    try:
+        import numpy as np
+
+        class TestArray(np.ndarray):
+            def __new__(cls, input_array, color):
+                obj = np.asarray(input_array).view(cls)
+                obj.color = color
+                return obj
+            def __array_finalize__(self, obj):
+                if obj is None:
+                    return
+                if isinstance(obj, type(self)):
+                    self.color = obj.color
+            def __getnewargs__(self):
+                return np.asarray(self), self.color
+
+        a1 = TestArray(np.zeros(100), color='green')
+        if not dill._dill.IS_PYPY:
+            assert dill.pickles(a1)
+            assert a1.__dict__ == dill.copy(a1).__dict__
+
+        a2 = a1[0:9]
+        if not dill._dill.IS_PYPY:
+            assert dill.pickles(a2)
+            assert a2.__dict__ == dill.copy(a2).__dict__
+
+        class TestArray2(np.ndarray):
+            color = 'blue'
+
+        a3 = TestArray2([1,2,3,4,5])
+        a3.color = 'green'
+        if not dill._dill.IS_PYPY:
+            assert dill.pickles(a3)
+            assert a3.__dict__ == dill.copy(a3).__dict__
+
+    except ImportError: pass
+
+
+def test_method_decorator():
+    class A(object):
+      @classmethod
+      def test(cls):
+        pass
+
+    a = A()
+
+    res = dill.dumps(a)
+    new_obj = dill.loads(res)
+    new_obj.__class__.test()
+
+# test slots
+class Y(object):
+  __slots__ = ('y', '__weakref__')
+  def __init__(self, y):
+    self.y = y
+
+value = 123
+y = Y(value)
+
+class Y2(object):
+  __slots__ = 'y'
+  def __init__(self, y):
+    self.y = y
+
+def test_slots():
+    assert dill.pickles(Y)
+    assert dill.pickles(y)
+    assert dill.pickles(Y.y)
+    assert dill.copy(y).y == value
+    assert dill.copy(Y2(value)).y == value
+
+def test_origbases():
+    assert dill.copy(customIntList).__orig_bases__ == customIntList.__orig_bases__
+
+def test_attr():
+    import attr
+    @attr.s
+    class A:
+        a = attr.ib()
+
+    v = A(1)
+    assert dill.copy(v) == v
+
+def test_metaclass():
+    class metaclass_with_new(type):
+        def __new__(mcls, name, bases, ns, **kwds):
+            cls = super().__new__(mcls, name, bases, ns, **kwds)
+            assert mcls is not None
+            assert cls.method(mcls)
+            return cls
+        def method(cls, mcls):
+            return isinstance(cls, mcls)
+
+    l = locals()
+    exec("""class subclass_with_new(metaclass=metaclass_with_new):
+        def __new__(cls):
+            self = super().__new__(cls)
+            return self""", None, l)
+    subclass_with_new = l['subclass_with_new']
+
+    assert dill.copy(subclass_with_new())
+
+def test_enummeta():
+    from http import HTTPStatus
+    import enum
+    assert dill.copy(HTTPStatus.OK) is HTTPStatus.OK
+    assert dill.copy(enum.EnumMeta) is enum.EnumMeta
+
+def test_inherit(): #NOTE: see issue #612
+    class Foo:
+        w = 0
+        x = 1
+        y = 1.1
+        a = ()
+        b = (1,)
+        n = None
+
+    class Bar(Foo):
+        w = 2
+        x = 1
+        y = 1.1
+        z = 0.2
+        a = ()
+        b = (1,)
+        c = (2,)
+        n = None
+
+    Baz = dill.copy(Bar)
+
+    import platform
+    is_pypy = platform.python_implementation() == 'PyPy'
+    assert Bar.__dict__ == Baz.__dict__
+    # ints
+    assert 'w' in Bar.__dict__ and 'w' in Baz.__dict__
+    assert Bar.__dict__['w'] is Baz.__dict__['w']
+    assert 'x' in Bar.__dict__ and 'x' in Baz.__dict__
+    assert Bar.__dict__['x'] is Baz.__dict__['x']
+    # floats
+    assert 'y' in Bar.__dict__ and 'y' in Baz.__dict__
+    same = Bar.__dict__['y'] is Baz.__dict__['y']
+    assert same if is_pypy else not same
+    assert 'z' in Bar.__dict__ and 'z' in Baz.__dict__
+    same = Bar.__dict__['z'] is Baz.__dict__['z']
+    assert same if is_pypy else not same
+    # tuples
+    assert 'a' in Bar.__dict__ and 'a' in Baz.__dict__
+    assert Bar.__dict__['a'] is Baz.__dict__['a']
+    assert 'b' in Bar.__dict__ and 'b' in Baz.__dict__
+    assert Bar.__dict__['b'] is not Baz.__dict__['b']
+    assert 'c' in Bar.__dict__ and 'c' in Baz.__dict__
+    assert Bar.__dict__['c'] is not Baz.__dict__['c']
+    # None
+    assert 'n' in Bar.__dict__ and 'n' in Baz.__dict__
+    assert Bar.__dict__['n'] is Baz.__dict__['n']
+
+
+if __name__ == '__main__':
+    test_class_instances()
+    test_class_objects()
+    test_specialtypes()
+    test_namedtuple()
+    test_dtype()
+    test_array_nested()
+    test_array_subclass()
+    test_method_decorator()
+    test_slots()
+    test_origbases()
+    test_metaclass()
+    test_enummeta()
+    test_inherit()

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

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

@@ -0,0 +1,160 @@
+#!/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.detect import baditems, badobjects, badtypes, errors, parent, at, globalvars
+from dill import settings
+from dill._dill import IS_PYPY
+from pickle import PicklingError
+
+import inspect
+import sys
+import os
+
+def test_bad_things():
+    f = inspect.currentframe()
+    assert baditems(f) == [f]
+    #assert baditems(globals()) == [f] #XXX
+    assert badobjects(f) is f
+    assert badtypes(f) == type(f)
+    assert type(errors(f)) is TypeError
+    d = badtypes(f, 1)
+    assert isinstance(d, dict)
+    assert list(badobjects(f, 1).keys()) == list(d.keys())
+    assert list(errors(f, 1).keys()) == list(d.keys())
+    s = set([(err.__class__.__name__,err.args[0]) for err in list(errors(f, 1).values())])
+    a = dict(s)
+    if not os.environ.get('COVERAGE'): #XXX: travis-ci
+        proxy = 0 if type(f.f_locals) is dict else 1
+        assert len(s) == len(a) + proxy # TypeError (and possibly PicklingError)
+    n = 2
+    assert len(a) is n if 'PicklingError' in a.keys() else n-1
+
+def test_parent():
+    x = [4,5,6,7]
+    listiter = iter(x)
+    obj = parent(listiter, list)
+    assert obj is x
+
+    if IS_PYPY: assert parent(obj, int) is None
+    else: assert parent(obj, int) is x[-1] # python oddly? finds last int
+    assert at(id(at)) is at
+
+a, b, c = 1, 2, 3
+
+def squared(x):
+  return a+x**2
+
+def foo(x):
+  def bar(y):
+    return squared(x)+y
+  return bar
+
+class _class:
+    def _method(self):
+        pass
+    def ok(self):
+        return True
+
+def test_globals():
+    def f():
+        a
+        def g():
+            b
+            def h():
+                c
+    assert globalvars(f) == dict(a=1, b=2, c=3)
+
+    res = globalvars(foo, recurse=True)
+    assert set(res) == set(['squared', 'a'])
+    res = globalvars(foo, recurse=False)
+    assert res == {}
+    zap = foo(2)
+    res = globalvars(zap, recurse=True)
+    assert set(res) == set(['squared', 'a'])
+    res = globalvars(zap, recurse=False)
+    assert set(res) == set(['squared'])
+    del zap
+    res = globalvars(squared)
+    assert set(res) == set(['a'])
+    # FIXME: should find referenced __builtins__
+    #res = globalvars(_class, recurse=True)
+    #assert set(res) == set(['True'])
+    #res = globalvars(_class, recurse=False)
+    #assert res == {}
+    #res = globalvars(_class.ok, recurse=True)
+    #assert set(res) == set(['True'])
+    #res = globalvars(_class.ok, recurse=False)
+    #assert set(res) == set(['True'])
+
+
+#98 dill ignores __getstate__ in interactive lambdas
+bar = [0]
+
+class Foo(object):
+    def __init__(self):
+        pass
+    def __getstate__(self):
+        bar[0] = bar[0]+1
+        return {}
+    def __setstate__(self, data):
+        pass
+
+f = Foo()
+
+def test_getstate():
+    from dill import dumps, loads
+    dumps(f)
+    b = bar[0]
+    dumps(lambda: f, recurse=False) # doesn't call __getstate__
+    assert bar[0] == b
+    dumps(lambda: f, recurse=True) # calls __getstate__
+    assert bar[0] == b + 1
+
+#97 serialize lambdas in test files
+def test_deleted():
+    global sin
+    from dill import dumps, loads
+    from math import sin, pi
+
+    def sinc(x):
+        return sin(x)/x
+
+    settings['recurse'] = True
+    _sinc = dumps(sinc)
+    sin = globals().pop('sin')
+    sin = 1
+    del sin
+    sinc_ = loads(_sinc) # no NameError... pickling preserves 'sin'
+    res = sinc_(1)
+    from math import sin
+    assert sinc(1) == res
+
+
+def test_lambdify():
+    try:
+        from sympy import symbols, lambdify
+    except ImportError:
+        return
+    settings['recurse'] = True
+    x = symbols("x")
+    y = x**2
+    f = lambdify([x], y)
+    z = min
+    d = globals()
+    globalvars(f, recurse=True, builtin=True)
+    assert z is min 
+    assert d is globals() 
+
+
+if __name__ == '__main__':
+    test_bad_things()
+    test_parent()
+    test_globals()
+    test_getstate()
+    test_deleted()
+    test_lambdify()

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

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

@@ -0,0 +1,107 @@
+#!/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 import __diff as diff
+
+import sys
+IS_PYPY = not hasattr(sys, 'getrefcount')
+
+class A:
+    pass
+
+def test_diff():
+    a = A()
+    b = A()
+    c = A()
+    a.a = b
+    b.a = c
+    diff.memorise(a)
+    assert not diff.has_changed(a)
+    c.a = 1
+    assert diff.has_changed(a)
+    diff.memorise(c, force=True)
+    assert not diff.has_changed(a)
+    c.a = 2
+    assert diff.has_changed(a)
+    changed = diff.whats_changed(a)
+    assert list(changed[0].keys()) == ["a"]
+    assert not changed[1]
+
+    a2 = []
+    b2 = [a2]
+    c2 = [b2]
+    diff.memorise(c2)
+    assert not diff.has_changed(c2)
+    a2.append(1)
+    assert diff.has_changed(c2)
+    changed = diff.whats_changed(c2)
+    assert changed[0] == {}
+    assert changed[1]
+
+    a3 = {}
+    b3 = {1: a3}
+    c3 = {1: b3}
+    diff.memorise(c3)
+    assert not diff.has_changed(c3)
+    a3[1] = 1
+    assert diff.has_changed(c3)
+    changed = diff.whats_changed(c3)
+    assert changed[0] == {}
+    assert changed[1]
+
+    if not IS_PYPY:
+        import abc
+        # make sure the "_abc_invaldation_counter" doesn't make test fail
+        diff.memorise(abc.ABCMeta, force=True)
+        assert not diff.has_changed(abc)
+        abc.ABCMeta.zzz = 1
+        assert diff.has_changed(abc)
+        changed = diff.whats_changed(abc)
+        assert list(changed[0].keys()) == ["ABCMeta"]
+        assert not changed[1]
+
+    '''
+    import Queue
+    diff.memorise(Queue, force=True)
+    assert not diff.has_changed(Queue)
+    Queue.Queue.zzz = 1
+    assert diff.has_changed(Queue)
+    changed = diff.whats_changed(Queue)
+    assert list(changed[0].keys()) == ["Queue"]
+    assert not changed[1]
+
+    import math
+    diff.memorise(math, force=True)
+    assert not diff.has_changed(math)
+    math.zzz = 1
+    assert diff.has_changed(math)
+    changed = diff.whats_changed(math)
+    assert list(changed[0].keys()) == ["zzz"]
+    assert not changed[1]
+    '''
+
+    a = A()
+    b = A()
+    c = A()
+    a.a = b
+    b.a = c
+    diff.memorise(a)
+    assert not diff.has_changed(a)
+    c.a = 1
+    assert diff.has_changed(a)
+    diff.memorise(c, force=True)
+    assert not diff.has_changed(a)
+    del c.a
+    assert diff.has_changed(a)
+    changed = diff.whats_changed(a)
+    assert list(changed[0].keys()) == ["a"]
+    assert not changed[1]
+
+
+if __name__ == '__main__':
+    test_diff()

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

@@ -0,0 +1,53 @@
+#!/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 as pickle
+from io import BytesIO as StringIO
+
+
+def my_fn(x):
+    return x * 17
+
+
+def test_extend():
+    obj = lambda : my_fn(34)
+    assert obj() == 578
+
+    obj_io = StringIO()
+    pickler = pickle.Pickler(obj_io)
+    pickler.dump(obj)
+
+    obj_str = obj_io.getvalue()
+
+    obj2_io = StringIO(obj_str)
+    unpickler = pickle.Unpickler(obj2_io)
+    obj2 = unpickler.load()
+
+    assert obj2() == 578
+
+
+def test_isdill():
+    obj_io = StringIO()
+    pickler = pickle.Pickler(obj_io)
+    assert pickle._dill.is_dill(pickler) is True
+
+    pickler = pickle._dill.StockPickler(obj_io)
+    assert pickle._dill.is_dill(pickler) is False
+
+    try:
+        import multiprocess as mp
+        pickler = mp.reduction.ForkingPickler(obj_io)
+        assert pickle._dill.is_dill(pickler, child=True) is True
+        assert pickle._dill.is_dill(pickler, child=False) is False
+    except Exception:
+        pass
+
+
+if __name__ == '__main__':
+    test_extend()
+    test_isdill()

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

@@ -0,0 +1,55 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2021-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 get_fun_with_strftime():
+    def fun_with_strftime():
+        import datetime
+        return datetime.datetime.strptime("04-01-1943", "%d-%m-%Y").strftime(
+            "%Y-%m-%d %H:%M:%S"
+        )
+    return fun_with_strftime
+
+
+def get_fun_with_strftime2():
+    import datetime
+    return datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+
+
+def test_doc_dill_issue_219():
+    back_fn = dill.loads(dill.dumps(get_fun_with_strftime()))
+    assert back_fn() == "1943-01-04 00:00:00"
+    dupl = dill.loads(dill.dumps(get_fun_with_strftime2))
+    assert dupl() == get_fun_with_strftime2()
+
+
+def get_fun_with_internal_import():
+    def fun_with_import():
+        import re
+        return re.compile("$")
+    return fun_with_import
+
+
+def test_method_with_internal_import_should_work():
+    import re
+    back_fn = dill.loads(dill.dumps(get_fun_with_internal_import()))
+    import inspect
+    if hasattr(inspect, 'getclosurevars'):
+        vars = inspect.getclosurevars(back_fn)
+        assert vars.globals == {}
+        assert vars.nonlocals == {}
+    assert back_fn() == re.compile("$")
+    assert "__builtins__" in back_fn.__globals__
+
+
+if __name__ == "__main__":
+    import sys
+    if (sys.version_info[:3] != (3,10,0) or sys.version_info[3] != 'alpha'):
+        test_doc_dill_issue_219()
+        test_method_with_internal_import_should_work()

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

@@ -0,0 +1,500 @@
+#!/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 os
+import sys
+import string
+import random
+
+import dill
+
+
+dill.settings['recurse'] = True
+
+fname = "_test_file.txt"
+rand_chars = list(string.ascii_letters) + ["\n"] * 40  # bias newline
+
+buffer_error = ValueError("invalid buffer size")
+dne_error = FileNotFoundError("[Errno 2] No such file or directory: '%s'" % fname)
+
+
+def write_randomness(number=200):
+    f = open(fname, "w")
+    for i in range(number):
+        f.write(random.choice(rand_chars))
+    f.close()
+    f = open(fname, "r")
+    contents = f.read()
+    f.close()
+    return contents
+
+
+def trunc_file():
+    open(fname, "w").close()
+
+
+def throws(op, args, exc):
+    try:
+        op(*args)
+    except type(exc):
+        return sys.exc_info()[1].args == exc.args
+    else:
+        return False
+
+
+def teardown_module():
+    if os.path.exists(fname):
+        os.remove(fname)
+
+
+def bench(strictio, fmode, skippypy):
+    import platform
+    if skippypy and platform.python_implementation() == 'PyPy':
+        # Skip for PyPy...
+        return
+
+    # file exists, with same contents
+    # read
+
+    write_randomness()
+
+    f = open(fname, "r")
+    _f = dill.loads(dill.dumps(f, fmode=fmode))#, strictio=strictio))
+    assert _f.mode == f.mode
+    assert _f.tell() == f.tell()
+    assert _f.read() == f.read()
+    f.close()
+    _f.close()
+
+    # write
+
+    f = open(fname, "w")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    f2 = dill.loads(f_dumped) #FIXME: fails due to pypy/issues/1233
+    # TypeError: expected py_object instance instead of str
+    f2mode = f2.mode
+    f2tell = f2.tell()
+    f2name = f2.name
+    f2.write(" world!")
+    f2.close()
+
+    if fmode == dill.HANDLE_FMODE:
+        assert open(fname).read() == " world!"
+        assert f2mode == f1mode
+        assert f2tell == 0
+    elif fmode == dill.CONTENTS_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2mode == f1mode
+        assert f2tell == ftell
+        assert f2name == fname
+    elif fmode == dill.FILE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2mode == f1mode
+        assert f2tell == ftell
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+
+    # append
+
+    trunc_file()
+
+    f = open(fname, "a")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    f2 = dill.loads(f_dumped)
+    f2mode = f2.mode
+    f2tell = f2.tell()
+    f2.write(" world!")
+    f2.close()
+
+    assert f2mode == f1mode
+    if fmode == dill.CONTENTS_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2tell == ftell
+    elif fmode == dill.HANDLE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2tell == ftell
+    elif fmode == dill.FILE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2tell == ftell
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+
+    # file exists, with different contents (smaller size)
+    # read
+
+    write_randomness()
+
+    f = open(fname, "r")
+    fstr = f.read()
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    _flen = 150
+    _fstr = write_randomness(number=_flen)
+
+    if strictio:  # throw error if ftell > EOF
+        assert throws(dill.loads, (f_dumped,), buffer_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        assert f2.mode == f1mode
+        if fmode == dill.CONTENTS_FMODE:
+            assert f2.tell() == _flen
+            assert f2.read() == ""
+            f2.seek(0)
+            assert f2.read() == _fstr
+            assert f2.tell() == _flen  # 150
+        elif fmode == dill.HANDLE_FMODE:
+            assert f2.tell() == 0
+            assert f2.read() == _fstr
+            assert f2.tell() == _flen  # 150
+        elif fmode == dill.FILE_FMODE:
+            assert f2.tell() == ftell  # 200
+            assert f2.read() == ""
+            f2.seek(0)
+            assert f2.read() == fstr
+            assert f2.tell() == ftell  # 200
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+        f2.close()
+
+    # write
+
+    write_randomness()
+
+    f = open(fname, "w")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    fstr = open(fname).read()
+
+    f = open(fname, "w")
+    f.write("h")
+    _ftell = f.tell()
+    f.close()
+
+    if strictio:  # throw error if ftell > EOF
+        assert throws(dill.loads, (f_dumped,), buffer_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        f2mode = f2.mode
+        f2tell = f2.tell()
+        f2.write(" world!")
+        f2.close()
+        if fmode == dill.CONTENTS_FMODE:
+            assert open(fname).read() == "h world!"
+            assert f2mode == f1mode
+            assert f2tell == _ftell
+        elif fmode == dill.HANDLE_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2mode == f1mode
+            assert f2tell == 0
+        elif fmode == dill.FILE_FMODE:
+            assert open(fname).read() == "hello world!"
+            assert f2mode == f1mode
+            assert f2tell == ftell
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+        f2.close()
+
+    # append
+
+    trunc_file()
+
+    f = open(fname, "a")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    fstr = open(fname).read()
+
+    f = open(fname, "w")
+    f.write("h")
+    _ftell = f.tell()
+    f.close()
+
+    if strictio:  # throw error if ftell > EOF
+        assert throws(dill.loads, (f_dumped,), buffer_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        f2mode = f2.mode
+        f2tell = f2.tell()
+        f2.write(" world!")
+        f2.close()
+        assert f2mode == f1mode
+        if fmode == dill.CONTENTS_FMODE:
+            # position of writes cannot be changed on some OSs
+            assert open(fname).read() == "h world!"
+            assert f2tell == _ftell
+        elif fmode == dill.HANDLE_FMODE:
+            assert open(fname).read() == "h world!"
+            assert f2tell == _ftell
+        elif fmode == dill.FILE_FMODE:
+            assert open(fname).read() == "hello world!"
+            assert f2tell == ftell
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+        f2.close()
+
+    # file does not exist
+    # read
+
+    write_randomness()
+
+    f = open(fname, "r")
+    fstr = f.read()
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+
+    os.remove(fname)
+
+    if strictio:  # throw error if file DNE
+        assert throws(dill.loads, (f_dumped,), dne_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        assert f2.mode == f1mode
+        if fmode == dill.CONTENTS_FMODE:
+            # FIXME: this fails on systems where f2.tell() always returns 0
+            # assert f2.tell() == ftell # 200
+            assert f2.read() == ""
+            f2.seek(0)
+            assert f2.read() == ""
+            assert f2.tell() == 0
+        elif fmode == dill.FILE_FMODE:
+            assert f2.tell() == ftell  # 200
+            assert f2.read() == ""
+            f2.seek(0)
+            assert f2.read() == fstr
+            assert f2.tell() == ftell  # 200
+        elif fmode == dill.HANDLE_FMODE:
+            assert f2.tell() == 0
+            assert f2.read() == ""
+            assert f2.tell() == 0
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+        f2.close()
+
+    # write
+
+    write_randomness()
+
+    f = open(fname, "w+")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    ftell = f.tell()
+    f1mode = f.mode
+    f.close()
+
+    os.remove(fname)
+
+    if strictio:  # throw error if file DNE
+        assert throws(dill.loads, (f_dumped,), dne_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        f2mode = f2.mode
+        f2tell = f2.tell()
+        f2.write(" world!")
+        f2.close()
+        if fmode == dill.CONTENTS_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2mode == 'w+'
+            assert f2tell == 0
+        elif fmode == dill.HANDLE_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2mode == f1mode
+            assert f2tell == 0
+        elif fmode == dill.FILE_FMODE:
+            assert open(fname).read() == "hello world!"
+            assert f2mode == f1mode
+            assert f2tell == ftell
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+
+    # append
+
+    trunc_file()
+
+    f = open(fname, "a")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    ftell = f.tell()
+    f1mode = f.mode
+    f.close()
+
+    os.remove(fname)
+
+    if strictio:  # throw error if file DNE
+        assert throws(dill.loads, (f_dumped,), dne_error)
+    else:
+        f2 = dill.loads(f_dumped)
+        f2mode = f2.mode
+        f2tell = f2.tell()
+        f2.write(" world!")
+        f2.close()
+        assert f2mode == f1mode
+        if fmode == dill.CONTENTS_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2tell == 0
+        elif fmode == dill.HANDLE_FMODE:
+            assert open(fname).read() == " world!"
+            assert f2tell == 0
+        elif fmode == dill.FILE_FMODE:
+            assert open(fname).read() == "hello world!"
+            assert f2tell == ftell
+        else:
+            raise RuntimeError("Unknown file mode '%s'" % fmode)
+
+    # file exists, with different contents (larger size)
+    # read
+
+    write_randomness()
+
+    f = open(fname, "r")
+    fstr = f.read()
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    f.close()
+    _flen = 250
+    _fstr = write_randomness(number=_flen)
+
+    # XXX: no safe_file: no way to be 'safe'?
+
+    f2 = dill.loads(f_dumped)
+    assert f2.mode == f1mode
+    if fmode == dill.CONTENTS_FMODE:
+        assert f2.tell() == ftell  # 200
+        assert f2.read() == _fstr[ftell:]
+        f2.seek(0)
+        assert f2.read() == _fstr
+        assert f2.tell() == _flen  # 250
+    elif fmode == dill.HANDLE_FMODE:
+        assert f2.tell() == 0
+        assert f2.read() == _fstr
+        assert f2.tell() == _flen  # 250
+    elif fmode == dill.FILE_FMODE:
+        assert f2.tell() == ftell  # 200
+        assert f2.read() == ""
+        f2.seek(0)
+        assert f2.read() == fstr
+        assert f2.tell() == ftell  # 200
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+    f2.close()  # XXX: other alternatives?
+
+    # write
+
+    f = open(fname, "w")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+
+    fstr = open(fname).read()
+
+    f.write(" and goodbye!")
+    _ftell = f.tell()
+    f.close()
+
+    # XXX: no safe_file: no way to be 'safe'?
+
+    f2 = dill.loads(f_dumped)
+    f2mode = f2.mode
+    f2tell = f2.tell()
+    f2.write(" world!")
+    f2.close()
+    if fmode == dill.CONTENTS_FMODE:
+        assert open(fname).read() == "hello world!odbye!"
+        assert f2mode == f1mode
+        assert f2tell == ftell
+    elif fmode == dill.HANDLE_FMODE:
+        assert open(fname).read() == " world!"
+        assert f2mode == f1mode
+        assert f2tell == 0
+    elif fmode == dill.FILE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2mode == f1mode
+        assert f2tell == ftell
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+    f2.close()
+
+    # append
+
+    trunc_file()
+
+    f = open(fname, "a")
+    f.write("hello")
+    f_dumped = dill.dumps(f, fmode=fmode)#, strictio=strictio)
+    f1mode = f.mode
+    ftell = f.tell()
+    fstr = open(fname).read()
+
+    f.write(" and goodbye!")
+    _ftell = f.tell()
+    f.close()
+
+    # XXX: no safe_file: no way to be 'safe'?
+
+    f2 = dill.loads(f_dumped)
+    f2mode = f2.mode
+    f2tell = f2.tell()
+    f2.write(" world!")
+    f2.close()
+    assert f2mode == f1mode
+    if fmode == dill.CONTENTS_FMODE:
+        assert open(fname).read() == "hello and goodbye! world!"
+        assert f2tell == ftell
+    elif fmode == dill.HANDLE_FMODE:
+        assert open(fname).read() == "hello and goodbye! world!"
+        assert f2tell == _ftell
+    elif fmode == dill.FILE_FMODE:
+        assert open(fname).read() == "hello world!"
+        assert f2tell == ftell
+    else:
+        raise RuntimeError("Unknown file mode '%s'" % fmode)
+    f2.close()
+
+
+def test_nostrictio_handlefmode():
+    bench(False, dill.HANDLE_FMODE, False)
+    teardown_module()
+
+
+def test_nostrictio_filefmode():
+    bench(False, dill.FILE_FMODE, False)
+    teardown_module()
+
+
+def test_nostrictio_contentsfmode():
+    bench(False, dill.CONTENTS_FMODE, True)
+    teardown_module()
+
+
+#bench(True, dill.HANDLE_FMODE, False)
+#bench(True, dill.FILE_FMODE, False)
+#bench(True, dill.CONTENTS_FMODE, True)
+
+
+if __name__ == '__main__':
+    test_nostrictio_handlefmode()
+    test_nostrictio_filefmode()
+    test_nostrictio_contentsfmode()

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

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

@@ -0,0 +1,39 @@
+#!/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 functools
+import dill
+dill.settings['recurse'] = True
+
+
+def f(a, b, c):  # without keywords
+    pass
+
+
+def g(a, b, c=2):  # with keywords
+    pass
+
+
+def h(a=1, b=2, c=3):  # without args
+    pass
+
+
+def test_functools():
+    fp = functools.partial(f, 1, 2)
+    gp = functools.partial(g, 1, c=2)
+    hp = functools.partial(h, 1, c=2)
+    bp = functools.partial(int, base=2)
+
+    assert dill.pickles(fp, safe=True)
+    assert dill.pickles(gp, safe=True)
+    assert dill.pickles(hp, safe=True)
+    assert dill.pickles(bp, safe=True)
+
+
+if __name__ == '__main__':
+    test_functools()

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

@@ -0,0 +1,70 @@
+#!/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 logging
+import re
+import tempfile
+
+import dill
+from dill import detect
+from dill.logger import stderr_handler, adapter as logger
+
+try:
+    from StringIO import StringIO
+except ImportError:
+    from io import StringIO
+
+test_obj = {'a': (1, 2), 'b': object(), 'f': lambda x: x**2, 'big': list(range(10))}
+
+def test_logging(should_trace):
+    buffer = StringIO()
+    handler = logging.StreamHandler(buffer)
+    logger.addHandler(handler)
+    try:
+        dill.dumps(test_obj)
+        if should_trace:
+            regex = re.compile(r'(\S*┬ \w.*[^)]'              # begin pickling object
+                               r'|│*└ # \w.* \[\d+ (\wi)?B])' # object written (with size)
+                               )
+            for line in buffer.getvalue().splitlines():
+                assert regex.fullmatch(line)
+            return buffer.getvalue()
+        else:
+            assert buffer.getvalue() == ""
+    finally:
+        logger.removeHandler(handler)
+        buffer.close()
+
+def test_trace_to_file(stream_trace):
+    file = tempfile.NamedTemporaryFile(mode='r')
+    with detect.trace(file.name, mode='w'):
+        dill.dumps(test_obj)
+    file_trace = file.read()
+    file.close()
+    # Apparently, objects can change location in memory...
+    reghex = re.compile(r'0x[0-9A-Za-z]+')
+    file_trace, stream_trace = reghex.sub('0x', file_trace), reghex.sub('0x', stream_trace)
+    # PyPy prints dictionary contents with repr(dict)...
+    regdict = re.compile(r'(dict\.__repr__ of ).*')
+    file_trace, stream_trace = regdict.sub(r'\1{}>', file_trace), regdict.sub(r'\1{}>', stream_trace)
+    assert file_trace == stream_trace
+
+if __name__ == '__main__':
+    logger.removeHandler(stderr_handler)
+    test_logging(should_trace=False)
+    detect.trace(True)
+    test_logging(should_trace=True)
+    detect.trace(False)
+    test_logging(should_trace=False)
+
+    loglevel = logging.ERROR
+    logger.setLevel(loglevel)
+    with detect.trace():
+        stream_trace = test_logging(should_trace=True)
+    test_logging(should_trace=False)
+    assert logger.getEffectiveLevel() == loglevel
+    test_trace_to_file(stream_trace)

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

@@ -0,0 +1,121 @@
+#!/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 wtf(x,y,z):
+  def zzz():
+    return x
+  def yyy():
+    return y
+  def xxx():
+    return z
+  return zzz,yyy
+
+
+def quad(a=1, b=1, c=0):
+  inverted = [False]
+  def invert():
+    inverted[0] = not inverted[0]
+  def dec(f):
+    def func(*args, **kwds):
+      x = f(*args, **kwds)
+      if inverted[0]: x = -x
+      return a*x**2 + b*x + c
+    func.__wrapped__ = f
+    func.invert = invert
+    func.inverted = inverted
+    return func
+  return dec
+
+
+@quad(a=0,b=2)
+def double_add(*args):
+  return sum(args)
+
+
+fx = sum([1,2,3])
+
+
+### to make it interesting...
+def quad_factory(a=1,b=1,c=0):
+  def dec(f):
+    def func(*args,**kwds):
+      fx = f(*args,**kwds)
+      return a*fx**2 + b*fx + c
+    return func
+  return dec
+
+
+@quad_factory(a=0,b=4,c=0)
+def quadish(x):
+  return x+1
+
+
+quadratic = quad_factory()
+
+
+def doubler(f):
+  def inner(*args, **kwds):
+    fx = f(*args, **kwds)
+    return 2*fx
+  return inner
+
+
+@doubler
+def quadruple(x):
+  return 2*x
+
+
+def test_mixins():
+  # test mixins
+  assert double_add(1,2,3) == 2*fx
+  double_add.invert()
+  assert double_add(1,2,3) == -2*fx
+
+  _d = dill.copy(double_add)
+  assert _d(1,2,3) == -2*fx
+ #_d.invert() #FIXME: fails seemingly randomly
+ #assert _d(1,2,3) == 2*fx
+
+  assert _d.__wrapped__(1,2,3) == fx
+
+  # XXX: issue or feature? in python3.4, inverted is linked through copy
+  if not double_add.inverted[0]:
+      double_add.invert()
+
+  # test some stuff from source and pointers
+  ds = dill.source
+  dd = dill.detect
+  assert ds.getsource(dd.freevars(quadish)['f']) == '@quad_factory(a=0,b=4,c=0)\ndef quadish(x):\n  return x+1\n'
+  assert ds.getsource(dd.freevars(quadruple)['f']) == '@doubler\ndef quadruple(x):\n  return 2*x\n'
+  assert ds.importable(quadish, source=False) == 'from %s import quadish\n' % __name__
+  assert ds.importable(quadruple, source=False) == 'from %s import quadruple\n' % __name__
+  assert ds.importable(quadratic, source=False) == 'from %s import quadratic\n' % __name__
+  assert ds.importable(double_add, source=False) == 'from %s import double_add\n' % __name__
+  assert ds.importable(quadruple, source=True) == 'def doubler(f):\n  def inner(*args, **kwds):\n    fx = f(*args, **kwds)\n    return 2*fx\n  return inner\n\n@doubler\ndef quadruple(x):\n  return 2*x\n'
+  #***** #FIXME: this needs work
+  result = ds.importable(quadish, source=True)
+  a,b,c,_,result = result.split('\n',4)
+  assert result == '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\n@quad_factory(a=0,b=4,c=0)\ndef quadish(x):\n  return x+1\n'
+  assert set([a,b,c]) == set(['a = 0', 'c = 0', 'b = 4'])
+  result = ds.importable(quadratic, source=True)
+  a,b,c,result = result.split('\n',3)
+  assert result == '\ndef 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 set([a,b,c]) == set(['a = 1', 'c = 0', 'b = 1'])
+  result = ds.importable(double_add, source=True)
+  a,b,c,d,_,result = result.split('\n',5)
+  assert result == '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\n@quad(a=0,b=2)\ndef double_add(*args):\n  return sum(args)\n'
+  assert set([a,b,c,d]) == set(['a = 0', 'c = 0', 'b = 2', 'inverted = [True]'])
+  #*****
+
+
+if __name__ == '__main__':
+    test_mixins()