1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
|
"""
pint.facets.systems.objects
~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: 2022 by Pint Authors, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import annotations
import numbers
from collections.abc import Callable, Iterable
from numbers import Number
from typing import Any, Generic
from ..._typing import UnitLike
from ...babel_names import _babel_systems
from ...compat import babel_parse
from ...util import (
SharedRegistryObject,
getattr_maybe_raise,
logger,
to_units_container,
)
from .. import group
from ..plain import MagnitudeT
from .definitions import SystemDefinition
GetRootUnits = Callable[[UnitLike, bool], tuple[Number, UnitLike]]
class SystemQuantity(Generic[MagnitudeT], group.GroupQuantity[MagnitudeT]):
pass
class SystemUnit(group.GroupUnit):
pass
class System(SharedRegistryObject):
"""A system is a Group plus a set of plain units.
Members are computed dynamically, that is if a unit is added to a group X
all groups that include X are affected.
The System belongs to one Registry.
See SystemDefinition for the definition file syntax.
Parameters
----------
name
Name of the group.
"""
def __init__(self, name: str):
#: Name of the system
#: :type: str
self.name = name
#: Maps root unit names to a dict indicating the new unit and its exponent.
self.base_units: dict[str, dict[str, numbers.Number]] = {}
#: Derived unit names.
self.derived_units: set[str] = set()
#: Names of the _used_groups in used by this system.
self._used_groups: set[str] = set()
self._computed_members: frozenset[str] | None = None
# Add this system to the system dictionary
self._REGISTRY._systems[self.name] = self
def __dir__(self):
return list(self.members)
def __getattr__(self, item: str) -> Any:
getattr_maybe_raise(self, item)
u = getattr(self._REGISTRY, self.name + "_" + item, None)
if u is not None:
return u
return getattr(self._REGISTRY, item)
@property
def members(self):
d = self._REGISTRY._groups
if self._computed_members is None:
tmp: set[str] = set()
for group_name in self._used_groups:
try:
tmp |= d[group_name].members
except KeyError:
logger.warning(
"Could not resolve {} in System {}".format(
group_name, self.name
)
)
self._computed_members = frozenset(tmp)
return self._computed_members
def invalidate_members(self):
"""Invalidate computed members in this Group and all parent nodes."""
self._computed_members = None
def add_groups(self, *group_names: str) -> None:
"""Add groups to group."""
self._used_groups |= set(group_names)
self.invalidate_members()
def remove_groups(self, *group_names: str) -> None:
"""Remove groups from group."""
self._used_groups -= set(group_names)
self.invalidate_members()
def format_babel(self, locale: str) -> str:
"""translate the name of the system."""
if locale and self.name in _babel_systems:
name = _babel_systems[self.name]
locale = babel_parse(locale)
return locale.measurement_systems[name]
return self.name
# TODO: When 3.11 is minimal version, use Self
@classmethod
def from_lines(
cls: type[System],
lines: Iterable[str],
get_root_func: GetRootUnits,
non_int_type: type = float,
) -> System:
# TODO: we changed something here it used to be
# system_definition = SystemDefinition.from_lines(lines, get_root_func)
system_definition = SystemDefinition.from_lines(lines, non_int_type)
if system_definition is None:
raise ValueError(f"Could not define System from from {lines}")
return cls.from_definition(system_definition, get_root_func)
@classmethod
def from_definition(
cls: type[System],
system_definition: SystemDefinition,
get_root_func: GetRootUnits | None = None,
) -> System:
if get_root_func is None:
# TODO: kept for backwards compatibility
get_root_func = cls._REGISTRY.get_root_units
base_unit_names = {}
derived_unit_names = []
for new_unit, old_unit in system_definition.unit_replacements:
if old_unit is None:
old_unit_dict = to_units_container(get_root_func(new_unit)[1])
if len(old_unit_dict) != 1:
raise ValueError(
"The new unit must be a root dimension if not discarded unit is specified."
)
old_unit, value = dict(old_unit_dict).popitem()
base_unit_names[old_unit] = {new_unit: 1 / value}
else:
# The old unit MUST be a root unit, if not raise an error.
if old_unit != str(get_root_func(old_unit)[1]):
raise ValueError(
f"The old unit {old_unit} must be a root unit "
f"in order to be replaced by new unit {new_unit}"
)
# Here we find new_unit expanded in terms of root_units
new_unit_expanded = to_units_container(
get_root_func(new_unit)[1], cls._REGISTRY
)
# We require that the old unit is present in the new_unit expanded
if old_unit not in new_unit_expanded:
raise ValueError("Old unit must be a component of new unit")
# Here we invert the equation, in other words
# we write old units in terms new unit and expansion
new_unit_dict = {
new_unit: -1 / value
for new_unit, value in new_unit_expanded.items()
if new_unit != old_unit
}
new_unit_dict[new_unit] = 1 / new_unit_expanded[old_unit]
base_unit_names[old_unit] = new_unit_dict
system = cls(system_definition.name)
system.add_groups(*system_definition.using_group_names)
system.base_units.update(**base_unit_names)
system.derived_units |= set(derived_unit_names)
return system
class Lister:
def __init__(self, d: dict[str, Any]):
self.d = d
def __dir__(self) -> list[str]:
return list(self.d.keys())
def __getattr__(self, item: str) -> Any:
getattr_maybe_raise(self, item)
return self.d[item]
|
