chore: replaed kwargs with param names in create expectation functions

Author: ryanseq-gyg

dataframe_expectations/expectations/aggregation_expectations/__init__.py

@@ -38,8 +38,7 @@ def __init__(self, min_rows: int):
         """
         Initialize the minimum rows expectation.
 
-        Args:
-            min_rows (int): Minimum number of rows required (inclusive).
+        :param min_rows: Minimum number of rows required (inclusive).
         """
         if min_rows < 0:
             raise ValueError(f"min_rows must be non-negative, got {min_rows}")
@@ -124,8 +123,7 @@ def __init__(self, max_rows: int):
         """
         Initialize the maximum rows expectation.
 
-        Args:
-            max_rows (int): Maximum number of rows allowed (inclusive).
+        :param max_rows: Maximum number of rows allowed (inclusive).
         """
         if max_rows < 0:
             raise ValueError(f"max_rows must be non-negative, got {max_rows}")
@@ -214,9 +212,8 @@ def __init__(self, column_name: str, max_percentage: float):
         """
         Initialize the maximum null percentage expectation.
 
-        Args:
-            column_name (str): Name of the column to check for null percentage.
-            max_percentage (float): Maximum percentage of null values allowed (0.0-100.0).
+        :param column_name: Name of the column to check for null percentage.
+        :param max_percentage: Maximum percentage of null values allowed (0.0-100.0).
         """
         if not 0 <= max_percentage <= 100:
             raise ValueError(f"max_percentage must be between 0.0 and 100.0, got {max_percentage}")
@@ -332,9 +329,8 @@ def __init__(self, column_name: str, max_count: int):
         """
         Initialize the maximum null count expectation.
 
-        Args:
-            column_name (str): Name of the column to check for null count.
-            max_count (int): Maximum number of null values allowed.
+        :param column_name: Name of the column to check for null count.
+        :param max_count: Maximum number of null values allowed.
         """
         if max_count < 0:
             raise ValueError(f"max_count must be non-negative, got {max_count}")
@@ -426,17 +422,14 @@ def aggregate_and_validate_pyspark(
     },
 )
 @requires_params("min_rows", types={"min_rows": int})
-def create_expectation_min_rows(**kwargs) -> ExpectationMinRows:
+def create_expectation_min_rows(min_rows: int) -> ExpectationMinRows:
     """
     Create an ExpectMinRows instance.
 
-    Args:
-        min_rows (int): Minimum number of rows required.
-
-    Returns:
-        ExpectationMinRows: A configured expectation instance.
+    :param min_rows: Minimum number of rows required.
+    :return: A configured expectation instance.
     """
-    return ExpectationMinRows(min_rows=kwargs["min_rows"])
+    return ExpectationMinRows(min_rows=min_rows)
 
 
 @register_expectation(
@@ -449,17 +442,14 @@ def create_expectation_min_rows(**kwargs) -> ExpectationMinRows:
     },
 )
 @requires_params("max_rows", types={"max_rows": int})
-def create_expectation_max_rows(**kwargs) -> ExpectationMaxRows:
+def create_expectation_max_rows(max_rows: int) -> ExpectationMaxRows:
     """
     Create an ExpectationMaxRows instance.
 
-    Args:
-        max_rows (int): Maximum number of rows allowed.
-
-    Returns:
-        ExpectationMaxRows: A configured expectation instance.
+    :param max_rows: Maximum number of rows allowed.
+    :return: A configured expectation instance.
     """
-    return ExpectationMaxRows(max_rows=kwargs["max_rows"])
+    return ExpectationMaxRows(max_rows=max_rows)
 
 
 @register_expectation(
@@ -477,20 +467,19 @@ def create_expectation_max_rows(**kwargs) -> ExpectationMaxRows:
     "max_percentage",
     types={"column_name": str, "max_percentage": (int, float)},
 )
-def create_expectation_max_null_percentage(**kwargs) -> ExpectationMaxNullPercentage:
+def create_expectation_max_null_percentage(
+    column_name: str, max_percentage: float
+) -> ExpectationMaxNullPercentage:
     """
     Create an ExpectationMaxNullPercentage instance.
 
-    Args:
-        column_name (str): Name of the column to check for null percentage.
-        max_percentage (float): Maximum percentage of null values allowed (0.0-100.0).
-
-    Returns:
-        ExpectationMaxNullPercentage: A configured expectation instance.
+    :param column_name: Name of the column to check for null percentage.
+    :param max_percentage: Maximum percentage of null values allowed (0.0-100.0).
+    :return: A configured expectation instance.
     """
     return ExpectationMaxNullPercentage(
-        column_name=kwargs["column_name"],
-        max_percentage=kwargs["max_percentage"],
+        column_name=column_name,
+        max_percentage=max_percentage,
     )
 
 
@@ -509,18 +498,15 @@ def create_expectation_max_null_percentage(**kwargs) -> ExpectationMaxNullPercen
     "max_count",
     types={"column_name": str, "max_count": int},
 )
-def create_expectation_max_null_count(**kwargs) -> ExpectationMaxNullCount:
+def create_expectation_max_null_count(column_name: str, max_count: int) -> ExpectationMaxNullCount:
     """
     Create an ExpectationMaxNullCount instance.
 
-    Args:
-        column_name (str): Name of the column to check for null count.
-        max_count (int): Maximum number of null values allowed.
-
-    Returns:
-        ExpectationMaxNullCount: A configured expectation instance.
+    :param column_name: Name of the column to check for null count.
+    :param max_count: Maximum number of null values allowed.
+    :return: A configured expectation instance.
     """
     return ExpectationMaxNullCount(
-        column_name=kwargs["column_name"],
-        max_count=kwargs["max_count"],
+        column_name=column_name,
+        max_count=max_count,
     )

dataframe_expectations/expectations/aggregation_expectations/any_value_expectations.py

@@ -53,14 +53,11 @@ def __init__(
         """
         Initialize the column quantile between expectation.
 
-        Args:
-            column_name (str): Name of the column to check.
-            quantile (float): Quantile to compute (0.0 to 1.0, where 0.0=min, 0.5=median, 1.0=max).
-            min_value (Union[int, float]): Minimum allowed value for the column quantile (inclusive).
-            max_value (Union[int, float]): Maximum allowed value for the column quantile (inclusive).
-
-        Raises:
-            ValueError: If quantile is not between 0.0 and 1.0.
+        :param column_name: Name of the column to check.
+        :param quantile: Quantile to compute (0.0 to 1.0, where 0.0=min, 0.5=median, 1.0=max).
+        :param min_value: Minimum allowed value for the column quantile (inclusive).
+        :param max_value: Maximum allowed value for the column quantile (inclusive).
+        :raises ValueError: If quantile is not between 0.0 and 1.0.
         """
         if not (0.0 <= quantile <= 1.0):
             raise ValueError(f"Quantile must be between 0.0 and 1.0, got {quantile}")
@@ -226,10 +223,9 @@ def __init__(
         """
         Initialize the column mean between expectation.
 
-        Args:
-            column_name (str): Name of the column to check.
-            min_value (Union[int, float]): Minimum allowed value for the column mean (inclusive).
-            max_value (Union[int, float]): Maximum allowed value for the column mean (inclusive).
+        :param column_name: Name of the column to check.
+        :param min_value: Minimum allowed value for the column mean (inclusive).
+        :param max_value: Maximum allowed value for the column mean (inclusive).
         """
         description = f"column '{column_name}' mean value between {min_value} and {max_value}"
 
@@ -345,25 +341,25 @@ def aggregate_and_validate_pyspark(
     },
 )
 def create_expectation_column_quantile_between(
-    **kwargs,
+    column_name: str,
+    quantile: float,
+    min_value: Union[int, float],
+    max_value: Union[int, float],
 ) -> ExpectationColumnQuantileBetween:
     """
     Create an ExpectationColumnQuantileBetween instance.
 
-    Args:
-        column_name (str): Name of the column to check.
-        quantile (float): Quantile to compute (0.0 to 1.0).
-        min_value (Union[int, float]): Minimum allowed value for the column quantile.
-        max_value (Union[int, float]): Maximum allowed value for the column quantile.
-
-    Returns:
-        ExpectationColumnQuantileBetween: A configured expectation instance.
+    :param column_name: Name of the column to check.
+    :param quantile: Quantile to compute (0.0 to 1.0).
+    :param min_value: Minimum allowed value for the column quantile.
+    :param max_value: Maximum allowed value for the column quantile.
+    :return: A configured expectation instance.
     """
     return ExpectationColumnQuantileBetween(
-        column_name=kwargs["column_name"],
-        quantile=kwargs["quantile"],
-        min_value=kwargs["min_value"],
-        max_value=kwargs["max_value"],
+        column_name=column_name,
+        quantile=quantile,
+        min_value=min_value,
+        max_value=max_value,
     )
 
 
@@ -386,24 +382,23 @@ def create_expectation_column_quantile_between(
     types={"column_name": str, "min_value": (int, float), "max_value": (int, float)},
 )
 def create_expectation_column_max_to_be_between(
-    **kwargs,
+    column_name: str,
+    min_value: Union[int, float],
+    max_value: Union[int, float],
 ) -> ExpectationColumnQuantileBetween:
     """
     Create an ExpectationColumnQuantileBetween instance for maximum values (quantile=1.0).
 
-    Args:
-        column_name (str): Name of the column to check.
-        min_value (Union[int, float]): Minimum allowed value for the column maximum.
-        max_value (Union[int, float]): Maximum allowed value for the column maximum.
-
-    Returns:
-        ExpectationColumnQuantileBetween: A configured expectation instance for maximum values.
+    :param column_name: Name of the column to check.
+    :param min_value: Minimum allowed value for the column maximum.
+    :param max_value: Maximum allowed value for the column maximum.
+    :return: A configured expectation instance for maximum values.
     """
     return ExpectationColumnQuantileBetween(
-        column_name=kwargs["column_name"],
+        column_name=column_name,
         quantile=1.0,
-        min_value=kwargs["min_value"],
-        max_value=kwargs["max_value"],
+        min_value=min_value,
+        max_value=max_value,
     )
 
 
@@ -425,24 +420,23 @@ def create_expectation_column_max_to_be_between(
     types={"column_name": str, "min_value": (int, float), "max_value": (int, float)},
 )
 def create_expectation_column_min_to_be_between(
-    **kwargs,
+    column_name: str,
+    min_value: Union[int, float],
+    max_value: Union[int, float],
 ) -> ExpectationColumnQuantileBetween:
     """
     Create an ExpectationColumnQuantileBetween instance for minimum values (quantile=0.0).
 
-    Args:
-        column_name (str): Name of the column to check.
-        min_value (Union[int, float]): Minimum allowed value for the column minimum.
-        max_value (Union[int, float]): Maximum allowed value for the column minimum.
-
-    Returns:
-        ExpectationColumnQuantileBetween: A configured expectation instance for minimum values.
+    :param column_name: Name of the column to check.
+    :param min_value: Minimum allowed value for the column minimum.
+    :param max_value: Maximum allowed value for the column minimum.
+    :return: A configured expectation instance for minimum values.
     """
     return ExpectationColumnQuantileBetween(
-        column_name=kwargs["column_name"],
+        column_name=column_name,
         quantile=0.0,
-        min_value=kwargs["min_value"],
-        max_value=kwargs["max_value"],
+        min_value=min_value,
+        max_value=max_value,
     )
 
 
@@ -464,25 +458,24 @@ def create_expectation_column_min_to_be_between(
     types={"column_name": str, "min_value": (int, float), "max_value": (int, float)},
 )
 def create_expectation_column_mean_to_be_between(
-    **kwargs,
+    column_name: str,
+    min_value: Union[int, float],
+    max_value: Union[int, float],
 ) -> ExpectationColumnMeanBetween:
     """
     Create a custom ExpectationColumnMeanBetween instance for mean values.
     Note: This uses a separate implementation since mean is not a quantile.
 
-    Args:
-        column_name (str): Name of the column to check.
-        min_value (Union[int, float]): Minimum allowed value for the column mean.
-        max_value (Union[int, float]): Maximum allowed value for the column mean.
-
-    Returns:
-        ExpectationColumnMeanBetween: A configured expectation instance for mean values.
+    :param column_name: Name of the column to check.
+    :param min_value: Minimum allowed value for the column mean.
+    :param max_value: Maximum allowed value for the column mean.
+    :return: A configured expectation instance for mean values.
     """
     # For mean, we need a separate class since it's not a quantile
     return ExpectationColumnMeanBetween(
-        column_name=kwargs["column_name"],
-        min_value=kwargs["min_value"],
-        max_value=kwargs["max_value"],
+        column_name=column_name,
+        min_value=min_value,
+        max_value=max_value,
     )
 
 
@@ -504,22 +497,21 @@ def create_expectation_column_mean_to_be_between(
     types={"column_name": str, "min_value": (int, float), "max_value": (int, float)},
 )
 def create_expectation_column_median_to_be_between(
-    **kwargs,
+    column_name: str,
+    min_value: Union[int, float],
+    max_value: Union[int, float],
 ) -> ExpectationColumnQuantileBetween:
     """
     Create an ExpectationColumnQuantileBetween instance for median values (quantile=0.5).
 
-    Args:
-        column_name (str): Name of the column to check.
-        min_value (Union[int, float]): Minimum allowed value for the column median.
-        max_value (Union[int, float]): Maximum allowed value for the column median.
-
-    Returns:
-        ExpectationColumnQuantileBetween: A configured expectation instance for median values.
+    :param column_name: Name of the column to check.
+    :param min_value: Minimum allowed value for the column median.
+    :param max_value: Maximum allowed value for the column median.
+    :return: A configured expectation instance for median values.
     """
     return ExpectationColumnQuantileBetween(
-        column_name=kwargs["column_name"],
+        column_name=column_name,
         quantile=0.5,
-        min_value=kwargs["min_value"],
-        max_value=kwargs["max_value"],
+        min_value=min_value,
+        max_value=max_value,
     )