o #US`@sdZdZeZddlZddlZddlZddlZddlZddlZddl Z ddl Z ddl m Z ddl mZmZddlmZeeZdZeejejd Zd d d eeed DZeradefZn e dd eDfZdddZ!gfddZ"Gddde#Z$dS)z flask.ext.cache ~~~~~~~~~~~~~~ Adds cache support to your application. :copyright: (c) 2010 by Thadeus Burgess. :license: BSD, see LICENSE for more details z0.13.1N) import_string)request current_app)PY2z_template_fragment_cache_%s%sz_.ccs|] }|tvr|VqdSN) valid_chars).0cr M/home/ubuntu/webapp/venv/lib/python3.10/site-packages/flask_cache/__init__.py #srccs|]}|dfVqdSrr )r kr r r r'sc Cs>t|d}d}t|dd}|rt|st|j}n|r,|ddkr,|r,t|d}|j}t|dr8|j}nBt|dd}|rHt|sH|j }|sPt|dd}|sl|rl|rl|ddkrb|dj }n |ddkrl|d}|rw|j d|j }n|j }d ||f}|j t }|rd |||f} | j t } || fSd} || fS) z; Attempts to returns unique namespace for function rN__self__self __qualname__im_classcls.)inspect getargspecgetattrisclassreprr __module__hasattrr __class____name__join translate null_control) fargsm_argsinstance_token instance_selfmodulenameklassnsinsr r r function_namespace)sN            r-cCs|rd|}t|d|fS)z7 Make a cache key for a specific fragment name z%s__)TEMPLATE_FRAGMENT_KEY_TEMPLATEr ) fragment_namevary_onr r r make_template_fragment_key_sr2c@seZdZdZd0ddZd1ddZdd Zed d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZd2ddZdd Zd!d"Z  d3d$d%Zd4d&d'Zd(d)Zd5d*d+Zd,d-Zd.d/ZdS)6Cachez: This class is used to control the cache objects. NTcCsH|dus t|ts td||_||_||_|dur"|||dSdS)N,`config` must be an instance of dict or None) isinstancedict ValueErrorwith_jinja2_extconfigappinit_app)rr:r8r9r r r __init__pszCache.__init__cCs|dus t|ts td|j}|jr||j|r"|||}|dd|dd|dd|d d|d d|d d|d g|d d|dd|d dkri|dsitd|j rddl m }m }t |j|||j||||dS)z5This is used to initialize cache with your app objectNr4CACHE_DEFAULT_TIMEOUTi,CACHE_THRESHOLDiCACHE_KEY_PREFIX flask_cache_CACHE_MEMCACHED_SERVERS CACHE_DIR CACHE_OPTIONS CACHE_ARGS CACHE_TYPEnullCACHE_NO_NULL_WARNINGFzHFlask-Cache: CACHE_TYPE is set to null, caching is effectively disabled.r)CacheExtensionJINJA_CACHE_ATTR_NAME)r5r6r7r9copyupdate setdefaultwarningswarnr8 jinja2extrHrIsetattr jinja_env add_extension _set_cache)rr:r9 base_configrHrIr r r r;{s0              zCache.init_appcCs|d}d|vr#ddlm}zt||}Wnty"td|wt|}|ddd}d|di}|d r@||d t|d sHi|_|j d i||||||jd |<dS) NrErr)backendsz$%s is not a valid FlaskCache backendrDdefault_timeoutr=rC extensionscache) rrUrAttributeError ImportErrorrrKrrWrL)rr:r9 import_merU cache_obj cache_args cache_optionsr r r rSs*    zCache._set_cachecCs|jpt}|jd|S)NrX)r:rrW)rr:r r r rXs z Cache.cachecO|jj|i|S)Proxy function for internal cache object.)rXgetrr$kwargsr r r rbz Cache.getcO|jj|i|dSraN)rXsetrcr r r rhz Cache.setcOrfrg)rXaddrcr r r rjriz Cache.addcOrfrg)rXdeletercr r r rkriz Cache.deletecOrfrg)rX delete_manyrcr r r rlrizCache.delete_manycCs|jdSrg)rXclearrr r r rmsz Cache.clearcOr_r`)rXget_manyrcr r r rorezCache.get_manycOrfrg)rXset_manyrcr r r rprizCache.set_manyview/%scfdd}|S)a? Decorator. Use this to cache a function. By default the cache key is `view/request.path`. You are able to use this decorator with any function by changing the `key_prefix`. If the token `%s` is located within the `key_prefix` then it will replace that with `request.path` Example:: # An example view function @cache.cached(timeout=50) def big_foo(): return big_bar_calc() # An example misc function to cache. @cache.cached(key_prefix='MyCachedList') def get_list(): return [random.randrange(0, 1) for i in range(50000)] my_list = get_list() .. note:: You MUST have a request context to actually called any functions that are cached. .. versionadded:: 0.4 The returned decorated function now has three function attributes assigned to it. These attributes are readable/writable. **uncached** The original undecorated function **cache_timeout** The cache timeout value for this function. For a custom value to take affect, this must be set before the function is called. **make_cache_key** A function used in generating the cache_key used. :param timeout: Default None. If set to an integer, will cache for that amount of time. Unit of time is in seconds. :param key_prefix: Default 'view/%(request.path)s'. Beginning key to . use for the cache key. .. versionadded:: 0.3.4 Can optionally be a callable which takes no arguments but returns a string that will be used as the cache_key. :param unless: Default None. Cache will *always* execute the caching facilities unless this callable is true. This will bypass the caching entirely. cs>tfddfdd}__|_S)Ncstrdur|i|Szj|i|}j|}Wnty9tjr+td|i|YSw|durl|i|}z jj ||j dW|Styktjr]td|i|YSw|SNT(Exception possibly due to cache backend.timeout callablemake_cache_keyrXrb Exceptionrdebuglogger exceptionrh cache_timeoutr$rd cache_keyrvdecorated_functionr#runlessr r rs2     z;Cache.cached..decorator..decorated_functioncs0tr }|Sdvrtj}|S}|S)Nz%s)rxrpath)r$rdr) key_prefixr r ry4s z7Cache.cached..decorator..make_cache_key) functoolswrapsuncachedr~ry)r#ryrrrvrrr#r decorators  zCache.cached..decoratorr )rrvrrrr rr cacheds6+z Cache.cachedcCs|dS)N_memverr )rfuncnamer r r _memvnameEszCache._memvnamecCsttjdddS)Nutf-8)base64 b64encodeuuiduuid4bytesdecodernr r r _memoize_make_version_hashHsz Cache._memoize_make_version_hashFc Cst||d\}}||}|g} |r||} | | |r*|j| d|dfSt|jj| } d} | ddurB|| d<d} |rR| ddurR|| d<d} |ra| dd} |g} d} | rp|jjt t | | |d|d | fS) zY Updates the hash version associated with a memoized function or method. )r$NFrTrrur) r-rappendrXrllistrorrpr6zipr ) rr#r$resetrkrvfnameinstance_fname version_key fetch_keysinstance_version_keyversion_data_listdirtyr r r _memoize_versionKs4        zCache._memoize_versioncsfdd}|S)zO Function used to create the cache_key for memoized functions. c std}j|||d\}}tr|}n|}t|r.j|g|Ri|\}}n||}}z d|||} WntyLd|||f} Ynwt} | | dt | dd} | d} | |7} | S)Nr~)r$rvz {0}{1}{2}z%s%s%sr)rrrx_memoize_kwargs_to_argsformatrYhashlibmd5rKencoderrdigestr) r#r$rd_timeoutr version_dataaltfnamekeyargs keykwargsupdatedr make_namerrvr r ryzs2      z5Cache._memoize_make_cache_key..make_cache_keyr )rrrvryr rr _memoize_make_cache_keyvszCache._memoize_make_cache_keyc Osg}d}t|}t|j}t|D]X}|dkr*|j|dvr*t|d} |d7}n;|j||vr9||j|} n,|t|krH||} |d7}nt||t|jkr_|j||} |d7}nd} |d7}|| qt |ifS)Nr)rrr) rrlenr$rangerabsdefaultsrtuple) rr#r$rdnew_argsarg_numargspecargs_leniargr r r rs(          zCache._memoize_kwargs_to_argscrr)a[ Use this to cache the result of a function, taking its arguments into account in the cache key. Information on `Memoization `_. Example:: @cache.memoize(timeout=50) def big_foo(a, b): return a + b + random.randrange(0, 1000) .. code-block:: pycon >>> big_foo(5, 2) 753 >>> big_foo(5, 3) 234 >>> big_foo(5, 2) 753 .. versionadded:: 0.4 The returned decorated function now has three function attributes assigned to it. **uncached** The original undecorated function. readable only **cache_timeout** The cache timeout value for this function. For a custom value to take affect, this must be set before the function is called. readable and writable **make_cache_key** A function used in generating the cache_key used. readable and writable :param timeout: Default None. If set to an integer, will cache for that amount of time. Unit of time is in seconds. :param make_name: Default None. If set this is a function that accepts a single argument, the function name, and returns a new string to be used as the function name. If not set then the function name is used. :param unless: Default None. Cache will *always* execute the caching facilities unelss this callable is true. This will bypass the caching entirely. .. versionadded:: 0.5 params ``make_name``, ``unless`` csJtfdd___fdd_S)Ncstrdur|i|Szjg|Ri|}j|}Wnty=tjr/td|i|YSw|durj|i|}z jj ||j dW|StyitjratdY|Sw|Srsrwrrr r r s2     z:Cache.memoize..memoize..decorated_functioncs Sr)delete_memoizedr )r#rr r 's z0Cache.memoize..memoize..)rrrr~rryr)r#rrrvrrr memoizeszCache.memoize..memoizer )rrvrrrr rr rs8"z Cache.memoizecOst|stdz$|s|s|j|ddWdS|j|jg|Ri|}|j|WdSty?tj r7t dYdSw)a Deletes the specified functions caches, based by given parameters. If parameters are given, only the functions that were memoized with them will be erased. Otherwise all versions of the caches will be forgotten. Example:: @cache.memoize(50) def random_func(): return random.randrange(1, 50) @cache.memoize() def param_func(a, b): return a+b+random.randrange(1, 50) .. code-block:: pycon >>> random_func() 43 >>> random_func() 43 >>> cache.delete_memoized('random_func') >>> random_func() 16 >>> param_func(1, 2) 32 >>> param_func(1, 2) 32 >>> param_func(2, 2) 47 >>> cache.delete_memoized('param_func', 1, 2) >>> param_func(1, 2) 13 >>> param_func(2, 2) 47 Delete memoized is also smart about instance methods vs class methods. When passing a instancemethod, it will only clear the cache related to that instance of that object. (object uniqueness can be overridden by defining the __repr__ method, such as user id). When passing a classmethod, it will clear all caches related across all instances of that class. Example:: class Adder(object): @cache.memoize() def add(self, b): return b + random.random() .. code-block:: pycon >>> adder1 = Adder() >>> adder2 = Adder() >>> adder1.add(3) 3.23214234 >>> adder2.add(3) 3.60898509 >>> cache.delete_memoized(adder.add) >>> adder1.add(3) 3.01348673 >>> adder2.add(3) 3.60898509 >>> cache.delete_memoized(Adder.add) >>> adder1.add(3) 3.53235667 >>> adder2.add(3) 3.72341788 :param fname: Name of the memoized function, or a reference to the function. :param \*args: A list of positional parameters used with memoized function. :param \**kwargs: A dict of named parameters used with memoized function. .. note:: Flask-Cache uses inspect to order kwargs into positional args when the function is memoized. If you pass a function reference into ``fname`` instead of the function name, Flask-Cache will be able to place the args/kwargs in the proper order, and delete the positional cache. However, if ``delete_memoized`` is just called with the name of the function, be sure to pass in potential arguments in the same order as defined in your function as args only, otherwise Flask-Cache will not be able to compute the same cache key. .. note:: Flask-Cache maintains an internal random version hash for the function. Using delete_memoized will only swap out the version hash, causing the memoize function to recompute results and put them into another key. This leaves any computed caches for this memoized function within the caching backend. It is recommended to use a very high timeout with memoize if using this function, so that when the version has is swapped, the old cached results would eventually be reclaimed by the caching backend. z_Deleting messages by relative name is no longer reliable, please switch to a function referenceT)rrtN) rxDeprecationWarningrryrrXrkrzrr{r|r})rr#r$rdrr r r r,se zCache.delete_memoizedcGsLt|stdz |j|ddWdSty%tjrtdYdSw)a Delete the version hash associated with the function. ..warning:: Performing this operation could leave keys behind that have been created with this version hash. It is up to the application to make sure that all keys that may have been created with this version hash at least have timeouts so they will not sit orphaned in the cache backend. zYDeleting messages by relative name is no longer reliable, please use a function referenceT)rkrtN)rxrrrzrr{r|r})rr#r$r r r delete_memoized_verhashs  zCache.delete_memoized_verhash)NTNr)NrqN)NFFN)NN)NNN)rrr__doc__r<r;rSpropertyrXrbrhrjrkrlrmrorprrrrrrrrrr r r r r3ks4  (  c +% 5\ ur3r)%r __version____versionfull__rrrrloggingstringrrMwerkzeugrflaskrr_compatr getLoggerrr|r/rh ascii_lettersdigitsr r mapchrrdelcharsr"r6r-r2objectr3r r r r s0       6