o *ήc*@sdZddlZddlZddlZddlmZmZddlmZm Z m Z ddl m Z ddZ dd Zd d Zd d ZGdddZdddZddZddZddddZdS)zUseful utility decorators. N)wrapsupdate_wrapper)DependencyError SymPyDocTestsPyTestReportersympy_deprecation_warningcsDddlmddlmddlmtfdd}|S)z'A factory for ``threaded`` decorators. r)sympify) MatrixBase)iterablecst|r|fddS|r/z|fdd|DWSty.|YSw|}rG|jrG|jfdd|jDS|jrd||jgRi|jgRiS|gRiS)Ncs|gRiSN)fargsfunckwargsr @/tmp/pip-target-vg8gfxp4/lib/python/sympy/utilities/decorator.pysz9threaded_factory..threaded_func..c"g|] }|gRiqSr r .0rrr r "z;threaded_factory..threaded_func..crr r rrr rrr) isinstance applyfunc __class__ TypeErroris_Addr is_Relationallhsrhs)exprrrr rr r use_addrrr threaded_funcs   z'threaded_factory..threaded_func) sympy.corer sympy.matricesr sympy.utilities.iterablesr r)rr$r&r r#rthreaded_factory s   r*cC t|dS)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): Tr*rr r rthreaded( 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 xthreaded<r/r0cs$ddlfdd}t|}|S)zsAfter 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 )mpdps)rrr2rmpmathr r func_wrapperUsz)conserve_mpmath_dps..func_wrapper)r4r)rr5r r3rconserve_mpmath_dpsPs r6c@s"eZdZdZddZdddZdS)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)selfr8rr r r__init__ss zno_attrs_in_subclass.__init__NcCs.||jkrt|jdr|j||S|jSt)N__get__)r8hasattrrr;AttributeError)r9instanceownerr r rr;ws  zno_attrs_in_subclass.__get__r )__name__ __module__ __qualname____doc__r:r;r r r rr7`sr7csbi|dur |d<|dur|d<|dur|d<|dur"|d<fddfdd }|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 preview() to disable python_version should be the minimum Python version required, as a tuple (like (3, 0)) N executablesmodulesdisable_viewerspython_versioncs<t}t|d}z |jdiWdStyYdSw)NTFr )rr_check_dependenciesr)rt) dependenciesr r skiptestss  z%doctest_depends_on..skiptestscs6|_|_t|rt||j|_t||j|_|Sr )_doctest_depends_on__doctest_skip__inspectisclassr7_doctest_depdends_on)fnrKrLr rdepends_on_decos z+doctest_depends_on..depends_on_decor )exerErFrGrTr rSrdoctest_depends_ons   rVcCsvt|tjr |j}|j}nt|tttfr!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__) rtypes FunctionType __globals__r@typesysrErA__dict__rappend)objnsnamer r rpublics   rbcs0djttfdd}t|S)zProperty 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 )getattrsetattr)r9valattrnamepropfuncsentinelr raccessors  z"memoize_property..accessor)r@objectrproperty)rirkr rgrmemoize_propertys rn) stacklevelcs t||dfdd}|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_versionactive_deprecations_targetcsTtdrGfddd}j|_|Stfdd}|_|S)N__mro__csVeZdZjZjZZdjvrfddZZSfddZZS)9deprecated..deprecated_decorator..wrapper__new__cs2tfiditj|g|Ri|SNrp)rsuperru)r8rrrdecorator_kwargsmessagerpr rru<szAdeprecated..deprecated_decorator..wrapper.__new__cs.tfiditj|i|dSrv)rrwr:)r9rrrxr rr:@szBdeprecated..deprecated_decorator..wrapper.__init__) r@rArBrC_sympy_deprecated_funcr]rur: __classcell__r ryrzrpwrapped)rrwrapper7s rcs&tfidi|i|Srvrr%r}r rrEsrt)r<r@rr{)r~rryrzrp)r~rdeprecated_decorator5s  z(deprecated..deprecated_decorator)dict)rzrqrrrprr rr deprecateds @r)NNNN)rCr\rXrO functoolsrrsympy.testing.runtestsrrrsympy.utilities.exceptionsrr*r.r0r6r7rVrbrnrr r r rs"  11