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

altcodepro_polydb_python-2.1.0.dist-info/METADATA

@@ -0,0 +1,378 @@
+Metadata-Version: 2.4
+Name: altcodepro-polydb-python
+Version: 2.1.0
+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
+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"
+Requires-Dist: redis>=6.4.0; 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 v3.0 - 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 CacheEngine
+cache = CacheEngine()
+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.1.0.dist-info/RECORD

@@ -0,0 +1,51 @@
+altcodepro_polydb_python-2.1.0.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
+polydb/__init__.py,sha256=V_xW5w910ofGc0jMFTbek-d8KcszZMtMYaX2p48f9Qc,1440
+polydb/advanced_query.py,sha256=cxMB-EB-qT3bWXJlhmjnMCUtrzogORWyoEfS50Dy7go,4280
+polydb/batch.py,sha256=_DjWZa1ZXYSk6MLKqFe0eT7SYVRZtYNqZb9bI8Y2sao,4566
+polydb/cache.py,sha256=hCv_oMJvymcMDIFxpwGhGR3e5V1eYNFdLHswMViOGzc,6221
+polydb/databaseFactory.py,sha256=4XI6VhXBBc6YgQlBr-OoBi5gSmuQ0iliYB64leUxT4U,25430
+polydb/decorators.py,sha256=Rzk8Bj8wHi8YFtc06HEYT5r_Vqqn7TGaCtR5qvHdY-E,420
+polydb/errors.py,sha256=rcFeBH0cenjJ86v0cmDc2Yjj4R019pLCBcTeSC4qps4,1428
+polydb/factory.py,sha256=qCZIK9X6s69DCwWWQbCST5MO411sb6hRa4rQQ59WJ70,4556
+polydb/models.py,sha256=HZYKB67ayoS1D4qxYfNLrUplbk7W-SIpexUnz4foyuQ,923
+polydb/monitoring.py,sha256=pwR2p-sSlt6nA29lCAJFmdT0ODIyVQ9gSxB51hgaAbQ,10137
+polydb/multitenancy.py,sha256=JTazyHLRq8ZcrnDGFy7VnIiDnTX3wrer1rZJsC949zE,6376
+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=7qCl-xAr3pSTFgLZSCUK0h0rWfjSQna2MXQ0wjqt3rk,16229
+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=qiT-qNVfsvc4badEoBu6qiIKb_ctKWooIyXs0HI_qjk,2434
+polydb/adapters/AzureTableStorageAdapter.py,sha256=EtfalUoM8nVGCWM1_-UMt0bOzNtkz32lL_BapJ6nM9U,7774
+polydb/adapters/DynamoDBAdapter.py,sha256=WbVlnb8D03AphzCwEqBUs9pknSHiDCf34BeXcqKxeak,8650
+polydb/adapters/EFSAdapter.py,sha256=GFHXn2fjohXxVJaM4ptbisEs5bwiwkHeQ1Av_5ILiCA,1688
+polydb/adapters/FirestoreAdapter.py,sha256=ITqE1rKGjYDOHeOUNICl7SLp7WFuUOxVFz1AlvcYWZY,7798
+polydb/adapters/GCPStorageAdapter.py,sha256=x_xcHE4w85hfJGfAqmc3Uu80KlXyCC0zssEfSOaMa6Y,2809
+polydb/adapters/MongoDBAdapter.py,sha256=aP_S3pLgoBthUNkOviAmxP-tlBsE5HXPBn33neEqthQ,4872
+polydb/adapters/PostgreSQLAdapter.py,sha256=olt_8_cVKZ-5nmpeUuP0569E-SSad6Us7SGKlQ96jUU,15016
+polydb/adapters/PubSubAdapter.py,sha256=7_g9TlGaKTAfVIQO-LOeesuTCrYswJ0TmF3GK9rDmSE,3139
+polydb/adapters/S3Adapter.py,sha256=iw4bETrG5sPspQtYDadmTXbqydCXn-VEsGqHrvbYn9Y,3011
+polydb/adapters/S3CompatibleAdapter.py,sha256=3hiOVEqyGbRX1rnpeldea8aWljSlWgCN3iE-g_Bks0I,3513
+polydb/adapters/SQSAdapter.py,sha256=rOoJ74j9cdxP4Ds30bxvKYNpXdgzfzT_8d6xFdohw-A,2895
+polydb/adapters/VercelKVAdapter.py,sha256=stJ32PrBYEb4YE_V_NVla80gn_oPwFQrbxncmmFnrIA,12765
+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=wm8XozEtEpXKrBjLc932QaLkqdn4hriUxrT6YBQ-5RU,2203
+polydb/base/NoSQLKVAdapter.py,sha256=yILpI0jsKWju1MqJX4mYfWbnlWe-Wz-GFl0ORDir-eg,11343
+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.1.0.dist-info/METADATA,sha256=pJqaLZvRkZRf6X9iqCZB4nBMPXyXJCb-aZxw5cmfe8w,10834
+altcodepro_polydb_python-2.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+altcodepro_polydb_python-2.1.0.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
+altcodepro_polydb_python-2.1.0.dist-info/RECORD,,

altcodepro_polydb_python-2.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

altcodepro_polydb_python-2.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AltCodePro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

altcodepro_polydb_python-2.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+polydb

polydb/__init__.py

@@ -0,0 +1,64 @@
+# src/polydb/__init__.py
+"""
+PolyDB - Enterprise Cloud-Independent Database Abstraction
+Full LINQ support, field-level audit, cache, soft delete, overflow storage
+"""
+
+__version__ = "3.0.0"
+
+from .factory import CloudDatabaseFactory
+from .databaseFactory import DatabaseFactory
+from .models import CloudProvider, PartitionConfig
+from .decorators import polydb_model
+from .query import QueryBuilder, Operator
+from .audit.context import AuditContext
+from .cache import CacheEngine
+from .errors import (
+    CloudDBError,
+    DatabaseError,
+    NoSQLError,
+    StorageError,
+    QueueError,
+    ConnectionError,
+    ValidationError,
+    PolyDBError,
+    ModelNotRegisteredError,
+    InvalidModelMetadataError,
+    UnsupportedStorageTypeError,
+    AdapterConfigurationError,
+    OperationNotSupportedError,
+)
+
+__all__ = [
+    # Factories
+    'CloudDatabaseFactory',
+    'DatabaseFactory',
+    
+    # Models & Config
+    'CloudProvider',
+    'PartitionConfig',
+    'polydb_model',
+    
+    # Query
+    'QueryBuilder',
+    'Operator',
+    
+    # Audit & Cache
+    'AuditContext',
+    'CacheEngine',
+    
+    # Errors
+    'CloudDBError',
+    'DatabaseError',
+    'NoSQLError',
+    'StorageError',
+    'QueueError',
+    'ConnectionError',
+    'ValidationError',
+    'PolyDBError',
+    'ModelNotRegisteredError',
+    'InvalidModelMetadataError',
+    'UnsupportedStorageTypeError',
+    'AdapterConfigurationError',
+    'OperationNotSupportedError',
+]

polydb/adapters/AzureBlobStorageAdapter.py

@@ -0,0 +1,77 @@
+# src/polydb/adapters/AzureBlobStorageAdapter.py
+
+from polydb.base.ObjectStorageAdapter import ObjectStorageAdapter
+from polydb.errors import ConnectionError, StorageError
+from polydb.retry import retry
+import os
+import threading
+from typing import List
+
+class AzureBlobStorageAdapter(ObjectStorageAdapter):
+    """Azure Blob Storage with client reuse"""
+
+    def __init__(self):
+        super().__init__()
+        self.connection_string = os.getenv("AZURE_STORAGE_CONNECTION_STRING") or ""
+        self.container_name = os.getenv("AZURE_CONTAINER_NAME", "default") or ""
+        self._client = None
+        self._lock = threading.Lock()
+        self._initialize_client()
+
+    def _initialize_client(self):
+        """Initialize Azure Blob Storage client once"""
+        try:
+            from azure.storage.blob import BlobServiceClient
+
+            with self._lock:
+                if not self._client:
+                    self._client = BlobServiceClient.from_connection_string(self.connection_string)
+                    self.logger.info("Initialized Azure Blob Storage client")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize Azure Blob Storage: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def _put_raw(self, key: str, data: bytes) -> str:
+        """Store blob"""
+        try:
+            if self._client:
+                blob_client = self._client.get_blob_client(self.container_name, key)
+                blob_client.upload_blob(data, overwrite=True)
+                self.logger.debug(f"Uploaded blob: {key}")
+            return key
+        except Exception as e:
+            raise StorageError(f"Azure Blob put failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def get(self, key: str) -> bytes | None:
+        """Get blob"""
+        try:
+            if self._client:
+                blob_client = self._client.get_blob_client(self.container_name, key)
+                return blob_client.download_blob().readall()
+            return None
+        except Exception as e:
+            raise StorageError(f"Azure Blob get failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def delete(self, key: str) -> bool:
+        """Delete blob"""
+        try:
+            if self._client:
+                blob_client = self._client.get_blob_client(self.container_name, key)
+                blob_client.delete_blob()
+                return True
+            return False
+        except Exception as e:
+            raise StorageError(f"Azure Blob delete failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def list(self, prefix: str = "") -> List[str]:
+        """List blobs with prefix"""
+        try:
+            if self._client:
+                container_client = self._client.get_container_client(self.container_name)
+                return [blob.name for blob in container_client.list_blobs(name_starts_with=prefix)]
+            return []
+        except Exception as e:
+            raise StorageError(f"Azure Blob list failed: {str(e)}")

polydb/adapters/AzureFileStorageAdapter.py

@@ -0,0 +1,79 @@
+# src/polydb/adapters/AzureFileStorageAdapter.py
+
+from polydb.base.SharedFilesAdapter import SharedFilesAdapter
+from polydb.errors import ConnectionError, StorageError
+from polydb.retry import retry
+import os
+import threading
+from typing import List
+
+class AzureFileStorageAdapter(SharedFilesAdapter):
+    """Azure File Storage with client reuse"""
+
+    def __init__(self):
+        super().__init__()
+        self.connection_string = os.getenv("AZURE_STORAGE_CONNECTION_STRING") or ""
+        self.share_name = os.getenv("AZURE_SHARE_NAME", "default") or ""
+        self._client = None
+        self._lock = threading.Lock()
+        self._initialize_client()
+
+    def _initialize_client(self):
+        """Initialize Azure File Storage client once"""
+        try:
+            from azure.storage.fileshare import ShareServiceClient
+
+            with self._lock:
+                if not self._client:
+                    self._client = ShareServiceClient.from_connection_string(self.connection_string)
+                    self.logger.info("Initialized Azure File Storage client")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize Azure File Storage: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def write(self, path: str, data: bytes) -> bool:
+        """Write file"""
+        try:
+            if self._client:
+                file_client = self._client.get_share_client(self.share_name).get_file_client(path)
+                file_client.upload_file(data)
+                return True
+            return False
+        except Exception as e:
+            raise StorageError(f"Azure File write failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def read(self, path: str) -> bytes | None:
+        """Read file"""
+        try:
+            if self._client:
+                file_client = self._client.get_share_client(self.share_name).get_file_client(path)
+                return file_client.download_file().readall()
+            return None
+        except Exception as e:
+            raise StorageError(f"Azure File read failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def delete(self, path: str) -> bool:
+        """Delete file"""
+        try:
+            if self._client:
+                file_client = self._client.get_share_client(self.share_name).get_file_client(path)
+                file_client.delete_file()
+                return True
+            return False
+        except Exception as e:
+            raise StorageError(f"Azure File delete failed: {str(e)}")
+
+    @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
+    def list(self, directory: str = "/") -> List[str]:
+        """List files in directory"""
+        try:
+            if self._client:
+                dir_client = self._client.get_share_client(self.share_name).get_directory_client(
+                    directory
+                )
+                return [item.name for item in dir_client.list_directories_and_files()]
+            return []
+        except Exception as e:
+            raise StorageError(f"Azure File list failed: {str(e)}")