physpyx 1.0.1__tar.gz → 2.0.0__tar.gz

{physpyx-1.0.1 → physpyx-2.0.0}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.3
 Name: physpyx
-Version: 1.0.1
+Version: 2.0.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>
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
 Classifier: Operating System :: Unix
-Classifier: Environment :: X11 Applications :: Qt
 Classifier: Topic :: Education
 Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Dist: numpy>=2.3.4

{physpyx-1.0.1 → physpyx-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "physpyx"
-version = "1.0.1"
+version = "2.0.0"
 authors = [
 	{ name="Jérôme Dufour", email="jerome.dufour@eduvaud.ch" },
 ]
@@ -9,7 +9,6 @@ classifiers = [
 	"Programming Language :: Python :: 3",
 	"License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
 	"Operating System :: Unix",
-	"Environment :: X11 Applications :: Qt",
 	"Topic :: Education",
   "Topic :: Scientific/Engineering :: Physics"
 ]
@@ -44,4 +43,3 @@ build-backend = "uv_build"
 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/"
-

{physpyx-1.0.1 → physpyx-2.0.0}/src/physpyx/nuclide.py

@@ -2,7 +2,7 @@ from enum import Enum
 from logging import getLogger
 from math import sqrt
 from pathlib import Path
-from pickle import dump, load
+from pickle import dump, loads
 from tempfile import gettempdir
 from typing import Generator, Iterable, Iterator, TypedDict
 
@@ -139,11 +139,10 @@ class Radioactivity:
             self.half_life = float(data[16])
         except ValueError:
             self.half_life = 0
-
         self.decays = DecayChannels(data)
 
     def __str__(self) -> str:
-        return f"T={self.half_life:.2e} -> {self.decays}"
+        return f"T={self.half_life:.2e}s -> {self.decays}"
 
     def __getitem__(self, c: int) -> Channel:
         return self.decays[c]
@@ -244,8 +243,7 @@ class NuclideTable:
     def _load(self) -> None:
         pk_file = Path(gettempdir()) / "physpyx-nuclides.pkl"
         if pk_file.exists():
-            with pk_file.open("rb") as pklin:
-                self._by_numbers = load(pklin)
+            self._by_numbers = loads(pk_file.read_bytes())
         else:
             with (Path(__file__).parent / "data/all-nuclides.csv").open() as csv:
                 n_col = len(csv.readline().split(","))
@@ -290,7 +288,9 @@ class NuclideTable:
                 return self._by_numbers[f"{A}-{A - N}"]
             if Z and N and not A:
                 return self._by_numbers[f"{N + Z}-{Z}"]
-        raise ValueError
+        raise ValueError(
+            f"Problematic argumetns combination {N=}, {Z=}, {A=} and {symbol=}"
+        )
 
     def range(
         self,

{physpyx-1.0.1 → physpyx-2.0.0}/src/physpyx/physpyx.py

@@ -11,8 +11,7 @@ class PhysPyX(PTManager):
         self._out = ""
 
     def _write_successfile(self) -> None:
-        with self._fname.open("w") as outfile:
-            outfile.write(self._out)
+        self._fname.write_text(self._out)
 
     def __call__(self, data: str | Generator[str]) -> None:
         if isinstance(data, str):

{physpyx-1.0.1 → physpyx-2.0.0}/src/physpyx/qty.py

@@ -4,8 +4,7 @@ import sys
 from logging import getLogger
 from pint._typing import Scalar
 from physpyx.manager import PTManager
-from physpyx.nuclide import NuclideTable
-from physpyx.quantity import SiunitxQuantity, SiunitxUnitRegistry
+from physpyx.quantity import Constants, SiunitxQuantity, SiunitxUnitRegistry
 
 logger = getLogger(__name__)
 
@@ -23,25 +22,26 @@ class Qty(PTManager):
         energy and vice-versa.
         """
         super().__init__(fname)
+        self._constants = Constants(self._fname.parent / "physpyx_constants.json")
         self._ureg = SiunitxUnitRegistry()
-        self._ureg.define("jour = day")
         self._ureg.define("heure = hour")
-        self._ureg.define("an = year")
-        self._ureg.define("ans = years")
-        self._ureg.define("mois = month")
+        self._ureg.define("heures = hours")
+        self._ureg.define("jour = day")
+        self._ureg.define("jours = days")
         self._ureg.define("semaine = week")
         self._ureg.define("semaines = weeks")
+        self._ureg.define("mois = month")
+        self._ureg.define("an = year")
+        self._ureg.define("ans = years")
         self._ureg.define("celerity = speed_of_light")
         self._ureg.define("chf = [currency] = franc")
         self._ureg.define("ct = 0.01 * chf = centime")
-        self._nuclide_table = NuclideTable()
         if context:
             self._ureg.enable_contexts(context)
 
     def _write_successfile(self) -> None:
         if self._fname.exists():
-            with self._fname.open("r") as outfile:
-                active = dict(re.findall(r"{(.*)} = {(.*)}", outfile.read()))
+            active = dict(re.findall(r"{(.*)} = {(.*)}", self._fname.read_text()))
         else:
             active = {}
         with self._fname.open("w") as outfile:
@@ -92,10 +92,10 @@ class Qty(PTManager):
 
         :param unit: Assigns the unit if any (ignored for constants).
         :param to: Immediately converts unit.
-        :param fmt: Sets the amplitude "f-string" format.
+        :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
-        rescaled to compact, human-readable units".
+        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.
@@ -103,17 +103,7 @@ class Qty(PTManager):
         if isinstance(value, str):
             if unit is not None:
                 logger.warning("Units are ignored when instanciating a constant")
-            if data := SiunitxQuantity.CONSTANTS.get(value, None):
-                value, unit, default_fmt = data
-                if fmt == "g":
-                    fmt = default_fmt
-            elif n := self._nuclide_table.get(symbol=value[1:]):
-                if fmt == "g":
-                    fmt = "f"
-                value = n.atomic_mass
-                unit = "amu"
-            else:
-                raise ValueError(f"Constant {value} not found")
+            value, unit, fmt = self._constants(value, fmt)
 
         q = self._ureg.Quantity(
             value, unit, fmt=fmt, base=base, compact=compact, preferred=preferred

{physpyx-1.0.1 → physpyx-2.0.0}/src/physpyx/quantity.py

@@ -1,9 +1,12 @@
-from typing import cast
-from numpy import cross, ndarray, linalg
-
+from json import loads
 from logging import getLogger
-from pint.registry import GenericUnitRegistry, Quantity, Unit
+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 physpyx.nuclide import NuclideTable
 
 logger = getLogger(__name__)
 
@@ -25,6 +28,7 @@ class SiunitxQuantity(Quantity):
         "standard_atmosphere": "atm",
         "unified_atomic_mass_unit": "amu",
         "meter_Hg": "mHg",
+        "watt_hour": "watthour",
     }
     _preferred_units = {
         Unit(name).dimensionality: name
@@ -48,33 +52,6 @@ class SiunitxQuantity(Quantity):
             "farad",
         ]
     }
-    CONSTANTS = {
-        "G": (6.6743e-11, "newton meter squared per kilogram squared", ".2e"),
-        "g": (9.81, "meter per second squared", ".2f"),
-        "c": (299792458, "meter per second", "d"),
-        "h": (6.62607015e-34, "joule second", ".8e"),
-        "malpha": (4.001506179129, "amu", "f"),
-        "mn": (1.67492750056e-27, "kilogram", ".3e"),
-        "mp": (1.67262192595e-27, "kilogram", ".3e"),
-        "me": (9.1093837139e-31, "kilogram", ".3e"),
-        "qe": (1.602176634e-19, "coulomb", ".3e"),
-        "Na": (6.02214076e23, "", ".8e"),
-        "amu": (1.66053906892e-27, "kilogram", ".11e"),
-        "kB": (1.380649e-23, "joule per kelvin", "e"),
-        "R": (8.31446261815324, "joule per kelvin per mole", "f"),
-        "mu0": (1.2566370612696005e-06, "tesla meter per ampere", "e"),
-        "a0": (5.29177210903e-11, "meter", "e"),
-        "k": (8.987551e9, "newton meter squared per coulomb squared", ".0e"),
-        "ceau": (4184, "joule per kilogram per kelvin", "g"),
-        "cglace": (2060, "joule per kilogram per kelvin", "g"),
-        "Lveau": (2300000, "joule per kilogram", ".1e"),
-        "Lfeau": (330000, "joule per kilogram", ".1e"),
-        "Ms": (1.98847e30, "kilogram", ".5e"),
-        "MTerre": (5.9722e24, "kilogram", ".4e"),
-        "MLune": (7.34e22, "kilogram", ".2e"),
-        "RTerre": (6371000, "meter", ".3e"),
-        "RLune": (1737000, "meter", ".3e"),
-    }
 
     def __new__(
         cls,
@@ -176,8 +153,6 @@ class SiunitxQuantity(Quantity):
         for unit_str, power in self.unit_items():
             if unit_str == "kilogram":
                 tmp = r"\kilogram"
-            elif unit_str.startswith("kilowatt_hour"):
-                tmp = r"\kWh"
             else:
                 tmp = ""
                 for p in self._REGISTRY._prefixes.values():
@@ -252,3 +227,73 @@ class SiunitxQuantity(Quantity):
 class SiunitxUnitRegistry(GenericUnitRegistry):
     Quantity: type = SiunitxQuantity
     Unit: type = Unit
+
+
+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 sauqred",
+            ".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")