TypedUnit 0.0.3__tar.gz → 0.0.5__tar.gz

{typedunit-0.0.3 → typedunit-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypedUnit
-Version: 0.0.3
+Version: 0.0.5
 Summary: A package wrapping pint for handling typed units in Python.
 Author-email: Martin Poinsinet de Sivry-Houle <martin.poinsinet.de.sivry@gmail.com>
 License: MIT License

{typedunit-0.0.3 → typedunit-0.0.5}/TypedUnit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.3'
-__version_tuple__ = version_tuple = (0, 0, 3)
+__version__ = version = '0.0.5'
+__version_tuple__ = version_tuple = (0, 0, 5)
 
-__commit_id__ = commit_id = 'g60e49e059'
+__commit_id__ = commit_id = 'g036d03e92'

typedunit-0.0.5/TypedUnit/helper.py

@@ -0,0 +1,67 @@
+from TypedUnit.units import BaseUnit
+from typing import get_type_hints, get_origin, get_args, Union
+import inspect
+
+def _get_unit_type(hint):
+    """Extract BaseUnit type from hint, handling Optional and List."""
+    # Direct BaseUnit subclass
+    if inspect.isclass(hint) and issubclass(hint, BaseUnit):
+        return hint, False, False  # (unit_type, is_optional, is_list)
+
+    origin = get_origin(hint)
+    args = get_args(hint)
+
+    if origin is Union:
+        # Handle Optional[BaseUnit] (Union[BaseUnit, None])
+        unit_types = [arg for arg in args if arg is not type(None)]
+        if len(unit_types) == 1 and inspect.isclass(unit_types[0]) and issubclass(unit_types[0], BaseUnit):
+            return unit_types[0], True, False  # Optional BaseUnit
+
+    elif origin in (list, tuple):
+        # Handle List[BaseUnit] or Tuple[BaseUnit]
+        if len(args) == 1 and inspect.isclass(args[0]) and issubclass(args[0], BaseUnit):
+            return args[0], False, True  # List of BaseUnit
+
+    return None, False, False
+
+def validate_units(function):
+    def wrapper(*args, **kwargs):
+        hints = get_type_hints(function)
+        sig = inspect.signature(function)
+
+        # Bind arguments to get parameter names
+        bound_args = sig.bind(*args, **kwargs)
+        bound_args.apply_defaults()
+
+        for param_name, value in bound_args.arguments.items():
+            if param_name not in hints:
+                continue
+
+            hint = hints[param_name]
+            unit_type, is_optional, is_list = _get_unit_type(hint)
+
+            if unit_type is None:
+                continue  # No unit validation needed
+
+            # Handle None values for Optional types
+            if value is None and is_optional:
+                continue
+            elif value is None and not is_optional:
+                raise ValueError(f"Parameter '{param_name}' cannot be None")
+
+            # Handle List/Tuple types
+            if is_list:
+                for i, item in enumerate(value):
+                    try:
+                        unit_type.check(item)
+                    except (AssertionError, ValueError) as e:
+                        raise ValueError(f"Parameter '{param_name}[{i}]': {e}")
+            else:
+                # Handle single values
+                try:
+                    unit_type.check(value)
+                except (AssertionError, ValueError) as e:
+                    raise ValueError(f"Parameter '{param_name}': {e}")
+
+        return function(*args, **kwargs)
+    return wrapper

typedunit-0.0.5/TypedUnit/units.py

@@ -0,0 +1,206 @@
+# Initialize a unit registry
+from pint import Quantity, UnitRegistry
+
+ureg = UnitRegistry()
+
+ureg.define("photoelectron = [Float64]")  # Define a custom unit 'photoelectron'
+ureg.define("event = [Int64]")  # Define a custom unit 'events'
+ureg.define("sqrt_hertz = Hz**0.5")
+ureg.define("bit_bins = ![Int64]")
+
+class UnitMeta(type):
+    """
+    Metaclass that makes isinstance(x, SomeUnit) return True
+    when x is a pint.Quantity with the right dimensionality.
+    """
+    def __instancecheck__(cls, obj):
+        if not isinstance(obj, Quantity):
+            return False
+        expected = getattr(cls, "_expected_dim", None)
+        if expected is None:
+            return True
+        # Use pint's dimensionality check; accepts strings like "energy"
+        return obj.check(expected)
+
+    def __truediv__(cls, other):
+        if not (isinstance(other, UnitMeta) and issubclass(other, BaseUnit)):
+            return NotImplemented
+        num = cls.__name__
+        den = other.__name__
+        name = f"{num}Per{den}"
+        expected = f"{getattr(cls, '_expected_dim')}/{getattr(other, '_expected_dim')}"
+        # Create a new subclass that uses the same metaclass
+        return UnitMeta(name, (BaseUnit,), {"_expected_dim": expected})
+
+    # (Optional) multiplication, powers, etc., if you ever want them.
+    def __mul__(cls, other):
+        if not (isinstance(other, UnitMeta) and issubclass(other, BaseUnit)):
+            return NotImplemented
+        a = cls.__name__
+        b = other.__name__
+        name = f"{a}Times{b}"
+        expected = f"({getattr(cls, '_expected_dim')})*({getattr(other, '_expected_dim')})"
+        return UnitMeta(name, (BaseUnit,), {"_expected_dim": expected})
+
+    def __pow__(cls, power):
+        if not isinstance(power, int):
+            return NotImplemented
+        name = f"{cls.__name__}Pow{power}"
+        expected = f"({getattr(cls, '_expected_dim')})**{power}"
+        return UnitMeta(name, (BaseUnit,), {"_expected_dim": expected})
+
+class BaseUnit(metaclass=UnitMeta):
+    _expected_dim: str | None = None
+
+    @classmethod
+    def check(cls, value):
+        if cls._expected_dim is None:
+            return value
+        assert isinstance(value, Quantity), f"Expected a pint Quantity instance, got {type(value)}"
+        assert value.check(cls._expected_dim), f"Value units {value.dimensionality} do not match {cls.__name__} units"
+        return value
+
+class Energy(BaseUnit):
+    """Quantity specifically for energy units."""
+    _expected_dim = "joule"
+
+class Time(BaseUnit):
+    """Quantity specifically for time units."""
+    _expected_dim = "second"
+
+class Power(BaseUnit):
+    """Quantity specifically for power units."""
+    _expected_dim = "watt"
+
+class Voltage(BaseUnit):
+    """Quantity specifically for voltage units."""
+    _expected_dim = "volt"
+
+class Current(BaseUnit):
+    """Quantity specifically for current units."""
+    _expected_dim = "ampere"
+
+class Resistance(BaseUnit):
+    """Quantity specifically for resistance units."""
+    _expected_dim = "ohm"
+
+class Temperature(BaseUnit):
+    """Quantity specifically for temperature units."""
+    _expected_dim = "kelvin"
+
+class Length(BaseUnit):
+    """Quantity specifically for length units."""
+    _expected_dim = "meter"
+
+class Volume(BaseUnit):
+    """Quantity specifically for volume units."""
+    _expected_dim = "liter"
+
+class FlowRate(BaseUnit):
+    """Quantity specifically for flow rate units."""
+    _expected_dim = "liter / second"
+
+class Frequency(BaseUnit):
+    """Quantity specifically for frequency units."""
+    _expected_dim = "hertz"
+
+class Angle(BaseUnit):
+    """Quantity specifically for angle units."""
+    _expected_dim = "degree"
+
+class Mass(BaseUnit):
+    """Quantity specifically for mass units."""
+    _expected_dim = "kilogram"
+
+class RefractiveIndex(BaseUnit):
+    """Quantity specifically for refractive index units."""
+    _expected_dim = "refractive_index_units"
+
+class Dimensionless(BaseUnit):
+    """Quantity specifically for dimensionless units."""
+    _expected_dim = ""
+
+class Responsitivity(BaseUnit):
+    """Quantity specifically for responsitivity units."""
+    _expected_dim = "ampere / watt"
+
+class Viscosity(BaseUnit):
+    """Quantity specifically for viscosity units."""
+    _expected_dim = "pascal * second"
+
+class Area(BaseUnit):
+    """Quantity specifically for viscosity units."""
+    _expected_dim = "meter * meter"
+
+class ElectricField(BaseUnit):
+    """Quantity specifically for electric field units."""
+    _expected_dim = "volt / meter"
+
+class Velocity(BaseUnit):
+    """Quantity specifically for velocity units."""
+    _expected_dim = "meter / second"
+
+class Ohm(BaseUnit):
+    """Quantity specifically for resistance units."""
+    _expected_dim = "ohm"
+
+class Concentration(BaseUnit):
+    """Quantity specifically for concentration units."""
+    _expected_dim = "particle / liter"
+
+class Particle(BaseUnit):
+    """Quantity specifically for particle units."""
+    _expected_dim = "particle"
+
+class ParticleFlux(BaseUnit):
+    """Quantity specifically for particle flux units."""
+    _expected_dim = "particle / second"
+
+class Any(BaseUnit):
+    """Quantity that can have any unit."""
+    _expected_dim = None  # Accept any dimensionality
+
+class AnyUnit(BaseUnit):
+    """Quantity that can have any unit."""
+    _expected_dim = None  # Accept any dimensionality
+
+ureg.AU = ureg.dimensionless
+
+
+
+
+
+
+
+
+
+
+
+# from pydantic.dataclasses import dataclass
+
+# config_dict = dict(
+#     arbitrary_types_allowed=True,
+#     kw_only=True,
+#     slots=True,
+#     extra='forbid'
+# )
+
+
+
+
+# @dataclass(config=config_dict)
+# class Sphere():
+#     name: str
+#     refractive_index: RefractiveIndex
+#     diameter: Length
+#     particle_count: Particle
+
+
+# test = Sphere(
+#     name="Test Sphere",
+#     refractive_index=1 * ureg.refractive_index_units,
+#     diameter=1 * ureg.meter,
+#     particle_count=1 * 5e9 * ureg.particle / ureg.milliliter
+# )
+
+# print(test)

{typedunit-0.0.3 → typedunit-0.0.5}/TypedUnit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypedUnit
-Version: 0.0.3
+Version: 0.0.5
 Summary: A package wrapping pint for handling typed units in Python.
 Author-email: Martin Poinsinet de Sivry-Houle <martin.poinsinet.de.sivry@gmail.com>
 License: MIT License

typedunit-0.0.3/TypedUnit/helper.py

@@ -1,20 +0,0 @@
-from TypedUnit.units import BaseUnit
-
-from typing import get_type_hints
-
-def validate_units(function):
-    def wrapper(*args, **kwargs):
-        hints = get_type_hints(function)
-
-        for arg, hint in zip(args, hints.values()):
-            if isinstance(hint, BaseUnit):
-                hint.check(arg)
-
-        for kwarg_name, kwarg_value in kwargs.items():
-            if kwarg_name in hints:
-                hint = hints[kwarg_name]
-                if issubclass(hint, BaseUnit):
-                    hint.check(kwarg_value)
-
-        return function(*args, **kwargs)
-    return wrapper

typedunit-0.0.3/TypedUnit/units.py

@@ -1,106 +0,0 @@
-# Initialize a unit registry
-from pint import Quantity, UnitRegistry
-
-ureg = UnitRegistry()
-
-# _scaled_units_str_list = [
-#     'watt', 'volt', 'meter', 'second', 'liter', 'hertz', 'ohm', 'ampere', 'joule', 'coulomb', 'kelvin', 'celsius', 'degree', 'particle'
-# ]
-
-# for _units_str in _scaled_units_str_list:
-#     for scale in ['femto', 'pico', 'nano', 'micro', 'milli', '', 'kilo', 'mega']:
-#         _unit = scale + _units_str
-#         globals()[_unit] = getattr(ureg, _unit)
-
-
-ureg.define("photoelectron = [Float64]")  # Define a custom unit 'photoelectron'
-ureg.define("event = [Int64]")  # Define a custom unit 'events'
-ureg.define("sqrt_hertz = Hz**0.5")
-ureg.define("bit_bins = ![Int64]")
-
-class UnitMeta(type):
-    """
-    Metaclass that makes isinstance(x, SomeUnit) return True
-    when x is a pint.Quantity with the right dimensionality.
-    """
-    def __instancecheck__(cls, obj):
-        if not isinstance(obj, Quantity):
-            return False
-        expected = getattr(cls, "_expected_dim", None)
-        if expected is None:
-            return False
-        # Use pint's dimensionality check; accepts strings like "energy"
-        return obj.check(expected)
-
-class BaseUnit(metaclass=UnitMeta):
-    _expected_dim: str | None = None
-
-    @classmethod
-    def check(cls, value):
-        assert isinstance(value, Quantity), f"Expected a pint Quantity instance, got {type(value)}"
-        assert value.check(cls._expected_dim), f"Value units {value.dimensionality} do not match {cls.__name__} units"
-        return value
-
-
-class Energy(BaseUnit):
-    """Quantity specifically for energy units."""
-    _expected_dim = "joule"
-
-class Time(BaseUnit):
-    """Quantity specifically for time units."""
-    _expected_dim = "second"
-
-class Power(BaseUnit):
-    """Quantity specifically for power units."""
-    _expected_dim = "watt"
-
-class Voltage(BaseUnit):
-    """Quantity specifically for voltage units."""
-    _expected_dim = "volt"
-
-class Current(BaseUnit):
-    """Quantity specifically for current units."""
-    _expected_dim = "ampere"
-
-class Resistance(BaseUnit):
-    """Quantity specifically for resistance units."""
-    _expected_dim = "ohm"
-
-class Temperature(BaseUnit):
-    """Quantity specifically for temperature units."""
-    _expected_dim = "kelvin"
-
-class Length(BaseUnit):
-    """Quantity specifically for length units."""
-    _expected_dim = "meter"
-
-class Volume(BaseUnit):
-    """Quantity specifically for volume units."""
-    _expected_dim = "liter"
-
-class FlowRate(BaseUnit):
-    """Quantity specifically for flow rate units."""
-    _expected_dim = "liter / second"
-
-class Frequency(BaseUnit):
-    """Quantity specifically for frequency units."""
-    _expected_dim = "hertz"
-
-class Angle(BaseUnit):
-    """Quantity specifically for angle units."""
-    _expected_dim = "degree"
-
-class Mass(BaseUnit):
-    """Quantity specifically for mass units."""
-    _expected_dim = "kilogram"
-
-class RefractiveIndex(BaseUnit):
-    """Quantity specifically for refractive index units."""
-    _expected_dim = "refractive_index_units"
-
-class Dimensionless(BaseUnit):
-    """Quantity specifically for dimensionless units."""
-    _expected_dim = ""
-
-
-