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

polydb/adapters/S3CompatibleAdapter.py

@@ -0,0 +1,90 @@
+# src/polydb/adapters/S3CompatibleAdapter.py
+import os
+import threading
+from typing import List
+from ..base.ObjectStorageAdapter import ObjectStorageAdapter
+from ..errors import StorageError, ConnectionError
+from ..retry import retry
+
+class S3CompatibleAdapter(ObjectStorageAdapter):
+    """S3-compatible storage (MinIO, DigitalOcean Spaces) with client reuse"""
+
+    def __init__(self):
+        super().__init__()
+        self.endpoint = os.getenv("S3_ENDPOINT_URL")
+        self.access_key = os.getenv("S3_ACCESS_KEY")
+        self.secret_key = os.getenv("S3_SECRET_KEY")
+        self.bucket_name = os.getenv("S3_BUCKET_NAME", "default")
+        self._client = None
+        self._lock = threading.Lock()
+        self._initialize_client()
+
+    def _initialize_client(self):
+        """Initialize S3-compatible client once"""
+        try:
+            import boto3
+
+            with self._lock:
+                if not self._client:
+                    self._client = boto3.client(
+                        "s3",
+                        endpoint_url=self.endpoint,
+                        aws_access_key_id=self.access_key,
+                        aws_secret_access_key=self.secret_key,
+                    )
+                    self.logger.info("Initialized S3-compatible client")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize S3-compatible client: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def _put_raw(self, key: str, data: bytes) -> str:
+        """Store object"""
+        try:
+            if not self._client:
+                self._initialize_client()
+            if self._client:
+                self._client.put_object(Bucket=self.bucket_name, Key=key, Body=data)
+                self.logger.debug(f"Uploaded to S3-compatible: {key}")
+            return key
+        except Exception as e:
+            raise StorageError(f"S3-compatible put failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def get(self, key: str) -> bytes | None:
+        """Get object"""
+        try:
+            if not self._client:
+                self._initialize_client()
+            if self._client:
+                response = self._client.get_object(Bucket=self.bucket_name, Key=key)
+                return response["Body"].read()
+            return None
+        except Exception as e:
+            raise StorageError(f"S3-compatible get failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def delete(self, key: str) -> bool:
+        """Delete object"""
+        try:
+            if not self._client:
+                self._initialize_client()
+            if self._client:
+                self._client.delete_object(Bucket=self.bucket_name, Key=key)
+                return True
+            return False
+        except Exception as e:
+            raise StorageError(f"S3-compatible delete failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def list(self, prefix: str = "") -> List[str]:
+        """List objects with prefix"""
+        try:
+            if not self._client:
+                self._initialize_client()
+            if self._client:
+                response = self._client.list_objects_v2(Bucket=self.bucket_name, Prefix=prefix)
+                return [obj["Key"] for obj in response.get("Contents", [])]
+            return []
+        except Exception as e:
+            raise StorageError(f"S3-compatible list failed: {str(e)}")
+

polydb/adapters/SQSAdapter.py

@@ -0,0 +1,84 @@
+from polydb.base.QueueAdapter import QueueAdapter
+from polydb.errors import ConnectionError, QueueError
+from polydb.retry import retry
+
+
+import boto3
+from botocore.client import BaseClient
+
+
+import json
+import os
+import threading
+from typing import Any, Dict, List
+
+
+class SQSAdapter(QueueAdapter):
+    """AWS SQS with client reuse"""
+
+    def __init__(self):
+        super().__init__()
+        self.queue_url = os.getenv("SQS_QUEUE_URL")
+        self._client: BaseClient | None = None
+        self._lock = threading.Lock()
+        self._initialize_client()
+
+    def _initialize_client(self):
+        """Initialize SQS client once"""
+        try:
+            import boto3
+
+            with self._lock:
+                if not self._client:
+                    self._client = boto3.client("sqs")
+                    self.logger.info("Initialized SQS client")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize SQS client: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(QueueError,))
+    def send(self, message: Dict[str, Any], queue_name: str = "default") -> str:
+        """Send message to queue"""
+        try:
+            import json
+
+            if not self._client:
+                self._initialize_client()
+            if self._client:
+                response = self._client.send_message(
+                    QueueUrl=self.queue_url, MessageBody=json.dumps(message)
+                )
+                return response["MessageId"]
+            return ""
+        except Exception as e:
+            raise QueueError(f"SQS send failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(QueueError,))
+    def receive(self, queue_name: str = "default", max_messages: int = 1) -> List[Dict[str, Any]]:
+        """Receive messages from queue"""
+        try:
+            import json
+
+            if not self._client:
+                self._initialize_client()
+            if self._client:
+                response = self._client.receive_message(
+                    QueueUrl=self.queue_url, MaxNumberOfMessages=max_messages, WaitTimeSeconds=5
+                )
+                messages = response.get("Messages", [])
+                return [json.loads(msg["Body"]) for msg in messages]
+            return []
+        except Exception as e:
+            raise QueueError(f"SQS receive failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(QueueError,))
+    def delete(self, message_id: str, queue_name: str = "default") -> bool:
+        """Delete message from queue"""
+        try:
+            if not self._client:
+                self._initialize_client()
+            if self._client:
+                self._client.delete_message(QueueUrl=self.queue_url, ReceiptHandle=message_id)
+                return True
+            return False
+        except Exception as e:
+            raise QueueError(f"SQS delete failed: {str(e)}")

polydb/adapters/VercelKVAdapter.py

@@ -0,0 +1,327 @@
+# src/polydb/adapters/VercelKVAdapter.py
+import os
+import threading
+from typing import Any, Dict, List, Optional
+from polydb.base.NoSQLKVAdapter import NoSQLKVAdapter
+from ..errors import NoSQLError, StorageError
+from ..retry import retry
+from ..types import JsonDict
+from ..models import PartitionConfig
+
+
+class VercelKVAdapter(NoSQLKVAdapter):
+    """Vercel KV (Redis) with Vercel Blob overflow (limit: 100KB per key)"""
+    
+    VERCEL_KV_MAX_SIZE = 100 * 1024  # 100KB
+    
+    def __init__(self, partition_config: Optional[PartitionConfig] = None):
+        super().__init__(partition_config)
+        self.max_size = self.VERCEL_KV_MAX_SIZE
+        self.kv_url = os.getenv('KV_URL')
+        self.kv_token = os.getenv('KV_REST_API_TOKEN')
+        self.blob_token = os.getenv('BLOB_READ_WRITE_TOKEN')
+        self.timeout = int(os.getenv('VERCEL_KV_TIMEOUT', '10'))
+        self._client_lock = threading.Lock()
+    
+    @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
+    def _put_raw(self, model: type, pk: str, rk: str, data: JsonDict) -> JsonDict:
+        try:
+            import requests
+            import json
+            import hashlib
+            
+            key = f"{pk}:{rk}"
+            data_copy = dict(data)
+            data_copy['_pk'] = pk
+            data_copy['_rk'] = rk
+            
+            # Check size
+            data_bytes = json.dumps(data_copy).encode()
+            data_size = len(data_bytes)
+            
+            if data_size > self.VERCEL_KV_MAX_SIZE:
+                # Store in Vercel Blob
+                blob_id = hashlib.md5(data_bytes).hexdigest()
+                blob_key = f"overflow/{pk}/{rk}/{blob_id}.json"
+                
+                blob_response = requests.put(
+                    f"https://blob.vercel-storage.com/{blob_key}",
+                    headers={
+                        "Authorization": f"Bearer {self.blob_token}",
+                        "x-content-type": "application/json",
+                    },
+                    data=data_bytes,
+                    timeout=self.timeout,
+                )
+                blob_response.raise_for_status()
+                self.logger.info(f"Stored overflow to Blob: {blob_key} ({data_size} bytes)")
+                
+                # Store reference in KV
+                reference_data = {
+                    '_pk': pk,
+                    '_rk': rk,
+                    '_overflow': True,
+                    '_blob_key': blob_key,
+                    '_size': data_size,
+                    '_checksum': blob_id,
+                }
+                
+                response = requests.post(
+                    f"{self.kv_url}/set/{key}",
+                    headers={'Authorization': f'Bearer {self.kv_token}'},
+                    json={'value': json.dumps(reference_data)},
+                    timeout=self.timeout
+                )
+                response.raise_for_status()
+            else:
+                # Store directly in KV
+                response = requests.post(
+                    f"{self.kv_url}/set/{key}",
+                    headers={'Authorization': f'Bearer {self.kv_token}'},
+                    json={'value': json.dumps(data_copy)},
+                    timeout=self.timeout
+                )
+                response.raise_for_status()
+            
+            return {'key': key, '_pk': pk, '_rk': rk}
+        except Exception as e:
+            raise NoSQLError(f"Vercel KV put failed: {str(e)}")
+    
+    @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
+    def _get_raw(self, model: type, pk: str, rk: str) -> Optional[JsonDict]:
+        try:
+            import requests
+            import json
+            import hashlib
+            
+            key = f"{pk}:{rk}"
+            
+            response = requests.get(
+                f"{self.kv_url}/get/{key}",
+                headers={'Authorization': f'Bearer {self.kv_token}'},
+                timeout=self.timeout
+            )
+            
+            if response.status_code != 200:
+                return None
+            
+            result = response.json().get('result')
+            if not result:
+                return None
+            
+            kv_data = json.loads(result)
+            
+            # Check if overflow
+            if kv_data.get('_overflow'):
+                blob_key = kv_data.get('_blob_key')
+                checksum = kv_data.get('_checksum')
+                
+                if blob_key:
+                    blob_response = requests.get(
+                        f"https://blob.vercel-storage.com/{blob_key}",
+                        headers={"Authorization": f"Bearer {self.blob_token}"},
+                        timeout=self.timeout,
+                    )
+                    blob_response.raise_for_status()
+                    blob_data = blob_response.content
+                    
+                    # Verify checksum
+                    actual_checksum = hashlib.md5(blob_data).hexdigest()
+                    if actual_checksum != checksum:
+                        raise NoSQLError(f"Checksum mismatch: expected {checksum}, got {actual_checksum}")
+                    
+                    retrieved = json.loads(blob_data.decode())
+                    self.logger.debug(f"Retrieved overflow from Blob: {blob_key}")
+                    return retrieved
+            
+            return kv_data
+        except Exception as e:
+            raise NoSQLError(f"Vercel KV get failed: {str(e)}")
+    
+    @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
+    def _query_raw(self, model: type, filters: Dict[str, Any], limit: Optional[int]) -> List[JsonDict]:
+        try:
+            import requests
+            import json
+            
+            # Vercel KV doesn't support native queries, use SCAN pattern
+            pattern = "*"
+            if filters.get('_pk'):
+                pattern = f"{filters['_pk']}:*"
+            
+            response = requests.get(
+                f"{self.kv_url}/keys/{pattern}",
+                headers={'Authorization': f'Bearer {self.kv_token}'},
+                timeout=self.timeout
+            )
+            
+            if response.status_code != 200:
+                return []
+            
+            keys = response.json().get('result', [])
+            
+            # Fetch all matching keys
+            results = []
+            for key in keys:
+                if limit and len(results) >= limit:
+                    break
+                
+                get_response = requests.get(
+                    f"{self.kv_url}/get/{key}",
+                    headers={'Authorization': f'Bearer {self.kv_token}'},
+                    timeout=self.timeout
+                )
+                
+                if get_response.status_code == 200:
+                    result = get_response.json().get('result')
+                    if result:
+                        data = json.loads(result)
+                        
+                        # Apply filters
+                        match = True
+                        for k, v in filters.items():
+                            if k.startswith('_'):
+                                continue
+                            if data.get(k) != v:
+                                match = False
+                                break
+                        
+                        if match:
+                            results.append(data)
+            
+            return results
+        except Exception as e:
+            raise NoSQLError(f"Vercel KV query failed: {str(e)}")
+    
+    @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
+    def _delete_raw(self, model: type, pk: str, rk: str, etag: Optional[str]) -> JsonDict:
+        try:
+            import requests
+            import json
+            
+            key = f"{pk}:{rk}"
+            
+            # Check if overflow before deleting
+            try:
+                get_response = requests.get(
+                    f"{self.kv_url}/get/{key}",
+                    headers={'Authorization': f'Bearer {self.kv_token}'},
+                    timeout=self.timeout
+                )
+                
+                if get_response.status_code == 200:
+                    result = get_response.json().get('result')
+                    if result:
+                        kv_data = json.loads(result)
+                        
+                        if kv_data.get('_overflow'):
+                            blob_key = kv_data.get('_blob_key')
+                            if blob_key:
+                                blob_response = requests.delete(
+                                    f"https://blob.vercel-storage.com/{blob_key}",
+                                    headers={"Authorization": f"Bearer {self.blob_token}"},
+                                    timeout=self.timeout,
+                                )
+                                blob_response.raise_for_status()
+                                self.logger.debug(f"Deleted overflow Blob: {blob_key}")
+            except:
+                pass  # Key might not exist or no overflow
+            
+            # Delete KV key
+            response = requests.delete(
+                f"{self.kv_url}/del/{key}",
+                headers={'Authorization': f'Bearer {self.kv_token}'},
+                timeout=self.timeout
+            )
+            response.raise_for_status()
+            
+            return {'deleted': True, 'key': key}
+        except Exception as e:
+            raise NoSQLError(f"Vercel KV delete failed: {str(e)}")
+
+
+class VercelBlobAdapter:
+    """Vercel Blob Storage"""
+    
+    def __init__(self):
+        from ..utils import setup_logger
+        self.logger = setup_logger(__name__)
+        self.blob_token = os.getenv("BLOB_READ_WRITE_TOKEN")
+        self.timeout = int(os.getenv("VERCEL_BLOB_TIMEOUT", "10"))
+    
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def put(self, key: str, data: bytes) -> str:
+        try:
+            import requests
+            
+            response = requests.put(
+                f"https://blob.vercel-storage.com/{key}",
+                headers={
+                    "Authorization": f"Bearer {self.blob_token}",
+                    "x-content-type": "application/octet-stream",
+                },
+                data=data,
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            return response.json()["url"]
+        except Exception as e:
+            raise StorageError(f"Vercel Blob put failed: {str(e)}")
+    
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def get(self, key: str) -> bytes:
+        try:
+            import requests
+            
+            response = requests.get(
+                f"https://blob.vercel-storage.com/{key}",
+                headers={"Authorization": f"Bearer {self.blob_token}"},
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            return response.content
+        except Exception as e:
+            raise StorageError(f"Vercel Blob get failed: {str(e)}")
+    
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def delete(self, key: str) -> bool:
+        try:
+            import requests
+            
+            response = requests.delete(
+                f"https://blob.vercel-storage.com/{key}",
+                headers={"Authorization": f"Bearer {self.blob_token}"},
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            return True
+        except Exception as e:
+            raise StorageError(f"Vercel Blob delete failed: {str(e)}")
+    
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def list(self, prefix: str = "") -> List[str]:
+        try:
+            import requests
+            
+            response = requests.get(
+                f"https://blob.vercel-storage.com/?prefix={prefix}",
+                headers={"Authorization": f"Bearer {self.blob_token}"},
+                timeout=self.timeout,
+            )
+            response.raise_for_status()
+            return [blob["pathname"] for blob in response.json()["blobs"]]
+        except Exception as e:
+            raise StorageError(f"Vercel Blob list failed: {str(e)}")
+
+
+class VercelQueueAdapter:
+    """Vercel Queue adapter"""
+    
+    def send(self, message: Dict[str, Any], queue_name: str = "default") -> str:
+        raise NotImplementedError("Vercel Queue not yet available")
+    
+    def receive(self, queue_name: str = "default", max_messages: int = 1) -> List[Dict[str, Any]]:
+        raise NotImplementedError("Vercel Queue not yet available")
+    
+    def delete(self, message_id: str, queue_name: str = "default") -> bool:
+        raise NotImplementedError("Vercel Queue not yet available")

polydb/advanced_query.py

@@ -0,0 +1,147 @@
+# src/polydb/advanced_query.py
+"""
+Advanced query capabilities: JOIN, subqueries, aggregates
+"""
+from typing import List, Optional, Any, Dict
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class JoinType(Enum):
+    INNER = "INNER JOIN"
+    LEFT = "LEFT JOIN"
+    RIGHT = "RIGHT JOIN"
+    FULL = "FULL OUTER JOIN"
+
+
+class AggregateFunction(Enum):
+    COUNT = "COUNT"
+    SUM = "SUM"
+    AVG = "AVG"
+    MIN = "MIN"
+    MAX = "MAX"
+
+
+@dataclass
+class Join:
+    table: str
+    join_type: JoinType
+    on_left: str
+    on_right: str
+    alias: Optional[str] = None
+
+
+@dataclass
+class Aggregate:
+    function: AggregateFunction
+    field: str
+    alias: str
+
+
+@dataclass
+class AdvancedQueryBuilder:
+    """Extended QueryBuilder with JOINs and aggregates"""
+
+    table: str
+    joins: List[Join] = field(default_factory=list)
+    aggregates: List[Aggregate] = field(default_factory=list)
+    group_by_fields: List[str] = field(default_factory=list)
+    having_conditions: List[str] = field(default_factory=list)
+    subqueries: Dict[str, "AdvancedQueryBuilder"] = field(default_factory=dict)
+
+    def join(
+        self,
+        table: str,
+        on_left: str,
+        on_right: str,
+        join_type: JoinType = JoinType.INNER,
+        alias: Optional[str] = None,
+    ) -> "AdvancedQueryBuilder":
+        """Add JOIN clause"""
+        self.joins.append(
+            Join(table=table, join_type=join_type, on_left=on_left, on_right=on_right, alias=alias)
+        )
+        return self
+
+    def aggregate(
+        self, function: AggregateFunction, field: str, alias: str
+    ) -> "AdvancedQueryBuilder":
+        """Add aggregate function"""
+        self.aggregates.append(Aggregate(function=function, field=field, alias=alias))
+        return self
+
+    def group_by(self, *fields: str) -> "AdvancedQueryBuilder":
+        """Add GROUP BY"""
+        self.group_by_fields.extend(fields)
+        return self
+
+    def having(self, condition: str) -> "AdvancedQueryBuilder":
+        """Add HAVING clause"""
+        self.having_conditions.append(condition)
+        return self
+
+    def to_sql(self) -> tuple[str, List[Any]]:
+        """Generate complete SQL with JOINs"""
+        params = []
+
+        # SELECT clause
+        if self.aggregates:
+            select_parts = [
+                f"{agg.function.value}({agg.field}) AS {agg.alias}" for agg in self.aggregates
+            ]
+            if self.group_by_fields:
+                select_parts = list(self.group_by_fields) + select_parts
+            sql = f"SELECT {', '.join(select_parts)}"
+        else:
+            sql = f"SELECT *"
+
+        # FROM clause
+        sql += f" FROM {self.table}"
+
+        # JOIN clauses
+        for join in self.joins:
+            table = f"{join.table} AS {join.alias}" if join.alias else join.table
+            sql += f" {join.join_type.value} {table}"
+            sql += f" ON {join.on_left} = {join.on_right}"
+
+        # GROUP BY clause
+        if self.group_by_fields:
+            sql += f" GROUP BY {', '.join(self.group_by_fields)}"
+
+        # HAVING clause
+        if self.having_conditions:
+            sql += f" HAVING {' AND '.join(self.having_conditions)}"
+
+        return sql, params
+
+
+# Example usage helper
+class QueryHelper:
+    """Helper methods for common query patterns"""
+
+    @staticmethod
+    def count_by_field(table: str, field: str, group_field: str) -> AdvancedQueryBuilder:
+        """Count occurrences grouped by field"""
+        return (
+            AdvancedQueryBuilder(table=table)
+            .aggregate(AggregateFunction.COUNT, field, "count")
+            .group_by(group_field)
+        )
+
+    @staticmethod
+    def sum_by_category(table: str, sum_field: str, category_field: str) -> AdvancedQueryBuilder:
+        """Sum values grouped by category"""
+        return (
+            AdvancedQueryBuilder(table=table)
+            .aggregate(AggregateFunction.SUM, sum_field, "total")
+            .group_by(category_field)
+        )
+
+    @staticmethod
+    def join_with_filter(
+        left_table: str, right_table: str, join_field: str
+    ) -> AdvancedQueryBuilder:
+        """Simple INNER JOIN"""
+        return AdvancedQueryBuilder(table=left_table).join(
+            right_table, f"{left_table}.{join_field}", f"{right_table}.{join_field}"
+        )