TypedUnit 0.0.7__tar.gz → 0.0.10__tar.gz

typedunit-0.0.10/.coveragerc

@@ -0,0 +1,22 @@
+# .coveragerc
+[run]
+source = TypedUnit
+branch = True
+relative_files = True
+parallel = True
+omit =
+    **/__init__.py
+    TypedUnit/_version.py
+    TypedUnit/directories.py
+    TypedUnit/**/__main__.py
+
+[report]
+skip_covered = True
+show_missing = True
+precision = 2
+
+[html]
+directory = htmlcov
+
+[xml]
+output = coverage.xml

{typedunit-0.0.7 → typedunit-0.0.10}/.github/dependabot.yml

@@ -6,6 +6,6 @@ updates:
     directory: "/"
     target-branch: "master"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
       day: "sunday"
       time: "09:00"

{typedunit-0.0.7 → typedunit-0.0.10}/.github/workflows/deploy_anaconda.yml

@@ -11,11 +11,11 @@ permissions:
     contents: write
 
 jobs:
-  ManyLinux_x86_64:
+  linux:
     uses: MartinPdeS/MPSActions/.github/workflows/publish_compiled_package_to_anaconda.yml@master
     with:
-      python-versions: '["3.11", "3.12", "3.13"]'
-      apt-package: ""
+      python_versions: '["3.11", "3.12", "3.13"]'
+      apt_package: ""
+      os_list: '["ubuntu-latest", "macos-latest", "windows-latest"]'
     secrets:
       ANACONDA_API_TOKEN: ${{ secrets.ANACONDA_API_TOKEN }}
-

typedunit-0.0.10/.gitignore

@@ -0,0 +1,35 @@
+
+# Ignore all
+/*
+
+# Except ...
+!.github
+!.gitmodules
+!extern
+!TypedUnit
+!development
+!docs
+!tests
+!.flake8
+!.gitignore
+!.pre-commit-config.yaml
+!LICENSE
+!meta.yaml
+!pyproject.toml
+!README.rst
+!notebook.ipynb
+!CMakeLists.txt
+!pytest.ini
+!.coveragerc
+
+# But ignore docs/build inside docs and code
+docs/build/
+docs/source/gallery/
+
+# Compiled files in the project
+*__pycache__*
+*.DS_Store*
+*.so*
+*.a*
+
+# Package specifics

typedunit-0.0.10/.pre-commit-config.yaml

@@ -0,0 +1,17 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.6.0
+    hooks:
+      - id: check-merge-conflict
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+      - id: check-yaml
+      - id: check-toml
+      - id: detect-private-key
+      - id: check-json
+      - id: check-case-conflict
+
+  - repo: https://github.com/psf/black
+    rev: 24.4.2
+    hooks:
+      - id: black

{typedunit-0.0.7 → typedunit-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypedUnit
-Version: 0.0.7
+Version: 0.0.10
 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.10/TypedUnit/__init__.py

@@ -0,0 +1,9 @@
+try:
+    from ._version import version as __version__  # noqa: F401
+
+except ImportError:
+    __version__ = "0.0.0"
+
+from TypedUnit.units import *
+from TypedUnit.helper import validate_units
+from TypedUnit.units import ureg, Quantity

{typedunit-0.0.7 → typedunit-0.0.10}/TypedUnit/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.7'
-__version_tuple__ = version_tuple = (0, 0, 7)
+__version__ = version = '0.0.10'
+__version_tuple__ = version_tuple = (0, 0, 10)
 
-__commit_id__ = commit_id = 'gdd1c6b1a7'
+__commit_id__ = commit_id = 'g159a86b15'

{typedunit-0.0.7 → typedunit-0.0.10}/TypedUnit/units.py

@@ -3,7 +3,7 @@ import pint as _pint
 from pint import Quantity, UnitRegistry
 import pint_pandas as pint
 
-ureg = UnitRegistry()
+ureg = UnitRegistry(autoconvert_offset_to_baseunit=True)
 ureg.setup_matplotlib()
 
 _pint.set_application_registry(ureg)
@@ -12,12 +12,44 @@ 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]")
+ureg.define("dB_per_Hz = dB / hertz")
+
+
+__all__ = [
+    "Energy",
+    "Time",
+    "Power",
+    "Voltage",
+    "Current",
+    "Resistance",
+    "Temperature",
+    "Length",
+    "Volume",
+    "FlowRate",
+    "Frequency",
+    "Angle",
+    "Mass",
+    "RefractiveIndex",
+    "Dimensionless",
+    "Responsitivity",
+    "Viscosity",
+    "Area",
+    "ElectricField",
+    "Velocity",
+    "Ohm",
+    "Concentration",
+    "Particle",
+    "ParticleFlux",
+    "AnyUnit",
+]
+
 
 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
@@ -44,7 +76,9 @@ class UnitMeta(type):
         a = cls.__name__
         b = other.__name__
         name = f"{a}Times{b}"
-        expected = f"({getattr(cls, '_expected_dim')})*({getattr(other, '_expected_dim')})"
+        expected = (
+            f"({getattr(cls, '_expected_dim')})*({getattr(other, '_expected_dim')})"
+        )
         return UnitMeta(name, (BaseUnit,), {"_expected_dim": expected})
 
     def __pow__(cls, power):
@@ -54,6 +88,7 @@ class UnitMeta(type):
         expected = f"({getattr(cls, '_expected_dim')})**{power}"
         return UnitMeta(name, (BaseUnit,), {"_expected_dim": expected})
 
+
 class BaseUnit(metaclass=UnitMeta):
     _expected_dim: str | None = None
 
@@ -61,151 +96,163 @@ class BaseUnit(metaclass=UnitMeta):
     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"
+        assert isinstance(
+            value, Quantity
+        ), f"Expected a pint Quantity [{cls._expected_dim}] 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
 
+    _expected_dim = None  # Accept any dimensionality
 
-# 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)
+ureg.AU = ureg.dimensionless

{typedunit-0.0.7 → typedunit-0.0.10}/TypedUnit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: TypedUnit
-Version: 0.0.7
+Version: 0.0.10
 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.7 → typedunit-0.0.10}/TypedUnit.egg-info/SOURCES.txt

@@ -1,9 +1,12 @@
+.coveragerc
 .flake8
 .gitignore
+.pre-commit-config.yaml
 LICENSE
 README.rst
 meta.yaml
 pyproject.toml
+pytest.ini
 .github/dependabot.yml
 .github/workflows/deploy_PyPi.yml
 .github/workflows/deploy_anaconda.yml
@@ -34,6 +37,5 @@ docs/source/sg_execution_times.rst
 docs/source/theory.rst
 docs/source/_static/default.css
 docs/source/_static/thumbnail.png
-docs/source/gallery/index.rst
 tests/__init__.py
 tests/test_0.py

{typedunit-0.0.7 → typedunit-0.0.10}/pyproject.toml

@@ -61,27 +61,3 @@ documentation = [
     "sphinx-rtd-theme >=2,<4",
     "pydata-sphinx-theme ~=0.15"
 ]
-
-[tool.pytest.ini_options]
-minversion = "6.0"
-xfail_strict = true
-log_cli_level = "INFO"
-testpaths = ["tests"]
-addopts = [
-    '-v',
-    '-rA',
-    '-rw',
-    '--cov=TypedUnit',
-    '--cov-report=html',
-    "--cov-report=term"
-]
-
-[tool.coverage.run]
-source = ['TypedUnit']
-omit = [
-    '*\__init__.py',
-    '*/_version.py',
-    '*/directories.py',
-]
-branch = true
-relative_files = true

typedunit-0.0.10/pytest.ini

@@ -0,0 +1,21 @@
+# pytest.ini
+[pytest]
+minversion = 6.0
+xfail_strict = true
+log_cli_level = INFO
+
+addopts =
+    -vv
+    -rA
+    -rw
+    --cov
+    --cov-report=html
+    --cov-report=term
+    --cov-config=.coveragerc
+    --capture=tee-sys
+
+testpaths = tests
+
+python_files = *.py
+python_classes = Test_*
+python_functions = test_*

{typedunit-0.0.7 → typedunit-0.0.10}/tests/test_0.py

@@ -16,96 +16,123 @@ import numpy
 
 # Import the TypedUnits components
 from TypedUnit import (
-    Energy, Time, Power, Voltage, Current, Resistance,
-    Temperature, Length, Volume, FlowRate, Frequency, Mass,
-    Angle, RefractiveIndex, Dimensionless,
-    ureg, Quantity, validate_units
+    Energy,
+    Time,
+    Power,
+    Voltage,
+    Current,
+    Resistance,
+    Temperature,
+    Length,
+    Volume,
+    FlowRate,
+    Frequency,
+    Mass,
+    Angle,
+    RefractiveIndex,
+    Dimensionless,
+    ureg,
+    Quantity,
+    validate_units,
 )
 
 
 # Test data for parametrized tests
-@pytest.mark.parametrize("quantity,unit_type,expected", [
-    # Energy tests
-    (100 * ureg.joule, Energy, True),
-    (1.5 * ureg.kilowatt_hour, Energy, True),
-    (250 * ureg.calorie, Energy, True),
-    (10 * ureg.second, Energy, False),  # Time, not Energy
-    (5 * ureg.meter, Energy, False),   # Length, not Energy
-
-    # Time tests
-    (30 * ureg.second, Time, True),
-    (5 * ureg.minute, Time, True),
-    (2 * ureg.hour, Time, True),
-    (500 * ureg.millisecond, Time, True),
-    (100 * ureg.joule, Time, False),   # Energy, not Time
-
-    # Power tests
-    (1500 * ureg.watt, Power, True),
-    (2.5 * ureg.kilowatt, Power, True),
-    (1 * ureg.horsepower, Power, True),
-    (12 * ureg.volt, Power, False),    # Voltage, not Power
-
-    # Electrical units
-    (12 * ureg.volt, Voltage, True),
-    (2.5 * ureg.ampere, Current, True),
-    (4.8 * ureg.ohm, Resistance, True),
-    (12 * ureg.volt, Current, False),  # Cross-check
-    (2.5 * ureg.ampere, Resistance, False),
-
-    # Mechanical units
-    (10 * ureg.meter, Length, True),
-    (50 * ureg.millimeter, Length, True),
-    (2 * ureg.kilometer, Length, True),
-    (5 * ureg.liter, Volume, True),
-    (250 * ureg.milliliter, Volume, True),
-    (10 * ureg.meter, Volume, False),  # Length, not Volume
-
-    # Temperature tests
-    (300 * ureg.kelvin, Temperature, True),
-    (77 * ureg.kelvin, Temperature, True),
-    # (50 * ureg.hertz, Temperature, False),
-
-    # # Frequency and angle
-    (50 * ureg.hertz, Frequency, True),
-    (1.57 * ureg.radian, Angle, True),
-
-    # Other tests
-    (1 * ureg.RIU, RefractiveIndex, True),
-    (1 * ureg.dimensionless, Dimensionless, True),
-    (1 * ureg.gram, Mass, True)
-])
+@pytest.mark.parametrize(
+    "quantity,unit_type,expected",
+    [
+        # Energy tests
+        (100 * ureg.joule, Energy, True),
+        (1.5 * ureg.kilowatt_hour, Energy, True),
+        (250 * ureg.calorie, Energy, True),
+        (10 * ureg.second, Energy, False),  # Time, not Energy
+        (5 * ureg.meter, Energy, False),  # Length, not Energy
+        # Time tests
+        (30 * ureg.second, Time, True),
+        (5 * ureg.minute, Time, True),
+        (2 * ureg.hour, Time, True),
+        (500 * ureg.millisecond, Time, True),
+        (100 * ureg.joule, Time, False),  # Energy, not Time
+        # Power tests
+        (1500 * ureg.watt, Power, True),
+        (2.5 * ureg.kilowatt, Power, True),
+        (1 * ureg.horsepower, Power, True),
+        (12 * ureg.volt, Power, False),  # Voltage, not Power
+        # Electrical units
+        (12 * ureg.volt, Voltage, True),
+        (2.5 * ureg.ampere, Current, True),
+        (4.8 * ureg.ohm, Resistance, True),
+        (12 * ureg.volt, Current, False),  # Cross-check
+        (2.5 * ureg.ampere, Resistance, False),
+        # Mechanical units
+        (10 * ureg.meter, Length, True),
+        (50 * ureg.millimeter, Length, True),
+        (2 * ureg.kilometer, Length, True),
+        (5 * ureg.liter, Volume, True),
+        (250 * ureg.milliliter, Volume, True),
+        (10 * ureg.meter, Volume, False),  # Length, not Volume
+        # Temperature tests
+        (300 * ureg.kelvin, Temperature, True),
+        (77 * ureg.kelvin, Temperature, True),
+        # (50 * ureg.hertz, Temperature, False),
+        # # Frequency and angle
+        (50 * ureg.hertz, Frequency, True),
+        (1.57 * ureg.radian, Angle, True),
+        # Other tests
+        (1 * ureg.RIU, RefractiveIndex, True),
+        (1 * ureg.dimensionless, Dimensionless, True),
+        (1 * ureg.gram, Mass, True),
+    ],
+)
 def test_unit_type_checking(quantity, unit_type, expected):
     """Test isinstance() functionality for all unit types."""
     assert isinstance(quantity, unit_type) == expected
 
 
-@pytest.mark.parametrize("non_quantity", [
-    42,           # int
-    3.14,         # float
-    "10 meters",  # string
-    [1, 2, 3],    # list
-    {'value': 10}, # dict
-    None,         # None
-])
+@pytest.mark.parametrize(
+    "non_quantity",
+    [
+        42,  # int
+        3.14,  # float
+        "10 meters",  # string
+        [1, 2, 3],  # list
+        {"value": 10},  # dict
+        None,  # None
+    ],
+)
 def test_non_quantity_objects_rejected(non_quantity):
     """Test that non-Quantity objects are properly rejected by all unit types."""
-    unit_types = [Energy, Time, Power, Voltage, Current, Resistance,
-                  Temperature, Length, Volume, Frequency, Angle]
+    unit_types = [
+        Energy,
+        Time,
+        Power,
+        Voltage,
+        Current,
+        Resistance,
+        Temperature,
+        Length,
+        Volume,
+        Frequency,
+        Angle,
+    ]
 
     for unit_type in unit_types:
         assert not isinstance(non_quantity, unit_type)
 
 
-@pytest.mark.parametrize("unit_type,valid_quantity,invalid_quantity", [
-    (Energy, 100 * ureg.joule, 10 * ureg.meter),
-    (Time, 30 * ureg.second, 100 * ureg.joule),
-    (Power, 1500 * ureg.watt, 10 * ureg.meter),
-    (Voltage, 12 * ureg.volt, 5 * ureg.ampere),
-    (Current, 2.5 * ureg.ampere, 12 * ureg.volt),
-    (Resistance, 4.8 * ureg.ohm, 100 * ureg.joule),
-    (Length, 100 * ureg.meter, 50 * ureg.joule),
-    (Temperature, 300 * ureg.kelvin, 2.5 * ureg.ampere),
-])
+@pytest.mark.parametrize(
+    "unit_type,valid_quantity,invalid_quantity",
+    [
+        (Energy, 100 * ureg.joule, 10 * ureg.meter),
+        (Time, 30 * ureg.second, 100 * ureg.joule),
+        (Power, 1500 * ureg.watt, 10 * ureg.meter),
+        (Voltage, 12 * ureg.volt, 5 * ureg.ampere),
+        (Current, 2.5 * ureg.ampere, 12 * ureg.volt),
+        (Resistance, 4.8 * ureg.ohm, 100 * ureg.joule),
+        (Length, 100 * ureg.meter, 50 * ureg.joule),
+        (Temperature, 300 * ureg.kelvin, 2.5 * ureg.ampere),
+    ],
+)
 def test_unit_check_methods(unit_type, valid_quantity, invalid_quantity):
     """Test the check() methods for various unit types."""
     # Valid quantity should pass
@@ -116,48 +143,60 @@ def test_unit_check_methods(unit_type, valid_quantity, invalid_quantity):
         unit_type.check(invalid_quantity)
 
 
-@pytest.mark.parametrize("invalid_input", [
-    42,
-    3.14,
-    "not a quantity",
-    None,
-    [1, 2, 3],
-])
+@pytest.mark.parametrize(
+    "invalid_input",
+    [
+        42,
+        3.14,
+        "not a quantity",
+        None,
+        [1, 2, 3],
+    ],
+)
 def test_check_method_rejects_non_quantities(invalid_input):
     """Test that check() methods reject non-Quantity objects."""
-    with pytest.raises(AssertionError, match="Expected a pint Quantity instance"):
+    with pytest.raises(AssertionError, match="Expected a pint Quantity"):
         Energy.check(invalid_input)
 
 
-@pytest.mark.parametrize("energy_quantity", [
-    100 * ureg.joule,
-    1.5 * ureg.kilowatt_hour,
-    250 * ureg.calorie,
-    500 * ureg.british_thermal_unit,
-])
+@pytest.mark.parametrize(
+    "energy_quantity",
+    [
+        100 * ureg.joule,
+        1.5 * ureg.kilowatt_hour,
+        250 * ureg.calorie,
+        500 * ureg.british_thermal_unit,
+    ],
+)
 def test_energy_type_checking_various_units(energy_quantity):
     """Test Energy type checking with various energy units."""
     assert isinstance(energy_quantity, Energy)
 
 
-@pytest.mark.parametrize("time_quantity", [
-    30 * ureg.second,
-    5 * ureg.minute,
-    2 * ureg.hour,
-    500 * ureg.millisecond,
-    0.1 * ureg.microsecond,
-])
+@pytest.mark.parametrize(
+    "time_quantity",
+    [
+        30 * ureg.second,
+        5 * ureg.minute,
+        2 * ureg.hour,
+        500 * ureg.millisecond,
+        0.1 * ureg.microsecond,
+    ],
+)
 def test_time_type_checking_various_units(time_quantity):
     """Test Time type checking with various time units."""
     assert isinstance(time_quantity, Time)
 
 
-@pytest.mark.parametrize("power_quantity", [
-    1500 * ureg.watt,
-    2.5 * ureg.kilowatt,
-    1 * ureg.horsepower,
-    100 * ureg.milliwatt,
-])
+@pytest.mark.parametrize(
+    "power_quantity",
+    [
+        1500 * ureg.watt,
+        2.5 * ureg.kilowatt,
+        1 * ureg.horsepower,
+        100 * ureg.milliwatt,
+    ],
+)
 def test_power_type_checking_various_units(power_quantity):
     """Test Power type checking with various power units."""
     assert isinstance(power_quantity, Power)
@@ -191,32 +230,41 @@ def test_mechanical_units_cross_checking():
     assert not isinstance(volume, Length)
 
 
-@pytest.mark.parametrize("temperature_quantity", [
-    300 * ureg.kelvin,
-    # 25 * ureg.celsius,
-    # 77 * ureg.fahrenheit,
-])
+@pytest.mark.parametrize(
+    "temperature_quantity",
+    [
+        300 * ureg.kelvin,
+        # 25 * ureg.celsius,
+        # 77 * ureg.fahrenheit,
+    ],
+)
 def test_temperature_type_checking_various_units(temperature_quantity):
     """Test temperature type checking with various units."""
     assert isinstance(temperature_quantity, Temperature)
 
 
-@pytest.mark.parametrize("frequency_quantity", [
-    50 * ureg.hertz,
-    2.4 * ureg.kilohertz,
-    1.0 * ureg.megahertz,
-])
+@pytest.mark.parametrize(
+    "frequency_quantity",
+    [
+        50 * ureg.hertz,
+        2.4 * ureg.kilohertz,
+        1.0 * ureg.megahertz,
+    ],
+)
 def test_frequency_type_checking_various_units(frequency_quantity):
     """Test frequency type checking with various units."""
     assert isinstance(frequency_quantity, Frequency)
 
 
-@pytest.mark.parametrize("angle_quantity", [
-    45 * ureg.degree,
-    1.57 * ureg.radian,
-    90 * ureg.degree,
-    3.14159 * ureg.radian,
-])
+@pytest.mark.parametrize(
+    "angle_quantity",
+    [
+        45 * ureg.degree,
+        1.57 * ureg.radian,
+        90 * ureg.degree,
+        3.14159 * ureg.radian,
+    ],
+)
 def test_angle_type_checking_various_units(angle_quantity):
     """Test angle type checking with various units."""
     assert isinstance(angle_quantity, Angle)
@@ -298,11 +346,14 @@ def test_no_annotation_parameters_validation():
     assert isinstance(result, Quantity)
 
 
-@pytest.mark.parametrize("energy_quantity", [
-    1000 * ureg.joule,
-    1.5 * ureg.kilowatt_hour,
-    250 * ureg.calorie,
-])
+@pytest.mark.parametrize(
+    "energy_quantity",
+    [
+        1000 * ureg.joule,
+        1.5 * ureg.kilowatt_hour,
+        250 * ureg.calorie,
+    ],
+)
 def test_energy_conversions(energy_quantity):
     """Test energy unit conversions preserve type checking."""
     # Convert to different energy units
@@ -352,13 +403,10 @@ def test_unit_arithmetic_cross_types():
     assert isinstance(energy, Energy)
 
 
-@pytest.mark.parametrize("invalid_input", [
-    None,
-    42,
-    "10 joules",
-    [100, ureg.joule],
-    {'value': 100, 'unit': 'joule'}
-])
+@pytest.mark.parametrize(
+    "invalid_input",
+    [None, 42, "10 joules", [100, ureg.joule], {"value": 100, "unit": "joule"}],
+)
 def test_invalid_quantity_detection(invalid_input):
     """Test detection of invalid quantities."""
     assert not isinstance(invalid_input, Energy)
@@ -410,15 +458,20 @@ def test_physics_calculations_integration():
 
     # Verify the calculation
     assert power.magnitude == 60  # 12V * 5A = 60W
-    assert numpy.isclose(work.to(ureg.kilowatt_hour).magnitude, 0.06)  # 60W * 1h = 0.06 kWh
-
-
-@pytest.mark.parametrize("length_quantity", [
-    100 * ureg.meter,
-    50 * ureg.millimeter,
-    2 * ureg.kilometer,
-    328 * ureg.foot,  # Imperial if supported
-])
+    assert numpy.isclose(
+        work.to(ureg.kilowatt_hour).magnitude, 0.06
+    )  # 60W * 1h = 0.06 kWh
+
+
+@pytest.mark.parametrize(
+    "length_quantity",
+    [
+        100 * ureg.meter,
+        50 * ureg.millimeter,
+        2 * ureg.kilometer,
+        328 * ureg.foot,  # Imperial if supported
+    ],
+)
 def test_multiple_unit_systems(length_quantity):
     """Test working with multiple unit systems."""
     assert isinstance(length_quantity, Length)

typedunit-0.0.7/.gitignore

@@ -1,28 +0,0 @@
-# General patterns
-*.DS_store
-*.ipynb_checkpoints*
-*__pycache__*
-*.so
-*.a
-.coverage*
-*.pytest_cache
-htmlcov
-dist
-build
-*.egg*
-*.whl
-CMakeCache.txt
-CMakeFiles
-install_manifest.txt
-cmake_install.cmake
-wheelhouse
-
-# Docs-specific patterns
-docs/source/gallery/*
-!docs/source/gallery/index.rst
-PyOptik/data/**/test*
-PyOptik/data/**/example*
-
-# Override for documentation_build
-!documentation_build
-!documentation_build/**

typedunit-0.0.7/TypedUnit/__init__.py

@@ -1,9 +0,0 @@
-try:
-    from ._version import version as __version__  # noqa: F401
-
-except ImportError:
-    __version__ = "0.0.0"
-
-
-from .units import *
-from .helper import validate_units

typedunit-0.0.7/docs/source/gallery/index.rst

@@ -1,71 +0,0 @@
-:orphan:
-
-.. _examples_gallery:
-
-Coding examples
-===============
-
-Explore our gallery of examples demonstrating the usage of TypedUnits.
-
-
-
-.. raw:: html
-
-    <div class="sphx-glr-thumbnails">
-
-.. thumbnail-parent-div-open
-
-.. raw:: html
-
-    <div class="sphx-glr-thumbcontainer" tooltip="Workflow - 0">
-
-.. only:: html
-
-  .. image:: /gallery/images/thumb/sphx_glr_example_0_thumb.png
-    :alt:
-
-  :ref:`sphx_glr_gallery_example_0.py`
-
-.. raw:: html
-
-      <div class="sphx-glr-thumbnail-title">Workflow - 0</div>
-    </div>
-
-
-.. raw:: html
-
-    <div class="sphx-glr-thumbcontainer" tooltip="Workflow - 1">
-
-.. only:: html
-
-  .. image:: /gallery/images/thumb/sphx_glr_example_1_thumb.png
-    :alt:
-
-  :ref:`sphx_glr_gallery_example_1.py`
-
-.. raw:: html
-
-      <div class="sphx-glr-thumbnail-title">Workflow - 1</div>
-    </div>
-
-
-.. thumbnail-parent-div-close
-
-.. raw:: html
-
-    </div>
-
-
-.. toctree::
-   :hidden:
-
-   /gallery/example_0
-   /gallery/example_1
-
-
-
-.. only:: html
-
- .. rst-class:: sphx-glr-signature
-
-    `Gallery generated by Sphinx-Gallery <https://sphinx-gallery.github.io>`_