altcodepro-polydb-python 2.2.2__py3-none-any.whl → 2.2.4__py3-none-any.whl

altcodepro_polydb_python-2.2.2.dist-info/METADATA

@@ -1,379 +0,0 @@
-Metadata-Version: 2.4
-Name: altcodepro-polydb-python
-Version: 2.2.2
-Summary: Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety
-Author: AltCodePro
-Project-URL: Homepage, https://github.com/altcodepro/polydb-python
-Project-URL: Documentation, https://github.com/altcodepro/polydb-python#readme
-Project-URL: Repository, https://github.com/altcodepro/polydb-python
-Project-URL: Bug Tracker, https://github.com/altcodepro/polydb-python/issues
-Keywords: database,cloud,multi-cloud,aws,azure,gcp,abstraction,nosql,sql,postgres,mongodb,dynamodb,s3
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Database
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: psycopg2-binary>=2.9.11
-Requires-Dist: tenacity>=9.1.4
-Requires-Dist: redis>=6.4.0
-Requires-Dist: python-dotenv>=1.1.1
-Provides-Extra: aws
-Requires-Dist: boto3>=1.42.47; extra == "aws"
-Requires-Dist: botocore>=1.42.47; extra == "aws"
-Provides-Extra: azure
-Requires-Dist: azure-core>=1.38.1; extra == "azure"
-Requires-Dist: azure-data-tables>=12.7.0; extra == "azure"
-Requires-Dist: azure-storage-blob>=12.28.0; extra == "azure"
-Requires-Dist: azure-storage-file-share>=12.24.0; extra == "azure"
-Requires-Dist: azure-storage-queue>=12.15.0; extra == "azure"
-Provides-Extra: gcp
-Requires-Dist: google-api-core>=2.29.0; extra == "gcp"
-Requires-Dist: google-auth>=2.48.0; extra == "gcp"
-Requires-Dist: google-cloud-core>=2.5.0; extra == "gcp"
-Requires-Dist: google-cloud-firestore>=2.23.0; extra == "gcp"
-Requires-Dist: google-cloud-pubsub>=2.35.0; extra == "gcp"
-Requires-Dist: google-cloud-storage>=3.9.0; extra == "gcp"
-Provides-Extra: mongodb
-Requires-Dist: pymongo>=4.16.0; extra == "mongodb"
-Provides-Extra: rabbitmq
-Requires-Dist: pika>=1.3.2; extra == "rabbitmq"
-Provides-Extra: vercel
-Requires-Dist: requests>=2.32.5; extra == "vercel"
-Provides-Extra: generic
-Requires-Dist: pymongo>=4.16.0; extra == "generic"
-Requires-Dist: pika>=1.3.2; extra == "generic"
-Requires-Dist: boto3>=1.42.47; extra == "generic"
-Provides-Extra: all
-Requires-Dist: boto3>=1.42.47; extra == "all"
-Requires-Dist: botocore>=1.42.47; extra == "all"
-Requires-Dist: azure-core>=1.38.1; extra == "all"
-Requires-Dist: azure-data-tables>=12.7.0; extra == "all"
-Requires-Dist: azure-storage-blob>=12.28.0; extra == "all"
-Requires-Dist: azure-storage-file-share>=12.24.0; extra == "all"
-Requires-Dist: azure-storage-queue>=12.15.0; extra == "all"
-Requires-Dist: google-cloud-firestore>=2.23.0; extra == "all"
-Requires-Dist: google-cloud-pubsub>=2.35.0; extra == "all"
-Requires-Dist: google-cloud-storage>=3.9.0; extra == "all"
-Requires-Dist: pymongo>=4.16.0; extra == "all"
-Requires-Dist: pika>=1.3.2; extra == "all"
-Requires-Dist: requests>=2.32.5; extra == "all"
-Provides-Extra: dev
-Requires-Dist: black>=26.1.0; extra == "dev"
-Requires-Dist: flake8>=7.3.0; extra == "dev"
-Requires-Dist: isort>=7.0.0; extra == "dev"
-Requires-Dist: mypy>=1.19.1; extra == "dev"
-Provides-Extra: test
-Requires-Dist: pytest>=9.0.2; extra == "test"
-Requires-Dist: pytest-cov>=7.0.0; extra == "test"
-Requires-Dist: pytest-mock>=3.15.1; extra == "test"
-Requires-Dist: moto>=5.1.21; extra == "test"
-Dynamic: license-file
-
-# PolyDB v2.2.2 - Enterprise Database Abstraction Layer
-
-**Production-ready, cloud-independent database abstraction with full LINQ support, field-level audit, cache, and overflow storage**
-
-## Features
-
-✅ **LINQ-Style Queries** - All SQL clauses: WHERE, ORDER BY, SELECT, GROUP BY, DISTINCT, COUNT  
-✅ **Multi-Cloud** - Azure, AWS, GCP, Vercel, MongoDB, PostgreSQL  
-✅ **Automatic Overflow** - Large NoSQL records → Object Storage (transparent)  
-✅ **Enterprise Audit** - Cryptographic hash chain, field-level changes, strict ordering  
-✅ **Cache Engine** - In-memory with TTL, automatic invalidation  
-✅ **Soft Delete** - Optional logical deletion with audit trail  
-✅ **Auto-Inject** - Tenant ID, audit fields (created_at, updated_by, etc.)  
-✅ **Thread-Safe** - Connection pooling, distributed-safe hash chaining  
-✅ **Retry Logic** - Exponential backoff, configurable  
-✅ **Type-Safe** - Protocol-based adapters, full type hints  
-
-## Quick Start
-
-```python
-from polydb import DatabaseFactory, polydb_model, QueryBuilder, Operator, AuditContext
-
-# 1. Define model
-@polydb_model
-class User:
-    __polydb__ = {
-        "storage": "sql",
-        "table": "users",
-        "cache": True,
-        "cache_ttl": 600,
-    }
-
-# 2. Initialize
-db = DatabaseFactory(
-    enable_audit=True,
-    enable_cache=True,
-    soft_delete=True,
-)
-
-# 3. Set context (per-request)
-AuditContext.set(
-    actor_id="user_123",
-    roles=["admin"],
-    tenant_id="tenant_abc",
-)
-
-# 4. CRUD with auto-audit
-user = db.create(User, {"name": "John", "email": "john@example.com"})
-# Auto-injects: tenant_id, created_at, created_by, updated_at, updated_by
-
-# 5. LINQ queries
-query = (
-    QueryBuilder()
-    .where("role", Operator.EQ, "admin")
-    .where("age", Operator.GTE, 18)
-    .order_by("created_at", descending=True)
-    .skip(10)
-    .take(20)
-    .select("id", "name", "email")
-)
-
-admins = db.query_linq(User, query)
-```
-
-## LINQ Operations
-
-### Filters
-```python
-builder.where("field", Operator.EQ, value)      # ==
-builder.where("field", Operator.NE, value)      # !=
-builder.where("field", Operator.GT, value)      # >
-builder.where("field", Operator.GTE, value)     # >=
-builder.where("field", Operator.LT, value)      # <
-builder.where("field", Operator.LTE, value)     # <=
-builder.where("field", Operator.IN, [1,2,3])    # IN
-builder.where("field", Operator.CONTAINS, "text") # LIKE
-builder.where("field", Operator.STARTS_WITH, "prefix")
-builder.where("field", Operator.ENDS_WITH, "suffix")
-```
-
-### Ordering & Pagination
-```python
-builder.order_by("field", descending=True)
-builder.skip(10)
-builder.take(20)
-```
-
-### Projection
-```python
-builder.select("id", "name", "email")
-```
-
-### Aggregation
-```python
-builder.count()
-builder.distinct_on()
-builder.group_by("role", "department")
-```
-
-## NoSQL Overflow Storage
-
-Records >1MB automatically stored in object storage:
-
-```python
-@polydb_model
-class Product:
-    __polydb__ = {
-        "storage": "nosql",
-        "collection": "products",
-    }
-
-# Large data automatically overflows
-product = db.create(Product, {
-    "data": {"huge": "payload"} * 100000
-})
-
-# Transparent retrieval
-retrieved = db.read_one(Product, {"id": product["id"]})
-# User never knows it came from blob storage
-```
-
-## Enterprise Audit Trail
-
-### Automatic Tracking
-- **Who**: actor_id, roles
-- **What**: action, model, entity_id, changed_fields
-- **When**: timestamp (microsecond precision)
-- **Where**: tenant_id, ip_address, user_agent
-- **Context**: trace_id, request_id
-- **Integrity**: cryptographic hash chain
-
-### Field-Level Changes
-```python
-db.update(User, user_id, {"email": "new@example.com"})
-# Audit log shows: changed_fields = ["email", "updated_at", "updated_by"]
-```
-
-### Verify Chain
-```python
-from polydb.audit.storage import AuditStorage
-
-audit = AuditStorage()
-is_valid = audit.verify_chain(tenant_id="tenant_abc")
-```
-
-## Cache Engine
-
-```python
-# Auto-cache from model metadata
-@polydb_model
-class User:
-    __polydb__ = {
-        "storage": "sql",
-        "table": "users",
-        "cache": True,
-        "cache_ttl": 600,  # 10 minutes
-    }
-
-# Cached read
-users = db.read(User, {"role": "admin"})
-
-# Bypass cache
-users = db.read(User, {"role": "admin"}, no_cache=True)
-
-# Manual invalidation
-from polydb.cache import RedisCacheEngine
-cache = RedisCacheEngine()
-cache.invalidate("User")
-cache.clear()
-```
-
-## Soft Delete
-
-```python
-db = DatabaseFactory(soft_delete=True)
-
-# Soft delete (sets deleted_at, deleted_by)
-db.delete(User, user_id)
-
-# Hard delete
-db.delete(User, user_id, hard=True)
-
-# Include deleted in queries
-all_users = db.read(User, {}, include_deleted=True)
-```
-
-## Pagination
-
-```python
-page1, next_token = db.read_page(User, {"role": "admin"}, page_size=50)
-page2, token2 = db.read_page(User, {"role": "admin"}, page_size=50, continuation_token=next_token)
-```
-
-## Multi-Tenant
-
-```python
-# Auto-inject tenant_id from context
-AuditContext.set(tenant_id="tenant_123", actor_id="user_456", roles=["admin"])
-
-user = db.create(User, {"name": "John"})
-# Result: {"name": "John", "tenant_id": "tenant_123", "created_by": "user_456", ...}
-
-# Filter by tenant (automatic)
-users = db.read(User, {})  # Only returns tenant_123 records
-```
-
-## Environment Variables
-
-```bash
-# Provider selection (optional, auto-detected)
-CLOUD_PROVIDER=aws|azure|gcp|vercel|mongodb|postgresql
-
-# PostgreSQL
-POSTGRES_CONNECTION_STRING=postgresql://user:pass@host:5432/db
-POSTGRES_MIN_CONNECTIONS=2
-POSTGRES_MAX_CONNECTIONS=20
-
-# AWS
-AWS_ACCESS_KEY_ID=...
-AWS_SECRET_ACCESS_KEY=...
-DYNAMODB_TABLE_NAME=...
-S3_BUCKET_NAME=...
-
-# Azure
-AZURE_STORAGE_CONNECTION_STRING=...
-AZURE_TABLE_NAME=...
-AZURE_CONTAINER_NAME=...
-
-# GCP
-GOOGLE_CLOUD_PROJECT=...
-FIRESTORE_COLLECTION=...
-GCS_BUCKET_NAME=...
-
-# MongoDB
-MONGODB_URI=mongodb://...
-MONGODB_DATABASE=...
-MONGODB_COLLECTION=...
-
-# Vercel
-KV_URL=...
-KV_REST_API_TOKEN=...
-BLOB_READ_WRITE_TOKEN=...
-```
-
-## Model Metadata
-
-```python
-@polydb_model
-class Entity:
-    __polydb__ = {
-        # Required
-        "storage": "sql" | "nosql",
-        
-        # SQL
-        "table": "table_name",
-        
-        # NoSQL
-        "collection": "collection_name",
-        "pk_field": "partition_key_field",
-        "rk_field": "row_key_field",
-        
-        # Cache
-        "cache": True,
-        "cache_ttl": 300,  # seconds
-        
-        # Optional
-        "provider": "aws",  # Override auto-detection
-    }
-```
-
-## Thread Safety
-
-- Connection pooling with locks
-- Distributed-safe audit hash chaining
-- Cache with thread-safe operations
-- Retry logic with exponential backoff
-
-## Performance
-
-- **SQL**: Connection pooling (min=2, max=20)
-- **NoSQL**: Client reuse, overflow storage
-- **Cache**: In-memory with automatic invalidation
-- **Retry**: Configurable backoff (0.5s-6s)
-
-## Production Checklist
-
-✅ Set `CLOUD_PROVIDER` explicitly  
-✅ Configure connection pool sizes  
-✅ Enable audit (`enable_audit=True`)  
-✅ Set cache TTL per model  
-✅ Use soft delete for compliance  
-✅ Set audit context per request  
-✅ Monitor audit chain integrity  
-✅ Configure retry attempts  
-
-## License
-
-MIT

altcodepro_polydb_python-2.2.2.dist-info/RECORD

@@ -1,52 +0,0 @@
-altcodepro_polydb_python-2.2.2.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
-polydb/__init__.py,sha256=u-YwcKMl-NkVemvAKqLgIHE2eQND64toGXyJ64JeF8U,1441
-polydb/advanced_query.py,sha256=cxMB-EB-qT3bWXJlhmjnMCUtrzogORWyoEfS50Dy7go,4280
-polydb/batch.py,sha256=_DjWZa1ZXYSk6MLKqFe0eT7SYVRZtYNqZb9bI8Y2sao,4566
-polydb/cache.py,sha256=FGg5ln2GPhUpj3fljdJ4cygNYhdwJmfQhDhA_2MvOFY,6290
-polydb/databaseFactory.py,sha256=ZMPzGeg6RQ-Sh3lWyN9kIk3_FITH8JtNlCZr2J9-VCY,26340
-polydb/decorators.py,sha256=Rzk8Bj8wHi8YFtc06HEYT5r_Vqqn7TGaCtR5qvHdY-E,420
-polydb/errors.py,sha256=rcFeBH0cenjJ86v0cmDc2Yjj4R019pLCBcTeSC4qps4,1428
-polydb/factory.py,sha256=qCZIK9X6s69DCwWWQbCST5MO411sb6hRa4rQQ59WJ70,4556
-polydb/json_safe.py,sha256=R5PrqAGirqjYKPyy-8KH-lSXjLH0FPr2TSGozy4eheU,149
-polydb/models.py,sha256=HZYKB67ayoS1D4qxYfNLrUplbk7W-SIpexUnz4foyuQ,923
-polydb/monitoring.py,sha256=pwR2p-sSlt6nA29lCAJFmdT0ODIyVQ9gSxB51hgaAbQ,10137
-polydb/multitenancy.py,sha256=9kyY98RpKg8xDy9ejB_MyV_YzF7eZd4uxashw5S8vlg,6408
-polydb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polydb/query.py,sha256=qPisSV0i_GcgUz_DRKQPZy1TZ_6sEbbwQGhfh5BGWqQ,5097
-polydb/registry.py,sha256=g-jLKq5jzDvdZ24weAqZHSxUIUaBsu1TZghxRMqbUXQ,1926
-polydb/retry.py,sha256=etsj8MGo1WMvlcZMzWmFELAsWCRs-XPEuJe6K76QgbM,2548
-polydb/schema.py,sha256=VrOayX6V6AD2Qh3-lm4ZVPTpI24e4V52IYheZf2rNQ4,5812
-polydb/security.py,sha256=-bXdRjFmvq4X6ie6FrZMcO9ZbgjWFkNySSbRwFt1X1Q,16281
-polydb/types.py,sha256=XB_85Un8_aWt4dSfpjIGotHbK3KBY2WurQGXr9EOxWY,2992
-polydb/utils.py,sha256=G_ki5zKr5rGPgpFQM1CTq6twQd5OytaHKfet267MftM,1662
-polydb/validation.py,sha256=a1o1d02k3c6PWQwkBbw_0nEmIgrdB5RR8OcpNQMn4cA,4810
-polydb/adapters/AzureBlobStorageAdapter.py,sha256=knNpS-O-Kd7pDjMaP53sl7Tud_FUm5K7ZhdpVOm5Vmc,3124
-polydb/adapters/AzureFileStorageAdapter.py,sha256=EM6fzOLr7I8P4s0LgCcNrd3MuEkvOe2KeuwGHwrryW8,3168
-polydb/adapters/AzureQueueAdapter.py,sha256=Kut1p0KDMSTxVMmO9YJ1OoqVuuu9tYvtKzk84CWLryc,2487
-polydb/adapters/AzureTableStorageAdapter.py,sha256=qKvG6OujuvHYdv2U9BY7pqWRfsUfmE28USABeUpM5K4,7826
-polydb/adapters/DynamoDBAdapter.py,sha256=WvcnNdFpCkeIVeUgW60dfcvKjxEgvlrurflZzWxaX6U,8668
-polydb/adapters/EFSAdapter.py,sha256=GFHXn2fjohXxVJaM4ptbisEs5bwiwkHeQ1Av_5ILiCA,1688
-polydb/adapters/FirestoreAdapter.py,sha256=r0a1Act48CXGsVofZMCmelV-GE4fDnLgOHZ3jC7uEh0,7850
-polydb/adapters/GCPStorageAdapter.py,sha256=x_xcHE4w85hfJGfAqmc3Uu80KlXyCC0zssEfSOaMa6Y,2809
-polydb/adapters/MongoDBAdapter.py,sha256=aP_S3pLgoBthUNkOviAmxP-tlBsE5HXPBn33neEqthQ,4872
-polydb/adapters/PostgreSQLAdapter.py,sha256=aBPgh51513CcYmtRVZHj5fCmQPa1B-1zRUdmoYyx8N8,17053
-polydb/adapters/PubSubAdapter.py,sha256=1NFSj3-fZ84xAMhrbW1r6kMyTR8ntWcK4kiYpjPgMvA,3192
-polydb/adapters/S3Adapter.py,sha256=iw4bETrG5sPspQtYDadmTXbqydCXn-VEsGqHrvbYn9Y,3011
-polydb/adapters/S3CompatibleAdapter.py,sha256=3hiOVEqyGbRX1rnpeldea8aWljSlWgCN3iE-g_Bks0I,3513
-polydb/adapters/SQSAdapter.py,sha256=7DO0cPFW993oxKJ5gr6cmbG-4gDe4JaIj-RHvXiD-OU,2948
-polydb/adapters/VercelKVAdapter.py,sha256=jgD4rN6YYj_To1sN83MxkzEM8YRuYZ_Ulk7aRrIB7_I,12853
-polydb/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polydb/audit/AuditStorage.py,sha256=w22LXLR0nohn7A5orIHob_KNyUEir8UgpPVnnnVojLE,4936
-polydb/audit/__init__.py,sha256=m_GE7gjLw00zfHX-1SpkF7QZpRE72HO699ZzKzqD3kc,244
-polydb/audit/context.py,sha256=-A1FMtmr-2snVAHpTrVT80u-D_MCaqX6AoV4Ku2bz_o,1955
-polydb/audit/manager.py,sha256=KzaaOf5bDfr4M-CkCAZBG_U_4xIBCKDLRAf3hsm-DAk,1236
-polydb/audit/models.py,sha256=BgkSEQRbjbourxyGcEeJYIYzozwTM-pqTiSOM_BhWHs,2256
-polydb/base/NoSQLKVAdapter.py,sha256=9qyKJt6EGdWdzSfKM15brVHMMqy932uJxACq-9bibGo,11468
-polydb/base/ObjectStorageAdapter.py,sha256=97ZGsOFOG3epS2ecF5GRtfx_opxcizNtKOduEc0aNxU,1216
-polydb/base/QueueAdapter.py,sha256=dVBlleJK0gNc0YliTVvvc7KO2VReQ7Ct1_Prdd2XP0s,746
-polydb/base/SharedFilesAdapter.py,sha256=BaDPXDTePvsMYEnKoZMi01tlnI_Ww0tOoHVupqle7vM,700
-polydb/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-altcodepro_polydb_python-2.2.2.dist-info/METADATA,sha256=hCW3c_3-nZYXjRvWRWSPsZyekD0x0QfrIAv2gS_5-M8,10866
-altcodepro_polydb_python-2.2.2.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
-altcodepro_polydb_python-2.2.2.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
-altcodepro_polydb_python-2.2.2.dist-info/RECORD,,

polydb/adapters/PubSubAdapter.py

@@ -1,85 +0,0 @@
-# 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
-
-from ..json_safe import json_safe
-
-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,default=json_safe).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/factory.py

@@ -1,107 +0,0 @@
-# src/polydb/factory.py
-import os
-import threading
-from typing import Optional
-
-from .models import CloudProvider, PartitionConfig
-from .utils import setup_logger
-
-
-class CloudDatabaseFactory:
-    """Cloud-independent factory with auto-detection"""
-    
-    def __init__(self, provider: Optional[CloudProvider] = None):
-        self.logger = setup_logger(__name__)
-        self.provider = provider or self._detect_provider()
-        self.connections = {}
-        self._lock = threading.Lock()
-        
-        self.logger.info(f"CloudDatabaseFactory provider: {self.provider.value}")
-    
-    def _detect_provider(self) -> CloudProvider:
-        explicit = os.getenv('CLOUD_PROVIDER')
-        if explicit:
-            try:
-                return CloudProvider(explicit.lower())
-            except ValueError:
-                self.logger.warning(f"Invalid CLOUD_PROVIDER: {explicit}")
-        
-        rules = [
-            ('AZURE_STORAGE_CONNECTION_STRING', CloudProvider.AZURE),
-            ('AWS_ACCESS_KEY_ID', CloudProvider.AWS),
-            ('GOOGLE_CLOUD_PROJECT', CloudProvider.GCP),
-            ('VERCEL_ENV', CloudProvider.VERCEL),
-            ('MONGODB_URI', CloudProvider.MONGODB),
-            ('POSTGRES_URL', CloudProvider.POSTGRESQL),
-            ('POSTGRES_CONNECTION_STRING', CloudProvider.POSTGRESQL),
-        ]
-        
-        for env_var, provider in rules:
-            if os.getenv(env_var):
-                return provider
-        
-        self.logger.warning("No provider detected, defaulting to PostgreSQL")
-        return CloudProvider.POSTGRESQL
-    
-    def get_nosql_kv(self, partition_config: Optional[PartitionConfig] = None):
-        if self.provider == CloudProvider.AZURE:
-            from .adapters.AzureTableStorageAdapter import AzureTableStorageAdapter
-            return AzureTableStorageAdapter(partition_config)
-        elif self.provider == CloudProvider.AWS:
-            from .adapters.DynamoDBAdapter import DynamoDBAdapter
-            return DynamoDBAdapter(partition_config)
-        elif self.provider == CloudProvider.GCP:
-            from .adapters.FirestoreAdapter import FirestoreAdapter
-            return FirestoreAdapter(partition_config)
-        elif self.provider == CloudProvider.VERCEL:
-            from .adapters.VercelKVAdapter import VercelKVAdapter
-            return VercelKVAdapter(partition_config)
-        else:
-            from .adapters.MongoDBAdapter import MongoDBAdapter
-            return MongoDBAdapter(partition_config)
-    
-    def get_object_storage(self):
-        if self.provider == CloudProvider.AZURE:
-            from .adapters.AzureBlobStorageAdapter import AzureBlobStorageAdapter
-            return AzureBlobStorageAdapter()
-        elif self.provider == CloudProvider.AWS:
-            from .adapters.S3Adapter import S3Adapter
-            return S3Adapter()
-        elif self.provider == CloudProvider.GCP:
-            from .adapters.GCPStorageAdapter import GCPStorageAdapter
-            return GCPStorageAdapter()
-        elif self.provider == CloudProvider.VERCEL:
-            from .adapters.VercelKVAdapter import VercelBlobAdapter
-            return VercelBlobAdapter()
-        else:
-            from .adapters.S3CompatibleAdapter import S3CompatibleAdapter
-            return S3CompatibleAdapter()
-    
-    def get_queue(self):
-        if self.provider == CloudProvider.AZURE:
-            from .adapters.AzureQueueAdapter import AzureQueueAdapter
-            return AzureQueueAdapter()
-        elif self.provider == CloudProvider.AWS:
-            from .adapters.SQSAdapter import SQSAdapter
-            return SQSAdapter()
-        elif self.provider == CloudProvider.GCP:
-            from .adapters.PubSubAdapter import PubSubAdapter
-            return PubSubAdapter()
-        elif self.provider == CloudProvider.VERCEL:
-            from .adapters.VercelKVAdapter import VercelQueueAdapter
-            return VercelQueueAdapter()
-    
-    def get_shared_files(self):
-        if self.provider == CloudProvider.AZURE:
-            from .adapters.AzureFileStorageAdapter import AzureFileStorageAdapter
-            return AzureFileStorageAdapter()
-        elif self.provider == CloudProvider.AWS:
-            from .adapters.EFSAdapter import EFSAdapter
-            return EFSAdapter()
-        elif self.provider == CloudProvider.GCP:
-            from .adapters.GCPStorageAdapter import GCPStorageAdapter
-            return GCPStorageAdapter()
-    
-    def get_sql(self):
-        from .adapters.PostgreSQLAdapter import PostgreSQLAdapter
-        return PostgreSQLAdapter()