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

click_extended/decorators/math/divide.py

@@ -0,0 +1,42 @@
+"""Divide the input by a value."""
+
+from typing import Any
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Divide(ChildNode):
+    """Divide the input by a value."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        n = kwargs["n"]
+        if n == 0:
+            raise ZeroDivisionError("division by zero")
+        return value / n
+
+
+def divide(n: int | float) -> Decorator:
+    """
+    Divide the input by a value.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Args:
+        n (int | float):
+            The value to divide by.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Divide.as_decorator(n=n)

click_extended/decorators/math/floor.py

@@ -0,0 +1,36 @@
+"""Calculate the floor of the input."""
+
+import math
+from typing import Any
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Floor(ChildNode):
+    """Calculate the floor of the input."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        return math.floor(value)
+
+
+def floor() -> Decorator:
+    """
+    Calculate the floor of the input.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Floor.as_decorator()

click_extended/decorators/math/maximum.py

@@ -0,0 +1,39 @@
+"""Ensure the value is at most a maximum."""
+
+from typing import Any, Union
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Maximum(ChildNode):
+    """Ensure the value is at most a maximum."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        return min(value, kwargs["max_val"])
+
+
+def maximum(max_val: Union[int, float]) -> Decorator:
+    """
+    Ensure the value is at most a maximum.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Args:
+        max_val (int | float):
+            The maximum value.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Maximum.as_decorator(max_val=max_val)

click_extended/decorators/math/minimum.py

@@ -0,0 +1,39 @@
+"""Ensure the value is at least a minimum."""
+
+from typing import Any
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Minimum(ChildNode):
+    """Ensure the value is at least a minimum."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        return max(value, kwargs["min_val"])
+
+
+def minimum(min_val: int | float) -> Decorator:
+    """
+    Ensure the value is at least a minimum.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Args:
+        min_val (int | float):
+            The minimum value.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Minimum.as_decorator(min_val=min_val)

click_extended/decorators/math/modulo.py

@@ -0,0 +1,39 @@
+"""Calculate the modulo of the input."""
+
+from typing import Any
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Modulo(ChildNode):
+    """Calculate the modulo of the input."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        return value % kwargs["n"]
+
+
+def modulo(n: int | float) -> Decorator:
+    """
+    Calculate the modulo of the input.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Args:
+        n (int | float):
+            The divisor.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Modulo.as_decorator(n=n)

click_extended/decorators/math/multiply.py

@@ -0,0 +1,51 @@
+"""Multiply the input by a value."""
+
+from typing import Any
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Multiply(ChildNode):
+    """Multiply the input by a value."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        return value * kwargs["n"]
+
+    def handle_str(
+        self,
+        value: str,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        n = kwargs["n"]
+        if not isinstance(n, int):
+            raise TypeError(f"Cannot multiply string by non-int type {type(n)}")
+        return value * n
+
+
+def multiply(n: int | float) -> Decorator:
+    """
+    Multiply the input by a value.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`, `str`
+
+    Args:
+        n (int | float):
+            The value to multiply by.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Multiply.as_decorator(n=n)

click_extended/decorators/math/normalize.py

@@ -0,0 +1,76 @@
+"""Normalize a value within a range."""
+
+from decimal import Decimal, getcontext
+from typing import Any
+
+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
+
+
+class Normalize(ChildNode):
+    """Normalize a value within a range."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> float:
+        min_val = kwargs["min_val"]
+        max_val = kwargs["max_val"]
+        new_min = kwargs.get("new_min")
+        new_max = kwargs.get("new_max")
+
+        val = Decimal(str(value))
+        min_v = Decimal(str(min_val))
+        max_v = Decimal(str(max_val))
+
+        if new_min is None or new_max is None:
+            # Normalize to 0-1
+            result = (val - min_v) / (max_v - min_v)
+        else:
+            # Normalize to new range
+            n_min = Decimal(str(new_min))
+            n_max = Decimal(str(new_max))
+            result = n_min + (val - min_v) * (n_max - n_min) / (max_v - min_v)
+
+        return float(result)
+
+
+def normalize(
+    min_val: float,
+    max_val: float,
+    new_min: float | None = None,
+    new_max: float | None = None,
+) -> Decorator:
+    """
+    Normalize a value within a range.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Args:
+        min_val (float):
+            The minimum value of the input range.
+        max_val (float):
+            The maximum value of the input range.
+        new_min (float, optional):
+            The minimum value of the output range.
+        new_max (float, optional):
+            The maximum value of the output range.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Normalize.as_decorator(
+        min_val=min_val,
+        max_val=max_val,
+        new_min=new_min,
+        new_max=new_max,
+    )

click_extended/decorators/math/power.py

@@ -0,0 +1,39 @@
+"""Raise the input to a power."""
+
+from typing import Any
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Power(ChildNode):
+    """Raise the input to a power."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        return value ** kwargs["n"]
+
+
+def power(n: int | float) -> Decorator:
+    """
+    Raise the input to a power.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Args:
+        n (int | float):
+            The exponent.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Power.as_decorator(n=n)

click_extended/decorators/math/rounded.py

@@ -0,0 +1,39 @@
+"""Round the input to a given precision."""
+
+from typing import Any
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Rounded(ChildNode):
+    """Round the input to a given precision."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        return round(value, kwargs["digits"])
+
+
+def rounded(digits: int = 0) -> Decorator:
+    """
+    Round the input to a given precision.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Args:
+        digits (int):
+            The number of digits to round to. Defaults to `0`.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Rounded.as_decorator(digits=digits)

click_extended/decorators/math/sqrt.py

@@ -0,0 +1,39 @@
+"""Calculate the square root of the input."""
+
+import cmath
+import math
+from typing import Any
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Sqrt(ChildNode):
+    """Calculate the square root of the input."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        if value < 0:
+            return cmath.sqrt(value)
+        return math.sqrt(value)
+
+
+def sqrt() -> Decorator:
+    """
+    Calculate the square root of the input, supports complex numbers.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Sqrt.as_decorator()

click_extended/decorators/math/subtract.py

@@ -0,0 +1,39 @@
+"""Subtract a value from the input."""
+
+from typing import Any
+
+from click_extended.core.nodes.child_node import ChildNode
+from click_extended.core.other.context import Context
+from click_extended.types import Decorator
+
+
+class Subtract(ChildNode):
+    """Subtract a value from the input."""
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        return value - kwargs["n"]
+
+
+def subtract(n: int | float) -> Decorator:
+    """
+    Subtract a value from the input.
+
+    Type: `ChildNode`
+
+    Supports: `int`, `float`
+
+    Args:
+        n (int | float):
+            The value to subtract.
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return Subtract.as_decorator(n=n)

click_extended/decorators/math/to_percent.py

@@ -0,0 +1,63 @@
+"""Convert a value to a percentage decimal."""
+
+from decimal import Decimal, getcontext
+from typing import Any
+
+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
+
+
+class ToPercent(ChildNode):
+    """Convert a value to a percentage decimal."""
+
+    def handle_str(
+        self,
+        value: str,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> float:
+        s_val = value.strip()
+        if s_val.endswith("%"):
+            s_val = s_val[:-1]
+
+        try:
+            val = Decimal(s_val)
+        except Exception as e:
+            raise ValueError(f"Cannot convert '{value}' to percent.") from e
+
+        return float(val / 100)
+
+    def handle_numeric(
+        self,
+        value: int | float,
+        context: Context,
+        *args: Any,
+        **kwargs: Any,
+    ) -> float:
+        val = Decimal(str(value))
+        return float(val / 100)
+
+
+def to_percent() -> Decorator:
+    """
+    Convert a value to a percentage decimal.
+
+    Type: `ChildNode`
+
+    Supports: `str`, `int`, `float`
+
+    Examples:
+        - "50%" -> 0.5
+        - "50" -> 0.5
+        - 50 -> 0.5
+        - 0.5 -> 0.005
+
+    Returns:
+        Decorator:
+            The decorated function.
+    """
+    return ToPercent.as_decorator()

click_extended/decorators/misc/__init__.py

@@ -0,0 +1,17 @@
+"""Initialization file for the `click_extended.decorators.misc` module."""
+
+from click_extended.decorators.misc.choice import choice
+from click_extended.decorators.misc.confirm_if import confirm_if
+from click_extended.decorators.misc.default import default
+from click_extended.decorators.misc.deprecated import deprecated
+from click_extended.decorators.misc.experimental import experimental
+from click_extended.decorators.misc.now import now
+
+__all__ = [
+    "choice",
+    "confirm_if",
+    "default",
+    "deprecated",
+    "experimental",
+    "now",
+]