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
|
"""
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
from ...babel_names import _babel_systems
from ...compat import babel_parse
from ...util import (
SharedRegistryObject,
getattr_maybe_raise,
logger,
to_units_container,
)
from .definitions import SystemDefinition
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.
"""
def __init__(self, name):
"""
:param name: Name of the group
:type 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.
#: :type: dict[str, dict[str, number]]]
self.base_units = {}
#: Derived unit names.
#: :type: set(str)
self.derived_units = set()
#: Names of the _used_groups in used by this system.
#: :type: set(str)
self._used_groups = set()
#: :type: frozenset | None
self._computed_members = 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):
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:
self._computed_members = set()
for group_name in self._used_groups:
try:
self._computed_members |= d[group_name].members
except KeyError:
logger.warning(
"Could not resolve {} in System {}".format(
group_name, self.name
)
)
self._computed_members = frozenset(self._computed_members)
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):
"""Add groups to group."""
self._used_groups |= set(group_names)
self.invalidate_members()
def remove_groups(self, *group_names):
"""Remove groups from group."""
self._used_groups -= set(group_names)
self.invalidate_members()
def format_babel(self, locale):
"""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
@classmethod
def from_lines(cls, lines, get_root_func, non_int_type=float):
system_definition = SystemDefinition.from_lines(lines, get_root_func)
return cls.from_definition(system_definition, get_root_func)
@classmethod
def from_definition(cls, system_definition: SystemDefinition, get_root_func):
base_unit_names = {}
derived_unit_names = []
for lineno, 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 plain 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(
"In `%s`, the unit at the right of the `:` (%s) must be a root unit."
% (lineno, old_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):
self.d = d
def __dir__(self):
return list(self.d.keys())
def __getattr__(self, item):
getattr_maybe_raise(self, item)
return self.d[item]
|
