import pandas as pd
from forge import AutoFeatureTransformer

# Load your data
X = pd.read_csv("data.csv")
y = pd.read_csv("labels.csv")["target"]

# Automatic feature engineering
transformer = AutoFeatureTransformer(max_features=100)
X_engineered = transformer.fit_transform(X, y)

# View generated features
print(f"Generated {len(transformer.get_feature_names_out())} features")
print(transformer.get_feature_importance().head(10))

from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier
from forge import AutoFeatureTransformer

pipeline = Pipeline([
    ("features", AutoFeatureTransformer(max_features=50)),
    ("classifier", RandomForestClassifier(n_estimators=100)),
])

pipeline.fit(X_train, y_train)
predictions = pipeline.predict(X_test)

from forge.generators.numeric import InteractionGenerator, PolynomialGenerator
from forge.generators.categorical import TargetEncoder
from forge.transformers import ForgePipeline

pipeline = ForgePipeline([
    ("interactions", InteractionGenerator(columns=["price", "quantity"])),
    ("polynomials", PolynomialGenerator(degree=2)),
    ("encoding", TargetEncoder(columns=["category", "region"])),
])

X_features = pipeline.fit_transform(X, y)

from forge.analyzer import DataAnalyzer

analyzer = DataAnalyzer()
report = analyzer.analyze(X, y)

print(report.summary())
print(report.column_types)
print(report.quality_issues)

from forge import PSICalculator, DriftDetector

# Fit on training data
drift_monitor = PSICalculator(threshold=0.2)
drift_monitor.fit(X_train)

# Check for drift in production data
drift_monitor.transform(X_prod)
summary = drift_monitor.get_drift_summary()

if summary["flagged_features"]:
    print(f"Drift detected in: {summary['flagged_features']}")

from forge.utils.memory import (
    estimate_feature_engineering_memory,
    process_in_chunks,
    check_memory_and_warn,
)

# Estimate memory before processing
estimate = estimate_feature_engineering_memory(X, max_features=100)
print(estimate)  # Shows peak memory, availability, recommendations

# Process large datasets in chunks
result = process_in_chunks(transformer, X, y, chunk_size=100_000)

AutoFeatureTransformer(
    max_features: int | float | None = None,    # Max features to keep
    numeric_transformations: list[str] = None,  # ["log", "sqrt", "bin"]
    categorical_encoding: str = "auto",         # Encoding strategy
    temporal_features: list[str] = None,        # Temporal components
    missing_strategy: str = "auto",             # Imputation strategy
    selection_method: str = "importance",       # Selection method
    n_jobs: int = -1,                           # Parallel jobs
    random_state: int | None = None,            # Random seed
    verbose: int = 0,                           # Verbosity level
)