Merge pull request #44 from vertti/release/1.0.0

Release 1.0.0 - First stable release

Author: vertti

CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to this project will be documented in this file.
 
+## 1.0.0
+
+### Stable Release
+
+Daffy 1.0.0 marks the first stable release. The public API (`df_in`, `df_out`, `df_log`) is now considered stable and follows semantic versioning.
+
+### Changed
+
+- Development status upgraded from Beta to Production/Stable
+- Updated documentation to reflect current tooling (uv, ruff, pyrefly)
+
+### Fixed
+
+- Improved error handling for invalid regex patterns in column specifications
+- Better error messages when parameter extraction fails
+
+### Internal
+
+- Extracted duplicate row validation logic into shared helper function
+- Added docstrings to public-facing utility functions
+
+### API Stability
+
+As of 1.0.0, Daffy follows semantic versioning:
+- Major versions (2.0, 3.0) may contain breaking changes
+- Minor versions (1.1, 1.2) add features without breaking changes
+- Patch versions (1.0.1, 1.0.2) contain bug fixes only
+
 ## 0.19.0
 
 ### Performance Improvements

README.md

@@ -52,6 +52,15 @@ Install with your favorite Python dependency manager:
 pip install daffy
 ```
 
+Daffy works with **pandas**, **polars**, or both - install whichever you need:
+
+```sh
+pip install pandas   # for pandas support
+pip install polars   # for polars support
+```
+
+**Python version support:** 3.9 - 3.14
+
 ## Quick Start
 
 ### Column Validation
@@ -69,7 +78,7 @@ def apply_discount(cars_df):
 
 ### Row Validation
 
-For validating actual data values (requires `pip install pydantic`):
+For validating actual data values (requires `pip install 'pydantic>=2.4.0'`):
 
 ```python
 from pydantic import BaseModel, Field

daffy/config.py

@@ -1,12 +1,13 @@
 """Configuration handling for DAFFY."""
 
 import os
-from typing import Any, Dict, Optional
+from functools import lru_cache
+from typing import Any, Optional
 
 import tomli
 
 
-def load_config() -> Dict[str, Any]:
+def load_config() -> dict[str, Any]:
     """
     Load daffy configuration from pyproject.toml.
 
@@ -45,41 +46,20 @@ def load_config() -> Dict[str, Any]:
 
 
 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
+    """Find pyproject.toml in the current working directory."""
+    path = os.path.join(os.getcwd(), "pyproject.toml")
+    return path if os.path.isfile(path) else None
 
-    return None
 
+@lru_cache(maxsize=1)
+def get_config() -> dict[str, Any]:
+    """Get the daffy configuration, cached after first load."""
+    return load_config()
 
-# Cache config to avoid reading the file multiple times
-_config_cache = None
 
-
-def get_config() -> Dict[str, Any]:
-    """
-    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 clear_config_cache() -> None:
+    """Clear the configuration cache. Primarily for testing."""
+    get_config.cache_clear()
 
 
 def get_strict(strict_param: Optional[bool] = None) -> bool:
@@ -97,7 +77,7 @@ def get_strict(strict_param: Optional[bool] = None) -> bool:
     return bool(get_config()["strict"])
 
 
-def get_row_validation_config() -> Dict[str, Any]:
+def get_row_validation_config() -> dict[str, Any]:
     """Get all row validation configuration options."""
     config = get_config()
     return {

daffy/dataframe_types.py

@@ -1,6 +1,8 @@
 """DataFrame type handling for DAFFY - supports Pandas and Polars."""
 
-from typing import TYPE_CHECKING, Any, List, Union
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Union
 
 # Lazy imports - only import what's available
 try:
@@ -26,6 +28,8 @@
 # Build DataFrame type dynamically based on what's available
 if TYPE_CHECKING:
     # For static type checking, assume both are available
+    from typing import TypeGuard
+
     from pandas import DataFrame as PandasDataFrame
     from polars import DataFrame as PolarsDataFrame
 
@@ -61,12 +65,12 @@ def get_dataframe_types() -> tuple[Any, ...]:
     return tuple(dataframe_types)
 
 
-def get_available_library_names() -> List[str]:
+def get_available_library_names() -> list[str]:
     """
     Get list of available DataFrame library names for error messages.
 
     Returns:
-        List[str]: List of available library names (e.g., ["Pandas", "Polars"])
+        list[str]: List of available library names (e.g., ["Pandas", "Polars"])
     """
     available_libs = []
     if HAS_PANDAS:
@@ -76,11 +80,11 @@ def get_available_library_names() -> List[str]:
     return available_libs
 
 
-def is_pandas_dataframe(df: Any) -> bool:
+def is_pandas_dataframe(df: Any) -> TypeGuard[PandasDataFrame]:
     return HAS_PANDAS and pd is not None and isinstance(df, pd.DataFrame)
 
 
-def is_polars_dataframe(df: Any) -> bool:
+def is_polars_dataframe(df: Any) -> TypeGuard[PolarsDataFrame]:
     return HAS_POLARS and pl is not None and isinstance(df, pl.DataFrame)
 
 

daffy/decorators.py

@@ -1,8 +1,11 @@
 """Decorators for DAFFY DataFrame Column Validator."""
 
+from __future__ import annotations
+
 import logging
+from collections.abc import Callable
 from functools import wraps
-from typing import TYPE_CHECKING, Any, Callable, Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, TypeVar
 
 if TYPE_CHECKING:
     # For static type checking, assume both are available
@@ -14,10 +17,12 @@
     PandasDataFrame = None
     PolarsDataFrame = None
 
-from daffy.config import get_strict
+from daffy.config import get_row_validation_config, get_strict
 from daffy.dataframe_types import DataFrameType
+from daffy.row_validation import validate_dataframe_rows
 from daffy.utils import (
     assert_is_dataframe,
+    format_param_context,
     get_parameter,
     get_parameter_name,
     log_dataframe_input,
@@ -28,16 +33,46 @@
 # Type variables for preserving return types
 T = TypeVar("T")  # Generic type var for df_log
 if TYPE_CHECKING:
-    DF = TypeVar("DF", bound=Union[PandasDataFrame, PolarsDataFrame])
+    DF = TypeVar("DF", bound=PandasDataFrame | PolarsDataFrame)
 else:
     DF = TypeVar("DF", bound=DataFrameType)
 R = TypeVar("R")  # Return type for df_in
 
 
+def _validate_rows_with_context(
+    df: Any,
+    row_validator: "type[BaseModel]",
+    func_name: str,
+    param_name: str | None,
+    is_return_value: bool,
+) -> None:
+    """Validate DataFrame rows with Pydantic model and add context to errors.
+
+    Args:
+        df: DataFrame to validate
+        row_validator: Pydantic model class for row validation
+        func_name: Name of the decorated function
+        param_name: Name of the parameter being validated (None for return values)
+        is_return_value: True if validating a return value
+    """
+    config = get_row_validation_config()
+
+    try:
+        validate_dataframe_rows(
+            df,
+            row_validator,
+            max_errors=config["max_errors"],
+            convert_nans=config["convert_nans"],
+        )
+    except AssertionError as e:
+        context = format_param_context(param_name, func_name, is_return_value)
+        raise AssertionError(f"{str(e)}{context}") from e
+
+
 def df_out(
     columns: ColumnsDef = None,
-    strict: Optional[bool] = None,
-    row_validator: Optional["type[BaseModel]"] = None,
+    strict: bool | None = None,
+    row_validator: "type[BaseModel] | None" = None,
 ) -> Callable[[Callable[..., DF]], Callable[..., DF]]:
     """Decorate a function that returns a Pandas or Polars DataFrame.
 
@@ -67,22 +102,7 @@ def wrapper(*args: Any, **kwargs: Any) -> DF:
                 validate_dataframe(result, columns, get_strict(strict), None, func.__name__, True)
 
             if row_validator is not None:
-                from daffy.config import get_row_validation_config
-                from daffy.row_validation import validate_dataframe_rows
-                from daffy.utils import format_param_context
-
-                config = get_row_validation_config()
-
-                try:
-                    validate_dataframe_rows(
-                        result,
-                        row_validator,
-                        max_errors=config["max_errors"],
-                        convert_nans=config["convert_nans"],
-                    )
-                except AssertionError as e:
-                    context = format_param_context(None, func.__name__, True)
-                    raise AssertionError(f"{str(e)}{context}") from e
+                _validate_rows_with_context(result, row_validator, func.__name__, None, True)
 
             return result
 
@@ -92,10 +112,10 @@ def wrapper(*args: Any, **kwargs: Any) -> DF:
 
 
 def df_in(
-    name: Optional[str] = None,
+    name: str | None = None,
     columns: ColumnsDef = None,
-    strict: Optional[bool] = None,
-    row_validator: Optional["type[BaseModel]"] = None,
+    strict: bool | None = None,
+    row_validator: "type[BaseModel] | None" = None,
 ) -> Callable[[Callable[..., R]], Callable[..., R]]:
     """Decorate a function parameter that is a Pandas or Polars DataFrame.
 
@@ -127,22 +147,7 @@ def wrapper(*args: Any, **kwargs: Any) -> R:
                 validate_dataframe(df, columns, get_strict(strict), param_name, func.__name__)
 
             if row_validator is not None:
-                from daffy.config import get_row_validation_config
-                from daffy.row_validation import validate_dataframe_rows
-                from daffy.utils import format_param_context
-
-                config = get_row_validation_config()
-
-                try:
-                    validate_dataframe_rows(
-                        df,
-                        row_validator,
-                        max_errors=config["max_errors"],
-                        convert_nans=config["convert_nans"],
-                    )
-                except AssertionError as e:
-                    context = format_param_context(param_name, func.__name__, False)
-                    raise AssertionError(f"{str(e)}{context}") from e
+                _validate_rows_with_context(df, row_validator, func.__name__, param_name, False)
 
             return func(*args, **kwargs)