O=djdZddlmZddlZddlZddlZdZGddeZ GddeZ Gd d e Z Gd d eZ Gd deZ GddeZGddeZGddeZGddeZGddeZGddeZGddeZGddeZGdd eZGd!d"eZGd#d$eZGd%d&eZGd'd(eZGd)d*eZd+Zd,Zd-Zd.ZdDd/Z dDd0Z!dEd2Z"d3Z#d4Z$d5Z%d6Z&d7Z'd8Z(d9Z)d:Z*d;Z+d<Z,d=Z-d>Z.d?Z/d@Z0dAZ1dBZ2dCZ3dS)Fz? Functions that wrap other functions. .. versionadded:: 1.0.0 )getfullargspecN)afterarybeforeconjoincurry curry_rightdebouncedelaydisjoinflipflow flow_rightiterated juxtaposenegateonce over_argspartial partial_rightreargspreadthrottleunarywrapceZdZdZdZdZdS)Afterz$Wrap a function in an after context.c t|}|dksJn#tttf$rd}YnwxYw||_||_dSNrint ValueError TypeErrorAssertionErrornfuncselfr&r%s :D:\Sites\api_v1\venv\Lib\site-packages\pydash/functions.py__init__zAfter.__init__-s` AA66666I~6   AAA  66cV|xjdzc_|jdkr |j|i|SdS)z5Return results of :attr:`func` after :attr:`n` calls.rNr%r&r(argskwargss r)__call__zAfter.__call__7s: !  6Q;;49d-f-- - ;N__name__ __module__ __qualname____doc__r*r2r3r)rr*s8.......r3rceZdZdZdZdZdS)Aryz"Wrap a function in an ary context.c t|}|dksJn#tttf$rd}YnwxYw||_||_dSrr r's r)r*z Ary.__init__Bs` AA66666I~6   AAA  r+cH|j|d|j}|j|i|S)z Return results of :attr:`func` with arguments capped to :attr:`n`. Only positional arguments are capped. Any number of keyword arguments are allowed. Nr.r/s r)r2z Ary.__call__Ls2 6 $&>Dty$)&)))r3Nr4r9r3r)r;r;?s8,, * * * * *r3r;ceZdZdZdZdS)Beforez$Wrap a function in a before context.cV|xjdzc_|jdkr |j|i|SdS)Nr-rr.r/s r)r2zBefore.__call__[s: !  6A::49d-f-- - :r3N)r5r6r7r8r2r9r3r)r?r?Xs).......r3r?ceZdZdZdZdZdS)Flowz"Wrap a function in a flow context.cJ||_|dd|_dS)N from_rightT)funcsgetrD)r(rEr1s r)r*z Flow.__init__es"  **\488r3ct|j}|jrdnd}d}|r"|||i|}|f}i}|"|S)z*Return results of composing :attr:`funcs`.rN)listrErDpop)r(r0r1rE from_indexresults r)r2z Flow.__call__iskTZ  ?1RR  *UYYz**D;F;;F9DF   r3Nr4r9r3r)rBrBbs8,,999     r3rBceZdZdZdZdZdS)Conjoinz-Wrap a set of functions in a conjoin context.c||_dSNrEr(rEs r)r*zConjoin.__init__{  r3c8fd}tj||S)z=Return result of conjoin `obj` with :attr:`funcs` predicates.c@tjjfdS)Nc|SrPr9r&items r)z4Conjoin.__call__..iteratee..sdd4jjr3)pydeveryrErXr(s`r)iterateez"Conjoin.__call__..iteratees"9TZ)@)@)@)@AA Ar3)rZr[r(objr]s` r)r2zConjoin.__call__~s5 B B B B Byh'''r3Nr4r9r3r)rNrNxs877(((((r3rNc&eZdZdZddZdZdZdS)Curryz#Wrap a function in a curry context.Nc||_|!tt|jn||_|dn||_|in||_dS)Nr9)r&lenrr0arityr1)r(r&rdr0r1s r)r*zCurry.__init__sN 7<}S--2333% ,BBD "Nbb r3cf||}||jt|t|z|jkr7|jt|z }|d|dkr|nd}|j|i|}n"||j|j||}|S)zhStore `args` and `kwargs` and call :attr:`func` if we've reached or exceeded the function arity.Nr) compose_argsupdater1rcrdr& __class__)r(r0r1 args_aritycurrieds r)r2zCurry.__call__s  && dk""" IIF # 2 2c&kk1J?a::Q?@Ddi000GGnnTY D&IIGr3cdtt|jt|zS)z/Combine `self.args` with `new_args` and return.tuplerIr0r(new_argss r)rfzCurry.compose_argss#T$)__tH~~5666r3)NN)r5r6r7r8r*r2rfr9r3r)rarasL--7777 "77777r3raceZdZdZdZdS) CurryRightz)Wrap a function in a curry-right context.cdtt|t|jzSrPrlrns r)rfzCurryRight.compose_argss#T(^^d49oo5666r3N)r5r6r7r8rfr9r3r)rqrqs)3377777r3rqc eZdZdZddZdZdS)Debouncez&Wrap a function in a debounce context.Fc||_||_||_d|_t j|jz |_t j|rt j|z nd|_dSrP) r&waitmax_wait last_resultrZnow last_call is_numberlast_execution)r(r&rvrws r)r*zDebounce.__init__sc    TY.69mH6M6MWcgii(22SWr3ctj}||jz |jks|jr,||jz |jkr|j|i||_||_||_|jS)z Execute :attr:`func` if function hasn't been called within last :attr:`wait` milliseconds or in last :attr:`max_wait` milliseconds. Return results of last successful call. )rZryrzrvrwr|r&rxr(r0r1presents r)r2zDebounce.__call__ss')) dn $ 2 2 M 3&)<<NN(ty$9&99D ")D  r3NFr4r9r3r)rtrtsA00 X X X X     r3rtceZdZdZdZdZdS)Disjoinz-Wrap a set of functions in a disjoin context.c||_dSrPrQrRs r)r*zDisjoin.__init__rSr3c8fd}tj||S)z=Return result of disjoin `obj` with :attr:`funcs` predicates.c@tjjfdS)Nc|SrPr9rWs r)rYz4Disjoin.__call__..iteratee..sTT$ZZr3)rZsomerEr\s`r)r]z"Disjoin.__call__..iteratees"8DJ(?(?(?(?@@ @r3)rZrr^s` r)r2zDisjoin.__call__s5 A A A A AxX&&&r3Nr4r9r3r)rrs877'''''r3rceZdZdZdZdZdS)Flipz"Wrap a function in a flip context.c||_dSrPr&r(r&s r)r*z Flip.__init__  r3c6|jt|i|SrP)r&reversedr/s r)r2z Flip.__call__sty(4..3F333r3Nr4r9r3r)rrs8,,44444r3rc$eZdZdZdZdZdZdS)Iteratedz'Wrap a function in an iterated context.c||_dSrPrrs r)r*zIterated.__init__rr3c#@K|} ||}|V)z1Iterator that composing :attr:`func` with itself.r)r(initialvalues r) _iterationzIterated._iterations/ IIe$$EKKK r3cv|}||}t|D]}t|}|S)zMReturn value of calling :attr:`func` `n` times using `initial` as seed value.)rrangenext)r(rr%r iteration_s r)r2zIterated.__call__s?OOE** q $ $AOOEE r3N)r5r6r7r8r*rr2r9r3r)rrsG11r3rceZdZdZdZdZdS) Juxtaposez'Wrap a function in a juxtapose context.c||_dSrPrQrRs r)r*zJuxtapose.__init__rSr3c*fd|jDS)Ncg|]}|Sr9r9).0r&objss r) z&Juxtapose.__call__..s333d 333r3rQ)r(rs `r)r2zJuxtapose.__call__s3333 3333r3Nr4r9r3r)rrs81144444r3rceZdZdZdZdZdS)OverArgsz'Wrap a function in a over_args context.cF||_tj||_dSrP)r&rZflatten transforms)r(r&rs r)r*zOverArgs.__init__s +j11r3cNfdt|D}j|S)Nc3JK|]\}}j||VdSrP)r)ridxr0r(s r) z$OverArgs.__call__..s9LLysD$$T**LLLLLLr3) enumerater&r(r0s` r)r2zOverArgs.__call__s1LLLLIdOOLLLty$r3Nr4r9r3r)rr s811222     r3rceZdZdZdZdZdS)Negatez$Wrap a function in a negate context.c||_dSrPrrs r)r*zNegate.__init__rr3c|j|i| S)z/Return negated results of calling :attr:`func`.rr/s r)r2zNegate.__call__s49d-f----r3Nr4r9r3r)rrs8.......r3rceZdZdZdZdZdS)Oncez"Wrap a function in a once context.c0||_d|_d|_dSNF)r&rLcalledrs r)r*z Once.__init__%s   r3cP|js|j|i||_d|_|jS)z3Return results from the first call of :attr:`func`.T)rr&rLr/s r)r2z Once.__call__*s3{ #$)T4V44DKDK{r3Nr4r9r3r)rr"s8,, r3rc eZdZdZddZdZdS)Partialz%Wrap a function in a partial context.NFcB||_||_|pi|_||_dSrP)r&r0r1rD)r(r&r0r1rDs r)r*zPartial.__init__6s&  l $r3c|jrtj||j}ntj|j|}i|j|}|j|i|S)z Return results from :attr:`func` with :attr:`args` + `args`. Apply arguments from left or right depending on :attr:`from_right`. )rD itertoolschainr0r1r&r/s r)r2zPartial.__call__<s^ ? 4?433DD?49d33D*DK*6*ty$)&)))r3rr4r9r3r)rr3s=//%%%% * * * * *r3rceZdZdZdZdZdS)Reargz#Wrap a function in a rearg context.ct||_dttj|D|_dS)Nci|]\}}|| Sr9r9)r dest_index src_indexs r) z"Rearg.__init__..Ts+   &;j)Iz   r3)r&rrZrindexes)r(r&rs r)r*zRearg.__init__Os@   ?HU\I]I]?^?^    r3cig}t|D]<\}}|j|}|||<'||=t jfdt D|}|j|i|S)z.is'FFs FFFFFFr3)rrrFappendrrsortedr&)r(r0r1restrargrrs @r)r2zRearg.__call__Xs(oo ! !NIs)))44J%%(z"" C    FFFFvf~~FFFMMty$)&)))r3Nr4r9r3r)rrLs8--   *****r3rceZdZdZdZdZdS)Spreadz$Wrap a function in a spread context.c||_dSrPrrs r)r*zSpread.__init__qrr3c|j|S)z@Return results from :attr:`func` using array of `args` provided.rrs r)r2zSpread.__call__tsty$r3Nr4r9r3r)rrns8..     r3rceZdZdZdZdZdS)Throttlez&Wrap a function in a throttle context.cp||_||_d|_tj|jz |_dSrP)r&rvrxrZryr|)r(r&rvs r)r*zThrottle.__init__|s3  !gii$)3r3ctj}||jz |jkr|j|i||_||_|jS)z Execute :attr:`func` if function hasn't been called within last :attr:`wait` milliseconds. Return results of last successful call. )rZryr|rvr&rxr~s r)r2zThrottle.__call__sN ')) d) )di 7 7(ty$9&99D ")D r3Nr4r9r3r)rrys800444      r3rc"t||S)a Creates a function that executes `func`, with the arguments of the created function, only after being called `n` times. Args: func (callable): Function to execute. n (int): Number of times `func` must be called before it is executed. Returns: After: Function wrapped in an :class:`After` context. Example: >>> func = lambda a, b, c: (a, b, c) >>> after_func = after(func, 3) >>> after_func(1, 2, 3) >>> after_func(1, 2, 3) >>> after_func(1, 2, 3) (1, 2, 3) >>> after_func(4, 5, 6) (4, 5, 6) .. versionadded:: 1.0.0 .. versionchanged:: 3.0.0 Reordered arguments to make `func` first. )rr&r%s r)rrs8 q>>r3c"t||S)a} Creates a function that accepts up to `n` arguments ignoring any additional arguments. Only positional arguments are capped. All keyword arguments are allowed through. Args: func (callable): Function to cap arguments for. n (int): Number of arguments to accept. Returns: Ary: Function wrapped in an :class:`Ary` context. Example: >>> func = lambda a, b, c=0, d=5: (a, b, c, d) >>> ary_func = ary(func, 2) >>> ary_func(1, 2, 3, 4, 5, 6) (1, 2, 0, 5) >>> ary_func(1, 2, 3, 4, 5, 6, c=10, d=20) (1, 2, 10, 20) .. versionadded:: 3.0.0 r;rs r)rrs. tQ<<r3c"t||S)a Creates a function that executes `func`, with the arguments of the created function, until it has been called `n` times. Args: func (callable): Function to execute. n (int): Number of times `func` may be executed. Returns: Before: Function wrapped in an :class:`Before` context. Example: >>> func = lambda a, b, c: (a, b, c) >>> before_func = before(func, 3) >>> before_func(1, 2, 3) (1, 2, 3) >>> before_func(1, 2, 3) (1, 2, 3) >>> before_func(1, 2, 3) >>> before_func(1, 2, 3) .. versionadded:: 1.1.0 .. versionchanged:: 3.0.0 Reordered arguments to make `func` first. )r?rs r)rrs8 $??r3ct|S)as Creates a function that composes multiple predicate functions into a single predicate that tests whether **all** elements of an object pass each predicate. Args: *funcs (callable): Function(s) to conjoin. Returns: Conjoin: Function(s) wrapped in a :class:`Conjoin` context. Example: >>> conjoiner = conjoin(lambda x: isinstance(x, int), lambda x: x > 3) >>> conjoiner([1, 2, 3]) False >>> conjoiner([1.0, 2, 1]) False >>> conjoiner([4.0, 5, 6]) False >>> conjoiner([4, 5, 6]) True .. versionadded:: 2.0.0 )rNrQs r)rrs2 E?r3c"t||S)a Creates a function that accepts one or more arguments of `func` that when invoked either executes `func` returning its result (if all `func` arguments have been provided) or returns a function that accepts one or more of the remaining `func` arguments, and so on. Args: func (callable): Function to curry. arity (int, optional): Number of function arguments that can be accepted by curried function. Default is to use the number of arguments that are accepted by `func`. Returns: Curry: Function wrapped in a :class:`Curry` context. Example: >>> func = lambda a, b, c: (a, b, c) >>> currier = curry(func) >>> currier = currier(1) >>> assert isinstance(currier, Curry) >>> currier = currier(2) >>> assert isinstance(currier, Curry) >>> currier = currier(3) >>> currier (1, 2, 3) .. versionadded:: 1.0.0 )rar&rds r)rrs8 u  r3c"t||S)aS This method is like :func:`curry` except that arguments are applied to `func` in the manner of :func:`partial_right` instead of :func:`partial`. Args: func (callable): Function to curry. arity (int, optional): Number of function arguments that can be accepted by curried function. Default is to use the number of arguments that are accepted by `func`. Returns: CurryRight: Function wrapped in a :class:`CurryRight` context. Example: >>> func = lambda a, b, c: (a, b, c) >>> currier = curry_right(func) >>> currier = currier(1) >>> assert isinstance(currier, CurryRight) >>> currier = currier(2) >>> assert isinstance(currier, CurryRight) >>> currier = currier(3) >>> currier (3, 2, 1) .. versionadded:: 1.1.0 )rqrs r)r r %s6 dE " ""r3Fc&t|||S)a, Creates a function that will delay the execution of `func` until after `wait` milliseconds have elapsed since the last time it was invoked. Subsequent calls to the debounced function will return the result of the last `func` call. Args: func (callable): Function to execute. wait (int): Milliseconds to wait before executing `func`. max_wait (optional): Maximum time to wait before executing `func`. Returns: Debounce: Function wrapped in a :class:`Debounce` context. .. versionadded:: 1.0.0 )rw)rt)r&rvrws r)r r Cs D$ 2 2 22r3c@tj|dz ||i|S)a Executes the `func` function after `wait` milliseconds. Additional arguments will be provided to `func` when it is invoked. Args: func (callable): Function to execute. wait (int): Milliseconds to wait before executing `func`. *args (optional): Arguments to pass to `func`. **kwargs (optional): Keyword arguments to pass to `func`. Returns: mixed: Return from `func`. .. versionadded:: 1.0.0 g@@)timesleep)r&rvr0r1s r)r r Vs-  Jtf} 4   r3ct|S)a} Creates a function that composes multiple predicate functions into a single predicate that tests whether **any** elements of an object pass each predicate. Args: *funcs (callable): Function(s) to disjoin. Returns: Disjoin: Function(s) wrapped in a :class:`Disjoin` context. Example: >>> disjoiner = disjoin(lambda x: isinstance(x, float), lambda x: isinstance(x, int)) >>> disjoiner([1, '2', '3']) True >>> disjoiner([1.0, '2', '3']) True >>> disjoiner(['1', '2', '3']) False .. versionadded:: 2.0.0 )rrQs r)r r js0 E?r3c t|S)a Creates a function that invokes the method with arguments reversed. Args: func (callable): Function to flip arguments for. Returns: function: Function wrapped in a :class:`Flip` context. Example: >>> flipped = flip(lambda *args: args) >>> flipped(1, 2, 3, 4) (4, 3, 2, 1) >>> flipped = flip(lambda *args: [i * 2 for i in args]) >>> flipped(1, 2, 3, 4) [8, 6, 4, 2] .. versionadded:: 4.0.0 )rrs r)r r * ::r3ct|ddiS)a  Creates a function that is the composition of the provided functions, where each successive invocation is supplied the return value of the previous. For example, composing the functions ``f()``, ``g()``, and ``h()`` produces ``h(g(f()))``. Args: *funcs (callable): Function(s) to compose. Returns: Flow: Function(s) wrapped in a :class:`Flow` context. Example: >>> mult_5 = lambda x: x * 5 >>> div_10 = lambda x: x / 10.0 >>> pow_2 = lambda x: x ** 2 >>> ops = flow(sum, mult_5, div_10, pow_2) >>> ops([1, 2, 3, 4]) 25.0 .. versionadded:: 2.0.0 .. versionchanged:: 2.3.1 Added :func:`pipe` as alias. .. versionchanged:: 4.0.0 Removed alias ``pipe``. rDFrBrQs r)rrs:  )5 ) ))r3ct|ddiS)ay This function is like :func:`flow` except that it creates a function that invokes the provided functions from right to left. For example, composing the functions ``f()``, ``g()``, and ``h()`` produces ``f(g(h()))``. Args: *funcs (callable): Function(s) to compose. Returns: Flow: Function(s) wrapped in a :class:`Flow` context. Example: >>> mult_5 = lambda x: x * 5 >>> div_10 = lambda x: x / 10.0 >>> pow_2 = lambda x: x ** 2 >>> ops = flow_right(mult_5, div_10, pow_2, sum) >>> ops([1, 2, 3, 4]) 50.0 .. versionadded:: 1.0.0 .. versionchanged:: 2.0.0 Added :func:`flow_right` and made :func:`compose` an alias. .. versionchanged:: 2.3.1 Added :func:`pipe_right` as alias. .. versionchanged:: 4.0.0 Removed aliases ``pipe_right`` and ``compose``. rDTrrQs r)rrs@  (4 ( ((r3c t|S)a Creates a function that is composed with itself. Each call to the iterated function uses the previous function call's result as input. Returned :class:`Iterated` instance can be called with ``(initial, n)`` where `initial` is the initial value to seed `func` with and `n` is the number of times to call `func`. Args: func (callable): Function to iterate. Returns: Iterated: Function wrapped in a :class:`Iterated` context. Example: >>> doubler = iterated(lambda x: x * 2) >>> doubler(4, 5) 128 >>> doubler(3, 9) 1536 .. versionadded:: 2.0.0 )rrs r)rrs. D>>r3ct|S)a Creates a function whose return value is a list of the results of calling each `funcs` with the supplied arguments. Args: *funcs (callable): Function(s) to juxtapose. Returns: Juxtapose: Function wrapped in a :class:`Juxtapose` context. Example: >>> double = lambda x: x * 2 >>> triple = lambda x: x * 3 >>> quadruple = lambda x: x * 4 >>> juxtapose(double, triple, quadruple)(5) [10, 15, 20] .. versionadded:: 2.0.0 )rrQs r)rrs, e r3c t|S)a Creates a function that negates the result of the predicate `func`. The `func` function is executed with the arguments of the created function. Args: func (callable): Function to negate execute. Returns: Negate: Function wrapped in a :class:`Negate` context. Example: >>> not_is_number = negate(lambda x: isinstance(x, (int, float))) >>> not_is_number(1) False >>> not_is_number('1') True .. versionadded:: 1.1.0 )rrs r)rrs* $<<r3c t|S)a Creates a function that is restricted to execute `func` once. Repeat calls to the function will return the value of the first call. Args: func (callable): Function to execute. Returns: Once: Function wrapped in a :class:`Once` context. Example: >>> oncer = once(lambda *args: args[0]) >>> oncer(5) 5 >>> oncer(6) 5 .. versionadded:: 1.0.0 )rrs r)rr+rr3ct|g|RS)a Creates a function that runs each argument through a corresponding transform function. Args: func (callable): Function to wrap. *transforms (callable): Functions to transform arguments, specified as individual functions or lists of functions. Returns: OverArgs: Function wrapped in a :class:`OverArgs` context. Example: >>> squared = lambda x: x ** 2 >>> double = lambda x: x * 2 >>> modder = over_args(lambda x, y: [x, y], squared, double) >>> modder(5, 10) [25, 20] .. versionadded:: 3.3.0 .. versionchanged:: 4.0.0 Renamed from ``mod_args`` to ``over_args``. )r)r&rs r)rrCs2 D &: & & &&r3c$t|||S)a Creates a function that, when called, invokes `func` with any additional partial arguments prepended to those provided to the new function. Args: func (callable): Function to execute. *args (optional): Partial arguments to prepend to function call. **kwargs (optional): Partial keyword arguments to bind to function call. Returns: Partial: Function wrapped in a :class:`Partial` context. Example: >>> dropper = partial(lambda array, n: array[n:], [1, 2, 3, 4]) >>> dropper(2) [3, 4] >>> dropper(1) [2, 3, 4] >>> myrest = partial(lambda array, n: array[n:], n=1) >>> myrest([1, 2, 3, 4]) [2, 3, 4] .. versionadded:: 1.0.0 rr&r0r1s r)rr_s4 4v & &&r3c(t|||dS)aE This method is like :func:`partial` except that partial arguments are appended to those provided to the new function. Args: func (callable): Function to execute. *args (optional): Partial arguments to append to function call. **kwargs (optional): Partial keyword arguments to bind to function call. Returns: Partial: Function wrapped in a :class:`Partial` context. Example: >>> myrest = partial_right(lambda array, n: array[n:], 1) >>> myrest([1, 2, 3, 4]) [2, 3, 4] .. versionadded:: 1.0.0 T)rDrrs r)rr|s* 4v$ 7 7 77r3ct|g|RS)a Creates a function that invokes `func` with arguments arranged according to the specified indexes where the argument value at the first index is provided as the first argument, the argument value at the second index is provided as the second argument, and so on. Args: func (callable): Function to rearrange arguments for. *indexes (int): The arranged argument indexes. Returns: Rearg: Function wrapped in a :class:`Rearg` context. Example: >>> jumble = rearg(lambda *args: args, 1, 2, 3) >>> jumble(1, 2, 3) (2, 3, 1) >>> jumble('a', 'b', 'c', 'd', 'e') ('b', 'c', 'd', 'a', 'e') .. versionadded:: 3.0.0 )r)r&rs r)rrs.    r3c t|S)a Creates a function that invokes `func` with the array of arguments provided to the created function. Args: func (callable): Function to spread. Returns: Spread: Function wrapped in a :class:`Spread` context. Example: >>> greet = spread(lambda *people: 'Hello ' + ', '.join(people) + '!') >>> greet(['Mike', 'Don', 'Leo']) 'Hello Mike, Don, Leo!' .. versionadded:: 3.1.0 )rrs r)rrs& $<<r3c"t||S)a Creates a function that, when executed, will only call the `func` function at most once per every `wait` milliseconds. Subsequent calls to the throttled function will return the result of the last `func` call. Args: func (callable): Function to throttle. wait (int): Milliseconds to wait before calling `func` again. Returns: mixed: Results of last `func` call. .. versionadded:: 1.0.0 )r)r&rvs r)rrs D$  r3c"t|dS)a Creates a function that accepts up to one argument, ignoring any additional arguments. Args: func (callable): Function to cap arguments for. Returns: Ary: Function wrapped in an :class:`Ary` context. Example: >>> func = lambda a, b=1, c=0, d=5: (a, b, c, d) >>> unary_func = unary(func) >>> unary_func(1, 2, 3, 4, 5, 6) (1, 1, 0, 5) >>> unary_func(1, 2, 3, 4, 5, 6, b=0, c=10, d=20) (1, 0, 10, 20) .. versionadded:: 4.0.0 r-rrs r)rrs* tQ<<r3c$t||fS)a1 Creates a function that provides value to the wrapper function as its first argument. Additional arguments provided to the function are appended to those provided to the wrapper function. Args: value (mixed): Value provided as first argument to function call. func (callable): Function to execute. Returns: Partial: Function wrapped in a :class:`Partial` context. Example: >>> wrapper = wrap('hello', lambda *args: args) >>> wrapper(1, 2) ('hello', 1, 2) .. versionadded:: 1.0.0 r)rr&s r)rrs( 4% " ""r3rPr)4r8inspectrrrpydashrZ__all__objectrr;r?rBrNrarqrtrrrrrrrrrrrrrrrrr r r r r rrrrrrrrrrrrrrr9r3r)rs #"""""  8.....F...******&***2.....U...6, ( ( ( ( (f ( ( (77777F777>77777777      v    F ' ' ' ' 'f ' ' '444446444v044444444      v    .....V...6"*****f***2*****F***D     V        v   2>4>8>####<3333&!!!(60***@ ) ) )F4200'''8''':8880!!!4,   $0#####r3