Add files using upload-large-folder tool

ckpts/llama-3b/global_step100/bf16_zero_pp_rank_203_mp_rank_01_optim_states.pt

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

venv/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  
+
+"""

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

@@ -0,0 +1,35 @@
+#!/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
+
+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)

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

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

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

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

venv/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()