.Ph\dZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl Z ddl Z ddl Z ddlZddlZddlmZddlmZmZmZddlmZmZmZmZmZddlmZmZmZdZ d Z!Gd d e"Z#d eiZ$d Z%ddZ&dZ'ej(Z)GddeZ*Gdde+Z,Gdde+Z-Gdde-Z.GddeZ/Gdde/Z0GddeZ1 d dZ2dS)!zo A context object for caching a function's return value each time it is called with the same input arguments. N)hashing) CacheWarningFileSystemStoreBackendStoreBackendBase) filter_args format_callformat_signature get_func_code get_func_name)Logger format_timepformatz # first line:c|trb|d}t|dt td}d|dd}nd}||fS)zUExtract the first line information from the function code text if available.  rNr) startswithFIRST_LINE_TEXTsplitintlenjoin) func_code first_lines M/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/joblib/memory.pyextract_first_liner9szO,,OOD)) 1c/&:&:&<&<=>> IIim,,  j  ceZdZdZdS)JobLibCollisionWarningz@Warn that there might be a collision between names of functions.N)__name__ __module__ __qualname____doc__rrrrFsJJJJrrlocalct|ts"td||t |t s"td||t |<dS)aExtend available store backends. The Memory, MemorizeResult and MemorizeFunc objects are designed to be agnostic to the type of store used behind. By default, the local file system is used but this function gives the possibility to extend joblib's memory pattern with other types of storage such as cloud storage (S3, GCS, OpenStack, HadoopFS, etc) or blob DBs. Parameters ---------- backend_name: str The name identifying the store backend being registered. For example, 'local' is used with FileSystemStoreBackend. backend: StoreBackendBase subclass The name of a class that implements the StoreBackendBase interface. z3Store backend name should be a string, '{0}' given.Nz;Store backend should inherit StoreBackendBase, '{0}' given.) isinstancestr ValueErrorformat issubclassr_STORE_BACKENDS) backend_namebackends rregister_store_backendr/Ms$ lC ( (  A H H V V   j2BCC I P P     %,OL!!!rcH|i}t|tjrt|}t|tr|St|trd}t j|}t D]\}}||kr |}|#td ||| ||||S|7tjd |jjt"dS)z7Return the correct store object for the given location.Nz#Unknown location {0} or backend {1}verbosebackend_optionszdInstantiating a backend using a {} as a location is not supported by joblib. Returning None instead.)r'pathlibPathr(rospath expanduserr,items TypeErrorr* configurewarningswarn __class__r UserWarning)r.locationr2r3obj backend_key backend_objs r_store_backend_factoryrDms7(GL))!x==(,--  Hc " " 7%%h//)8(=(=(?(? $ $ $K+%%!kmm ;5<>DfGL!3!<Mt}MMM??G s " #s14 B A BB cD|j|jdS)zClear value from cacheN)rQ clear_itemrPr\s rclearzMemorizedResult.clears! %%dm44444rcRdj|jj|jjg|jRS)Nz*{}(location="{}", func="{}", args_id="{}"))r*r>r rQr@rPr\s r__repr__zMemorizedResult.__repr__s9B;B N #T%7%@ CG=    rcB|j}d|d<|S)NrV__dict__copyrWstates r __getstate__zMemorizedResult.__getstate__s$ ""$$!k r)r%NrNN) r r!r"r#rOpropertyrFr[rbrUrjrlrsr$rrrKrKsD####0X  X   X ###$555   rrKc:eZdZdZdZdZdZdZdZdZ dZ d S) NotMemorizedResultzxClass representing an arbitrary value. This class is a replacement for MemorizedResult when there is no cache. valuevalidc"||_d|_dS)NTrw)rWrxs rrOzNotMemorizedResult.__init__  rc<|jr|jStd)NzNo value stored.)ryrxrer\s rrUzNotMemorizedResult.gets# : /: -.. .rc"d|_d|_dSNFryrxr\s rrjzNotMemorizedResult.clearr{rc|jr3d|jjt |jS|jjdzS)Nz{class_name}({value})) class_namerxz with no value)ryr*r>r rrxr\s rrlzNotMemorizedResult.__repr__!sP : >*11>2'$*:M:M2 >*-== =rc |j|jdS)Nrrr\s rrszNotMemorizedResult.__getstate__*sdj999rc:|d|_|d|_dS)Nryrxrrqs r __setstate__zNotMemorizedResult.__setstate__-s7^ 7^ rN) r r!r"r# __slots__rOrUrjrlrsrr$rrrvrv s #I/// >>>:::$$$$$rrvc>eZdZdZdZdZdZdZd dZdZ d Z d S) NotMemorizedFuncaNo-op object decorating a function. This class replaces MemorizedFunc when there is no cache. It provides an identical API but does not write anything on disk. Attributes ---------- func: callable Original undecorated function. c||_dSrZrF)rWrFs rrOzNotMemorizedFunc.__init__Bs  rc|j|i|SrZrrWargskwargss r__call__zNotMemorizedFunc.__call__Esty$)&)))rc6t|j|i|SrZrvrFrs rcall_and_shelvez NotMemorizedFunc.call_and_shelveHs!!)$)T"r rFr\s rrlzNotMemorizedFunc.__repr__Ks%%dn&=tyIIIrTcdSrZr$rWr=s rrjzNotMemorizedFunc.clearNs rc |j|i|ifSrZrrs rcallzNotMemorizedFunc.callRsty$)&))2--rcdSr~r$rs rcheck_call_in_cachez$NotMemorizedFunc.check_call_in_cacheUsurNT) r r!r"r#rOrrrlrjrrr$rrrr5s  ***>>>JJJ    ...rrceZdZdZdS)AsyncNotMemorizedFunccFKt|j|i|d{VSrZrrs rrz%AsyncNotMemorizedFunc.call_and_shelve]s7!  4(B6(B(B"B"B"B"B"B"BCCCrN)r r!r"rr$rrrr\s(DDDDDrrceZdZdZ d dZdZdZed Zd Z d Z d Z d Z dZ dZdZd!dZd"dZdZd#dZdZdZd$dZd%dZd%dZd&dZdZdS)' MemorizedFuncajCallable object decorating a function for caching its return value each time it is called. Methods are provided to inspect the cache or clean it. Attributes ---------- func: callable The original, undecorated, function. location: string The location of joblib cache. Depends on the store backend used. backend: str Type of store backend for reading/writing cache files. Default is 'local', in which case the location is the path to a disk storage. ignore: list or None List of variable names to ignore when choosing whether to recompute. mmap_mode: {None, 'r+', 'r', 'w+', 'c'} The memmapping mode used when loading from cache numpy arrays. See numpy.load for the meaning of the different values. compress: boolean, or integer Whether to zip the stored data on disk. If an integer is given, it should be between 1 and 9, and sets the amount of compression. Note that compressed arrays cannot be read by memmapping. verbose: int, optional The verbosity flag, controls messages that are issued as the function is evaluated. cache_validation_callback: callable, optional Callable to check if a result in cache is valid or is to be recomputed. When the function is called with arguments for which a cache exists, the callback is called with the cache entry's metadata as its sole argument. If it returns True, the cached result is returned, else the cache for these arguments is cleared and the result is recomputed. r%NFrc tj|||_||_||_| |_t ||_||ng|_||_ t|||t|||_ |j |j |jg||ntj|_ t!j||n#t$$rYnwxYwt'j|rTt+j|} | ddd} t3jdd| } n|j} d| z|_d|_d|_dS) NcompressrRr1rz rz.zMemoized version of %s)r rOrRrrFcache_validation_callbackrIr[ignore_verboserDdictrQstore_cached_func_codetimerV functoolsupdate_wrapper Exceptioninspect isfunctionpydocTextDocdocumentreplaceresubr#_func_code_info _func_code_id) rWrFr@r.rrRrr2rVrdocs rrOzMemorizedFunc.__init__s "   )B&-d33 & 2ff  4   (iHHH       )   5 5t|n E E E&/&;   $T4 0 0 0 0    D   d # # -//**400C++dFA..C&"c**CC,C/#5 #!sC C%$C%c|dsdS|j|sdS|j|}|j1||s|j|dSdS)aCheck if the function call is cached and valid for given arguments. - Compare the function code with the one from the cached function, asserting if it has changed. - Check if the function call is present in the cache. - Call `cache_validation_callback` for user define cache validation. Returns True if the function call is in cache and can be used, and returns False otherwise.  stacklevelFNT)_check_previous_func_coderQ contains_itemrTrrirWrXrSs r_is_in_cache_and_validz$MemorizedFunc._is_in_cache_and_valids---;; 5!//88 5%227;;  * 6228<< 7   ) )' 2 2 25trc |j|i|}|j|f}t|j\}}|j|jg}|d} |jdkrktjtj t|jg|Ri|\}} | tj d|d| d|d| d ||r|r||ifS t!j} ||} |jd kr+|t!j| z d | ifS#t&$rUt|jg|Ri|\}} |d | t-jYnwxYw|jd kr|d|d|d| |||||S)aCall wrapped function and cache result, or read cache if available. This function returns the wrapped function output or a reference to the cached result. Arguments: ---------- args, kwargs: list and dict input arguments for wrapped function shelving: bool True when called via the call_and_shelve function. Returns ------- output: Output of the wrapped function if shelving is false, or a MemorizedResult reference to the value if shelving is true. metadata: dict containing the metadata associated with the call. r@)levelz" Querying z( with signature z*. (argument hash z1) The store location is z. rz cache loaded )contextz*Exception while loading results for {} {} zComputing func z, argument hash z in location ) _get_args_idr[r rFrQget_cached_func_inforlogging basicConfigINFOr infotextwrapdedentr_get_memorized_resultr _load_item_print_durationrr=r* traceback format_exc_call) rWrrshelvingrbrX_ func_name func_infor@ signature start_timeoutputs r _cached_callzMemorizedFunc._cached_calls,$$#T4V44<)$TY// 9&;;T\NKK Z( =B    gl 3 3 3 3+DIGGGGGGLAy II"+")0  08        & &w / /  ?11'::B>> !Y[[ 11=1$$(( j0/)rz!   / KDKKKFKK 9 AHH!9#7#9#9  =2   II*)**W**'**    zz'4:::s;A!EAF<;F<ct|jdrO|jt|jj|_n)t|jj|jkrd|_|jt |j|_|jS)N__code__)hasattrrFridrrr r\s rfunc_code_infozMemorizedFunc.func_code_info4s 49j ) ) ,!)%' (:%;%;""DI&''4+==='+$   '$1#;#;D ##rc>|||ddS)a\Call wrapped function, cache result and return a reference. This method returns a reference to the cached result instead of the result itself. The reference object is small and picklable, allowing to send or store it easily. Call .get() on reference object to get result. Returns ------- cached_result: MemorizedResult or NotMemorizedResult reference to the value returned by the wrapped function. The class "NotMemorizedResult" is used when there is no cache activated (e.g. location=None in Memory). Trrrrs rrzMemorizedFunc.call_and_shelveKs$   v ==a@@rc>|||ddSNFrrrrs rrzMemorizedFunc.__call__]s"  v >>qAArcZ|j}|j}d|d<d|d<|S)NrVr)rrorp)rWrrrs rrszMemorizedFunc.__getstate__as<   ""$$!k"&o rcT|j|j|i|f}||S)aACheck if the function call is cached and valid for given arguments. Does not call the function or do any work besides function inspection and argument hashing. - Compare the function code with the one from the cached function, asserting if it has changed. - Check if the function call is present in the cache. - Call `cache_validation_callback` for user define cache validation. Returns ------- is_call_in_cache: bool Whether or not the function call is in cache and can be used. )r[rrrWrrrXs rrz!MemorizedFunc.check_call_in_cacheqs7 N) rrQrr[rrFr r_FUNCTION_HASHESr:)rWrris_named_callable func_hashs r_write_func_codezMemorizedFunc._write_func_codes ?J "JJ  114<.)LLL DIz * * Oty/AZ/O   ))I .7 +++       s+A<< B  B c  |jtvr,|}|t|jkrdSn#t$rYnwxYw|j\}}} t |j|jg\}}n.#ttf$r| ||YdSwxYw||krdSt|jdd\}} ||cxkrdksn| dkrV|dksd | ||} n| } tjt!d | |||ks4|1t"j|rt|jd \}} t)|d } t-j|5} | |d z |d z | zd z } d d d n #1swxYwYd | } | |k}n|d}|r,tjt!d| ||| ||fz||jdkrGt|jd \}} |d | |j|ddS)zx stacklevel is the depth a which this function is called, to issue useful warnings to the user. TF) resolv_aliaswin_charactersrrz {0} ({1}:{2})z0Cannot detect name collisions for function '{0}'rN)rrrrz "77GG-- )M>>!     ! !)Z 8 8 855  I % %4 % IE%   9 Z - - - -2 - - - -j1H1H###2#9#9{J$$  $- M&FMM( &     ++ 0Gw~~k** I,TYUKKK 9  5 566 ];//1() &*^a-?)-Ka-OO)%%'GG,=$>$>!%,,..-2F2F2H2HH#"&1%;%;K%H%H"!  *8&'*%'&     *$ =2  (GGGLAy II?FFt|     us38= A  A 0B 'B54B5=)G22G69G6Tc|j}|jdkr|r|d|z|j|g|j\}}}|||dS)zEmpty the function's cache.rz(Clearing function cache identified by %sN)r[rr=rQ clear_pathrr)rWr=r[rrrs rrjzMemorizedFunc.clears, =1    II@7J K K K %%    $(#6 1j i44444rcX|j|j|i|f}||||S)aForce the execution of the function with the given arguments. The output values will be persisted, i.e., the cache will be updated with any new values. Parameters ---------- *args: arguments The arguments. **kwargs: keyword arguments Keyword arguments. Returns ------- output : object The output of the function call. metadata : dict The metadata associated with the call. )r[rrrs rrzMemorizedFunc.call#s;( %__Wh77Fxr?cftj}t|j|j||}t d|D}|||d} |j|| tj|z } | |krtj d| zd| S)aSave a small summary of the call using json format in the output directory. output_dir: string directory where to write metadata. duration: float time taken by hashing input arguments, calling the wrapped function and persisting its output. args, kwargs: list and dict input arguments for wrapped function this_duration_limit: float Max execution time for this function before issuing a warning. c3>K|]\}}|t|fVdSrZ)repr).0kvs r z/MemorizedFunc._persist_input..js0II41a1d1gg,IIIIIIr)rN input_argsrzPersisting input arguments took %.2fs to run.If this happens often in your code, it can cause performance problems (results will be correct in all cases). The reason for this is probably some large input arguments for a wrapped function.r) rrrFrrr9rQstore_metadatar<r=) rWrNrXrrthis_duration_limitr argument_dict input_reprrS this_durations rrzMemorizedFunc._persist_inputVs"Y[[ #DIt{D&II II=3F3F3H3HIIIII !$   ))'8<<< j0 . . . M4 7D D     rcNt|j|||j|jdz S)NrrSrVr2)rKrQrVrrs rrz#MemorizedFunc._get_memorized_results4   nMA%     rcR|j|||j|jS)Nr%)rQrdrVrrs rrzMemorizedFunc._load_items/!++ h$.$-,   rrc t|j\}}|d|dt|}tt ddt |z dz|zdS)N z- rPr)r rFrrmaxr)rWrNrrnamemsgs rrzMemorizedFunc._print_durationsj **4::::;x#8#8:: c!b3s88m%%+c122222rcdd|jj|j|jjS)Nz.{class_name}(func={func}, location={location}))rrFr@)r*r>r rFrQr@r\s rrlzMemorizedFunc.__repr__s6?FF~.'0G   r)r%NNFrNN)rrF)rrZ)r)r r!r"r#rOrrrtrrrrsrrrrrrjrrr rrrrrrlr$rrrrds++j"&1"1"1"1"fs rrzAsyncMemorizedFunc.callsGegglD+F++#/44=Syyyyyyy#=rFcK|||tj}|j|i|d{V}|||||||SrZr rs rrzAsyncMemorizedFunc._callsm $'''Y[[  ty$1&11111111vxTTTrr.)r r!r"rrrr __classcell__)r>s@rr0r0sr  >>>>>UUUUUUUUrr0cZeZdZdZ ddZ ddZdd Zdd Zd Zd Z d Z dS)MemoryaA context object for caching a function's return value each time it is called with the same input arguments. All values are cached on the filesystem, in a deep directory structure. Read more in the :ref:`User Guide `. Parameters ---------- location: str, pathlib.Path or None The path of the base directory to use as a data store or None. If None is given, no caching is done and the Memory object is completely transparent. This option replaces cachedir since version 0.12. backend: str, optional, default='local' Type of store backend for reading/writing cache files. The 'local' backend is using regular filesystem operations to manipulate data (open, mv, etc) in the backend. mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional The memmapping mode used when loading from cache numpy arrays. See numpy.load for the meaning of the arguments. compress: boolean, or integer, optional Whether to zip the stored data on disk. If an integer is given, it should be between 1 and 9, and sets the amount of compression. Note that compressed arrays cannot be read by memmapping. verbose: int, optional Verbosity flag, controls the debug messages that are issued as functions are evaluated. backend_options: dict, optional Contains a dictionary of named parameters used to configure the store backend. Nr%Frc tj|||_||_t j|_||_||_|i}||_|r|tj dd||_ t|tr tj|d}t#|||jt%d||d||_dS)Nz&Compressed results cannot be memmappedrrjoblibrr1r$)r rOrrRrrVr.rr3r<r=r@r'r(r6r7rrDrrQ)rWr@r.rRrr2r3s rrOzMemory.__init__s  "    " O.  R - MBq Q Q Q Q  h $ $ 8w||Hh77H3  M !Y:I    rc |"t|std|d|tj|j||||S|j-t j|rtnt}||S||j }|dur|j }t|tr|j}t j|rtnt}|||j|j|||j||j| S)aDecorates the given function func to only compute its return value for input arguments not cached on disk. Parameters ---------- func: callable, optional The function to be decorated ignore: list of strings A list of arguments name to ignore in the hashing verbose: integer, optional The verbosity mode of the function. By default that of the memory object is used. mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, optional The memmapping mode used when loading from cache numpy arrays. See numpy.load for the meaning of the arguments. By default that of the memory object is used. cache_validation_callback: callable, optional Callable to validate whether or not the cache is valid. When the cached function is called with arguments for which a cache exists, this callable is called with the metadata of the cached result as its sole argument. If it returns True, then the cached result is returned, else the cache for these arguments is cleared and recomputed. Returns ------- decorated_func: MemorizedFunc object The returned object is a MemorizedFunc object, that is callable (behaves like a function), but offers extra methods for cache lookup and management. See the documentation for :class:`joblib.memory.MemorizedFunc`. Nz4cache_validation_callback needs to be callable. Got .)rrRr2rF)r@r.rrRrr2rVr)callabler)rpartialcacherQr3iscoroutinefunctionrrrrRr'rrFr0r.rrV)rWrFrr2rRrclss rrDz Memory.cachesIP % 0 %: : 040444  <$ #*C     %.t44&%%%  3t99  ?mG   I dM * * 9D$+$?$E$EX  =s 'L]n&?    rTc|r|d|j4|jtdSdS)z#Erase the complete cache directory.zFlushing completely the cacheN)r=rQrjrrs rrjz Memory.cleargs]  7 II5 6 6 6   )   $ $ & & &  " " $ $ $ $ $ * )rc`|jdS|||dS|j|||dS)aORemove cache elements to make the cache fit its limits. The limitation can impose that the cache size fits in ``bytes_limit``, that the number of cache items is no more than ``items_limit``, and that all files in cache are not older than ``age_limit``. Parameters ---------- bytes_limit: int | str, optional Limit in bytes of the size of the cache. By default, the size of the cache is unlimited. When reducing the size of the cache, ``joblib`` keeps the most recently accessed items first. If a str is passed, it is converted to a number of bytes using units { K | M | G} for kilo, mega, giga. items_limit: int, optional Number of items to limit the cache to. By default, the number of items in the cache is unlimited. When reducing the size of the cache, ``joblib`` keeps the most recently accessed items first. age_limit: datetime.timedelta, optional Maximum age of items to limit the cache to. When reducing the size of the cache, any items last accessed more than the given length of time ago are deleted. Example: to remove files older than 5 days, use datetime.timedelta(days=5). Negative timedelta are not accepted. N)rQenforce_store_limits)rW bytes_limit items_limit age_limits r reduce_sizezMemory.reduce_sizetsJ8   % F  ;#69;L F // [)TTTTTrcV|j||i|S|||i|S)zEval function func with arguments `*args` and `**kwargs`, in the context of the memory. This method works similarly to the builtin `apply`, except that the function is called only if the cache is not up to date. )rQrD)rWrFrrs revalz Memory.evalsC   %4((( (tzz$0000rcjd|jj|jdn |jjS)Nz!{class_name}(location={location}))rr@)r*r>r rQr@r\s rrlzMemory.__repr__s<299~.*28J8S:   rcB|j}d|d<|S)zaWe don't store the timestamp when pickling, to avoid the hash depending from it. NrVrnrqs rrszMemory.__getstate__s& ""$$!k r)Nr%NFrN)NNNFNr)NNN) r r!r"r#rOrDrjrMrOrlrsr$rrr=r=s''^! ! ! ! J"& Q Q Q Q f % % % %%U%U%U%UN 1 1 1"   rr=c Htj|||||||fd}|S)zHelper cache_validation_callback to force recompute after a duration. Parameters ---------- days, seconds, microseconds, milliseconds, minutes, hours, weeks: numbers argument passed to a timedelta. )daysseconds microseconds millisecondsminuteshoursweekscltj|dz }|kS)Nr)r total_seconds)rScomputation_agedeltas rrz0expires_after..cache_validation_callbacks/)++(88!4!4!6!666r)datetime timedelta) rSrTrUrVrWrXrYrr]s @r expires_afterr`sR   !!   E77777 %$r)rN)rrrrrrr)3r#r3r^rrrr6r4rrrrrrr<weakrefrr_store_backendsrrr func_inspectrr r r r loggerr rrrrr?rr,r/rDrIWeakKeyDictionaryrrKobjectrvrrrr0r=r`r$rrrgs[    1000000000! ! ! !KKKKK[KKK23,,,@((((V,,,-7,.. aaaaafaaaH$$$$$$$$$$$$$$$$T!!!!!v!!!NDDDDD,DDD@  @  @  @  @  F@  @  @  LUUUUUUUU2wwwwwVwww@RS%%%%%%r