cached

import ampform.sympy.cached

Handy aliases for working with cached SymPy expressions.

doit(expr: SympyObject) → SympyObject

Perform doit() and cache the result to disk.

The cached result is fetched from disk if the hash of the original expression is the same as the hash embedded in the filename (see get_readable_hash()).

Parameters:

expr – A sympy.Expr on which to call doit().

Added in version 0.14.4.

Helper functions for cached.doit() and related functions.

These methods are private, but can be imported from this module:

import ampform.sympy._cache

cache_to_disk(func: Callable[P, T]) → Callable[P, T]

cache_to_disk(*, dump_function: Callable[[Any, SupportsWrite[bytes]], None] = pickle.dump, load_function: Callable[[BufferedReader], Any] = pickle.load, dependencies: list[str] | None = None, function_name: str | None = None) → Callable[[Callable[P, T]], Callable[P, T]]

Decorator for caching the result of a function to disk.

This function works similarly to functools.cache, but it stores the result of the function to disk as a pickle file.

Tip

• Caching can be disabled by setting the environment variable NO_CACHE. This can be useful to test if caches are correctly invalidated.

• Set COMPWA_CACHE_DIR to change the cache directory. Alternatively, have a look at the implementation of get_system_cache_directory() to see how the cache directory is determined from system environment variables.

get_system_cache_directory() → str

Return the system cache directory for the current platform.

>>> import sys
>>> if sys.platform.startswith("darwin"):
...     assert get_system_cache_directory().endswith("/Library/Caches")
>>> if sys.platform.startswith("linux"):
...     assert get_system_cache_directory().endswith("/.cache")
>>> if sys.platform.startswith("win"):
...     assert get_system_cache_directory().endswith(R"\AppData\Local")

get_readable_hash(obj: Hashable, /) → str

Get a human-readable hash of any hashable Python object.

The hash follows from the value of the object, not from the identity of the parts it is built from. Two SymPy expressions that compare equal therefore hash the same, no matter what was constructed before them or in which process, which is what makes the hash usable as a cache key in cache_to_disk().

A set or dict handed to this function directly is serialized in iteration order, which depends on PYTHONHASHSEED when its elements or keys are str. Pass it through make_hashable() first, as cache_to_disk() does, to put it in a fixed order.

Parameters:

obj – Any hashable object, mutable or immutable, to be hashed.

to_bytes(obj, /) → bytes

Convert any Python object to bytes with pickle.

The bytes depend on the value of the object rather than on which of its parts happen to be the same instance. See get_readable_hash() for what that guarantees.

make_hashable(*args) → Hashable

Make a hashable object from any Python object.

Sets and dictionaries are put in a fixed order, because a set iterates in an order that depends on PYTHONHASHSEED for str elements, and a dict built by iterating one inherits that order. A cache key built from them would otherwise differ in every process.

>>> make_hashable("a", 1, {"b": 2}, {3, 4})
('a', 1, frozendict.frozendict({'b': 2}), _SortedSet(items=(3, 4)))
>>> make_hashable({"a": {"sub-key": {1, 2, 3}, "b": [4, 5]}})
frozendict.frozendict({'a': frozendict.frozendict({'b': (4, 5), 'sub-key': _SortedSet(items=(1, 2, 3))})})
>>> make_hashable("already-hashable")
'already-hashable'

simplify(expr: Expr, *args, **kwargs) → Expr

Perform simplify() and cache the result to disk.

Added in version 0.15.7.

trigsimp(expr: Expr, *args, **kwargs) → Expr

Perform trigsimp() and cache the result to disk.

Added in version 0.15.7.

subs(expr: Expr, substitutions: Mapping[Basic, Any]) → Expr

Call subs() and cache the result to disk.

The order of the substitutions does not affect the cache key.

xreplace(expr: Expr, substitutions: Mapping[Basic, Any]) → Expr

Call xreplace() and cache the result to disk.

The order of the substitutions does not affect the cache key.

unfold(obj: Model) → Expr

unfold(obj: Expr, substitutions: Mapping[Basic, Any]) → Expr

Efficiently perform both substitutions and doit().

class Model(*args, **kwargs)

Bases: Protocol

property intensity: Expr

property amplitudes: Mapping[Basic, Basic]