Merge pull request #16 from vertti/config-strict

Config strict

Author: vertti

README.md

@@ -4,7 +4,7 @@
 ![test](https://github.com/fourkind/daffy/workflows/test/badge.svg)
 [![codecov](https://codecov.io/gh/vertti/daffy/graph/badge.svg?token=00OL75TW4W)](https://codecov.io/gh/vertti/daffy)
 
-## Description 
+## Description
 
 Working with DataFrames often means passing them through multiple transformation functions, making it easy to lose track of their structure over time. DAFFY adds runtime validation and documentation to your DataFrame operations through simple decorators. By declaring the expected columns and types in your function definitions, you can:
 
@@ -35,7 +35,7 @@ Install with your favorite Python dependency manager like
 pip install daffy
 ```
 
-## Usage 
+## Usage
 
 Start by importing the needed decorators:
 
@@ -127,6 +127,27 @@ will, when `car_df` contains columns `["Brand", "Price"]` raise an error:
 AssertionError: DataFrame contained unexpected column(s): Price
 ```
 
+### Project-wide Configuration
+
+You can set the default value for strict mode at the project level by adding a `[tool.daffy]` section to your `pyproject.toml` file:
+
+```toml
+[tool.daffy]
+strict = true
+```
+
+When this configuration is present, all `@df_in` and `@df_out` decorators will use strict mode by default. You can still override this setting on individual decorators:
+
+```python
+# Uses strict=true from project config
+@df_in(columns=["Brand"])
+# Explicitly disable strict mode for this decorator
+@df_out(columns=["Brand", "FilteredPrice"], strict=False)
+def filter_cars(car_df):
+    # filter some cars
+    return filtered_cars_df
+```
+
 To quickly check what the incoming and outgoing dataframes contain, you can add a `@df_log` annotation to the function. For
 example adding `@df_log` to the above `filter_cars` function will product log lines:
 
@@ -164,6 +185,15 @@ MIT
 
 ## Changelog
 
+### 0.9.4
+
+- Fix to strict flag loading when tool config was missing
+
+### 0.9.3
+
+- Add configuration system to set default strict mode in pyproject.toml
+- Improve logging when multiple columns are missing
+
 ### 0.9.2
 
 - Add explicit `__all__` export for functions to make Mypy happy
@@ -212,7 +242,7 @@ MIT
 
 ### 0.2.1
 
-- Added Pypi classifiers. 
+- Added Pypi classifiers.
 
 ### 0.2.0
 

daffy/config.py

@@ -0,0 +1,89 @@
+"""Configuration handling for DAFFY."""
+
+import os
+from typing import Optional
+
+import tomli
+
+
+def load_config() -> dict:
+    """
+    Load daffy configuration from pyproject.toml.
+
+    Returns:
+        dict: Configuration dictionary with daffy settings
+    """
+    default_config = {"strict": False}
+
+    # Try to find pyproject.toml in the current directory or parent directories
+    config_path = find_config_file()
+    if not config_path:
+        return default_config
+
+    try:
+        with open(config_path, "rb") as f:
+            pyproject = tomli.load(f)
+
+        # Extract daffy configuration if it exists
+        daffy_config = pyproject.get("tool", {}).get("daffy", {})
+
+        # Update default config with values from pyproject.toml
+        if "strict" in daffy_config:
+            default_config["strict"] = bool(daffy_config["strict"])
+
+        return default_config
+    except (FileNotFoundError, tomli.TOMLDecodeError):
+        return default_config
+
+
+def find_config_file() -> Optional[str]:
+    """
+    Find pyproject.toml in the user's project directory.
+
+    This searches only in the current working directory (where the user's code is running),
+    not in daffy's installation directory.
+
+    Returns:
+        str or None: Path to pyproject.toml if found, None otherwise
+    """
+    # Only look for pyproject.toml in the current working directory,
+    # which should be the user's project directory, not daffy's installation directory
+    current_dir = os.getcwd()
+    config_path = os.path.join(current_dir, "pyproject.toml")
+
+    if os.path.isfile(config_path):
+        return config_path
+
+    return None
+
+
+# Cache config to avoid reading the file multiple times
+_config_cache = None
+
+
+def get_config() -> dict:
+    """
+    Get the daffy configuration, loading it if necessary.
+
+    Returns:
+        dict: Configuration dictionary with daffy settings
+    """
+    global _config_cache
+    if _config_cache is None:
+        _config_cache = load_config()
+    return _config_cache
+
+
+def get_strict(strict_param: Optional[bool] = None) -> bool:
+    """
+    Get the strict mode setting, with explicit parameter taking precedence over configuration.
+
+    Args:
+        strict_param: Explicitly provided strict parameter value, or None to use config
+
+    Returns:
+        bool: The effective strict mode setting
+    """
+    if strict_param is not None:
+        return strict_param
+    return bool(get_config()["strict"])

daffy/decorators.py

@@ -8,6 +8,8 @@
 import pandas as pd
 import polars as pl
 
+from daffy.config import get_strict
+
 ColumnsDef = Union[List, Dict]
 DataFrameType = Union[pd.DataFrame, pl.DataFrame]
 
@@ -42,14 +44,15 @@ def _check_columns(df: DataFrameType, columns: ColumnsDef, strict: bool) -> None
             raise AssertionError(f"DataFrame contained unexpected column(s): {', '.join(extra_columns)}")
 
 
-def df_out(columns: Optional[ColumnsDef] = None, strict: bool = False) -> Callable:
+def df_out(columns: Optional[ColumnsDef] = None, strict: Optional[bool] = None) -> Callable:
     """Decorate a function that returns a Pandas DataFrame.
 
     Document the return value of a function. The return value will be validated in runtime.
 
     Args:
         columns (ColumnsDef, optional): List or dict that describes expected columns of the DataFrame. Defaults to None.
-        strict (bool, optional): If True, columns must match exactly with no extra columns. Defaults to False.
+        strict (bool, optional): If True, columns must match exactly with no extra columns.
+            If None, uses the value from [tool.daffy] strict setting in pyproject.toml.
 
     Returns:
         Callable: Decorated function
@@ -63,7 +66,7 @@ def wrapper(*args: str, **kwargs: Any) -> Any:
                 f"Wrong return type. Expected DataFrame, got {type(result)}"
             )
             if columns:
-                _check_columns(result, columns, strict)
+                _check_columns(result, columns, get_strict(strict))
             return result
 
         return wrapper
@@ -87,15 +90,16 @@ def _get_parameter(func: Callable, name: Optional[str] = None, *args: str, **kwa
     return kwargs[name]
 
 
-def df_in(name: Optional[str] = None, columns: Optional[ColumnsDef] = None, strict: bool = False) -> Callable:
+def df_in(name: Optional[str] = None, columns: Optional[ColumnsDef] = None, strict: Optional[bool] = None) -> Callable:
     """Decorate a function parameter that is a Pandas DataFrame.
 
     Document the contents of an inpute parameter. The parameter will be validated in runtime.
 
     Args:
         name (Optional[str], optional): Name of the parameter that contains a DataFrame. Defaults to None.
         columns (ColumnsDef, optional): List or dict that describes expected columns of the DataFrame. Defaults to None.
-        strict (bool, optional): If True, columns must match exactly with no extra columns. Defaults to False.
+        strict (bool, optional): If True, columns must match exactly with no extra columns.
+            If None, uses the value from [tool.daffy] strict setting in pyproject.toml.
 
     Returns:
         Callable: Decorated function
@@ -109,7 +113,7 @@ def wrapper(*args: str, **kwargs: Any) -> Any:
                 f"Wrong parameter type. Expected DataFrame, got {type(df).__name__} instead."
             )
             if columns:
-                _check_columns(df, columns, strict)
+                _check_columns(df, columns, get_strict(strict))
             return func(*args, **kwargs)
 
         return wrapper

mise.toml

@@ -0,0 +1,3 @@
+[tools]
+node = "latest"
+poetry = "latest"

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "daffy"
-version = "0.9.2"
+version = "0.9.4"
 description = "Function decorators for Pandas and Polars Dataframe column name and data type validation"
 authors = [
  { name="Janne Sinivirta", email="[email protected]" },
@@ -36,6 +36,7 @@ include = ["daffy/py.typed"]
 python = ">=3.9.0,<4.0.0"
 pandas = ">=1.5.1,<3.0.0"
 polars = "^1.7.0"
+tomli = "^2.0.0"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.3.0"

tests/test_config.py

@@ -0,0 +1,53 @@
+"""Tests for the daffy configuration system."""
+
+import os
+import tempfile
+from unittest.mock import patch
+
+from daffy.config import get_config, get_strict
+
+
+def test_get_config_default() -> None:
+    """Test that get_config returns default values when no config file is found."""
+    with patch("daffy.config.find_config_file", return_value=None):
+        config = get_config()
+        assert config["strict"] is False
+
+
+def test_get_strict_default() -> None:
+    """Test that get_strict returns default value when no explicit value is provided."""
+    with patch("daffy.config.get_config", return_value={"strict": False}):
+        assert get_strict() is False
+
+    with patch("daffy.config.get_config", return_value={"strict": True}):
+        assert get_strict() is True
+
+
+def test_get_strict_override() -> None:
+    """Test that get_strict respects explicitly provided value."""
+    with patch("daffy.config.get_config", return_value={"strict": False}):
+        assert get_strict(True) is True
+
+    with patch("daffy.config.get_config", return_value={"strict": True}):
+        assert get_strict(False) is False
+
+
+def test_config_from_pyproject() -> None:
+    """Test loading configuration from pyproject.toml."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        # Create a mock pyproject.toml file
+        with open(os.path.join(tmpdir, "pyproject.toml"), "w") as f:
+            f.write("""
+[tool.daffy]
+strict = true
+            """)
+
+        # Test loading from this file
+        with patch("daffy.config.os.getcwd", return_value=tmpdir):
+            # Reset the cache to force reloading
+            from daffy.config import load_config
+
+            globals()["_config_cache"] = None
+
+            config = load_config()
+            assert config["strict"] is True