U Š±Ëhd+ã@s’dZddlZddlZddlZddlmZmZddlmZdd„Z dd„Z d d „Z d d „Z Gd d„dƒZ ddd„Zdd„Zdd„Zddœdd„ZdS)zUseful utility decorators. éN)ÚwrapsÚupdate_wrapper©Úsympy_deprecation_warningcsDddlm‰ddlm‰ddlm‰tˆƒ‡‡‡‡‡fdd„ƒ}|S)z'A factory for ``threaded`` decorators. r)Úsympify)Ú MatrixBase)ÚiterablecsÔt|ˆƒr | ‡‡‡fdd„¡Sˆ|ƒrbz| ‡‡‡fdd„|Dƒ¡WStk r^|YSXnnˆ|ƒ}ˆr’|jr’|j‡‡‡fdd„|jDƒŽS|jrÀ| ˆ|jfˆžˆŽˆ|jfˆžˆŽ¡Sˆ|fˆžˆŽSdS)Ncsˆ|fˆžˆŽS©N©)Úf©ÚargsÚfuncÚkwargsr ú=/tmp/pip-unpacked-wheel-6t8vlncq/sympy/utilities/decorator.pyÚóz9threaded_factory..threaded_func..csg|]}ˆ|fˆžˆŽ‘qSr r ©Ú.0r r r rÚ sz;threaded_factory..threaded_func..csg|]}ˆ|fˆžˆŽ‘qSr r rr r rrs) Ú isinstanceZ applyfuncÚ __class__Ú TypeErrorZis_Addr Z is_RelationalÚlhsÚrhs)Úexprr r©rrrrÚuse_add©r rrÚ threaded_funcs   ÿz'threaded_factory..threaded_func)Z sympy.corerZsympy.matricesrZsympy.utilities.iterablesrr)rrrr rrÚthreaded_factory s    r cCs 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'sr#cCs t|dƒS)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Ú xthreaded;sr$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ˆ||ŽW¢S|ˆj_XdSr )ÚmpÚdps)r rr&©rÚmpmathr rÚ func_wrapperTsz)conserve_mpmath_dps..func_wrapper)r(r)rr)r r'rÚconserve_mpmath_dpsOs 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 )Úselfr,r r r rÚ__init__rszno_attrs_in_subclass.__init__NcCs2||jkr*t|jdƒr$|j ||¡S|jSt‚dS)NÚ__get__)r,Úhasattrr r/ÚAttributeError)r-ÚinstanceÚownerr r rr/vs   zno_attrs_in_subclass.__get__)N)Ú__name__Ú __module__Ú __qualname__Ú__doc__r.r/r r r rr+_sr+csri‰|dk r|ˆd<|dk r$|ˆd<|dk r4|ˆd<|dk rD|ˆd<|dk rT|ˆ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_typescsTddlm}m}m}|ƒ}||dƒ}z|jfˆŽWn|k rJYdSXdSdS)Nr)ÚDependencyErrorÚ SymPyDocTestsÚPyTestReporterTF)Zsympy.testing.runtestsr<r=r>Z_check_dependencies)r<r=r>ÚrÚt)Ú dependenciesr rÚ skiptests™s z%doctest_depends_on..skiptestscs6ˆ|_ˆ|_t |¡r2t||jƒ|_t||jƒ|_|Sr )Z_doctest_depends_onZ__doctest_skip__ÚinspectÚisclassr+Z_doctest_depdends_on)Úfn©rArBr rÚdepends_on_deco¤s ÿÿz+doctest_depends_on..depends_on_decor )Zexer8r9r:r;rGr rFrÚdoctest_depends_on~s  rHcCstt|tjƒr|j}|j}n4t|ttƒtfƒrBtj|jj }|j}n t d|ƒ‚d|krb|g|d<n|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__r4ÚtypeÚsysr8r5Ú__dict__rÚappend)ÚobjÚnsÚnamer r rÚpublic²s   rTcs0dˆ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|ˆˆƒ}|ˆkr(ˆ|ƒ}t|ˆ|ƒ|Sr )ÚgetattrÚsetattr)r-Úval©ÚattrnameÚpropfuncÚsentinelr rÚaccessorês   z"memoize_property..accessor)r4ÚobjectrÚproperty)r[r]r rYrÚmemoize_propertyãs  r`é)Ú 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_targetcsRtˆdƒr.G‡‡‡‡fdd„dˆƒ}ˆj|_n tˆƒ‡‡‡‡fdd„ƒ}ˆ|_|S)NÚ__mro__csPeZdZ”jZ”jZ”Zd”jkr6‡‡‡‡fdd„Zn‡‡‡‡fdd„Z‡ZS)ú9deprecated..deprecated_decorator..wrapperÚ__new__cs(tˆfˆdˆi—Žtƒj|f|ž|ŽS©Nrb)rÚsuperrg)r,r r©rÚdecorator_kwargsÚmessagerbr rrg>szAdeprecated..deprecated_decorator..wrapper.__new__cs&tˆfˆdˆi—Žtƒj||ŽdSrh)rrir.)r-r rrjr rr.BszBdeprecated..deprecated_decorator..wrapper.__init__) r4r5r6r7Ú_sympy_deprecated_funcrOrgr.Ú __classcell__r ©rkrlrbÚwrapped)rrÚwrapper9s  rqcstˆfˆdˆi—Žˆ||ŽSrhrrror rrqGsrf)r0r4rrm)rprq©rkrlrb)rprÚdeprecated_decorator7s  z(deprecated..deprecated_decoratorr )rlrcrdrbrsr rrrÚ deprecatedõs @ÿrt)NNNNN)r7rNrJrCÚ functoolsrrZsympy.utilities.exceptionsrr r#r$r*r+rHrTr`rtr r r rÚs$ ÿ 41ÿ