unitx 0.6.3__tar.gz → 0.7.0__tar.gz

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

@@ -1,5 +1,69 @@
 # Changelog
 
+## [0.7.0] - 2026-10-19
+
+### Added
+
+- Add `[registered name]` references as single factors in unit expressions,
+  including products, reciprocals, parentheses, and rational powers. References
+  resolve names and name aliases only, with whitespace normalization and no
+  expression evaluation or nested quoting.
+- Support standalone hyphenated names and adjacent Unicode integer superscripts
+  such as `m²`, `s⁻¹²`, and `[metre]²`.
+- Extend `prefixable: PrefixPolicy = True` on all `.define()` entry points to
+  accept a tuple of exact registered symbols, names, or aliases. Only those
+  spellings accept prefixes; True enables all spellings and False or () disables
+  all spellings. `PrefixPolicy` is `bool | tuple[str, ...]`.
+- Enable prefixes on `arcsec` and `arcsecond` while keeping angle punctuation
+  unprefixable. Register unprefixable are (`a`) and hectare (`ha`), and reactive
+  power (`var`, name `volt-ampere reactive`). Keep `as` as attosecond and `yr`
+  as a 365-day year.
+- Add the Julian year `a_j` (exactly 31,557,600 seconds) and its twelfth,
+  `mo`, as a fixed month interval distinct from variable calendar months.
+- Add light year (`ly`), unified atomic mass unit (`u`), and common prefixed
+  namespace attributes, including attosecond (`as_`) and petaelectronvolt (`PeV`).
+
+### Changed
+
+- Move definitions, spelling resolution, and registration validation into
+  `unitx.unitregistry`, shared by SingleUnit and UnitParser. Preserve formal identities,
+  exact SI factors, existing `.define()` defaults, and validation before mutation.
+- Remove the superseded private `_unit_data` module. Name definition records
+  `PrefixDefinition` and `UnitDefinition`, with explicit definition indexes and
+  alias-to-symbol mappings.
+- Select permitted canonical output spellings after applying binding policies.
+  When only a name permits a prefix, expressions use `[name]` so repr and pickle
+  preserve the prefixed identity. Expose `PrefixPolicy` for type annotations.
+- Use the finite spelling exceptions `megohm` and `kilohm` in preferred names,
+  retaining `megaohm` and `kiloohm` as accepted inputs.
+- Reuse Unicode superscript tables, handle malformed name brackets through
+  the common lexical error path, and simplify definition initialization,
+  preferred spelling selection, and generated prefix-name validation.
+- Share coherent SI units and the seven defining constants through private
+  bases. Derive `ly` from `c` and the Julian year, and `eV` from `e` and `V`,
+  preserving the public `si` and `SI` namespaces and constant magnitude types.
+
+### Fixed
+
+- Register metre of mercury (`mHg`) as the prefixable unit and construct `mmHg`
+  from its milli prefix. Preserve `760 mmHg = 1 atm` and the existing Torr scale,
+  keep the definition exact, and reject stacked prefixes such as `kmmHg`.
+
+### Migration
+
+- Square brackets and `⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻` are now reserved grammar characters and can
+  no longer occur in registered symbols or names. Rename custom spellings that
+  previously used them before rebuilding or unpickling those definitions.
+- Long names remain whole-input lookups unless explicitly referenced in brackets.
+  `str()` remains readable display and is not a general serialization format;
+  use `expression()` for formal unit products and repr for ScaledUnit state.
+- `mmHg` now has the formal identity of milli-prefixed `mHg`; rebuild stored
+  units when moving between versions. Its pressure conversion scale is unchanged.
+  `kmmHg` and names with repeated prefixes are no longer accepted.
+- Registering `u` makes ASCII micro spellings such as `um` issue the existing
+  ambiguity warning. Their meaning is unchanged; use `µm`, `μm`, or `micrometre`
+  to avoid the warning. `kt` remains a knot alias and tonne stays unprefixable.
+
 ## [0.6.3] - 2026-10-18
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unitx
-Version: 0.6.3
+Version: 0.7.0
 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
@@ -246,14 +246,25 @@ False
   token: `ms` is a millisecond, while `m s` is metre times second.
 - Powers can use adjacent numbers, `^`, or `**`. Exponents written as ratios
   require parentheses, as in `m^(1/2)`; decimal exponents such as `m^0.5` are exact.
+  Adjacent integer superscripts are also accepted: `m²`, `s⁻¹²`, and `(m/s)²`.
+  Superscript fractions and mixed exponent notations are not supported.
 - Multiplication and division associate left to right. Use `m/(s A)` to put
   both `s` and `A` in the denominator; `m/s A` means `(m/s)*A`.
 - Unit symbols and names are case-sensitive. `u`, `µ`, and `μ` are accepted
   micro prefixes. Use lowercase `k` for kilo; `K` denotes kelvin.
-- A registered multiword name is recognized before implicit multiplication
+- A registered multiword or hyphenated name is recognized before implicit multiplication
   when it occupies the entire input. Whitespace between its words is treated
-  as a single space. Inside products, parentheses, reciprocals, and powers,
-  use its symbol or combine `Unit` objects instead.
+  as a single space. Inside expressions, use `[name]` to make a name one factor,
+  for example `[astronomical unit] / s` or `[volt-ampere reactive]**2`.
+  Symbols and `Unit` object composition remain available.
+
+Square brackets reference registered names and name aliases only: `[metre]`
+works, while `[m]` and `[m/s]` do not. The contents are never evaluated as an
+expression. Empty, nested, and unmatched brackets are errors. Put permitted
+name prefixes inside the brackets, as in `[kiloastronomical unit]`; `k[name]`
+does not apply a prefix. Single and double quotes retain their angle-unit
+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
@@ -303,9 +314,10 @@ aliases gives an empty tuple. `symbol_aliases` accepts a string or tuple of
 strings; it and `prefixable` must be passed by keyword.
 Symbols and symbol aliases must each be a single printable unit token.
 Names and name aliases may contain multiple such tokens separated by single
-ASCII spaces, without leading or trailing spaces. Decimal digits and parser
-operators are not allowed in any token. The primary symbol and `name` are
-required and must be nonempty; empty aliases are ignored.
+ASCII spaces or hyphens, without leading or trailing separators. Decimal digits
+and parser operators are not allowed in any token. The primary symbol and `name` are
+required and must be nonempty; empty aliases are ignored. Square brackets and
+the superscript characters `⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻` are reserved for parser syntax.
 
 ```pycon
 >>> span = (2 * si.m).define('span', 'survey span', 'survey distance')
@@ -315,22 +327,86 @@ True
 True
 >>> Unit('survey span') / si.s == Unit('span / s')
 True
+>>> Unit('[survey span] / [second]') == Unit('span / s')
+True
 
 ```
 
-Multiword names are recognized only as complete inputs. For example,
+Bare multiword names are recognized only as complete inputs. For example,
 `Unit('astronomical unit / arcsec')` does not recognize `astronomical unit`
-as a factor; use one of the two compound forms above instead.
+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
+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
+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, ...]`.
+
+```pycon
+>>> tick = si.s.define(
+...     'demoTick',
+...     'survey interval',
+...     symbol_aliases='demoT',
+...     prefixable=('demoT', 'survey interval'),
+... )
+>>> Unit('[millisurvey interval]') == Unit('mdemoT')
+True
+>>> Quantity(1000, 'mdemoT').to(tick).value
+Fraction(1, 1)
+>>> Unit('mdemoT').expression()
+'mdemoT'
+
+```
+
+Prefix permissions are checked before alias normalization. Canonical identity
+still uses the original registered unit and canonical prefix, independent of
+the input alias. Preferred spellings use the first permitted symbol or alias;
+if only a name supports a prefix, `SingleUnit.symbol` falls back to that name
+and `Unit.expression()` emits a `[name]` reference. Conversely, `SingleUnit.name`
+falls back to a symbol if no name allows that prefix. Repr and pickle preserve
+the same formal unit, rather than replacing the prefix with an extra scale.
+
+`arcsec` and `arcsecond` accept prefixes, for example `marcsec` and
+`milliarcsecond`; `″` and `"` do not. `as` continues to mean attosecond,
+and `mas` is not an arcsecond alias. `a` (are) and `ha` (hectare) are separate
+unprefixable units; `Pa` remains pascal. `yr` remains exactly 365 days.
+`a_j` is the Julian year of exactly 365.25 days (31,557,600 seconds), while
+`mo` is one twelfth of that interval, rather than a variable calendar month.
+The name exceptions `megohm` and `kilohm` are supported alongside the older
+`megaohm` and `kiloohm` spellings; `gigaohm` retains both vowels. No general
+vowel-elision rule is applied.
+
+`ly` is defined using the speed of light and the Julian year; `eV` uses the
+elementary charge and volt. Both reuse the defining constants exposed by `SI`.
+`mHg` is the registered metre-of-mercury unit and `mmHg` is its milli-prefixed
+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 prefixes are enabled by default; set `prefixable=False` to disable them.
-Prefix names attach directly to the first word of a multiword name, as in
-`kiloastronomical unit`; a separate `kilo astronomical unit` is not accepted.
 Registration raises `UnitRegistryError` if a new spelling, including a generated
 prefixed form, already resolves to a unit or conflicts with another spelling
 in the same definition. A multiword spelling must not replace an existing
 implicit product such as `metre second`. Validation finishes before the
 registry changes.
 
+The registry and spelling rules live in `unitx.unitregistry`; parsing expressions
+does not change unit definitions. A parser instance caches only a successful
+result; failed parses may be retried after a definition is added. Registration
+preserves existing valid spellings and validates before updating its indexes.
+Concurrent registry writes and isolated registry contexts are not supported.
+
 Quantity definitions require positive finite `int`, `Fraction`, `Decimal`, or
 `float` magnitudes. Prefer `Fraction` or `Decimal` for exact scales. Floats use
 Factor's denominator limit and can warn or round to zero and fail, for example

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

@@ -224,14 +224,25 @@ False
   token: `ms` is a millisecond, while `m s` is metre times second.
 - Powers can use adjacent numbers, `^`, or `**`. Exponents written as ratios
   require parentheses, as in `m^(1/2)`; decimal exponents such as `m^0.5` are exact.
+  Adjacent integer superscripts are also accepted: `m²`, `s⁻¹²`, and `(m/s)²`.
+  Superscript fractions and mixed exponent notations are not supported.
 - Multiplication and division associate left to right. Use `m/(s A)` to put
   both `s` and `A` in the denominator; `m/s A` means `(m/s)*A`.
 - Unit symbols and names are case-sensitive. `u`, `µ`, and `μ` are accepted
   micro prefixes. Use lowercase `k` for kilo; `K` denotes kelvin.
-- A registered multiword name is recognized before implicit multiplication
+- A registered multiword or hyphenated name is recognized before implicit multiplication
   when it occupies the entire input. Whitespace between its words is treated
-  as a single space. Inside products, parentheses, reciprocals, and powers,
-  use its symbol or combine `Unit` objects instead.
+  as a single space. Inside expressions, use `[name]` to make a name one factor,
+  for example `[astronomical unit] / s` or `[volt-ampere reactive]**2`.
+  Symbols and `Unit` object composition remain available.
+
+Square brackets reference registered names and name aliases only: `[metre]`
+works, while `[m]` and `[m/s]` do not. The contents are never evaluated as an
+expression. Empty, nested, and unmatched brackets are errors. Put permitted
+name prefixes inside the brackets, as in `[kiloastronomical unit]`; `k[name]`
+does not apply a prefix. Single and double quotes retain their angle-unit
+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
@@ -281,9 +292,10 @@ aliases gives an empty tuple. `symbol_aliases` accepts a string or tuple of
 strings; it and `prefixable` must be passed by keyword.
 Symbols and symbol aliases must each be a single printable unit token.
 Names and name aliases may contain multiple such tokens separated by single
-ASCII spaces, without leading or trailing spaces. Decimal digits and parser
-operators are not allowed in any token. The primary symbol and `name` are
-required and must be nonempty; empty aliases are ignored.
+ASCII spaces or hyphens, without leading or trailing separators. Decimal digits
+and parser operators are not allowed in any token. The primary symbol and `name` are
+required and must be nonempty; empty aliases are ignored. Square brackets and
+the superscript characters `⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻` are reserved for parser syntax.
 
 ```pycon
 >>> span = (2 * si.m).define('span', 'survey span', 'survey distance')
@@ -293,22 +305,86 @@ True
 True
 >>> Unit('survey span') / si.s == Unit('span / s')
 True
+>>> Unit('[survey span] / [second]') == Unit('span / s')
+True
 
 ```
 
-Multiword names are recognized only as complete inputs. For example,
+Bare multiword names are recognized only as complete inputs. For example,
 `Unit('astronomical unit / arcsec')` does not recognize `astronomical unit`
-as a factor; use one of the two compound forms above instead.
+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
+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
+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, ...]`.
+
+```pycon
+>>> tick = si.s.define(
+...     'demoTick',
+...     'survey interval',
+...     symbol_aliases='demoT',
+...     prefixable=('demoT', 'survey interval'),
+... )
+>>> Unit('[millisurvey interval]') == Unit('mdemoT')
+True
+>>> Quantity(1000, 'mdemoT').to(tick).value
+Fraction(1, 1)
+>>> Unit('mdemoT').expression()
+'mdemoT'
+
+```
+
+Prefix permissions are checked before alias normalization. Canonical identity
+still uses the original registered unit and canonical prefix, independent of
+the input alias. Preferred spellings use the first permitted symbol or alias;
+if only a name supports a prefix, `SingleUnit.symbol` falls back to that name
+and `Unit.expression()` emits a `[name]` reference. Conversely, `SingleUnit.name`
+falls back to a symbol if no name allows that prefix. Repr and pickle preserve
+the same formal unit, rather than replacing the prefix with an extra scale.
+
+`arcsec` and `arcsecond` accept prefixes, for example `marcsec` and
+`milliarcsecond`; `″` and `"` do not. `as` continues to mean attosecond,
+and `mas` is not an arcsecond alias. `a` (are) and `ha` (hectare) are separate
+unprefixable units; `Pa` remains pascal. `yr` remains exactly 365 days.
+`a_j` is the Julian year of exactly 365.25 days (31,557,600 seconds), while
+`mo` is one twelfth of that interval, rather than a variable calendar month.
+The name exceptions `megohm` and `kilohm` are supported alongside the older
+`megaohm` and `kiloohm` spellings; `gigaohm` retains both vowels. No general
+vowel-elision rule is applied.
+
+`ly` is defined using the speed of light and the Julian year; `eV` uses the
+elementary charge and volt. Both reuse the defining constants exposed by `SI`.
+`mHg` is the registered metre-of-mercury unit and `mmHg` is its milli-prefixed
+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 prefixes are enabled by default; set `prefixable=False` to disable them.
-Prefix names attach directly to the first word of a multiword name, as in
-`kiloastronomical unit`; a separate `kilo astronomical unit` is not accepted.
 Registration raises `UnitRegistryError` if a new spelling, including a generated
 prefixed form, already resolves to a unit or conflicts with another spelling
 in the same definition. A multiword spelling must not replace an existing
 implicit product such as `metre second`. Validation finishes before the
 registry changes.
 
+The registry and spelling rules live in `unitx.unitregistry`; parsing expressions
+does not change unit definitions. A parser instance caches only a successful
+result; failed parses may be retried after a definition is added. Registration
+preserves existing valid spellings and validates before updating its indexes.
+Concurrent registry writes and isolated registry contexts are not supported.
+
 Quantity definitions require positive finite `int`, `Fraction`, `Decimal`, or
 `float` magnitudes. Prefer `Fraction` or `Decimal` for exact scales. Floats use
 Factor's denominator limit and can warn or round to zero and fail, for example

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

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

{unitx-0.6.3 → unitx-0.7.0}/pyrightconfig.json

@@ -4,6 +4,9 @@
     "src/unitx/_numerics.py",
     "src/unitx/factor.py",
     "src/unitx/unit.py",
+    "src/unitx/unitregistry.py",
+    "src/unitx/singleunit.py",
+    "src/unitx/unitparser.py",
     "tests/typing"
   ],
   "strict": [

{unitx-0.6.3 → unitx-0.7.0}/src/unitx/_unicode.py

@@ -1,16 +1,17 @@
 """Unicode utilities for unitx."""
 
 from fractions import Fraction
-from typing import Literal, TypeAlias
+from typing import Literal
 
 __all__ = ['DOT', 'DotType', 'superscript']
 
 DOT = '⋅'  # chr(0x22C5)
-DotType: TypeAlias = Literal['⋅']
+type DotType = Literal['⋅']
 
-DIGITS = '0123456789+-=()'
-SUPERSCRIPTS = '⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻⁼⁽⁾'
+DIGITS = '0123456789+-'
+SUPERSCRIPTS = '⁰¹²³⁴⁵⁶⁷⁸⁹⁺⁻'
 DIGIT_TO_SUP = str.maketrans(DIGITS, SUPERSCRIPTS)
+SUP_TO_DIGIT = str.maketrans(SUPERSCRIPTS, DIGITS)
 SUPERSCRIPT_SLASH = 'ᐟ'  # Canadian Syllabics Final Acute, chr(0x141F)
 
 

{unitx-0.6.3 → unitx-0.7.0}/src/unitx/quantity.py

@@ -14,6 +14,7 @@ from .dimension import DIMENSIONLESS, Dimension
 from .exceptions import DimensionError
 from .factor import ONE, Factor, SymbolicConstant
 from .unit import Unit
+from .unitregistry import PrefixPolicy
 
 # Magnitudes are exposed read-only; operations construct new quantities.
 T = TypeVar('T', bound=Magnitude, covariant=True)
@@ -208,7 +209,7 @@ class Quantity(Generic[T]):
         name: str,
         *name_aliases: str,
         symbol_aliases: str | tuple[str, ...] = (),
-        prefixable: bool = True,
+        prefixable: PrefixPolicy = True,
     ) -> Unit:
         """Register a unit equal to this quantity, using Unit.define's name rules.
 
@@ -222,7 +223,11 @@ class Quantity(Generic[T]):
         """
         scale = Factor(self.value)
         return (scale * self.unit).define(
-            symbol, name, *name_aliases, symbol_aliases=symbol_aliases, prefixable=prefixable
+            symbol,
+            name,
+            *name_aliases,
+            symbol_aliases=symbol_aliases,
+            prefixable=prefixable,
         )
 
     def _comparison_pair(self) -> tuple[Magnitude, Factor]:

unitx-0.7.0/src/unitx/si/bases.py

@@ -0,0 +1,91 @@
+"""Shared coherent SI units and the seven defining constants."""
+
+from typing import Final
+
+from .._constclass import ConstClass
+from ..factor import ONE
+from ..quantity import Quantity, quantity
+from ..unit import Unit
+
+
+class _si(ConstClass):
+    # SI base unit
+
+    one: Final = Unit()
+    """unitless"""
+    s: Final = Unit('s')
+    """second, time"""
+    m: Final = Unit('m')
+    """metre/meter, length"""
+    kg: Final = Unit('kg')
+    """kilogram, mass"""
+    A: Final = Unit('A')
+    """ampere, electric current"""
+    K: Final = Unit('K')
+    """kelvin, thermodynamic temperature"""
+    mol: Final = Unit('mol')
+    """mole, amount of substance"""
+    cd: Final = Unit('cd')
+    """candela, luminous intensity"""
+
+    # SI derived unit
+
+    rad: Final = one.define('rad', name='radian')
+    """radian, plane angle"""
+    sr: Final = one.define('sr', name='steradian')
+    """steradian, solid angle"""
+    Hz: Final = (ONE / s).define('Hz', name='hertz')
+    """hertz, frequency"""
+    N: Final = (kg * m / s**2).define('N', name='newton')
+    """newton, force/weight"""
+    Pa: Final = (N / m**2).define('Pa', name='pascal')
+    """pascal, pressure/stress"""
+    J: Final = (N * m).define('J', name='joule')
+    """joule, energy/work/heat"""
+    W: Final = (J / s).define('W', name='watt')
+    """watt, power/radiant flux"""
+    C: Final = (A * s).define('C', name='coulomb')
+    """coulomb, electric charge"""
+    V: Final = (W / A).define('V', name='volt')
+    """volt, electric potential/voltage/emf"""
+    F: Final = (C / V).define('F', name='farad')
+    """farad, capacitance"""
+    ohm: Final = (V / A).define('Ω', name='ohm')
+    """ohm, resistance/impedance/reactance"""
+    S: Final = (A / V).define('S', name='siemens')
+    """siemens, electrical conductance"""
+    Wb: Final = (V * s).define('Wb', name='weber')
+    """weber, magnetic flux"""
+    T: Final = (Wb / m**2).define('T', name='tesla')
+    """tesla, magnetic flux density"""
+    H: Final = (Wb / A).define('H', name='henry')
+    """henry, inductance"""
+    lm: Final = (cd * sr).define('lm', name='lumen')
+    """lumen, luminous flux"""
+    lx: Final = (lm / m**2).define('lx', name='lux')
+    """lux, illuminance"""
+    Bq: Final = (ONE / s).define('Bq', name='becquerel')
+    """becquerel, activity referred to a radionuclide"""
+    Gy: Final = (J / kg).define('Gy', name='gray')
+    """gray, absorbed dose"""
+    Sv: Final = (J / kg).define('Sv', name='sievert')
+    """sievert, equivalent dose"""
+    kat: Final = (mol / s).define('kat', name='katal')
+    """katal, catalytic activity"""
+
+
+class _SI(ConstClass):
+    DeltanuCs: Final = Quantity(9_192_631_770, _si.Hz)
+    """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)
+    """Planck constant"""
+    e: Final = quantity(1.602_176_634e-19, _si.C)
+    """elementary charge"""
+    kB: Final = quantity(1.380_649e-23, _si.J / _si.K)
+    """Boltzmann constant"""
+    NA: Final = quantity(6.022_140_76e23, _si.mol**-1)
+    """Avogadro constant"""
+    Kcd: Final = Quantity(683, _si.lm / _si.W)
+    """luminous efficacy of 540 THz radiation, definition of candela"""