ZeIi`ddlmZddlZddlmZmZddlmZddlm Z ddl m Z m Z m Z mZmZddlmZdd ZGd d ee ZGddeZGddeZGddZdS)) annotationsN)ABCabstractmethod)errors)StorageRegistry)AnyCallablePRcast)LazyDependencyfnCallable[P, R]returncHtjdfd }|S) NargsP.argskwargsP.kwargsrr ctt|d} |i|S#|j$r"}|jrt j||d}~wwxYw)Nr)r Storagebase_exceptionswrap_exceptionsr StorageError)rrinstanceexcrs X/var/www/html/MCyber-Diagnostic/venv/lib/python3.11/site-packages/limits/storage/base.pyinnerz_wrap_errors..innerssa)) 2t&v&& &'   ' 8)#..C7  s& AA  A)rrrrrr ) functoolswraps)rrs` r _wrap_errorsr!s?_R LceZdZUdZded< d"fd Z d#d$fd Zeed%dZ ed&d'dZ ed(dZ ed)dZ ed*dZ ed+d Zed,d!ZxZS)-rzC Base class to extend when implementing a storage backend. zlist[str] | NoneSTORAGE_SCHEMErrrNonec dD].}t||tt||/tjdi|dS)N>getincrcheckclearreset get_expirysetattrr!getattrsuper__init_subclass__clsrmethod __class__s rr2zStorage.__init_subclass__*sb  E EF Cgc6.B.B!C!C D D D D!!++F+++++r"NFuri str | Nonerbooloptionsfloat | str | boolc Vt||_dS)z :param wrap_exceptions: Whether to wrap storage exceptions in :exc:`limits.errors.StorageError` before raising it. N)r1__init__r)selfr7rr:r6s rr=zStorage.__init__6s) .r"-type[Exception] | tuple[type[Exception], ...]ct)NNotImplementedErrorr>s rrzStorage.base_exceptionsDs "!r"keystrexpiryintamountct)z increments the counter for a given rate limit key :param key: the key to increment :param expiry: amount in seconds for the key to expire in :param amount: the number to increment by rA)r>rErGrIs rr(z Storage.incrIs "!r"ct)zB :param key: the key to get the counter value for rAr>rEs rr'z Storage.getT "!r"floatct)z; :param key: the key to get the expiry for rArLs rr,zStorage.get_expiry[rMr"ct)z- check if storage is healthy rArCs rr)z Storage.checkbrMr" int | Nonect)z/ reset storage to clear limits rArCs rr+z Storage.resetirMr"ct)za resets the rate limit key :param key: the key to clear rate limits for rArLs rr*z Storage.clearps "!r"rrrr%)NF)r7r8rr9r:r;)rr?rD)rErFrGrHrIrHrrH)rErFrrH)rErFrrN)rr9)rrQ)rErFrr%)__name__ __module__ __qualname____doc____annotations__r2r=propertyrrr(r'r,r)r+r* __classcell__r6s@rrr"st%$$$E , , , , , , % / / / / / / /"""^X"""""^""""^" """^" """^" """^" """^"""""r"r) metaclasscVeZdZdZdfd ZedddZeddZxZS)MovingWindowSupportzh Abstract base class for storages that support the :ref:`strategies:moving window` strategy rrrr%c dD].}t||tt||/tjdi|dS)N> acquire_entryget_moving_windowr-r.r3s rr2z%MovingWindowSupport.__init_subclass__sm   F WS&1122     "!++F+++++r"rDrErFlimitrHrGrIr9ct)z :param key: rate limit key to acquire an entry in :param limit: amount of entries allowed :param expiry: expiry of the entry :param amount: the number of entries to acquire rAr>rErdrGrIs rrbz!MovingWindowSupport.acquire_entrys "!r"tuple[float, int]ct)z returns the starting point and the number of entries in the moving window :param key: rate limit key :param expiry: expiry of entry :return: (start of window, number of acquired entries) rA)r>rErdrGs rrcz%MovingWindowSupport.get_moving_windows "!r"rTrU rErFrdrHrGrHrIrHrr9)rErFrdrHrGrHrrg) rVrWrXrYr2rrbrcr\r]s@rr`r`zs , , , , , ,""""^" " " "^ " " " " "r"r`cpeZdZdZdfd Ze dddZeddZeddZxZ S)SlidingWindowCounterSupportzr Abstract base class for storages that support the :ref:`strategies:sliding window counter` strategy. rrrr%c dD].}t||tt||/tjdi|dS)N>get_sliding_windowclear_sliding_windowacquire_sliding_window_entryr-r.r3s rr2z-SlidingWindowCounterSupport.__init_subclass__sm  F WS&1122     "!++F+++++r"rDrErFrdrHrGrIr9ct)aU Acquire an entry if the weighted count of the current and previous windows is less than or equal to the limit :param key: rate limit key to acquire an entry in :param limit: amount of entries allowed :param expiry: expiry of the entry :param amount: the number of entries to acquire rArfs rroz8SlidingWindowCounterSupport.acquire_sliding_window_entrys "!r"tuple[int, float, int, float]ct)a Return the previous and current window information. :param key: the rate limit key :param expiry: the rate limit expiry, needed to compute the key in some implementations :return: a tuple of (int, float, int, float) with the following information: - previous window counter - previous window TTL - current window counter - current window TTL rAr>rErGs rrmz.SlidingWindowCounterSupport.get_sliding_windows "!r"cdS)z Resets the rate limit key(s) for the sliding window :param key: the key to clear rate limits for :param expiry: the rate limit expiry, needed to compute the key in some implemenations Nr-rss rrnz0SlidingWindowCounterSupport.clear_sliding_windows  r"rTrUri)rErFrGrHrrq)rErFrGrHrr%) rVrWrXrYr2rrormrnr\r]s@rrkrks , , , , , ,?@ " " " "^ """"^"    ^     r"rkc*eZdZdZed d Zd S) TimestampedSlidingWindowz\Helper class for storage that support the sliding window counter, with timestamp based keys.rErFrGrHatrNrtuple[str, str]cd|dt||z |z |dt||z fS)a- returns the previous and the current window's keys. :param key: the key to get the window's keys from :param expiry: the expiry of the limit item, in seconds :param at: the timestamp to get the keys from. Default to now, ie ``time.time()`` Returns a tuple with the previous and the current key: (previous, current). Example: - key = "mykey" - expiry = 60 - at = 1738576292.6631825 The return value will be the tuple ``("mykey/28976271", "mykey/28976270")``. /)rH)r4rErGrws rsliding_window_keysz,TimestampedSlidingWindow.sliding_window_keyssH$55R&[F23355#7R7RBK@P@P7R7RRRr"N)rErFrGrHrwrNrrx)rVrWrXrY classmethodr{r-r"rrvrvs>ffSSS[SSSr"rv)rrrr) __future__rrabcrrlimitsrlimits.storage.registryr limits.typingrr r r r limits.utilr r!rr`rkrvr-r"rrs""""""########333333'&&&&&     U"U"U"U"U"nU"U"U"U"p&"&"&"&"&"#&"&"&"R; ; ; ; ; #; ; ; |SSSSSSSSSSr"