mcli-framework 7.12.2__py3-none-any.whl → 7.12.4__py3-none-any.whl

mcli/ml/optimization/portfolio_optimizer.py

@@ -1,19 +1,18 @@
-"""Advanced portfolio optimization for stock recommendations"""
+"""Advanced portfolio optimization for stock recommendations."""
 
 import logging
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta
+from datetime import datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple
 
 # Optimization libraries
 import cvxpy as cp
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-import seaborn as sns
 from scipy.optimize import minimize
 from scipy.stats import norm
 
@@ -21,7 +20,7 @@ logger = logging.getLogger(__name__)
 
 
 class OptimizationObjective(Enum):
-    """Portfolio optimization objectives"""
+    """Portfolio optimization objectives."""
 
     MEAN_VARIANCE = "mean_variance"
     RISK_PARITY = "risk_parity"
@@ -35,7 +34,7 @@ class OptimizationObjective(Enum):
 
 @dataclass
 class OptimizationConstraints:
-    """Portfolio optimization constraints"""
+    """Portfolio optimization constraints."""
 
     # Weight constraints
     min_weight: float = 0.0
@@ -66,7 +65,7 @@ class OptimizationConstraints:
 
 @dataclass
 class PortfolioAllocation:
-    """Portfolio allocation result"""
+    """Portfolio allocation result."""
 
     weights: Dict[str, float]
     expected_return: float
@@ -93,7 +92,7 @@ class PortfolioAllocation:
 
 
 class BaseOptimizer(ABC):
-    """Base class for portfolio optimizers"""
+    """Base class for portfolio optimizers."""
 
     def __init__(self, constraints: OptimizationConstraints):
         self.constraints = constraints
@@ -102,8 +101,7 @@ class BaseOptimizer(ABC):
     def optimize(
         self, expected_returns: pd.Series, covariance_matrix: pd.DataFrame, **kwargs
     ) -> PortfolioAllocation:
-        """Optimize portfolio allocation"""
-        pass
+        """Optimize portfolio allocation."""
 
     def _calculate_portfolio_metrics(
         self,
@@ -112,7 +110,7 @@ class BaseOptimizer(ABC):
         covariance_matrix: pd.DataFrame,
         risk_free_rate: float = 0.02,
     ) -> Tuple[float, float, float]:
-        """Calculate portfolio return, volatility, and Sharpe ratio"""
+        """Calculate portfolio return, volatility, and Sharpe ratio."""
         portfolio_return = np.dot(weights, expected_returns)
         portfolio_variance = np.dot(weights.T, np.dot(covariance_matrix, weights))
         portfolio_volatility = np.sqrt(portfolio_variance)
@@ -132,7 +130,7 @@ class BaseOptimizer(ABC):
         covariance_matrix: pd.DataFrame,
         confidence_level: float = 0.95,
     ) -> Tuple[float, float]:
-        """Calculate Value at Risk and Conditional Value at Risk"""
+        """Calculate Value at Risk and Conditional Value at Risk."""
         portfolio_return = np.dot(weights, expected_returns)
         portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(covariance_matrix, weights)))
 
@@ -147,7 +145,7 @@ class BaseOptimizer(ABC):
 
 
 class MeanVarianceOptimizer(BaseOptimizer):
-    """Modern Portfolio Theory mean-variance optimizer"""
+    """Modern Portfolio Theory mean-variance optimizer."""
 
     def optimize(
         self,
@@ -156,7 +154,7 @@ class MeanVarianceOptimizer(BaseOptimizer):
         risk_aversion: float = 1.0,
         **kwargs,
     ) -> PortfolioAllocation:
-        """Optimize using mean-variance framework"""
+        """Optimize using mean-variance framework."""
         n_assets = len(expected_returns)
 
         # Decision variable: portfolio weights
@@ -213,15 +211,15 @@ class MeanVarianceOptimizer(BaseOptimizer):
 
 
 class RiskParityOptimizer(BaseOptimizer):
-    """Risk parity portfolio optimizer"""
+    """Risk parity portfolio optimizer."""
 
     def optimize(
         self, expected_returns: pd.Series, covariance_matrix: pd.DataFrame, **kwargs
     ) -> PortfolioAllocation:
-        """Optimize using risk parity approach"""
+        """Optimize using risk parity approach."""
 
         def risk_parity_objective(weights, cov_matrix):
-            """Risk parity objective function"""
+            """Risk parity objective function."""
             portfolio_vol = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
             marginal_contrib = np.dot(cov_matrix, weights) / portfolio_vol
             contrib = weights * marginal_contrib
@@ -282,7 +280,7 @@ class RiskParityOptimizer(BaseOptimizer):
 
 
 class BlackLittermanOptimizer(BaseOptimizer):
-    """Black-Litterman portfolio optimizer"""
+    """Black-Litterman portfolio optimizer."""
 
     def optimize(
         self,
@@ -295,7 +293,7 @@ class BlackLittermanOptimizer(BaseOptimizer):
         risk_aversion: float = 3.0,
         **kwargs,
     ) -> PortfolioAllocation:
-        """Optimize using Black-Litterman model"""
+        """Optimize using Black-Litterman model."""
 
         # Market capitalization weights (if not provided, use equal weights)
         if market_caps is None:
@@ -354,7 +352,7 @@ class BlackLittermanOptimizer(BaseOptimizer):
 
 
 class CVaROptimizer(BaseOptimizer):
-    """Conditional Value at Risk optimizer"""
+    """Conditional Value at Risk optimizer."""
 
     def optimize(
         self,
@@ -364,7 +362,7 @@ class CVaROptimizer(BaseOptimizer):
         confidence_level: float = 0.95,
         **kwargs,
     ) -> PortfolioAllocation:
-        """Optimize portfolio to minimize CVaR"""
+        """Optimize portfolio to minimize CVaR."""
 
         if scenarios is None:
             # Generate scenarios from normal distribution
@@ -434,12 +432,12 @@ class CVaROptimizer(BaseOptimizer):
 
 
 class KellyCriterionOptimizer(BaseOptimizer):
-    """Kelly Criterion optimizer for growth-optimal portfolios"""
+    """Kelly Criterion optimizer for growth-optimal portfolios."""
 
     def optimize(
         self, expected_returns: pd.Series, covariance_matrix: pd.DataFrame, **kwargs
     ) -> PortfolioAllocation:
-        """Optimize using Kelly Criterion"""
+        """Optimize using Kelly Criterion."""
 
         # Kelly optimal weights: w* = Σ^(-1) * μ
         # where μ is expected excess returns and Σ is covariance matrix
@@ -510,7 +508,7 @@ class KellyCriterionOptimizer(BaseOptimizer):
 
 
 class AdvancedPortfolioOptimizer:
-    """Advanced portfolio optimization system"""
+    """Advanced portfolio optimization system."""
 
     def __init__(self, constraints: Optional[OptimizationConstraints] = None):
         self.constraints = constraints or OptimizationConstraints()
@@ -533,7 +531,7 @@ class AdvancedPortfolioOptimizer:
         objective: OptimizationObjective = OptimizationObjective.MEAN_VARIANCE,
         **optimizer_kwargs,
     ) -> PortfolioAllocation:
-        """Optimize portfolio using specified objective"""
+        """Optimize portfolio using specified objective."""
 
         if objective not in self.optimizers:
             raise ValueError(f"Unsupported optimization objective: {objective}")
@@ -558,7 +556,7 @@ class AdvancedPortfolioOptimizer:
         objectives: List[OptimizationObjective],
         weights: Optional[List[float]] = None,
     ) -> PortfolioAllocation:
-        """Combine multiple optimization objectives"""
+        """Combine multiple optimization objectives."""
 
         if weights is None:
             weights = [1.0 / len(objectives)] * len(objectives)
@@ -608,7 +606,7 @@ class AdvancedPortfolioOptimizer:
     def efficient_frontier(
         self, expected_returns: pd.Series, covariance_matrix: pd.DataFrame, n_points: int = 20
     ) -> pd.DataFrame:
-        """Generate efficient frontier"""
+        """Generate efficient frontier."""
 
         min_vol_allocation = self.optimize_portfolio(
             expected_returns,
@@ -676,7 +674,7 @@ class AdvancedPortfolioOptimizer:
         target_allocation: PortfolioAllocation,
         rebalance_threshold: float = 0.05,
     ) -> Dict[str, Any]:
-        """Calculate rebalancing trades"""
+        """Calculate rebalancing trades."""
 
         trades = {}
         total_deviation = 0
@@ -709,9 +707,9 @@ class AdvancedPortfolioOptimizer:
         expected_returns: pd.Series,
         covariance_matrix: pd.DataFrame,
     ) -> PortfolioAllocation:
-        """Add additional metrics to allocation"""
+        """Add additional metrics to allocation."""
 
-        weights_array = np.array(
+        _weights_array = np.array(  # noqa: F841
             [allocation.weights.get(asset, 0) for asset in expected_returns.index]
         )
 
@@ -727,7 +725,7 @@ class AdvancedPortfolioOptimizer:
     def plot_allocation(
         self, allocation: PortfolioAllocation, save_path: Optional[Path] = None
     ) -> None:
-        """Plot portfolio allocation"""
+        """Plot portfolio allocation."""
 
         # Filter out zero weights
         non_zero_weights = {k: v for k, v in allocation.weights.items() if abs(v) > 0.001}
@@ -854,7 +852,7 @@ if __name__ == "__main__":
             weights=[0.7, 0.3],
         )
 
-        print(f"\nMULTI-OBJECTIVE Optimization:")
+        print("\nMULTI-OBJECTIVE Optimization:")
         print(f"Expected Return: {multi_obj_allocation.expected_return:.3f}")
         print(f"Volatility: {multi_obj_allocation.expected_volatility:.3f}")
         print(f"Sharpe Ratio: {multi_obj_allocation.sharpe_ratio:.3f}")

mcli/ml/predictions/__init__.py

@@ -1,4 +1,4 @@
-"""ML Predictions Module"""
+"""ML Predictions Module."""
 
 from .prediction_engine import PoliticianTradingPredictor
 

mcli/ml/preprocessing/__init__.py

@@ -1,4 +1,4 @@
-"""ML Data Preprocessing Module"""
+"""ML Data Preprocessing Module."""
 
 from .data_cleaners import MissingValueHandler, OutlierDetector, TradingDataCleaner
 from .feature_extractors import (

mcli/ml/preprocessing/data_cleaners.py

@@ -1,10 +1,10 @@
-"""Data cleaning utilities for ML preprocessing"""
+"""Data cleaning utilities for ML preprocessing."""
 
 import logging
 import re
 from dataclasses import dataclass
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Tuple, Union
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Tuple
 
 import numpy as np
 import pandas as pd
@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class CleaningStats:
-    """Statistics about data cleaning operations"""
+    """Statistics about data cleaning operations."""
 
     total_records: int
     cleaned_records: int
@@ -25,7 +25,7 @@ class CleaningStats:
 
 
 class TradingDataCleaner:
-    """Cleans and standardizes politician trading data for ML"""
+    """Cleans and standardizes politician trading data for ML."""
 
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
@@ -41,7 +41,7 @@ class TradingDataCleaner:
     def clean_trading_records(
         self, records: List[Dict[str, Any]]
     ) -> Tuple[List[Dict[str, Any]], CleaningStats]:
-        """Clean a batch of trading records"""
+        """Clean a batch of trading records."""
         self.cleaning_stats.total_records = len(records)
         cleaned_records = []
 
@@ -56,7 +56,7 @@ class TradingDataCleaner:
         return cleaned_records, self.cleaning_stats
 
     def _clean_single_record(self, record: Dict[str, Any]) -> Optional[Dict[str, Any]]:
-        """Clean a single trading record"""
+        """Clean a single trading record."""
         try:
             cleaned = record.copy()
 
@@ -86,7 +86,7 @@ class TradingDataCleaner:
             return None
 
     def _clean_politician_name(self, record: Dict[str, Any]) -> Dict[str, Any]:
-        """Clean and standardize politician names"""
+        """Clean and standardize politician names."""
         name_fields = ["politician_name", "name", "representative_name", "senator_name"]
 
         for field in name_fields:
@@ -113,7 +113,7 @@ class TradingDataCleaner:
         return record
 
     def _clean_transaction_amount(self, record: Dict[str, Any]) -> Dict[str, Any]:
-        """Clean and standardize transaction amounts"""
+        """Clean and standardize transaction amounts."""
         amount_fields = ["transaction_amount", "amount", "value", "transaction_value"]
 
         for field in amount_fields:
@@ -148,7 +148,7 @@ class TradingDataCleaner:
         return record
 
     def _clean_transaction_date(self, record: Dict[str, Any]) -> Dict[str, Any]:
-        """Clean and standardize transaction dates"""
+        """Clean and standardize transaction dates."""
         date_fields = ["transaction_date", "date", "trade_date", "disclosure_date"]
 
         for field in date_fields:
@@ -183,7 +183,7 @@ class TradingDataCleaner:
                         date_obj = pd.to_datetime(date_str)
                         record["transaction_date_cleaned"] = date_obj.strftime("%Y-%m-%d")
                         self._increment_cleaning_operation("transaction_date_cleaned")
-                    except:
+                    except Exception:
                         continue
 
                 if "transaction_date_cleaned" in record:
@@ -192,8 +192,7 @@ class TradingDataCleaner:
         return record
 
     def _clean_asset_info(self, record: Dict[str, Any]) -> Dict[str, Any]:
-        """Clean and standardize asset information"""
-        asset_fields = ["asset_name", "stock_symbol", "ticker", "security_name"]
+        """Clean and standardize asset information."""
 
         # Clean ticker/symbol
         for field in ["stock_symbol", "ticker", "symbol"]:
@@ -230,7 +229,7 @@ class TradingDataCleaner:
         return record
 
     def _clean_transaction_type(self, record: Dict[str, Any]) -> Dict[str, Any]:
-        """Clean and standardize transaction types"""
+        """Clean and standardize transaction types."""
         type_fields = ["transaction_type", "type", "action", "trade_type"]
 
         for field in type_fields:
@@ -254,7 +253,7 @@ class TradingDataCleaner:
         return record
 
     def _validate_required_fields(self, record: Dict[str, Any]) -> bool:
-        """Validate that required fields exist after cleaning"""
+        """Validate that required fields exist after cleaning."""
         required_fields = [
             "politician_name_cleaned",
             "transaction_date_cleaned",
@@ -272,14 +271,14 @@ class TradingDataCleaner:
         return has_required and amount_or_asset
 
     def _increment_cleaning_operation(self, operation: str):
-        """Track cleaning operations"""
+        """Track cleaning operations."""
         if operation not in self.cleaning_stats.cleaning_operations:
             self.cleaning_stats.cleaning_operations[operation] = 0
         self.cleaning_stats.cleaning_operations[operation] += 1
 
 
 class OutlierDetector:
-    """Detects and handles outliers in trading data"""
+    """Detects and handles outliers in trading data."""
 
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
@@ -297,7 +296,7 @@ class OutlierDetector:
         }
 
     def detect_outliers(self, df: pd.DataFrame) -> Tuple[pd.DataFrame, Dict[str, Any]]:
-        """Detect outliers in the dataset"""
+        """Detect outliers in the dataset."""
         outlier_info = {"total_outliers": 0, "outliers_by_field": {}, "outlier_indices": set()}
 
         # Amount-based outliers
@@ -328,7 +327,7 @@ class OutlierDetector:
         return df, outlier_info
 
     def _detect_amount_outliers(self, df: pd.DataFrame) -> List[int]:
-        """Detect amount-based outliers"""
+        """Detect amount-based outliers."""
         outliers = []
         amount_col = "transaction_amount_cleaned"
 
@@ -344,7 +343,7 @@ class OutlierDetector:
         return list(set(outliers))
 
     def _detect_date_outliers(self, df: pd.DataFrame) -> List[int]:
-        """Detect date-based outliers"""
+        """Detect date-based outliers."""
         outliers = []
         date_col = "transaction_date_cleaned"
 
@@ -365,7 +364,7 @@ class OutlierDetector:
         return list(set(outliers))
 
     def _detect_statistical_outliers(self, df: pd.DataFrame, column: str) -> List[int]:
-        """Detect statistical outliers using Z-score"""
+        """Detect statistical outliers using Z-score."""
         outliers = []
 
         if column not in df.columns or df[column].dtype not in [np.number, "float64", "int64"]:
@@ -387,7 +386,7 @@ class OutlierDetector:
 
 
 class MissingValueHandler:
-    """Handles missing values in trading data"""
+    """Handles missing values in trading data."""
 
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
@@ -401,7 +400,7 @@ class MissingValueHandler:
         }
 
     def handle_missing_values(self, df: pd.DataFrame) -> Tuple[pd.DataFrame, Dict[str, Any]]:
-        """Handle missing values according to strategies"""
+        """Handle missing values according to strategies."""
         missing_info = {
             "original_shape": df.shape,
             "missing_counts": df.isnull().sum().to_dict(),

mcli/ml/preprocessing/feature_extractors.py

@@ -1,11 +1,8 @@
-"""Feature extraction utilities for ML preprocessing"""
+"""Feature extraction utilities for ML preprocessing."""
 
 import logging
-import re
-from collections import Counter, defaultdict
 from dataclasses import dataclass
-from datetime import datetime, timedelta
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, Optional
 
 import numpy as np
 import pandas as pd
@@ -15,7 +12,7 @@ logger = logging.getLogger(__name__)
 
 @dataclass
 class FeatureExtractionStats:
-    """Statistics about feature extraction operations"""
+    """Statistics about feature extraction operations."""
 
     total_records: int
     features_extracted: int
@@ -25,7 +22,7 @@ class FeatureExtractionStats:
 
 
 class PoliticianFeatureExtractor:
-    """Extracts features related to politicians"""
+    """Extracts features related to politicians."""
 
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
@@ -39,7 +36,7 @@ class PoliticianFeatureExtractor:
         }
 
     def extract_politician_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract politician-related features"""
+        """Extract politician-related features."""
         df_features = df.copy()
 
         # Basic politician features
@@ -51,7 +48,7 @@ class PoliticianFeatureExtractor:
         return df_features
 
     def _extract_name_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract features from politician names"""
+        """Extract features from politician names."""
         if "politician_name_cleaned" not in df.columns:
             return df
 
@@ -72,7 +69,7 @@ class PoliticianFeatureExtractor:
         return df
 
     def _extract_trading_patterns(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract trading pattern features for each politician"""
+        """Extract trading pattern features for each politician."""
         if "politician_name_cleaned" not in df.columns:
             return df
 
@@ -147,7 +144,7 @@ class PoliticianFeatureExtractor:
         return df
 
     def _extract_frequency_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract trading frequency features"""
+        """Extract trading frequency features."""
         if not all(
             col in df.columns for col in ["politician_name_cleaned", "transaction_date_cleaned"]
         ):
@@ -189,7 +186,7 @@ class PoliticianFeatureExtractor:
         return df
 
     def _extract_timing_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract timing-related features"""
+        """Extract timing-related features."""
         if "transaction_date_dt" not in df.columns:
             return df
 
@@ -220,14 +217,14 @@ class PoliticianFeatureExtractor:
 
 
 class MarketFeatureExtractor:
-    """Extracts market-related features"""
+    """Extracts market-related features."""
 
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
         self.sector_mapping = self._load_sector_mapping()
 
     def extract_market_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract market-related features"""
+        """Extract market-related features."""
         df_features = df.copy()
 
         # Asset features
@@ -238,7 +235,7 @@ class MarketFeatureExtractor:
         return df_features
 
     def _extract_asset_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract features from asset names"""
+        """Extract features from asset names."""
         if "asset_name_cleaned" not in df.columns:
             return df
 
@@ -270,7 +267,7 @@ class MarketFeatureExtractor:
         return df
 
     def _extract_ticker_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract features from stock tickers"""
+        """Extract features from stock tickers."""
         if "ticker_cleaned" not in df.columns:
             return df
 
@@ -288,7 +285,7 @@ class MarketFeatureExtractor:
         return df
 
     def _extract_market_cap_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract market cap related features (placeholder)"""
+        """Extract market cap related features (placeholder)."""
         # This would typically connect to external APIs
         # For now, create estimated features based on transaction amounts
 
@@ -311,7 +308,7 @@ class MarketFeatureExtractor:
         return df
 
     def _load_sector_mapping(self) -> Dict[str, str]:
-        """Load ticker to sector mapping (simplified)"""
+        """Load ticker to sector mapping (simplified)."""
         # This would typically be loaded from a data file or API
         return {
             "AAPL": "technology",
@@ -333,14 +330,14 @@ class MarketFeatureExtractor:
 
 
 class TemporalFeatureExtractor:
-    """Extracts temporal features for time series analysis"""
+    """Extracts temporal features for time series analysis."""
 
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
         self.lookback_periods = config.get("lookback_periods", [7, 30, 90, 365])
 
     def extract_temporal_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract temporal features"""
+        """Extract temporal features."""
         df_features = df.copy()
 
         if "transaction_date_dt" not in df.columns:
@@ -357,7 +354,7 @@ class TemporalFeatureExtractor:
         return df_features
 
     def _extract_rolling_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract rolling window features"""
+        """Extract rolling window features."""
         # Set date as index temporarily
         df_indexed = df.set_index("transaction_date_dt")
 
@@ -389,7 +386,7 @@ class TemporalFeatureExtractor:
         return df
 
     def _extract_lag_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract lagged features"""
+        """Extract lagged features."""
         lag_periods = [1, 7, 30]
 
         for lag in lag_periods:
@@ -406,7 +403,7 @@ class TemporalFeatureExtractor:
         return df
 
     def _extract_trend_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract trend features"""
+        """Extract trend features."""
         # Calculate percentage changes
         df["amount_pct_change_1d"] = df.groupby("politician_name_cleaned")[
             "transaction_amount_cleaned"
@@ -439,7 +436,7 @@ class TemporalFeatureExtractor:
 
 
 class SentimentFeatureExtractor:
-    """Extracts sentiment and text-based features"""
+    """Extracts sentiment and text-based features."""
 
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         self.config = config or {}
@@ -447,7 +444,7 @@ class SentimentFeatureExtractor:
         self.negative_words = ["loss", "down", "bear", "decline", "weak", "fall", "drop"]
 
     def extract_sentiment_features(self, df: pd.DataFrame) -> pd.DataFrame:
-        """Extract sentiment features from text fields"""
+        """Extract sentiment features from text fields."""
         df_features = df.copy()
 
         # Asset name sentiment
@@ -465,7 +462,7 @@ class SentimentFeatureExtractor:
     def _extract_text_sentiment(
         self, df: pd.DataFrame, text_column: str, prefix: str
     ) -> pd.DataFrame:
-        """Extract sentiment from text column"""
+        """Extract sentiment from text column."""
         if text_column not in df.columns:
             return df