Add files using upload-large-folder tool

env-llmeval/lib/python3.10/site-packages/dill/tests/__init__.py

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

env-llmeval/lib/python3.10/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 ([email protected])
+# Copyright (c) 2022-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+"""
+test pickling a dataclass
+"""
+
+import dill
+import dataclasses
+
+def test_dataclasses():
+    # Issue #500
+    @dataclasses.dataclass
+    class A:
+        x: int
+        y: str
+
+    @dataclasses.dataclass
+    class B:
+        a: A
+
+    a = A(1, "test")
+    before = B(a)
+    save = dill.dumps(before)
+    after = dill.loads(save)
+    assert before != after # classes don't match
+    assert before == B(A(**dataclasses.asdict(after.a)))
+    assert dataclasses.asdict(before) == dataclasses.asdict(after)
+
+if __name__ == '__main__':
+    test_dataclasses()

env-llmeval/lib/python3.10/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-2024 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()

env-llmeval/lib/python3.10/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-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import 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()

env-llmeval/lib/python3.10/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-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import 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()

env-llmeval/lib/python3.10/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-2024 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)

env-llmeval/lib/python3.10/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-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import 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()

env-llmeval/lib/python3.10/site-packages/dill/tests/test_recursive.py

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

env-llmeval/lib/python3.10/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-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import 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()

env-llmeval/lib/python3.10/site-packages/dill/tests/test_weakref.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python
+#
+# Author: Mike McKerns (mmckerns @caltech and @uqfoundation)
+# Copyright (c) 2008-2016 California Institute of Technology.
+# Copyright (c) 2016-2024 The Uncertainty Quantification Foundation.
+# License: 3-clause BSD.  The full license text is available at:
+#  - https://github.com/uqfoundation/dill/blob/master/LICENSE
+
+import dill
+dill.settings['recurse'] = True
+import weakref
+
+class _class:
+    def _method(self):
+        pass
+
+class _callable_class:
+    def __call__(self):
+        pass
+
+def _function():
+    pass
+
+
+def test_weakref():
+    o = _class()
+    oc = _callable_class()
+    f = _function
+    x = _class
+
+    # ReferenceType
+    r = weakref.ref(o)
+    d_r = weakref.ref(_class())
+    fr = weakref.ref(f)
+    xr = weakref.ref(x)
+
+    # ProxyType
+    p = weakref.proxy(o)
+    d_p = weakref.proxy(_class())
+
+    # CallableProxyType
+    cp = weakref.proxy(oc)
+    d_cp = weakref.proxy(_callable_class())
+    fp = weakref.proxy(f)
+    xp = weakref.proxy(x)
+
+    objlist = [r,d_r,fr,xr, p,d_p, cp,d_cp,fp,xp]
+    #dill.detect.trace(True)
+
+    for obj in objlist:
+      res = dill.detect.errors(obj)
+      if res:
+        print ("%r:\n  %s" % (obj, res))
+    # else:
+    #   print ("PASS: %s" % obj)
+      assert not res
+
+def test_dictproxy():
+    from dill._dill import DictProxyType
+    try:
+        m = DictProxyType({"foo": "bar"})
+    except Exception:
+        m = type.__dict__
+    mp = dill.copy(m)   
+    assert mp.items() == m.items()
+
+
+if __name__ == '__main__':
+    test_weakref()
+    from dill._dill import IS_PYPY
+    if not IS_PYPY:
+        test_dictproxy()

env-llmeval/lib/python3.10/site-packages/numexpr/__init__.py

@@ -0,0 +1,68 @@
+###################################################################
+#  Numexpr - Fast numerical array expression evaluator for NumPy.
+#
+#      License: MIT
+#      Author:  See AUTHORS.txt
+#
+#  See LICENSE.txt and LICENSES/*.txt for details about copyright and
+#  rights to use.
+####################################################################
+
+"""
+Numexpr is a fast numerical expression evaluator for NumPy.  With it,
+expressions that operate on arrays (like "3*a+4*b") are accelerated
+and use less memory than doing the same calculation in Python.
+
+See:
+
+https://github.com/pydata/numexpr
+
+for more info about it.
+
+"""
+
+from numexpr.interpreter import MAX_THREADS, use_vml, __BLOCK_SIZE1__
+
+is_cpu_amd_intel = False # DEPRECATION WARNING: WILL BE REMOVED IN FUTURE RELEASE
+
+# cpuinfo imports were moved into the test submodule function that calls them 
+# to improve import times.
+
+import os, os.path
+import platform
+from numexpr.expressions import E
+from numexpr.necompiler import (NumExpr, disassemble, evaluate, re_evaluate, 
+    validate)
+
+from numexpr.utils import (_init_num_threads,
+    get_vml_version, set_vml_accuracy_mode, set_vml_num_threads,
+    set_num_threads, get_num_threads,
+    detect_number_of_cores, detect_number_of_threads)
+
+# Detect the number of cores
+ncores = detect_number_of_cores()
+# Initialize the number of threads to be used
+nthreads = _init_num_threads()
+# The default for VML is 1 thread (see #39)
+# set_vml_num_threads(1)
+
+from . import version
+__version__ = version.version
+
+def print_versions():
+    """Print the versions of software that numexpr relies on."""
+    try:
+        import numexpr.tests
+        return numexpr.tests.print_versions()
+    except ImportError:
+        # To maintain Python 2.6 compatibility we have simple error handling
+        raise ImportError('`numexpr.tests` could not be imported, likely it was excluded from the distribution.')
+
+def test(verbosity=1):
+    """Run all the tests in the test suite."""
+    try:
+        import numexpr.tests
+        return numexpr.tests.test(verbosity=verbosity)
+    except ImportError:
+        # To maintain Python 2.6 compatibility we have simple error handling
+        raise ImportError('`numexpr.tests` could not be imported, likely it was excluded from the distribution.')