Add files using upload-large-folder tool

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

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

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-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 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)

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

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

lib/python3.12/site-packages/dill/tests/test_restricted.py

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

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

@@ -0,0 +1,154 @@
+#!/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.source import getsource, getname, _wrap, likely_import
+from dill.source import getimportable
+from dill._dill import IS_PYPY
+
+import sys
+PY310b = 0x30a00b1
+
+f = lambda x: x**2
+def g(x): return f(x) - x
+
+def h(x):
+  def g(x): return x
+  return g(x) - x
+
+class Foo(object):
+  def bar(self, x):
+    return x*x+x
+_foo = Foo()
+
+def add(x,y):
+  return x+y
+
+# yes, same as 'f', but things are tricky when it comes to pointers
+squared = lambda x:x**2
+
+class Bar:
+  pass
+_bar = Bar()
+
+                       # inspect.getsourcelines # dill.source.getblocks
+def test_getsource():
+  assert getsource(f) == 'f = lambda x: x**2\n'
+  assert getsource(g) == 'def g(x): return f(x) - x\n'
+  assert getsource(h) == 'def h(x):\n  def g(x): return x\n  return g(x) - x\n'
+  assert getname(f) == 'f'
+  assert getname(g) == 'g'
+  assert getname(h) == 'h'
+  assert _wrap(f)(4) == 16
+  assert _wrap(g)(4) == 12
+  assert _wrap(h)(4) == 0
+
+  assert getname(Foo) == 'Foo'
+  assert getname(Bar) == 'Bar'
+  assert getsource(Bar) == 'class Bar:\n  pass\n'
+  assert getsource(Foo) == 'class Foo(object):\n  def bar(self, x):\n    return x*x+x\n'
+  #XXX: add getsource for  _foo, _bar
+
+# test itself
+def test_itself():
+  assert likely_import(likely_import)=='from dill.source import likely_import\n'
+
+# builtin functions and objects
+def test_builtin():
+  assert likely_import(pow) == 'pow\n'
+  assert likely_import(100) == '100\n'
+  assert likely_import(True) == 'True\n'
+  assert likely_import(pow, explicit=True) == 'from builtins import pow\n'
+  assert likely_import(100, explicit=True) == '100\n'
+  assert likely_import(True, explicit=True) == 'True\n'
+  # this is kinda BS... you can't import a None
+  assert likely_import(None) == 'None\n'
+  assert likely_import(None, explicit=True) == 'None\n'
+
+
+# other imported functions
+def test_imported():
+  from math import sin
+  assert likely_import(sin) == 'from math import sin\n'
+
+# interactively defined functions
+def test_dynamic():
+  assert likely_import(add) == 'from %s import add\n' % __name__
+  # interactive lambdas
+  assert likely_import(squared) == 'from %s import squared\n' % __name__
+
+# classes and class instances
+def test_classes():
+  from io import BytesIO as StringIO
+  y = "from _io import BytesIO\n"
+  x = y if (IS_PYPY or sys.hexversion >= PY310b) else "from io import BytesIO\n"
+  s = StringIO()
+
+  assert likely_import(StringIO) == x
+  assert likely_import(s) == y
+  # interactively defined classes and class instances
+  assert likely_import(Foo) == 'from %s import Foo\n' % __name__
+  assert likely_import(_foo) == 'from %s import Foo\n' % __name__
+
+
+# test getimportable
+def test_importable():
+  assert getimportable(add) == 'from %s import add\n' % __name__
+  assert getimportable(squared) == 'from %s import squared\n' % __name__
+  assert getimportable(Foo) == 'from %s import Foo\n' % __name__
+  assert getimportable(Foo.bar) == 'from %s import bar\n' % __name__
+  assert getimportable(_foo.bar) == 'from %s import bar\n' % __name__
+  assert getimportable(None) == 'None\n'
+  assert getimportable(100) == '100\n'
+
+  assert getimportable(add, byname=False) == 'def add(x,y):\n  return x+y\n'
+  assert getimportable(squared, byname=False) == 'squared = lambda x:x**2\n'
+  assert getimportable(None, byname=False) == 'None\n'
+  assert getimportable(Bar, byname=False) == 'class Bar:\n  pass\n'
+  assert getimportable(Foo, byname=False) == 'class Foo(object):\n  def bar(self, x):\n    return x*x+x\n'
+  assert getimportable(Foo.bar, byname=False) == 'def bar(self, x):\n  return x*x+x\n'
+  assert getimportable(Foo.bar, byname=True) == 'from %s import bar\n' % __name__
+  assert getimportable(Foo.bar, alias='memo', byname=True) == 'from %s import bar as memo\n' % __name__
+  assert getimportable(Foo, alias='memo', byname=True) == 'from %s import Foo as memo\n' % __name__
+  assert getimportable(squared, alias='memo', byname=True) == 'from %s import squared as memo\n' % __name__
+  assert getimportable(squared, alias='memo', byname=False) == 'memo = squared = lambda x:x**2\n'
+  assert getimportable(add, alias='memo', byname=False) == 'def add(x,y):\n  return x+y\n\nmemo = add\n'
+  assert getimportable(None, alias='memo', byname=False) == 'memo = None\n'
+  assert getimportable(100, alias='memo', byname=False) == 'memo = 100\n'
+  assert getimportable(add, explicit=True) == 'from %s import add\n' % __name__
+  assert getimportable(squared, explicit=True) == 'from %s import squared\n' % __name__
+  assert getimportable(Foo, explicit=True) == 'from %s import Foo\n' % __name__
+  assert getimportable(Foo.bar, explicit=True) == 'from %s import bar\n' % __name__
+  assert getimportable(_foo.bar, explicit=True) == 'from %s import bar\n' % __name__
+  assert getimportable(None, explicit=True) == 'None\n'
+  assert getimportable(100, explicit=True) == '100\n'
+
+
+def test_numpy():
+  try:
+    from numpy import array
+    x = array([1,2,3])
+    assert getimportable(x) == 'from numpy import array\narray([1, 2, 3])\n'
+    assert getimportable(array) == 'from %s import array\n' % array.__module__
+    assert getimportable(x, byname=False) == 'from numpy import array\narray([1, 2, 3])\n'
+    assert getimportable(array, byname=False) == 'from %s import array\n' % array.__module__
+  except ImportError: pass
+
+#NOTE: if before likely_import(pow), will cause pow to throw AssertionError
+def test_foo():
+  assert getimportable(_foo, byname=False).startswith("import dill\nclass Foo(object):\n  def bar(self, x):\n    return x*x+x\ndill.loads(")
+
+if __name__ == '__main__':
+    test_getsource()
+    test_itself()
+    test_builtin()
+    test_imported()
+    test_dynamic()
+    test_classes()
+    test_importable()
+    test_numpy()
+    test_foo()

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