o tBh#@sldZddlZddlmZdZGdddeZGdd d eZGd d d eZ efd d Z ddZ ddZ dS)z5 Method chaining interface. .. versionadded:: 1.0.0 N)UNSET)chaintapthruc@s\eZdZdZeZefddZddZddZ dd Z d d Z e d d Z ddZddZdS)Chainz-Enables chaining of :attr:`module` functions.cCs ||_dS)N_valueselfvaluer f/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/pydash/chaining.py__init__s zChain.__init__cCs ||jS)z Return current value of the chain operations. Returns: mixed: Current value of chain operations. rr r r rr s z Chain.valuecCs|j|S)z Return current value as string. Returns: str: Current value of chain operations casted to ``str``. )module to_stringr rr r rr%szChain.to_stringcCs t|S)z Executes the chained sequence and returns the wrapped result. Returns: Chain: New instance of :class:`Chain` with resolved value from previous :class:`Class`. )rr rr r rcommit.s z Chain.commitcCsv|j}g}t|dr"|g}t|jtr"|j}|d|t|jtst|}|D]}t|j|j|ji|j}q(|S)z Return a clone of the chained sequence planting `value` as the wrapped value. Args: value (mixed): Value to plant as the initial chain value. r r) r hasattr isinstance ChainWrapperinsertrmethodargskwargs)r r wrapperwrappersclonewrapr r rplant8s    z Chain.plantcCs\|dvr|St|j|d}t|s|dst|j|dd}t|s,|jd||S)a Return valid :attr:`module` method. Args: name (str): Name of pydash method to get. Returns: function: :attr:`module` callable. Raises: InvalidMethod: Raised if `name` is not a valid :attr:`module` method. ) __wrapped__N_zInvalid pydash method: )getattrrcallableendswith InvalidMethod)clsnamerr r r get_methodQszChain.get_methodcCst|j||S)aJ Proxy attribute access to :attr:`module`. Args: attr (str): Name of :attr:`module` function to chain. Returns: ChainWrapper: New instance of :class:`ChainWrapper` with value passed on. Raises: InvalidMethod: Raised if `attr` is not a valid function. )rr r(r attrr r r __getattr__rs zChain.__getattr__cCst|jtr |j|}|S)z Return result of passing `value` through chained methods. Args: value (mixed): Initial value to pass through chained methods. Returns: mixed: Result of method chain evaluation of `value`. )rr runwrapr r r r__call__s zChain.__call__N)__name__ __module__ __qualname____doc__pydrrrr rrr classmethodr(r+r-r r r rrs      rc@s4eZdZdZddZddZefddZdd Zd S) rzGWrap :class:`Chain` method call within a :class:`ChainWrapper` context.cCs||_||_d|_i|_dS)Nr )r rrr)r r rr r rrs zChainWrapper.__init__cCs|j|j}|j|_|S)z!Generate a copy of this instance.) __class____new____dict__copy)r newr r r _generates zChainWrapper._generatecCsh|}t|jtr|j||_n t|ts|tur||_|jtur&|j}|j|g|jRi|jS)z Execute :meth:`method` with :attr:`_value`, :attr:`args`, and :attr:`kwargs`. If :attr:`_value` is an instance of :class:`ChainWrapper`, then unwrap it before calling :attr:`method`. ) r9rr rr,rrrr)r r rr r rr,s  zChainWrapper.unwrapcOs||_||_t|S)a% Invoke the :attr:`method` with :attr:`value` as the first argument and return a new :class:`Chain` object with the return value. Returns: Chain: New instance of :class:`Chain` with the results of :attr:`method` passed in as value. )rrr)r rrr r rr-s zChainWrapper.__call__N) r.r/r0r1rr9rr,r-r r r rrs   rc@s$eZdZdZddZefddZdS)_Dashz}Class that provides attribute access to valid :mod:`pydash` methods and callable access to :mod:`pydash` method chaining.cCs t|S)z"Proxy to :meth:`Chain.get_method`.)rr(r)r r rr+s z_Dash.__getattr__cCst|S)zAReturn a new instance of :class:`Chain` with `value` as the seed.rr r r rr-sz_Dash.__call__N)r.r/r0r1r+rr-r r r rr:sr:cCst|S)az Creates a :class:`Chain` object which wraps the given value to enable intuitive method chaining. Chaining is lazy and won't compute a final value until :meth:`Chain.value` is called. Args: value (mixed): Value to initialize chain operations with. Returns: :class:`Chain`: Instance of :class:`Chain` initialized with `value`. Example: >>> chain([1, 2, 3, 4]).map(lambda x: x * 2).sum().value() 20 >>> chain().map(lambda x: x * 2).sum()([1, 2, 3, 4]) 20 >>> summer = chain([1, 2, 3, 4]).sum() >>> new_summer = summer.plant([1, 2]) >>> new_summer.value() 3 >>> summer.value() 10 >>> def echo(item): print(item) >>> summer = chain([1, 2, 3, 4]).for_each(echo).sum() >>> committed = summer.commit() 1 2 3 4 >>> committed.value() 10 >>> summer.value() 1 2 3 4 10 .. versionadded:: 1.0.0 .. versionchanged:: 2.0.0 Made chaining lazy. .. versionchanged:: 3.0.0 - Added support for late passing of `value`. - Added :meth:`Chain.plant` for replacing initial chain value. - Added :meth:`Chain.commit` for returning a new :class:`Chain` instance initialized with the results from calling :meth:`Chain.value`. r;)r r r rrs5rcCs |||S)a Invokes `interceptor` with the `value` as the first argument and then returns `value`. The purpose of this method is to "tap into" a method chain in order to perform operations on intermediate results within the chain. Args: value (mixed): Current value of chain operation. interceptor (callable): Function called on `value`. Returns: mixed: `value` after `interceptor` call. Example: >>> data = [] >>> def log(value): data.append(value) >>> chain([1, 2, 3, 4]).map(lambda x: x * 2).tap(log).value() [2, 4, 6, 8] >>> data [[2, 4, 6, 8]] .. versionadded:: 1.0.0 r r interceptorr r rrsrcCs||S)a Returns the result of calling `interceptor` on `value`. The purpose of this method is to pass `value` through a function during a method chain. Args: value (mixed): Current value of chain operation. interceptor (callable): Function called with `value`. Returns: mixed: Results of ``interceptor(value)``. Example: >>> chain([1, 2, 3, 4]).thru(lambda x: x * 2).value() [1, 2, 3, 4, 1, 2, 3, 4] .. versionadded:: 2.0.0 r r<r r rr*sr) r1pydashr2helpersr__all__objectrrr:rrrr r r rs ~8 8