oVh7"dZddlmZddlmZddlmZddlmZmZer"ddlm Z m Z m Z e dZ e d Z e d Zddd Zdd Z ddZddZdZGddZy )z SymPy core decorators. The purpose of this module is to expose decorators without any other dependencies, so that they can be easily imported anywhere in sympy/core. ) annotations) TYPE_CHECKINGwraps) SympifyErrorsympify)CallableTypeVarUnionT1T2T3Ncfd}|S)a decorator to smartly _sympify function arguments Explanation =========== @_sympifyit('other', NotImplemented) def add(self, other): ... In add, other can be thought of as already being a SymPy object. If it is not, the code is likely to catch an exception, then other will be explicitly _sympified, and the whole code restarted. if _sympify(arg) fails, NotImplemented will be returned See also ======== __sympifyit ct|SN) __sympifyit)funcargretvals E/home/dcms/DCMS/lib/python3.12/site-packages/sympy/core/decorators.pydecoz_sympifyit..deco.s4f--)rrrs`` r _sympifyitrs.. Krcjjs tdjjd|k(sJt fd}|St fd}|S)zuDecorator to _sympify `arg` argument for function `func`. Do not use directly -- use _sympifyit instead. zfunc not foundrc,|t|dS)NTstrict)r )abrs r__sympifyit_wrapperz(__sympifyit..__sympifyit_wrapper@s71T23 3rcl t|ds t|d}||S#t$rcYSwxYwN _op_priorityTr)hasattrr r)r r!rrs rr"z(__sympifyit..__sympifyit_wrapperEs@ q.1$/AAqz!   s !% 33)__code__ co_argcount LookupError co_varnamesr)rrrr"s` ` rrr4s~ == $ $*++ == $ $Q '3 .. . ~ t 4  4  t    rcdfd }|S)aA decorator for binary special methods to handle _op_priority. Explanation =========== Binary special methods in Expr and its subclasses use a special attribute '_op_priority' to determine whose special method will be called to handle the operation. In general, the object having the highest value of '_op_priority' will handle the operation. Expr and subclasses that define custom binary special methods (__mul__, etc.) should decorate those methods with this decorator to add the priority logic. The ``method_name`` argument is the name of the method of the other class that will be called. Use this decorator in the following manner:: # Call other.__rmul__ if other._op_priority > self._op_priority @call_highest_priority('__rmul__') def __mul__(self, other): ... # Call other.__mul__ if other._op_priority > self._op_priority @call_highest_priority('__mul__') def __rmul__(self, other): ... c4tdfd }|S)Nct|dr0|j|jkDrt|d}|||S||S)Nr%)r&r%getattr)selfotherfr method_names rbinary_op_wrapperzLcall_highest_priority..priority_decorator..binary_op_wrapperosKun-%%(9(999@ UY9ZA} we$ $r)r/r r0rreturnrr)rr3r2s` rpriority_decoratorz1call_highest_priority..priority_decoratorns! t %  %! rrCallable[[T1, T2], T3]r4r7r)r2r5s` rcall_highest_priorityr8Ss6 ! rc|jjD]2\}}t|tst |||j |4|S)a Decorator for a class with methods that sympify arguments. Explanation =========== The sympify_method_args decorator is to be used with the sympify_return decorator for automatic sympification of method arguments. This is intended for the common idiom of writing a class like : Examples ======== >>> from sympy import Basic, SympifyError, S >>> from sympy.core.sympify import _sympify >>> class MyTuple(Basic): ... def __add__(self, other): ... try: ... other = _sympify(other) ... except SympifyError: ... return NotImplemented ... if not isinstance(other, MyTuple): ... return NotImplemented ... return MyTuple(*(self.args + other.args)) >>> MyTuple(S(1), S(2)) + MyTuple(S(3), S(4)) MyTuple(1, 2, 3, 4) In the above it is important that we return NotImplemented when other is not sympifiable and also when the sympified result is not of the expected type. This allows the MyTuple class to be used cooperatively with other classes that overload __add__ and want to do something else in combination with instance of Tuple. Using this decorator the above can be written as >>> from sympy.core.decorators import sympify_method_args, sympify_return >>> @sympify_method_args ... class MyTuple(Basic): ... @sympify_return([('other', 'MyTuple')], NotImplemented) ... def __add__(self, other): ... return MyTuple(*(self.args + other.args)) >>> MyTuple(S(1), S(2)) + MyTuple(S(3), S(4)) MyTuple(1, 2, 3, 4) The idea here is that the decorators take care of the boiler-plate code for making this happen in each method that potentially needs to accept unsympified arguments. Then the body of e.g. the __add__ method can be written without needing to worry about calling _sympify or checking the type of the resulting object. The parameters for sympify_return are a list of tuples of the form (parameter_name, expected_type) and the value to return (e.g. NotImplemented). The expected_type parameter can be a type e.g. Tuple or a string 'Tuple'. Using a string is useful for specifying a Type within its class body (as in the above example). Notes: Currently sympify_return only works for methods that take a single argument (not including self). Specifying an expected_type as a string only works for the class in which the method is defined. )__dict__items isinstance_SympifyWrappersetattr make_wrapped)clsattrnameobjs rsympify_method_argsrC{sMF++-: # c? + C3#3#3C#8 9: Jrcdfd }|S)zFunction/method decorator to sympify arguments automatically See the docstring of sympify_method_args for explanation. ct|Sr)r=rargss rwrapperzsympify_return..wrapperstT**rr6r)rGrHs` rsympify_returnrIs + NrceZdZdZdZdZy)r=z=Internal class used by sympify_return and sympify_method_argsc ||_||_yrrF)r/rrGs r__init__z_SympifyWrapper.__init__s  rcV|j|j\}|\\}|jk(r|jj}|dk7r t djj d|k7rt d|djtfd}|S)Nz9sympify_return can only be used with 2 argument functionsrzparameter name mismatch "z" in ct|ds t|d}t|sS||S#t$rcYSwxYwr$)r&r rr<)r/r0 expectedclsrrs r_funcz+_SympifyWrapper.make_wrapped.._funcsT 5.1"#E$7Ee[1 e$ $ $"!M"s 3 AA)rrG__name__r'r( RuntimeErrorr*r) r/r@ parameters parameternargsrQrPrrs @@@rr?z_SympifyWrapper.make_wrappedsyy!YY F&0" !)[ #,, &K )) A:Z[ [ == $ $Q '9 4  /0 0 t %  % rN)rR __module__ __qualname____doc__rLr?rrrr=r=sG$rr=r)r4:Callable[[Callable[[T1, T2], T3]], Callable[[T1, T2], T3]])r2strr4rZ)r@type[T1]r4r\)rY __future__rtypingr functoolsrr rr r r r rrrrr8rCrIr=rrrr`sl# *// B B B:>% C%PFR++r