__init__.py000064400000000765150044142170006663 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2018-2023 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 setup.py build $ python setup.py install then run the tests with: $ python -m dill.tests or, if `nose` is installed: $ nosetests """ __main__.py000064400000001603150044142170006634 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2018-2023 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) __pycache__/test_recursive.cpython-311.pyc000064400000025525150044142170014533 0ustar00 bgVXddlZddlmZddlZd"dZGddeZGddeZGd d eZd Z d Z Gd deZ GddeZ dZ GddeZGddeZdZGddeZdZdZdZdadZdZdZed krej5ejd!e e eeeeeddddS#1swxYwYdSdS)#N)partialFc|ri tj|||S#t$rYnwxYwt jdtj|||}t jd|Stj|||S)NbyrefrecursezCopy of z- with byref=True should have given a warning!ignoreerror)dillcopyAssertionError Exceptionwarnings simplefilter)objrrvals j/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_recursive.pyr r s < e9Sw??? ?    D  h'''i5':::g&&& yE7;;;;s  ((ceZdZfdZxZS)obj1cVtt|dSN)superr__init__self __class__s rrz obj1.__init__% dD""$$$$$__name__ __module__ __qualname__r __classcell__rs@rrr8%%%%%%%%%rrceZdZfdZxZS)obj2cVtt|dSr)rr&rrs rrz obj2.__init__#rrrr#s@rr&r&"r$rr&ceZdZeZdZdS)obj3cjtt|dSr)r)super_rrs rrz obj3.__init__(s( D$((*****rN)rr r!rr+rrrr)r)&s( F+++++rr)cttdsJttddsJttdsJttsJttdsJttddsJttdsJttsJttdsJttddsJttdsJttsJdSNT)rrr)r rr&r)r-rr test_superr1,sR d # # ### # dD 1 1 111 1  % % %%% % <<< d # # ### # dD 1 1 111 1  % % %%% % <<< d # # ### # dD 1 1 111 1  % % %%% % <<<rcdSrr-)models r get_triggerr4=sDrceZdZdZdS)Machinect|_tt||_tt|j|j_dSr)Modelchildrr4triggerr,s rrzMachine.__init__As:WW {D11 $[$*== rN)rr r!rr-rrr6r6@s#>>>>>rr6ceZdZdS)r8N)rr r!r-rrr8r8FsDrr8cttdsJttddsJttdsJttsJdSr/)r r6r-rr test_partialr=Ksv   & & &&& &  t 4 4 444 4  4 ( ( ((( (  ???rceZdZdZdZdS)Machine2c:t|j||_dSr)rmembergor,s rrzMachine2.__init__Ss$+t,,rcdSrr-)rr3s rrAzMachine2.memberUs rN)rr r!rrAr-rrr?r?Rs2---     rr?ceZdZfdZxZS) SubMachinecVtt|dSr)rrErrs rrzSubMachine.__init__Zs% j$((*****rrr#s@rrErEYs8+++++++++rrEcttdsJttddsJttdsJttsJdSr/)r rEr-rr test_partialsrH^sy  D ) ) ))) )  D$ 7 7 777 7  d + + +++ +    rceZdZfdZxZS)obj4ctt||Gfddt|_dS)Nc$eZdZfdZxZS)obj4.__init__..obj5cZt||_dSr)rra)rrrOobj5s rrz$obj4.__init__..obj5.__init__js*dD!!**,,,rr)rrOrPs@rrPrMisC           rrP)rrJrobjectb)rrOrPrs @@rrz obj4.__init__fsr dD""$$$         6   rrr#s@rrJrJes8rrJcttsJtjtjt}t |t |jjdjusJt |j t |j jjdjusJdS)Nr) r rJr loadsdumpstyper __closure__ cell_contentsrR) obj4_copys rtest_circular_referencerZps <<< 4:dff--..I  ??d9oo6B1ES S S S S   Y[ 1 1 : Fq I W W W W W W WrcfdS)NcSrr-gsrr^z f..gxsxrr-r]s@rfr_ws! Hrc@ttsJdSr)r r_r-rrtest_function_cellsra}s 999rcl|dksJ|dkr|St|dz t|dz zS)Nr)fib)ns rreres< 6666Avv1Q3xx#ac((""rcttd}tt}t}b|ddksJ||fD],} |dtd#t$rY)wxYw|adS)NTr0z&Function fib shouldn't have been found)r rer r )fib2fib3fib4_fibs rtest_recursive_functionrms T " " "D 99D D 477a<<<<t KK K DGGG !!IJJ J     D  CCCs A%% A21A2c ifd}|d<|S)NcSrr-)dsrr^z(collection_function_recursion..gsrr^r-)r^rps @rcollection_function_recursionrqs/ A AcF Hrcdtt}|d|usJdS)Nr^)r rqr]s r"test_collection_function_recursionrss1 * , ,--A 133s8q======r__main__r )FF)r functoolsrrr rQrr&r)r1r4r6r8r=r?rErHrJrZr_rarermrqrsrcatch_warningsrr-rrrws1 <<<<"%%%%%6%%%%%%%%6%%%+++++6+++ "   >>>>>f>>>      F        v   ++++++++ 6XXX   ###$     z  " "--g&&&   !!!!!!**,,,------------------s9ADD!$D!__pycache__/__init__.cpython-311.pyc000064400000000674150044142170013222 0ustar00 bg dZdS)z to run this test suite, first build and install `dill`. $ python setup.py build $ python setup.py install then run the tests with: $ python -m dill.tests or, if `nose` is installed: $ nosetests N)__doc__d/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/__init__.pyrsr__pycache__/__main__.cpython-311.pyc000064400000002546150044142170013203 0ustar00 bgddlZddlZddlZddlZejZ ddlZejdpeZn #e $rYnwxYwej dddkZ ej ep ej jZejeej jzdzZedkrfdZeD]IZejeege Zered d d d Z;ed d d Jed eedSdS)NT)versionwinz test_*.py__main__)shellF)endflush.)globossys subprocesssp executablepythonpox which_python ImportErrorplatformrpathdirname__file__curdirsuiteseptests__name__failedtestPopenwaitpprintexitd/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/__main__.pyr+s|   JJJ S d + + + 5vFF   D  RaRE! !!3RW^ %"'+% 344 z F++ BHfd^5 1 1 1 6 6 8 8  + E#2T * * * *FF E#2T * * * * * E"IIIDLLLLLs 199__pycache__/test_registered.cpython-311.pyc000064400000006071150044142170014654 0ustar00 bg%dZddlZddlmZmZmZddlZejdddZeeZ e e rJn#e $rZ e de ze ddZ [ wwxYweed Z e erJn#e $rZ e d eze ddZ [ wwxYweed Z e erJn#e $rZ e d eze ddZ [ wwxYwddlZddlZejjZd eDZeeejZ e erJn#e $rZ e d eze ddZ [ wwxYweejeZ e erJdS#e $rZ e deze ddZ [ wwxYw)z" test pickling registered objects N)failures registeredsucceedsignoreTcg}|D]O\}} tj|}|r||2#|s||YMxYw|S)N)itemsdillcopyappend)dokreskvzs k/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_registered.pycheckrsm Cwwyy%%! % ! A 3::a=== % $szz!}}} Js +A  A$z FAILS: %sF)r z REGISTER: %sz SUCCESS: %scri|]4\}}|ttv|ttv1||5S)varsbuiltinstypes).0rrs r r2s>RRRSQq$x..!8!8Qd5kk=Q=QQq=Q=Q=QzDIFF: %szMISS: %s)T)__doc__r dill._objectsrrrwarningsfilterwarningsrfailsboolAssertionErroreprintregistersuccessrr_dill_reverse_typemapqrpsetkeys differencediffmissrrrr0s 8888888888!!! htE{{? E+   5 & & &tH~~  E.8 #$$$  %U # # #tG}}  E-' !"""  JRRAGGIIRRR s16688}}  1 122tDzz> E*t   s?:?  ((22tDzz> E*t  sw AAAA/ A==BBB) B77C<C  C EE.E))E./ F>>GGG__pycache__/test_abc.cpython-311.pyc000064400000021713150044142170013244 0ustar00 bgdZddlZddlZddlmZddlZddlmZdejd<GddeZGd d eZ d Z d Z d Z e dkr e e e dSdS)z; test dill's ability to pickle abstract base class objects N)ABC) FunctionTypeTrecurseceZdZejdZeejdZejejdZe ejdZ e ejdZ dS) OneTwoThreecdS)zA methodNselfs d/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_abc.pyfoozOneTwoThree.foos  cdS)zProperty getterNr r s r barzOneTwoThree.bar  rcdS)zProperty setterNr r values r rzOneTwoThree.barrrcdS)z Class methodNr clss r cfoozOneTwoThree.cfoo rrcdS)z Static methodNr r rr sfoozOneTwoThree.sfoo&rrN) __name__ __module__ __qualname__abcabstractmethodr propertyrsetter classmethodr staticmethodrr rr rrs     X  Z  Z   [   \   rrc|eZdZdZdZedZejdZedZ e dZ dS) EasyAsAbccd|_dSN_barr s r __init__zEasyAsAbc.__init__-s  rcdS)NInstance Method FOOr r s r r z EasyAsAbc.foo0s$$rc|jSr'r(r s r rz EasyAsAbc.bar3s yrc||_dSr'r(rs r rz EasyAsAbc.bar7s  rcdS)NClass Method CFOOr rs r rzEasyAsAbc.cfoo;s""rcdS)NStatic Method SFOOr r rr rzEasyAsAbc.sfoo?s##rN) rrrr*r r rr!r"rr#rr rr r%r%,s%%%X ZZ##[#$$\$$$rr%cTtjttusJtjttusJt j5t jdtjtjtdtusJtjtdtusJ dddn #1swxYwYt}d|_tj|}t|t|usJt|jtusJ|ddksJ| dksJ| dksJ| d ksJdS) NignoreT)byrefc |dzS)Nr )xs r z$test_abc_non_local..Ns QTr r2r0r,)dillcopyrr%warningscatch_warnings simplefilterPicklingWarningrtyperrrr )instance depickleds r test_abc_non_localrECs 9[ ! ! 4 4 4 4 9Y  y 0 0 0 0  " "==h(<===yD111[@@@@y$///9<<<<<=============== {{H!>HL (##I  ??$x.. 0 0 0 0   , . . . . ==  q >>  3 3 3 3 3 >>  2 2 2 2 2 ==??3 3 3 3 3 3 3sA(C  CCcGddt}tj|}||usJt|t|usJGfdd|}|dksJ |t dJ#t $r }Yd}~nd}~wwxYwtj|f\}}dt|jksJd t|jvsJt|usJ||usJ||usJt||sJt||rJt||rJ| d t|zksJdS) z- Test using locally scoped ABC class c4eZdZejdZdZdS) test_abc_local..LocalABCcdSr'r r s r r z$test_abc_local..LocalABC.foo\s Drc t|Sr')reprr s r bazz$test_abc_local..LocalABC.baz`s:: rN)rrrrrr rLr rr LocalABCrH[s@           rrMc(eZdZdZfdZxZS)test_abc_local..RealcdS)NTrue!r r s r r z test_abc_local..Real.fooks7rcNdt|zS)NMy )superrL)r Real __class__s r rLz test_abc_local..Real.bazns$5t,,00222 2r)rrrr rL __classcell__)rVrUs@r rUrOjsM    3 3 3 3 3 3 3 3 3 3rrUrQzFailed to raise type errorFNz.RealrS) rr<r=rBr print TypeErrorrr isinstancerLrK)rMlabcrealelabc2pikrUs @r test_abc_localr`Ws3 9X  D x     ::h ' ' ' ' 3333333t333 466D 88::   *+++u      D$$&&>**JE3 T#YY' ' ' ' ' d3ii, , , , , 99D       c5 ! !!! !#t$$$$ $#x(((( ( 7799S ) ) ) ) ) ) )s B B3.B3ctjddi}Gdd}Gdd}||t||rJt||sJt j|||f}t j|\}}}t|t|ksJt||rJt||sJdS)z7 Test calling metaclass and cache registration LocalMetaABCr ceZdZdS)-test_meta_local_no_cache..ClassyClassNrrrr rr ClassyClassrds rrfceZdZdS)-test_meta_local_no_cache..KlassyClassNrer rr KlassyClassrhs drriN)rABCMetaregister issubclassr<dumpsloadsrB)rbrfrireslmabccckcs r test_meta_local_no_cacherss#;~r266L                +&&&+|4444 4 k< 0 000 0 *lK= > >CJsOOME2r ;;$|,, , , , ,"e$$$$ $ b%     r__main__)__doc__r<rrr>typesrsettingsrr%rEr`rsrr rr rxs%  i     #   <$$$$$ $$$.444(/*/*/*b!!!0 zNr__pycache__/test_check.cpython-311.pyc000064400000005151150044142170013572 0ustar00 bgtddlmZddlZddlmZdZdZd dZd dZd dZ d d Z d d Z e d kr4eee e e dSdS) )checkN)capturec  td5}t|fi|dddn #1swxYwYd|vsJnC#t$r6t jd}t t|wxYw |dS#|wxYw)Nstdout Traceback) rrgetvalue Exceptionsysexc_infoAssertionErrorstrclose)funckwdsoutes f/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_check.py raise_checkrs  X   # $  $                  #,,..00000 %%% LNN1 SVV$$$%1  s8A+ A/A/AB)ABB))B?c |dzS)N)xs rrs QTc2tt|dS)Nverboserfrs r test_simpler! s7######rc4ttd|dS)NT)recurserrrs r test_recurser$$s4111111rc4ttd|dS)NT)byrefrrrs r test_byrefr'(sw//////rc4ttd|dS)NT)protocolrrrs r test_protocolr*,sD'222222rc4ttd|dS)N)pythonrrrs r test_pythonr-0s$000000r__main__)N) dillrr dill.temprrr r!r$r'r*r-__name__rrrr2s    M$$$$2222000033331111 zKMMMLNNNJLLLMOOOKMMMMM r__pycache__/test_restricted.cpython-311.pyc000064400000002572150044142170014671 0ustar00 bglddlZGddZeZdZdZedkr edSdS)Nc0eZdZdZexZxZxZxZxZxZ Z dS)RestrictedTypec td)NzRestricted function) Exception)argskwargss k/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_restricted.py__bool__zRestrictedType.__bool__ s-...N) __name__ __module__ __qualname__r __eq____lt____le____ne____gt____ge____hash__r r rr sD///FNMFMVMfMvMM(((r rct}dS)N)glob_obj)as r restricted_funcrs AAAr c`tjtjtd}dS)NT)recurse)dillloadsdumpsr) deserializeds r $test_function_with_restricted_objectr!s$:dj$GGGHHLLLr __main__)rrrrr!r rr r r#s NNNNNNNN >  III z((*****r __pycache__/test_classdef.cpython-311.pyc000064400000045630150044142170014307 0ustar00 bgjddlZddlmZddlZdejd<GddZGddZGd d eZGd d eZ Gd de Z dZ dZ e defe e dZ[ [ eZeZeZe ZeZejdkrddlZGddejeZnGddeeZdZdZdZddlmZedddgZeddZ edddgZ!d e!_"d e!_#e!ddZ$ed!ddgZ%e%ddZ&ed"d#d$gdg%Z'e'd&Z(d'Z)d(Z*d)Z+d*Z,d+Z-Gd,deZ.d-Z/e.e/Z0Gd.d/eZ1d0Z2d1Z3d2Z4d3Z5d4Z6e"d5krzeeee)e*e+e,e-e2e3e5e6dSdS)6N)EnumMetaTrecurseceZdZdZdZdS)_classcdSNselfs i/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_classdef.py_methodz_class._method cdSNTr r s r okz _class.oktrN__name__ __module__ __qualname__r rr rr rr2   rrceZdZdZdZdS)_class2cdSrr r s r __call__z_class2.__call__rrcdSrr r s r rz _class2.okrrNrrrrrr rr rrrrrceZdZdZdZdS) _newclasscdSrr r s r r z_newclass._methodrrcdSrr r s r rz _newclass.okrrNrr rr r r rrr ceZdZdZdZdS) _newclass2cdSrr r s r rz_newclass2.__call__"rrcdSrr r s r rz _newclass2.ok$rrNrr rr r$r$!rrr$ceZdZdS)_metaNrrrr rr r(r('sDrr(cdSrr r s r rr*sDrcdSrr r s r rr,s 4r_mclass)rri ceZdZdS customIntListNr)r rr r/r/< rr/ceZdZdSr.r)r rr r/r/?r0rctjtsJtjtsJtjtsJtjt sJtjt sJdSr)dillpicklesoocnncmr rr test_class_instancesr:Csm <??? <    <??? <    <???rctttttg}t t tttg}d|D}d|D}|D](}t |j )~dD]#}t |$~~t||D]\}}tj|}tj|}|sJ||sJ|j dkrt#|j dksJdS)Nc6g|]}tj|Sr r3dumps.0objs r z&test_class_objects..M 333C 3333rc6g|]}tj|Sr r=r?s r rBz&test_class_objects..NrCr)r5r6r7r8r,r()rrr r$r,r5r6r7r8r9globalspoprzipr3loadsrtype)clslistobjlist_clslist_objlistrAcls_cls_objs r test_class_objectsrQJs9gi 7;GAbmG337333H337333H$$ cl####" c x))22Cz#z#wwyyywwttvv =I % %::&'1111 22rc<tjtdsJtjttsJtjttsJtjtt sJdSr)r3r4rINotImplementedEllipsisrr rr test_specialtypesrUasz <T # ### # <^,, - --- - <X ' ''' ' <X ' ''' '''r) namedtupleZabYXFakeNameDefaultsxy)defaultsczttjtjtusJttjtjtksJt tjtjt usJt tjtjt ksJttjtjtusJttjtjtksJttjtjtusJtj tjtjtj ksJttttjtjtksJGdd}|}tj |sJtj |jjdksJtj |jjdsJtj |jjdksJtj |jjdksJddlmfd }t-tj |d jt-|d jksJdS) Nc PeZdZGddedddgZde_dS)test_namedtuple..AceZdZdZdS)test_namedtuple..A.B docstringN)rrr__doc__r rr Brgs OOOrrjConetwotestingN)rrrrVrjr rr AresO      3//     rrorjz ..A.Brhrnr) NamedTuplec$Gdd}|S)NceZdZUeed<dS)%test_namedtuple..A..Br_N)rrrint__annotations__r rr rjrssFFFFFrrjr )rjrps r roztest_namedtuple..As2         r)rWr3rHr>Zir\Xir^ DefaultsiBad_fieldstupleBadicopyrjrrendswithrirtypingrprI)rorXrps @r test_namedtuplerts  4:a==)) ) ) ) ) DJrNN++ + + + +  4:a==)) ) ) ) ) DJrNN++ + + + + tz$*X"6"677 7 7 7 7  4:i#8#899 9 9 9 9 djC11 1 1 1 1 ;$*TZ__55= = = = = ;;% 4:d+;+; < <== = = = =!!!!!!!! A 9Q<<< 9QS>> "c ) ) ) ) 9QS>> & / / @ @@@ @ 9QS>> ![ 0 0 0 0 9QS>> $ 1 1 1 1!!!!!!  #!!##a&&!! " " /4A<<3L L L L L L Lrc ddl}|d}|jtj|jksJ|tj|ksJdS#t$rYdSwxYw)Nrrt)numpydtyper3r~ ImportError)npdtis r test_dtypersyhhuoox49RX......dinn$$$$$$ sAA A)(A)c ddl}|dg}|f}|tj|ksJdS#t$rYdSwxYw)NrrZ)rarrayr3r~r)rr_r`s r test_array_nestedrsc HHaSMM DDIaLL      s7; A A c ddlGfddj}|dd}tjjs:tj|sJ|jtj|jksJ|dd}tjjs:tj|sJ|jtj|jksJGdd j}|gd }d|_ tjjs:tj|sJ|jtj|jksJdSdS#t$rYdSwxYw) Nrc*eZdZfdZdZfdZdS)&test_array_subclass..TestArraycf||}||_|Sr)asarrayviewcolor)rN input_arrayrrArs r __new__z.test_array_subclass..TestArray.__new__s.jj--22377!  rcd|dSt|t|r|j|_dSdSr) isinstancerIr)r rAs r __array_finalize__z9test_array_subclass..TestArray.__array_finalize__s;;Fc4::..+!$DJJJ++rc<||jfSr)rr)r rs r __getnewargs__z5test_array_subclass..TestArray.__getnewargs__szz$''33rN)rrrrrr)rsr TestArrayrsV      + + +  4 4 4 4 4 4 4rrdgreen)r ceZdZdZdS)'test_array_subclass..TestArray2blueN)rrrrr rr TestArray2rsEEErr)rZrb) rndarrayzerosr3_dillIS_PYPYr4__dict__r~rr)ra1a2ra3rs @r test_array_subclassrs# 4 4 4 4 4 4 4 4 4 4Yrxx}}G 4 4 4z! 9<## # ##;$)B--"88888 !Wz! 9<## # ##;$)B--"88888        Z $ $z! 9<## # ##;$)B--"88888 9 988 sE E E E cGddt}|}tj|}tj|}|jdS)Nc$eZdZedZdS) test_method_decorator..AcdSrr )rNs r testz%test_method_decorator..A.tests rN)rrr classmethodrr rr rors-  {   rro)objectr3r>rH __class__r)rorXresnew_objs r test_method_decoratorrsn     F   A *Q--CjooG rceZdZdZdZdS)r[)r` __weakref__c||_dSrr`r r`s r __init__z Y.__init__ DFFFrNrrr __slots__rr rr r[r[s(")r{ceZdZdZdZdS)Y2r`c||_dSrrrs r rz Y2.__init__rrNrr rr rrs()rrcptjtsJtjtsJtjtjsJtjtjt ksJtjt t jt ksJdSr)r3r4r[r`r~valuerr rr test_slotsrs <??? <??? <    9Q<<>U " " " " 9RYY   !U * * * * * *rcbtjtjtjksJdSr)r3r~r/__orig_bases__r rr test_origbasesrs) 9] # # 2m6R R R R R R RrcddljGfdd}|d}tj||ksJdS)Nrc8eZdZZdS)test_attr..AN)rrribrX)attrsr rors GGIIrrorZ)rsr3r~)rovrs @r test_attrrsxKKK V V !A 9Q<<1      rcGddt}t}tdd||d}tj|sJdS)Nc$eZdZfdZdZxZS)*test_metaclass..metaclass_with_newcxtj||||fi|}|J||sJ|Sr)superrmethod)mclsnamebasesnskwdsrNrs r rz2test_metaclass..metaclass_with_new.__new__sO!%''/$eR@@4@@C###::d## # ##Jrc"t||Sr)r)rNrs r rz1test_metaclass..metaclass_with_new.methodsc4(( (r)rrrrr __classcell__)rs@r metaclass_with_newrsG       ) ) ) ) ) ) )rrzclass subclass_with_new(metaclass=metaclass_with_new): def __new__(cls): self = super().__new__(cls) return selfsubclass_with_new)rIlocalsexecr3r~)rlrs r test_metaclassrs)))))T))) A !!%%%-. 9&&(( ) ))) )))rcddlm}ddl}tj|j|jusJtj|j|jusJdS)Nr) HTTPStatus)httprenumr3r~OKr)rrs r test_enummetarsaKKK 9Z] # #z} 4 4 4 4 9T] # #t} 4 4 4 4 4 4r__main__)7r3rrsyssettingsrrrr r$rIr(rrr,r5r6r7r8r9 hexversionrListrtr/listr:rQrU collectionsrVrWrwr\rrrxrzr}r^ryrrrrrr[rr`rrrrrrr rr rs   i         D       % F982&F&F G G  FHH WYY IKKZ\\ GII>JMMM      C(         S    222.((( #"""""JsSIQqVVJsSI  QqVVjc#Y'' s1Qxx :j3*s ; ; ; HQKK MMMB$$$N    AeHH +++SSS***&555  zOJLLLJLLLNNMOOOOOr__pycache__/test_nested.cpython-311.pyc000064400000015712150044142170014003 0ustar00 bgJ dZddlZddlZddlZdejd<dZGddeZGdd Z Gd d eZ Gd d Z dZ dZ dZdZdZdZdZdZdZdZedkrReeeeeeeedSdS)z0 test dill's ability to handle nested functions NTrecursecdgfd}|S)Nrc |zdzSNr)addendaugendzeros g/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_nested.pyinnerzadder..innersa((r)r r r s` @r adderrs. 3D)))))) Lr ceZdZdZdZdS)cadderc$||_dg|_dSrr r selfr s r __init__zcadder.__init__ C r c2||jz|jdzSrrrrs r __call__zcadder.__call__" #dil22r N__name__ __module__ __qualname__rrrr r rr233333r rceZdZdZdZdS)c2adderc$||_dg|_dSrrrs r rzc2adder.__init__(rr c2||jz|jdzSrrrs r rzc2adder.__call__,rr Nrrr r r!r!'rr r!ceZdZdS)basicNrrrrr r r%r%1Dr r%ceZdZdS)basic2Nr&rr r r)r)5r'r r)cgd}tj|}tjt}tjt}tj|}tj|}tj|}t ttj|t ||j|ksJdS)N)rr+)pickledumpsmathmaploadslistsin)apapmathpmaplalmathlmaps r test_basicr<=s A aB L  E <  D b  B L  E <  D DHa  ! !T$$uy"*=*=%>%> > > > > > >r ctjt}tj|}tjt}tj|}dSN)r.r/r)r2r%)pbasic2_pbasic2pbasic_pbasics r test_basic_classrCIsRl6""G$v|G$$&&H \% F"fl6""$$GGGr ctjt}tj|t}|t tt zksJdSr>)r.r/r!r2xy)pc2adderpc2add5s r test_c2adderrIPsM|G$$H$fl8$$Q''G 71::1      r ctjt}tj|t}|t tt zksJdSr>)r.r/rr2rErF)pcadderpcadd5s r test_pickled_cadderrMVsMl6""G "V\' " "1 % %F 6!99!      r cttt}|tttzksJdSr>)rrErF)add5s r test_raw_adder_and_innerrP\s* 88D 477ac>>>>>>r ctjt}tj|t}|t tt zksJdSr>)r.r/rr2rErF)padderpadd5s r test_pickled_adderrTasG \% F FL  # #E 588qs??????r ctt}tj|}tj|}|t tt zksJdSr>)rrEr.r/r2rF)rOpinnerp5adds r test_pickled_innerrXgsH 88D \$  F L E 588qs??????r cr ddlm}n#t$rddl}YnwxYwd}tj|r9tj|dzrtj|dztj|rVt|drFtj|jr"tjt|dtjdr*tj dstj ddSdSdS)Nr+)test_moduledictrztest_moduledict.pyc __cached__ __pycache__) rZ ImportErrorospathexistsremovehasattrr\getattrlistdir removedirs)rZnames r test_moduledict_where_not_mainrins<%%%%%%%  D w~~dtCx 8 8 $s( w~~d: F F: 7>>/4 5 5: '/<88999 w~~m$$%RZ -F-F% m$$$$$%%%%s  __main__)__doc__r`r0dillr.settingsrobjectrr!r%r)rErFr<rCrIrMrPrTrXrirrr r ros ! 33333V33333333333     F            ? ? ?%%%    %%%" zJLLLLNNN""$$$$$r __pycache__/test_selected.cpython-311.pyc000064400000015372150044142170014313 0ustar00 bg `dZddlZdejd<dZdZdZdZGd d eZdd lm Z dd lm Z e dd e dZ e d e d e d e d e d e d [ dZ dZdZdZedkr4eeee edSdS)z$ testing some selected object types NTrecurseFctj}|D]H\}}tj|}t r$t |dt|d||sJIt rt ddSdSN: , )type__dict__itemsdillpicklesverboseprint)cijoks i/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_selected.pytest_dict_contentsrs m! WWYYca aB7rrr47777AA6777 II2I eRjjjjjc#K|VdSN)xs r_grs77777rcT#t$rddlm}|\}}}||fcYSwxYw)Nr)exc_info) Exceptionsysr)reertbs r_fr#sP  IAr2 r6MMMs "''ceZdZdZdS)_dcdSrr)selfs r_methodz _d._method&sDrN)__name__ __module__ __qualname__r(rrrr%r%%s#     rr%)objects) load_types) pickleable unpickleableClassObjectTypeTemporaryFileTypeTextWrapperTypeBufferedRandomTypeBufferedReaderTypeBufferedWriterTypeFileTypectj}|D]E}tj|}t r$t |dt|d||sJFt rt dtj}|D]E}tj|}t r$t |dt|d||sJFt rt ddSdSr) r%r valuesr r rrr _newclass)drrods rtest_class_descriptorsr<7sk! 88::a aB7rrr47777AA6777 II2I eRjjj" 99;;a aB7rrr47777AA6777 II2I eRjjjjjrczt}t}tj|}tr$t |dt |d||sJtj|}tr$t |dt |d||sJtrt ddSdSr)r%r9r r rrr )ooors r test_classr@Fsdd!{{" |A" 5eRRRa!!4555 )) |B" 7eRRRb226777 )) eRjjjjjrctd}|j}t\}}d}tj|}t r$t |dt|d||rJtj|}t r$t |dt|d||| sJtj|}t r$t |dt|d||rJtj|}t r$t |dt|d||sJt rt ddSdS)Nc|Srr)rs rz$test_frame_related..Vs2rrrr)rgi_framer#r r rrr )gfr t_isrs rtest_frame_relatedrJRsNee!j! #!A # |A" 5eRRRa!!4555 -- |A" 5eRRRa!!4555 V |A" 5eRRRa!!4555 -- |A" 5eRRRa!!4555 )) eRjjjjjrcddl}|j}|tj|ksJ|jt t f}|tj|ksJ|jt }|tj|ksJ|jt t f}|tj|ksJ|jt }|tj|ksJ|jd}|tj|ksJ|jd d}|tj|ksJdS)Nrr) typingAnyr copyDictintstrListTuple copy_with)rLrs r test_typingrUes$--- j! dill     k#s(! dill     k#! dill     l38! dill     l3! dill     l2! dill     l2  $$! dill    &r__main__)__doc__r settingsrrrr#objectr%r,r-r9closer<r@rJrUr)rrrr[s  i             d.... % & ""$$$ """##%%%##%%%##%%%        &   & z *,,, +----- r__pycache__/test_dataclasses.cpython-311.pyc000064400000003415150044142170015005 0ustar00 bgzDdZddlZddlZdZedkr edSdS)z test pickling a dataclass Nc tjGddtjGfdd}dd}||}tj|}tj|}||ksJ||ditj|jksJtj|tj|ksJdS)Nc$eZdZUeed<eed<dS)test_dataclasses..AxyN)__name__ __module__ __qualname__int__annotations__strl/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_dataclasses.pyArs"  rrceZdZUed<dS)test_dataclasses..BaN)rr r r )rsrBrs rrtestr) dataclasses dataclassdilldumpsloadsasdictr)rrbeforesaveafterrs @rtest_dataclassesr!s)           !V A QqTTF :f  D Jt  E U???? QQqq77;-eg667788 8 8 8 8  f % %);E)B)B B B B B B Br__main__)__doc__rrr!rrrrr$sb CCC& zr__pycache__/test_detect.cpython-311.pyc000064400000022062150044142170013765 0ustar00 bgzddlmZmZmZmZmZmZmZddlm Z ddl m Z ddl m Z ddlZddlZddlZdZdZd\ZZZd Zd ZGd d Zd ZdgZGddeZeZdZdZdZ e!dkr>eeeeee dSdS))baditems badobjectsbadtypeserrorsparentat globalvars)settings)IS_PYPY) PicklingErrorNc 8tj}t||gksJt||usJt |t |ksJt t |tusJt |d}t|tsJtt|d t| ksJtt |d t| ksJtdtt |d D}t|}tjds t#|t#|usJd}d| vrt#||us n|dz sJdSdS)Nc@g|]}|jj|jdfS)r) __class____name__args).0errs g/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_detect.py z#test_bad_things..s( Y Y Yccm$SXa[ 1 Y Y YCOVERAGEr )inspect currentframerrrtyper TypeError isinstancedictlistkeyssetvaluesosenvirongetlen)fdsans rtest_bad_thingsr-sA A;;1#     a==A     A;;$q'' ! ! ! ! q ??i ' ' ' 'AA a     1a  %%'' ( (DNN : : : : q! !!## $ $QVVXX 6 6 6 6 Y YT&A,,BUBUBWBW=X=X Y Y YZZA QA :>>* % % 1vvQ A)QVVXX553q66Q;;;1Q3;; >;;;;rc2gd}t|}t|t}||usJtrt|tJnt|t|dusJt t t t usJdS)N))iterrr r intrid)xlistiterobjs r test_parentr:$s AAwwH 4 C !8888+vc3''////S!!QrU**** bff::      r)rrct|dzzS)Nrr+r7s rsquaredr?0s 1a4-rcfd}|S)Nc(t|zSN)r?)yr7s rbarzfoo..bar4s 1::a<r)r7rDs` rfoorF3s! *rceZdZdZdZdS)_classcdSrBrEselfs r_methodz_class._method9 rcdS)NTrErJs rokz _class.ok;strN)r __module__ __qualname__rLrOrErrrHrH8s2   rrHcfd}t|tdddksJttd}t|tdd gksJttd }|iksJtd}t|d}t|tdd gksJt|d }t|tdgksJ~tt}t|td gksJdS) Nctd}dS)Nctd}dS)NctdSrB)crErrhz-test_globals..f..g..hCs r)b)rWs rgz"test_globals..f..gAs A     rr=)rYs rr(ztest_globals..f?s       rrrr;)r+rXrVTrecurser?r+F)r rrFr"r?)r(reszaps r test_globalsr^>s7 a==D1Q/// / / / / S$ ' ' 'C s88sIs+,, , , , , S% ( ( (C "9999 a&&C S$ ' ' 'C s88sIs+,, , , , , S% ( ( (C s88sI;'' ' ' ' ' W  C s88sC5zz ! ! ! ! ! !rc eZdZdZdZdZdS)FoocdSrBrErJs r__init__z Foo.__init__brMrc6tddztd<iS)Nrr)rDrJs r __getstate__zFoo.__getstate__dsQA rcdSrBrE)rKdatas r __setstate__zFoo.__setstate__grMrN)rrPrQrbrdrgrErrr`r`asA        rr`cddlm}m}|ttd}|ddtd|ksJ|ddtd|dzksJdS) NrdumpsloadsctSrBr(rErrztest_getstate..p!rFrZctSrBrmrErrrnztest_getstate..rrorTr)dillrjrkr(rD)rjrkrXs r test_getstaterrls!!!!!!!! E!HHH AA E))U#### q6Q;;;; E))T"""" q6QU??????rcddlm}m}ddlmam}d}dt d<||}tdadab||}|d}dd lma|d|ksJdS) Nrri)sinpic&t||z SrBrtr>s rsincztest_deleted..sinc{s1vvaxrTr[rtrrw) rqrjrkmathrtrur globalspop)rjrkrurx_sincsinc_r\s r test_deletedr~vs!!!!!!!!HY E$KKE ))--  C C E%LLE %((C 477c>>>>>>rc ddlm}m}n#t$rYdSwxYwdtd<|d}|dz}||g|}t }t }t|dd|t usJ|t usJdS)Nr)symbolslambdifyTr[r7r)r[builtin)sympyrr ImportErrorr minrzr )rrr7rCr(zr)s r test_lambdifyrs+++++++++ HY A 1A!aA A Aq$---- 8888  >>>>>>s  __main__)" dill.detectrrrrrrr rqr dill._dillr pickler rsysr$r-r:r+rXrVr?rFrHr^rDobjectr`r(rrr~rrrErrrsWVVVVVVVVVVVVVVVVV  ???$ 1a    """B c     &   CEE&     zOKMMMLNNNMOOOLNNNMOOOOO r__pycache__/test_session.cpython-311.pyc000064400000040413150044142170014200 0ustar00 bg'ddlZddlZddlZddlZddlmZddlmZddlZej ej e dZ dZedkrheejdkrTejdd krCejd d kZeje ezd d ZeeejddlZddlZddlmZddlmcmZddlZddl m!a!m"Z"m#Z#ddl$m%Z&da'da(gda)dZ*dZ+Gdda,tYtRdtNa-GddtBa.t]a/ea0GddZ1dZ2ej3e2edZ4dZ5dZ6dZ7d Z8d!Z9edkrBe5d"#e5d$#e6e7e8e9dSdS)%N)suppress)BytesIOzsession-refimported-%s.pklcddl}|dddt |zdz}d|d|S)Nrz[obj][]z while testing (with refimported=z): ) traceback format_exc splitlinesreplacereprlstrip)errorobj refimportedr lines h/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_session.py _error_linersk    ! ! , , . .r 2 : :7CS MRUDU V VDD9Ddkkmmm TT__main__--childTruemodulec dD])}t|jtjvsJ*dtjvrdtjvsJddl}ddl}dD]5}t|tjdj|usJ6tjj dksJ|rtj|jusJtj |j usJdS#t$r}t|||f|_d}~wwxYw)Njsonurl local_modsaxdomcalendarcmathr)Calendarisleap)globals__name__sysmodulesr%r&__dict__rday_name __module__ complex_loglogAssertionErrorrargs)rrr%r&rs r test_modulesr4!s4 A > >yy~.#+=====,,CK1G1G1GG " " " " " " " "- O Oyy~Z)@)I#)NNNNNN$/:==== >(H,====='59444444   %eS+>>@EJ  sC C C8C33C8)r#)r'r(r.)r1)AliceBobCarolc |dzS)Nrxs rsquaredr=Rs q!t rc |dzS)Nrr:r;s rr?Ss !Q$rceZdZdZdS)Personc"||_||_dSN)nameage)selfrDrEs r__init__zPerson.__init__Us rN)r*r/ __qualname__rGr:rrrArATs#rrAceZdZdZdS)CalendarSubclassc>d|DS)Nc(g|]}t|Sr:)r.).0is r z-CalendarSubclass.weekdays..[s999 999r) iterweekdaysrFs rweekdayszCalendarSubclass.weekdaysZs"99T%6%6%8%89999rN)r*r/rHrRr:rrrJrJYs#:::::rrJcXeZdZeZdZdZdZdS) TestNamespacec ||_dSrC)extra)rFrVs rrGzTestNamespace.__init__bs  rc(t|_tt|jt|j|SrC)r)copybackupclearupdate test_globalsrVrQs r __enter__zTestNamespace.__enter__dseiinn&&   *+++ $$$ rctt|jdSrC)r)rZr[rY)rFexc_infos r__exit__zTestNamespace.__exit__js6  %%%%%rN) r*r/rHr)rXr\rGr]r`r:rrrTrT`sV799>>##L &&&&&rrTc|jddddz}t|dr|jn|}tjtj|jd}tj|ftj |ffD]<\}}tt5||dddn #1swxYwY=dS)N.rrz.pyc __cached__ __pycache__) __file__splithasattrrcospathjoindirnameremove removedirsrOSError)rcachedpycacherlfiles r_clean_up_cacherrns _ " "3 * *1 - 6F")&,"?"? KV  VFgll27??6?;;]KKG)V,r}g.FG  g     F4LLL               s5 C  C C c$ tj}dD],}t|j||jksJ-dD]}||||ksJdD]9}||j|usJ||d||dksJ:t jtjksJttt sJtj |dj ksJtttsJtttsJt|dksJttusJdS#t $r}t#|||f|_d}~wwxYw)Nr)r<emptynames)r=cubedrpersoncal)rr-r)r* __globals__rAr/ isinstancerwrE issubclassrJr'rxrRselfrefr2rr3)main globals_copyr main_dictrrs r _test_objectsrxs% > I IC99S>*l3.?.HHHHHH* 7 7CS>\#%666666' = =CS>-::::!9S>!$$(9 S(9!(<(<<<<<< H$55555&&)))))z\(377777*H55555#/00000||~~e!4!=!=!?!?????("""""" !%k::<  sE$E(( F2F  Fc Ti}|r ddlm}||d<td i|5} tjt |z|ddlm}m}m }| |tdt|g|}|rtj |tt5t!jt |zdddn #1swxYwYnM#tt5t!jt |zdddw#1swxYwYwxYwt%}tj|||dtj|d |jd t,|j|ddddS#1swxYwYdS) zNtest dump/load_module() for __main__, both in this process and in a subprocessr)flagsrr)pythonshellspr)rNrrrr:)r+rrTdill dump_module session_filedill.tests.__main__rrrcallrestrexitrrnrhrlrseek load_modulerYr) r extra_objectsrnsrrrrsession_buffers rtest_session_mainrsM'!& g  ' ' ' 'E2 6  \K7[ Q Q Q Q = = = = = = = = = =GGVXy#k:J:JKSXGYYE %chuooo'"" 6 6 ,4555 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6'"" 6 6 ,4555 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6 6! [AAAAA  ;;;;" /"8RY DDD!EEEEEEEEEEEEEEEEEEsrFA+C FC: FC F C FD'D  DD DD DA4FF!$F!cddltjt_djD}t}tj ||D] }j|= | dtj |tfd|DsJjusJdS)z8test dump/load_module() for a module other than __main__rNc<g|]}|d|S)__) startswith)rMrs rrOz&test_session_other..s*VVVCPTAUAUVCVVVrc3*K|] }|jvVdSrC)r-)rMrrs r z%test_session_other..s*>>#sfo%>>>>>>r) test_classdefatexitregisterrrr|r-keysrrrrrall) dict_objectsrrrs @rtest_session_otherrs"""" OOV,,,FNVV6?#7#7#9#9VVVLYYN^V,,,!! OC ^V,,, >>>>>>> > >>> > >V # # # # # #rc ddlm}d}||}d|_tj|}||ur-t d|j|j|j tj t}tj ||d|}||}tjt|| }|J|j|ksJ|jdksJ|tjvsJ|dtjt|}|j|ksJ|jdksJ|tjvsJdS) Nr) ModuleType __runtime__*z:There are objects to save by referenece that shouldn't be:)rqT)rrr)typesrr<rsession_stash_modulesprint__dill_imported__dill_imported_as__dill_imported_top_levelr+stderrrrgetvaluerr*r,valuesr)rmodnameruntimemodr session_dump return_vals rtest_runtime_modulers      Gj!!GGI , % %g . .C ' J!3#93;X:    YYN^GFFFF!**,,Lj!!G!',"7"7HHHJ      w & & & & 9???? #+,,.. . . . .w|4455G  w & & & & 9???? #+,,.. . . . . . .rcddl}ddl}ddl}ddl}|dx}t jd<|jdt_ |j |_ |j |_tj |_t!}tj||d|dtj|}t jd=t)|jhdksJdS)Nr__test__r) max_workersTr>rexecutor thread_exectypingAsyncContextManagerAsyncCM collectionsUserDictDict)rconcurrent.futuresrrrr+r,futuresThreadPoolExecutorrrrrrrrrrrloadsetr)r concurrentrrrrs rtest_refimported_imported_asrs LLLMMM$)$4$4Z$@$@@C#+j !&99a9HHDM#CH,CKmCOYYN^Sd;;;; )N # #C J s% & &+++      rc$t5t}tj|dxaabt}| dtj |}|tusJt|ksJ|ddksJ|dtksJ|dtusJ|dtksJd|vsJd|vsJ ddddS#1swxYwYdS)Nrr*rrur<yrt) rTrrrr<rrtr)rXrload_module_asdictru)r globals_state main_varss rtest_load_module_asdictrsu $$  ((( A  (( A+N;;  ))))yyM))))$ 2222!U****!....~"""")####)#####)$$$$$$$$$$$$$$$$$$sC(DD  D FrT):rrhr+r contextlibriorrrirjrkrerrr*lenargvrrr4rr urllibr!xmlr#xml.dom.minidomr$minidomtest_dictviewsr"r%r'r(r.r&r1r0r<rtrur=rvrArwrJrxr|rTrrrrrrrrrr:rrrsf  w||BGOOH557STT UUU  zcc#(mmq00SXa[I5M5M8A;&(KD\K/ CCCC2L CHJJJ """"0/////////$$$$$$ !!! a!  :::::x:::  & & & & & & & &+++:EEE4$$$& / / /D.$$$. z%(((($''''  """ r__pycache__/test_dictviews.cpython-311.pyc000064400000005136150044142170014521 0ustar00 bg9ddlZddlmZmZmZdZdZdZedkr eeedSdS)N)OLD310MAPPING_PROXY_TRICK DictProxyTypecPtjtddisJdS)Na)dillcopyrj/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_dictviews.pytest_dictproxyr s* 9]C8,, - --- ---r cddi}tj|sJtj|sJtj|sJdS)Nr)r r keysvaluesitems)xs r test_dictviewsrsk aA 9QVVXX    9QXXZZ   9QWWYY   r ctshtrbddi}||||f}t j|}|d}d|d<d|d<t|dkrt|dksJt|ddkrt|ddksJt|ddkrt|ddksJt|ddkrt|ddksJt|d|ksJt|d|ksJdSdSdS) Nrrrbcr) rrrrrr r lendict)r all_viewsseperate_viewsnew_xs r test_dictproxy_trickr s  0) 0 !HXXZZAFFHHa8 9--r"c c 5zzQ3q66Q;;;.>!$%%**s9Q!$%%**s9Q!$%%**s9Qr$s AAAAAAAAAA...   0 0 0 zNNr __pycache__/test_diff.cpython-311.pyc000064400000007476150044142170013441 0ustar00 bgk xddlmZddlZeed ZGddZdZedkr edSdS))__diffN getrefcountceZdZdS)AN)__name__ __module__ __qualname__e/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_diff.pyrrsDr rct}t}t}||_||_tj|tj|rJd|_tj|sJtj|dtj|rJd|_tj|sJtj|}t |ddgksJ|drJg}|g}|g}tj|tj|rJ|dtj|sJtj|}|diksJ|dsJi}d|i}d|i} tj| tj| rJd|d<tj| sJtj| }|diksJ|dsJtsddl } tj| j dtj| rJd| j _ tj| sJtj| }t |ddgksJ|drJ t}t}t}||_||_tj|tj|rJd|_tj|sJtj|dtj|rJ|`tj|sJtj|}t |ddgksJ|drJdS)NT)forceraABCMeta) rrdiffmemorise has_changed whats_changedlistkeysappendIS_PYPYabcrzzz) rbcchangeda2b2c2a3b3c3rs r test_diffr&s A A A AC ACM!"""" " AC  A   M!4    """" " AC  A    ##G  !! " "se + + + +qz> B B BM"#### #IIaLLL  B    $$G 1:     1:: B RB RBM"#### # BqE  B    $$G 1:     1::    ck....#C((((( $$$$$$S))GAJOO%%&&9+55551:~( A A A AC ACM!"""" " AC  A   M!4    """" "   A    ##G  !! " "se + + + +qz>r __main__) dillrrsyshasattrrrr&rr r r r+s  gc=)) )        VVVr z IKKKKKr __pycache__/test_pycapsule.cpython-311.pyc000064400000004464150044142170014530 0ustar00 bgpdZddlZddlZdZejjddlZdZedkreedSdSdS)z" test pickling a PyCapsule object NcHtjd}tjtjtjjtj|d}tj5tj dtj |dddn #1swxYwY|t_ tj5tj dtj |dddn #1swxYwYdt_ tj5tj dtj tj |dddn #1swxYwYtd#tj$rYdSwxYw)Nsdill._testcapsuleignorezExpected a different error)ctypescreate_string_bufferdill_dill_PyCapsule_Newcastc_void_pwarningscatch_warnings simplefiltercopy _testcapsulePicklingWarningAssertionErrorUnpicklingError)namecapsules j/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_pycapsule.pytest_pycapsulers-*+?@@*++ K 16? C C      $ & &    !( + + + Ig                  $  $ & &    !( + + + Ig                  ! ?(** # #%h0DEEE '""" # # # # # # # # # # # # # # # !!=>> >#    DD sZ5)B**B.1B.)D  D D !F44E4( F4E88F;E8<FF! F!__main__)__doc__rr rrrr__name__rrs :&MMM???0 z!!!r__pycache__/test_source.cpython-311.pyc000064400000024532150044142170014021 0ustar00 bgddlmZmZmZmZddlmZddlmZddlZdZ dZ dZ dZ Gd d e ZeZd Zd ZGd dZeZdZdZdZdZdZdZdZdZdZedkr\eeeeeeeeedSdS)) getsourcegetname_wrap likely_import) getimportable)IS_PYPYNi c |dzSNxs g/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_source.pyrs adc&t||z SN)fr s rgrs1/rc$d}|||z S)Nc|Srr r s rrz h..gs1Hrr )rrs rhrs 1/rceZdZdZdS)Fooc||z|zSrr )selfrs rbarzFoo.bars Q3q5LrN)__name__ __module__ __qualname__rr rrrrs#rrc ||zSrr )rys raddr#s 1*rc |dzSr r r s rrr s 1a4rceZdZdS)BarN)rrr r rrr&r&"s$rr&cttdksJttdksJttdksJt tdksJt tdksJt tdksJt tddksJt tdd ksJt tdd ksJt t d ksJt td ksJttd ksJtt dksJdS)Nzf = lambda x: x**2 zdef g(x): return f(x) - x z1def h(x): def g(x): return x return g(x) - x rrr rrr&class Bar: pass 8class Foo(object): def bar(self, x): return x*x+x )rrrrrrrr&r rrtest_getsourcer-'sP 1/ / / / / 16 6 6 6 6 1O O O O O s     s     s     q!     q!     q!               31 1 1 1 1 3X X X X X X Xrc:ttdksJdS)Nz&from dill.source import likely_import )rr rr test_itselfr/9s" } % %'P P P P P P PrczttdksJtddksJtddksJttddksJtdddksJtdddksJtddksJtdddksJdS) Nzpow d100 TzTrue explicitzfrom builtins import pow None )rpowr rr test_builtinr7=s s  w & & & & s  w & & & & t   ( ( ( ( sT * * *.J J J J J sT * * *g 5 5 5 5 td + + +x 7 7 7 7 t   ( ( ( ( td + + +x 7 7 7 7 7 7rc<ddlm}t|dksJdS)Nrsinzfrom math import sin )mathr:rr9s r test_importedr<Js4 s  7 7 7 7 7 7 7rcttdtzksJttdtzksJdS)Nfrom %s import add from %s import squared )rr#rsquaredr rr test_dynamicrAOsF s  5@ @ @ @ @ w  #=#H H H H H H HrcFddlm}d}tstjt kr|nd}|}t ||ksJt ||ksJt tdtzksJt tdtzksJdS)Nr)BytesIOzfrom _io import BytesIO zfrom io import BytesIO from %s import Foo ) iorCrsys hexversionPY310brrr_foo)StringIOr"rss r test_classesrLUs$$$$$$!! Ps~//aa6P!hjj! x A % % % % q  Q     s  5@ @ @ @ @ t   6 A A A A A A ArcttdtzksJttdtzksJttdtzksJttjdtzksJtt jdtzksJtddksJtddksJttd d ksJttd d ksJtdd dksJttd d ksJttd d ksJttjd dksJttjd dtzksJttjdddtzksJttdddtzksJttdddtzksJttdddksJttdddksJtddddksJtddddksJttddtzksJttddtzksJttddtzksJttjddtzksJtt jddtzksJtdddksJtdddksJdS)Nr>r?rDzfrom %s import bar r5r1r2Fbynamezdef add(x,y): return x+y zsquared = lambda x:x**2 r+r,z!def bar(self, x): return x*x+x Tmemo)aliasrOzfrom %s import bar as memo zfrom %s import Foo as memo zfrom %s import squared as memo zmemo = squared = lambda x:x**2 z'def add(x,y): return x+y memo = add z memo = None z memo = 100 r3)rr#rr@rrrIr&r rrtest_importablerRcs s  5@ @ @ @ @ w  #=#H H H H H s  5@ @ @ @ @ sw  #9H#D D D D D tx $:X$E E E E E t   ( ( ( ( s  w & & & & s5 ) ) )-L L L L L wu - - -1L L L L L tE * * *h 6 6 6 6 s5 ) ) )-C C C C C s5 ) ) )-j j j j j swu - - -1V V V V V swt , , ,0F0Q Q Q Q Q swfT : : :>\_g>g g g g g s& 6 6 6:X[c:c c c c c wfT : : :>`ck>k k k k k wfU ; ; ;?a a a a a s& 7 7 7;h h h h h t6% 8 8 8O K K K K s& 7 7 7> I I I I sT * * *.Dx.O O O O O w . . .2Lx2W W W W W sT * * *.Dx.O O O O O sw . . .2H82S S S S S tx$ / / /3IH3T T T T T td + + +x 7 7 7 7 sT * * *g 5 5 5 5 5 5rc  ddlm}|gd}t|dksJt|d|jzksJt|ddksJt|dd|jzksJdS#t$rYdSwxYw)Nr)array)r z)from numpy import array array([1, 2, 3]) zfrom %s import array FrN)numpyrTrr ImportError)rTrs r test_numpyrYs gggA   L L L L L   #;e>N#N N N N N 5 ) ) )-Z Z Z Z Z u - - -1IEL\1\ \ \ \ \ \ \ dddsA;A?? B  B c\ttddsJdS)NFrNzOimport dill class Foo(object): def bar(self, x): return x*x+x dill.loads()rrI startswithr rrtest_foor\sH tE * * * 5 57L M MMM MMMr__main__) dill.sourcerrrrr dill._dillrrFrHrrrobjectrrIr#r@r&_barr-r/r7r<rArLrRrYr\rr rrrbsA@@@@@@@@@@@%%%%%% N& suu    - suuYYY$QQQ 8 8 8888 III B B B666@MMM zNKMMMLNNNMOOOLNNNLNNNOJLLL HJJJJJr__pycache__/test_extendpickle.cpython-311.pyc000064400000004636150044142170015203 0ustar00 bg#dddlZddlmZdZdZdZedkreedSdS)N)BytesIOc |dzS)N)xs m/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_extendpickle.pymy_fnr s r6McPd}|dksJt}tj|}|||}t|}tj|}|}|dksJdS)Nc tdS)N")r rr rztest_extend..s 599r iB)StringIOpicklePicklerdumpgetvalue Unpicklerload)objobj_iopicklerobj_strobj2_io unpicklerobj2s r test_extendrs  C 355C<<<< ZZFnV$$G LLooGwG ))I >>  D 466S======r ct}tj|}tj|dusJtj|}tj|dusJ ddl}|j|}tj|ddusJtj|ddusJdS#t$rYdSwxYw)NTFr)child) rrr_dillis_dill StockPickler multiprocess reductionForkingPickler Exception)rrmps r test_isdillr("s  ZZFnV$$G <   ( (D 0 0 0 0l''//G <   ( (E 1 1 1 1 !!!!,--f55|##G4#88D@@@@|##G5#99UBBBBBB      s A(C33 DD__main__) dillriorrr rr(__name__rr rr-s"""""""   " zKMMMKMMMMMr __pycache__/test_temp.cpython-311.pyc000064400000011744150044142170013467 0ustar00 bg; ddlZddlmZmZmZmZddlmZmZmZm Z ej dddkZ dZ gdZ dZd Zd Zd Zd Z d ZdZGddeZeZdZdZGddZeZdZdZdZedkrHeeeeeeedSdS)N)dump dump_sourcedumpIO dumpIO_source)load load_sourceloadIO loadIO_sourcewinc |dzSNxs e/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_temp.pyr ad)rr ctsCttd}t|}|dtdksJdSdSN_faliasr)WINDOWSrfrpyfilers rtest_code_to_tempfiler#sU Qd+++  r!uu!}}}}}rcttd}t|}|dtdksJdSr)rr r r!s rtest_code_to_streamr%s@ 1D ) ) )F v  B 2a55AaDD======rcxts0tt}t|}|tksJdSdSN)rrrrdumpfile_xs rtest_pickle_to_tempfiler+ s> 77 (^^Qwwwwwrcftt}t|}|tksJdSr')rrr r(s rtest_pickle_to_streamr-'s+ayyH   B 777777rc |dzSrrrs rrr-rrc&t||z Sr')r rs rgr0.s1/rc$d}|||z S)Nc|Sr'rrs rr0z h..g1s1Hrr)rr0s rhr30s 1/rceZdZdZdS)Fooc||z|zSr'r)selfrs rbarzFoo.bar5s Q3q5LrN)__name__ __module__ __qualname__r8rrrr5r54s#rr5c ||zSr'r)rys raddr>9s 1*rc |dzSrrrs rrr=s 1a4rceZdZdS)BarN)r9r:r;rrrrArA?s$rrActfD]>}t|d}t|}|dd|ddksJ?dS)N_objrrr)r>rr objr"rCs rtest_two_arg_functionsrFEsdU!!c 3f - - -F  D 4!99Aa !!rctttfD]<}t|d}t |}|d|dksJ=dS)NrCrr)r0r3squaredrr rDs rtest_one_arg_functionsrILsdG_c 3f - - -F  D 477cc!ff     rctttjtjfD]4}t |d}t |}|j|jksJ5dS)NrCr)rAr5r8_foorr r9rDs r test_the_restrLYs_3 *))c 3f - - -F  D =CL ( ( ( ( ())r__main__)sys dill.temprrrrrrr r platformrr rr#r%r+r-r0r3objectr5rKr>rHrA_barrFrIrLr9rrrrSs  >>>>>>>>>>>>>>>>>>>>>>>> ,rr e #NKK  N& suu    - suu!!!))) zMOOOOOr__pycache__/test_fglobals.cpython-311.pyc000064400000006210150044142170014303 0ustar00 bgddlZdejd<dZdZdZdZdZed kr>ddlZej dd d ksej d d kreedSdSdS) NTrecursec d}|S)Ncfddl}|jdddS)Nrz 04-01-1943z%d-%m-%Y%Y-%m-%d %H:%M:%S)datetimestrptimestrftimers i/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_fglobals.pyfun_with_strftimez0get_fun_with_strftime..fun_with_strftime s9 )), CCLL    )r s r get_fun_with_strftimer s   r cbddl}|jdS)Nrr)rnowr r s r get_fun_with_strftime2rs/OOO   " " + +,? @ @@r ctjtjt}|dksJtjtjt}|t ksJdS)Nz1943-01-04 00:00:00)dillloadsdumpsrr)back_fndupls r test_doc_dill_issue_219rsxj$9$;$;<<==G 799- - - - - :dj!788 9 9D 466+-- - - - - - -r c d}|S)Nc4ddl}|dS)Nr$)recompile)rs r fun_with_importz5get_fun_with_internal_import..fun_with_import!s zz#r r)rs r get_fun_with_internal_importr s r cTddl}tjtjt }ddl}t |dr/||}|jiksJ|j iksJ|| dksJd|j vsJdS)Nrgetclosurevarsr __builtins__) rrrrr inspecthasattrr"globals nonlocalsr __globals__)rrr$varss r ,test_method_with_internal_import_should_workr*'s IIIj$@$B$BCCDDGNNNw())$%%g..|r!!!!~#### 799 3 ' ' ' ' W0 0 0 0 0 0 0r __main__)r, ralpha) rsettingsrrrr r*__name__sys version_inforr r r3s  iAAA ... 1 1 1 zJJJ !((C,>  UCA DJq... / /B 7af     7799 7799 GGIIIHHJJJ UCAGGGz!5)))H VF FFHHEGGIII H  B WF WWYYF WFHHYHHJJJ !!!E{{!!Y....{{{{{ $% % %E{{!!^3333 $/ ! !E{{!!^33333e;<<<LLL UCAGGGz!5)))H VF FFHHEGGIII H  B WF WWYYFHHYHHJJJ V     ###E{{!!^3333 $# # #E{{!!^3333 $/ ! !E{{!!^33333e;<<<  UCA 6688Dz!5)))H VF FFHHEGGIII E E * * *Edj8+|<<<<<< Z ! !w&    D' ' '7799%%%%7799???? GGAJJJ7799%%%%7799%%%%% d' ' '7799>>>>7799%%%%7799%%%%% do % %7799%%%%7799???? GGAJJJ7799$$$$7799%%%%%7%?@@ @   UCAGGGz!5)))H VF FFHHEGGIII ;;    D UCAGGCLLL VVXXFGGIIIdj8+|<<<<<< Z ! !   D' ' ';;##%%3333V####V##### d' ' ';;##%%2222V####Q;;;;; do % %;;##%%7777V####U?????7%?@@ @  LLL UCAGGGz!5)))H VF FFHHEGGIII ;;    D UCAGGCLLL VVXXFGGIIIdj8+|<<<<<< Z ! !    D' ' ';;##%%3333V##### d' ' ';;##%%3333V##### do % %;;##%%7777U?????7%?@@ @   UCA 6688Dz!5)))H VF FFHHEGGIIIIedj8+y999999 Z ! !w&    D' ' '7799???? GGAJJJ7799????7799>>>>> do % %7799%%%%7799???? GGAJJJ7799$$$$7799%%%%% d' ' '7799>>>>7799????7799>>>>>7%?@@ @   UDAGGGz!5)))H FFHHE VFGGIIIIeAdj8+y999999 Z ! !   D' ' ';;##%%2222T>>>>Q;;;;; d' ' ';;##%%2222V####Q;;;;; do % %;;##%%7777V####U?????7%?@@ @LLL UCAGGGz!5)))H FFHHE VFGGIIIIeAdj8+y999999 Z ! !    D' ' ';;##%%2222Q;;;;; d' ' ';;##%%2222Q;;;;; do % %;;##%%7777U?????7%?@@ @  UCA 6688Dz!5)))H VF FFHHEGGIII E E * * *E H  B 7f     ###wwyyE!!!!wwyyE%&&M))))  wwyyE!!!!wwyyE!!!!! $# # #wwyyA~~~~wwyyE!!!!wwyyE!!!!! $/ ! !wwyyE!!!!wwyyB  wwyyD    wwyyE!!!!!3e;<<<HHJJJ UCAGGGz!5)))H VF FFHHE ;;    DGGO VVXXFGGIII H  B WF WWYYFHHYHHJJJ ###E{{!!%99999 $# # #E{{!!Y....{{{{{ $/ ! !E{{!!^33333e;<<<HHJJJLLL UCAGGGz!5)))H VF FFHHE ;;    DGGO VVXXFGGIII H  B WF WWYYFHHYHHJJJ V     ###E{{!!%@@@@@ $# # #E{{!!%@@@@@ $/ ! !E{{!!^33333e;<<<HHJJJJJrcXtdtjdtdSNF)rRr7r=r+rrrtest_nostrictio_handlefmoderUs) %"E***rcXtdtjdtdSrT)rRr7r?r+rrrtest_nostrictio_filefmoderWs( %%(((rcXtdtjdtdS)NFT)rRr7r>r+rrrtest_nostrictio_contentsfmoderYs) %$d+++r__main__)r)r'r stringrr7settingsr list ascii_lettersr ValueErrorrAFileNotFoundErrorrCrrr%r+rRrUrWrY__name__rrrrbsS   i T&& ' '4&2+ 5 z/00  IEQ R R  cccL    z!!!!!#####r__pycache__/test_weakref.cpython-311.pyc000064400000006145150044142170014145 0ustar00 bgBddlZdejd<ddlZGddZGddZdZd Zd Zed kredd l m Z e sedSdSdS) NTrecurseceZdZdZdS)_classcdSNselfs h/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_weakref.py_methodz_class._method N)__name__ __module__ __qualname__r rrr rr #     rrceZdZdZdS)_callable_classcdSrrr s r __call__z_callable_class.__call__r rN)rrrrrrr rrrrrcdSrrrrr _functionrsDrc t}t}t}t}tj|}tjt}tj|}tj|}tj|}tjt} tj|} tjt} tj|} tj|} |||||| | | | | g }|D];}t j|}|rt|d||rJrCs  i                   B### zLNNN""""""  r__pycache__/test_functions.cpython-311.pyc000064400000017704150044142170014534 0ustar00 bg ddlZddlZddlZdejd<dZdZddZddZd e_e d da ej dd Z d Z d ZdZdZedkr eeedSdS)NTrecursec|SN)as j/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_functions.py function_ar s Hc ||zSrr)bb1s r function_br r6Mr c ||zSrr)cc1s r function_crrr c||z|zS)z doc stringr)dd1d2s r function_drs r6B;r za modulezE def function_e(e, *e1, e2=1, e3=2): return e + sum(e1) + e2 + e3c$t|z atSr) globalvar)xs rfunction_with_cacher'sNI r c fdS)NFcSrrvaluesrz3function_with_unassigned_variable..1sEr rr s@r!function_with_unassigned_variabler#.s MMMr cGdd}ddl}ddl}|}|j|}||usJdS)NceZdZdZdS)test_issue_510..Fooc@d}|||_dS)Nc|Srr)selfs rf2z0test_issue_510..Foo.__init__..f29s# r )__get__r*)r)r*s r__init__z$test_issue_510..Foo.__init__8s($$$**T**r N)__name__ __module__ __qualname__r,rr rFoor&7s# + + + + +r r0r)dill pickletoolscopyr*)r0r1r2ff1s rtest_issue_510r64sw++++++++  A 1B 5577b======r c~tjt}tj|ddksJtjt}tj|dddksJtjt }tj|ddksJtj|dddksJtjt }tj|jt jksJtj|jt jksJtj|dddksJtj|ddddksJtj|ddddksJtdd}tjt}tddksJtddksJtddksJtddksJt}tjtj|}dt|j dvsJ |td #t$rYnwxYwtd dS) Nrr)remptyz&cell_copy() did not read an empty cella_ 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)r1dumpsr loadsrrr__doc__r.rr#str __closure__AssertionError Exceptionexec) dumped_func_a dumped_func_b dumped_func_c dumped_func_drdumped_func_cache empty_cell cell_copys rtest_functionsrLCsJz**M $4:m $ $Q ' '1 , , , ,Jz**M $4:m $ $Qq ) )Q . . . .Jz**M $4:m $ $Q ' '1 , , , , $4:m $ $Q * *a / / / /Jz**M :m $ $ , 0B B B B B :m $ $ /:3H H H H H $4:m $ $Q * *a / / / / $4:m $ $Q1 - - 2 2 2 2 $4:m $ $Qa 0 0 0A 5 5 5 5I #677 q ! !Q & & & & q ! !Q & & & & q ! !Q & & & & q ! !Q & & & &244J 4:j1122I c)/233 3 3 3 3G EFFF        ?@@@@@s J J+*J+c" ddl}ddlm}m}m}m}t j |dtt dd}|j r|j d= fd|D dd d | d d d d  d d dd dd|D]\}}}t fd|D} || |dkr| d g| RO#t$r(} td|| d} ~ wwxYwdS)Nr)ALL_CODE_PARAMS CODE_PARAMS CODE_VERSION _create_codeignore)category co_lnotabr c8i|]}|td|zS)co_)getattr).0r4codes r z$test_code_object..xs) = = =AauQw'' = = =r posonlyargcountlnotab linetablequalnamenameexceptiontable endlinetable columntablec3(K|] }|V dSrr)rXpfieldss r z#test_code_object..s'771VAY777777r )r9 z6failed to construct code object with format version {})warnings dill._dillrNrOrPrQr__code__filterwarningsDeprecationWarningrWfilters setdefaulttuplesplitrCformat) rhrNrOrPrQLNOTABversion_paramsargserrorrYres @@rtest_code_objectrxqsOOOSSSSSSSSSSSS  D H/ABBB T; , ,F0X-a0 = = = = = = =F '+++ h''' k3''' j&.111 &,,, nd+++ mT***-qqF7777 77777 q L$  &   VH-55555 q q qT[[\cddeekp p q qqs?E F $#FF __main__)r) functoolsr1syssettingsr rrrr.rDr lru_cacherr#r6rLrxr-rr rr~sS  i   # $%%%  T    ,@,@,@\qqq2 zNNr __pycache__/test_functors.cpython-311.pyc000064400000003132150044142170014355 0ustar00 bgjddlZddlZdejd<dZd dZd d Zd Zed kr edSdS)NTrecursecdSNabcs i/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_functors.pyfr DcdSrrrs r grr rcdSrrrs r hrr rctjtdd}tjtdd}tjtdd}tjt d}t j|dsJt j|dsJt j|dsJt j|dsJdS)Nrr)r )baseT)safe) functoolspartialr rrintdillpickles)fpgphpbps r test_functoolsr"s  1a # #B  1a1 % % %B  1a1 % % %B  3Q ' ' 'B < & & &&& & < & & &&& & < & & &&& & < & & &&& &&&r__main__)r)rrr)rrsettingsr rrr"__name__rrr r&s  i            ' ' ' zNr__pycache__/test_logger.cpython-311.pyc000064400000010314150044142170013771 0ustar00 bgQ hddlZddlZddlZddlZddlmZddlmZmZ ddl m Z n#e $r ddl m Z YnwxYwde de eddZd Zd Zed krejeed ejded ejd ed ejZejeej5ed Zdddn #1swxYwYed ejeksJeedSdS)N)detect)stderr_handleradapter)StringIO)c |dzS)Nr)xs g/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_logger.pyr s q!t )abfbigct}tj|}tj| t jt|rtj d}| D]}| |sJ| tj ||S| dksJ tj ||dS#tj ||wxYw)Nu/(\S*┬ \w.*[^)]|│*└ # \w.* \[\d+ (\wi)?B]))rlogging StreamHandlerlogger addHandlerdilldumpstest_objrecompilegetvalue splitlines fullmatch removeHandlerclose) should_tracebufferhandlerregexlines r test_loggingr)s9 ZZF#F++G g  8  +J B!!E))4466 - -t,,,,,,??$$ W%%% ??$$*****W%%%  W%%% sBD(#D((*Ec(tjd}tj|jd5t jtdddn #1swxYwY|}| tj d}| d|| d|}}tj d}| d|| d|}}||ksJdS)Nr)modewz0x[0-9A-Za-z]+0xz(dict\.__repr__ of ).*z\1{}>) tempfileNamedTemporaryFilertracenamerrrreadr#rrsub) stream_tracefile file_tracereghexregdicts r test_trace_to_filer:*s-  &C 0 0 0D dic * * * 8JJJLLL Z) * *F%zz$ ;;VZZl=[=[ Jj233G&{{8Z@@'++hXdBeBe J  % % % % % %sAAA__main__F)r$T)rrr/rr dill.loggerrrrr ImportErrorioobjectlistrangerr)r:__name__r"r1ERRORloglevelsetLevelr5getEffectiveLevelr rr rGsD  99999999!!!!!!!ffhh^^DDrOO T T& & & & zF(((Le$$$$FLLd####FLLe$$$$}HFOH 77#|666 777777777777777Le$$$$ #6 # % % 1 1 1 1|$$$$$s' 55 C99C=C=__pycache__/test_mixins.cpython-311.pyc000064400000017255150044142170014034 0ustar00 bgddlZdejd<dZddZeddd Zegd Zdd Zedd d dZeZ dZ e dZ dZ e dkr e dSdS)NTrecursec.fd}fd}fd}||fS)NcSNxsg/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_mixins.pyzzzzwtf..zzz HcSrr)ysr yyyzwtf..yyyr r cSrr)zsr xxxzwtf..xxxr r r)r rrr rrs``` r wtfr sY               S.r c2dgfdfd}|S)NFc d d<dS)Nrr)invertedsr invertzquad..invertsqk/HQKKKr cFfd}|_|_|_|S)NcL|i|}dr| }|dzz|zzzS)Nrr)argskwdsr abcfrs r funczquad..dec..funcsB !T T  a !1"a q!tVac\A r ) __wrapped__rr)r"r#rr r!rrs` r deczquad..decsNDDKDM Kr r)rr r!r%rrs``` @@r quadr&s[W(""""" *r r)rr c t|Sr)sum)rs r double_addr)'s Tr )rrcfd}|S)Ncfd}|S)Nc6|i|}|dzz|zzzSNrr)rrfxrr r!r"s r r#z'quad_factory..dec..func2s/ 1d?T??b r1uWqt^a r r)r"r#rr r!s` r r%zquad_factory..dec1s3         Kr r)rr r!r%s``` r quad_factoryr00s/ *r )rr r!c |dzS)Nrrrs r quadishr39 1*r cfd}|S)Nc|i|}d|zSr.r)rrr/r"s r innerzdoubler..innerBs D D  B R4Kr r)r"r7s` r doublerr8As# ,r c d|zSr.rrs r quadrupler:Hr4r ctddddtzksJttddddtzksJtjt}|ddddtzksJ|dddtksJtjdsttj}tj}| | tddksJ| | tddksJ| td d tzksJ| td d tzksJ| td d tzksJ| td dtzksJ| td dksJ| td }|dd\}}}}}|dksJt#|||gt#gdksJ| td }|dd\}}}}|dksJt#|||gt#gdksJ| td }|dd\}}}}}}|dksJt#||||gt#gdksJdS)Nrrr*rr"z8@quad_factory(a=0,b=4,c=0) def quadish(x): return x+1 z(@doubler def quadruple(x): return 2*x F)sourcezfrom %s import quadish zfrom %s import quadruple zfrom %s import quadratic zfrom %s import double_add Tzdef doubler(f): def inner(*args, **kwds): fx = f(*args, **kwds) return 2*fx return inner @doubler def quadruple(x): return 2*x  r1zdef 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 )a = 0c = 0zb = 4zl def dec(f): def func(*args,**kwds): fx = f(*args,**kwds) return a*fx**2 + b*fx + c return func )za = 1r@zb = 1adef 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) )r?r@zb = 2zinverted = [True])r)r/rdillcopyr$rr=detect getsourcefreevarsr3r: importable__name__ quadraticsplitset) _ddsddresultrr r!_ds r test_mixinsrRMs Aa  ad " " " "  Aa  be # # # # y" Aabe     !A  " $ $ $ $  Q  {" {" bkk'**3/ 0 04q q q q q bkk),,S1 2 26c c c c c wu - -1Kh1V V V V V y / /3ORZ3Z Z Z Z Z y / /3ORZ3Z Z Z Z Z z% 0 04QT\4\ \ \ \ \ y . .3L L L L L === . .&<<Q''.!Aa& { { { { { a!W88899 9 9 9 9 ==4= 0 0&d1%%,!Aa H H H H H a!W88899 9 9 9 9 ==D= 1 1&\\$q))!Aa!F o o o o o a!AY3OOOPP P P P P P Pr __main__)rrr)rBsettingsrr&r)r(r/r0r3rIr8r:rRrHrr r rUs(  i     A S\\    A    LNN      'Q'Q'QV zKMMMMMr __pycache__/test_module.cpython-311.pyc000064400000006506150044142170014007 0ustar00 bgddlZddlZddlZddlmZdejd<eedrejn#ej ddddzZ d e_ ej eZde_ ejej=[ejeZd Zee ejd e_ ej eZde_ ejej=[ejeZd Zn#e$rd ZYnwxYwddlZeje reje ejejej d Zejer ejesejeddlZdZ e deZ!dZ"edkr eee"dSdS)N)reloadTrecurse __cached__.z.pyccXtjddddtjzksJdS)Nr)module double_addfxg/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_module.pytest_attributesrs.  Q1 % %VY 6 6 6 6 6 6rcttdrtjdksJtjddddtjzksJdS)Narrr r )hasattrr rr rrrrtest_diff_attributesr3sPvs##8D(8(8(88 Aq))Q]::::::rcdSNrrrrrr8s r __pycache__c $t||dSr)eval)strkwargs r get_lambdarGs UD ! !!rzlambda x: math.exp(x))mathctjJtjtdtdksJdS)Nr )obj __module__dillcopyrrrtest_module_is_noner%Ls? > ! ! ! 49S>>!  A & & & & & &r__main__)#sysr# test_mixinsr importlibrsettingsrr__file__splitcachedrdumpspik_modmodules__name__loadsruse_diffrAttributeErrorospathexistsremovejoindirnamepycachelistdir removedirsrrr!r%rrrr>s  i&wv|<< 9&  $$S!,,Q/&8  $*V   K  G  777 v DMOOOFHdj  GFH FO$ TZ F;;;;          7>>& BIf ',,rwv77 G G7>>':2:g#6#6BM' """j(t444'''  zOsAC..C98C9__pycache__/test_objects.cpython-311.pyc000064400000005666150044142170014161 0ustar00 bg*8dZddlZdejd<ddlmZmZmZeddGdd ZiZd xed <Z ej xed <Z ej ed <ej eddZ dZ edkr ddlZejde dSdS)z demonstrate dill's ability to pickle different python types test pickling of all Python Standard Library objects (currently: CH 1-14 @ 2.7) NTrecurse) load_typesobjectsextendF) pickleable unpickleableceZdZdZdS)_classcdSN)selfs h/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_objects.py_methodz_class._methods N)__name__ __module__ __qualname__rr rrr r s#     rr cfdS)NcSr r )yxs rz..!sarr )rs`rrr!s KKKKr LambdaType MethodTypeUnboundMethodTypec t|} tjtj|}|r` ||ksJdS#t$rHt |t |ksJt d|dt |YdSwxYwt |t |ksJdS#t$r&t d|dt |YdSwxYw)z'quick check if object pickles with dillzweak:  zfails: N)rpickleloadsdumpsAssertionErrortypeprint Exception)nameexactobjpiks rpicklesr*&s $-C 3l6<,,--  * :czzzzzz! : : :CyyDII----d3iii8999999 :99S )))))) 333 tCyyy12222223s/(B;AABB;B%B;;,C+*C+cTtjD]}t|ddS)NF)r')rkeysr*)members r test_objectsr.7s7,..%%e$$$$$%%r__main__ignore)F)__doc__dillrsettingsrrrr special_lambdarupdater*r.rwarnings simplefilterr rrr9s9 !  -,,,,,,,,, d....        "7"77 "(&(("22 %~w3333"%%%  zOOOH(###LNNNNNr__pycache__/test_moduledict.cpython-311.pyc000064400000004473150044142170014654 0ustar00 bgddlZdejd<dZedZdZddlZddlZejejGdd e Z e Z d Z d Z d Zed kr ee edSdS)NTrecursec d}|S)Nct|SN)f)argss k/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_moduledict.pywz f..w s d8O)funcr s r rr s (r cdSrr r r r f2rs $r c<tjtsJdSr)dillpicklesrr r r test_decoratedrs b   r )levelceZdZdZdS) SomeUnreferencedUnpicklableClassctr) Exception)selfs r __reduce__z+SomeUnreferencedUnpicklableClass.__reduce__sr N)__name__ __module__ __qualname__rr r r rrs#r rc0tjd}dS)Nc|Srr )xs r ztest_normal..%sar )rdumps) serializeds r test_normalr$$sKK((JJJr cdS)z2 >>> serialized = dill.dumps(lambda x: x) Nr r r r testsr&(s  Fr c,tjdSr)doctesttestmodr r r test_doctestr*/s Or __main__)rsettingsrrrr(logging basicConfigDEBUGobjectr unpicklabler$r&r*rr r r r2s  i   '-((((v/.00 )))    zNKMMMLNNNNNr __pycache__/test_properties.cpython-311.pyc000064400000005146150044142170014715 0ustar00 bgBddlZddlZdejd<GddeZdZdZdZed kr eeedSdS) NTrecursec8eZdZdZdZdZeeeZdS)Foocd|_dSN_dataselfs k/builddir/build/BUILD/cloudlinux-venv-1.0.7/venv/lib/python3.11/site-packages/dill/tests/test_properties.py__init__z Foo.__init__  c|jSNr r s r _get_dataz Foo._get_datas zrc||_dSrr )r xs r _set_dataz Foo._set_datarrN)__name__ __module__ __qualname__rrrpropertydatarr rrsN 8Iy ) )DDDrrctjt}|jjJ|jjJ|jjJdSr)dillcopyrrfgetfsetfdel)FooSs r test_data_not_noner$sE 9S>>D 9> % % % 9> % % % 9> ! ! ! ! !rctjt} |j}|dksJdS#t$r6t jd}tt|wxYwr rrrr Exceptionsysexc_infoAssertionErrorstr)r#reses r test_data_unchangedr.#su 9S>>Ddffk axxxxxx %%% LNN1 SVV$$$%s 4AA4ctjt} |}d|_|j}|dksJdS#t$r6t jd}tt|wxYw)Nirr&)r#fr,r-s r test_data_changedr1.s 9S>>D DFFf d{{{{{{ %%% LNN1 SVV$$$%s =AA=__main__) r(rsettingsobjectrr$r.r1rrrr r5s  i * * * * *& * * *"""    zrtest_abc.py000064400000007376150044142170006715 0ustar00#!/usr/bin/env python """ 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 not type(instance) 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) # TODO should work like it does for non local classes # # .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() test_check.py000064400000002564150044142170007237 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_classdef.py000064400000015770150044142170007751 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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('..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 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_dataclasses.py000064400000001572150044142170010447 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Author: Anirudh Vegesana (avegesan@cs.stanford.edu) # Copyright (c) 2022-2023 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() test_detect.py000064400000007763150044142170007440 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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 assert len(s) is len(a) # 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() test_dictviews.py000064400000002471150044142170010160 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Author: Anirudh Vegesana (avegesan@cs.stanford.edu) # Copyright (c) 2021-2023 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() test_diff.py000064400000005153150044142170007067 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_extendpickle.py000064400000002443150044142170010635 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_fglobals.py000064400000003214150044142170007744 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2021-2023 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() test_file.py000064400000032412150044142170007074 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_functions.py000064400000010253150044142170010164 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2019-2023 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() test_functors.py000064400000001642150044142170010021 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_logger.py000064400000004521150044142170007434 0ustar00#!/usr/bin/env python # Author: Leonardo Gama (@leogama) # Copyright (c) 2022-2023 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) test_mixins.py000064400000007647150044142170007500 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_module.py000064400000003627150044142170007450 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_moduledict.py000064400000002236150044142170010307 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/dill/blob/master/LICENSE import dill dill.settings['recurse'] = True def f(func): def w(*args): return f(*args) return w @f def f2(): pass # check when __main__ and on import def test_decorated(): assert dill.pickles(f2) import doctest import logging logging.basicConfig(level=logging.DEBUG) class SomeUnreferencedUnpicklableClass(object): def __reduce__(self): raise Exception unpicklable = SomeUnreferencedUnpicklableClass() # This works fine outside of Doctest: def test_normal(): serialized = dill.dumps(lambda x: x) # should not try to pickle unpicklable object in __globals__ def tests(): """ >>> serialized = dill.dumps(lambda x: x) """ return #print("\n\nRunning Doctest:") def test_doctest(): doctest.testmod() if __name__ == '__main__': test_decorated() test_normal() test_doctest() test_nested.py000064400000006112150044142170007435 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_objects.py000064400000003452150044142170007610 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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): """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) print ("weak: %s %s" % (name, type(obj))) else: assert type(obj) == type(pik) except Exception: print ("fails: %s %s" % (name, type(obj))) def test_objects(): for member in objects.keys(): #pickles(member, exact=True) pickles(member, exact=False) if __name__ == '__main__': import warnings warnings.simplefilter('ignore') test_objects() test_properties.py000064400000002502150044142170010346 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_pycapsule.py000064400000002611150044142170010160 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Author: Anirudh Vegesana (avegesan@cs.stanford.edu) # Copyright (c) 2022-2023 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/dill/blob/master/LICENSE """ test pickling a PyCapsule object """ import dill import warnings test_pycapsule = None if dill._dill._testcapsule is not None: import ctypes def test_pycapsule(): name = ctypes.create_string_buffer(b'dill._testcapsule') capsule = dill._dill._PyCapsule_New( ctypes.cast(dill._dill._PyCapsule_New, ctypes.c_void_p), name, None ) with warnings.catch_warnings(): warnings.simplefilter("ignore") dill.copy(capsule) dill._testcapsule = capsule with warnings.catch_warnings(): warnings.simplefilter("ignore") dill.copy(capsule) dill._testcapsule = None try: with warnings.catch_warnings(): warnings.simplefilter("ignore", dill.PicklingWarning) dill.copy(capsule) except dill.UnpicklingError: pass else: raise AssertionError("Expected a different error") if __name__ == '__main__': if test_pycapsule is not None: test_pycapsule() test_recursive.py000064400000010126150044142170010162 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2019-2023 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() test_registered.py000064400000003045150044142170010312 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2022-2023 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/dill/blob/master/LICENSE """ test pickling registered objects """ import dill from dill._objects import failures, registered, succeeds import warnings warnings.filterwarnings('ignore') def check(d, ok=True): res = [] for k,v in d.items(): try: z = dill.copy(v) if ok: res.append(k) except: if not ok: res.append(k) return res fails = check(failures) try: assert not bool(fails) except AssertionError as e: print("FAILS: %s" % fails) raise e from None register = check(registered, ok=False) try: assert not bool(register) except AssertionError as e: print("REGISTER: %s" % register) raise e from None success = check(succeeds, ok=False) try: assert not bool(success) except AssertionError as e: print("SUCCESS: %s" % success) raise e from None import builtins import types q = dill._dill._reverse_typemap p = {k:v for k,v in q.items() if k not in vars(builtins) and k not in vars(types)} diff = set(p.keys()).difference(registered.keys()) try: assert not bool(diff) except AssertionError as e: print("DIFF: %s" % diff) raise e from None miss = set(registered.keys()).difference(p.keys()) try: assert not bool(miss) except AssertionError as e: print("MISS: %s" % miss) raise e from None test_restricted.py000064400000001417150044142170010326 0ustar00#!/usr/bin/env python # # Author: Kirill Makhonin (@kirillmakhonin) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_selected.py000064400000006222150044142170007745 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/dill/blob/master/LICENSE """ testing some selected object types """ import dill dill.settings['recurse'] = True verbose = False def test_dict_contents(): c = type.__dict__ for i,j in c.items(): #try: ok = dill.pickles(j) #except Exception: # print ("FAIL: %s with %s" % (i, dill.detect.errors(j))) if verbose: print ("%s: %s, %s" % (ok, type(j), j)) assert ok if verbose: print ("") def _g(x): yield x; def _f(): try: raise except Exception: from sys import exc_info e, er, tb = exc_info() return er, tb class _d(object): def _method(self): pass from dill import objects from dill import load_types load_types(pickleable=True,unpickleable=False) _newclass = objects['ClassObjectType'] # some clean-up #FIXME: should happen internal to dill objects['TemporaryFileType'].close() objects['TextWrapperType'].close() objects['BufferedRandomType'].close() objects['BufferedReaderType'].close() objects['BufferedWriterType'].close() objects['FileType'].close() del objects # getset_descriptor for new-style classes (fails on '_method', if not __main__) def test_class_descriptors(): d = _d.__dict__ for i in d.values(): ok = dill.pickles(i) if verbose: print ("%s: %s, %s" % (ok, type(i), i)) assert ok if verbose: print ("") od = _newclass.__dict__ for i in od.values(): ok = dill.pickles(i) if verbose: print ("%s: %s, %s" % (ok, type(i), i)) assert ok if verbose: print ("") # (__main__) class instance for new-style classes def test_class(): o = _d() oo = _newclass() ok = dill.pickles(o) if verbose: print ("%s: %s, %s" % (ok, type(o), o)) assert ok ok = dill.pickles(oo) if verbose: print ("%s: %s, %s" % (ok, type(oo), oo)) assert ok if verbose: print ("") # frames, generators, and tracebacks (all depend on frame) def test_frame_related(): g = _g(1) f = g.gi_frame e,t = _f() _is = lambda ok: ok ok = dill.pickles(f) if verbose: print ("%s: %s, %s" % (ok, type(f), f)) assert not ok ok = dill.pickles(g) if verbose: print ("%s: %s, %s" % (ok, type(g), g)) assert _is(not ok) #XXX: dill fails ok = dill.pickles(t) if verbose: print ("%s: %s, %s" % (ok, type(t), t)) assert not ok #XXX: dill fails ok = dill.pickles(e) if verbose: print ("%s: %s, %s" % (ok, type(e), e)) assert ok if verbose: print ("") def test_typing(): import typing x = typing.Any assert x == dill.copy(x) x = typing.Dict[int, str] assert x == dill.copy(x) x = typing.List[int] assert x == dill.copy(x) x = typing.Tuple[int, str] assert x == dill.copy(x) x = typing.Tuple[int] assert x == dill.copy(x) x = typing.Tuple[()] assert x == dill.copy(x) x = typing.Tuple[()].copy_with(()) assert x == dill.copy(x) return if __name__ == '__main__': test_frame_related() test_dict_contents() test_class() test_class_descriptors() test_typing() test_session.py000064400000023661150044142170007646 0ustar00#!/usr/bin/env python # Author: Leonardo Gama (@leogama) # Copyright (c) 2022-2023 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/dill/blob/master/LICENSE import atexit import os import sys import __main__ from contextlib import suppress from io import BytesIO import dill session_file = os.path.join(os.path.dirname(__file__), 'session-refimported-%s.pkl') ################### # Child process # ################### def _error_line(error, obj, refimported): import traceback line = traceback.format_exc().splitlines()[-2].replace('[obj]', '['+repr(obj)+']') return "while testing (with refimported=%s): %s" % (refimported, line.lstrip()) if __name__ == '__main__' and len(sys.argv) >= 3 and sys.argv[1] == '--child': # Test session loading in a fresh interpreter session. refimported = (sys.argv[2] == 'True') dill.load_module(session_file % refimported, module='__main__') def test_modules(refimported): # FIXME: In this test setting with CPython 3.7, 'calendar' is not included # in sys.modules, independent of the value of refimported. Tried to # run garbage collection just before loading the session with no luck. It # fails even when preceding them with 'import calendar'. Needed to run # these kinds of tests in a supbrocess. Failing test sample: # assert globals()['day_name'] is sys.modules['calendar'].__dict__['day_name'] try: for obj in ('json', 'url', 'local_mod', 'sax', 'dom'): assert globals()[obj].__name__ in sys.modules assert 'calendar' in sys.modules and 'cmath' in sys.modules import calendar, cmath for obj in ('Calendar', 'isleap'): assert globals()[obj] is sys.modules['calendar'].__dict__[obj] assert __main__.day_name.__module__ == 'calendar' if refimported: assert __main__.day_name is calendar.day_name assert __main__.complex_log is cmath.log except AssertionError as error: error.args = (_error_line(error, obj, refimported),) raise test_modules(refimported) sys.exit() #################### # Parent process # #################### # Create various kinds of objects to test different internal logics. ## Modules. import json # top-level module import urllib as url # top-level module under alias from xml import sax # submodule import xml.dom.minidom as dom # submodule under alias import test_dictviews as local_mod # non-builtin top-level module ## Imported objects. from calendar import Calendar, isleap, day_name # class, function, other object from cmath import log as complex_log # imported with alias ## Local objects. x = 17 empty = None names = ['Alice', 'Bob', 'Carol'] def squared(x): return x**2 cubed = lambda x: x**3 class Person: def __init__(self, name, age): self.name = name self.age = age person = Person(names[0], x) class CalendarSubclass(Calendar): def weekdays(self): return [day_name[i] for i in self.iterweekdays()] cal = CalendarSubclass() selfref = __main__ # Setup global namespace for session saving tests. class TestNamespace: test_globals = globals().copy() def __init__(self, **extra): self.extra = extra def __enter__(self): self.backup = globals().copy() globals().clear() globals().update(self.test_globals) globals().update(self.extra) return self def __exit__(self, *exc_info): globals().clear() globals().update(self.backup) def _clean_up_cache(module): cached = module.__file__.split('.', 1)[0] + '.pyc' cached = module.__cached__ if hasattr(module, '__cached__') else cached pycache = os.path.join(os.path.dirname(module.__file__), '__pycache__') for remove, file in [(os.remove, cached), (os.removedirs, pycache)]: with suppress(OSError): remove(file) atexit.register(_clean_up_cache, local_mod) def _test_objects(main, globals_copy, refimported): try: main_dict = __main__.__dict__ global Person, person, Calendar, CalendarSubclass, cal, selfref for obj in ('json', 'url', 'local_mod', 'sax', 'dom'): assert globals()[obj].__name__ == globals_copy[obj].__name__ for obj in ('x', 'empty', 'names'): assert main_dict[obj] == globals_copy[obj] for obj in ['squared', 'cubed']: assert main_dict[obj].__globals__ is main_dict assert main_dict[obj](3) == globals_copy[obj](3) assert Person.__module__ == __main__.__name__ assert isinstance(person, Person) assert person.age == globals_copy['person'].age assert issubclass(CalendarSubclass, Calendar) assert isinstance(cal, CalendarSubclass) assert cal.weekdays() == globals_copy['cal'].weekdays() assert selfref is __main__ except AssertionError as error: error.args = (_error_line(error, obj, refimported),) raise def test_session_main(refimported): """test dump/load_module() for __main__, both in this process and in a subprocess""" extra_objects = {} if refimported: # Test unpickleable imported object in main. from sys import flags extra_objects['flags'] = flags with TestNamespace(**extra_objects) as ns: try: # Test session loading in a new session. dill.dump_module(session_file % refimported, refimported=refimported) from dill.tests.__main__ import python, shell, sp error = sp.call([python, __file__, '--child', str(refimported)], shell=shell) if error: sys.exit(error) finally: with suppress(OSError): os.remove(session_file % refimported) # Test session loading in the same session. session_buffer = BytesIO() dill.dump_module(session_buffer, refimported=refimported) session_buffer.seek(0) dill.load_module(session_buffer, module='__main__') ns.backup['_test_objects'](__main__, ns.backup, refimported) def test_session_other(): """test dump/load_module() for a module other than __main__""" import test_classdef as module atexit.register(_clean_up_cache, module) module.selfref = module dict_objects = [obj for obj in module.__dict__.keys() if not obj.startswith('__')] session_buffer = BytesIO() dill.dump_module(session_buffer, module) for obj in dict_objects: del module.__dict__[obj] session_buffer.seek(0) dill.load_module(session_buffer, module) assert all(obj in module.__dict__ for obj in dict_objects) assert module.selfref is module def test_runtime_module(): from types import ModuleType modname = '__runtime__' runtime = ModuleType(modname) runtime.x = 42 mod = dill.session._stash_modules(runtime) if mod is not runtime: print("There are objects to save by referenece that shouldn't be:", mod.__dill_imported, mod.__dill_imported_as, mod.__dill_imported_top_level, file=sys.stderr) # This is also for code coverage, tests the use case of dump_module(refimported=True) # without imported objects in the namespace. It's a contrived example because # even dill can't be in it. This should work after fixing #462. session_buffer = BytesIO() dill.dump_module(session_buffer, module=runtime, refimported=True) session_dump = session_buffer.getvalue() # Pass a new runtime created module with the same name. runtime = ModuleType(modname) # empty return_val = dill.load_module(BytesIO(session_dump), module=runtime) assert return_val is None assert runtime.__name__ == modname assert runtime.x == 42 assert runtime not in sys.modules.values() # Pass nothing as main. load_module() must create it. session_buffer.seek(0) runtime = dill.load_module(BytesIO(session_dump)) assert runtime.__name__ == modname assert runtime.x == 42 assert runtime not in sys.modules.values() def test_refimported_imported_as(): import collections import concurrent.futures import types import typing mod = sys.modules['__test__'] = types.ModuleType('__test__') dill.executor = concurrent.futures.ThreadPoolExecutor(max_workers=1) mod.Dict = collections.UserDict # select by type mod.AsyncCM = typing.AsyncContextManager # select by __module__ mod.thread_exec = dill.executor # select by __module__ with regex session_buffer = BytesIO() dill.dump_module(session_buffer, mod, refimported=True) session_buffer.seek(0) mod = dill.load(session_buffer) del sys.modules['__test__'] assert set(mod.__dill_imported_as) == { ('collections', 'UserDict', 'Dict'), ('typing', 'AsyncContextManager', 'AsyncCM'), ('dill', 'executor', 'thread_exec'), } def test_load_module_asdict(): with TestNamespace(): session_buffer = BytesIO() dill.dump_module(session_buffer) global empty, names, x, y x = y = 0 # change x and create y del empty globals_state = globals().copy() session_buffer.seek(0) main_vars = dill.load_module_asdict(session_buffer) assert main_vars is not globals() assert globals() == globals_state assert main_vars['__name__'] == '__main__' assert main_vars['names'] == names assert main_vars['names'] is not names assert main_vars['x'] != x assert 'y' not in main_vars assert 'empty' in main_vars if __name__ == '__main__': test_session_main(refimported=False) test_session_main(refimported=True) test_session_other() test_runtime_module() test_refimported_imported_as() test_load_module_asdict() test_source.py000064400000013624150044142170007461 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_temp.py000064400000005073150044142170007125 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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() test_weakref.py000064400000003102150044142170007573 0ustar00#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 2008-2016 California Institute of Technology. # Copyright (c) 2016-2023 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()