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

polydb/adapters/PostgreSQLAdapter.py

@@ -0,0 +1,453 @@
+# src/polydb/adapters/postgres.py
+import os
+import threading
+from typing import Any, List, Optional, Tuple, Union
+import hashlib
+from contextlib import contextmanager
+
+from ..errors import DatabaseError, ConnectionError
+from ..retry import retry
+from ..utils import validate_table_name, validate_column_name
+from ..query import QueryBuilder
+from ..types import JsonDict, Lookup
+
+
+class PostgreSQLAdapter:
+    """PostgreSQL with full LINQ support, connection pooling"""
+
+    def __init__(self):
+        from ..utils import setup_logger
+
+        self.logger = setup_logger(__name__)
+        self.connection_string = os.getenv(
+            "POSTGRES_CONNECTION_STRING",
+            os.getenv("POSTGRES_URL", "postgresql://user:password@localhost:5432/database"),
+        )
+        self._pool = None
+        self._lock = threading.Lock()
+        self._initialize_pool()
+
+    def _initialize_pool(self):
+        try:
+            import psycopg2.pool
+
+            with self._lock:
+                if not self._pool:
+                    self._pool = psycopg2.pool.ThreadedConnectionPool(
+                        minconn=int(os.getenv("POSTGRES_MIN_CONNECTIONS", "2")),
+                        maxconn=int(os.getenv("POSTGRES_MAX_CONNECTIONS", "20")),
+                        dsn=self.connection_string,
+                    )
+                    self.logger.info("PostgreSQL pool initialized")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize PostgreSQL pool: {str(e)}")
+
+    def _get_connection(self):
+        if not self._pool:
+            self._initialize_pool()
+        return self._pool.getconn()  # type: ignore
+
+    def _return_connection(self, conn):
+        if self._pool and conn:
+            self._pool.putconn(conn)
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(DatabaseError,))
+    def insert(self, table: str, data: JsonDict) -> JsonDict:
+        table = validate_table_name(table)
+        for k in data.keys():
+            validate_column_name(k)
+
+        conn = None
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+
+            columns = ", ".join(data.keys())
+            placeholders = ", ".join(["%s"] * len(data))
+            query = f"INSERT INTO {table} ({columns}) VALUES ({placeholders}) RETURNING *"
+
+            cursor.execute(query, list(data.values()))
+            result_row = cursor.fetchone()
+            columns_list = [desc[0] for desc in cursor.description]
+            result = dict(zip(columns_list, result_row))
+
+            conn.commit()
+            cursor.close()
+            return result
+        except Exception as e:
+            if conn:
+                conn.rollback()
+            raise DatabaseError(f"Insert failed: {str(e)}")
+        finally:
+            if conn:
+                self._return_connection(conn)
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(DatabaseError,))
+    def select(
+        self,
+        table: str,
+        query: Optional[Lookup] = None,
+        limit: Optional[int] = None,
+        offset: Optional[int] = None,
+    ) -> List[JsonDict]:
+        table = validate_table_name(table)
+        conn = None
+
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+
+            sql = f"SELECT * FROM {table}"
+            params = []
+
+            if query:
+                where_parts = []
+                for k, v in query.items():
+                    validate_column_name(k)
+                    if isinstance(v, (list, tuple)):
+                        placeholders = ",".join(["%s"] * len(v))
+                        where_parts.append(f"{k} IN ({placeholders})")
+                        params.extend(v)
+                    else:
+                        where_parts.append(f"{k} = %s")
+                        params.append(v)
+
+                if where_parts:
+                    sql += " WHERE " + " AND ".join(where_parts)
+
+            if limit:
+                sql += f" LIMIT %s"
+                params.append(limit)
+            if offset:
+                sql += f" OFFSET %s"
+                params.append(offset)
+
+            cursor.execute(sql, params)
+            columns = [desc[0] for desc in cursor.description]
+            results = [dict(zip(columns, row)) for row in cursor.fetchall()]
+            cursor.close()
+
+            return results
+        except Exception as e:
+            raise DatabaseError(f"Select failed: {str(e)}")
+        finally:
+            if conn:
+                self._return_connection(conn)
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(DatabaseError,))
+    def select_page(
+        self, table: str, query: Lookup, page_size: int, continuation_token: Optional[str] = None
+    ) -> Tuple[List[JsonDict], Optional[str]]:
+        offset = int(continuation_token) if continuation_token else 0
+        results = self.select(table, query, limit=page_size + 1, offset=offset)
+
+        has_more = len(results) > page_size
+        if has_more:
+            results = results[:page_size]
+
+        next_token = str(offset + page_size) if has_more else None
+        return results, next_token
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(DatabaseError,))
+    def update(self, table: str, entity_id: Union[Any, Lookup], data: JsonDict) -> JsonDict:
+        table = validate_table_name(table)
+        for k in data.keys():
+            validate_column_name(k)
+
+        conn = None
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+
+            set_clause = ", ".join([f"{k} = %s" for k in data.keys()])
+            params = list(data.values())
+
+            if isinstance(entity_id, dict):
+                where_parts = []
+                for k, v in entity_id.items():
+                    validate_column_name(k)
+                    where_parts.append(f"{k} = %s")
+                    params.append(v)
+                where_clause = " AND ".join(where_parts)
+            else:
+                where_clause = "id = %s"
+                params.append(entity_id)
+
+            query = f"UPDATE {table} SET {set_clause} WHERE {where_clause} RETURNING *"
+            cursor.execute(query, params)
+
+            result_row = cursor.fetchone()
+            if not result_row:
+                raise DatabaseError("No rows updated")
+
+            columns = [desc[0] for desc in cursor.description]
+            result = dict(zip(columns, result_row))
+
+            conn.commit()
+            cursor.close()
+            return result
+        except Exception as e:
+            if conn:
+                conn.rollback()
+            raise DatabaseError(f"Update failed: {str(e)}")
+        finally:
+            if conn:
+                self._return_connection(conn)
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(DatabaseError,))
+    def upsert(self, table: str, data: JsonDict) -> JsonDict:
+        table = validate_table_name(table)
+        for k in data.keys():
+            validate_column_name(k)
+
+        conn = None
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+
+            columns = ", ".join(data.keys())
+            placeholders = ", ".join(["%s"] * len(data))
+
+            conflict_columns = ["id"] if "id" in data else list(data.keys())[:1]
+            update_clause = ", ".join(
+                [f"{k} = EXCLUDED.{k}" for k in data.keys() if k not in conflict_columns]
+            )
+
+            query = f"""
+                INSERT INTO {table} ({columns}) 
+                VALUES ({placeholders})
+                ON CONFLICT ({', '.join(conflict_columns)}) 
+                DO UPDATE SET {update_clause}
+                RETURNING *
+            """
+
+            cursor.execute(query, list(data.values()))
+            result_row = cursor.fetchone()
+            columns_list = [desc[0] for desc in cursor.description]
+            result = dict(zip(columns_list, result_row))
+
+            conn.commit()
+            cursor.close()
+            return result
+        except Exception as e:
+            if conn:
+                conn.rollback()
+            raise DatabaseError(f"Upsert failed: {str(e)}")
+        finally:
+            if conn:
+                self._return_connection(conn)
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(DatabaseError,))
+    def delete(self, table: str, entity_id: Union[Any, Lookup]) -> JsonDict:
+        table = validate_table_name(table)
+        conn = None
+
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+
+            params = []
+            if isinstance(entity_id, dict):
+                where_parts = []
+                for k, v in entity_id.items():
+                    validate_column_name(k)
+                    where_parts.append(f"{k} = %s")
+                    params.append(v)
+                where_clause = " AND ".join(where_parts)
+            else:
+                where_clause = "id = %s"
+                params.append(entity_id)
+
+            query = f"DELETE FROM {table} WHERE {where_clause} RETURNING *"
+            cursor.execute(query, params)
+            result_row = cursor.fetchone()
+
+            if not result_row:
+                raise DatabaseError("No rows deleted")
+
+            columns = [desc[0] for desc in cursor.description]
+            result = dict(zip(columns, result_row))
+
+            conn.commit()
+            cursor.close()
+            return result
+        except Exception as e:
+            if conn:
+                conn.rollback()
+            raise DatabaseError(f"Delete failed: {str(e)}")
+        finally:
+            if conn:
+                self._return_connection(conn)
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(DatabaseError,))
+    def query_linq(self, table: str, builder: QueryBuilder) -> Union[List[JsonDict], int]:
+        table = validate_table_name(table)
+        conn = None
+
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+
+            if builder.count_only:
+                sql = f"SELECT COUNT(*) FROM {table}"
+            elif builder.select_fields:
+                for f in builder.select_fields:
+                    validate_column_name(f)
+                fields = ", ".join(builder.select_fields)
+                if builder.distinct:
+                    sql = f"SELECT DISTINCT {fields} FROM {table}"
+                else:
+                    sql = f"SELECT {fields} FROM {table}"
+            else:
+                sql = f"SELECT * FROM {table}"
+
+            params = []
+
+            # WHERE
+            where_clause, where_params = builder.to_sql_where()
+            if where_clause:
+                sql += f" WHERE {where_clause}"
+                params.extend(where_params)
+
+            # GROUP BY
+            if builder.group_by_fields:
+                for f in builder.group_by_fields:
+                    validate_column_name(f)
+                sql += f" GROUP BY {', '.join(builder.group_by_fields)}"
+
+            # ORDER BY
+            if builder.order_by_fields:
+                order_parts = []
+                for field, desc in builder.order_by_fields:
+                    validate_column_name(field)
+                    direction = "DESC" if desc else "ASC"
+                    order_parts.append(f"{field} {direction}")
+                sql += f" ORDER BY {', '.join(order_parts)}"
+
+            # LIMIT / OFFSET
+            if builder.take_count:
+                sql += f" LIMIT %s"
+                params.append(builder.take_count)
+
+            if builder.skip_count:
+                sql += f" OFFSET %s"
+                params.append(builder.skip_count)
+
+            cursor.execute(sql, params)
+
+            if builder.count_only:
+                return cursor.fetchone()[0]
+
+            columns = [desc[0] for desc in cursor.description]
+            results = [dict(zip(columns, row)) for row in cursor.fetchall()]
+            cursor.close()
+
+            return results
+        except Exception as e:
+            raise DatabaseError(f"LINQ query failed: {str(e)}")
+        finally:
+            if conn:
+                self._return_connection(conn)
+
+    def __del__(self):
+        if self._pool:
+            try:
+                self._pool.closeall()
+            except:
+                pass
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(DatabaseError,))
+    def execute(
+        self,
+        sql: str,
+        params: Optional[List[Any]] = None,
+        *,
+        fetch: bool = False,
+        fetch_one: bool = False,
+    ) -> Union[None, JsonDict, List[JsonDict]]:
+        conn = None
+        cursor = None
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+
+            self.logger.debug("Executing raw SQL: %s", sql)
+            cursor.execute(sql, params or [])
+
+            # Fetch results (if any) BEFORE commit (fine either way)
+            if fetch_one:
+                row = cursor.fetchone()
+                result = None
+                if row:
+                    columns = [desc[0] for desc in cursor.description]
+                    result = dict(zip(columns, row))
+                conn.commit()
+                return result
+
+            if fetch:
+                rows = cursor.fetchall()
+                columns = [desc[0] for desc in cursor.description]
+                results = [dict(zip(columns, r)) for r in rows]
+                conn.commit()
+                return results
+
+            # Non-fetch execution (DDL/DML)
+            conn.commit()
+            return None
+
+        except Exception as e:
+            if conn:
+                try:
+                    conn.rollback()
+                except Exception:
+                    pass
+            raise DatabaseError(f"Execute failed: {str(e)}")
+
+        finally:
+            if cursor:
+                try:
+                    cursor.close()
+                except Exception:
+                    pass
+            if conn:
+                self._return_connection(conn)
+
+    @contextmanager
+    def distributed_lock(self, lock_name: str):
+        """
+        PostgreSQL advisory lock.
+        Cluster-wide distributed lock.
+
+        Safe across:
+        - Multiple pods
+        - Multiple containers
+        - Multiple instances
+        """
+
+        conn = None
+        try:
+            conn = self._get_connection()
+            cursor = conn.cursor()
+
+            # Convert lock_name to 64-bit hash
+            lock_id = int(hashlib.sha256(lock_name.encode()).hexdigest(), 16) % (2**63)
+
+            cursor.execute("SELECT pg_advisory_lock(%s);", (lock_id,))
+            self.logger.debug(f"Acquired distributed lock: {lock_name}")
+
+            yield
+
+            cursor.execute("SELECT pg_advisory_unlock(%s);", (lock_id,))
+            self.logger.debug(f"Released distributed lock: {lock_name}")
+
+            cursor.close()
+            conn.commit()
+
+        except Exception as e:
+            if conn:
+                conn.rollback()
+            raise DatabaseError(f"Distributed lock failed: {str(e)}")
+
+        finally:
+            if conn:
+                self._return_connection(conn)

polydb/adapters/PubSubAdapter.py

@@ -0,0 +1,83 @@
+# src/polydb/adapters/PubSubAdapter.py
+
+from polydb.base.QueueAdapter import QueueAdapter
+from polydb.errors import ConnectionError, QueueError
+from polydb.retry import retry
+import os
+import threading
+from typing import Any, Dict, List
+
+class PubSubAdapter(QueueAdapter):
+    """GCP Pub/Sub with client reuse"""
+
+    def __init__(self):
+        super().__init__()
+        self.project_id = os.getenv("GOOGLE_CLOUD_PROJECT") or ""
+        self.topic_name = os.getenv("PUBSUB_TOPIC", "default")
+        self._publisher = None
+        self._subscriber = None
+        self._lock = threading.Lock()
+        self._initialize_clients()
+
+    def _initialize_clients(self):
+        """Initialize Pub/Sub clients once"""
+        try:
+            from google.cloud import pubsub_v1
+
+            with self._lock:
+                if not self._publisher:
+                    self._publisher = pubsub_v1.PublisherClient()
+                    self._subscriber = pubsub_v1.SubscriberClient()
+                    self.logger.info("Initialized Pub/Sub clients")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize Pub/Sub: {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 topic"""
+        try:
+            import json
+
+            if self._publisher:
+                topic_path = self._publisher.topic_path(
+                    self.project_id, queue_name or self.topic_name
+                )
+                data = json.dumps(message).encode("utf-8")
+                future = self._publisher.publish(topic_path, data)
+                return future.result()
+            return ""
+        except Exception as e:
+            raise QueueError(f"Pub/Sub 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 subscription"""
+        try:
+            import json
+
+            if self._subscriber:
+                subscription_path = self._subscriber.subscription_path(
+                    self.project_id, queue_name or self.topic_name
+                )
+
+                response = self._subscriber.pull(
+                    subscription=subscription_path, max_messages=max_messages, timeout=5.0
+                )
+
+                messages = [
+                    json.loads(msg.message.data.decode()) for msg in response.received_messages
+                ]
+
+                # Acknowledge messages
+                if response.received_messages:
+                    ack_ids = [msg.ack_id for msg in response.received_messages]
+                    self._subscriber.acknowledge(subscription=subscription_path, ack_ids=ack_ids)
+
+                return messages
+            return []
+        except Exception as e:
+            raise QueueError(f"Pub/Sub receive failed: {str(e)}")
+
+    def delete(self, message_id: str, queue_name: str = "default") -> bool:
+        """Messages are acknowledged upon receipt"""
+        return True

polydb/adapters/S3Adapter.py

@@ -0,0 +1,86 @@
+# src/polydb/adapters/S3Adapter.py
+"""
+S3 adapter
+"""
+
+import os
+import threading
+from typing import List, Optional
+from ..base.ObjectStorageAdapter import ObjectStorageAdapter
+from ..errors import StorageError, ConnectionError
+from ..retry import retry
+class S3Adapter(ObjectStorageAdapter):
+    """AWS S3 with client reuse"""
+
+    def __init__(self):
+        super().__init__()
+        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 client once"""
+        try:
+            import boto3
+
+            with self._lock:
+                if not self._client:
+                    self._client = boto3.client("s3")
+                    self.logger.info("Initialized S3 client")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize S3 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: {key}")
+            return key
+        except Exception as e:
+            raise StorageError(f"S3 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 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 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 list failed: {str(e)}")
+
+