altcodepro-polydb-python 2.3.9__py3-none-any.whl → 2.3.11__py3-none-any.whl

polydb/adapters/GCPPubSubAdapter.py

@@ -3,7 +3,6 @@ import json
 import threading
 from typing import Any, Dict, List, Optional, Tuple, Union
 
-from google.cloud import pubsub_v1
 from google.api_core.exceptions import AlreadyExists, NotFound
 
 from ..base.QueueAdapter import QueueAdapter
@@ -11,7 +10,6 @@ from ..errors import ConnectionError, QueueError
 from ..retry import retry
 from ..json_safe import json_safe
 
-
 JsonLike = Union[Dict[str, Any], List[Any], str, int, float, bool, None]
 
 
@@ -40,13 +38,15 @@ class GCPPubSubAdapter(QueueAdapter):
             "PUBSUB_SUBSCRIPTION", "polydb-sub"
         )
 
-        self._publisher: Optional[pubsub_v1.PublisherClient] = None
-        self._subscriber: Optional[pubsub_v1.SubscriberClient] = None
+        self._publisher = None
+        self._subscriber = None
         self._lock = threading.Lock()
 
         self._initialize_clients()
 
     def _initialize_clients(self) -> None:
+        from google.cloud import pubsub_v1
+
         try:
             with self._lock:
                 if self._publisher and self._subscriber:

polydb/adapters/GCPStorageAdapter.py

@@ -5,9 +5,6 @@ import os
 import threading
 from typing import Any, Dict, List, Optional
 
-from google.cloud import storage
-from google.api_core.exceptions import NotFound
-
 from ..base.ObjectStorageAdapter import ObjectStorageAdapter
 from ..errors import StorageError, ConnectionError
 from ..retry import retry
@@ -17,13 +14,11 @@ class GCPStorageAdapter(ObjectStorageAdapter):
     """
     Production-grade Google Cloud Storage adapter.
 
-    Features
-    --------
-    - Thread-safe client initialization
-    - Automatic bucket creation
-    - Emulator support (fake-gcs-server)
-    - Retry support
-    - Structured logging
+    - One client, many buckets (resolved + cached per call)
+    - Automatic bucket creation, emulator support (fake-gcs-server)
+    - put/get/delete are symmetric: a blob is stored at `key` and fetched at `key`
+    - per-call `container_name` overrides the bucket (generic name kept for
+      cross-provider parity)
     """
 
     def __init__(self, project_id: str, endpoint: Optional[str], bucket_name: Optional[str] = None):
@@ -31,22 +26,21 @@ class GCPStorageAdapter(ObjectStorageAdapter):
 
         self.bucket_name: str = bucket_name or os.getenv("GCS_BUCKET_NAME", "default")
         self.project_id: str = project_id or os.getenv("GOOGLE_CLOUD_PROJECT", "polydb-test")
-
         self._endpoint: Optional[str] = endpoint or os.getenv("GCS_ENDPOINT")
 
-        self._client: Optional[storage.Client] = None
-        self._bucket: Optional[storage.Bucket] = None
-
+        self._client = None
+        self._buckets: Dict[str, Any] = {}
         self._lock = threading.Lock()
 
         self._initialize_client()
 
     # ------------------------------------------------------------------
-    # Client initialization
+    # Client / bucket resolution
     # ------------------------------------------------------------------
-
     def _initialize_client(self) -> None:
-        """Initialize GCS client once (thread-safe)"""
+        """Initialize the shared GCS client once (thread-safe)."""
+        from google.cloud import storage  # lazy: only required for this provider
+
         try:
             with self._lock:
                 if self._client:
@@ -61,27 +55,61 @@ class GCPStorageAdapter(ObjectStorageAdapter):
                 else:
                     self._client = storage.Client(project=self.project_id)
 
-                self._bucket = self._client.bucket(self.bucket_name)
+                self.logger.info(f"GCS client initialized (project={self.project_id})")
+        except Exception as e:
+            raise ConnectionError(f"Failed to initialize GCS: {str(e)}")
 
-                # Ensure bucket exists
-                try:
-                    if not self._bucket.exists():
-                        self._bucket = self._client.create_bucket(self.bucket_name)
-                        self.logger.info(f"Created GCS bucket: {self.bucket_name}")
-                except Exception:
-                    # fake-gcs-server does not support bucket.exists()
-                    pass
+    def _get_bucket(self, container_name: Optional[str] = None):
+        """Resolve (and cache) a bucket, auto-creating it."""
+        if self._client is None:
+            raise ConnectionError("GCS client not initialized")
 
-                self.logger.info(
-                    f"GCS initialized (bucket={self.bucket_name}, project={self.project_id})"
-                )
+        name = container_name or self.bucket_name
 
-        except Exception as e:
-            raise ConnectionError(f"Failed to initialize GCS: {str(e)}")
+        cached = self._buckets.get(name)
+        if cached is not None:
+            return cached
+
+        with self._lock:
+            cached = self._buckets.get(name)  # re-check under lock
+            if cached is not None:
+                return cached
+
+            bucket = self._client.bucket(name)
+            try:
+                if not bucket.exists():
+                    bucket = self._client.create_bucket(name)
+                    self.logger.info(f"Created GCS bucket: {name}")
+            except Exception:
+                # fake-gcs-server does not support bucket.exists()
+                pass
+
+            self._buckets[name] = bucket
+            return bucket
 
     # ------------------------------------------------------------------
-    # Put object
+    # Put
     # ------------------------------------------------------------------
+    def put(
+        self,
+        key: str,
+        data: bytes,
+        fileName: str = "",
+        optimize: bool = True,
+        media_type: Optional[str] = None,
+        metadata: Dict[str, Any] | None = None,
+        container_name: Optional[str] = None,
+    ) -> str:
+        if optimize and media_type:
+            data = self._optimize_media(data, media_type)
+        return self._put_raw(
+            key=key,
+            data=data,
+            fileName=fileName,
+            media_type=media_type,
+            metadata=metadata,
+            container_name=container_name,
+        )
 
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
     def _put_raw(
@@ -91,135 +119,68 @@ class GCPStorageAdapter(ObjectStorageAdapter):
         fileName: str = "",
         media_type: Optional[str] = None,
         metadata: Dict[str, Any] | None = None,
+        container_name: Optional[str] = None,
     ) -> str:
-        """Upload object to GCS with media type, metadata, filename handling"""
+        """Upload object. Stored at `key` so get/delete find it by the same key."""
         try:
-            if not self._bucket:
-                raise ConnectionError("GCS bucket not initialized")
+            bucket = self._get_bucket(container_name)
+            name = container_name or self.bucket_name
 
-            # --------------------------------------------------
-            # Resolve filename
-            # --------------------------------------------------
-            filename = fileName or os.path.basename(key)
-
-            # --------------------------------------------------
-            # Ensure extension from media_type
-            # --------------------------------------------------
+            # filename is metadata only — it must NOT alter the blob key
+            filename = fileName or os.path.basename(key) or key
             if media_type:
                 ext = mimetypes.guess_extension(media_type) or ""
                 if ext and not filename.lower().endswith(ext):
                     filename += ext
 
-            # --------------------------------------------------
-            # Final blob key
-            # --------------------------------------------------
-            blob_key = f"{key.rstrip('/')}/{filename}" if fileName else key
-
-            blob = self._bucket.blob(blob_key)
+            blob = bucket.blob(key)
 
-            # --------------------------------------------------
-            # Metadata (must be string)
-            # --------------------------------------------------
             safe_metadata = {k: str(v) for k, v in (metadata or {}).items()}
             safe_metadata["filename"] = filename
-
             blob.metadata = safe_metadata
 
-            # --------------------------------------------------
-            # Upload with content type
-            # --------------------------------------------------
-            blob.upload_from_string(
-                data,
-                content_type=media_type or "application/octet-stream",
-            )
+            blob.upload_from_string(data, content_type=media_type or "application/octet-stream")
+            blob.patch()  # persist metadata
 
-            # Persist metadata (required in GCS)
-            blob.patch()
-
-            self.logger.debug(f"GCS uploaded blob: {blob_key}, type={media_type}")
-
-            # --------------------------------------------------
-            # Return public URL
-            # --------------------------------------------------
-            return f"https://storage.googleapis.com/{self.bucket_name}/{blob_key}"
+            self.logger.debug(f"GCS uploaded blob: {name}/{key}, type={media_type}")
+            return f"https://storage.googleapis.com/{name}/{key}"
 
         except Exception as e:
             raise StorageError(f"GCS put failed: {str(e)}")
 
     # ------------------------------------------------------------------
-    # Get object
+    # Get / Delete / List
     # ------------------------------------------------------------------
-
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def get(self, key: str) -> Optional[bytes]:
-        """Download object from GCS"""
+    def get(self, key: str, container_name: Optional[str] = None) -> Optional[bytes]:
         try:
-            if not self._bucket:
-                raise ConnectionError("GCS bucket not initialized")
-
-            blob = self._bucket.blob(key)
-
+            blob = self._get_bucket(container_name).blob(key)
             if not blob.exists():
                 return None
-
             data = blob.download_as_bytes()
-
             self.logger.debug(f"GCS downloaded blob: {key}")
-
             return data
-
-        except NotFound:
-            return None
-
         except Exception as e:
             raise StorageError(f"GCS get failed: {str(e)}")
 
-    # ------------------------------------------------------------------
-    # Delete object
-    # ------------------------------------------------------------------
-
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def delete(self, key: str) -> bool:
-        """Delete object from GCS"""
+    def delete(self, key: str, container_name: Optional[str] = None) -> bool:
         try:
-            if not self._bucket:
-                raise ConnectionError("GCS bucket not initialized")
-
-            blob = self._bucket.blob(key)
-
+            blob = self._get_bucket(container_name).blob(key)
             if not blob.exists():
                 return False
-
             blob.delete()
-
             self.logger.debug(f"GCS deleted blob: {key}")
-
             return True
-
-        except NotFound:
-            return False
-
         except Exception as e:
             raise StorageError(f"GCS delete failed: {str(e)}")
 
-    # ------------------------------------------------------------------
-    # List objects
-    # ------------------------------------------------------------------
-
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def list(self, prefix: str = "") -> List[str]:
-        """List objects with optional prefix"""
+    def list(self, prefix: str = "", container_name: Optional[str] = None) -> List[str]:
         try:
-            if not self._bucket:
-                raise ConnectionError("GCS bucket not initialized")
-
-            blobs = self._bucket.list_blobs(prefix=prefix)
-
+            blobs = self._get_bucket(container_name).list_blobs(prefix=prefix)
             results = [blob.name for blob in blobs]
-
             self.logger.debug(f"GCS listed {len(results)} blobs (prefix={prefix})")
-
             return results
-
         except Exception as e:
             raise StorageError(f"GCS list failed: {str(e)}")

polydb/adapters/PostgreSQLAdapter.py

@@ -8,7 +8,7 @@ import hashlib
 from contextlib import contextmanager
 import json
 from datetime import datetime, date
-from psycopg2.extras import Json
+
 
 from ..errors import DatabaseError, ConnectionError
 from ..retry import retry
@@ -111,6 +111,7 @@ class PostgreSQLAdapter:
         - Decimal -> convert to float
         - everything else -> pass as-is
         """
+        from psycopg2.extras import Json
 
         if v is None:
             return None

polydb/adapters/S3Adapter.py

@@ -11,8 +11,6 @@ import os
 import threading
 from typing import Any, Dict, List, Optional
 
-import boto3
-from botocore.exceptions import ClientError
 
 from ..base.ObjectStorageAdapter import ObjectStorageAdapter
 from ..errors import StorageError, ConnectionError
@@ -44,6 +42,8 @@ class S3Adapter(ObjectStorageAdapter):
 
     def _initialize_client(self):
         """Initialize S3 client once"""
+        import boto3
+
         try:
             with self._lock:
                 if self._client:
@@ -72,6 +72,9 @@ class S3Adapter(ObjectStorageAdapter):
 
     def _ensure_bucket_exists(self):
         """Create bucket if it doesn't exist (safe for AWS + LocalStack)"""
+        import boto3
+        from botocore.exceptions import ClientError
+
         if not self._client:
             return
 

polydb/adapters/S3CompatibleAdapter.py

@@ -3,28 +3,35 @@ import mimetypes
 import os
 import threading
 from typing import Any, Dict, List, Optional
+
 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"""
+    """S3-compatible storage (AWS S3, MinIO, DigitalOcean Spaces) with client reuse.
+
+    - put/get/delete are symmetric: a blob is stored at `key` and fetched at `key`
+    - per-call `container_name` overrides the bucket (generic name kept for
+      cross-provider parity with the Azure adapter)
+    - get() returns None when the object does not exist
+    """
 
-    def __init__(self):
+    def __init__(self, bucket_name: str = ""):
         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.bucket_name = bucket_name or 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"""
+        """Initialize S3-compatible client once."""
         try:
-            import boto3
+            import boto3  # lazy: boto3 is only required for this provider
 
             with self._lock:
                 if not self._client:
@@ -38,6 +45,50 @@ class S3CompatibleAdapter(ObjectStorageAdapter):
         except Exception as e:
             raise ConnectionError(f"Failed to initialize S3-compatible client: {str(e)}")
 
+    # ------------------------------------------------------------------
+    # helpers
+    # ------------------------------------------------------------------
+    def _bucket(self, container_name: Optional[str] = None) -> str:
+        return container_name or self.bucket_name
+
+    @staticmethod
+    def _is_not_found(exc: Exception) -> bool:
+        # inspect botocore ClientError without importing botocore at module load
+        resp = getattr(exc, "response", None)
+        if isinstance(resp, dict):
+            code = str(resp.get("Error", {}).get("Code", ""))
+            return code in {"NoSuchKey", "404"}
+        return False
+
+    def _url(self, bucket: str, key: str) -> str:
+        if self.endpoint:  # MinIO / Spaces / custom endpoint (path-style)
+            return f"{self.endpoint.rstrip('/')}/{bucket}/{key}"
+        return f"https://{bucket}.s3.amazonaws.com/{key}"  # AWS default (virtual-host)
+
+    # ------------------------------------------------------------------
+    # put
+    # ------------------------------------------------------------------
+    def put(
+        self,
+        key: str,
+        data: bytes,
+        fileName: str = "",
+        optimize: bool = True,
+        media_type: Optional[str] = None,
+        metadata: Dict[str, Any] | None = None,
+        container_name: Optional[str] = None,
+    ) -> str:
+        if optimize and media_type:
+            data = self._optimize_media(data, media_type)
+        return self._put_raw(
+            key=key,
+            data=data,
+            fileName=fileName,
+            media_type=media_type,
+            metadata=metadata,
+            container_name=container_name,
+        )
+
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
     def _put_raw(
         self,
@@ -46,99 +97,78 @@ class S3CompatibleAdapter(ObjectStorageAdapter):
         fileName: str = "",
         media_type: Optional[str] = None,
         metadata: Dict[str, Any] | None = None,
+        container_name: Optional[str] = None,
     ) -> str:
-        """Upload object to S3-compatible storage with metadata and media type"""
+        """Upload object. Stored at `key` so get/delete find it by the same key."""
         try:
             if not self._client:
                 self._initialize_client()
 
-            # --------------------------------------------------
-            # Resolve filename
-            # --------------------------------------------------
-            filename = fileName or os.path.basename(key)
+            bucket = self._bucket(container_name)
 
-            # --------------------------------------------------
-            # Ensure extension from media_type
-            # --------------------------------------------------
+            # filename is metadata only — it must NOT alter the object key
+            filename = fileName or os.path.basename(key) or key
             if media_type:
                 ext = mimetypes.guess_extension(media_type) or ""
                 if ext and not filename.lower().endswith(ext):
                     filename += ext
 
-            # --------------------------------------------------
-            # Final key
-            # --------------------------------------------------
-            blob_key = f"{key.rstrip('/')}/{filename}" if fileName else key
-
-            # --------------------------------------------------
-            # Metadata (string only)
-            # --------------------------------------------------
             safe_metadata = {k: str(v) for k, v in (metadata or {}).items()}
             safe_metadata["filename"] = filename
 
-            # --------------------------------------------------
-            # Upload
-            # --------------------------------------------------
             self._client.put_object(  # type: ignore
-                Bucket=self.bucket_name,
-                Key=blob_key,
+                Bucket=bucket,
+                Key=key,
                 Body=data,
                 ContentType=media_type or "application/octet-stream",
                 Metadata=safe_metadata,
             )
 
-            self.logger.debug(f"S3 uploaded: {blob_key}, type={media_type}")
-
-            # --------------------------------------------------
-            # Return URL
-            # --------------------------------------------------
-            if self.endpoint:
-                # MinIO / Spaces / custom endpoint
-                url = f"{self.endpoint.rstrip('/')}/{self.bucket_name}/{blob_key}"
-            else:
-                # AWS S3 default
-                url = f"https://{self.bucket_name}.s3.amazonaws.com/{blob_key}"
-
-            return url
+            self.logger.debug(f"S3 uploaded: {bucket}/{key}, type={media_type}")
+            return self._url(bucket, key)
 
         except Exception as e:
             raise StorageError(f"S3-compatible put failed: {str(e)}")
 
+    # ------------------------------------------------------------------
+    # get / delete / list
+    # ------------------------------------------------------------------
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
-    def get(self, key: str) -> bytes | None:
-        """Get object"""
+    def get(self, key: str, container_name: Optional[str] = None) -> bytes | None:
         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
+            response = self._client.get_object(  # type: ignore
+                Bucket=self._bucket(container_name), Key=key
+            )
+            return response["Body"].read()
         except Exception as e:
+            if self._is_not_found(e):
+                return None
             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"""
+    def delete(self, key: str, container_name: Optional[str] = None) -> bool:
         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
+            self._client.delete_object(Bucket=self._bucket(container_name), Key=key)  # type: ignore
+            return True
         except Exception as e:
+            if self._is_not_found(e):
+                return False
             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"""
+    def list(self, prefix: str = "", container_name: Optional[str] = None) -> List[str]:
         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 []
+            paginator = self._client.get_paginator("list_objects_v2")  # type: ignore
+            results: List[str] = []
+            for page in paginator.paginate(Bucket=self._bucket(container_name), Prefix=prefix):
+                results.extend(obj["Key"] for obj in page.get("Contents", []))
+            self.logger.debug(f"S3 listed {len(results)} objects prefix={prefix}")
+            return results
         except Exception as e:
             raise StorageError(f"S3-compatible list failed: {str(e)}")

polydb/adapters/SQSAdapter.py

@@ -5,8 +5,6 @@ import os
 import threading
 from typing import Any, Dict, List
 
-import boto3
-from botocore.exceptions import ClientError
 
 from ..base.QueueAdapter import QueueAdapter
 from ..errors import ConnectionError, QueueError
@@ -39,6 +37,8 @@ class SQSAdapter(QueueAdapter):
     # ---------------------------------------------------------
 
     def _initialize_client(self):
+        import boto3
+
         try:
             with self._lock:
                 if self._client:
@@ -67,6 +67,9 @@ class SQSAdapter(QueueAdapter):
 
     def _ensure_queue_exists(self, queue_name: str) -> str:
         """Create queue if it does not exist"""
+
+        from botocore.exceptions import ClientError
+
         if not self._client:
             raise ConnectionError("SQS client not initialized")
 

polydb/adapters/VercelFileAdapter.py

@@ -0,0 +1,29 @@
+# src/polydb/adapters/VercelFileAdapter.py
+
+from typing import List, Optional
+
+from ..base.SharedFilesAdapter import SharedFilesAdapter
+
+
+class VercelFileAdapter(SharedFilesAdapter):
+    """
+    Vercel has no shared/persistent filesystem (only ephemeral per-invocation /tmp).
+    Shared file storage is not supported — use object storage (Vercel Blob) instead.
+    """
+
+    _MSG = (
+        "Vercel has no shared file storage (only ephemeral /tmp). "
+        "Use object storage (get_object_storage) instead."
+    )
+
+    def write(self, path: str, data: bytes, share_name: Optional[str] = None) -> bool:
+        raise NotImplementedError(self._MSG)
+
+    def read(self, path: str, share_name: Optional[str] = None) -> bytes | None:
+        raise NotImplementedError(self._MSG)
+
+    def delete(self, path: str, share_name: Optional[str] = None) -> bool:
+        raise NotImplementedError(self._MSG)
+
+    def list(self, directory: str = "", share_name: Optional[str] = None) -> List[str]:
+        raise NotImplementedError(self._MSG)

polydb/audit/__init__.py

@@ -4,4 +4,4 @@ from .context import AuditContext
 from .manager import AuditManager
 from .AuditStorage import AuditStorage
 
-__all__ = ['AuditRecord', 'AuditContext', 'AuditManager', 'AuditStorage']
+__all__ = ["AuditRecord", "AuditContext", "AuditManager", "AuditStorage"]