physpyx 2.2.0__tar.gz → 2.3.0__tar.gz

{physpyx-2.2.0 → physpyx-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: physpyx
-Version: 2.2.0
+Version: 2.3.0
 Summary: Provides a way to use python code in LaTeX
 Author: Jérôme Dufour
 Author-email: Jérôme Dufour <jerome.dufour@eduvaud.ch>

physpyx-2.3.0/pyproject.toml

@@ -0,0 +1,48 @@
+[project]
+name = "physpyx"
+version = "2.3.0"
+description = "Provides a way to use python code in LaTeX"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: Unix",
+    "Topic :: Education",
+    "Topic :: Scientific/Engineering :: Physics",
+]
+license = "GPL-3.0-or-later"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "numpy>=2.3.4",
+    "pint>=0.25.1",
+    "scipy>=1.17.0",
+]
+
+[[project.authors]]
+name = "Jérôme Dufour"
+email = "jerome.dufour@eduvaud.ch"
+
+[project.urls]
+Repository = "https://bitbucket.org/jdufour/physpyx/src/master/"
+Changelog = "https://bitbucket.org/jdufour/physpyx/src/master/CHANGELOG.md"
+Documentation = "https://physpyx.readthedocs.io/fr/latest/"
+
+[dependency-groups]
+dev = [
+    "mypy>=1.18.1",
+    "ipdb>=0.13.13",
+    "scipy-stubs>=1.17.1.5",
+    "ruff>=0.16.0",
+]
+docs = [
+    "sphinx>=7.1.2",
+    "sphinx-rtd-theme>=3.0.2",
+    "sphinx-argparse>=0.5.2",
+    "myst-parser>=4.0.1",
+    "sphinx-autodoc2>=0.5.0",
+    "sphinx-autobuild>=2025.8.25",
+    "sphinx-design>=0.7.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.11.0,<0.12.0"]
+build-backend = "uv_build"

physpyx-2.2.0/pyproject.toml → physpyx-2.3.0/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "physpyx"
-version = "2.2.0"
+version = "2.3.0"
 authors = [
 	{ name="Jérôme Dufour", email="jerome.dufour@eduvaud.ch" },
 ]
@@ -25,6 +25,7 @@ dev = [
   "mypy>=1.18.1",
   "ipdb>=0.13.13",
   "scipy-stubs>=1.17.1.5",
+  "ruff>=0.16.0",
 ]
 docs = [
 	"sphinx>=7.1.2",

{physpyx-2.2.0 → physpyx-2.3.0}/src/physpyx/__init__.py

@@ -1,6 +1,7 @@
 from .astronomy import Orbit
+from .context import NuclearContext
 from .nuclide import NuclideTable
 from .physpyx import PhysPyX
 from .qty import Qty
 
-__all__ = ["NuclideTable", "PhysPyX", "Qty", "Orbit"]
+__all__ = ["NuclearContext", "NuclideTable", "Orbit", "PhysPyX", "Qty"]

{physpyx-2.2.0 → physpyx-2.3.0}/src/physpyx/astronomy.py

@@ -1,8 +1,9 @@
+from collections.abc import Iterator
+
 import numpy as np
 from numpy.typing import NDArray
-from scipy.special import ellipk, ellipkinc
 from scipy.optimize import newton
-from typing import Iterator
+from scipy.special import ellipk, ellipkinc
 
 
 class Orbit:
@@ -77,7 +78,7 @@ class Orbit:
             raise ValueError(f"{every} is not a divisor {steps} steps")
 
         dt = self.T / steps
-        for i in range(0, steps + 1):
+        for i in range(steps + 1):
             if i % every == 0:
                 yield self.x
             self.step(dt)

physpyx-2.3.0/src/physpyx/constants.py

@@ -0,0 +1,75 @@
+from json import loads
+from pathlib import Path
+from typing import ClassVar
+
+from physpyx.nuclide import NuclideTable
+
+
+class Constants:
+    _CONSTANTS: ClassVar[dict[str, tuple[float | int, str, str]]] = {
+        "cesium_standard": (9192631770, "hertz", "d"),  # SI defining constant
+        "c": (299792458, "meter per second", "d"),  # SI defining constant
+        "h": (6.62607015e-34, "joule second", ".8e"),  # SI defining constant
+        "qe": (1.602176634e-19, "coulomb", ".3e"),  # SI defining constant
+        "kB": (1.380649e-23, "joule per kelvin", "e"),  # SI defining constant
+        "Na": (6.02214076e23, "", ".8e"),  # SI defining constant
+        "R": (8.31446261815324, "joule per kelvin per mole", "f"),
+        "k": (8.987551e9, "newton meter squared per coulomb squared", ".0e"),
+        "epsilon0": (
+            8.8541878188e-12,
+            "coulomb squared per newton meter squared",
+            ".3e",
+        ),
+        "mu0": (1.2566370612696005e-06, "tesla meter per ampere", ".3e"),
+        "mn": (1.67492750056e-27, "kilogram", ".3e"),
+        "mp": (1.67262192595e-27, "kilogram", ".3e"),
+        "me": (9.1093837139e-31, "kilogram", ".3e"),
+        "a0": (5.29177210903e-11, "meter", "e"),
+        "G": (6.6743e-11, "newton meter squared per kilogram squared", ".2e"),
+        "g": (9.81, "meter per second squared", ".2f"),
+    }
+
+    def __init__(self, fname: Path | None):
+        self._fname = fname
+        self._nuclide_table = NuclideTable()
+        self._constants: dict[str, tuple[float, str, str]] = {}
+
+    def _get_default_constant(
+        self, name: str, fmt: str
+    ) -> tuple[float, str, str] | None:
+        if data := self._CONSTANTS.get(name, None):
+            value, unit, default_fmt = data
+            return value, unit, default_fmt if fmt == "g" else fmt
+
+    def _get_custom_constant(
+        self, name: str, fmt: str
+    ) -> tuple[float, str, str] | None:
+        if not self._constants and self._fname and self._fname.exists():
+            self._constants = loads(self._fname.read_bytes())
+
+        if data := self._constants.get(name, None):
+            value, unit, default_fmt = data
+            return value, unit, default_fmt if fmt == "g" else fmt
+
+    def _get_nuclide_data(self, name: str, fmt: str) -> tuple[float, str, str] | None:
+        try:
+            match name[0]:
+                case "m":
+                    n = self._nuclide_table.get(symbol=name[1:])
+                    return n.atomic_mass, "amu", "f" if fmt == "g" else fmt
+                case "t":
+                    n = self._nuclide_table.get(symbol=name[1:])
+                    if n.radioactivity.stable:
+                        raise ValueError(f"No half-life for {n.symbol}")
+                    return n.radioactivity.half_life, "second", "g"
+        except KeyError:
+            pass
+
+    def __call__(self, name: str, fmt: str) -> tuple[float, str, str]:
+        if data := (
+            self._get_default_constant(name, fmt)
+            or self._get_custom_constant(name, fmt)
+            or self._get_nuclide_data(name, fmt)
+        ):
+            return data
+        raise ValueError(f"Constant '{name}' not found")

{physpyx-2.2.0 → physpyx-2.3.0}/src/physpyx/context.py

@@ -7,7 +7,7 @@ class SiunitxContext(Context):
 
 
 class NuclearContext(SiunitxContext):
-    def __init__(self, mass_is_amu: bool = True):
+    def __init__(self, preferred_units: bool = True):
         super().__init__("nuclear")
         self.add_transformation(
             "[mass]",
@@ -20,5 +20,16 @@ class NuclearContext(SiunitxContext):
             lambda ureg, x: x / ureg.speed_of_light / ureg.speed_of_light,
         )
         self.preferred_units = (
-            {UnitsContainer({"[mass]": 1}): "amu"} if mass_is_amu else {}
+            {
+                UnitsContainer({"[mass]": 1}): "amu",
+                UnitsContainer(
+                    {
+                        "[mass]": 1,
+                        "[length]": 2,
+                        "[time]": -2,
+                    }
+                ): "megaelectronvolt",
+            }
+            if preferred_units
+            else {}
         )

{physpyx-2.2.0 → physpyx-2.3.0}/src/physpyx/manager.py

@@ -29,7 +29,7 @@ class PTManager(ABC):
         except Exception as e:
             if tb_type := e.__traceback__:
                 self._write_errorfile(e, tb_type)
-                raise e
+                raise
 
     @abstractmethod
     def _write_successfile(self) -> None: ...

{physpyx-2.2.0 → physpyx-2.3.0}/src/physpyx/nuclide.py

@@ -1,10 +1,11 @@
+from collections.abc import Generator, Iterable, Iterator
 from enum import Enum
 from logging import getLogger
 from math import sqrt
 from pathlib import Path
 from pickle import dump, loads
 from tempfile import gettempdir
-from typing import Generator, Iterable, Iterator, TypedDict
+from typing import ClassVar, TypedDict
 
 logger = getLogger(__name__)
 
@@ -59,7 +60,7 @@ class PossibleDecays(Enum):
 
 
 class Channel:
-    _DECAY_MAP = {d: md for md in PossibleDecays for d in md.channels.keys()}
+    _DECAY_MAP: ClassVar = {d: md for md in PossibleDecays for d in md.channels}
 
     def __init__(self, channel: str, prob: float):
         self.decay = self._DECAY_MAP[channel]
@@ -105,16 +106,15 @@ class DecayChannels:
                     self.channels.append(B)
                     look_for_C = True
 
-                if look_for_C:
-                    if C := self._parse_decays(data[24], data[25]):
-                        if C.prob < 1:
-                            logger.warning(f"{symbol} skip 3rd (<1% | none)")
-                        elif A.prob + B.prob + C.prob > 100:
-                            logger.warning(
-                                f"{symbol} skip 3rd ({A.prob + B.prob + C.prob:.0f}%>100%)"
-                            )
-                        else:
-                            self.channels.append(C)
+                if look_for_C and (C := self._parse_decays(data[24], data[25])):
+                    if C.prob < 1:
+                        logger.warning(f"{symbol} skip 3rd (<1% | none)")
+                    elif A.prob + B.prob + C.prob > 100:
+                        logger.warning(
+                            f"{symbol} skip 3rd ({A.prob + B.prob + C.prob:.0f}%>100%)"
+                        )
+                    else:
+                        self.channels.append(C)
 
         if len(self.channels) == 1 and self.channels[0].prob == 0:
             self.channels[0].prob = 100
@@ -214,8 +214,7 @@ class Nuclide:
         with_mass: bool = False,
         with_decay: bool = False,
     ) -> Generator[str]:
-        for tex in self.radioactivity.to_tex(self.N, self.Z):
-            yield tex
+        yield from self.radioactivity.to_tex(self.N, self.Z)
 
         if with_symbol:
             yield rf"\node[anchor=north] at ({self.N + 0.5}, {self.Z + 1}) {{\ce{{^{self.A}{self.symbol}}}}};"
@@ -231,14 +230,13 @@ class Nuclide:
 
 class NuclideTable:
     def __init__(self):
-        self._by_numbers = dict()
-        self._by_symbols = dict()
+        self._by_numbers = {}
+        self._by_symbols = {}
 
     def __iter__(self) -> Iterator[Nuclide]:
         if not self._by_numbers:
             self._load()
-        for n in self._by_numbers.values():
-            yield n
+        yield from self._by_numbers.values()
 
     def _load(self) -> None:
         pk_file = Path(gettempdir()) / "physpyx-nuclides.pkl"
@@ -354,14 +352,10 @@ class NuclideTable:
         Nmin, Nmax = 1000, 0
         Zmin, Zmax = 1000, 0
         for n in nuclides:
-            if n.N < Nmin:
-                Nmin = n.N
-            if n.Z < Zmin:
-                Zmin = n.Z
-            if n.N > Nmax:
-                Nmax = n.N
-            if n.Z > Zmax:
-                Zmax = n.Z
+            Nmin = min(Nmin, n.N)
+            Zmin = min(Zmin, n.Z)
+            Nmax = max(Nmax, n.N)
+            Zmax = max(Zmax, n.Z)
 
         yield rf"\draw[<->] ({Nmin - 0.1}, {Zmax + 1}) node[left]{{$Z$}} |- ({Nmax + 1}, {Zmin - 0.1}) node[below]{{$N$}};"
         for i in range(Nmin, Nmax + 1):

{physpyx-2.2.0 → physpyx-2.3.0}/src/physpyx/physpyx.py

@@ -1,4 +1,4 @@
-from typing import Generator
+from collections.abc import Generator
 from contextlib import contextmanager
 
 from physpyx.manager import PTManager
@@ -20,7 +20,7 @@ class PhysPyX(PTManager):
             indent = "\t" * self._stack
             self._out += indent + f"\n{indent}".join(data) + "\n"
         else:
-            raise ValueError
+            raise TypeError
 
     @contextmanager
     def begin(

{physpyx-2.2.0 → physpyx-2.3.0}/src/physpyx/qty.py

@@ -1,16 +1,14 @@
 import re
 import sys
-
 from logging import getLogger
-from typing import TYPE_CHECKING
 
+from pint._typing import Scalar
 from pint.facets.context import Context
 
+from physpyx.constants import Constants
 from physpyx.manager import PTManager
-from physpyx.quantity import AltDict, Constants, SiunitxQuantity, SiunitxUnitRegistry
-
-if TYPE_CHECKING:
-    from pint._typing import Scalar
+from physpyx.quantity import AltDict, SiunitxQuantity
+from physpyx.registry import SiunitxUnitRegistry
 
 logger = getLogger(__name__)
 
@@ -42,9 +40,9 @@ class Qty(PTManager):
             outfile.write(
                 "\\ExplSyntaxOn\n\\prop_gset_from_keyval:Nn \\g_physpyx_pty_prop {\n"
             )
-            for name, qty in sys._getframe(2).f_locals.items():
+            for variable, qty in sys._getframe(2).f_locals.items():
                 if isinstance(qty, SiunitxQuantity):
-                    for name, new in qty.export(name):
+                    for name, new in qty.export(variable):
                         outfile.write(f"\t{{{name}}} = {{{new}}},\n")
                         if old := current.pop(name, None):
                             if old != new:

{physpyx-2.2.0 → physpyx-2.3.0}/src/physpyx/quantity.py

@@ -1,16 +1,10 @@
-from json import loads
+from collections.abc import Generator, Iterator
 from logging import getLogger
-from numpy import cross, ndarray, linalg
-from pathlib import Path
-from pint.registry import GenericUnitRegistry, Quantity, Unit
-from pint.facets.context import Context
-from typing import TYPE_CHECKING, Any, Generator, TypedDict, cast
+from typing import ClassVar, Self, TypedDict, cast
 
-from physpyx.context import SiunitxContext
-from physpyx.nuclide import NuclideTable
-
-if TYPE_CHECKING:
-    from pint._typing import Magnitude, UnitLike
+from numpy import cross, linalg, ndarray
+from pint._typing import Magnitude, UnitLike
+from pint.registry import Quantity
 
 logger = getLogger(__name__)
 
@@ -31,7 +25,7 @@ class SiunitxQuantity(Quantity):
     _preferred: bool
     _alt: AltDict
 
-    _sinunitx_map = {
+    _sinunitx_map: ClassVar[dict[str, str]] = {
         "astronomical_unit": "astronomicalunit",
         "degree_Celsius": "celsius",
         "delta_degree_Celsius": "celsius",
@@ -54,7 +48,7 @@ class SiunitxQuantity(Quantity):
         compact: bool = False,
         preferred: bool = True,
         alt: AltDict | bool = False,
-    ) -> "SiunitxQuantity":
+    ) -> Self:
         """
         Return an instance of SiunitxQuantity
 
@@ -71,7 +65,7 @@ class SiunitxQuantity(Quantity):
         :param alt: If provided, writes an additional alternative output with
         different formatting. The string '_alt' is added to the base name.
         """
-        quantity = cast(SiunitxQuantity, super().__new__(cls, value, units))
+        quantity = cast(Self, super().__new__(cls, value, units))
         quantity._fmt = fmt
         quantity._base = base
         quantity._compact = compact
@@ -86,6 +80,17 @@ class SiunitxQuantity(Quantity):
         else:
             return alt
 
+    def __iter__(self) -> Iterator["SiunitxQuantity"]:
+        # NOTE: this is used to set formatting options in tuple expansions:
+        # rx, ry = qty([3, 2], "kilometer", fmt=".1e")
+        for val in super().__iter__():
+            val._fmt = self._fmt
+            val._base = self._base
+            val._compact = self._compact
+            val._preferred = self._preferred
+            val._alt = self._alt
+            yield val
+
     def __str__(self) -> str:
         quantity = self
         if self._base:
@@ -146,6 +151,11 @@ class SiunitxQuantity(Quantity):
         # "PlainQuantity[Unknown]"'
         return cast(SiunitxQuantity, super().__neg__())
 
+    def __add__(self, other: object) -> "SiunitxQuantity":
+        # NOTE: to fix typing warning 'Cannot access attribute "???" for class
+        # "PlainQuantity[Unknown]"'
+        return cast(SiunitxQuantity, super().__add__(other))
+
     def _format_unit(self) -> str:
         num = ""
         den = ""
@@ -176,7 +186,7 @@ class SiunitxQuantity(Quantity):
                 den += r"\per" + tmp
         return num + den
 
-    def export(self, name: str) -> Generator[tuple[str, str], None, None]:
+    def export(self, name: str) -> Generator[tuple[str, str]]:
         try:
             yield (
                 name,
@@ -189,7 +199,7 @@ class SiunitxQuantity(Quantity):
             # the one raised in PTManager.__exit__
             logger.error(f"exporting {name} failed, {self._fmt}")
             e.add_note(f"exporting {name} failed")
-            raise e
+            raise
 
         if self._alt:
             alt = self.fmtex(**self._alt)
@@ -257,130 +267,3 @@ class SiunitxQuantity(Quantity):
         if not isinstance(other, SiunitxQuantity):
             raise TypeError(f"Can't perform a cross product with a {type(other)}")
         return cast(SiunitxQuantity, cross(self, other))
-
-
-class SiunitxUnitRegistry(GenericUnitRegistry):
-    Quantity: type = SiunitxQuantity
-    Unit: type = Unit
-
-    def __init__(self):
-        super().__init__()
-        self.define("heure = hour")
-        self.define("heures = hours")
-        self.define("jour = day")
-        self.define("jours = days")
-        self.define("semaine = week")
-        self.define("semaines = weeks")
-        self.define("mois = month")
-        self.define("an = year")
-        self.define("ans = years")
-        self.define("celerity = speed_of_light")
-        self.define("chf = [currency] = franc")
-        self.define("ct = 0.01 * chf = centime")
-        self._preferred_units = {
-            Unit(name).dimensionality: name
-            for name in [
-                "meter",
-                "second",
-                "kilogram",
-                "ampere",
-                "kelvin",
-                "mole",
-                "meter per second",
-                "meter per second squared",
-                "newton",
-                "joule",
-                "watt",
-                "pascal",
-                "volt",
-                "ohm",
-                "tesla",
-                "henry",
-                "farad",
-                "coulomb",
-            ]
-        }
-
-    def enable_contexts(self, *names_or_contexts: str | Context, **kwargs: Any) -> None:
-        for context in names_or_contexts:
-            if isinstance(context, SiunitxContext):
-                self._preferred_units |= context.preferred_units
-        return super().enable_contexts(*names_or_contexts, **kwargs)
-
-    def to_preferred_units(self, qty: SiunitxQuantity) -> SiunitxQuantity:
-        return cast(
-            SiunitxQuantity,
-            qty.to(to)
-            if (to := self._preferred_units.get(qty.dimensionality, None))
-            else qty.to_reduced_units(),
-        )
-
-
-class Constants:
-    _CONSTANTS = {
-        "cesium_standard": (9192631770, "hertz", "d"),  # SI defining constant
-        "c": (299792458, "meter per second", "d"),  # SI defining constant
-        "h": (6.62607015e-34, "joule second", ".8e"),  # SI defining constant
-        "qe": (1.602176634e-19, "coulomb", ".3e"),  # SI defining constant
-        "kB": (1.380649e-23, "joule per kelvin", "e"),  # SI defining constant
-        "Na": (6.02214076e23, "", ".8e"),  # SI defining constant
-        "R": (8.31446261815324, "joule per kelvin per mole", "f"),
-        "k": (8.987551e9, "newton meter squared per coulomb squared", ".0e"),
-        "epsilon0": (
-            8.8541878188e-12,
-            "coulomb squared per newton meter squared",
-            ".3e",
-        ),
-        "mu0": (1.2566370612696005e-06, "tesla meter per ampere", ".3e"),
-        "mn": (1.67492750056e-27, "kilogram", ".3e"),
-        "mp": (1.67262192595e-27, "kilogram", ".3e"),
-        "me": (9.1093837139e-31, "kilogram", ".3e"),
-        "a0": (5.29177210903e-11, "meter", "e"),
-        "G": (6.6743e-11, "newton meter squared per kilogram squared", ".2e"),
-        "g": (9.81, "meter per second squared", ".2f"),
-    }
-
-    def __init__(self, fname: Path | None):
-        self._fname = fname
-        self._nuclide_table = NuclideTable()
-        self._constants: dict[str, tuple[float, str, str]] = {}
-
-    def _get_default_constant(
-        self, name: str, fmt: str
-    ) -> tuple[float, str, str] | None:
-        if data := self._CONSTANTS.get(name, None):
-            value, unit, default_fmt = data
-            return value, unit, default_fmt if fmt == "g" else fmt
-
-    def _get_custom_constant(
-        self, name: str, fmt: str
-    ) -> tuple[float, str, str] | None:
-        if not self._constants and self._fname and self._fname.exists():
-            self._constants = loads(self._fname.read_bytes())
-
-        if data := self._constants.get(name, None):
-            value, unit, default_fmt = data
-            return value, unit, default_fmt if fmt == "g" else fmt
-
-    def _get_nuclide_data(self, name: str, fmt: str) -> tuple[float, str, str] | None:
-        try:
-            match name[0]:
-                case "m":
-                    n = self._nuclide_table.get(symbol=name[1:])
-                    return n.atomic_mass, "amu", "f" if fmt == "g" else fmt
-                case "t":
-                    n = self._nuclide_table.get(symbol=name[1:])
-                    if n.radioactivity.stable:
-                        raise ValueError(f"No half-life for {n.symbol}")
-                    return n.radioactivity.half_life, "second", "g"
-        except KeyError:
-            pass
-
-    def __call__(self, name: str, fmt: str) -> tuple[float, str, str]:
-        if data := (
-            self._get_default_constant(name, fmt)
-            or self._get_custom_constant(name, fmt)
-            or self._get_nuclide_data(name, fmt)
-        ):
-            return data
-        raise ValueError(f"Constant '{name}' not found")

physpyx-2.3.0/src/physpyx/registry.py

@@ -0,0 +1,64 @@
+from typing import Any, cast
+
+from pint.facets.context import Context
+from pint.registry import GenericUnitRegistry, Unit
+
+from physpyx.context import SiunitxContext
+from physpyx.quantity import SiunitxQuantity
+
+
+class SiunitxUnitRegistry(GenericUnitRegistry):
+    Quantity: type = SiunitxQuantity
+    Unit: type = Unit
+
+    def __init__(self):
+        super().__init__()
+        self.define("heure = hour")
+        self.define("heures = hours")
+        self.define("jour = day")
+        self.define("jours = days")
+        self.define("semaine = week")
+        self.define("semaines = weeks")
+        self.define("mois = month")
+        self.define("an = year")
+        self.define("ans = years")
+        self.define("celerity = speed_of_light")
+        self.define("chf = [currency] = franc")
+        self.define("ct = 0.01 * chf = centime")
+        self._preferred_units = {
+            Unit(name).dimensionality: name
+            for name in [
+                "meter",
+                "second",
+                "kilogram",
+                "ampere",
+                "kelvin",
+                "mole",
+                "meter per second",
+                "meter per second squared",
+                "newton",
+                "joule",
+                "watt",
+                "pascal",
+                "volt",
+                "ohm",
+                "tesla",
+                "henry",
+                "farad",
+                "coulomb",
+            ]
+        }
+
+    def enable_contexts(self, *names_or_contexts: str | Context, **kwargs: Any) -> None:
+        for context in names_or_contexts:
+            if isinstance(context, SiunitxContext):
+                self._preferred_units |= context.preferred_units
+        return super().enable_contexts(*names_or_contexts, **kwargs)
+
+    def to_preferred_units(self, qty: SiunitxQuantity) -> SiunitxQuantity:
+        return cast(
+            SiunitxQuantity,
+            qty.to(to)
+            if (to := self._preferred_units.get(qty.dimensionality, None))
+            else qty.to_reduced_units(),
+        )