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

click_extended/decorators/convert/convert_bits.py

@@ -0,0 +1,211 @@
+"""Convert between different bit/byte 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 = {
+    "B": Decimal("1"),
+    "kB": Decimal("1000"),
+    "MB": Decimal("1000") ** 2,
+    "GB": Decimal("1000") ** 3,
+    "TB": Decimal("1000") ** 4,
+    "PB": Decimal("1000") ** 5,
+    "EB": Decimal("1000") ** 6,
+    "ZB": Decimal("1000") ** 7,
+    "YB": Decimal("1000") ** 8,
+    "RB": Decimal("1000") ** 9,
+    "QB": Decimal("1000") ** 10,
+    "KiB": Decimal("1024"),
+    "MiB": Decimal("1024") ** 2,
+    "GiB": Decimal("1024") ** 3,
+    "TiB": Decimal("1024") ** 4,
+    "PiB": Decimal("1024") ** 5,
+    "EiB": Decimal("1024") ** 6,
+    "ZiB": Decimal("1024") ** 7,
+    "YiB": Decimal("1024") ** 8,
+    # Bit units
+    "b": Decimal("0.125"),
+    "kb": Decimal("1000") * Decimal("0.125"),
+    "Mb": Decimal("1000") ** 2 * Decimal("0.125"),
+    "Gb": Decimal("1000") ** 3 * Decimal("0.125"),
+    "Tb": Decimal("1000") ** 4 * Decimal("0.125"),
+    "Pb": Decimal("1000") ** 5 * Decimal("0.125"),
+    "Eb": Decimal("1000") ** 6 * Decimal("0.125"),
+    "Zb": Decimal("1000") ** 7 * Decimal("0.125"),
+    "Yb": Decimal("1000") ** 8 * Decimal("0.125"),
+    "Rb": Decimal("1000") ** 9 * Decimal("0.125"),
+    "Qb": Decimal("1000") ** 10 * Decimal("0.125"),
+    "Kib": Decimal("1024") * Decimal("0.125"),
+    "Mib": Decimal("1024") ** 2 * Decimal("0.125"),
+    "Gib": Decimal("1024") ** 3 * Decimal("0.125"),
+    "Tib": Decimal("1024") ** 4 * Decimal("0.125"),
+    "Pib": Decimal("1024") ** 5 * Decimal("0.125"),
+    "Eib": Decimal("1024") ** 6 * Decimal("0.125"),
+    "Zib": Decimal("1024") ** 7 * Decimal("0.125"),
+    "Yib": Decimal("1024") ** 8 * Decimal("0.125"),
+}
+
+
+class ConvertBits(ChildNode):
+    """Convert between different bit/byte 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}'")
+
+        bytes_val = val * UNITS[from_unit]
+        return float(bytes_val / UNITS[to_unit])
+
+
+def convert_bits(
+    from_unit: Literal[
+        "B",
+        "kB",
+        "MB",
+        "GB",
+        "TB",
+        "PB",
+        "EB",
+        "ZB",
+        "YB",
+        "RB",
+        "QB",
+        "KiB",
+        "MiB",
+        "GiB",
+        "TiB",
+        "PiB",
+        "EiB",
+        "ZiB",
+        "YiB",
+        "b",
+        "kb",
+        "Mb",
+        "Gb",
+        "Tb",
+        "Pb",
+        "Eb",
+        "Zb",
+        "Yb",
+        "Rb",
+        "Qb",
+        "Kib",
+        "Mib",
+        "Gib",
+        "Tib",
+        "Pib",
+        "Eib",
+        "Zib",
+        "Yib",
+    ],
+    to_unit: Literal[
+        "B",
+        "kB",
+        "MB",
+        "GB",
+        "TB",
+        "PB",
+        "EB",
+        "ZB",
+        "YB",
+        "RB",
+        "QB",
+        "KiB",
+        "MiB",
+        "GiB",
+        "TiB",
+        "PiB",
+        "EiB",
+        "ZiB",
+        "YiB",
+        "b",
+        "kb",
+        "Mb",
+        "Gb",
+        "Tb",
+        "Pb",
+        "Eb",
+        "Zb",
+        "Yb",
+        "Rb",
+        "Qb",
+        "Kib",
+        "Mib",
+        "Gib",
+        "Tib",
+        "Pib",
+        "Eib",
+        "Zib",
+        "Yib",
+    ],
+) -> Decorator:
+    """
+    Convert between different bit/byte units.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Units:
+        - **B**: Bytes
+        - **kB**: Kilobytes
+        - **MB**: Megabytes
+        - **GB**: Gigabytes
+        - **TB**: Terabytes
+        - **PB**: Petabytes
+        - **EB**: Exabytes
+        - **ZB**: Zettabytes
+        - **YB**: Yottabytes
+        - **RB**: Ronnabytes
+        - **QB**: Quettabytes
+        - **KiB**: Kibibytes
+        - **MiB**: Mebibytes
+        - **GiB**: Gibibytes
+        - **TiB**: Tebibytes
+        - **PiB**: Pebibytes
+        - **EiB**: Exbibytes
+        - **ZiB**: Zebibytes
+        - **YiB**: Yobibytes
+        - **b**: Bits
+        - **kb**: Kilobits
+        - **Mb**: Megabits
+        - **Gb**: Gigabits
+        - **Tb**: Terabits
+        - **Pb**: Petabits
+        - **Eb**: Exabits
+        - **Zb**: Zettabits
+        - **Yb**: Yottabits
+        - **Rb**: Ronnabits
+        - **Qb**: Quettabits
+        - **Kib**: Kibibits
+        - **Mib**: Mebibits
+        - **Gib**: Gibibits
+        - **Tib**: Tebibits
+        - **Pib**: Pebibits
+        - **Eib**: Exbibits
+        - **Zib**: Zebibits
+        - **Yib**: Yobibits
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ConvertBits.as_decorator(from_unit=from_unit, to_unit=to_unit)

click_extended/decorators/convert/convert_distance.py

@@ -0,0 +1,154 @@
+"""Convert between various distance 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 = {
+    "Qm": Decimal("1e30"),
+    "Rm": Decimal("1e27"),
+    "ym": Decimal("1e-24"),
+    "zm": Decimal("1e-21"),
+    "am": Decimal("1e-18"),
+    "fm": Decimal("1e-15"),
+    "pm": Decimal("1e-12"),
+    "nm": Decimal("1e-9"),
+    "us": Decimal("1e-6"),
+    "mm": Decimal("1e-3"),
+    "cm": Decimal("1e-2"),
+    "dm": Decimal("1e-1"),
+    "m": Decimal("1"),
+    "km": Decimal("1e3"),
+    "mil": Decimal("1e4"),
+    "AU": Decimal("149597870700"),
+    "ly": Decimal("9460730472580800"),
+    "pc": Decimal("3.0856775814913673e16"),
+    "in": Decimal("0.0254"),
+    "ft": Decimal("0.3048"),
+    "yd": Decimal("0.9144"),
+    "mi": Decimal("1609.344"),
+    "nmi": Decimal("1852"),
+    "ang": Decimal("1e-10"),
+}
+
+
+class ConvertDistance(ChildNode):
+    """Convert between various distance 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}'")
+
+        meters = val * UNITS[from_unit]
+        return float(meters / UNITS[to_unit])
+
+
+def convert_distance(
+    from_unit: Literal[
+        "Qm",
+        "Rm",
+        "ym",
+        "zm",
+        "am",
+        "fm",
+        "pm",
+        "nm",
+        "us",
+        "mm",
+        "cm",
+        "dm",
+        "m",
+        "km",
+        "mil",
+        "AU",
+        "ly",
+        "pc",
+        "in",
+        "ft",
+        "yd",
+        "mi",
+        "nmi",
+        "ang",
+    ],
+    to_unit: Literal[
+        "Qm",
+        "Rm",
+        "ym",
+        "zm",
+        "am",
+        "fm",
+        "pm",
+        "nm",
+        "us",
+        "mm",
+        "cm",
+        "dm",
+        "m",
+        "km",
+        "mil",
+        "AU",
+        "ly",
+        "pc",
+        "in",
+        "ft",
+        "yd",
+        "mi",
+        "nmi",
+        "ang",
+    ],
+) -> Decorator:
+    """
+    Convert between various distance units.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Units:
+        - **Qm**: Quettameter
+        - **Rm**: Ronnameter
+        - **ym**: Yoctometer
+        - **zm**: Zeptometer
+        - **am**: Attometer
+        - **fm**: Femtometer
+        - **pm**: Picometer
+        - **nm**: Nanometer
+        - **us**: Micrometer
+        - **mm**: Millimeter
+        - **cm**: Centimeter
+        - **dm**: Decimeter
+        - **m**: Meter
+        - **km**: Kilometer
+        - **mil**: Swedish mile (10 kilometers)
+        - **AU**: Astronomical Unit
+        - **ly**: Light-year
+        - **pc**: Parsec
+        - **in**: Inch
+        - **ft**: Foot
+        - **yd**: Yard
+        - **mi**: Mile
+        - **nmi**: Nautical mile
+        - **ang**: Angstrom
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ConvertDistance.as_decorator(from_unit=from_unit, to_unit=to_unit)

click_extended/decorators/convert/convert_energy.py

@@ -0,0 +1,155 @@
+"""Convert between different energy 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 = {
+    "J": Decimal("1"),
+    "kJ": Decimal("1e3"),
+    "MJ": Decimal("1e6"),
+    "GJ": Decimal("1e9"),
+    "TJ": Decimal("1e12"),
+    "Wh": Decimal("3600"),
+    "kWh": Decimal("3.6e6"),
+    "MWh": Decimal("3.6e9"),
+    "GWh": Decimal("3.6e12"),
+    "TWh": Decimal("3.6e15"),
+    "cal": Decimal("4.184"),
+    "kcal": Decimal("4184"),
+    "eV": Decimal("1.602176634e-19"),
+    "keV": Decimal("1.602176634e-16"),
+    "MeV": Decimal("1.602176634e-13"),
+    "GeV": Decimal("1.602176634e-10"),
+    "TeV": Decimal("1.602176634e-7"),
+    "ftlb": Decimal("1.3558179483314004"),
+    "inlb": Decimal("0.1129848290276167"),
+    "Btu": Decimal("1055.05585262"),
+    "therm": Decimal("105505585.262"),
+    "erg": Decimal("1e-7"),
+    "ktTNT": Decimal("4.184e12"),
+    "MtTNT": Decimal("4.184e15"),
+}
+
+
+class ConvertEnergy(ChildNode):
+    """Convert between different energy 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}'")
+
+        joules = val * UNITS[from_unit]
+
+        return float(joules / UNITS[to_unit])
+
+
+def convert_energy(
+    from_unit: Literal[
+        "J",
+        "kJ",
+        "MJ",
+        "GJ",
+        "TJ",
+        "Wh",
+        "kWh",
+        "MWh",
+        "GWh",
+        "TWh",
+        "cal",
+        "kcal",
+        "eV",
+        "keV",
+        "MeV",
+        "GeV",
+        "TeV",
+        "ftlb",
+        "inlb",
+        "Btu",
+        "therm",
+        "erg",
+        "ktTNT",
+        "MtTNT",
+    ],
+    to_unit: Literal[
+        "J",
+        "kJ",
+        "MJ",
+        "GJ",
+        "TJ",
+        "Wh",
+        "kWh",
+        "MWh",
+        "GWh",
+        "TWh",
+        "cal",
+        "kcal",
+        "eV",
+        "keV",
+        "MeV",
+        "GeV",
+        "TeV",
+        "ftlb",
+        "inlb",
+        "Btu",
+        "therm",
+        "erg",
+        "ktTNT",
+        "MtTNT",
+    ],
+) -> Decorator:
+    """
+    Convert between different energy units.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Units:
+        - **J**: Joule
+        - **kJ**: Kilojoule
+        - **MJ**: Megajoule
+        - **GJ**: Gigajoule
+        - **TJ**: Terajoule
+        - **Wh**: Watt-hour
+        - **kWh**: Kilowatt-hour
+        - **MWh**: Megawatt-hour
+        - **GWh**: Gigawatt-hour
+        - **TWh**: Terawatt-hour
+        - **cal**: Small calorie
+        - **kcal**: Kilocalorie
+        - **eV**: Electronvolt
+        - **keV**: Kiloelectronvolt
+        - **MeV**: Megaelectronvolt
+        - **GeV**: Gigaelectronvolt
+        - **TeV**: Teraelectronvolt
+        - **ftlb**: Foot-pound
+        - **inlb**: Inch-pound
+        - **Btu**: British thermal unit
+        - **therm**: Therm (natural gas energy unit)
+        - **erg**: Erg (centimeter-gram-second)
+        - **ktTNT**: Kiloton of TNT equivalent
+        - **MtTNT**: Megaton of TNT equivalent
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ConvertEnergy.as_decorator(from_unit=from_unit, to_unit=to_unit)

click_extended/decorators/convert/convert_power.py

@@ -0,0 +1,128 @@
+"""Convert between different power 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 = {
+    "W": Decimal("1"),
+    "kW": Decimal("1e3"),
+    "MW": Decimal("1e6"),
+    "GW": Decimal("1e9"),
+    "TW": Decimal("1e12"),
+    "hp": Decimal("745.69987158227022"),
+    "hpM": Decimal("735.49875"),
+    "ftlbs": Decimal("1.3558179483314004"),
+    "Btuh": Decimal("0.2930710701722222"),
+    "Btus": Decimal("1055.05585262"),
+    "tonref": Decimal("3516.852842066666"),
+}
+
+
+class ConvertPower(ChildNode):
+    """Convert between different power 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 == "dBW":
+            watts = Decimal(10) ** (val / 10)
+        elif from_unit == "dBm":
+            watts = Decimal(10) ** ((val - 30) / 10)
+        elif from_unit in UNITS:
+            watts = val * UNITS[from_unit]
+        else:
+            raise ValueError(f"Unknown unit '{from_unit}'")
+
+        if to_unit == "dBW":
+            if watts <= 0:
+                raise ValueError(
+                    "Power must be positive for logarithmic conversion"
+                )
+            result = 10 * watts.log10()
+        elif to_unit == "dBm":
+            if watts <= 0:
+                raise ValueError(
+                    "Power must be positive for logarithmic conversion"
+                )
+            result = 10 * (watts * 1000).log10()
+        elif to_unit in UNITS:
+            result = watts / UNITS[to_unit]
+        else:
+            raise ValueError(f"Unknown unit '{to_unit}'")
+
+        return float(result)
+
+
+def convert_power(
+    from_unit: Literal[
+        "W",
+        "kW",
+        "MW",
+        "GW",
+        "TW",
+        "hp",
+        "hpM",
+        "dBW",
+        "dBm",
+        "Btuh",
+        "Btus",
+        "ftlbs",
+        "tonref",
+    ],
+    to_unit: Literal[
+        "W",
+        "kW",
+        "MW",
+        "GW",
+        "TW",
+        "hp",
+        "hpM",
+        "dBW",
+        "dBm",
+        "Btuh",
+        "Btus",
+        "ftlbs",
+        "tonref",
+    ],
+) -> Decorator:
+    """
+    Convert between different power units.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Units:
+        - **W**: Watt
+        - **kW**: Kilowatt
+        - **MW**: Megawatt
+        - **GW**: Gigawatt
+        - **TW**: Terawatt
+        - **hp**: Horsepower
+        - **hpM**: Metric horsepower
+        - **dBW**: Decibel-watt
+        - **dBm**: Decibel-milliwatt
+        - **Btuh**: BTU per hour
+        - **Btus**: BTU per second
+        - **ftlbs**: Foot-pounds per second
+        - **tonref**: Ton of refrigeration (cooling capacity)
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ConvertPower.as_decorator(from_unit=from_unit, to_unit=to_unit)