altcodepro-polydb-python 2.1.0__py3-none-any.whl

polydb/multitenancy.py

@@ -0,0 +1,197 @@
+# src/polydb/multitenancy.py
+"""
+Multi-tenancy enforcement and isolation
+"""
+from typing import Dict, Any, List, Optional, Callable
+from contextvars import ContextVar
+from dataclasses import dataclass
+from enum import Enum
+
+
+class IsolationLevel(Enum):
+    """Tenant isolation levels"""
+    SHARED_SCHEMA = "shared"  # Shared tables with tenant_id
+    SEPARATE_SCHEMA = "schema"  # Separate schema per tenant
+    SEPARATE_DATABASE = "database"  # Separate DB per tenant
+
+
+@dataclass
+class TenantConfig:
+    """Tenant configuration"""
+    tenant_id: str
+    isolation_level: IsolationLevel
+    schema_name: Optional[str] = None
+    database_name: Optional[str] = None
+    max_connections: int = 10
+    storage_quota_gb: Optional[float] = None
+    features: List[str] = []
+
+
+class TenantRegistry:
+    """Registry of tenant configurations"""
+    
+    def __init__(self):
+        self._tenants: Dict[str, TenantConfig] = {}
+    
+    def register(self, config: TenantConfig):
+        """Register tenant"""
+        self._tenants[config.tenant_id] = config
+    
+    def get(self, tenant_id: str) -> Optional[TenantConfig]:
+        """Get tenant config"""
+        return self._tenants.get(tenant_id)
+    
+    def list_all(self) -> List[TenantConfig]:
+        """List all tenants"""
+        return list(self._tenants.values())
+
+
+class TenantContext:
+    """Tenant context management"""
+    
+    current_tenant: ContextVar[Optional[TenantConfig]] = \
+        ContextVar("current_tenant", default=None)
+    
+    @classmethod
+    def set_tenant(cls, tenant_id: str, registry: TenantRegistry):
+        """Set current tenant"""
+        config = registry.get(tenant_id)
+        if not config:
+            raise ValueError(f"Tenant not found: {tenant_id}")
+        
+        cls.current_tenant.set(config)
+    
+    @classmethod
+    def get_tenant(cls) -> Optional[TenantConfig]:
+        """Get current tenant"""
+        return cls.current_tenant.get()
+    
+    @classmethod
+    def clear(cls):
+        """Clear tenant context"""
+        cls.current_tenant.set(None)
+
+
+class TenantIsolationEnforcer:
+    """Enforces tenant isolation at query level"""
+    
+    def __init__(self, registry: TenantRegistry):
+        self.registry = registry
+    
+    def enforce_read(
+        self,
+        model: str,
+        query: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Enforce tenant isolation on read"""
+        tenant = TenantContext.get_tenant()
+        
+        if not tenant:
+            raise ValueError("No tenant context set")
+        
+        if tenant.isolation_level == IsolationLevel.SHARED_SCHEMA:
+            # Add tenant_id filter
+            query = query.copy()
+            query['tenant_id'] = tenant.tenant_id
+        
+        return query
+    
+    def enforce_write(
+        self,
+        model: str,
+        data: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Enforce tenant isolation on write"""
+        tenant = TenantContext.get_tenant()
+        
+        if not tenant:
+            raise ValueError("No tenant context set")
+        
+        if tenant.isolation_level == IsolationLevel.SHARED_SCHEMA:
+            # Add tenant_id
+            data = data.copy()
+            data['tenant_id'] = tenant.tenant_id
+        
+        return data
+    
+    def get_table_name(self, base_table: str) -> str:
+        """Get tenant-specific table name"""
+        tenant = TenantContext.get_tenant()
+        
+        if not tenant:
+            raise ValueError("No tenant context set")
+        
+        if tenant.isolation_level == IsolationLevel.SEPARATE_SCHEMA:
+            return f"{tenant.schema_name}.{base_table}"
+        elif tenant.isolation_level == IsolationLevel.SEPARATE_DATABASE:
+            return f"{tenant.database_name}.public.{base_table}"
+        else:
+            return base_table
+
+
+class TenantQuotaManager:
+    """Manages tenant resource quotas"""
+    
+    def __init__(self, registry: TenantRegistry):
+        self.registry = registry
+        self._usage: Dict[str, Dict[str, float]] = {}
+    
+    def check_storage_quota(self, tenant_id: str, size_gb: float) -> bool:
+        """Check if operation would exceed storage quota"""
+        config = self.registry.get(tenant_id)
+        if not config or not config.storage_quota_gb:
+            return True
+        
+        current_usage = self._usage.get(tenant_id, {}).get('storage_gb', 0.0)
+        return (current_usage + size_gb) <= config.storage_quota_gb
+    
+    def record_storage_usage(self, tenant_id: str, size_gb: float):
+        """Record storage usage"""
+        if tenant_id not in self._usage:
+            self._usage[tenant_id] = {}
+        
+        self._usage[tenant_id]['storage_gb'] = \
+            self._usage[tenant_id].get('storage_gb', 0.0) + size_gb
+    
+    def get_usage(self, tenant_id: str) -> Dict[str, float]:
+        """Get tenant resource usage"""
+        return self._usage.get(tenant_id, {})
+
+
+class TenantMigrationManager:
+    """Manages tenant migrations and onboarding"""
+    
+    def __init__(self, factory, registry: TenantRegistry):
+        self.factory = factory
+        self.registry = registry
+    
+    def provision_tenant(self, config: TenantConfig):
+        """Provision new tenant"""
+        # Register tenant
+        self.registry.register(config)
+        
+        if config.isolation_level == IsolationLevel.SEPARATE_SCHEMA:
+            # Create schema
+            schema_sql = f"CREATE SCHEMA IF NOT EXISTS {config.schema_name};"
+            self.factory._sql.execute(schema_sql)
+        
+        elif config.isolation_level == IsolationLevel.SEPARATE_DATABASE:
+            # Create database (requires superuser)
+            db_sql = f"CREATE DATABASE {config.database_name};"
+            self.factory._sql.execute(db_sql)
+    
+    def deprovision_tenant(self, tenant_id: str):
+        """Deprovision tenant"""
+        config = self.registry.get(tenant_id)
+        if not config:
+            return
+        
+        if config.isolation_level == IsolationLevel.SEPARATE_SCHEMA:
+            # Drop schema
+            schema_sql = f"DROP SCHEMA IF EXISTS {config.schema_name} CASCADE;"
+            self.factory._sql.execute(schema_sql)
+        
+        elif config.isolation_level == IsolationLevel.SEPARATE_DATABASE:
+            # Drop database
+            db_sql = f"DROP DATABASE IF EXISTS {config.database_name};"
+            self.factory._sql.execute(db_sql)

polydb/query.py

@@ -0,0 +1,150 @@
+# src/polydb/query.py
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Union
+from enum import Enum
+
+
+class Operator(Enum):
+    EQ = "=="
+    NE = "!="
+    GT = ">"
+    GTE = ">="
+    LT = "<"
+    LTE = "<="
+    IN = "in"
+    NOT_IN = "not_in"
+    CONTAINS = "contains"
+    STARTS_WITH = "starts_with"
+    ENDS_WITH = "ends_with"
+
+
+@dataclass
+class QueryFilter:
+    field: str
+    operator: Operator
+    value: Any
+
+
+@dataclass
+class QueryBuilder:
+    """LINQ-style query builder supporting all SQL clauses"""
+    
+    filters: List[QueryFilter] = field(default_factory=list)
+    order_by_fields: List[tuple[str, bool]] = field(default_factory=list)  # (field, desc)
+    skip_count: int = 0
+    take_count: Optional[int] = None
+    select_fields: Optional[List[str]] = None
+    group_by_fields: Optional[List[str]] = None
+    distinct: bool = False
+    count_only: bool = False
+    
+    def where(self, field: str, operator: Union[Operator, str], value: Any) -> QueryBuilder:
+        """Add filter condition"""
+        if isinstance(operator, str):
+            operator = Operator(operator)
+        self.filters.append(QueryFilter(field, operator, value))
+        return self
+    
+    def order_by(self, field: str, descending: bool = False) -> QueryBuilder:
+        """Add ordering"""
+        self.order_by_fields.append((field, descending))
+        return self
+    
+    def skip(self, count: int) -> QueryBuilder:
+        """Skip records"""
+        self.skip_count = count
+        return self
+    
+    def take(self, count: int) -> QueryBuilder:
+        """Take records"""
+        self.take_count = count
+        return self
+    
+    def select(self, *fields: str) -> QueryBuilder:
+        """Select specific fields"""
+        self.select_fields = list(fields)
+        return self
+    
+    def group_by(self, *fields: str) -> QueryBuilder:
+        """Group by fields"""
+        self.group_by_fields = list(fields)
+        return self
+    
+    def distinct_on(self) -> QueryBuilder:
+        """Return distinct results"""
+        self.distinct = True
+        return self
+    
+    def count(self) -> QueryBuilder:
+        """Return count only"""
+        self.count_only = True
+        return self
+    
+    def to_sql_where(self) -> tuple[str, List[Any]]:
+        """Convert to SQL WHERE clause"""
+        if not self.filters:
+            return "", []
+        
+        clauses = []
+        params = []
+        
+        for f in self.filters:
+            if f.operator == Operator.EQ:
+                clauses.append(f"{f.field} = %s")
+                params.append(f.value)
+            elif f.operator == Operator.NE:
+                clauses.append(f"{f.field} != %s")
+                params.append(f.value)
+            elif f.operator == Operator.GT:
+                clauses.append(f"{f.field} > %s")
+                params.append(f.value)
+            elif f.operator == Operator.GTE:
+                clauses.append(f"{f.field} >= %s")
+                params.append(f.value)
+            elif f.operator == Operator.LT:
+                clauses.append(f"{f.field} < %s")
+                params.append(f.value)
+            elif f.operator == Operator.LTE:
+                clauses.append(f"{f.field} <= %s")
+                params.append(f.value)
+            elif f.operator == Operator.IN:
+                placeholders = ','.join(['%s'] * len(f.value))
+                clauses.append(f"{f.field} IN ({placeholders})")
+                params.extend(f.value)
+            elif f.operator == Operator.NOT_IN:
+                placeholders = ','.join(['%s'] * len(f.value))
+                clauses.append(f"{f.field} NOT IN ({placeholders})")
+                params.extend(f.value)
+            elif f.operator == Operator.CONTAINS:
+                clauses.append(f"{f.field} LIKE %s")
+                params.append(f"%{f.value}%")
+            elif f.operator == Operator.STARTS_WITH:
+                clauses.append(f"{f.field} LIKE %s")
+                params.append(f"{f.value}%")
+            elif f.operator == Operator.ENDS_WITH:
+                clauses.append(f"{f.field} LIKE %s")
+                params.append(f"%{f.value}")
+        
+        return " AND ".join(clauses), params
+    
+    def to_nosql_filter(self) -> Dict[str, Any]:
+        """Convert to NoSQL filter dict"""
+        result = {}
+        for f in self.filters:
+            if f.operator == Operator.EQ:
+                result[f.field] = f.value
+            elif f.operator == Operator.IN:
+                result[f"{f.field}__in"] = f.value
+            elif f.operator == Operator.GT:
+                result[f"{f.field}__gt"] = f.value
+            elif f.operator == Operator.GTE:
+                result[f"{f.field}__gte"] = f.value
+            elif f.operator == Operator.LT:
+                result[f"{f.field}__lt"] = f.value
+            elif f.operator == Operator.LTE:
+                result[f"{f.field}__lte"] = f.value
+            elif f.operator == Operator.CONTAINS:
+                result[f"{f.field}__contains"] = f.value
+        return result

polydb/registry.py

@@ -0,0 +1,71 @@
+# src/polydb/registry.py
+from typing import Dict, Type
+
+
+class ModelRegistry:
+    """
+    Lightweight model registry.
+
+    Supports:
+    - register(model)
+    - get(model) → metadata
+    - resolve(model_or_name) → model class
+    """
+
+    _models: Dict[Type, Dict] = {}
+
+    @classmethod
+    def register(cls, model):
+        meta = getattr(model, "__polydb__", None)
+        if not meta:
+            raise ValueError(f"{model} missing __polydb__ config")
+
+        cls._models[model] = meta
+
+    # -------------------------
+    # NEW: resolve()
+    # -------------------------
+    @classmethod
+    def resolve(cls, model):
+        """
+        Resolve model class from:
+        - class
+        - class name string
+
+        Returns actual class
+        """
+        # Already class
+        if isinstance(model, type):
+            if model not in cls._models:
+                raise ValueError(f"Model not registered: {model.__name__}")
+            return model
+
+        # String name
+        if isinstance(model, str):
+            for m in cls._models:
+                if m.__name__ == model:
+                    return m
+
+            raise ValueError(f"Model not registered: '{model}'")
+
+        raise TypeError(f"Invalid model reference {model!r}. Must be class or class name.")
+
+    @classmethod
+    def get(cls, model):
+        """Get model metadata"""
+        from .types import ModelMeta
+
+        model_cls = cls.resolve(model)
+        raw_meta = cls._models[model_cls]
+
+        # Convert to ModelMeta
+        return ModelMeta(
+            storage=raw_meta.get("storage", "sql"),
+            table=raw_meta.get("table"),
+            collection=raw_meta.get("collection"),
+            pk_field=raw_meta.get("pk_field"),
+            rk_field=raw_meta.get("rk_field"),
+            provider=raw_meta.get("provider"),
+            cache=raw_meta.get("cache", False),
+            cache_ttl=raw_meta.get("cache_ttl"),
+        )

polydb/retry.py

@@ -0,0 +1,76 @@
+# src/polydb/retry.py
+"""
+Retry logic with exponential backoff and metrics hooks
+"""
+
+import time
+import logging
+from functools import wraps
+from typing import Callable, Optional, Tuple, Type
+
+
+# Metrics hooks for enterprise monitoring
+class MetricsHooks:
+    """Metrics hooks that users can override for monitoring"""
+    
+    @staticmethod
+    def on_query_start(operation: str, **kwargs):
+        """Called when query starts"""
+        pass
+    
+    @staticmethod
+    def on_query_end(operation: str, duration: float, success: bool, **kwargs):
+        """Called when query ends"""
+        pass
+    
+    @staticmethod
+    def on_error(operation: str, error: Exception, **kwargs):
+        """Called when error occurs"""
+        pass
+
+
+def retry(max_attempts: int = 3, delay: float = 1.0, backoff: float = 2.0, 
+        exceptions: Tuple[Type[Exception], ...] = (Exception,)):
+    """
+    Retry decorator with exponential backoff
+    
+    Args:
+        max_attempts: Maximum number of retry attempts
+        delay: Initial delay between retries (seconds)
+        backoff: Backoff multiplier
+        exceptions: Tuple of exceptions to catch
+    """
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            attempt = 0
+            current_delay = delay
+            
+            logger = logging.getLogger(__name__)
+            
+            while attempt < max_attempts:
+                start_time = time.time()
+                try:
+                    MetricsHooks.on_query_start(func.__name__, args=args, kwargs=kwargs)
+                    result = func(*args, **kwargs)
+                    duration = time.time() - start_time
+                    MetricsHooks.on_query_end(func.__name__, duration, True)
+                    return result
+                except exceptions as e:
+                    attempt += 1
+                    duration = time.time() - start_time
+                    MetricsHooks.on_query_end(func.__name__, duration, False)
+                    MetricsHooks.on_error(func.__name__, e)
+                    
+                    if attempt >= max_attempts:
+                        raise
+                    
+                    logger.warning(
+                        f"Attempt {attempt}/{max_attempts} failed for {func.__name__}: {str(e)}. "
+                        f"Retrying in {current_delay}s..."
+                    )
+                    time.sleep(current_delay)
+                    current_delay *= backoff
+            
+        return wrapper
+    return decorator

polydb/schema.py

@@ -0,0 +1,205 @@
+# src/polydb/schema.py
+"""
+Schema management and migrations
+"""
+from typing import Dict, List, Optional, Any
+from dataclasses import dataclass
+from enum import Enum
+import json
+from datetime import datetime
+
+
+class ColumnType(Enum):
+    INTEGER = "INTEGER"
+    BIGINT = "BIGINT"
+    VARCHAR = "VARCHAR"
+    TEXT = "TEXT"
+    BOOLEAN = "BOOLEAN"
+    TIMESTAMP = "TIMESTAMP"
+    DATE = "DATE"
+    JSONB = "JSONB"
+    UUID = "UUID"
+    FLOAT = "FLOAT"
+    DECIMAL = "DECIMAL"
+
+
+@dataclass
+class Column:
+    name: str
+    type: ColumnType
+    nullable: bool = True
+    default: Optional[Any] = None
+    primary_key: bool = False
+    unique: bool = False
+    max_length: Optional[int] = None
+
+
+@dataclass
+class Index:
+    name: str
+    columns: List[str]
+    unique: bool = False
+
+
+class SchemaBuilder:
+    """Build SQL schema definitions"""
+    
+    def __init__(self):
+        self.columns: List[Column] = []
+        self.indexes: List[Index] = []
+        self.primary_keys: List[str] = []
+    
+    def add_column(self, column: Column) -> 'SchemaBuilder':
+        self.columns.append(column)
+        if column.primary_key:
+            self.primary_keys.append(column.name)
+        return self
+    
+    def add_index(self, index: Index) -> 'SchemaBuilder':
+        self.indexes.append(index)
+        return self
+    
+    def to_create_table(self, table_name: str) -> str:
+        """Generate CREATE TABLE statement"""
+        col_defs = []
+        
+        for col in self.columns:
+            parts = [col.name]
+            
+            # Type
+            if col.type == ColumnType.VARCHAR and col.max_length:
+                parts.append(f"VARCHAR({col.max_length})")
+            else:
+                parts.append(col.type.value)
+            
+            # Nullable
+            if not col.nullable:
+                parts.append("NOT NULL")
+            
+            # Default
+            if col.default is not None:
+                if isinstance(col.default, str):
+                    parts.append(f"DEFAULT '{col.default}'")
+                else:
+                    parts.append(f"DEFAULT {col.default}")
+            
+            # Unique
+            if col.unique:
+                parts.append("UNIQUE")
+            
+            col_defs.append(" ".join(parts))
+        
+        # Primary key
+        if self.primary_keys:
+            col_defs.append(f"PRIMARY KEY ({', '.join(self.primary_keys)})")
+        
+        sql = f"CREATE TABLE IF NOT EXISTS {table_name} (\n"
+        sql += ",\n".join(f"  {col}" for col in col_defs)
+        sql += "\n);"
+        
+        return sql
+    
+    def to_create_indexes(self, table_name: str) -> List[str]:
+        """Generate CREATE INDEX statements"""
+        statements = []
+        
+        for idx in self.indexes:
+            unique = "UNIQUE " if idx.unique else ""
+            cols = ", ".join(idx.columns)
+            sql = f"CREATE {unique}INDEX IF NOT EXISTS {idx.name} ON {table_name}({cols});"
+            statements.append(sql)
+        
+        return statements
+
+
+class MigrationManager:
+    """Database migration management"""
+    
+    def __init__(self, sql_adapter):
+        self.sql = sql_adapter
+        self._ensure_migrations_table()
+    
+    def _ensure_migrations_table(self):
+        """Create migrations tracking table"""
+        schema = """
+        CREATE TABLE IF NOT EXISTS polydb_migrations (
+            id SERIAL PRIMARY KEY,
+            version VARCHAR(255) UNIQUE NOT NULL,
+            name VARCHAR(255) NOT NULL,
+            applied_at TIMESTAMP DEFAULT NOW(),
+            rollback_sql TEXT,
+            checksum VARCHAR(64)
+        );
+        """
+        self.sql.execute(schema)
+    
+    def apply_migration(
+        self,
+        version: str,
+        name: str,
+        up_sql: str,
+        down_sql: Optional[str] = None
+    ) -> bool:
+        """Apply a migration"""
+        import hashlib
+        
+        # Check if already applied
+        existing = self.sql.execute(
+            "SELECT version FROM polydb_migrations WHERE version = %s",
+            [version],
+            fetch_one=True
+        )
+        
+        if existing:
+            return False
+        
+        # Calculate checksum
+        checksum = hashlib.sha256(up_sql.encode()).hexdigest()
+        
+        try:
+            # Execute migration
+            self.sql.execute(up_sql)
+            
+            # Record migration
+            self.sql.insert('polydb_migrations', {
+                'version': version,
+                'name': name,
+                'rollback_sql': down_sql,
+                'checksum': checksum
+            })
+            
+            return True
+        except Exception as e:
+            raise Exception(f"Migration {version} failed: {str(e)}")
+    
+    def rollback_migration(self, version: str) -> bool:
+        """Rollback a migration"""
+        migration = self.sql.execute(
+            "SELECT rollback_sql FROM polydb_migrations WHERE version = %s",
+            [version],
+            fetch_one=True
+        )
+        
+        if not migration or not migration.get('rollback_sql'):
+            raise Exception(f"No rollback available for {version}")
+        
+        try:
+            # Execute rollback
+            self.sql.execute(migration['rollback_sql'])
+            
+            # Remove from migrations
+            self.sql.execute(
+                "DELETE FROM polydb_migrations WHERE version = %s",
+                [version]
+            )
+            
+            return True
+        except Exception as e:
+            raise Exception(f"Rollback {version} failed: {str(e)}")
+    
+    def get_applied_migrations(self) -> List[Dict[str, Any]]:
+        """Get list of applied migrations"""
+        return self.sql.execute(
+            "SELECT * FROM polydb_migrations ORDER BY applied_at",
+            fetch=True
+        )