PlasmaCalcs.quantities.quantity_tools.MatchedVar

class PlasmaCalcs.quantities.quantity_tools.MatchedVar(var, loadable=None, *, _match=None, fname=None, deps=UNSET, attr_deps=UNSET, value_deps=UNSET, dims=UNSET, ignores_dims=UNSET, reduces_dims=UNSET, **kw_super)

Bases: MatchedQuantity

LoadableVar matched to a var, which can be loaded from a QuantityLoader.

var: str: the var matched to this object.
loadable: LoadableVar or None: the LoadableVar associated with this MatchedVar instance.

None –> create one from fname, deps, dims, ignores_dims, and reduces_dims,

using defaults if UNSET. (however, fname must be provided in this case.)
_match: result of re.match: the result of pattern.fullmatch(var) for the pattern associated with this object.

None –> no pattern match; either no associated pattern or var is not a match.

self.fname aliases to self.loadable.fname.
similarly for deps, attr_deps, value_deps, dims, ignores_dims, reduces_dims.
also similarly for self.get_f and self.get_f_module.

__init__(var, loadable=None, *, _match=None, fname=None, deps=UNSET, attr_deps=UNSET, value_deps=UNSET, dims=UNSET, ignores_dims=UNSET, reduces_dims=UNSET, **kw_super)

Methods

`__init__`(var[, loadable, _match, fname, ...])
`all_deps`([quantity_loader, missing_ok])
`dep_vars`([quantity_loader, missing_ok])
`groups`(*[, default])
`items`()
`keys`()
`load_value`(quantity_loader, args, *kw)

Attributes

`attr_deps`
`deps`
`dims`
`fname`
`get_f`
`get_f_module`
`ignores_dims`
`reduces_dims`
`value_deps`

all_deps(quantity_loader=None, *, missing_ok=False)

returns list of deps, based on quantity_loader and self.deps, self.attr_deps, and self.value_deps.
Each dep in result is a str, int, tuple, dict, or callable.
See self.dep_vars() to convert list of deps to list of strs.
If any attr_deps or value_deps are provided, quantity_loader must be provided.

missing_ok: bool: whether to return [] for attr_dep when quantity_loader is a class and attr is a property.

False –> crash with InputError in that case.

property attr_deps: alias to self.loadable.attr_deps

dep_vars(quantity_loader=None, *, missing_ok=False)

returns list of dep var strings or 2-tuples of (str, using)

These are the var names associated with self.deps, self.attr_deps, and self.value_deps.

Each string will be a quant that QuantityLoader might load;

might be a KNOWN_VAR or might be a KNOWN_PATTERN.

(However, this method doesn’t know whether the deps are actually loadable).

Each 2-tuple has a string like above,

and a dict of values essential to set via quantity_loader.using(**dict),
when trying to determine the deps of that string,
e.g. during quantity_loader.match_var_tree().
(If it’s not essential to set values, use string instead of 2-tuple.)

self.deps is a list of str/int/tuple/dict/callable

list of dependencies for this quant. Each dependency is one of the following:

- a str, indicating a known var or pattern name,

- an int, indicating a group index from a pattern match,

- a 2-tuple of (non-tuple-dep, dict),

where dict tells any values essential to set via quantity_loader.using(**dict),

in order to properly determine deps.

E.g. (‘n’, {‘fluid’: ELECTRON}) for ‘depends on n when self.fluid=electron’.

Note: mostly intended for internal use (in value_deps). It’s usually preferable to

just define a different variable, e.g. ‘ne’ which will set values appropriately.

- a dict with length 1, with

key = int or tuple of ints, specifying which groups are relevant.

dep will utilize info about groups = _match.groups().

val = str, or callable f -> str or iterable.

str –> val.format(**group_info), where

group_info = {f’group{i}’: groups[i] for i in key},

replacing groups[i] with ‘’ if groups[i] is None.

callable f –> f(group_info), where

group_info = {i: groups[i] for i in key}

- a callable of the form f(quantity_loader, var, groups) -> str or iterable,

which tells the var name(s) associated with this dependency,

where: quantity_loader is a QuantityLoader instance,

var is the matched var,

and groups=_match.groups() if _match provided else None.

self.attr_deps is a list of 2-tuples of (str, dict or str)

list of attr-based dependencies for this quant. Each dependency is:

(attr, lookup), where lookup.get(v, []) tells str or list of deps associated with v,
where v=quantity_loader.attr.
if ‘__default__’ in lookup, use lookup.get(v, lookup[‘__default__’]) instead.
str lookup –> lookup = getattr(quantity_loader, lookup).

self.value_deps is a list of 2-tuples of (str, dict or str)

list of value-based dependencies for this quant. Each dependency is:

(var, lookup), where lookup.get(val, []) tells str or list of deps associated with val,
for all unique vals in quantity_loader(var).
Each dep associated with val may be str/int/callable, similar to deps.
if ‘__default__’ in lookup, use lookup.get(v, lookup[‘__default__’]) instead.
str lookup –> lookup = getattr(quantity_loader, lookup).

quantity_loader: None or QuantityLoader: if any dep is callable, quantity_loader must be provided,

and is used to get string for dep via dep(quantity_loader, self.var, self.groups(default=None))

if any attr_deps or value_deps are provided, quantity_loaded must be provided,

and is used to convert to list of deps based on attr or values.
missing_ok: bool: whether to be lenient sometimes when missing details that would allow to fully determine deps.

E.g., if quantity_loader is a class (e.g. dep_vars called inside QuantityLoader.cls_var_tree()),

and an attr_dep’s attr’s value is a property, ignore that attr_dep if missing_ok, else crash.

property deps: alias to self.loadable.deps

property dims: alias to self.loadable.dims

property fname: alias to self.loadable.fname

property get_f: alias to self.loadable.get_f

property get_f_module: alias to self.loadable.get_f_module

groups(*, default=UNSET)

return self._match.groups().

default: UNSET or any object: if _match is None, return default if provided (not UNSET), else raise TypeError.

property ignores_dims: alias to self.loadable.ignores_dims

items(): returns (key, self[key]) for key in self.keys().

keys(): returns keys whose values can be accessed via self[key].

i.e.: (‘var’, ‘loadable’, ‘_match’, ‘fname’,

‘deps’, ‘attr_deps’, ‘value_deps’,

‘dims’, ‘ignores_dims’, ‘reduces_dims’).

load_value(quantity_loader, *args, **kw): actually get the value of this matched var, from the quantity loader.

uses getter = self.get_f(quantity_loader);

if _match is None, calls getter(*args, **kw);

else, calls getter(self.var, *args, _match=_match, **kw).

property reduces_dims: alias to self.loadable.reduces_dims

property value_deps: alias to self.loadable.value_deps