click-extended 1.0.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

click_extended/decorators/convert/convert_pressure.py

@@ -0,0 +1,131 @@
+"""Convert between different pressure units."""
+
+from decimal import Decimal, getcontext
+from typing import Any, Literal
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+getcontext().prec = 35
+
+UNITS = {
+    "Pa": Decimal("1"),
+    "kPa": Decimal("1000"),
+    "MPa": Decimal("1e6"),
+    "GPa": Decimal("1e9"),
+    "hPa": Decimal("100"),
+    "bar": Decimal("100000"),
+    "mbar": Decimal("100"),
+    "Ba": Decimal("0.1"),
+    "psi": Decimal("6894.757293168"),
+    "ksi": Decimal("6894757.293168"),
+    "psf": Decimal("47.88025898"),
+    "mmHg": Decimal("133.322387415"),
+    "inHg": Decimal("3386.388666666"),
+    "mmH2O": Decimal("9.80665"),
+    "inH2O": Decimal("249.08891"),
+    "atm": Decimal("101325"),
+    "at": Decimal("98066.5"),
+    "torr": Decimal("133.322368421"),
+}
+
+
+class ConvertPressure(ChildNode):
+    """Convert between different pressure units."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> float:
+        from_unit = kwargs["from_unit"]
+        to_unit = kwargs["to_unit"]
+        val = Decimal(str(value))
+
+        if from_unit not in UNITS:
+            raise ValueError(f"Unknown unit '{from_unit}'")
+        if to_unit not in UNITS:
+            raise ValueError(f"Unknown unit '{to_unit}'")
+
+        pa = val * UNITS[from_unit]
+
+        return float(pa / UNITS[to_unit])
+
+
+def convert_pressure(
+    from_unit: Literal[
+        "Pa",
+        "kPa",
+        "MPa",
+        "GPa",
+        "bar",
+        "mbar",
+        "hPa",
+        "psi",
+        "ksi",
+        "psf",
+        "mmHg",
+        "inHg",
+        "mmH2O",
+        "inH2O",
+        "atm",
+        "at",
+        "torr",
+        "Ba",
+    ],
+    to_unit: Literal[
+        "Pa",
+        "kPa",
+        "MPa",
+        "GPa",
+        "bar",
+        "mbar",
+        "hPa",
+        "psi",
+        "ksi",
+        "psf",
+        "mmHg",
+        "inHg",
+        "mmH2O",
+        "inH2O",
+        "atm",
+        "at",
+        "torr",
+        "Ba",
+    ],
+) -> Decorator:
+    """
+    Convert between different pressure units.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Units:
+        - **Pa**: Pascal
+        - **kPa**: Kilopascal
+        - **MPa**: Megapascal
+        - **GPa**: Gigapascal
+        - **bar**: Bar
+        - **mbar**: Millibar
+        - **hPa**: Hectopascal
+        - **psi**: Pounds per square inch
+        - **ksi**: Kilopounds per square inch
+        - **psf**: Pounds per square foot
+        - **mmHg**: Millimeters of mercury
+        - **inHg**: Inches of mercury
+        - **mmH2O**: Millimeters of water
+        - **inH2O**: Inches of water
+        - **atm**: Standard atmosphere
+        - **at**: Technical atmosphere
+        - **torr**: Torr (1/760 atm)
+        - **Ba**: Barye (dyn/cm2)
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ConvertPressure.as_decorator(from_unit=from_unit, to_unit=to_unit)

click_extended/decorators/convert/convert_speed.py

@@ -0,0 +1,122 @@
+"""Convert between different speed units."""
+
+from decimal import Decimal, getcontext
+from typing import Any, Literal
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+getcontext().prec = 35
+
+UNITS = {
+    "mps": Decimal("1"),
+    "kmh": Decimal("1000") / Decimal("3600"),
+    "kmps": Decimal("1000"),
+    "cmps": Decimal("0.01"),
+    "mmps": Decimal("0.001"),
+    "kmday": Decimal("1000") / Decimal("86400"),
+    "mph": Decimal("1609.344") / Decimal("3600"),
+    "fps": Decimal("0.3048"),
+    "ftmin": Decimal("0.3048") / Decimal("60"),
+    "inps": Decimal("0.0254"),
+    "kn": Decimal("1852") / Decimal("3600"),
+    "kt": Decimal("1852") / Decimal("3600"),
+    "mach": Decimal("343"),
+    "c": Decimal("299792458"),
+    "auday": Decimal("149597870700") / Decimal("86400"),
+    "pcyr": Decimal("3.0856775814913673e16") / Decimal("31557600"),
+}
+
+
+class ConvertSpeed(ChildNode):
+    """Convert between different speed units."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> float:
+        from_unit = kwargs["from_unit"]
+        to_unit = kwargs["to_unit"]
+        val = Decimal(str(value))
+
+        if from_unit not in UNITS:
+            raise ValueError(f"Unknown unit '{from_unit}'")
+        if to_unit not in UNITS:
+            raise ValueError(f"Unknown unit '{to_unit}'")
+
+        mps = val * UNITS[from_unit]
+        return float(mps / UNITS[to_unit])
+
+
+def convert_speed(
+    from_unit: Literal[
+        "mps",
+        "kmh",
+        "kmps",
+        "cmps",
+        "mmps",
+        "mph",
+        "fps",
+        "ftmin",
+        "inps",
+        "kn",
+        "kt",
+        "mach",
+        "c",
+        "auday",
+        "kmday",
+        "pcyr",
+    ],
+    to_unit: Literal[
+        "mps",
+        "kmh",
+        "kmps",
+        "cmps",
+        "mmps",
+        "mph",
+        "fps",
+        "ftmin",
+        "inps",
+        "kn",
+        "kt",
+        "mach",
+        "c",
+        "auday",
+        "kmday",
+        "pcyr",
+    ],
+) -> Decorator:
+    """
+    Convert between different speed units.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Units:
+        - **mps**: Meters per second
+        - **kmh**: Kilometers per hour
+        - **kmps**: Kilometers per second
+        - **cmps**: Centimeters per second
+        - **mmps**: Millimeters per second
+        - **mph**: Miles per hour
+        - **fps**: Feet per second
+        - **ftmin**: Feet per minute
+        - **inps**: Inches per second
+        - **kn**: Knot
+        - **kt**: Knot
+        - **mach**: Mach number (ratio to speed of sound)
+        - **c**: Fraction of the speed of light
+        - **auday**: Astronomical units per day
+        - **kmday**: Kilometers per day
+        - **pcyr**: Parsecs per year
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ConvertSpeed.as_decorator(from_unit=from_unit, to_unit=to_unit)

click_extended/decorators/convert/convert_temperature.py

@@ -0,0 +1,89 @@
+"""Convert between temperature units."""
+
+from decimal import Decimal, getcontext
+from typing import Any, Literal
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+getcontext().prec = 28
+
+
+class ConvertTemperature(ChildNode):
+    """Convert between temperature units."""
+
+    def _to_celsius(self, value: float, unit: str) -> Decimal:
+        val = Decimal(str(value))
+        if unit == "C":
+            return val
+        if unit == "F":
+            return (val - 32) * Decimal("5") / Decimal("9")
+        if unit == "K":
+            return val - Decimal("273.15")
+        if unit == "R":
+            return (val - Decimal("491.67")) * Decimal("5") / Decimal("9")
+        if unit == "Re":
+            return val * Decimal("5") / Decimal("4")
+        if unit == "De":
+            return 100 - val * Decimal("2") / Decimal("3")
+        raise ValueError(f"Unknown unit '{unit}'")
+
+    def _from_celsius(self, value: Decimal, unit: str) -> Decimal:
+        if unit == "C":
+            return value
+        if unit == "F":
+            return (value * Decimal("9") / Decimal("5")) + 32
+        if unit == "K":
+            return value + Decimal("273.15")
+        if unit == "R":
+            return (value + Decimal("273.15")) * Decimal("9") / Decimal("5")
+        if unit == "Re":
+            return value * Decimal("4") / Decimal("5")
+        if unit == "De":
+            return (100 - value) * Decimal("3") / Decimal("2")
+        raise ValueError(f"Unknown unit '{unit}'")
+
+    def handle_numeric(
+        self, value: int | float, context: Context, *args: Any, **kwargs: Any
+    ) -> float:
+        celsius = self._to_celsius(value, kwargs["from_unit"])
+
+        if celsius < Decimal("-273.15"):
+            raise ValueError(
+                "Temperature cannot be below absolute zero (-273.15°C)."
+            )
+
+        return float(self._from_celsius(celsius, kwargs["to_unit"]))
+
+
+def convert_temperature(
+    from_unit: Literal["C", "F", "K", "R", "Re", "De"],
+    to_unit: Literal["C", "F", "K", "R", "Re", "De"],
+) -> Decorator:
+    """
+    Convert between temperature units.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Units:
+        - **C**: Celcius
+        - **F**: Fahrenheit
+        - **K**: Kelvin
+        - **R**: Rankine
+        - **Re**: Reaumur
+        - **De**: Delisle
+
+    Args:
+        from_unit (str):
+            The unit to convert from.
+        to_unit (str):
+            The unit to convert to.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ConvertTemperature.as_decorator(from_unit=from_unit, to_unit=to_unit)

click_extended/decorators/convert/convert_time.py

@@ -0,0 +1,108 @@
+"""Convert between time units."""
+
+import re
+from decimal import Decimal, getcontext
+from typing import Any, Literal
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+# Set precision high enough for time conversions
+getcontext().prec = 28
+
+UNITS = {
+    "ns": Decimal("1e-9"),
+    "us": Decimal("1e-6"),
+    "ms": Decimal("1e-3"),
+    "s": Decimal("1"),
+    "m": Decimal("60"),
+    "h": Decimal("3600"),
+    "d": Decimal("86400"),
+    "w": Decimal("604800"),
+    "M": Decimal("2592000"),
+    "y": Decimal("31536000"),
+}
+
+
+class ConvertTime(ChildNode):
+    """Convert between time units."""
+
+    def _convert(self, value: float, from_unit: str, to_unit: str) -> float:
+        if from_unit not in UNITS:
+            raise ValueError(f"Unknown unit '{from_unit}'")
+        if to_unit not in UNITS:
+            raise ValueError(f"Unknown unit '{to_unit}'")
+
+        val = Decimal(str(value))
+        seconds = val * UNITS[from_unit]
+        result = seconds / UNITS[to_unit]
+        return float(result)
+
+    def handle_str(
+        self, value: str, context: Context, *args: Any, **kwargs: Any
+    ) -> float:
+        to_unit = str(kwargs["to_unit"])
+        parts = re.findall(r"(\d+(?:\.\d+)?)\s*([a-zA-Z]+)", value)
+
+        if not parts:
+            try:
+                val = float(value)
+                from_unit = str(kwargs["from_unit"])
+                return self._convert(val, from_unit, to_unit)
+            except ValueError as e:
+                raise ValueError(
+                    f"Could not parse time string '{value}'."
+                ) from e
+
+        total_seconds = Decimal("0.0")
+        for val_str, unit in parts:
+            if unit not in UNITS:
+                raise ValueError(f"Unknown unit '{unit}' in string.")
+            total_seconds += Decimal(val_str) * UNITS[unit]
+
+        result = total_seconds / UNITS[to_unit]
+        return float(result)
+
+    def handle_numeric(
+        self, value: int | float, context: Context, *args: Any, **kwargs: Any
+    ) -> Any:
+        return self._convert(
+            float(value), kwargs["from_unit"], kwargs["to_unit"]
+        )
+
+
+def convert_time(
+    from_unit: Literal["ns", "us", "ms", "s", "m", "h", "d", "w", "M", "y"],
+    to_unit: Literal["ns", "us", "ms", "s", "m", "h", "d", "w", "M", "y"],
+) -> Decorator:
+    """
+    Convert between time units.
+
+    Type: `ChildNode`
+
+    Supports: `str`, `int`, `float`
+
+    Units:
+        - **ns**: Nanoseconds
+        - **us**: Microseconds
+        - **ms**: Milliseconds
+        - **s**: Seconds
+        - **m**: Minutes
+        - **h**: Hours
+        - **d**: Days
+        - **w**: Weeks
+        - **M**: Months
+        - **y**: Years
+
+    Args:
+        from_unit (str):
+            The unit to convert from.
+        to_unit (str):
+            The unit to convert to.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ConvertTime.as_decorator(from_unit=from_unit, to_unit=to_unit)

click_extended/decorators/convert/convert_volume.py

@@ -0,0 +1,218 @@
+"""Convert between various volume units."""
+
+from decimal import Decimal, getcontext
+from typing import Any, Literal
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+getcontext().prec = 35
+
+UNITS = {
+    "mm3": Decimal("1e-6"),
+    "cm3": Decimal("1e-3"),
+    "m3": Decimal("1000"),
+    "km3": Decimal("1e12"),
+    "mL": Decimal("1e-3"),
+    "cL": Decimal("1e-2"),
+    "dL": Decimal("1e-1"),
+    "L": Decimal("1"),
+    "kL": Decimal("1000"),
+    "ML": Decimal("1e6"),
+    "hL": Decimal("100"),
+    "cc": Decimal("1e-3"),
+    "in3": Decimal("0.016387064"),
+    "ft3": Decimal("28.316846592"),
+    "yd3": Decimal("764.554857984"),
+    "floz": Decimal("0.0295735295625"),
+    "cup": Decimal("0.2365882365"),
+    "pt": Decimal("0.473176473"),
+    "qt": Decimal("0.946352946"),
+    "gal": Decimal("3.785411784"),
+    "bbl": Decimal("119.240471196"),
+    "tsp": Decimal("0.00492892159375"),
+    "tbsp": Decimal("0.01478676478125"),
+    "gill": Decimal("0.11829411825"),
+    "drop": Decimal("0.00005"),
+    "dry_pt": Decimal("0.5506104713575"),
+    "dry_qt": Decimal("1.101220942715"),
+    "dry_gal": Decimal("4.40488377086"),
+    "pk": Decimal("8.80976754172"),
+    "bu": Decimal("35.23907016688"),
+    "imp_floz": Decimal("0.0284130625"),
+    "imp_pt": Decimal("0.56826125"),
+    "imp_qt": Decimal("1.1365225"),
+    "imp_gal": Decimal("4.54609"),
+    "imp_gill": Decimal("0.1420653125"),
+    "krm": Decimal("1e-3"),
+    "tsk": Decimal("5e-3"),
+    "msk": Decimal("15e-3"),
+    "firkin": Decimal("40.91481"),
+    "kilderkin": Decimal("81.82962"),
+}
+
+
+class ConvertVolume(ChildNode):
+    """Convert between various volume units."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> float:
+        from_unit = kwargs["from_unit"]
+        to_unit = kwargs["to_unit"]
+        val = Decimal(str(value))
+
+        if from_unit not in UNITS:
+            raise ValueError(f"Unknown unit '{from_unit}'")
+        if to_unit not in UNITS:
+            raise ValueError(f"Unknown unit '{to_unit}'")
+
+        liters = val * UNITS[from_unit]
+        return float(liters / UNITS[to_unit])
+
+
+def convert_volume(
+    from_unit: Literal[
+        "mm3",
+        "cm3",
+        "m3",
+        "km3",
+        "mL",
+        "cL",
+        "dL",
+        "L",
+        "kL",
+        "ML",
+        "hL",
+        "in3",
+        "ft3",
+        "yd3",
+        "floz",
+        "cup",
+        "pt",
+        "qt",
+        "gal",
+        "imp_floz",
+        "imp_pt",
+        "imp_qt",
+        "imp_gal",
+        "bbl",
+        "cc",
+        "tsp",
+        "tbsp",
+        "gill",
+        "drop",
+        "dry_pt",
+        "dry_qt",
+        "dry_gal",
+        "pk",
+        "bu",
+        "imp_gill",
+        "firkin",
+        "kilderkin",
+        "krm",
+        "tsk",
+        "msk",
+    ],
+    to_unit: Literal[
+        "mm3",
+        "cm3",
+        "m3",
+        "km3",
+        "mL",
+        "cL",
+        "dL",
+        "L",
+        "kL",
+        "ML",
+        "hL",
+        "in3",
+        "ft3",
+        "yd3",
+        "floz",
+        "cup",
+        "pt",
+        "qt",
+        "gal",
+        "imp_floz",
+        "imp_pt",
+        "imp_qt",
+        "imp_gal",
+        "bbl",
+        "cc",
+        "tsp",
+        "tbsp",
+        "gill",
+        "drop",
+        "dry_pt",
+        "dry_qt",
+        "dry_gal",
+        "pk",
+        "bu",
+        "imp_gill",
+        "firkin",
+        "kilderkin",
+        "krm",
+        "tsk",
+        "msk",
+    ],
+) -> Decorator:
+    """
+    Convert between various volume units.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Units:
+        - **mm3**: Cubic millimeter
+        - **cm3**: Cubic centimeter
+        - **m3**: Cubic meter
+        - **km3**: Cubic kilometer
+        - **mL**: Milliliter
+        - **cL**: Centiliter
+        - **dL**: Deciliter
+        - **L**: Liter
+        - **kL**: Kiloliter
+        - **ML**: Megaliter
+        - **hL**: Hectoliter
+        - **in3**: Cubic inch
+        - **ft3**: Cubic foot
+        - **yd3**: Cubic yard
+        - **floz**: US fluid ounce
+        - **cup**: US cup
+        - **pt**: US pint
+        - **qt**: US quart
+        - **gal**: US gallon
+        - **imp_floz**: Imperial fluid ounce
+        - **imp_pt**: Imperial pint
+        - **imp_qt**: Imperial quart
+        - **imp_gal**: Imperial gallon
+        - **bbl**: Barrel
+        - **cc**: Cubic centimeter
+        - **tsp**: Teaspoon
+        - **tbsp**: Tablespoon
+        - **gill**: US gill
+        - **drop**: Drop
+        - **dry_pt**: US dry pint
+        - **dry_qt**: US dry quart
+        - **dry_gal**: US dry gallon
+        - **pk**: Peck
+        - **bu**: Bushel
+        - **imp_gill**: Imperial gill
+        - **firkin**: Firkin (beer/brewing measure)
+        - **kilderkin**: Kilderkin (beer/brewing measure)
+        - **krm**: Kryddmått (1 ml)
+        - **tsk**: Tesked (5 ml)
+        - **msk**: Matsked (15 ml)
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ConvertVolume.as_decorator(from_unit=from_unit, to_unit=to_unit)