feat: implement singleton pattern for SecureExpressionEvaluator (#105)

* feat: implement singleton pattern for SecureExpressionEvaluator

Added performance optimization through singleton pattern implementation:

• **Singleton Pattern**: Replaced per-call SecureExpressionEvaluator() instantiation
  with get_secure_expression_evaluator() singleton access for improved performance

• **Performance Benefits**: Eliminates expensive object initialization overhead on
  every expression evaluation while maintaining thread safety

• **API Compatibility**: Updated evaluate_expression_safely() and validate_expression_safety()
  to use singleton pattern while preserving existing function interfaces

• **Testing Support**: Added reset_secure_expression_evaluator() function for test
  isolation and create_secure_expression_evaluator() factory function

• **Memory Efficiency**: Single evaluator instance reused across all expression
  operations instead of creating new instances repeatedly

• **Quality Assurance**: All 997 tests passing with ruff and mypy compliance maintained

This follows the same singleton pattern established for session management, providing
consistent architecture patterns and improved resource utilization for expression-heavy
operations throughout DataBeak.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Interim commit for session dependency injection cleanup

* feat: implement comprehensive Pandera validation integration

Major enhancements to validation system:

- Added pandera dependency for industry-standard validation framework
- Replaced ColumnValidationRules with comprehensive Pandera Field/Check capabilities
- Implemented Pandera validation logic replacing manual validation
- Enhanced documentation with official Pandera API references
- Removed duplicate functionality (unused pandera_schemas module, 179 tests)
- Streamlined ValidationError model (removed 9 legacy fields)
- Updated all validation tests for new Pandera field names

Quality verification:
- MyPy: Perfect compliance (validation components)
- Tests: All 41 validation tests passing
- Functionality: Robust validation using industry-standard framework

This establishes DataBeak validation on professional-grade Pandera framework
with comprehensive rule coverage and clean architecture.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* fix: add pandera to mypy pre-commit dependencies

Resolves mypy hook failure by adding pandera>=0.22.0 to the mypy
additional_dependencies list in pre-commit configuration.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* fix: improve YAML formatting in pre-commit config

Breaks long description lines to comply with yamllint line length rules
using proper YAML multi-line format.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* fix: improve pre-commit configuration and markdown formatting

- Remove docformatter from pre-commit hooks to eliminate ruff conflicts
- Add py.typed marker file for proper MyPy module resolution
- Configure MyPy pre-commit hook to check source only, add local package dependency
- Add mdformat-ruff integration for consistent Python code block formatting
- Apply comprehensive mdformat fixes across all project documentation
- Update quality-gate-runner documentation to remove docformatter references

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* refactor: implement singleton patterns for session and settings management

- Centralize SessionManager creation with thread-safe singleton
- Implement singleton pattern for DataBeakSettings initialization
- Standardize get_session_manager() calls across all servers
- Remove redundant SessionManager instantiations
- Improve dependency injection patterns throughout codebase
- Reduce code duplication and ensure consistent state management

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

* Final bug fixes and tweaks

* Reset is also thread-safe

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: jonpspri

.claude/agents/mcp-tool-generator.md

@@ -64,22 +64,25 @@ logger = logging.getLogger(__name__)
 # PYDANTIC MODELS (Domain-specific, self-contained)
 # ============================================================================
 
+
 class DomainResult(BaseModel):
     """Response model for domain operations."""
 
-    model_config = ConfigDict(extra='forbid')
+    model_config = ConfigDict(extra="forbid")
 
     session_id: str
     success: bool = True
     data: dict[str, Any] = Field(default_factory=dict)
 
+
 class DomainRule(BaseModel):
     """Base class for domain rules."""
 
-    model_config = ConfigDict(extra='forbid')
+    model_config = ConfigDict(extra="forbid")
 
     type: str
 
+
 class SpecificRule(DomainRule):
     """Specific rule implementation."""
 
@@ -94,16 +97,18 @@ class SpecificRule(DomainRule):
             raise ValueError("Threshold must be between 0.0 and 1.0")
         return v
 
+
 # Discriminated union for automatic type conversion
 DomainRuleType = Annotated[
     SpecificRule,  # Add more rule types here
-    Field(discriminator="type")
+    Field(discriminator="type"),
 ]
 
 # ============================================================================
 # DOMAIN LOGIC (Synchronous for computational operations)
 # ============================================================================
 
+
 def process_domain_operation(
     session_id: str,
     rules: list[DomainRuleType] | None = None,
@@ -147,18 +152,16 @@ def process_domain_operation(
                 "operation": "domain_operation",
                 "rules_count": len(rules),
                 "results_count": len(results),
-            }
+            },
         )
 
-        return DomainResult(
-            session_id=session_id,
-            data={"results": results, "total": len(results)}
-        )
+        return DomainResult(session_id=session_id, data={"results": results, "total": len(results)})
 
     except Exception as e:
         logger.error(f"Error in domain operation: {e!s}")
         raise ToolError(f"Error processing domain operation: {e!s}") from e
 
+
 # ============================================================================
 # FASTMCP SERVER SETUP
 # ============================================================================
@@ -193,23 +196,24 @@ mcp.mount(domain_server)
 ```python
 # Base class with discriminator
 class BaseRule(BaseModel):
-    model_config = ConfigDict(extra='forbid')
+    model_config = ConfigDict(extra="forbid")
     type: str
 
+
 # Specific implementations
 class TypeARule(BaseRule):
     type: Literal["type_a"] = "type_a"
     param1: str
 
+
 class TypeBRule(BaseRule):
     type: Literal["type_b"] = "type_b"
     param2: int = Field(ge=0)
 
+
 # Discriminated union for automatic conversion
-RuleType = Annotated[
-    TypeARule | TypeBRule,
-    Field(discriminator="type")
-]
+RuleType = Annotated[TypeARule | TypeBRule, Field(discriminator="type")]
+
 
 # Usage in function
 def process_rules(rules: list[RuleType]) -> Results:
@@ -224,12 +228,10 @@ def process_rules(rules: list[RuleType]) -> Results:
 class DomainModel(BaseModel):
     """Model with comprehensive validation."""
 
-    model_config = ConfigDict(extra='forbid')
+    model_config = ConfigDict(extra="forbid")
 
     # Use Literal for known values (compile-time safety)
-    status: Literal["active", "inactive", "pending"] = Field(
-        description="Processing status"
-    )
+    status: Literal["active", "inactive", "pending"] = Field(description="Processing status")
 
     # Use field validation for complex rules
     pattern: str | None = Field(None, description="Regex pattern")
@@ -242,6 +244,7 @@ class DomainModel(BaseModel):
             return v
 
         import re
+
         try:
             re.compile(v)
             return v
@@ -343,6 +346,7 @@ class IntegrationTestCase(unittest.IsolatedAsyncioTestCase):
             except Exception:
                 pass
 
+
 class TestDomainIntegration(IntegrationTestCase):
     """Integration tests for domain operations."""
 

.claude/agents/python-type-optimizer.md

@@ -53,18 +53,21 @@ return {"success": False, "error": str(e)}
 ```python
 from typing import TypedDict, Literal
 
+
 class OperationSuccess(TypedDict):
     success: Literal[True]
     data: dict[str, CellValue] | list[dict[str, CellValue]]
     session_id: str
     rows_affected: int | None
     message: str
 
+
 class OperationError(TypedDict):
     success: Literal[False]
     error: str | dict[str, str]
     session_id: str | None
 
+
 OperationResult = OperationSuccess | OperationError
 ```
 
@@ -98,6 +101,7 @@ class NumericColumnStats(TypedDict):
     skewness: float
     kurtosis: float
 
+
 class StatisticsResult(TypedDict):
     success: Literal[True]
     statistics: dict[str, NumericColumnStats]
@@ -114,11 +118,10 @@ class AutoSaveConfigDict(TypedDict):
     backup_directory: str
     format: Literal["csv", "tsv", "json", "excel", "parquet"]
 
+
 class FilterCondition(TypedDict):
     column: str
-    operator: Literal[
-        "==", "!=", ">", "<", ">=", "<=", "contains", "startswith", "endswith"
-    ]
+    operator: Literal["==", "!=", ">", "<", ">=", "<=", "contains", "startswith", "endswith"]
     value: CellValue
 ```
 
@@ -187,23 +190,28 @@ CellValue = str | int | float | bool | None
 RowData = dict[str, CellValue]
 DataFrame = pd.DataFrame
 
+
 # Base operation result types
 class BaseOperationResult(TypedDict):
     success: bool
     session_id: str | None
 
+
 class SuccessfulOperationResult(BaseOperationResult):
     success: Literal[True]
     message: str
     rows_affected: int | None
     columns_affected: list[str] | None
 
+
 class FailedOperationResult(BaseOperationResult):
     success: Literal[False]
     error: str | dict[str, str]
 
+
 OperationResult = SuccessfulOperationResult | FailedOperationResult
 
+
 # Session types
 class SessionMetadata(TypedDict):
     created_at: str
@@ -212,6 +220,7 @@ class SessionMetadata(TypedDict):
     auto_save_enabled: bool
     file_path: str | None
 
+
 # Configuration types
 class DataBeakSettings(TypedDict):
     session_timeout_minutes: int
@@ -303,11 +312,13 @@ class ToolSuccessResponse(TypedDict):
     metadata: dict[str, int | str]  # Not Any
     session_id: str
 
+
 class ToolErrorResponse(TypedDict):
     success: Literal[False]
     error: dict[str, str]  # Structured error info
     session_id: str | None
 
+
 ToolResponse = ToolSuccessResponse | ToolErrorResponse
 ```
 
@@ -322,7 +333,7 @@ class DataBeakErrorInfo(TypedDict):
         "NoDataLoadedError",
         "ColumnNotFoundError",
         "InvalidParameterError",
-        "DataProcessingError"
+        "DataProcessingError",
     ]
     message: str
     details: dict[str, str] | None

.claude/agents/quality-gate-runner.md

@@ -89,7 +89,6 @@ uv run pre-commit run --all-files
 # Fix specific hook types
 uv run pre-commit run ruff --all-files
 uv run pre-commit run ruff-format --all-files
-uv run pre-commit run docformatter --all-files
 ```
 
 #### Individual Tool Auto-fixes
@@ -116,7 +115,6 @@ The project uses a comprehensive pre-commit setup with these tools:
 - **Ruff**: Linting and formatting (replaces Black, isort, autoflake, pyupgrade)
 - **MyPy**: Type checking with pandas-stubs
 - **Bandit**: Security scanning
-- **docformatter**: Docstring formatting
 - **markdownlint**: Documentation quality
 - **License insertion**: Automatic Apache license headers
 
@@ -184,6 +182,7 @@ from fastmcp import Context  # TC003 error
 
 # Fix: Move to TYPE_CHECKING block
 from typing import TYPE_CHECKING
+
 if TYPE_CHECKING:
     from fastmcp import Context
 ```
@@ -213,8 +212,9 @@ assert "DataBeak" in result["message"]
 
 ```python
 # Add coverage-focused test files
-tests/test_analytics_coverage.py
-tests/test_validation_coverage.py
+tests / test_analytics_coverage.py
+tests / test_validation_coverage.py
+
 
 # Test error handling paths
 async def test_handles_empty_dataframe(self, empty_session):
@@ -234,6 +234,7 @@ async def test_session_with_data():
     result = await load_csv_from_content(csv_content)
     return result["session_id"]
 
+
 # Error handling test pattern
 async def test_invalid_session_handling(self):
     result = await tool_function("invalid_session", "param")

.claude/agents/test-coverage-analyzer.md

@@ -109,7 +109,7 @@ class TestStatisticsServer:
     @pytest.fixture
     def mock_session(self):
         """Create mock session."""
-        with patch('get_session_manager') as mock:
+        with patch("get_session_manager") as mock:
             session = MagicMock()
             session.data_session.df = pd.DataFrame(test_data)
             mock.return_value.get_session.return_value = session
@@ -175,14 +175,15 @@ Create tests in the appropriate tier:
 # tests/unit/servers/test_statistics_server.py
 async def test_handles_empty_dataframe(self):
     """Test statistics with empty DataFrame."""
-    with patch('get_session_manager') as mock:
+    with patch("get_session_manager") as mock:
         session = MagicMock()
         session.data_session.df = pd.DataFrame()
         mock.return_value.get_session.return_value = session
 
         with pytest.raises(ToolError, match="No data"):
             await get_statistics("session-id")
 
+
 # Integration test for workflow
 # tests/integration/test_analytics_workflow.py
 async def test_statistics_to_export_workflow(self):
@@ -236,6 +237,7 @@ async def test_statistics_to_export_workflow(self):
        # Wait for timeout
        # Verify cleanup
 
+
    async def test_concurrent_sessions(self):
        """Test concurrent session operations."""
        # Create multiple sessions
@@ -251,6 +253,7 @@ async def test_statistics_to_export_workflow(self):
        # Test type conversion failures
        # Test validation error messages
 
+
    async def test_malformed_input(self):
        """Test malformed input handling."""
        # Test parsing errors

.claude/planning/REFACTORING_CHECKLIST.md

@@ -27,6 +27,7 @@ async def filter_rows(
     # Implementation here
     pass
 
+
 # Register at the end of file
 server = FastMCP("Server Name")
 server.tool(name="filter_rows")(filter_rows)
@@ -148,6 +149,7 @@ Is the model used by multiple servers?
 # In server file
 class ColumnOperationResult(BaseModel):
     """Result of a column operation (local to this server)."""
+
     session_id: str
     operation: str
     rows_affected: int
@@ -160,6 +162,7 @@ class ColumnOperationResult(BaseModel):
 # In models/tool_responses.py (shared across servers)
 class LoadResult(BaseModel):
     """Result of loading data (used by multiple servers)."""
+
     session_id: str
     success: bool
     rows_affected: int
@@ -188,6 +191,7 @@ Is the exception used by multiple servers?
 # In server file
 class FilterExpressionError(Exception):
     """Error in filter expression syntax (specific to this server)."""
+
     pass
 ```
 
@@ -248,13 +252,11 @@ async def test_session() -> str:
     result = await load_csv_from_content(csv_content)
     return result.session_id
 
+
 @pytest.mark.asyncio
 async def test_filter_rows_basic(test_session):
     """Test basic filtering functionality."""
-    result = await filter_rows(
-        test_session,
-        [{"column": "age", "operator": ">", "value": 25}]
-    )
+    result = await filter_rows(test_session, [{"column": "age", "operator": ">", "value": 25}])
     assert result.rows_after == 1
     assert result.rows_filtered == 1
 ```

.github/ISSUE_TEMPLATE/feature_request.md

@@ -26,9 +26,7 @@ any alternative solutions or features you've considered.
 ```python
 # Example usage
 databeak.new_feature(
-    input_file="data.csv",
-    operation="your_feature",
-    parameters={"param1": "value1"}
+    input_file="data.csv", operation="your_feature", parameters={"param1": "value1"}
 )
 ```