churnkit 0.75.0a1__py3-none-any.whl

customer_retention/generators/spec_generator/pipeline_spec.py

@@ -0,0 +1,298 @@
+import json
+from dataclasses import asdict, dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import yaml
+
+from customer_retention.core.config.column_config import ColumnType
+
+
+@dataclass
+class SourceSpec:
+    name: str
+    path: str
+    format: str
+    options: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class ColumnSpec:
+    name: str
+    data_type: str
+    semantic_type: str
+    nullable: bool = True
+    description: str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_column_finding(cls, finding) -> "ColumnSpec":
+        type_to_dtype = {
+            ColumnType.IDENTIFIER: "string",
+            ColumnType.TARGET: "integer",
+            ColumnType.BINARY: "integer",
+            ColumnType.NUMERIC_CONTINUOUS: "float",
+            ColumnType.NUMERIC_DISCRETE: "integer",
+            ColumnType.CATEGORICAL_NOMINAL: "string",
+            ColumnType.CATEGORICAL_ORDINAL: "string",
+            ColumnType.CATEGORICAL_CYCLICAL: "string",
+            ColumnType.DATETIME: "timestamp",
+            ColumnType.TEXT: "string"
+        }
+        return cls(
+            name=finding.name,
+            data_type=type_to_dtype.get(finding.inferred_type, "string"),
+            semantic_type=finding.inferred_type.value,
+            nullable=finding.universal_metrics.get("null_count", 0) > 0
+        )
+
+
+@dataclass
+class SchemaSpec:
+    columns: List[ColumnSpec]
+    primary_key: Optional[str] = None
+    partition_columns: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "columns": [c.to_dict() for c in self.columns],
+            "primary_key": self.primary_key,
+            "partition_columns": self.partition_columns
+        }
+
+    @classmethod
+    def from_findings(cls, findings) -> "SchemaSpec":
+        columns = [ColumnSpec.from_column_finding(col) for col in findings.columns.values()]
+        primary_key = findings.identifier_columns[0] if findings.identifier_columns else None
+        return cls(columns=columns, primary_key=primary_key)
+
+
+@dataclass
+class TransformSpec:
+    name: str
+    transform_type: str
+    input_columns: List[str]
+    output_columns: List[str]
+    parameters: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class FeatureSpec:
+    name: str
+    source_columns: List[str]
+    computation: str
+    description: str = ""
+    parameters: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class ModelSpec:
+    name: str
+    model_type: str
+    target_column: str
+    feature_columns: List[str]
+    hyperparameters: Dict[str, Any] = field(default_factory=dict)
+    metrics: List[str] = field(default_factory=lambda: ["auc", "precision", "recall", "f1"])
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class QualityGateSpec:
+    name: str
+    gate_type: str
+    column: str
+    threshold: float
+    action: str = "fail"
+    parameters: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class PipelineSpec:
+    name: str = "pipeline"
+    version: str = "1.0.0"
+    description: str = ""
+    created_at: str = field(default_factory=lambda: datetime.now().isoformat())
+    sources: List[SourceSpec] = field(default_factory=list)
+    schema: Optional[SchemaSpec] = None
+    bronze_transforms: List[TransformSpec] = field(default_factory=list)
+    silver_transforms: List[TransformSpec] = field(default_factory=list)
+    gold_transforms: List[TransformSpec] = field(default_factory=list)
+    feature_definitions: List[FeatureSpec] = field(default_factory=list)
+    model_config: Optional[ModelSpec] = None
+    quality_gates: List[QualityGateSpec] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_findings(cls, findings, name: str = None) -> "PipelineSpec":
+        spec = cls(
+            name=name or Path(findings.source_path).stem + "_pipeline",
+            description=f"Pipeline generated from {findings.source_path}"
+        )
+        spec.sources.append(SourceSpec(
+            name="primary_source",
+            path=findings.source_path,
+            format=findings.source_format
+        ))
+        spec.schema = SchemaSpec.from_findings(findings)
+        spec._add_default_transforms(findings)
+        spec._add_default_features(findings)
+        spec._add_default_model(findings)
+        spec._add_default_quality_gates(findings)
+        return spec
+
+    def _add_default_transforms(self, findings):
+        for name, col in findings.columns.items():
+            if col.inferred_type == ColumnType.IDENTIFIER:
+                continue
+            if col.inferred_type == ColumnType.TARGET:
+                continue
+            if col.inferred_type in [ColumnType.NUMERIC_CONTINUOUS, ColumnType.NUMERIC_DISCRETE]:
+                self.silver_transforms.append(TransformSpec(
+                    name=f"scale_{name}",
+                    transform_type="standard_scaling",
+                    input_columns=[name],
+                    output_columns=[f"{name}_scaled"]
+                ))
+            elif col.inferred_type in [ColumnType.CATEGORICAL_NOMINAL, ColumnType.CATEGORICAL_ORDINAL]:
+                self.silver_transforms.append(TransformSpec(
+                    name=f"encode_{name}",
+                    transform_type="one_hot_encoding",
+                    input_columns=[name],
+                    output_columns=[f"{name}_encoded"]
+                ))
+
+    def _add_default_features(self, findings):
+        for name in findings.datetime_columns:
+            self.feature_definitions.append(FeatureSpec(
+                name=f"days_since_{name}",
+                source_columns=[name],
+                computation="days_since_today",
+                description=f"Days since {name}"
+            ))
+
+    def _add_default_model(self, findings):
+        if findings.target_column:
+            feature_cols = [
+                name for name, col in findings.columns.items()
+                if col.inferred_type not in [ColumnType.IDENTIFIER, ColumnType.TARGET]
+            ]
+            self.model_config = ModelSpec(
+                name="default_model",
+                model_type="gradient_boosting",
+                target_column=findings.target_column,
+                feature_columns=feature_cols
+            )
+
+    def _add_default_quality_gates(self, findings):
+        self.quality_gates.append(QualityGateSpec(
+            name="schema_check",
+            gate_type="schema_validation",
+            column="*",
+            threshold=0
+        ))
+        self.quality_gates.append(QualityGateSpec(
+            name="null_check",
+            gate_type="null_percentage",
+            column="*",
+            threshold=50.0,
+            action="warn"
+        ))
+
+    def add_transform(self, transform: TransformSpec, stage: str = "silver"):
+        if stage == "bronze":
+            self.bronze_transforms.append(transform)
+        elif stage == "silver":
+            self.silver_transforms.append(transform)
+        elif stage == "gold":
+            self.gold_transforms.append(transform)
+
+    def add_feature(self, feature: FeatureSpec):
+        self.feature_definitions.append(feature)
+
+    def add_quality_gate(self, gate: QualityGateSpec):
+        self.quality_gates.append(gate)
+
+    def to_dict(self) -> dict:
+        return {
+            "name": self.name,
+            "version": self.version,
+            "description": self.description,
+            "created_at": self.created_at,
+            "sources": [s.to_dict() for s in self.sources],
+            "schema": self.schema.to_dict() if self.schema else None,
+            "bronze_transforms": [t.to_dict() for t in self.bronze_transforms],
+            "silver_transforms": [t.to_dict() for t in self.silver_transforms],
+            "gold_transforms": [t.to_dict() for t in self.gold_transforms],
+            "feature_definitions": [f.to_dict() for f in self.feature_definitions],
+            "model_config": self.model_config.to_dict() if self.model_config else None,
+            "quality_gates": [g.to_dict() for g in self.quality_gates],
+            "metadata": self.metadata
+        }
+
+    def to_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent)
+
+    def to_yaml(self) -> str:
+        return yaml.dump(self.to_dict(), default_flow_style=False, sort_keys=False)
+
+    def save(self, path: str):
+        content = self.to_yaml() if path.endswith((".yaml", ".yml")) else self.to_json()
+        with open(path, "w") as f:
+            f.write(content)
+
+    @classmethod
+    def load(cls, path: str) -> "PipelineSpec":
+        with open(path, "r") as f:
+            content = f.read()
+        data = yaml.safe_load(content) if path.endswith((".yaml", ".yml")) else json.loads(content)
+        return cls._from_dict(data)
+
+    @classmethod
+    def _from_dict(cls, data: dict) -> "PipelineSpec":
+        spec = cls(
+            name=data.get("name", "pipeline"),
+            version=data.get("version", "1.0.0"),
+            description=data.get("description", ""),
+            created_at=data.get("created_at", datetime.now().isoformat())
+        )
+        for src_data in data.get("sources", []):
+            spec.sources.append(SourceSpec(**src_data))
+        if data.get("schema"):
+            schema_data = data["schema"]
+            columns = [ColumnSpec(**c) for c in schema_data.get("columns", [])]
+            spec.schema = SchemaSpec(
+                columns=columns,
+                primary_key=schema_data.get("primary_key"),
+                partition_columns=schema_data.get("partition_columns", [])
+            )
+        for t_data in data.get("bronze_transforms", []):
+            spec.bronze_transforms.append(TransformSpec(**t_data))
+        for t_data in data.get("silver_transforms", []):
+            spec.silver_transforms.append(TransformSpec(**t_data))
+        for t_data in data.get("gold_transforms", []):
+            spec.gold_transforms.append(TransformSpec(**t_data))
+        for f_data in data.get("feature_definitions", []):
+            spec.feature_definitions.append(FeatureSpec(**f_data))
+        if data.get("model_config"):
+            spec.model_config = ModelSpec(**data["model_config"])
+        for g_data in data.get("quality_gates", []):
+            spec.quality_gates.append(QualityGateSpec(**g_data))
+        spec.metadata = data.get("metadata", {})
+        return spec

customer_retention/integrations/adapters/__init__.py

@@ -0,0 +1,13 @@
+from .base import AdapterResult
+from .factory import get_delta, get_feature_store, get_mlflow
+from .feature_store import DatabricksFeatureStore, FeatureStoreAdapter, LocalFeatureStore
+from .mlflow import DatabricksMLflow, LocalMLflow, MLflowAdapter
+from .storage import DatabricksDelta, DeltaStorage, LocalDelta
+
+__all__ = [
+    "AdapterResult",
+    "DeltaStorage", "LocalDelta", "DatabricksDelta",
+    "FeatureStoreAdapter", "LocalFeatureStore", "DatabricksFeatureStore",
+    "MLflowAdapter", "LocalMLflow", "DatabricksMLflow",
+    "get_delta", "get_feature_store", "get_mlflow",
+]

customer_retention/integrations/adapters/base.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class AdapterResult:
+    success: bool
+    data: Optional[Any] = None
+    error: Optional[str] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)

customer_retention/integrations/adapters/factory.py

@@ -0,0 +1,25 @@
+from customer_retention.core.compat.detection import is_spark_available
+
+from .feature_store import DatabricksFeatureStore, FeatureStoreAdapter, LocalFeatureStore
+from .mlflow import DatabricksMLflow, LocalMLflow, MLflowAdapter
+from .storage import DatabricksDelta, DeltaStorage, LocalDelta
+
+
+def get_delta(force_local: bool = False) -> DeltaStorage:
+    if force_local or not is_spark_available():
+        return LocalDelta()
+    return DatabricksDelta()
+
+
+def get_feature_store(base_path: str = "./feature_store", catalog: str = "main",
+                      schema: str = "default", force_local: bool = False) -> FeatureStoreAdapter:
+    if force_local or not is_spark_available():
+        return LocalFeatureStore(base_path=base_path)
+    return DatabricksFeatureStore(catalog=catalog, schema=schema)
+
+
+def get_mlflow(tracking_uri: str = "./mlruns", registry_uri: str = "databricks-uc",
+               force_local: bool = False) -> MLflowAdapter:
+    if force_local or not is_spark_available():
+        return LocalMLflow(tracking_uri=tracking_uri)
+    return DatabricksMLflow(registry_uri=registry_uri)

customer_retention/integrations/adapters/feature_store/__init__.py

@@ -0,0 +1,6 @@
+from .base import FeatureStoreAdapter, FeatureViewConfig
+from .databricks import DatabricksFeatureStore
+from .feast_adapter import FeastAdapter
+from .local import LocalFeatureStore
+
+__all__ = ["FeatureStoreAdapter", "FeatureViewConfig", "LocalFeatureStore", "DatabricksFeatureStore", "FeastAdapter"]

customer_retention/integrations/adapters/feature_store/base.py

@@ -0,0 +1,57 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from ..base import AdapterResult
+
+
+@dataclass
+class FeatureViewConfig:
+    name: str
+    entity_key: str
+    features: List[str]
+    ttl_days: Optional[int] = None
+    tags: Dict[str, str] = field(default_factory=dict)
+    cutoff_date: Optional[datetime] = None
+    data_hash: Optional[str] = None
+
+
+class FeatureStoreAdapter(ABC):
+    @abstractmethod
+    def create_table(self, name: str, schema: Dict[str, str], primary_keys: List[str]) -> AdapterResult:
+        pass
+
+    @abstractmethod
+    def write_table(self, name: str, df: pd.DataFrame, mode: str = "merge") -> AdapterResult:
+        pass
+
+    @abstractmethod
+    def read_table(self, name: str, version: Optional[int] = None) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def get_table_metadata(self, name: str) -> Dict[str, Any]:
+        pass
+
+    @abstractmethod
+    def list_tables(self) -> List[str]:
+        pass
+
+    @abstractmethod
+    def delete_table(self, name: str) -> AdapterResult:
+        pass
+
+    def register_feature_view(self, config: FeatureViewConfig, df: pd.DataFrame) -> str:
+        raise NotImplementedError("Subclass must implement register_feature_view")
+
+    def get_historical_features(self, entity_df: pd.DataFrame, feature_refs: List[str]) -> pd.DataFrame:
+        raise NotImplementedError("Subclass must implement get_historical_features")
+
+    def materialize(self, feature_views: List[str], start_date: str, end_date: str) -> None:
+        raise NotImplementedError("Subclass must implement materialize")
+
+    def get_online_features(self, entity_keys: Dict[str, List[Any]], feature_refs: List[str]) -> Dict:
+        raise NotImplementedError("Subclass must implement get_online_features")

customer_retention/integrations/adapters/feature_store/databricks.py

@@ -0,0 +1,94 @@
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from customer_retention.core.compat.detection import get_spark_session, is_spark_available
+
+from ..base import AdapterResult
+from .base import FeatureStoreAdapter, FeatureViewConfig
+
+
+class DatabricksFeatureStore(FeatureStoreAdapter):
+    def __init__(self, catalog: str = "main", schema: str = "default"):
+        if not is_spark_available():
+            raise ImportError("PySpark required for DatabricksFeatureStore")
+        self.catalog = catalog
+        self.schema = schema
+        self._fe_client = None
+
+    @property
+    def fe_client(self) -> Any:
+        if self._fe_client is None:
+            from databricks.feature_engineering import FeatureEngineeringClient
+            self._fe_client = FeatureEngineeringClient()
+        return self._fe_client
+
+    def _full_name(self, name: str) -> str:
+        return f"{self.catalog}.{self.schema}.{name}"
+
+    def create_table(self, name: str, schema: Dict[str, str], primary_keys: List[str]) -> AdapterResult:
+        full_name = self._full_name(name)
+        spark = get_spark_session()
+        df = spark.createDataFrame([], self._schema_to_spark(schema))
+        self.fe_client.create_table(name=full_name, primary_keys=primary_keys, df=df)
+        return AdapterResult(success=True, metadata={"name": full_name})
+
+    def _schema_to_spark(self, schema: Dict[str, str]) -> Any:
+        from pyspark.sql.types import FloatType, IntegerType, StringType, StructField, StructType
+        type_map = {"int": IntegerType(), "float": FloatType(), "string": StringType()}
+        fields = [StructField(name, type_map.get(dtype, StringType()), True) for name, dtype in schema.items()]
+        return StructType(fields)
+
+    def write_table(self, name: str, df: pd.DataFrame, mode: str = "merge") -> AdapterResult:
+        full_name = self._full_name(name)
+        spark = get_spark_session()
+        spark_df = spark.createDataFrame(df)
+        self.fe_client.write_table(name=full_name, df=spark_df, mode=mode)
+        return AdapterResult(success=True)
+
+    def read_table(self, name: str, version: Optional[int] = None) -> pd.DataFrame:
+        full_name = self._full_name(name)
+        spark = get_spark_session()
+        reader = spark.read.format("delta").table(full_name)
+        if version is not None:
+            reader = spark.read.format("delta").option("versionAsOf", version).table(full_name)
+        return reader.toPandas()
+
+    def get_table_metadata(self, name: str) -> Dict[str, Any]:
+        full_name = self._full_name(name)
+        table_info = self.fe_client.get_table(full_name)
+        return {"name": full_name, "primary_keys": table_info.primary_keys, "features": table_info.features}
+
+    def list_tables(self) -> List[str]:
+        tables = self.fe_client.list_tables()
+        return [t.name for t in tables if t.name.startswith(f"{self.catalog}.{self.schema}")]
+
+    def delete_table(self, name: str) -> AdapterResult:
+        full_name = self._full_name(name)
+        self.fe_client.drop_table(full_name)
+        return AdapterResult(success=True)
+
+    def register_feature_view(self, config: FeatureViewConfig, df: pd.DataFrame) -> str:
+        table_name = self._full_name(config.name)
+        spark = get_spark_session()
+        spark_df = spark.createDataFrame(df)
+        self.fe_client.create_table(name=table_name, primary_keys=[config.entity_key], df=spark_df)
+        return table_name
+
+    def get_historical_features(self, entity_df: pd.DataFrame, feature_refs: List[str]) -> pd.DataFrame:
+        from databricks.feature_engineering import FeatureLookup
+        spark = get_spark_session()
+        lookups = [FeatureLookup(table_name=ref.split(":")[0], lookup_key=[entity_df.columns[0]]) for ref in feature_refs]
+        training_set = self.fe_client.create_training_set(df=spark.createDataFrame(entity_df), feature_lookups=lookups, label=None)
+        return training_set.load_df().toPandas()
+
+    def materialize(self, feature_views: List[str], start_date: str, end_date: str) -> None:
+        pass
+
+    def get_online_features(self, entity_keys: Dict[str, List[Any]], feature_refs: List[str]) -> Dict:
+        entity_df = pd.DataFrame(entity_keys)
+        spark = get_spark_session()
+        from databricks.feature_engineering import FeatureLookup
+        lookups = [FeatureLookup(table_name=ref.split(":")[0], lookup_key=list(entity_keys.keys())) for ref in feature_refs]
+        result = self.fe_client.score_batch(df=spark.createDataFrame(entity_df), feature_lookups=lookups)
+        return result.toPandas().to_dict()

customer_retention/integrations/adapters/feature_store/feast_adapter.py

@@ -0,0 +1,97 @@
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from ..base import AdapterResult
+from .base import FeatureStoreAdapter, FeatureViewConfig
+
+
+class FeastAdapter(FeatureStoreAdapter):
+    def __init__(self, repo_path: str = "./feature_store/feature_repo"):
+        self._repo_path = repo_path
+        self._store = None
+        self._feature_views: Dict[str, FeatureViewConfig] = {}
+        self._data_sources: Dict[str, pd.DataFrame] = {}
+        self.storage = _get_storage()
+
+    @property
+    def store(self):
+        if self._store is None:
+            from feast import FeatureStore
+            self._store = FeatureStore(repo_path=self._repo_path)
+        return self._store
+
+    def register_feature_view(self, config: FeatureViewConfig, df: pd.DataFrame) -> str:
+        self._feature_views[config.name] = config
+        self._data_sources[config.name] = df
+        data_dir = Path(self._repo_path) / "data"
+        data_dir.mkdir(parents=True, exist_ok=True)
+        if self.storage:
+            self.storage.write(df, str(data_dir / config.name))
+        else:
+            df.to_parquet(data_dir / f"{config.name}.parquet", index=False)
+        return config.name
+
+    def get_historical_features(self, entity_df: pd.DataFrame, feature_refs: List[str]) -> pd.DataFrame:
+        return self.store.get_historical_features(entity_df=entity_df, features=feature_refs).to_df()
+
+    def materialize(self, feature_views: List[str], start_date: str, end_date: str) -> None:
+        self.store.materialize(
+            start_date=datetime.fromisoformat(start_date),
+            end_date=datetime.fromisoformat(end_date),
+            feature_views=feature_views
+        )
+
+    def get_online_features(self, entity_keys: Dict[str, List[Any]], feature_refs: List[str]) -> Dict:
+        entity_rows = [{k: v[i] for k, v in entity_keys.items()} for i in range(len(next(iter(entity_keys.values()))))]
+        return self.store.get_online_features(features=feature_refs, entity_rows=entity_rows).to_dict()
+
+    def create_table(self, name: str, schema: Dict[str, str], primary_keys: List[str]) -> AdapterResult:
+        config = FeatureViewConfig(name=name, entity_key=primary_keys[0], features=list(schema.keys()))
+        self._feature_views[name] = config
+        return AdapterResult(success=True, metadata={"name": name})
+
+    def write_table(self, name: str, df: pd.DataFrame, mode: str = "merge") -> AdapterResult:
+        if name not in self._feature_views:
+            return AdapterResult(success=False, error=f"Feature view {name} not found")
+        config = self._feature_views[name]
+        self.register_feature_view(config, df)
+        return AdapterResult(success=True)
+
+    def read_table(self, name: str, version: Optional[int] = None) -> pd.DataFrame:
+        if name not in self._data_sources:
+            delta_path = Path(self._repo_path) / "data" / name
+            parquet_path = Path(self._repo_path) / "data" / f"{name}.parquet"
+            if self.storage and delta_path.is_dir() and self.storage.exists(str(delta_path)):
+                return self.storage.read(str(delta_path), version=version)
+            if parquet_path.exists():
+                return pd.read_parquet(parquet_path)
+            raise KeyError(f"Feature view {name} not found")
+        return self._data_sources[name]
+
+    def get_table_metadata(self, name: str) -> Dict[str, Any]:
+        if name not in self._feature_views:
+            raise KeyError(f"Feature view {name} not found")
+        config = self._feature_views[name]
+        return {"name": config.name, "entity_key": config.entity_key, "features": config.features, "ttl_days": config.ttl_days}
+
+    def list_tables(self) -> List[str]:
+        return list(self._feature_views.keys())
+
+    def delete_table(self, name: str) -> AdapterResult:
+        if name not in self._feature_views:
+            return AdapterResult(success=False, error=f"Feature view {name} not found")
+        del self._feature_views[name]
+        if name in self._data_sources:
+            del self._data_sources[name]
+        return AdapterResult(success=True)
+
+
+def _get_storage():
+    try:
+        from customer_retention.integrations.adapters.factory import get_delta
+        return get_delta(force_local=True)
+    except ImportError:
+        return None

customer_retention/integrations/adapters/feature_store/local.py

@@ -0,0 +1,75 @@
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from ..base import AdapterResult
+from ..storage import LocalDelta
+from .base import FeatureStoreAdapter
+
+
+class LocalFeatureStore(FeatureStoreAdapter):
+    def __init__(self, base_path: str = "./feature_store"):
+        self.base_path = Path(base_path)
+        self.base_path.mkdir(parents=True, exist_ok=True)
+        self.registry_path = self.base_path / "registry.json"
+        self.storage = LocalDelta()
+        self._load_registry()
+
+    def _load_registry(self) -> None:
+        if self.registry_path.exists():
+            with open(self.registry_path) as f:
+                self._registry = json.load(f)
+        else:
+            self._registry = {"tables": {}}
+
+    def _save_registry(self) -> None:
+        with open(self.registry_path, "w") as f:
+            json.dump(self._registry, f, indent=2)
+
+    def _table_path(self, name: str) -> str:
+        return str(self.base_path / "tables" / name)
+
+    def create_table(self, name: str, schema: Dict[str, str], primary_keys: List[str]) -> AdapterResult:
+        self._registry["tables"][name] = {
+            "schema": schema,
+            "primary_keys": primary_keys,
+            "path": self._table_path(name)
+        }
+        self._save_registry()
+        return AdapterResult(success=True, metadata={"name": name})
+
+    def write_table(self, name: str, df: pd.DataFrame, mode: str = "merge") -> AdapterResult:
+        if name not in self._registry["tables"]:
+            return AdapterResult(success=False, error=f"Table {name} not found")
+        table_info = self._registry["tables"][name]
+        path = table_info["path"]
+        if mode == "merge" and Path(path).exists():
+            primary_keys = table_info["primary_keys"]
+            condition = " AND ".join([f"source.{k} = target.{k}" for k in primary_keys])
+            self.storage.merge(df, path, condition)
+        else:
+            self.storage.write(df, path, mode="overwrite" if mode == "merge" else mode)
+        return AdapterResult(success=True)
+
+    def read_table(self, name: str, version: Optional[int] = None) -> pd.DataFrame:
+        if name not in self._registry["tables"]:
+            raise KeyError(f"Table {name} not found")
+        path = self._registry["tables"][name]["path"]
+        return self.storage.read(path, version=version)
+
+    def get_table_metadata(self, name: str) -> Dict[str, Any]:
+        if name not in self._registry["tables"]:
+            raise KeyError(f"Table {name} not found")
+        return self._registry["tables"][name]
+
+    def list_tables(self) -> List[str]:
+        return list(self._registry["tables"].keys())
+
+    def delete_table(self, name: str) -> AdapterResult:
+        if name not in self._registry["tables"]:
+            return AdapterResult(success=False, error=f"Table {name} not found")
+        del self._registry["tables"][name]
+        self._save_registry()
+        return AdapterResult(success=True)