o GZŽh°+ã@s¶dZddlmZddlZddlZddlZddlmZmZddl m Z edƒZ dd„Z d d „Z d d „Zd d„ZGdd„dƒZ  ddd„Zde de fdd„Zdd„Zddœdd„ZdS)zUseful utility decorators. é)ÚTypeVarN)ÚwrapsÚupdate_wrapper©Úsympy_deprecation_warningÚTcsDddlm‰ddlm‰ddlm‰tˆƒ‡‡‡‡‡fdd„ƒ}|S)z'A factory for ``threaded`` decorators. r)Úsympify)Ú MatrixBase)ÚiterablecsÞt|ˆƒr| ‡‡‡fdd„¡Sˆ|ƒr/z| ‡‡‡fdd„|Dƒ¡WSty.|YSwˆ|ƒ}ˆrG|jrG|j‡‡‡fdd„|jDƒŽS|jrd| ˆ|jgˆ¢Riˆ¤Žˆ|jgˆ¢Riˆ¤Ž¡Sˆ|gˆ¢Riˆ¤ŽS)Ncsˆ|gˆ¢Riˆ¤ŽS©N©)Úf©ÚargsÚfuncÚkwargsr úH/var/www/auris/lib/python3.10/site-packages/sympy/utilities/decorator.pyÚsz9threaded_factory..threaded_func..có"g|] }ˆ|gˆ¢Riˆ¤Ž‘qSr r ©Ú.0r rr rÚ ó"z;threaded_factory..threaded_func..crr r rrr rr#r) Ú isinstanceZ applyfuncÚ __class__Ú TypeErrorZis_AddrZ is_RelationalÚlhsÚrhs)Úexprrr©r rr rÚuse_add©rrrÚ threaded_funcs  ÿ ÿz'threaded_factory..threaded_func)Z sympy.corerZsympy.matricesr Zsympy.utilities.iterablesr r)rr r"r rrÚthreaded_factorys   r#cCó t|dƒS)aUApply ``func`` to sub--elements of an object, including :class:`~.Add`. This decorator is intended to make it uniformly possible to apply a function to all elements of composite objects, e.g. matrices, lists, tuples and other iterable containers, or just expressions. This version of :func:`threaded` decorator allows threading over elements of :class:`~.Add` class. If this behavior is not desirable use :func:`xthreaded` decorator. Functions using this decorator must have the following signature:: @threaded def function(expr, *args, **kwargs): T©r#©rr r rÚthreaded-ó r'cCr$)aXApply ``func`` to sub--elements of an object, excluding :class:`~.Add`. This decorator is intended to make it uniformly possible to apply a function to all elements of composite objects, e.g. matrices, lists, tuples and other iterable containers, or just expressions. This version of :func:`threaded` decorator disallows threading over elements of :class:`~.Add` class. If this behavior is not desirable use :func:`threaded` decorator. Functions using this decorator must have the following signature:: @xthreaded def function(expr, *args, **kwargs): Fr%r&r r rÚ xthreadedAr(r)cs$ddl‰‡‡fdd„}t|ˆƒ}|S)zwAfter the function finishes, resets the value of ``mpmath.mp.dps`` to the value it had before the function was run.rNcs,ˆjj}z ˆ|i|¤ŽW|ˆj_S|ˆj_wr )ÚmpÚdps)rrr+©rÚmpmathr rÚ func_wrapperZsz)conserve_mpmath_dps..func_wrapper)r-r)rr.r r,rÚconserve_mpmath_dpsUs r/c@s"eZdZdZdd„Zddd„ZdS)Úno_attrs_in_subclassaEDon't 'inherit' certain attributes from a base class >>> from sympy.utilities.decorator import no_attrs_in_subclass >>> class A(object): ... x = 'test' >>> A.x = no_attrs_in_subclass(A, A.x) >>> class B(A): ... pass >>> hasattr(A, 'x') True >>> hasattr(B, 'x') False cCs||_||_dSr )Úclsr )Úselfr1r r r rÚ__init__xs zno_attrs_in_subclass.__init__NcCs.||jkrt|jdƒr|j ||¡S|jSt‚)NÚ__get__)r1Úhasattrr r4ÚAttributeError)r2ÚinstanceÚownerr r rr4|s  zno_attrs_in_subclass.__get__r )Ú__name__Ú __module__Ú __qualname__Ú__doc__r3r4r r r rr0esr0csri‰|dur |ˆd<|dur|ˆd<|dur|ˆd<|dur"|ˆd<|dur*|ˆd<‡fdd„‰‡‡fd d „}|S) a­ Adds metadata about the dependencies which need to be met for doctesting the docstrings of the decorated objects. ``exe`` should be a list of executables ``modules`` should be a list of modules ``disable_viewers`` should be a list of viewers for :func:`~sympy.printing.preview.preview` to disable ``python_version`` should be the minimum Python version required, as a tuple (like ``(3, 0)``) NZ executablesÚmodulesÚdisable_viewersÚpython_versionÚ ground_typescsPddlm}m}m}|ƒ}||dƒ}z |jdiˆ¤ŽWdS|y'YdSw)Nr)ÚDependencyErrorÚ SymPyDocTestsÚPyTestReporterTFr )Zsympy.testing.runtestsrArBrCZ_check_dependencies)rArBrCÚrÚt)Ú dependenciesr rÚ skiptestsŸs  ýÿz%doctest_depends_on..skiptestscs6ˆ|_ˆ|_t |¡rt||jƒ|_t||jƒ|_|Sr )Z_doctest_depends_onZ__doctest_skip__ÚinspectÚisclassr0Z_doctest_depdends_on)Úfn©rFrGr rÚdepends_on_decoªs ÿÿz+doctest_depends_on..depends_on_decor )Úexer=r>r?r@rLr rKrÚdoctest_depends_on„s   rNÚobjÚreturncCsvt|tjƒr |j}|j}nt|ttƒtfƒr!tj|jj }|j}nt d|ƒ‚d|vr2|g|d<|S|d  |¡|S)aå Append ``obj``'s name to global ``__all__`` variable (call site). By using this decorator on functions or classes you achieve the same goal as by filling ``__all__`` variables manually, you just do not have to repeat yourself (object's name). You also know if object is public at definition site, not at some random location (where ``__all__`` was set). Note that in multiple decorator setup (in almost all cases) ``@public`` decorator must be applied before any other decorators, because it relies on the pointer to object's global namespace. If you apply other decorators first, ``@public`` may end up modifying the wrong namespace. Examples ======== >>> from sympy.utilities.decorator import public >>> __all__ # noqa: F821 Traceback (most recent call last): ... NameError: name '__all__' is not defined >>> @public ... def some_function(): ... pass >>> __all__ # noqa: F821 ['some_function'] z&expected a function or a class, got %sÚ__all__) rÚtypesÚ FunctionTypeÚ __globals__r9ÚtypeÚsysr=r:Ú__dict__rÚappend)rOÚnsÚnamer r rÚpublic¸s   þr[cs0dˆj‰tƒ‰tˆƒ‡‡‡fdd„ƒ}t|ƒS)zÍProperty decorator that caches the value of potentially expensive ``propfunc`` after the first evaluation. The cached value is stored in the corresponding property name with an attached underscore.Ú_cs,t|ˆˆƒ}|ˆurˆ|ƒ}t|ˆ|ƒ|Sr )ÚgetattrÚsetattr)r2Úval©ÚattrnameÚpropfuncÚsentinelr rÚaccessorðs  z"memoize_property..accessor)r9ÚobjectrÚproperty)rbrdr r`rÚmemoize_propertyés rgé)Ú stacklevelcs||dœ‰‡‡‡fdd„}|S)aš Mark a function as deprecated. This decorator should be used if an entire function or class is deprecated. If only a certain functionality is deprecated, you should use :func:`~.warns_deprecated_sympy` directly. This decorator is just a convenience. There is no functional difference between using this decorator and calling ``warns_deprecated_sympy()`` at the top of the function. The decorator takes the same arguments as :func:`~.warns_deprecated_sympy`. See its documentation for details on what the keywords to this decorator do. See the :ref:`deprecation-policy` document for details on when and how things should be deprecated in SymPy. Examples ======== >>> from sympy.utilities.decorator import deprecated >>> from sympy import simplify >>> @deprecated(""" ... The simplify_this(expr) function is deprecated. Use simplify(expr) ... instead.""", deprecated_since_version="1.1", ... active_deprecations_target='simplify-this-deprecation') ... def simplify_this(expr): ... """ ... Simplify ``expr``. ... ... .. deprecated:: 1.1 ... ... The ``simplify_this`` function is deprecated. Use :func:`simplify` ... instead. See its documentation for more information. See ... :ref:`simplify-this-deprecation` for details. ... ... """ ... return simplify(expr) >>> from sympy.abc import x >>> simplify_this(x*(x + 1) - x**2) # doctest: +SKIP :1: SymPyDeprecationWarning: The simplify_this(expr) function is deprecated. Use simplify(expr) instead. See https://docs.sympy.org/latest/explanation/active-deprecations.html#simplify-this-deprecation for details. This has been deprecated since SymPy version 1.1. It will be removed in a future version of SymPy. simplify_this(x) x See Also ======== sympy.utilities.exceptions.SymPyDeprecationWarning sympy.utilities.exceptions.sympy_deprecation_warning sympy.utilities.exceptions.ignore_warnings sympy.testing.pytest.warns_deprecated_sympy )Údeprecated_since_versionÚactive_deprecations_targetcsTtˆdƒrG‡‡‡‡fdd„dˆƒ}ˆj|_|Stˆƒ‡‡‡‡fdd„ƒ}ˆ|_|S)NÚ__mro__csVeZdZ”jZ”jZ”Zd”jvr‡‡‡‡fdd„Z‡ZS‡‡‡‡fdd„Z‡ZS)ú9deprecated..deprecated_decorator..wrapperÚ__new__cs2tˆfiˆ¤dˆi¤Žtƒj|g|¢Ri|¤ŽS©Nri)rÚsuperrn)r1rr©rÚdecorator_kwargsÚmessagerir rrnDszAdeprecated..deprecated_decorator..wrapper.__new__cs.tˆfiˆ¤dˆi¤Žtƒj|i|¤ŽdSro)rrpr3)r2rrrqr rr3HszBdeprecated..deprecated_decorator..wrapper.__init__) r9r:r;r<Ú_sympy_deprecated_funcrWrnr3Ú __classcell__r ©rrrsriÚwrapped)rrÚwrapper?s rxcs&tˆfiˆ¤dˆi¤Žˆ|i|¤ŽSrorr!rvr rrxMsrm)r5r9rrt)rwrx©rrrsri)rwrÚdeprecated_decorator=s  ûz(deprecated..deprecated_decoratorr )rsrjrkrirzr ryrÚ deprecatedûs @ÿr{)NNNNN)r<ÚtypingrrVrRrHÚ functoolsrrZsympy.utilities.exceptionsrrr#r'r)r/r0rNr[rgr{r r r rÚs*   ÿ41ÿ