a ”$a•cã@s~dZddlZddlZddlZddlZddlmZmZdZdd„Z dd„Z d d „Z Gd d „d e ƒZ ej ¡ZGd d„de ƒZdS)a\ Node: filesystem structure #. Each file/folder is represented by exactly one node. #. Some potential class properties are stored on :py:class:`waflib.Build.BuildContext` : nodes to depend on, etc. Unused class members can increase the `.wafpickle` file size sensibly. #. Node objects should never be created directly, use the methods :py:func:`Node.make_node` or :py:func:`Node.find_node` for the low-level operations #. The methods :py:func:`Node.find_resource`, :py:func:`Node.find_dir` :py:func:`Node.find_or_declare` must be used when a build context is present #. Each instance of :py:class:`waflib.Context.Context` has a unique :py:class:`Node` subclass required for serialization. (:py:class:`waflib.Node.Nod3`, see the :py:class:`waflib.Context.Context` initializer). A reference to the context owning a node is held as *self.ctx* éN)ÚUtilsÚErrorsa: **/*~ **/#*# **/.#* **/%*% **/._* **/*.swp **/CVS **/CVS/** **/.cvsignore **/SCCS **/SCCS/** **/vssver.scc **/.svn **/.svn/** **/BitKeeper **/.git **/.git/** **/.gitignore **/.bzr **/.bzrignore **/.bzr/** **/.hg **/.hg/** **/_MTN **/_MTN/** **/.arch-ids **/{arch} **/_darcs **/_darcs/** **/.intlcache **/.DS_Storec Csü|r tjnd}g}t |¡D]Ú}| dd¡ dd¡}| d¡rF|d7}g}| d¡D]–}|dkrl| |¡qT| dd¡ dd ¡ d d¡ d d ¡}d |}ztj||d}Wn4t yÞ}zt   d||¡‚WYd}~qTd}~00| |¡qT| |¡q|S)Nrú\ú/z//ú**Ú.z[.]Ú*z.*ú?ú+z\+z^%s$)ÚflagszInvalid pattern: %s) ÚreÚIrÚto_listÚreplaceÚendswithÚsplitÚappendÚcompileÚ ExceptionrÚWafError) ÚsÚ ignorecaseZreflagsÚretÚxZaccuÚkÚexpÚe©rúf/home/jack/SDK/ZBT-AX3000-OpenWrt-21.02/build_dir/hostpkg/samba-4.14.12/third_party/waf/waflib/Node.pyÚ ant_matcher@s&  $&  rcCsˆg}|D]z}|sq|ddkrb| |¡t|ƒdkrV|d |¡r`| |dd…¡q‚| g¡q|d |¡r| |dd…¡q|S)Nrréé)rÚlenÚmatch)ÚnameZnnrÚlstrrrÚant_sub_filterWs    r&cCs0t||dƒ}t||dƒ}g|vr(g}||gS)Nrr )r&)r$ÚpatsZnaccZnrejrrrÚant_sub_matchergs r(c@sŠeZdZdZeZdZdd„Zdd„Zdd„Z d d „Z d d „Z d d„Z d^dd„Z d_dd„Zd`dd„Zdadd„Zdd„Zdd„Zd d!„Zdbd"d#„Zd$d%„Zd&d'„Zd(d)„Zd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4d5„Zd6d7„Zej rìd8d7„Zd9d:„Z!d;dd?„Z"d@dA„Z#dBdC„Z$dDdE„Z%dFdG„Z&dHdI„Z'dJdK„Z(dLdM„Z)dNdO„Z*dcdPdQ„Z+dRdS„Z,dTdU„Z-dVdW„Z.dXdY„Z/dZd[„Z0d\d]„Z1d;S)dÚNodezî This class is organized in two parts: * The basic methods meant for filesystem access (compute paths, create folders, etc) * The methods bound to a :py:class:`waflib.Build.BuildContext` (require ``bld.srcnode`` and ``bld.bldnode``) )r$ÚparentÚchildrenÚ cache_abspathÚ cache_isdircCs:||_||_|r6||jvr,t d||f¡‚||j|<dS)zn .. note:: Use :py:func:`Node.make_node` or :py:func:`Node.find_node` instead of calling this constructor z-node %s exists in the parent files %r alreadyN)r$r*r+rr)Úselfr$r*rrrÚ__init__|s  z Node.__init__cCs4|d|_|d|_|ddur0| |d¡|_dS)z3Deserializes node information, used for persistencerr r!N)r$r*Ú dict_classr+)r.ÚdatarrrÚ __setstate__‡s   zNode.__setstate__cCs|j|jt|ddƒfS)z1Serializes node information, used for persistencer+N)r$r*Úgetattr©r.rrrÚ __getstate__szNode.__getstate__cCs| ¡S©zO String representation (abspath), for debugging purposes :rtype: string ©Úabspathr4rrrÚ__str__“sz Node.__str__cCs| ¡Sr6r7r4rrrÚ__repr__›sz Node.__repr__cCst d¡‚dS)z` Provided to prevent nodes from being copied :raises: :py:class:`waflib.Errors.WafError` z#nodes are not supposed to be copiedN)rrr4rrrÚ__copy__£sz Node.__copy__Úrúlatin-1cCst | ¡||¡S)aW Reads and returns the contents of the file represented by this node, see :py:func:`waflib.Utils.readf`:: def build(bld): bld.path.find_node('wscript').read() :param flags: Open mode :type flags: string :param encoding: encoding value for Python3 :type encoding: string :rtype: string or bytes :return: File contents )rÚreadfr8)r.r ÚencodingrrrÚread«sz Node.readÚwcCst | ¡|||¡dS)aV Writes data to the file represented by this node, see :py:func:`waflib.Utils.writef`:: def build(bld): bld.path.make_node('foo.txt').write('Hello, world!') :param data: data to write :type data: string :param flags: Write mode :type flags: string :param encoding: encoding value for Python3 :type encoding: string N)rÚwritefr8)r.r1r r?rrrÚwrite»sz Node.writeTúutf-8csnddl}d}ˆrXtjdkrXzt‰Wnty8t‰Yn0‡‡fdd„‰‡fdd„}|}|j|j|d|d S) u Reads and parses the contents of this node as JSON (Python ≥ 2.6):: def build(bld): bld.path.find_node('abc.json').read_json() Note that this by default automatically decodes unicode strings on Python2, unlike what the Python JSON module does. :type convert: boolean :param convert: Prevents decoding of unicode strings on Python2 :type encoding: string :param encoding: The encoding of the file to read. This default to UTF8 as per the JSON standard :rtype: object :return: Parsed file contents rNics6t|tƒr‡fdd„|DƒSt|ˆƒr.t|ƒS|SdS)Ncsg|] }ˆ|ƒ‘qSrr)Ú.0Úelement©ÚconvertrrÚ åóz3Node.read_json..convert..)Ú isinstanceÚlistÚstr)Úvalue©Z_typerHrrrHãs   zNode.read_json..convertcst‡fdd„|DƒƒS)Nc3s&|]}t|dƒˆ|dƒfVqdS)rr N)rM)rEÚpairrGrrÚ ìrJz7Node.read_json..object_pairs..)Údict)ZpairsrGrrÚ object_pairsësz$Node.read_json..object_pairs©r?)Úobject_pairs_hook)ÚjsonÚsysÚ hexversionÚunicodeÚ NameErrorrMÚloadsr@)r.rHr?rVrUrSrrOrÚ read_jsonËs   zNode.read_jsonc CsRddl}d}d}|}tj}|s*d}d}d}|j||||d|}|j|dd dS) uD Writes a python object as JSON to disk (Python ≥ 2.6) as UTF-8 data (JSON standard):: def build(bld): bld.path.find_node('xyz.json').write_json(199) :type data: object :param data: The data to write to disk :type pretty: boolean :param pretty: Determines if the JSON will be nicely space separated rNr!)ú,z: )r]ú:Ú)ÚindentÚ separatorsÚ sort_keysrDrT)rVÚosÚlinesepÚdumpsrC) r.r1ZprettyrVr`rarbÚnewlineÚoutputrrrÚ write_jsonòs zNode.write_jsoncCstj | ¡¡S)zK Returns whether the Node is present on the filesystem :rtype: bool )rcÚpathÚexistsr8r4rrrrj sz Node.existscCstj | ¡¡S)zB Returns whether the Node represents a folder :rtype: bool )rcriÚisdirr8r4rrrrksz Node.isdircCst | ¡|¡dS)z[ Changes the file/dir permissions:: def build(bld): bld.path.chmod(493) # 0755 N)rcÚchmodr8©r.Úvalrrrrlsz Node.chmodcCs|zhz2tj | ¡¡r$t | ¡¡nt | ¡¡Wn$tyXtj | ¡¡rT‚Yn0W|rx|  ¡n|rv|  ¡0dS)zª Removes the file/folder from the filesystem (equivalent to `rm -rf`), and remove this object from the Node tree. Do not use this object after calling this method. N) rcrirkr8ÚshutilÚrmtreeÚremoveÚOSErrorrjÚevict)r.rsrrrÚdelete#s   ÿz Node.deletecCs|jj|j=dS)z* Removes this node from the Node tree N)r*r+r$r4rrrrs5sz Node.evictcCs td|j d¡ƒ}|j|d…S)uZ Returns the file rightmost extension, for example `a.b.c.d → .d` :rtype: string rrN)Úmaxr$Úrfind)r.rrrrÚsuffix;sz Node.suffixcCs |}d}|r|j}|d7}q|S)z” Returns the depth in the folder hierarchy from the filesystem root or from all the file drives :returns: filesystem depth :rtype: integer éÿÿÿÿr )r*)r.ÚdrnrrrÚheightDs  z Node.heightcCst | ¡¡}| ¡|S)zv Lists the folder contents :returns: list of file/folder names ordered alphabetically :rtype: list of string )rÚlistdirr8Úsort)r.r%rrrr{Rsz Node.listdircCsœ| ¡r dSz|j ¡Wnty,Yn0|jr˜zt | ¡¡WntyXYn0| ¡spt  d|¡‚z |j Wnt y–|  ¡|_ Yn0dS)z¦ Creates a folder represented by this node. Intermediate folders are created as needed. :raises: :py:class:`waflib.Errors.WafError` when the folder is missing Nz!Could not create the directory %r) rkr*Úmkdirrrr$rcÚmakedirsr8rrr+ÚAttributeErrorr0r4rrrr}]s"    z Node.mkdirc Cs t|tƒrdd„t |¡Dƒ}|r`|d d¡r`|js`|jj |d¡}d|_ |  |dd…¡S|}|D]†}|dkr€|jp||}qhz |j }Wnt y¦|  ¡|_ Yn&0z||}WqhWntyÊYn0| ||¡}| ¡sh| ¡dSqh| ¡s| ¡dS|S) u7 Finds a node on the file system (files or folders), and creates the corresponding Node objects if it exists :param lst: relative path :type lst: string or list of string :returns: The corresponding Node object or None if no entry was found on the filesystem :rtype: :py:class:´waflib.Node.Node´ cSsg|]}|r|dkr|‘qS©rr©rErrrrrI„rJz"Node.find_node..rz\\Tr Nú..)rKrMrÚ split_pathÚ startswithr*ÚctxÚrootÚ make_noder-Ú find_noder+rr0ÚKeyErrorÚ __class__rjrs)r.r%ÚnodeÚcurrZchrrrrˆys8       zNode.find_nodec CsŽt|tƒrdd„t |¡Dƒ}|}|D]b}|dkr>|jp:|}q&z|j|}Wq&tyh| ¡|_YntyxYn0q&|  ||¡}q&|S)uÖ Returns or creates a Node object corresponding to the input path without considering the filesystem. :param lst: relative path :type lst: string or list of string :rtype: :py:class:´waflib.Node.Node´ cSsg|]}|r|dkr|‘qSr€rrrrrrI±rJz"Node.make_node..r‚) rKrMrrƒr*r+rr0r‰rŠ©r.r%rŒrrrrr‡¨s     zNode.make_nodec Csnt|tƒrdd„t |¡Dƒ}|}|D]B}|dkr>|jp:|}q&z|j|}Wq&ttfyfYdS0q&|S)u Returns a Node previously defined in the data structure. The filesystem is not considered. :param lst: relative path :type lst: string or list of string :rtype: :py:class:´waflib.Node.Node´ or None if there is no entry in the Node datastructure cSsg|]}|r|dkr|‘qSr€rrrrrrIÍrJz$Node.search_node..r‚N)rKrMrrƒr*r+rr‰rrrrÚ search_nodeÄs   zNode.search_nodecCsÈ|}|}| ¡}| ¡}g}d}||krD| |j¡|j}|d8}q ||krd|d7}|j}|d8}qD||urŽ| |j¡|d7}|j}|j}qd|jr¼| dg|¡| ¡tj |¡pºdS|  ¡SdS)aj Path of this node seen from the other:: def build(bld): n1 = bld.path.find_node('foo/bar/xyz.txt') n2 = bld.path.find_node('foo/stuff/') n1.path_from(n2) # '../bar/xyz.txt' :param node: path to use as a reference :type node: :py:class:`waflib.Node.Node` :returns: a relative path or an absolute one if that is better :rtype: string rr r‚rN) rzrr$r*ÚextendÚreversercÚsepÚjoinr8)r.r‹Úc1Úc2Zc1hZc2hr%ÚuprrrÚ path_fromÚs0    zNode.path_fromcCs`z|jWStyYn0|js*tj}n,|jjs@tj|j}n|j ¡tj|j}||_|S)zk Returns the absolute path. A cache is kept in the context as ``cache_node_abspath`` :rtype: string )r,rr*rcr‘r$r8rmrrrr8 s z Node.abspathcCsfz|jWStyYn0|js(d}n4|jjs>|jtj}n|j ¡ tj¡tj|j}||_|S)Nr_)r,rr*r$rcr‘r8Úrstriprmrrrr8s cCs4|}| ¡| ¡}|dkr,|d8}|j}q||uS)a Returns whether the object belongs to a subtree of the input node:: def build(bld): node = bld.path.find_node('wscript') node.is_child_of(bld.path) # True :param node: path to use as a reference :type node: :py:class:`waflib.Node.Node` :rtype: bool rr )rzr*)r.r‹ÚpZdiffrrrÚ is_child_of-s zNode.is_child_ofNéFc csô| ¡}zt|j ¡ƒ} Wnty6| ¡|_Yn&0|r\| t|ƒD]} |j|  ¡qH|D]Ž} || |ƒ} | r`| dr`g| dv} | | g¡}| ¡}| r¸|r®|r¸|Vn |r¸|V|r`d|_ |r`|j ||d| ||||dD] }|Vqâq`dS)a Recursive method used by :py:meth:`waflib.Node.ant_glob`. :param accept: function used for accepting/rejecting a node, returns the patterns that can be still accepted in recursion :type accept: function :param maxdepth: maximum depth in the filesystem (25) :type maxdepth: int :param pats: list of patterns to accept and list of patterns to exclude :type pats: tuple :param dir: return folders too (False by default) :type dir: bool :param src: return files (True by default) :type src: bool :param remove: remove files/folders that do not exist (True by default) :type remove: bool :param quiet: disable build directory traversal warnings (verbose mode) :type quiet: bool :returns: A generator object to iterate from :rtype: iterator rTr )ÚacceptÚmaxdepthr'ÚdirÚsrcrqÚquietN) r{Úsetr+Úkeysrr0rsr‡rkr-Úant_iter)r.r›rœr'rržrqrŸZdircontr%rr$ZnpatsZacceptedr‹rkrrrrr¢@s2      z Node.ant_iterc sä| dd¡}| d¡}| dt¡}|r.|dp8| dd¡}| dd¡}| d d ¡}| d d ¡} | d d ¡} t|| ƒt|| ƒf} | d¡r¤t ˆjt|| |||| f¡Sˆ t|| |||| ¡} | d¡rÜd ‡fdd„| Dƒ¡St| ƒS)aö Finds files across folders and returns Node objects: * ``**/*`` find all files recursively * ``**/*.class`` find all files ending by .class * ``..`` find files having two dot characters For example:: def configure(cfg): # find all .cpp files cfg.path.ant_glob('**/*.cpp') # find particular files from the root filesystem (can be slow) cfg.root.ant_glob('etc/*.txt') # simple exclusion rule example cfg.path.ant_glob('*.c*', excl=['*.c'], src=True, dir=False) For more information about the patterns, consult http://ant.apache.org/manual/dirtasks.html Please remember that the '..' sequence does not represent the parent directory:: def configure(cfg): cfg.path.ant_glob('../*.h') # incorrect cfg.path.parent.ant_glob('*.h') # correct The Node structure is itself a filesystem cache, so certain precautions must be taken while matching files in the build or installation phases. Nodes objects that do have a corresponding file or folder are garbage-collected by default. This garbage collection is usually required to prevent returning files that do not exist anymore. Yet, this may also remove Node objects of files that are yet-to-be built. This typically happens when trying to match files in the build directory, but there are also cases when files are created in the source directory. Run ``waf -v`` to display any warnings, and try consider passing ``remove=False`` when matching files in the build directory. Since ant_glob can traverse both source and build folders, it is a best practice to call this method only from the most specific build node:: def build(bld): # traverses the build directory, may need ``remove=False``: bld.path.ant_glob('project/dir/**/*.h') # better, no accidental build directory traversal: bld.path.find_node('project/dir').ant_glob('**/*.h') # best In addition, files and folders are listed immediately. When matching files in the build folders, consider passing ``generator=True`` so that the generator object returned can defer computation to a later stage. For example:: def build(bld): bld(rule='tar xvf ${SRC}', source='arch.tar') bld.add_group() gen = bld.bldnode.ant_glob("*.h", generator=True, remove=True) # files will be listed only after the arch.tar is unpacked bld(rule='ls ${SRC}', source=gen, name='XYZ') :param incl: ant patterns or list of patterns to include :type incl: string or list of strings :param excl: ant patterns or list of patterns to exclude :type excl: string or list of strings :param dir: return folders too (False by default) :type dir: bool :param src: return files (True by default) :type src: bool :param maxdepth: maximum depth of recursion :type maxdepth: int :param ignorecase: ignore case while matching (False by default) :type ignorecase: bool :param generator: Whether to evaluate the Nodes lazily :type generator: bool :param remove: remove files/folders that do not exist (True by default) :type remove: bool :param quiet: disable build directory traversal warnings (verbose mode) :type quiet: bool :returns: The corresponding Node objects as a list or as a generator object (generator=True) :rtype: by default, list of :py:class:`waflib.Node.Node` instances ržTrÚexclrÚinclrrqrœršrFrŸÚ generatorZflatú c3s|]}| ˆ¡VqdS)N)r–rr4rrrQÔrJz Node.ant_glob..) ÚgetÚ exclude_regsrrÚlazy_generatorr¢r(r’rL) r.rÚkwržrr£r¤rqrœrrŸr'Úitrr4rÚant_globusN         z Node.ant_globcCs>|}|jj}|jj}|jr:||ur&dS||ur2dS|j}qdS)ur Returns True if the node is below the source directory. Note that ``!is_src() ≠ is_bld()`` :rtype: bool FT)r…ÚsrcnodeÚbldnoder*)r.rŒrÚyrrrÚis_srcÚsz Node.is_srccCs*|}|jj}|jr&||urdS|j}q dS)uq Returns True if the node is below the build directory. Note that ``!is_bld() ≠ is_src()`` :rtype: bool TF)r…r®r*)r.rŒr¯rrrÚis_bldësz Node.is_bldcCs\|}|jj}|jj}g}|jrX||ur8| ¡| |¡S||urD|S| |j¡|j}q|S)a! Returns the corresponding Node object in the source directory (or self if already under the source directory). Use this method only if the purpose is to create a Node object (this is common with folders but not with files, see ticket 1937) :rtype: :py:class:`waflib.Node.Node` )r…r­r®r*rr‡rr$©r.rŒrr¯r%rrrÚget_srcùs  z Node.get_srccCs°|}|jj}|jj}g}|jr\||ur*|S||urH| ¡|jj |¡S| |j¡|j}q| ¡|rœtj rœt |dƒdkrœ|d  d¡rœ|dd|d<|jj dg|¡S)a Return the corresponding Node object in the build directory (or self if already under the build directory). Use this method only if the purpose is to create a Node object (this is common with folders but not with files, see ticket 1937) :rtype: :py:class:`waflib.Node.Node` rr!r^Z__root__) r…r­r®r*rr‡rr$rÚis_win32r"rr²rrrÚget_blds  (z Node.get_bldcCsRt|tƒrdd„t |¡Dƒ}| ¡ |¡}|s>| ¡ |¡}|rN| ¡rNdS|S)a· Use this method in the build phase to find source files corresponding to the relative path given. First it looks up the Node data structure to find any declared Node object in the build directory. If None is found, it then considers the filesystem in the source directory. :param lst: relative path :type lst: string or list of string :returns: the corresponding Node object or None :rtype: :py:class:`waflib.Node.Node` cSsg|]}|r|dkr|‘qSr€rrrrrrI6rJz&Node.find_resource..N) rKrMrrƒrµrŽr³rˆrk©r.r%r‹rrrÚ find_resource)s  zNode.find_resourcecCsBt|tƒr&tj |¡r&|jj |¡}n| ¡ |¡}|j   ¡|S)a Use this method in the build phase to declare output files which are meant to be written in the build directory. This method creates the Node object and its parent folder as needed. :param lst: relative path :type lst: string or list of string ) rKrMrcriÚisabsr…r†r‡rµr*r}r¶rrrÚfind_or_declare?s  zNode.find_or_declarecCs<t|tƒrdd„t |¡Dƒ}| |¡}|r8| ¡s8dS|S)a Searches for a folder on the filesystem (see :py:meth:`waflib.Node.Node.find_node`) :param lst: relative path :type lst: string or list of string :returns: The corresponding Node object or None if there is no such folder :rtype: :py:class:`waflib.Node.Node` cSsg|]}|r|dkr|‘qSr€rrrrrrI[rJz!Node.find_dir..N)rKrMrrƒrˆrkr¶rrrÚfind_dirQs   z Node.find_dircCs`|j}|dur<| d¡}|dkr2|d|…|}qR||}n|dt|ƒ …|}|j |g¡S)zà Declares a build node with a distinct extension; this is uses :py:meth:`waflib.Node.Node.find_or_declare` :return: A build node of the same path, but with a different extension :rtype: :py:class:`waflib.Node.Node` Nrr)r$rvr"r*r¹)r.ÚextÚext_inr$rrrrÚ change_extcs  zNode.change_extcCs| |jj¡S)z_ Returns the relative path seen from the build directory ``src/foo.cpp`` :rtype: string )r–r…r®r4rrrÚbldpathvsz Node.bldpathcCs| |jj¡S)zc Returns the relative path seen from the source directory ``../src/foo.cpp`` :rtype: string )r–r…r­r4rrrÚsrcpath~sz Node.srcpathcCs2|}|jj}|jr*||ur"| ¡S|j}q | ¡S)z™ If a file in the build directory, returns :py:meth:`waflib.Node.Node.bldpath`, else returns :py:meth:`waflib.Node.Node.srcpath` :rtype: string )r…r®r*r¾r¿)r.rŒrrrrÚrelpath†sz Node.relpathcCs |j ¡S)z; Equivalent to self.parent.bldpath() :rtype: string )r*r¾r4rrrÚbld_dir•sz Node.bld_dircCst | ¡¡S)zt See :py:func:`waflib.Utils.h_file` :return: a hash representing the file contents :rtype: string or bytes )rÚh_filer8r4rrrrÂsz Node.h_filec Cs¼z |jj}Wnty*i}|j_Yn0z ||}Wn~ty¶| ¡}z| ¡}||<WnNty°| ¡rªt  |¡}t   ||j |j g¡}||<|YYS‚Yn0Yn0|S)zé Returns a signature (see :py:meth:`waflib.Node.Node.h_file`) for the purpose of build dependency calculation. This method uses a per-context cache. :return: a hash representing the object contents :rtype: string or bytes )r…Ú cache_sigrr‰r8rÂÚEnvironmentErrorrkrcÚstatrÚh_listÚst_inoÚst_mode)r.Úcacherr˜ÚstrrrÚ get_bld_sig¦s"        zNode.get_bld_sig)r<r=)rAr=)TrD)T)T)N)2Ú__name__Ú __module__Ú __qualname__Ú__doc__rRr0Ú __slots__r/r2r5r9r:r;r@rCr\rhrjrkrlrtrsrwrzr{r}rˆr‡rŽr–r8rr´r™r¢r¬r°r±r³rµr·r¹rºr½r¾r¿rÀrÁrÂrËrrrrr)ns\    '    //5e  r)c@seZdZdZdS)ÚNod3z5Mandatory subclass for thread-safe node serializationN)rÌrÍrÎrÏrrrrrÑÅsrÑ)rÏrcr rWroÚwaflibrrr¨rr&r(Úobjectr)Ú threadingÚLockZ pickle_lockrÑrrrrÚs %Z