refactor: extract property creation to base class

pyproject.toml

@@ -32,8 +32,12 @@ ignore = [
 
     "ISC001",  # conflicts with ruff formatter
 
+    "N802",    # interferes with setting constant abstract properties
+
     "PGH003",  # necessary for _QuantityBase.__eq__()
 
+    "RUF012",  # does not work with constants
+
     "TCH001",  # adds hard to understand compexity without providing a benefit for smaller projects
     "TCH002",  # same as TCH001
     "TCH003",  # same as TCH001

quantio/_quantity_base.py

@@ -13,16 +13,23 @@ class _QuantityBase(ABC):
 
     @property
     @abstractmethod
-    def unit_conversion(self) -> dict[str, float]:
-        """Dict containing all units of the quantity."""
+    def _UNIT_CONVERSION(self) -> dict[str, float]:
+        """Table used for recording the units with conversion values."""
 
     def __init__(self, **kwargs: float) -> None:
         """Construct this class with the used units."""
         self._base_value = kwargs.get("_base_value", 0.0)
 
-        for unit_name, factor in self.unit_conversion.items():
+        for unit_name, factor in self._UNIT_CONVERSION.items():
             self._base_value += kwargs.get(unit_name, 0.0) * factor
 
+        for unit_name, factor in self._UNIT_CONVERSION.items():
+
+            def make_property(factor: float) -> property:
+                return property(lambda self: self._base_value / factor)
+
+            setattr(self.__class__, unit_name, make_property(factor))
+
     def __eq__(self, other: object) -> bool:
         """Assess if this object is the same as another."""
         if type(self) is not type(other):

quantio/quantities.py

@@ -1,14 +1,12 @@
 from __future__ import annotations
 
-from typing import ClassVar
-
 from ._quantity_base import _QuantityBase
 
 
 class Length(_QuantityBase):
     """The one-dimensional extent of an object or the distance between two points."""
 
-    unit_conversion: ClassVar[dict[str, float]] = {
+    _UNIT_CONVERSION: dict[str, float] = {
         "miles": 1609.34,
         "kilometers": 10**3,
         "meters": 10**0,
@@ -19,73 +17,13 @@ class Length(_QuantityBase):
         "micrometers": 10**-6,
     }
 
-    @property
-    def miles(self) -> float:
-        """The length in miles."""
-        return self._base_value / self.unit_conversion["miles"]
-
-    @property
-    def kilometers(self) -> float:
-        """The length in kilometers."""
-        return self._base_value / self.unit_conversion["kilometers"]
-
-    @property
-    def meters(self) -> float:
-        """The length in meters."""
-        return self._base_value / self.unit_conversion["meters"]
-
-    @property
-    def feet(self) -> float:
-        """The length in feet."""
-        return self._base_value / self.unit_conversion["feet"]
-
-    @property
-    def inches(self) -> float:
-        """The length in inches."""
-        return self._base_value / self.unit_conversion["inches"]
-
-    @property
-    def centimeters(self) -> float:
-        """The length in centimeters."""
-        return self._base_value / self.unit_conversion["centimeters"]
-
-    @property
-    def millimeters(self) -> float:
-        """The length in millimeters."""
-        return self._base_value / self.unit_conversion["millimeters"]
-
-    @property
-    def micrometers(self) -> float:
-        """The length in micrometers."""
-        return self._base_value / self.unit_conversion["micrometers"]
-
 
 class Time(_QuantityBase):
     """The duration of an event."""
 
-    unit_conversion: ClassVar[dict[str, float]] = {
+    _UNIT_CONVERSION: dict[str, float] = {
         "hours": 60 * 60,
         "minutes": 60,
         "seconds": 1,
         "milliseconds": 10**-3,
     }
-
-    @property
-    def hours(self) -> float:
-        """The time in hours."""
-        return self._base_value / self.unit_conversion["hours"]
-
-    @property
-    def minutes(self) -> float:
-        """The time in minutes."""
-        return self._base_value / self.unit_conversion["minutes"]
-
-    @property
-    def seconds(self) -> float:
-        """The time in seconds."""
-        return self._base_value / self.unit_conversion["seconds"]
-
-    @property
-    def milliseconds(self) -> float:
-        """The time in milliseconds."""
-        return self._base_value / self.unit_conversion["milliseconds"]