unitx 0.7.0__tar.gz → 0.7.1__tar.gz

{unitx-0.7.0 → unitx-0.7.1}/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## [0.7.1] - 2026-10-19
+
+### Added
+
+- Accept a single exact spelling string for `prefixable`, equivalent to a
+  one-element tuple, with the same spelling validation before registration.
+- Expand the `si` namespace's prefixed shortcuts and common units, including
+  percent, permille, permyriad, rotational frequency (`rpm`), speed of light
+  (`c`), gram-force, volt-ampere, ampere-hour, mho, and nit. Enable Torr prefixes.
+- Add `SI.kappa` and the wavelength and frequency Wien displacement constants,
+  `SI.b` and `SI.b_`.
+
+### Changed
+
+- Use fixed Decimal approximations with about 50 significant digits for pi and
+  the positive roots in the Wien displacement laws. Derived constants still use
+  the Decimal context active at import.
+- Treat `u` and `Da` as spellings of one formal unit, with prefixes enabled only
+  on `Da`. Rebuild stored units when migrating from the separate `u` identity;
+  the mass conversion scale is unchanged. Use `kDa` rather than `kilodalton`.
+- Keep ASCII micro spellings such as `um` and `us` convenient to type without
+  warnings. The explicit product `u m` retains its separate mass-times-length
+  meaning.
+
 ## [0.7.0] - 2026-10-19
 
 ### Added

{unitx-0.7.0 → unitx-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unitx
-Version: 0.7.0
+Version: 0.7.1
 Summary: A modern, intuitive Python library for units, quantities, and dimensional analysis.
 Project-URL: Homepage, https://github.com/DaitTHU/unitx
 Project-URL: Issues, https://github.com/DaitTHU/unitx/issues
@@ -22,11 +22,15 @@ Description-Content-Type: text/markdown
 
 # unitx
 
-Write Python formulas with ready-to-use units and physical constants. unitx
+[![PyPI version](https://img.shields.io/pypi/v/unitx)](https://pypi.org/project/unitx/)
+[![Python versions](https://img.shields.io/pypi/pyversions/unitx)](https://pypi.org/project/unitx/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Write Python formulas with ready-to-use units and physical constants. `unitx`
 handles scalar quantities, unit conversion, and dimensional analysis, with
 exact rational unit scales and exponents.
 
-unitx is in early development. Public APIs may change during the 0.x series.
+`unitx` is in early development. Public APIs may change during the 0.x series.
 
 ## Installation
 
@@ -101,15 +105,17 @@ astronomical units are included. Units and constants can be combined directly:
 
 Both namespaces are read-only and do not need to be instantiated. `si` exposes
 a selection of convenient attributes; other registered prefix combinations
-remain available through `Unit`, for example `Unit('Tm')`. Importing unitx
+remain available through `Unit`, for example `Unit('Tm')`. Importing `unitx`
 initializes the predefined unit catalogue. Defining a custom unit registers its
 text spellings without adding an attribute to `si`.
 
 SI defining constants retain their exact decimal values. Measured constants
 are stored nominal values; measurement uncertainties are not propagated.
 Derived Decimal constants are evaluated in the Decimal context active at
-import. Formulas involving pi use `Decimal(str(math.pi))` as an approximation;
-additional Decimal precision does not add precision to pi.
+import. Pi and the positive roots used by the Wien displacement constants
+(`SI.b` for wavelength and `SI.b_` for frequency) use fixed Decimal
+approximations with about 50 significant digits. Raising the context precision
+does not add accuracy beyond those stored approximations.
 
 ## Constructing units and quantities
 
@@ -267,7 +273,7 @@ meaning rather than acting as string delimiters. Bare compound names are
 not guessed from adjacent words, and ordinary parentheses still group products.
 
 The unit table contains `s`, `m`, `g`, `A`, `K`, `mol`, and `cd`, plus the
-dimensionless identity. Importing unitx also initializes the common units in
+dimensionless identity. Importing `unitx` also initializes the common units in
 `unitx.si`, including named derived units such as `N`. Mass scales are referenced
 to kilograms: `g` has factor `1/1000`, and `kg` has factor `1`.
 
@@ -337,8 +343,9 @@ Bare multiword names are recognized only as complete inputs. For example,
 as a factor; use `[astronomical unit] / arcsec`, symbols, or Unit objects instead.
 
 SI prefixes are enabled by default. `prefixable: PrefixPolicy = True` accepts
-`True` for all spellings, `False` for none, or a tuple of exact symbols, names,
-and aliases supplied in that definition. With a tuple, only the listed
+`True` for all spellings, `False` for none, a single spelling string, or a tuple
+of exact symbols, names, and aliases supplied in that definition. A string such
+as `prefixable='Da'` is equivalent to `prefixable=('Da',)`. Only the selected
 spellings accept prefixes; an empty tuple disables prefixes. Unknown spellings
 and non-string entries are errors. For example,
 `prefixable=('arcsec', 'arcsecond')` enables all SI prefixes on those two
@@ -347,7 +354,7 @@ spellings, while other spellings of that unit remain unprefixable.
 The tuple selects **unit spellings**, not prefix symbols. Prefix names attach
 directly to the first word of a multiword name, as in `kiloastronomical unit`;
 a separate `kilo astronomical unit` is not accepted. `PrefixPolicy` is available
-from `unitx.unitregistry` for annotations and means `bool | tuple[str, ...]`.
+from `unitx.unitregistry` for annotations and means `bool | str | tuple[str, ...]`.
 
 ```pycon
 >>> tick = si.s.define(
@@ -390,10 +397,24 @@ form; `760 * si.mmHg` converts to `si.atm` with value 1 under the library's
 existing pressure convention. Prefixes do not stack: `mmmHg` and `kmmHg` are
 invalid. `kt` retains its meaning as a knot alias; tonne remains unprefixable.
 
-The newly registered `u` denotes the unified atomic mass unit. ASCII micro
-spellings such as `um` still mean micrometres, but now issue `UnitSymbolWarning`
-because `u m` has a separate meaning. Use `µm`, `μm`, or `micrometre` to avoid
-this warning.
+`si.mas` and `si.uas` provide milli- and microarcseconds as namespace shortcuts;
+their registered expressions are `marcsec` and `µarcsec`. The strings `mas`
+and `uas` are not registered aliases. `si.Da` and `si.u` now share one formal
+unit identity; only the spelling `Da` accepts prefixes, such as `kDa`.
+`si.mTorr` is available, and Torr accepts SI prefixes. Tonne uses `t` or
+`tonne`; the ambiguous spelling `ton` is not registered.
+
+`si.rpm` represents rotational frequency: `60 * si.rpm` converts to `si.Hz`
+with value 1. For angular velocity, multiply that frequency by `2 * PI` and
+convert to `si.rad / si.s`; directly converting frequency to `rad/s` does
+not insert the physical factor of 2π. `si.c` is a speed unit equal to the
+speed of light, while `SI.c` is the corresponding physical quantity.
+
+The spelling `u` denotes the unified atomic mass unit when used on its own.
+ASCII micro spellings such as `um` and `us` remain supported without warnings,
+so entering non-ASCII characters is optional. `um`, `µm`, `μm`, and
+`micrometre` all mean micrometres; the explicit product `u m` instead means
+unified atomic mass unit times metre.
 
 Registration raises `UnitRegistryError` if a new spelling, including a generated
 prefixed form, already resolves to a unit or conflicts with another spelling

{unitx-0.7.0 → unitx-0.7.1}/README.md

@@ -1,10 +1,14 @@
 # unitx
 
-Write Python formulas with ready-to-use units and physical constants. unitx
+[![PyPI version](https://img.shields.io/pypi/v/unitx)](https://pypi.org/project/unitx/)
+[![Python versions](https://img.shields.io/pypi/pyversions/unitx)](https://pypi.org/project/unitx/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Write Python formulas with ready-to-use units and physical constants. `unitx`
 handles scalar quantities, unit conversion, and dimensional analysis, with
 exact rational unit scales and exponents.
 
-unitx is in early development. Public APIs may change during the 0.x series.
+`unitx` is in early development. Public APIs may change during the 0.x series.
 
 ## Installation
 
@@ -79,15 +83,17 @@ astronomical units are included. Units and constants can be combined directly:
 
 Both namespaces are read-only and do not need to be instantiated. `si` exposes
 a selection of convenient attributes; other registered prefix combinations
-remain available through `Unit`, for example `Unit('Tm')`. Importing unitx
+remain available through `Unit`, for example `Unit('Tm')`. Importing `unitx`
 initializes the predefined unit catalogue. Defining a custom unit registers its
 text spellings without adding an attribute to `si`.
 
 SI defining constants retain their exact decimal values. Measured constants
 are stored nominal values; measurement uncertainties are not propagated.
 Derived Decimal constants are evaluated in the Decimal context active at
-import. Formulas involving pi use `Decimal(str(math.pi))` as an approximation;
-additional Decimal precision does not add precision to pi.
+import. Pi and the positive roots used by the Wien displacement constants
+(`SI.b` for wavelength and `SI.b_` for frequency) use fixed Decimal
+approximations with about 50 significant digits. Raising the context precision
+does not add accuracy beyond those stored approximations.
 
 ## Constructing units and quantities
 
@@ -245,7 +251,7 @@ meaning rather than acting as string delimiters. Bare compound names are
 not guessed from adjacent words, and ordinary parentheses still group products.
 
 The unit table contains `s`, `m`, `g`, `A`, `K`, `mol`, and `cd`, plus the
-dimensionless identity. Importing unitx also initializes the common units in
+dimensionless identity. Importing `unitx` also initializes the common units in
 `unitx.si`, including named derived units such as `N`. Mass scales are referenced
 to kilograms: `g` has factor `1/1000`, and `kg` has factor `1`.
 
@@ -315,8 +321,9 @@ Bare multiword names are recognized only as complete inputs. For example,
 as a factor; use `[astronomical unit] / arcsec`, symbols, or Unit objects instead.
 
 SI prefixes are enabled by default. `prefixable: PrefixPolicy = True` accepts
-`True` for all spellings, `False` for none, or a tuple of exact symbols, names,
-and aliases supplied in that definition. With a tuple, only the listed
+`True` for all spellings, `False` for none, a single spelling string, or a tuple
+of exact symbols, names, and aliases supplied in that definition. A string such
+as `prefixable='Da'` is equivalent to `prefixable=('Da',)`. Only the selected
 spellings accept prefixes; an empty tuple disables prefixes. Unknown spellings
 and non-string entries are errors. For example,
 `prefixable=('arcsec', 'arcsecond')` enables all SI prefixes on those two
@@ -325,7 +332,7 @@ spellings, while other spellings of that unit remain unprefixable.
 The tuple selects **unit spellings**, not prefix symbols. Prefix names attach
 directly to the first word of a multiword name, as in `kiloastronomical unit`;
 a separate `kilo astronomical unit` is not accepted. `PrefixPolicy` is available
-from `unitx.unitregistry` for annotations and means `bool | tuple[str, ...]`.
+from `unitx.unitregistry` for annotations and means `bool | str | tuple[str, ...]`.
 
 ```pycon
 >>> tick = si.s.define(
@@ -368,10 +375,24 @@ form; `760 * si.mmHg` converts to `si.atm` with value 1 under the library's
 existing pressure convention. Prefixes do not stack: `mmmHg` and `kmmHg` are
 invalid. `kt` retains its meaning as a knot alias; tonne remains unprefixable.
 
-The newly registered `u` denotes the unified atomic mass unit. ASCII micro
-spellings such as `um` still mean micrometres, but now issue `UnitSymbolWarning`
-because `u m` has a separate meaning. Use `µm`, `μm`, or `micrometre` to avoid
-this warning.
+`si.mas` and `si.uas` provide milli- and microarcseconds as namespace shortcuts;
+their registered expressions are `marcsec` and `µarcsec`. The strings `mas`
+and `uas` are not registered aliases. `si.Da` and `si.u` now share one formal
+unit identity; only the spelling `Da` accepts prefixes, such as `kDa`.
+`si.mTorr` is available, and Torr accepts SI prefixes. Tonne uses `t` or
+`tonne`; the ambiguous spelling `ton` is not registered.
+
+`si.rpm` represents rotational frequency: `60 * si.rpm` converts to `si.Hz`
+with value 1. For angular velocity, multiply that frequency by `2 * PI` and
+convert to `si.rad / si.s`; directly converting frequency to `rad/s` does
+not insert the physical factor of 2π. `si.c` is a speed unit equal to the
+speed of light, while `SI.c` is the corresponding physical quantity.
+
+The spelling `u` denotes the unified atomic mass unit when used on its own.
+ASCII micro spellings such as `um` and `us` remain supported without warnings,
+so entering non-ASCII characters is optional. `um`, `µm`, `μm`, and
+`micrometre` all mean micrometres; the explicit product `u m` instead means
+unified atomic mass unit times metre.
 
 Registration raises `UnitRegistryError` if a new spelling, including a generated
 prefixed form, already resolves to a unit or conflicts with another spelling

{unitx-0.7.0 → unitx-0.7.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'hatchling.build'
 
 [project]
 name = 'unitx'
-version = '0.7.0'
+version = '0.7.1'
 description = 'A modern, intuitive Python library for units, quantities, and dimensional analysis.'
 readme = 'README.md'
 requires-python = '>=3.12'

unitx-0.7.1/src/unitx/_constnamespace.py

@@ -0,0 +1,33 @@
+"""Class-based namespaces for constants accessed directly as class attributes.
+
+Namespaces cannot be instantiated, and their attributes cannot be rebound or
+deleted. Objects referenced by those attributes are not recursively frozen.
+"""
+
+from typing import Any, NoReturn
+
+__all__ = ['ConstNamespace']
+
+
+class _ConstNamespaceMeta(type):
+    def __call__(metacls, *args: Any, **kwds: Any) -> NoReturn:
+        """
+        This namespace cannot be instantiated; access constants via class attributes.
+        """
+        raise TypeError(metacls.__call__.__doc__)
+
+    def __setattr__(cls, name, value) -> NoReturn:
+        """
+        Constant namespace attributes cannot be assigned.
+        """
+        raise AttributeError(cls.__class__.__setattr__.__doc__)
+
+    def __delattr__(cls, name) -> NoReturn:
+        """
+        Constant namespace attributes cannot be deleted.
+        """
+        raise AttributeError(cls.__class__.__delattr__.__doc__)
+
+
+class ConstNamespace(metaclass=_ConstNamespaceMeta):
+    """Base for constant namespaces with protected class attribute bindings."""

{unitx-0.7.0 → unitx-0.7.1}/src/unitx/si/bases.py

@@ -2,13 +2,12 @@
 
 from typing import Final
 
-from .._constclass import ConstClass
-from ..factor import ONE
+from .._constnamespace import ConstNamespace
 from ..quantity import Quantity, quantity
 from ..unit import Unit
 
 
-class _si(ConstClass):
+class _si(ConstNamespace):
     # SI base unit
 
     one: Final = Unit()
@@ -34,7 +33,7 @@ class _si(ConstClass):
     """radian, plane angle"""
     sr: Final = one.define('sr', name='steradian')
     """steradian, solid angle"""
-    Hz: Final = (ONE / s).define('Hz', name='hertz')
+    Hz: Final = (s**-1).define('Hz', name='hertz')
     """hertz, frequency"""
     N: Final = (kg * m / s**2).define('N', name='newton')
     """newton, force/weight"""
@@ -64,7 +63,7 @@ class _si(ConstClass):
     """lumen, luminous flux"""
     lx: Final = (lm / m**2).define('lx', name='lux')
     """lux, illuminance"""
-    Bq: Final = (ONE / s).define('Bq', name='becquerel')
+    Bq: Final = (s**-1).define('Bq', name='becquerel')
     """becquerel, activity referred to a radionuclide"""
     Gy: Final = (J / kg).define('Gy', name='gray')
     """gray, absorbed dose"""
@@ -74,9 +73,9 @@ class _si(ConstClass):
     """katal, catalytic activity"""
 
 
-class _SI(ConstClass):
+class _SI(ConstNamespace):
     DeltanuCs: Final = Quantity(9_192_631_770, _si.Hz)
-    """hyperfine transition frequency of Cs-133, definition of second."""
+    """hyperfine transition frequency ∆ν of Cs-133, definition of second."""
     c: Final = Quantity(299_792_458, _si.m / _si.s)
     """speed of light in vacuum"""
     h: Final = quantity(6.626_070_15e-34, _si.J * _si.s)
@@ -89,3 +88,6 @@ class _SI(ConstClass):
     """Avogadro constant"""
     Kcd: Final = Quantity(683, _si.lm / _si.W)
     """luminous efficacy of 540 THz radiation, definition of candela"""
+
+    g: Final = quantity(9.80665, _si.m / _si.s**2)  # defined here for si.kgf
+    """standard acceleration of gravity"""

{unitx-0.7.0 → unitx-0.7.1}/src/unitx/si/constants.py

@@ -1,16 +1,19 @@
-import math
 from decimal import Decimal
 from typing import Final
 
-from .._constclass import ConstClass
+from .._constnamespace import ConstNamespace
 from ..quantity import quantity
 from .bases import _SI
 from .units import si
 
 __all__ = ['SI', 'Particle']
 
-# Match the constants' Decimal magnitudes when using the approximate value of pi.
-_PI = Decimal(str(math.pi))
+_PI = Decimal('3.1415926535897932384626433832795028841971693993751')
+"""the ratio of the circumference of a circle to its diameter"""
+_WIEN_W = Decimal('4.9651142317442763036987591313228939440555849867973')
+"""Approximate positive root of x = 5*(1 - exp(-x))."""
+_WIEN_F = Decimal('2.8214393721220788934031913302944851953458817440731')
+"""Approximate positive root of x = 3*(1 - exp(-x))."""
 
 
 class SI(_SI):
@@ -31,8 +34,6 @@ class SI(_SI):
 
     hbar: Final = _SI.h / (2 * _PI)
     """reduced Planck constant, ħ: Final = h / 2π"""
-    g: Final = quantity(9.80665, 'm/s2')
-    """standard acceleration of gravity"""
     T0: Final = quantity(273.15, si.K)
     """standard temperature"""
 
@@ -40,12 +41,8 @@ class SI(_SI):
 
     G: Final = quantity(6.674_30e-11, 'm3/(kg*s2)')
     """Newtonian constant of gravitation"""
-    # kappa: Final = 8 * _PI * G / c**4  # simplify=True
-    # """Einstein gravitational constant"""
-    # H0: Final = Quantity(70, 'km/s*Mpc')
-    # """Hubble constant, approx"""
-    # Lambda: Final = quantity(1.089e-52, 'm-2')
-    # """cosmological constant, approx"""
+    kappa: Final = (8 * _PI * G / _SI.c**4).to(si.N**-1)
+    """Einstein gravitational constant"""
 
     # electromagnetic constants
 
@@ -104,7 +101,6 @@ class SI(_SI):
     """molar gas constant"""
     F: Final = _SI.NA * _SI.e
     """Faraday constant"""
-
     sigma: Final = (_PI**2 * _SI.kB**4 / (60 * hbar**3 * _SI.c**2)).to('W/(m2*K4)')
     """Stefan-Boltzmann constant"""
     c1L: Final = (2 * _SI.h * _SI.c**2).to('W*m2/sr')
@@ -113,22 +109,18 @@ class SI(_SI):
     """first radiation constant"""
     c2: Final = _SI.h * _SI.c / _SI.kB
     """second radiation constant"""
-    # b: Final = c2 / Math.WEIN_W
-    # """Wien wavelength displacement law constant"""
-    # b_: Final = (Math.WEIN_F * c / c2).to('Hz/K')
-    # """Wien frequency displacement law constant"""
+    b: Final = c2 / _WIEN_W
+    """Wien wavelength displacement law constant"""
+    b_: Final = (_WIEN_F * _SI.c / c2).to('Hz/K')
+    """Wien frequency displacement law constant"""
 
     Vm: Final = (R * T0 / si.bar).to('m3/mol')
     """molar volume of ideal gas (273.15 K, 100 kPa)"""
-    # Vmatm: Final = (R * T0 / si.atm).to(Vm.unit)
-    # """molar volume of ideal gas (273.15 K, 101.325 kPa)"""
     n0: Final = _SI.NA / Vm
     """Loschmidt constant (273.15 K, 100 kPa)"""
-    # n0atm: Final = _SI.NA / Vmatm
-    # """Loschmidt constant (273.15 K, 101.32 kPa)"""
 
 
-class Particle(ConstClass):
+class Particle(ConstNamespace):
     """
     Common particle data, including mass and magnetic moment of
     electron (e), muon (μ), tau (τ), proton (p), neutron (n),

{unitx-0.7.0 → unitx-0.7.1}/src/unitx/si/units.py

@@ -20,7 +20,7 @@ def _prefixed_units(unit: str, prefixes: str | list[str]) -> Iterator[Unit]:
 
 
 class si(_si):
-    """The `si` constclass offers a comprehensive set of common units
+    """The `si` namespace offers a comprehensive set of common units
     such as meters (m), kilograms (kg), and more.
 
     These units can be directly used in formulas or code.
@@ -32,72 +32,67 @@ class si(_si):
 
     # SI base unit
 
-    as_, fs, ps, ns, us, ms = _prefixed_units('s', 'afpnum')
+    ys, zs, as_, fs, ps, ns, us, ms = _prefixed_units('s', 'yzafpnum')
     """second, time"""
-    fm, pm, nm, um, mm, cm, dm, km = _prefixed_units('m', 'fpnumcdk')
+    am, fm, pm, nm, um, mm, cm, dm, km, Mm, Gm = _prefixed_units('m', 'afpnumcdkMG')
     """metre/meter, length"""
-    pg, ng, ug, mg, g = _prefixed_units('g', 'pnum ')
+    fg, pg, ng, ug, mg, g, Mg, Gg = _prefixed_units('g', 'fpnum MG')
     """gram, mass"""
-    pA, nA, uA, mA, kA = _prefixed_units('A', 'pnumk')
+    fA, pA, nA, uA, mA, kA, MA = _prefixed_units('A', 'fpnumkM')
     """ampere, electric current"""
     nK, uK, mK = _prefixed_units('K', 'num')
     """kelvin, thermodynamic temperature"""
-    pmol, nmol, umol, mmol, kmol = _prefixed_units('mol', 'pnumk')
+    fmol, pmol, nmol, umol, mmol, kmol = _prefixed_units('mol', 'fpnumk')
     """mole, amount of substance"""
-    mcd: Final = Unit('mcd')
+    ucd, mcd, kcd = _prefixed_units('cd', 'umk')
     """candela, luminous intensity"""
 
     # SI derived unit
 
-    urad, mrad = _prefixed_units('rad', 'um')
+    nrad, urad, mrad = _prefixed_units('rad', 'num')
     """radian, plane angle"""
-    kHz, MHz, GHz, THz, PHz = _prefixed_units('Hz', 'kMGTP')
+    nHz, uHz, mHz, kHz, MHz, GHz, THz, PHz, EHz = _prefixed_units('Hz', 'numkMGTPE')
     """hertz, frequency"""
-    pN, nN, uN, mN, kN, MN = _prefixed_units('N', 'pnumkM')
+    fN, pN, nN, uN, mN, kN, MN, GN = _prefixed_units('N', 'fpnumkMG')
     """newton, force/weight"""
-    mPa, hPa, kPa, MPa, GPa = _prefixed_units('Pa', 'mhkMG')
+    fPa, nPa, uPa, mPa, hPa, kPa, MPa, GPa, TPa = _prefixed_units('Pa', 'fnumhkMGT')
     """pascal, pressure/stress"""
-    nJ, uJ, mJ, kJ, MJ, GJ = _prefixed_units('J', 'numkMG')
+    fJ, pJ, nJ, uJ, mJ, kJ, MJ, GJ, TJ, PJ = _prefixed_units('J', 'fpnumkMGTP')
     """joule, energy/work/heat"""
-    pW, nW, uW, mW, kW, MW, GW, TW = _prefixed_units('W', 'pnumkMGT')
+    fW, pW, nW, uW, mW, kW, MW, GW, TW, PW = _prefixed_units('W', 'fpnumkMGTP')
     """watt, power/radiant flux"""
-    fC, pC, nC, uC, mC = _prefixed_units('C', 'fpnum')
+    aC, fC, pC, nC, uC, mC, kC = _prefixed_units('C', 'afpnumk')
     """coulomb, electric charge"""
-    nV, uV, mV, kV, MV = _prefixed_units('V', 'numkM')
+    pV, nV, uV, mV, kV, MV, GV = _prefixed_units('V', 'pnumkMG')
     """volt, electric potential/voltage/emf"""
-    fF, pF, nF, uF, mF = _prefixed_units('F', 'fpnum')
+    aF, fF, pF, nF, uF, mF, kF = _prefixed_units('F', 'afpnumk')
     """farad, capacitance"""
-    uohm, mohm, kohm, Mohm, Gohm = _prefixed_units('Ω', 'umkMG')
+    nohm, uohm, mohm, kohm, Mohm, Gohm, Tohm = _prefixed_units('Ω', 'numkMGT')
     """ohm, resistance/impedance/reactance"""
-    uS, mS = _prefixed_units('S', 'um')
+    pS, nS, uS, mS, kS = _prefixed_units('S', 'pnumk')
     """siemens, electrical conductance"""
-    uWb, mWb = _prefixed_units('Wb', 'um')
+    nWb, uWb, mWb, kWb = _prefixed_units('Wb', 'numk')
     """weber, magnetic flux"""
-    nT, uT, mT = _prefixed_units('T', 'num')
+    fT, pT, nT, uT, mT, kT = _prefixed_units('T', 'fpnumk')
     """tesla, magnetic flux density"""
-    nH, uH, mH = _prefixed_units('H', 'num')
+    pH, nH, uH, mH, kH = _prefixed_units('H', 'pnumk')
     """henry, inductance"""
-    kBq, MBq, GBq, TBq = _prefixed_units('Bq', 'kMGT')
+    ulm, mlm, klm, Mlm = _prefixed_units('lm', 'umkM')
+    """lumen, luminous flux"""
+    mlx, klx = _prefixed_units('lx', 'mk')
+    """lux, illuminance"""
+    mBq, kBq, MBq, GBq, TBq, PBq = _prefixed_units('Bq', 'mkMGTP')
     """becquerel, activity referred to a radionuclide"""
-    uGy, mGy = _prefixed_units('Gy', 'um')
+    nGy, uGy, mGy, kGy, MGy = _prefixed_units('Gy', 'numkM')
     """gray, absorbed dose"""
-    nSv, uSv, mSv = _prefixed_units('Sv', 'num')
+    pSv, nSv, uSv, mSv, kSv = _prefixed_units('Sv', 'pnumk')
     """sievert, equivalent dose"""
+    nkat, ukat, mkat = _prefixed_units('kat', 'num')
+    """katal, catalytic activity"""
 
-    # non-SI units accepted for use with SI
+    # other common units
 
-    min: Final = (60 * _si.s).define('min', name='minute', prefixable=False)
-    """minute, 1 min = 60 s, time"""
-    h: Final = (60 * min).define('h', name='hour', prefixable=False)
-    """hour, 1 h = 60 min, time"""
-    d: Final = (24 * h).define('d', name='day', prefixable=False)
-    """day, 1 d = 24 h, time"""
-    yr: Final = (365 * d).define('yr', name='year', prefixable=False)
-    """simple year, 1 yr = 365 d, time"""
-    a_j: Final = (365.25 * d).define('a_j', name='Julian year')
-    """Julian year, 1 a_j = 365.25 d, time"""
-    mo: Final = (a_j / 12).define('mo', name='month', prefixable=False)
-    """month, 1 mo = 1/12 a_j, time"""
+    # dimensionless
     deg: Final = (PI / 180 * _si.rad).define(
         '°', name='degree', symbol_aliases='deg', prefixable=False
     )
@@ -113,66 +108,126 @@ class si(_si):
         prefixable=('arcsec', 'arcsecond'),
     )
     """arcsecond, plane angle"""
+    mas, uas = _prefixed_units('arcsec', 'mu')
+    """arcsecond, plane angle"""
+    percent: Final = (_si.one / 100).define(
+        '%', name='percent', symbol_aliases='٪', prefixable=False
+    )
+    """percent, 1/100, dimensionless"""
+    permille: Final = (_si.one / 1000).define('‰', name='permille', prefixable=False)
+    """permille, 1/1000, dimensionless"""
+    permyriad: Final = (_si.one / 10000).define(
+        '‱', 'permyriad', 'per ten thousand', prefixable=False
+    )
+    """permyriad, 1/10000, dimensionless"""
+    # time/frequency related
+    min: Final = (60 * _si.s).define('min', name='minute', prefixable=False)
+    """minute, 1 min = 60 s, time"""
+    h: Final = (60 * min).define('h', name='hour', prefixable=False)
+    """hour, 1 h = 60 min, time"""
+    d: Final = (24 * h).define('d', name='day', prefixable=False)
+    """day, 1 d = 24 h, time"""
+    yr: Final = (365 * d).define('yr', name='year', prefixable=False)
+    """simple year, 1 yr = 365 d, time"""
+    a_j: Final = (365.25 * d).define('a_j', 'Julian year', 'annum')
+    """Julian year, 1 a_j = 365.25 d, time"""
+    mo: Final = (a_j / 12).define('mo', name='month', prefixable=False)
+    """month, 1 mo = 1/12 a_j, time"""
+    rpm: Final = (1 / min).define('rpm', name='revolutions per minute', prefixable=False)
+    """revoltions per minute, 60 rpm = 1 Hz, rotational speed"""
+    # length/area/volume related
+    au: Final = (149_597_870_700 * _si.m).define(
+        'au', name='astronomical unit', symbol_aliases='AU'
+    )
+    """astronomical unit, length"""
+    pc: Final = (au / arcsec).define('pc', name='parsec')
+    """parsec, length"""
+    kpc, Mpc, Gpc, Tpc = _prefixed_units('pc', 'kMGT')
+    """parsec, length"""
+    ly: Final = (_SI.c * a_j).define('ly', name='light year', prefixable=False)
+    """light year, length"""
+    nmile: Final = (1852 * _si.m).define('nmi', 'nautical mile', symbol_aliases='NM')
+    """nautical mile, length in marine and aerial navigation"""
+    angstrom: Final = (_si.m / TEN**10).define(
+        'Å', 'ångström', 'angstrom', symbol_aliases=('Å', 'Å')
+    )  # symbol: chr(0xC5), chr(0x212B), 'A'+chr(0x30A)
+    """ångström, 1 Å = 10⁻¹⁰ m,
+    lengths of chemical bonds, sizes of atoms and molecules, and wavelengths.
+    """
     a: Final = (100 * _si.m**2).define('a', name='are', prefixable=False)
     """are, 1 a = 100 m², land area"""
     ha: Final = (100 * a).define('ha', name='hectare', prefixable=False)
     """hectare, 1 ha = 100 a = 10000 m², land area"""
     b: Final = (_si.m**2 / TEN**28).define('b', name='barn')
     """barn, 1 b = 10⁻²⁸ m², effective cross sections."""
-    L: Final = (dm**3).define('L', 'liter', 'litre', symbol_aliases='l')
-    """liter/litre, 1 L = 1 dm³, volume"""
-    nL, uL, mL, cL, dL = _prefixed_units('L', 'numcd')
-    """liter/litre, 1 L = 1 dm³, volume"""
+    L: Final = (dm**3).define('L', 'litre', 'liter', symbol_aliases='l')
+    """litre/liter, 1 L = 1 dm³, volume"""
+    fL, pL, nL, uL, mL, cL, dL, kL, ML = _prefixed_units('L', 'fpnumcdkM')
+    """litre/liter, 1 L = 1 dm³, volume"""
+    # mass related
     t: Final = (1000 * _si.kg).define('t', name='tonne', prefixable=False)
     """tonne, 1 t = 1000 kg, mass"""
-    # symbol aliases: chr(0xC5), chr(0x212B), 'A'+chr(0x30A)
-    angstrom: Final = (_si.m / TEN**10).define(
-        'Å', 'ångström', 'angstrom', symbol_aliases=('Å', 'Å')
+    Da: Final = (Decimal('1.660_539_068_92e-27') * _si.kg).define(
+        'Da', 'dalton', 'unified atomic mass unit', symbol_aliases='u', prefixable='Da'
     )
-    """ångström, 1 Å = 10⁻¹⁰ m,
-    lengths of chemical bonds, sizes of atoms and molecules, and wavelengths.
-    """
-    Gal: Final = (cm / _si.s**2).define('Gal', name='gal')
-    """gal, acceleration"""
-    bar: Final = (TEN**5 * _si.Pa).define('bar', name='bar')
-    """bar, standard-state pressure"""
-    mbar: Final = Unit('mbar')
-    """millibar, standard-state pressure"""
-    Da: Final = (Decimal('1.660_539_068_92e-27') * _si.kg).define('Da', name='dalton')
     """dalton, unified atomic mass unit, 1 Da = m(¹²C) / 12, mass"""
-    u: Final = Da.define('u', name='unified atomic mass unit', prefixable=False)
+    kDa, MDa = _prefixed_units('Da', 'kM')
+    """dalton, unified atomic mass unit, 1 Da = m(¹²C) / 12, mass"""
+    u: Final = Unit('u')
     """unified atomic mass unit, 1 u = m(¹²C) / 12, mass"""
-    au: Final = (149_597_870_700 * _si.m).define('au', name='astronomical unit')
-    """astronomical unit, length"""
-    pc: Final = (au / arcsec).define('pc', name='parsec')
-    """parsec, length"""
-    ly: Final = (_SI.c * a_j).define('ly', name='light year', prefixable=False)
-    """light year, length"""
-    nmile: Final = (1852 * _si.m).define('nmi', 'nautical mile', symbol_aliases='NM')
-    """nautical mile, length in marine and aerial navigation"""
+    # kinetic related
+    c: Final = _SI.c.define('c', name='speed of light', prefixable=False)
+    """speed of light in vacuum, 299_792_458 m/s"""
+    Gal: Final = (cm / _si.s**2).define('Gal', 'gal', 'galileo')
+    """gal, acceleration"""
     knot: Final = (nmile / h).define('kn', 'knot', symbol_aliases='kt')
     """knot, speed in marine and aerial navigation"""
+    # dynamic related
+    gf: Final = (_SI.g * g).define('gf', 'gram-force', 'gram force')
+    """gram-force, 1 gf = 1 g * 9.80665 m/s², force"""
+    kgf: Final = Unit('kgf')
+    """kilogram-force, 1 kgf = 1 kg * 9.80665 m/s², force"""
+    bar: Final = (TEN**5 * _si.Pa).define('bar', name='bar')
+    """bar, standard-state pressure"""
+    ubar, mbar = _prefixed_units('bar', 'um')
+    """bar, standard-state pressure"""
     atm: Final = (101_325 * _si.Pa).define('atm', name='atmosphere')
     """standard atmosphere"""
     mHg: Final = (1000 * (atm / 760)).define('mHg', name='metre of mercury')
     """metre of mercury, 0.760 mHg = 1 atm, pressure"""
     mmHg: Final = Unit('mmHg')
     """millimetre of mercury, 760 mmHg = 1 atm, pressure"""
-    Torr: Final = mmHg.define('Torr', 'torr', 'torricelli', prefixable=False)
+    Torr: Final = mmHg.define('Torr', 'torr', 'torricelli')
     """torr, 760 Torr = 1 atm, pressure"""
+    mTorr: Final = Unit('mTorr')
+    """millitorr, pressure"""
     Wh: Final = (_si.W * h).define('Wh', name='watthour')
     """watthour, energy"""
-    mWh, kWh, MWh, GWh, TWh = _prefixed_units('Wh', 'mkMGT')
+    uWh, mWh, kWh, MWh, GWh, TWh, PWh = _prefixed_units('Wh', 'umkMGTP')
     """watthour, energy"""
     eV: Final = (_SI.e * _si.V).define('eV', name='electronvolt')
     """electron volt, energy"""
-    meV, keV, MeV, GeV, TeV, PeV = _prefixed_units('eV', 'mkMGTP')
+    ueV, meV, keV, MeV, GeV, TeV, PeV, EeV = _prefixed_units('eV', 'umkMGTPE')
     """electron volt, energy"""
-    cal: Final = (Decimal('4.184') * _si.J).define('cal', name='calorie')
+    cal: Final = (4184 * mJ).define('cal', name='calorie')
     """calorie, energy"""
     kcal: Final = Unit('kcal')
     """kilocalorie, energy"""
-    var: Final = (_si.V * _si.A).define('var', name='volt-ampere reactive')
+    VA: Final = (_si.V * _si.A).define('VA', name='volt-ampere')
+    """volt-ampere, apparent power"""
+    kVA, MVA = _prefixed_units('VA', 'kM')
+    """volt-ampere, apparent power"""
+    var: Final = (_si.V * _si.A).define('var', name='volt-ampere reactive', symbol_aliases='VAr')
+    """volt-ampere reactive, reactive power"""
+    kvar, Mvar = _prefixed_units('var', 'kM')
     """volt-ampere reactive, reactive power"""
-    kvar: Final = Unit('kvar')
-    """kilovolt-ampere reactive, reactive power"""
+    # electromagnetic related
+    Ah: Final = (_si.A * h).define('Ah', name='ampere-hour')
+    """ampere-hour, electric charge"""
+    mAh, kAh, MAh = _prefixed_units('Ah', 'mkM')
+    """ampere-hour, electric charge"""
+    mho: Final = _si.S.define('mho', name='mho', symbol_aliases='℧')
+    """mho, electrical conductance"""
+    # others
+    nt: Final = (_si.cd / _si.m**2).define('nt', name='nit')
+    """nit, luminance"""

{unitx-0.7.0 → unitx-0.7.1}/src/unitx/unit.py

@@ -285,10 +285,11 @@ class Unit:
         All new texts, including prefixed forms, must be unambiguous and must
         not already resolve to registered units or implicit unit products.
         Complex names work standalone or in ``[name]`` references in expressions.
-        ``prefixable`` accepts True for all spellings, False for none, or a
-        tuple of exact symbols, names, or aliases from this definition, such as
+        ``prefixable`` accepts True for all spellings, False for none, a single
+        spelling string, or a tuple of exact symbols, names, or aliases, such as
         ``('arcsec', 'arcsecond')``. Only listed spellings accept prefixes;
-        an empty tuple disables all prefixes. Unknown spellings are errors.
+        ``'arcsec'`` is equivalent to ``('arcsec',)``. An empty tuple disables
+        all prefixes. Unknown or empty spellings are errors.
         Invalid definitions raise TypeError, ValueError, or UnitRegistryError
         before changing the registry.
         """

{unitx-0.7.0 → unitx-0.7.1}/src/unitx/unitregistry.py

@@ -22,11 +22,11 @@ from .factor import ONE, TEN, Factor
 
 __all__ = ['PrefixPolicy']
 
-type PrefixPolicy = bool | tuple[str, ...]
+type PrefixPolicy = bool | str | tuple[str, ...]
 
 _UNIT_SYMBOL_PATTERN = r'[^\s\d' + re.escape('*^()/+-[]' + SUPERSCRIPTS) + ']+'
 _UNIT_SYMBOL_RE = re.compile(_UNIT_SYMBOL_PATTERN)
-_UNIT_NAME_RE = re.compile(_UNIT_SYMBOL_PATTERN + '(?:[ -]' + _UNIT_SYMBOL_PATTERN + ')*')
+_UNIT_NAME_RE = re.compile(f'{_UNIT_SYMBOL_PATTERN}(?:[ -]{_UNIT_SYMBOL_PATTERN})*')
 _PREFIXED_NAME_EXCEPTIONS = {('M', 'ohm'): 'megohm', ('k', 'ohm'): 'kilohm'}
 
 
@@ -113,7 +113,7 @@ class UnitDefinition:
         self.factor = factor
         self.names = (name, *name_aliases)
         self.dimension = dimension
-        self.prefixable = prefixable
+        self.prefixable = (prefixable,) if isinstance(prefixable, str) else prefixable
         self.symbols: tuple[str, ...] = ()
 
     def allows_prefix(self, spelling: str) -> bool:
@@ -229,7 +229,7 @@ def _preferred_unit_spelling(
 def _register_unit(symbol: str, definition: UnitDefinition, /, *symbol_aliases: str) -> None:
     """Validate every binding and generated spelling before updating indexes."""
     if not isinstance(definition.prefixable, (bool, tuple)):
-        raise TypeError('Prefixable must be bool or tuple of spellings.')
+        raise TypeError('Prefixable must be bool, str or tuple of spellings.')
     for kind, texts in (
         ('symbol', (symbol,)),
         ('name', (definition.name,)),

{unitx-0.7.0 → unitx-0.7.1}/tests/test_si.py

@@ -1,8 +1,11 @@
 """Public SI namespaces, conversions, and constant values."""
 
+import copy
 import os
+import pickle
 import subprocess
 import sys
+import warnings
 from decimal import Decimal, localcontext
 from fractions import Fraction
 from pathlib import Path
@@ -79,6 +82,18 @@ def test_si_coherent_units(attribute: str, expression: str) -> None:
         ('Wh', 'J', 3600),
         ('eV', 'J', Decimal('1.602176634e-19')),
         ('cal', 'J', Decimal('4.184')),
+        ('percent', '', Fraction(1, 100)),
+        ('permille', '', Fraction(1, 1000)),
+        ('permyriad', '', Fraction(1, 10000)),
+        ('rpm', 'Hz', Fraction(1, 60)),
+        ('c', 'm/s', 299792458),
+        ('gf', 'N', Decimal('0.00980665')),
+        ('kgf', 'N', Decimal('9.80665')),
+        ('Ah', 'C', 3600),
+        ('VA', 'W', 1),
+        ('mho', 'S', 1),
+        ('nt', 'cd/m2', 1),
+        ('mTorr', 'Pa', Fraction(4053, 30400)),
     ],
 )
 def test_si_unit_conversions(attribute: str, target: str, value: int | Fraction | Decimal) -> None:
@@ -151,6 +166,20 @@ def test_si_hbar_value() -> None:
     assert float(SI.hbar.value) == pytest.approx(1.0545718176461565e-34, rel=1e-15, abs=0)
 
 
+@pytest.mark.parametrize(
+    ('attribute', 'target', 'value'),
+    [
+        ('kappa', '1/N', 2.076647442844972e-43),
+        ('b', 'm*K', 2.8977719551851727e-3),
+        ('b_', 'Hz/K', 5.878925757646825e10),
+    ],
+)
+def test_si_derived_constants(attribute: str, target: str, value: float) -> None:
+    constant = getattr(SI, attribute)
+    assert constant.unit.dimension == Unit(target).dimension
+    assert float(constant.value_in(target)) == pytest.approx(value, rel=1e-14, abs=0)
+
+
 @pytest.mark.parametrize(
     ('attribute', 'target'),
     [('Phi0', si.Wb), ('G0', si.S), ('RK', si.ohm), ('a0', si.m), ('lambdaC', si.m), ('Eh', si.J)],
@@ -247,7 +276,8 @@ def test_si_mercury_prefixes() -> None:
     assert Unit('kt') == si.knot
     for unit in (si.mHg, si.mmHg, si.Torr):
         assert Unit(unit.expression()) == unit
-    for text in ('mmmHg', 'kmmHg', 'millimillimetre of mercury', 'kTorr'):
+    assert Quantity(1, 'kTorr').to(si.Torr).value == 1000
+    for text in ('mmmHg', 'kmmHg', 'millimillimetre of mercury'):
         with pytest.raises(UnitSymbolError):
             Unit(text)
 
@@ -257,6 +287,37 @@ def test_si_light_year() -> None:
     assert 1 * si.eV == SI.e * si.V
 
 
+def test_si_dalton_aliases() -> None:
+    assert si.u == si.Da == Unit('unified atomic mass unit')
+    assert hash(si.u) == hash(si.Da)
+    assert {si.Da: 'found'}[si.u] == 'found'
+    assert Quantity(1, si.kDa).to(si.Da).value == 1000
+    for text in ('mu', 'kilodalton', 'kilounified atomic mass unit', 'ton'):
+        with pytest.raises(UnitSymbolError):
+            Unit(text)
+
+
+def test_si_ascii_micro() -> None:
+    with warnings.catch_warnings(record=True) as recorded:
+        warnings.simplefilter('always')
+        assert Unit('um') == si.um
+        assert Unit('us') == si.us
+        assert Unit('u m') == si.u * si.m
+        assert Unit('u m') != Unit('um')
+    assert not recorded
+
+
+@pytest.mark.parametrize('attribute', ['mas', 'uas', 'u', 'Da', 'mTorr', 'c', 'gf', 'VA', 'Ah'])
+def test_si_unit_roundtrip(attribute: str) -> None:
+    unit = getattr(si, attribute)
+    assert Unit(unit.expression()) == unit
+    assert eval(repr(unit), {'Unit': Unit}) == unit
+    assert copy.copy(unit) == copy.deepcopy(unit) == unit
+    restored = pickle.loads(pickle.dumps(unit))
+    assert restored == unit
+    assert hash(restored) == hash(unit)
+
+
 @pytest.mark.parametrize('name', ['volt-ampere reactive', 'kilovolt-ampere reactive'])
 def test_si_reactive_power_name(name: str) -> None:
     assert Unit('[' + name + '] / s') == Unit(name) / si.s

{unitx-0.7.0 → unitx-0.7.1}/tests/test_singleunit.py

@@ -53,6 +53,9 @@ def test_single_unit_combinations() -> None:
                 ('M', 'Ω'): 'megohm',
                 ('k', 'Ω'): 'kilohm',
             }.get((prefix, symbol), prefix_definition.name + unit_definition.name)
+            if prefix and not unit_definition.allows_prefix(unit_definition.name):
+                # Da permits prefixed symbols but no prefixed names.
+                expected_name = unit.symbol
             assert unit.name == expected_name
             assert SingleUnit(unit.name) == unit
             assert unit.dimension == unit_definition.dimension
@@ -96,7 +99,6 @@ def test_single_unit_name_alias(prefix: str) -> None:
         ('KK', 'kK', 'kilokelvin', Dimension(Theta=1), 1000),
         ('Kmol', 'kmol', 'kilomole', Dimension(N=1), 1000),
         ('Kcd', 'kcd', 'kilocandela', Dimension(J=1), 1000),
-        ('um', 'µm', 'micrometre', Dimension(L=1), Fraction(1, 10**6)),
     ],
 )
 def test_single_unit_symbol_warning(
@@ -120,7 +122,9 @@ def test_single_unit_symbol_warning(
     assert type(unit.factor.value) is type(factor)
 
 
-@pytest.mark.parametrize('text', ['', 'K', 'kelvin', 'kK', 'km', 'ms', 'Ms', 'µm', 'μm'])
+@pytest.mark.parametrize(
+    'text', ['', 'K', 'kelvin', 'kK', 'km', 'ms', 'Ms', 'um', 'us', 'µm', 'μm']
+)
 def test_single_unit_no_warning(text: str) -> None:
     with warnings.catch_warnings(record=True) as recorded:
         warnings.simplefilter('always')

{unitx-0.7.0 → unitx-0.7.1}/tests/test_unitregistry.py

@@ -116,9 +116,30 @@ def test_unit_define_duplicate_spellings() -> None:
         Unit('millireview policy')
 
 
-@pytest.mark.parametrize('policy', [None, [], ['rvpolicy'], {}, {'rvpolicy': True}, 'rvpolicy', 1])
+@pytest.mark.parametrize('source', [Unit('m'), PI * Unit('m'), Quantity(Fraction(3, 7), 'm')])
+@pytest.mark.parametrize('spelling', ['rvselect', 'rvselected', 'review selected', 'review alias'])
+def test_unit_define_string_policy(source, spelling: str) -> None:
+    unit = source.define(
+        'rvselect',
+        'review selected',
+        'review alias',
+        symbol_aliases='rvselected',
+        prefixable=spelling,
+    )
+    for text in ('rvselect', 'rvselected', 'review selected', 'review alias'):
+        assert Unit(text) == unit
+        prefixed = ('kilo' if ' ' in text else 'k') + text
+        if text == spelling:
+            assert Unit(prefixed).factor == 1000 * unit.factor
+            assert Unit(Unit(prefixed).expression()) == Unit(prefixed)
+        else:
+            with pytest.raises(UnitSymbolError):
+                Unit(prefixed)
+
+
+@pytest.mark.parametrize('policy', [None, [], ['rvpolicy'], {}, {'rvpolicy': True}, 1])
 def test_unit_define_invalid_policy(policy, unit_registry) -> None:
-    with pytest.raises(TypeError, match='Prefixable must be bool or tuple of spellings'):
+    with pytest.raises(TypeError, match='Prefixable must be bool, str or tuple of spellings'):
         Unit('m').define('rvpolicy', 'review policy', prefixable=policy)
     assert (UNIT_DEFINITIONS, UNIT_NAME_TO_SYMBOL, UNIT_SYMBOL_ALIAS_TO_SYMBOL) == unit_registry
 
@@ -131,9 +152,12 @@ def test_unit_define_invalid_policy_type(text, unit_registry) -> None:
 
 
 @pytest.mark.parametrize('text', ['unknown', '', 'mrvpolicy', 'm', 'µ'])
-def test_unit_define_invalid_policy_spelling(text: str, unit_registry) -> None:
+@pytest.mark.parametrize('as_tuple', [False, True])
+def test_unit_define_invalid_policy_spelling(text: str, as_tuple: bool, unit_registry) -> None:
     with pytest.raises(ValueError, match='is not a registered spelling'):
-        Unit('m').define('rvpolicy', 'review policy', prefixable=('rvpolicy', text))
+        Unit('m').define(
+            'rvpolicy', 'review policy', prefixable=('rvpolicy', text) if as_tuple else text
+        )
     assert (UNIT_DEFINITIONS, UNIT_NAME_TO_SYMBOL, UNIT_SYMBOL_ALIAS_TO_SYMBOL) == unit_registry
 
 

{unitx-0.7.0 → unitx-0.7.1}/tests/typing/check_quantity.py

@@ -124,6 +124,12 @@ def test_unit_numeric_scaling(unit: Unit, scaled: ScaledUnit) -> None:
 def test_unit_define() -> None:
     policy: PrefixPolicy = ('rvpolicy',)
     assert_type(Unit('m').define('rvpolicy', 'review policy', prefixable=policy), Unit)
+    single_policy: PrefixPolicy = 'rvpolicy'
+    assert_type(Unit('m').define('rvpolicy', 'review policy', prefixable=single_policy), Unit)
+    assert_type((PI * Unit('m')).define('rvpolicy', 'review policy', prefixable='rvpolicy'), Unit)
+    assert_type(
+        Quantity(2, 'm').define('rvpolicy', 'review policy', prefixable='review policy'), Unit
+    )
     assert_type(
         Unit('m').define(
             'rvbound',

{unitx-0.7.0 → unitx-0.7.1}/tests/typing/check_si.py

@@ -3,7 +3,7 @@
 from decimal import Decimal
 from typing import assert_type
 
-from unitx.quantity import Quantity
+from unitx.quantity import Magnitude, Quantity
 from unitx.si import SI, si
 from unitx.unit import Unit
 
@@ -16,6 +16,10 @@ def test_si_unit_types() -> None:
     assert_type(si.mHg, Unit)
     assert_type(si.mmHg, Unit)
     assert_type(si.cd, Unit)
+    assert_type(si.mas, Unit)
+    assert_type(si.kDa, Unit)
+    assert_type(si.c, Unit)
+    assert_type(si.kgf, Unit)
     assert_type(2 * si.m, Quantity[int])
     assert_type(Decimal('0.5') * si.s, Quantity[Decimal])
 
@@ -24,5 +28,9 @@ def test_si_constant_types() -> None:
     assert_type(SI.c, Quantity[int])
     assert_type(SI.h, Quantity[Decimal])
     assert_type(SI.hbar, Quantity[Decimal])
+    # Integer powers currently have a conservative numeric return type.
+    assert_type(SI.kappa, Quantity[Magnitude])
+    assert_type(SI.b, Quantity[Decimal])
+    assert_type(SI.b_, Quantity[Decimal])
     assert_type(SI.e, Quantity[Decimal])
     assert_type(SI.h.to(si.J * si.s), Quantity[Decimal])

unitx-0.7.0/src/unitx/_constclass.py

@@ -1,34 +0,0 @@
-"""
-ConstClass is a class storing static constants.
-It's similar to Enum, but members of Enum need an extra value attribute `value`
-to access its value, and I think it's unnecessary, so I use ConstClass.
-"""
-
-from typing import Any, NoReturn
-
-__all__ = ['ConstMeta', 'ConstClass']
-
-
-class ConstMeta(type):
-    def __call__(metacls, *args: Any, **kwds: Any) -> NoReturn:
-        """
-        No, this class restores constants, you can NOT instantiate objects.
-        please access constants via class attributes.
-        """
-        raise TypeError(metacls.__call__.__doc__)
-
-    def __setattr__(cls, name, value) -> NoReturn:
-        """
-        No, this class restores constants, you can NOT modify them.
-        """
-        raise AttributeError(cls.__class__.__setattr__.__doc__)
-
-    def __delattr__(cls, name) -> NoReturn:
-        """
-        No, this class restores constants, you can NOT delete them.
-        """
-        raise AttributeError(cls.__class__.__delattr__.__doc__)
-
-
-class ConstClass(metaclass=ConstMeta):
-    pass