churnkit 0.75.0a1__py3-none-any.whl

customer_retention/integrations/streaming/early_warning_model.py

@@ -0,0 +1,227 @@
+import pickle
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Dict, List, Optional, Tuple
+
+
+class WarningLevel(Enum):
+    LOW = "low"
+    MEDIUM = "medium"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+class SignalType(Enum):
+    ACTIVITY_DROP = "activity_drop"
+    DORMANT_RISK = "dormant_risk"
+    SUPPORT_SPIKE = "support_spike"
+    PAYMENT_ISSUE = "payment_issue"
+    EXPLICIT_SIGNAL = "explicit_signal"
+
+
+@dataclass
+class EarlyWarningConfig:
+    activity_drop_threshold: float = 0.50
+    dormant_days_threshold: int = 14
+    support_spike_count: int = 3
+    support_spike_window_days: int = 7
+    low_threshold: float = 0.30
+    medium_threshold: float = 0.30
+    high_threshold: float = 0.50
+    critical_threshold: float = 0.90
+
+
+@dataclass
+class WarningResult:
+    customer_id: str
+    warning_score: float
+    warning_level: WarningLevel
+    warning_signals: List[SignalType]
+    primary_signal: Optional[SignalType]
+    timestamp: datetime
+    recommended_action: Optional[str]
+
+    def to_alert(self):
+        from customer_retention.stages.monitoring import Alert, AlertLevel
+        level_mapping = {
+            WarningLevel.LOW: AlertLevel.INFO,
+            WarningLevel.MEDIUM: AlertLevel.WARNING,
+            WarningLevel.HIGH: AlertLevel.WARNING,
+            WarningLevel.CRITICAL: AlertLevel.CRITICAL
+        }
+        return Alert(
+            alert_id=f"streaming_warning_{self.customer_id}_{self.timestamp.isoformat()}",
+            condition_id="STREAMING_WARNING",
+            level=level_mapping.get(self.warning_level, AlertLevel.INFO),
+            message=f"Early warning for customer {self.customer_id}: {self.warning_level.value} risk (score: {self.warning_score:.2f})",
+            timestamp=self.timestamp
+        )
+
+
+class SignalDetector:
+    def __init__(self, activity_drop_threshold: float = 0.50, dormant_days_threshold: int = 14,
+                 support_spike_threshold: int = 3):
+        self._activity_threshold = activity_drop_threshold
+        self._dormant_threshold = dormant_days_threshold
+        self._support_threshold = support_spike_threshold
+
+    def detect(self, features: Dict[str, float]) -> List[SignalType]:
+        signals = []
+        if features.get("activity_drop_7d", 0) >= self._activity_threshold:
+            signals.append(SignalType.ACTIVITY_DROP)
+        if features.get("days_since_last_order", 0) >= self._dormant_threshold:
+            signals.append(SignalType.DORMANT_RISK)
+        if features.get("support_tickets_7d", 0) >= self._support_threshold:
+            signals.append(SignalType.SUPPORT_SPIKE)
+        if features.get("payment_failure", 0) > 0:
+            signals.append(SignalType.PAYMENT_ISSUE)
+        if features.get("email_unsubscribe", 0) > 0:
+            signals.append(SignalType.EXPLICIT_SIGNAL)
+        return signals
+
+
+class EarlyWarningModel:
+    def __init__(self, config: Optional[EarlyWarningConfig] = None):
+        self._config = config or EarlyWarningConfig()
+        self._signal_detector = SignalDetector(
+            activity_drop_threshold=self._config.activity_drop_threshold,
+            dormant_days_threshold=self._config.dormant_days_threshold,
+            support_spike_threshold=self._config.support_spike_count
+        )
+        self._weights = {
+            "activity_drop_7d": 0.25,
+            "days_since_last_order": 0.20,
+            "support_tickets_7d": 0.20,
+            "email_unsubscribe": 0.15,
+            "payment_failure": 0.30,
+            "session_abandon_rate": 0.10,
+            "negative_review": 0.10
+        }
+        self._trained = False
+        self._model = None
+
+    def predict(self, customer_id: str, features: Dict[str, float]) -> WarningResult:
+        score = self._compute_score(features)
+        level = self.score_to_level(score)
+        signals = self._signal_detector.detect(features)
+        primary = self._get_primary_signal(features, signals)
+        action = self._get_recommended_action(primary, level)
+        return WarningResult(
+            customer_id=customer_id,
+            warning_score=score,
+            warning_level=level,
+            warning_signals=signals,
+            primary_signal=primary,
+            timestamp=datetime.now(),
+            recommended_action=action
+        )
+
+    def predict_batch(self, customers: Dict[str, Dict[str, float]]) -> Dict[str, WarningResult]:
+        return {cust_id: self.predict(cust_id, features) for cust_id, features in customers.items()}
+
+    def score_to_level(self, score: float) -> WarningLevel:
+        if score >= self._config.critical_threshold:
+            return WarningLevel.CRITICAL
+        elif score >= self._config.high_threshold:
+            return WarningLevel.HIGH
+        elif score >= self._config.medium_threshold:
+            return WarningLevel.MEDIUM
+        return WarningLevel.LOW
+
+    def get_feature_importance(self) -> Dict[str, float]:
+        return self._weights.copy()
+
+    def train(self, training_data: List[Tuple[Dict[str, float], int]]):
+        try:
+            import numpy as np
+            from sklearn.linear_model import LogisticRegression
+            feature_names = sorted(self._weights.keys())
+            X = []
+            y = []
+            for features, label in training_data:
+                row = [features.get(f, 0.0) for f in feature_names]
+                X.append(row)
+                y.append(label)
+            self._model = LogisticRegression()
+            self._model.fit(np.array(X), np.array(y))
+            self._trained = True
+            for i, name in enumerate(feature_names):
+                self._weights[name] = abs(self._model.coef_[0][i])
+            total = sum(self._weights.values())
+            self._weights = {k: v / total for k, v in self._weights.items()}
+        except ImportError:
+            pass
+
+    def to_bytes(self) -> bytes:
+        return pickle.dumps({
+            "config": self._config,
+            "weights": self._weights,
+            "model": self._model,
+            "trained": self._trained
+        })
+
+    @classmethod
+    def from_bytes(cls, data: bytes) -> "EarlyWarningModel":
+        loaded = pickle.loads(data)
+        model = cls(config=loaded["config"])
+        model._weights = loaded["weights"]
+        model._model = loaded["model"]
+        model._trained = loaded["trained"]
+        return model
+
+    def _compute_score(self, features: Dict[str, float]) -> float:
+        if self._trained and self._model:
+            try:
+                import numpy as np
+                feature_names = sorted(self._weights.keys())
+                X = [[features.get(f, 0.0) for f in feature_names]]
+                return float(self._model.predict_proba(np.array(X))[0][1])
+            except Exception:
+                pass
+        score = 0.0
+        normalized_features = self._normalize_features(features)
+        for feature_name, weight in self._weights.items():
+            value = normalized_features.get(feature_name, 0.0)
+            score += weight * value
+        return min(max(score, 0.0), 1.0)
+
+    def _normalize_features(self, features: Dict[str, float]) -> Dict[str, float]:
+        normalized = {}
+        normalized["activity_drop_7d"] = min(features.get("activity_drop_7d", 0), 1.0)
+        days = features.get("days_since_last_order", 0)
+        normalized["days_since_last_order"] = min(days / 30.0, 1.0)
+        tickets = features.get("support_tickets_7d", 0)
+        normalized["support_tickets_7d"] = min(tickets / 5.0, 1.0)
+        normalized["email_unsubscribe"] = min(features.get("email_unsubscribe", 0), 1.0)
+        normalized["payment_failure"] = min(features.get("payment_failure", 0), 1.0)
+        normalized["session_abandon_rate"] = min(features.get("session_abandon_rate", 0), 1.0)
+        normalized["negative_review"] = min(features.get("negative_review", 0), 1.0)
+        return normalized
+
+    def _get_primary_signal(self, features: Dict[str, float], signals: List[SignalType]) -> Optional[SignalType]:
+        if not signals:
+            return None
+        priority = [
+            SignalType.PAYMENT_ISSUE,
+            SignalType.EXPLICIT_SIGNAL,
+            SignalType.ACTIVITY_DROP,
+            SignalType.SUPPORT_SPIKE,
+            SignalType.DORMANT_RISK
+        ]
+        for signal in priority:
+            if signal in signals:
+                return signal
+        return signals[0]
+
+    def _get_recommended_action(self, primary_signal: Optional[SignalType], level: WarningLevel) -> Optional[str]:
+        if not primary_signal:
+            return None
+        action_mapping = {
+            SignalType.PAYMENT_ISSUE: "phone_call",
+            SignalType.EXPLICIT_SIGNAL: "immediate_escalation",
+            SignalType.ACTIVITY_DROP: "email_campaign",
+            SignalType.SUPPORT_SPIKE: "cs_followup",
+            SignalType.DORMANT_RISK: "re_engagement_email"
+        }
+        return action_mapping.get(primary_signal)

customer_retention/integrations/streaming/event_schema.py

@@ -0,0 +1,214 @@
+import json
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class EventSource(Enum):
+    WEBSITE = "website"
+    MOBILE_APP = "mobile_app"
+    EMAIL = "email"
+    SUPPORT = "support"
+    PURCHASE = "purchase"
+
+
+class EventType(Enum):
+    PAGE_VIEW = "page_view"
+    CLICK = "click"
+    SEARCH = "search"
+    APP_SESSION = "app_session"
+    APP_ACTION = "app_action"
+    APP_CRASH = "app_crash"
+    EMAIL_OPEN = "email_open"
+    EMAIL_CLICK = "email_click"
+    EMAIL_UNSUBSCRIBE = "email_unsubscribe"
+    SUPPORT_TICKET = "support_ticket"
+    SUPPORT_CHAT = "support_chat"
+    SUPPORT_CALL = "support_call"
+    ORDER = "order"
+    RETURN = "return"
+    REFUND = "refund"
+
+    @property
+    def source_category(self) -> EventSource:
+        mapping = {
+            EventType.PAGE_VIEW: EventSource.WEBSITE,
+            EventType.CLICK: EventSource.WEBSITE,
+            EventType.SEARCH: EventSource.WEBSITE,
+            EventType.APP_SESSION: EventSource.MOBILE_APP,
+            EventType.APP_ACTION: EventSource.MOBILE_APP,
+            EventType.APP_CRASH: EventSource.MOBILE_APP,
+            EventType.EMAIL_OPEN: EventSource.EMAIL,
+            EventType.EMAIL_CLICK: EventSource.EMAIL,
+            EventType.EMAIL_UNSUBSCRIBE: EventSource.EMAIL,
+            EventType.SUPPORT_TICKET: EventSource.SUPPORT,
+            EventType.SUPPORT_CHAT: EventSource.SUPPORT,
+            EventType.SUPPORT_CALL: EventSource.SUPPORT,
+            EventType.ORDER: EventSource.PURCHASE,
+            EventType.RETURN: EventSource.PURCHASE,
+            EventType.REFUND: EventSource.PURCHASE,
+        }
+        return mapping[self]
+
+
+@dataclass
+class Event:
+    event_id: str
+    customer_id: str
+    event_type: EventType
+    event_timestamp: datetime
+    event_source: EventSource
+    event_properties: Dict[str, Any]
+    session_id: Optional[str] = None
+    device_type: Optional[str] = None
+    ingestion_timestamp: datetime = field(default_factory=datetime.now)
+
+    @property
+    def ingestion_latency_seconds(self) -> float:
+        return (self.ingestion_timestamp - self.event_timestamp).total_seconds()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "event_id": self.event_id,
+            "customer_id": self.customer_id,
+            "event_type": self.event_type.value,
+            "event_timestamp": self.event_timestamp.isoformat(),
+            "event_source": self.event_source.value,
+            "event_properties": self.event_properties,
+            "session_id": self.session_id,
+            "device_type": self.device_type,
+            "ingestion_timestamp": self.ingestion_timestamp.isoformat()
+        }
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict(), indent=2)
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Event":
+        event_type = EventType(data["event_type"]) if isinstance(data["event_type"], str) else data["event_type"]
+        event_source = EventSource(data["event_source"]) if isinstance(data["event_source"], str) else data["event_source"]
+        event_timestamp = datetime.fromisoformat(data["event_timestamp"]) if isinstance(data["event_timestamp"], str) else data["event_timestamp"]
+        ingestion_timestamp = datetime.fromisoformat(data.get("ingestion_timestamp", datetime.now().isoformat())) if isinstance(data.get("ingestion_timestamp"), str) else data.get("ingestion_timestamp", datetime.now())
+        return cls(
+            event_id=data["event_id"],
+            customer_id=data["customer_id"],
+            event_type=event_type,
+            event_timestamp=event_timestamp,
+            event_source=event_source,
+            event_properties=data.get("event_properties", {}),
+            session_id=data.get("session_id"),
+            device_type=data.get("device_type"),
+            ingestion_timestamp=ingestion_timestamp
+        )
+
+    @staticmethod
+    def to_spark_schema():
+        try:
+            from pyspark.sql.types import MapType, StringType, StructField, StructType, TimestampType
+            return StructType([
+                StructField("event_id", StringType(), False),
+                StructField("customer_id", StringType(), False),
+                StructField("event_type", StringType(), False),
+                StructField("event_timestamp", TimestampType(), False),
+                StructField("event_source", StringType(), False),
+                StructField("event_properties", MapType(StringType(), StringType()), True),
+                StructField("session_id", StringType(), True),
+                StructField("device_type", StringType(), True),
+                StructField("ingestion_timestamp", TimestampType(), False)
+            ])
+        except ImportError:
+            return None
+
+
+@dataclass
+class ValidationResult:
+    is_valid: bool
+    errors: List[str] = field(default_factory=list)
+
+
+@dataclass
+class BatchValidationResult:
+    total_count: int
+    valid_count: int
+    invalid_count: int
+    invalid_events: List[Event] = field(default_factory=list)
+    errors: List[str] = field(default_factory=list)
+
+
+class EventValidator:
+    def __init__(self, max_age_days: int = 30, allow_future: bool = False):
+        self._max_age_days = max_age_days
+        self._allow_future = allow_future
+
+    def validate(self, event: Event) -> ValidationResult:
+        errors = []
+        if not event.event_id or event.event_id.strip() == "":
+            errors.append("event_id is required")
+        if not event.customer_id or event.customer_id.strip() == "":
+            errors.append("customer_id is required")
+        if not self._allow_future and event.event_timestamp > datetime.now():
+            errors.append("event_timestamp cannot be in the future")
+        if event.event_timestamp < datetime.now() - timedelta(days=self._max_age_days):
+            errors.append(f"event_timestamp is older than {self._max_age_days} days")
+        if event.event_type.source_category != event.event_source:
+            errors.append(f"event_type {event.event_type.value} does not match event_source {event.event_source.value}")
+        return ValidationResult(is_valid=len(errors) == 0, errors=errors)
+
+    def validate_batch(self, events: List[Event]) -> BatchValidationResult:
+        valid_count = 0
+        invalid_count = 0
+        invalid_events = []
+        all_errors = []
+        for event in events:
+            result = self.validate(event)
+            if result.is_valid:
+                valid_count += 1
+            else:
+                invalid_count += 1
+                invalid_events.append(event)
+                all_errors.extend(result.errors)
+        return BatchValidationResult(
+            total_count=len(events),
+            valid_count=valid_count,
+            invalid_count=invalid_count,
+            invalid_events=invalid_events,
+            errors=all_errors
+        )
+
+
+@dataclass
+class EventSchema:
+    name: str
+    version: str
+    required_properties: List[str]
+    optional_properties: List[str] = field(default_factory=list)
+
+
+class SchemaRegistry:
+    def __init__(self):
+        self._schemas: Dict[str, Dict[str, EventSchema]] = {}
+
+    def register(self, schema: EventSchema):
+        if schema.name not in self._schemas:
+            self._schemas[schema.name] = {}
+        self._schemas[schema.name][schema.version] = schema
+
+    def get(self, name: str, version: str) -> Optional[EventSchema]:
+        return self._schemas.get(name, {}).get(version)
+
+    def get_latest(self, name: str) -> Optional[EventSchema]:
+        if name not in self._schemas:
+            return None
+        versions = sorted(self._schemas[name].keys())
+        return self._schemas[name][versions[-1]] if versions else None
+
+    def validate_event(self, event: Event, schema_name: str, version: str) -> ValidationResult:
+        schema = self.get(schema_name, version)
+        if not schema:
+            return ValidationResult(is_valid=False, errors=[f"Schema {schema_name}:{version} not found"])
+        errors = []
+        for prop in schema.required_properties:
+            if prop not in event.event_properties:
+                errors.append(f"Required property '{prop}' is missing")
+        return ValidationResult(is_valid=len(errors) == 0, errors=errors)

customer_retention/integrations/streaming/online_store_writer.py

@@ -0,0 +1,249 @@
+import statistics
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Dict, List, Optional
+
+from customer_retention.core.compat import DataFrame, pd
+
+
+@dataclass
+class FeatureStoreConfig:
+    backend: str = "simulation"
+    read_timeout_ms: int = 100
+    write_timeout_ms: int = 200
+
+
+@dataclass
+class TTLConfig:
+    default_ttl_seconds: int = 86400
+
+
+@dataclass
+class FeatureRecord:
+    customer_id: str
+    feature_name: str
+    feature_value: float
+    updated_at: datetime = field(default_factory=datetime.now)
+    ttl_seconds: Optional[int] = None
+
+
+@dataclass
+class FeatureWriteResult:
+    success: bool
+    features_written: int = 0
+    latency_ms: float = 0.0
+    error: Optional[str] = None
+
+
+@dataclass
+class BatchSyncResult:
+    success: bool
+    customers_synced: int = 0
+    features_synced: int = 0
+    error: Optional[str] = None
+
+
+@dataclass
+class FeatureStoreMetrics:
+    avg_read_latency_ms: float = 0.0
+    p99_read_latency_ms: float = 0.0
+    avg_write_latency_ms: float = 0.0
+    p99_write_latency_ms: float = 0.0
+    cache_hit_rate: float = 0.0
+    total_reads: int = 0
+    total_writes: int = 0
+
+
+@dataclass
+class FreshnessMetrics:
+    avg_freshness_seconds: float = 0.0
+
+
+@dataclass
+class FeatureStoreSchema:
+    columns: List[str] = field(default_factory=lambda: ["customer_id", "feature_name", "feature_value", "updated_at", "ttl"])
+
+
+class OnlineFeatureStore:
+    def __init__(self, config: Optional[FeatureStoreConfig] = None):
+        self._config = config or FeatureStoreConfig()
+        self._store: Dict[str, Dict[str, FeatureRecord]] = defaultdict(dict)
+        self._history: Dict[str, Dict[str, List[FeatureRecord]]] = defaultdict(lambda: defaultdict(list))
+        self._ttl_config = TTLConfig()
+        self._read_latencies: List[float] = []
+        self._write_latencies: List[float] = []
+        self._cache_hits = 0
+        self._cache_misses = 0
+
+    def write(self, record: FeatureRecord) -> FeatureWriteResult:
+        start = time.time()
+        try:
+            record.updated_at = datetime.now()
+            self._store[record.customer_id][record.feature_name] = record
+            self._history[record.customer_id][record.feature_name].append(record)
+            latency = (time.time() - start) * 1000
+            self._write_latencies.append(latency)
+            return FeatureWriteResult(success=True, features_written=1, latency_ms=latency)
+        except Exception as e:
+            return FeatureWriteResult(success=False, error=str(e))
+
+    def write_batch(self, customer_id: str, features: Dict[str, float]) -> FeatureWriteResult:
+        start = time.time()
+        try:
+            for name, value in features.items():
+                record = FeatureRecord(
+                    customer_id=customer_id,
+                    feature_name=name,
+                    feature_value=value,
+                    updated_at=datetime.now()
+                )
+                self._store[customer_id][name] = record
+                self._history[customer_id][name].append(record)
+            latency = (time.time() - start) * 1000
+            self._write_latencies.append(latency)
+            return FeatureWriteResult(success=True, features_written=len(features), latency_ms=latency)
+        except Exception as e:
+            return FeatureWriteResult(success=False, error=str(e))
+
+    def read(self, customer_id: str, feature_name: str) -> Optional[FeatureRecord]:
+        start = time.time()
+        record = self._store.get(customer_id, {}).get(feature_name)
+        if record and record.ttl_seconds:
+            age = (datetime.now() - record.updated_at).total_seconds()
+            if age > record.ttl_seconds:
+                del self._store[customer_id][feature_name]
+                record = None
+        latency = (time.time() - start) * 1000
+        self._read_latencies.append(latency)
+        if record:
+            self._cache_hits += 1
+        else:
+            self._cache_misses += 1
+        return record
+
+    def read_batch(self, customer_id: str, feature_names: List[str]) -> Dict[str, float]:
+        start = time.time()
+        result = {}
+        for name in feature_names:
+            record = self.read(customer_id, name)
+            if record:
+                result[name] = record.feature_value
+        latency = (time.time() - start) * 1000
+        self._read_latencies.append(latency)
+        return result
+
+    def set_ttl_config(self, config: TTLConfig):
+        self._ttl_config = config
+
+    def sync_from_batch(self, offline_features: Dict[str, Dict[str, float]], merge_mode: str = "overwrite") -> BatchSyncResult:
+        try:
+            customers_synced = 0
+            features_synced = 0
+            for customer_id, features in offline_features.items():
+                for name, value in features.items():
+                    if merge_mode == "preserve_streaming" and customer_id in self._store and name in self._store[customer_id]:
+                        continue
+                    record = FeatureRecord(
+                        customer_id=customer_id,
+                        feature_name=name,
+                        feature_value=value,
+                        updated_at=datetime.now()
+                    )
+                    self._store[customer_id][name] = record
+                    features_synced += 1
+                customers_synced += 1
+            return BatchSyncResult(success=True, customers_synced=customers_synced, features_synced=features_synced)
+        except Exception as e:
+            return BatchSyncResult(success=False, error=str(e))
+
+    def cleanup_expired(self) -> int:
+        expired_count = 0
+        for customer_id in list(self._store.keys()):
+            for feature_name in list(self._store[customer_id].keys()):
+                record = self._store[customer_id][feature_name]
+                if record.ttl_seconds:
+                    age = (datetime.now() - record.updated_at).total_seconds()
+                    if age > record.ttl_seconds:
+                        del self._store[customer_id][feature_name]
+                        expired_count += 1
+        return expired_count
+
+    def get_feature_history(self, customer_id: str, feature_name: str, limit: int = 10) -> List[FeatureRecord]:
+        history = self._history.get(customer_id, {}).get(feature_name, [])
+        return history[-limit:]
+
+    def read_at_time(self, customer_id: str, feature_name: str, timestamp: datetime) -> Optional[FeatureRecord]:
+        history = self._history.get(customer_id, {}).get(feature_name, [])
+        for record in reversed(history):
+            if record.updated_at <= timestamp:
+                return record
+        return history[0] if history else None
+
+    def get_metrics(self) -> FeatureStoreMetrics:
+        read_lat = self._read_latencies or [0]
+        write_lat = self._write_latencies or [0]
+        total_cache = self._cache_hits + self._cache_misses
+        return FeatureStoreMetrics(
+            avg_read_latency_ms=statistics.mean(read_lat),
+            p99_read_latency_ms=sorted(read_lat)[int(len(read_lat) * 0.99)] if len(read_lat) > 1 else read_lat[0],
+            avg_write_latency_ms=statistics.mean(write_lat),
+            p99_write_latency_ms=sorted(write_lat)[int(len(write_lat) * 0.99)] if len(write_lat) > 1 else write_lat[0],
+            cache_hit_rate=self._cache_hits / total_cache if total_cache > 0 else 0.0,
+            total_reads=len(self._read_latencies),
+            total_writes=len(self._write_latencies)
+        )
+
+    def get_freshness_metrics(self) -> FreshnessMetrics:
+        all_ages = []
+        now = datetime.now()
+        for customer_features in self._store.values():
+            for record in customer_features.values():
+                age = (now - record.updated_at).total_seconds()
+                all_ages.append(age)
+        return FreshnessMetrics(
+            avg_freshness_seconds=statistics.mean(all_ages) if all_ages else 0.0
+        )
+
+    def get_schema(self) -> FeatureStoreSchema:
+        return FeatureStoreSchema()
+
+    def get_feature_table_schema(self) -> List[str]:
+        return ["customer_id", "feature_name", "feature_value", "updated_at"]
+
+    def to_delta_dataframe(self) -> DataFrame:
+        rows = []
+        for customer_id, features in self._store.items():
+            for feature_name, record in features.items():
+                rows.append({
+                    "customer_id": customer_id,
+                    "feature_name": feature_name,
+                    "feature_value": record.feature_value,
+                    "updated_at": record.updated_at
+                })
+        return pd.DataFrame(rows)
+
+    def import_from_feature_table(self, feature_table: Dict[str, Dict[str, float]]) -> BatchSyncResult:
+        return self.sync_from_batch(feature_table)
+
+
+class FeatureLookup:
+    def __init__(self, feature_store: OnlineFeatureStore, feature_names: List[str],
+                 defaults: Optional[Dict[str, float]] = None):
+        self._store = feature_store
+        self._feature_names = feature_names
+        self._defaults = defaults or {}
+
+    def get_features(self, customer_id: str) -> Dict[str, float]:
+        result = {}
+        for name in self._feature_names:
+            record = self._store.read(customer_id, name)
+            if record:
+                result[name] = record.feature_value
+            elif name in self._defaults:
+                result[name] = self._defaults[name]
+        return result
+
+    def get_features_batch(self, customer_ids: List[str]) -> Dict[str, Dict[str, float]]:
+        return {cust_id: self.get_features(cust_id) for cust_id in customer_ids}