O=d#dZddlZddlmZdZGddeZGdd eZGd d eZ efd Z d Z dZ dS)z5 Method chaining interface. .. versionadded:: 1.0.0 N)UNSET)chaintapthrucZeZdZdZeZefdZdZdZ dZ dZ e dZ dZd Zd S) Chainz-Enables chaining of :attr:`module` functions.c||_dS)N_valueselfvalues 9D:\Sites\api_v1\venv\Lib\site-packages\pydash/chaining.py__init__zChain.__init__s  c"||jS)z Return current value of the chain operations. Returns: mixed: Current value of chain operations. r rs rrz Chain.valuestDK   rcZ|j|S)z Return current value as string. Returns: str: Current value of chain operations casted to ``str``. )module to_stringrrs rrzChain.to_string%s"{$$TZZ\\222rcDt|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`. )r rrs rcommitz Chain.commit.sTZZ\\"""rc\|j}g}t|drT|g}t|jtr7|j}|d|t|jt7t |}|D],}t|j|j|ji|j}-|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 ChainWrapperinsertr methodargskwargs)rrwrapperwrappersclonewraps rplantz Chain.plant8s+ 7H % % ,yHW^\:: ,!.7+++W^\:: ,e  W WD;Lt{;;TYV$+VVEE rc|dvr|St|j|d}t|s.|dst|j|dzd}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)clsnamers r get_methodzChain.get_methodQs" # # #JT400 ; c(:(: ;SZT::F M***+KT+K+KLL L rcRt|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 r0rattrs r __getattr__zChain.__getattr__rs"DK)>)>???rcnt|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 s r__call__zChain.__call__s2 dk< 0 0 .K&&u--E rN)__name__ __module__ __qualname____doc__pydrrrrrrr& classmethodr0r4r7rrr r s77F"!!!333###2[@ @ @ @     rr c.eZdZdZdZdZefdZdZdS)rzGWrap :class:`Chain` method call within a :class:`ChainWrapper` context.c>||_||_d|_i|_dS)Nr>)r rr r!)rrrs rrzChainWrapper.__init__s"    rc|j|j}|j|_|S)z!Generate a copy of this instance.) __class____new____dict__copy)rnews r _generatezChainWrapper._generates5n$$T^44}))++  rcH|}t|jtr |j||_n%t|ts|t ur||_|jt ur|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`. ) rGrr rr6rrr r!)rrr"s rr6zChainWrapper.unwraps.."" gnl 3 3 #$^22599GNNE<00 #U%5G5G"GN > & &NEw~eEglEEEgnEEErc<||_||_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. )r r!r )rr r!s rr7zChainWrapper.__call__s  T{{rN) r8r9r:r;rrGrr6r7r>rrrrsdQQ !FFFF4     rrc"eZdZdZdZefdZdS)_Dashz}Class that provides attribute access to valid :mod:`pydash` methods and callable access to :mod:`pydash` method chaining.c6t|S)z"Proxy to :meth:`Chain.get_method`.)r r0r2s rr4z_Dash.__getattr__s%%%rc t|S)zAReturn a new instance of :class:`Chain` with `value` as the seed.r r s rr7z_Dash.__call__sU||rN)r8r9r:r;r4rr7r>rrrKrKsF&&&&&#rrKc t|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`. rN)rs rrrsj <<rc|||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 interceptors rrrs0K Lrc||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>rQs rrr*s& ;u  r) r;pydashr<helpersr__all__objectr rrKrrrr>rrrXs  {{{{{F{{{|555556555p     F   5555p8r