unitx 0.6.3__tar.gz → 0.7.1__tar.gz

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

@@ -1,5 +1,93 @@
 # 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
+
+- 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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: unitx
-Version: 0.6.3
+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
 
@@ -246,17 +252,28 @@ 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
+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`.
 
@@ -303,9 +320,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 +333,101 @@ 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, 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
+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 | str | 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.
+
+`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.
 
-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.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
 
@@ -224,17 +230,28 @@ 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
+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`.
 
@@ -281,9 +298,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 +311,101 @@ 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, 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
+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 | str | 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.
+
+`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.
 
-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.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = 'hatchling.build'
 
 [project]
 name = 'unitx'
-version = '0.6.3'
+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.6.3 → unitx-0.7.1}/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.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.6.3 → unitx-0.7.1}/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.1}/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]: