physpyx 2.0.1__tar.gz → 2.1.0__tar.gz

{physpyx-2.0.1 → physpyx-2.1.0}/PKG-INFO

@@ -1,11 +1,11 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: physpyx
-Version: 2.0.1
+Version: 2.1.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>
+License-Expression: GPL-3.0-or-later
 Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: Unix
 Classifier: Topic :: Education
 Classifier: Topic :: Scientific/Engineering :: Physics

{physpyx-2.0.1 → physpyx-2.1.0}/pyproject.toml

@@ -1,17 +1,17 @@
 [project]
 name = "physpyx"
-version = "2.0.1"
+version = "2.1.0"
 authors = [
 	{ name="Jérôme Dufour", email="jerome.dufour@eduvaud.ch" },
 ]
 description = "Provides a way to use python code in LaTeX"
 classifiers = [
 	"Programming Language :: Python :: 3",
-	"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
 	"Operating System :: Unix",
 	"Topic :: Education",
   "Topic :: Scientific/Engineering :: Physics"
 ]
+license = "GPL-3.0-or-later"
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
@@ -24,6 +24,7 @@ dependencies = [
 dev = [
   "mypy>=1.18.1",
   "ipdb>=0.13.13",
+  "scipy-stubs>=1.17.1.5",
 ]
 docs = [
 	"sphinx>=7.1.2",
@@ -36,7 +37,7 @@ docs = [
 ]
 
 [build-system]
-requires = ["uv_build>=0.10.9,<0.11.0"]
+requires = ["uv_build>=0.11.0,<0.12.0"]
 build-backend = "uv_build"
 
 [project.urls]

{physpyx-2.0.1 → physpyx-2.1.0}/src/physpyx/astronomy.py

@@ -90,7 +90,7 @@ class Orbit:
             return self.a * ellipkinc(phi, m) - arc_length
 
         for i in range(n + 1):
-            phi = np.pi / 2 - newton(func, x0=np.pi / 2 * i / n, args=[P * i / n])
+            phi = np.pi / 2 - newton(func, x0=np.pi / 2 * i / n, args=(P * i / n))
             r = self.b / np.sqrt(1 - (self.e * np.cos(phi)) ** 2)
             yield np.array([-self.F + r * np.cos(phi), r * np.sin(phi)])
 

{physpyx-2.0.1 → physpyx-2.1.0}/src/physpyx/nuclide.py

@@ -224,7 +224,7 @@ class Nuclide:
         if with_mass:
             label += rf"\num{{{self.atomic_mass:.6f}}}"
         if with_decay:
-            label += "/".join(channel.label for channel in self.radioactivity)
+            label += str(self.radioactivity.decays.channels)
         if label:
             yield rf"\node[anchor=south] at ({self.N + 0.5}, {self.Z}) {{\tiny{{{label}}}}};"
 
@@ -337,7 +337,7 @@ class NuclideTable:
         :param y: y-position of the label (top of table if x=Zmax+1, bottom of table if x=Zmin-1)
         :param vertical: orientation of the label
         """
-        decays = {c.decay for n in nuclides for c in n.radioactivity.decays}
+        decays = {c.decay for n in nuclides for c in n.radioactivity.decays.channels}
         for i, decay in enumerate(sorted(decays, key=lambda x: x.name)):
             pos = f"({x}, {y - i})" if vertical else f"({x + i}, {y})"
             yield rf"\fill[color={decay.color}!60] {pos} rectangle ++(1, 1) node[midway, black]{{{decay.label}}};"

{physpyx-2.0.1 → physpyx-2.1.0}/src/physpyx/qty.py

@@ -4,7 +4,7 @@ import sys
 from logging import getLogger
 from pint._typing import Scalar
 from physpyx.manager import PTManager
-from physpyx.quantity import Constants, SiunitxQuantity, SiunitxUnitRegistry
+from physpyx.quantity import AltDict, Constants, SiunitxQuantity, SiunitxUnitRegistry
 
 logger = getLogger(__name__)
 
@@ -41,34 +41,25 @@ class Qty(PTManager):
 
     def _write_successfile(self) -> None:
         if self._fname.exists():
-            active = dict(re.findall(r"{(.*)} = {(.*)}", self._fname.read_text()))
+            current = dict(re.findall(r"{(.*)} = {(.*)}", self._fname.read_text()))
         else:
-            active = {}
+            current = {}
         with self._fname.open("w") as outfile:
             outfile.write(
                 "\\ExplSyntaxOn\n\\prop_gset_from_keyval:Nn \\g_physpyx_pty_prop {\n"
             )
             for name, qty in sys._getframe(2).f_locals.items():
                 if isinstance(qty, SiunitxQuantity):
-                    if name == "mu0":
-                        qty = r"\qty[input-digits = 0123456789\pi]{4\pi e-7}{\tesla\meter\per\ampere}"
-                    try:
-                        outfile.write(f"\t{{{name}}} = {{{str(qty)}}},\n")
-                        if old := active.pop(name, None):
-                            if old != str(qty):
-                                logger.info(f"update {name}: {old} -> {qty}")
+                    for name, new in qty.export(name):
+                        outfile.write(f"\t{{{name}}} = {{{new}}},\n")
+                        if old := current.pop(name, None):
+                            if old != new:
+                                logger.info(f"update {name}: {old} -> {new}")
                         else:
-                            logger.info(f"add {name}: {qty}")
-                    except ValueError as e:
-                        # TODO: report the correct error in
-                        # PTManager.write_errorfile, not the one raised in
-                        # PTManager.__exit__
-                        logger.error(f"exporting {name} failed, {qty._fmt}")
-                        e.add_note(f"exporting {name} failed")
-                        raise e
+                            logger.info(f"add {name}={new}")
 
-            for name, qty in active.items():
-                logger.info(f"remove {name}: {qty}")
+            for name, old in current.items():
+                logger.info(f"remove {name}: {old}")
             outfile.write("}\n\\ExplSyntaxOff\n")
 
     def __call__(
@@ -80,6 +71,7 @@ class Qty(PTManager):
         base: bool = False,
         compact: bool = False,
         preferred: bool = False,
+        alt: AltDict | bool = False,
     ) -> SiunitxQuantity:
         """
         Return an instance of SiunitxQuantity
@@ -94,11 +86,13 @@ class Qty(PTManager):
         :param to: Immediately converts unit.
         :param fmt: Sets the "f-string" format of the magnitude.
         :param base: If true, converts the unit into SI units.
-        :param compact: As described in the "Pint" documentation "returns a
+        :param compact: As described in the `Pint` documentation "returns a
         rescaled, human-readable unit".
         :param preferred: If true, attempts to convert unit into simpler one.
         For instance (kg.m/s2 will be converted to N). Note that, this defaults
         to "False" only here.
+        :param alt: If provided, writes an additional alternative output with
+        different formatting. The string '_alt' is added to the base name.
         """
         if isinstance(value, str):
             if unit is not None:
@@ -106,6 +100,12 @@ class Qty(PTManager):
             value, unit, fmt = self._constants(value, fmt)
 
         q = self._ureg.Quantity(
-            value, unit, fmt=fmt, base=base, compact=compact, preferred=preferred
+            value,
+            unit,
+            fmt=fmt,
+            base=base,
+            compact=compact,
+            preferred=preferred,
+            alt=alt,
         )
         return q if to is None else q.fmtex(to=to)

{physpyx-2.0.1 → physpyx-2.1.0}/src/physpyx/quantity.py

@@ -4,18 +4,28 @@ from numpy import cross, ndarray, linalg
 from pathlib import Path
 from pint._typing import Magnitude, UnitLike
 from pint.registry import GenericUnitRegistry, Quantity, Unit
-from typing import cast
+from typing import Generator, TypedDict, cast
 
 from physpyx.nuclide import NuclideTable
 
 logger = getLogger(__name__)
 
 
+class AltDict(TypedDict, total=False):
+    fmt: str
+    base: bool
+    preferred: bool
+    compact: bool
+    to: str
+    alt: "AltDict"
+
+
 class SiunitxQuantity(Quantity):
     _fmt: str
     _base: bool
     _compact: bool
     _preferred: bool
+    _alt: AltDict
 
     _sinunitx_map = {
         "astronomical_unit": "astronomicalunit",
@@ -62,6 +72,7 @@ class SiunitxQuantity(Quantity):
         base: bool = False,
         compact: bool = False,
         preferred: bool = True,
+        alt: AltDict | bool = False,
     ) -> "SiunitxQuantity":
         """
         Return an instance of SiunitxQuantity
@@ -70,30 +81,41 @@ class SiunitxQuantity(Quantity):
         :param unit: Assigns the unit if any.
         :param fmt: Sets the amplitude "f-string" format.
         :param base: If true, converts the unit into SI units.
-        :param compact: As described in the "Pint" documentation "returns a
+        :param compact: As described in the `Pint` documentation "returns a
         rescaled to compact, human-readable units".
         :param preferred: If true, attempts to convert units into preferred
         ones. For instance (kg.m/s2 will be converted to N). Note that, this
         defaults to "True" which means that all SiunitxQuantity resulting from
         mathematical operations, will be converted.
+        :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._fmt = fmt
         quantity._base = base
         quantity._compact = compact
         quantity._preferred = preferred
+        quantity._alt = cls._cast_alt_dict(alt)
         return quantity
 
+    @classmethod
+    def _cast_alt_dict(cls, alt: AltDict | bool) -> AltDict:
+        if isinstance(alt, bool):
+            return {"preferred": True} if alt else AltDict()
+        else:
+            return alt
+
     def __str__(self) -> str:
         quantity = self
         if self._base:
             quantity = cast(SiunitxQuantity, self.to_base_units())
         elif self._preferred:
-            if sum(1 for _ in self.unit_items()) != 1:
-                if to := self._preferred_units.get(self.dimensionality, None):
-                    quantity = cast(SiunitxQuantity, self.to(to))
-                else:
-                    quantity = cast(SiunitxQuantity, self.to_reduced_units())
+            quantity = cast(
+                SiunitxQuantity,
+                self.to(to)
+                if (to := self._preferred_units.get(self.dimensionality, None))
+                else self.to_reduced_units(),
+            )
         if self._compact:
             quantity = cast(SiunitxQuantity, self.to_compact())
 
@@ -144,8 +166,8 @@ class SiunitxQuantity(Quantity):
                 return rf"\num{{{out}}}"
 
     def __neg__(self) -> "SiunitxQuantity":
-        # NOTE: only useful to fix typing warning Cannot access attribute "???"
-        # for class "PlainQuantity[Unknown]"
+        # NOTE: to fix typing warning 'Cannot access attribute "???" for class
+        # "PlainQuantity[Unknown]"'
         return cast(SiunitxQuantity, super().__neg__())
 
     def _format_unit(self) -> str:
@@ -172,12 +194,33 @@ class SiunitxQuantity(Quantity):
                     tmp += r"\cubed"
                 else:
                     tmp += rf"\tothe{{{p:f}}}"
-            if power >= 0:
+            if power >= 0.0:
                 num += tmp
             else:
                 den += r"\per" + tmp
         return num + den
 
+    def export(self, name: str) -> Generator[tuple[str, str], None, None]:
+        try:
+            yield (
+                name,
+                r"\qty[input-digits = 0123456789\pi]{4\pi e-7}{\tesla\meter\per\ampere}"
+                if name == "mu0"
+                else str(self),
+            )
+        except ValueError as e:
+            # TODO: report the correct error in
+            # PTManager.write_errorfile, not the one raised in
+            # PTManager.__exit__
+            logger.error(f"exporting {name} failed, {self._fmt}")
+            e.add_note(f"exporting {name} failed")
+            raise e
+
+        if self._alt:
+            alt = self.fmtex(**self._alt)
+            alt._alt = AltDict()
+            yield from alt.export(name + "_alt")
+
     def fmtex(
         self,
         *,
@@ -186,15 +229,24 @@ class SiunitxQuantity(Quantity):
         base: bool | None = None,
         compact: bool | None = None,
         preferred: bool | None = None,
+        alt: AltDict | bool = False,
     ) -> "SiunitxQuantity":
         fmt = self._fmt if fmt is None else fmt
         compact = self._compact if compact is None else compact
         base = self._base if base is None else base
         preferred = self._preferred if preferred is None else preferred
+        alt = self._cast_alt_dict(alt)
+
         if to == "":
             m = self.m if self.units != "percent" else self.m / 100
             return self.__class__(
-                m, "", fmt=fmt, base=False, compact=compact, preferred=preferred
+                m,
+                "",
+                fmt=fmt,
+                base=False,
+                compact=compact,
+                preferred=preferred,
+                alt=alt,
             )
 
         if to:
@@ -203,10 +255,17 @@ class SiunitxQuantity(Quantity):
             q._base = False
             q._compact = compact
             q._preferred = False
+            q._alt = alt
             return q
 
         return self.__class__(
-            self.m, self.units, fmt=fmt, base=base, compact=compact, preferred=preferred
+            self.m,
+            self.units,
+            fmt=fmt,
+            base=base,
+            compact=compact,
+            preferred=preferred,
+            alt=alt,
         )
 
     def norm(self) -> "SiunitxQuantity":