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
|
"""
pint
~~~~
Pint is Python module/package to define, operate and manipulate
**physical quantities**: the product of a numerical value and a
unit of measurement. It allows arithmetic operations between them
and conversions from and to different units.
:copyright: 2016 by Pint Authors, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
import sys
from .context import Context
from .errors import ( # noqa: F401
DefinitionSyntaxError,
DimensionalityError,
LogarithmicUnitCalculusError,
OffsetUnitCalculusError,
RedefinitionError,
UndefinedUnitError,
UnitStrippedWarning,
)
from .formatting import formatter
from .measurement import Measurement
from .quantity import Quantity
from .registry import LazyRegistry, UnitRegistry
from .unit import Unit
from .util import logger, pi_theorem
try:
from importlib.metadata import version
except ImportError:
# Backport for Python < 3.8
from importlib_metadata import version
try:
from pint_pandas import PintArray, PintType
del PintType
del PintArray
_HAS_PINT_PANDAS = True
except ImportError:
_HAS_PINT_PANDAS = False
_, _pint_pandas_error, _ = sys.exc_info()
try: # pragma: no cover
__version__ = version("pint")
except Exception: # pragma: no cover
# we seem to have a local copy not installed without setuptools
# so the reported version will be unknown
__version__ = "unknown"
#: A Registry with the default units and constants.
_DEFAULT_REGISTRY = LazyRegistry()
#: Registry used for unpickling operations.
_APP_REGISTRY = _DEFAULT_REGISTRY
def _unpickle(cls, *args):
"""Rebuild object upon unpickling.
All units must exist in the application registry.
Parameters
----------
cls : Quantity, Magnitude, or Unit
*args
Returns
-------
object of type cls
"""
from .unit import UnitsContainer
for arg in args:
# Prefixed units are defined within the registry
# on parsing (which does not happen here).
# We need to make sure that this happens before using.
if isinstance(arg, UnitsContainer):
for name in arg:
_APP_REGISTRY.parse_units(name)
return cls(*args)
def _unpickle_quantity(cls, *args):
"""Rebuild quantity upon unpickling using the application registry."""
return _unpickle(_APP_REGISTRY.Quantity, *args)
def _unpickle_unit(cls, *args):
"""Rebuild unit upon unpickling using the application registry."""
return _unpickle(_APP_REGISTRY.Unit, *args)
def _unpickle_measurement(cls, *args):
"""Rebuild measurement upon unpickling using the application registry."""
return _unpickle(_APP_REGISTRY.Measurement, *args)
def set_application_registry(registry):
"""Set the application registry, which is used for unpickling operations
and when invoking pint.Quantity or pint.Unit directly.
Parameters
----------
registry : pint.UnitRegistry
"""
if not isinstance(registry, (LazyRegistry, UnitRegistry)):
raise TypeError("Expected UnitRegistry; got %s" % type(registry))
global _APP_REGISTRY
logger.debug("Changing app registry from %r to %r.", _APP_REGISTRY, registry)
_APP_REGISTRY = registry
def get_application_registry():
"""Return the application registry. If :func:`set_application_registry` was never
invoked, return a registry built using :file:`defaults_en.txt` embedded in the pint
package.
Returns
-------
pint.UnitRegistry
"""
return _APP_REGISTRY
def test():
"""Run all tests.
Returns
-------
unittest.TestResult
"""
from .testsuite import run
return run()
# Enumerate all user-facing objects
# Hint to intersphinx that, when building objects.inv, these objects must be registered
# under the top-level module and not in their original submodules
__all__ = (
"Context",
"Measurement",
"Quantity",
"Unit",
"UnitRegistry",
"DefinitionSyntaxError",
"DimensionalityError",
"OffsetUnitCalculusError",
"RedefinitionError",
"UndefinedUnitError",
"UnitStrippedWarning",
"formatter",
"get_application_registry",
"set_application_registry",
"pi_theorem",
"__version__",
)
|
