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

polydb/base/NoSQLKVAdapter.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import hashlib
 import json
 import threading
-from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
+from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING, cast
 
 from ..json_safe import json_safe
 
@@ -19,107 +19,117 @@ if TYPE_CHECKING:
 
 class NoSQLKVAdapter:
     """Base with auto-overflow and LINQ support"""
-    
+
     def __init__(self, partition_config: Optional[PartitionConfig] = None):
         from ..utils import setup_logger
+
         self.logger = setup_logger(self.__class__.__name__)
         self.partition_config = partition_config
         self.object_storage = None
         self._lock = threading.Lock()
         self.max_size = 1024 * 1024  # 1MB
-    
+
     def _get_pk_rk(self, model: type, data: JsonDict) -> Tuple[str, str]:
         """Extract PK/RK from model metadata"""
-        meta = getattr(model, '__polydb__', {})
-        pk_field = meta.get('pk_field', 'id')
-        rk_field = meta.get('rk_field')
-        
+        meta = getattr(model, "__polydb__", {})
+        pk_field = meta.get("pk_field", "id")
+        rk_field = meta.get("rk_field")
+
         if self.partition_config:
             try:
                 pk = self.partition_config.partition_key_template.format(**data)
             except KeyError:
                 pk = f"default_{data.get(pk_field, hashlib.md5(json.dumps(data, sort_keys=True,default=json_safe).encode()).hexdigest()[:8])}"
         else:
-            pk = str(data.get(pk_field, 'default'))
-        
+            pk = str(data.get(pk_field, "default"))
+
         if rk_field and rk_field in data:
             rk = str(data[rk_field])
         elif self.partition_config and self.partition_config.row_key_template:
             try:
                 rk = self.partition_config.row_key_template.format(**data)
             except KeyError:
-                rk = hashlib.md5(json.dumps(data, sort_keys=True,default=json_safe).encode()).hexdigest()
+                rk = hashlib.md5(
+                    json.dumps(data, sort_keys=True, default=json_safe).encode()
+                ).hexdigest()
         else:
-            rk = data.get('id', hashlib.md5(json.dumps(data, sort_keys=True,default=json_safe).encode()).hexdigest())
-        
+            rk = data.get(
+                "id",
+                hashlib.md5(
+                    json.dumps(data, sort_keys=True, default=json_safe).encode()
+                ).hexdigest(),
+            )
+
         return str(pk), str(rk)
-    
+
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
     def _check_overflow(self, data: JsonDict) -> Tuple[JsonDict, Optional[str]]:
         """Check size and store in blob if needed"""
-        data_bytes = json.dumps(data,default=json_safe).encode()
+        data_bytes = json.dumps(data, default=json_safe).encode()
         data_size = len(data_bytes)
-        
+
         if data_size > self.max_size:
             with self._lock:
                 if not self.object_storage:
-                    from ..factory import CloudDatabaseFactory
+                    from ..cloudDatabaseFactory import CloudDatabaseFactory
+
                     factory = CloudDatabaseFactory()
                     self.object_storage = factory.get_object_storage()
-            
+
             blob_id = hashlib.md5(data_bytes).hexdigest()
             blob_key = f"overflow/{blob_id}.json"
-            
+
             try:
                 self.object_storage.put(blob_key, data_bytes)
             except Exception as e:
                 raise StorageError(f"Overflow storage failed: {str(e)}")
-            
+
             return {
                 "_overflow": True,
                 "_blob_key": blob_key,
                 "_size": data_size,
-                "_checksum": blob_id
+                "_checksum": blob_id,
             }, blob_key
-        
+
         return data, None
-    
+
     @retry(max_attempts=3, delay=1.0, exceptions=(StorageError,))
     def _retrieve_overflow(self, data: JsonDict) -> JsonDict:
         """Retrieve from blob if overflow"""
         if not data.get("_overflow"):
             return data
-        
+
         with self._lock:
             if not self.object_storage:
-                from ..factory import CloudDatabaseFactory
+                from ..cloudDatabaseFactory import CloudDatabaseFactory
+
                 factory = CloudDatabaseFactory()
                 self.object_storage = factory.get_object_storage()
-        
+
         try:
             blob_data = self.object_storage.get(data["_blob_key"])
             retrieved = json.loads(blob_data.decode())
-            
+
             # Verify checksum
             checksum = hashlib.md5(blob_data).hexdigest()
             if checksum != data.get("_checksum"):
                 raise StorageError("Checksum mismatch on overflow retrieval")
-            
+
             return retrieved
         except Exception as e:
             raise StorageError(f"Overflow retrieval failed: {str(e)}")
-    
+
     def _apply_filters(self, results: List[JsonDict], builder: QueryBuilder) -> List[JsonDict]:
         """Apply filters in-memory for NoSQL"""
         if not builder.filters:
             return results
-        
+
         filtered = []
         for item in results:
             match = True
             for f in builder.filters:
                 value = item.get(f.field)
-                
+
                 if f.operator == Operator.EQ and value != f.value:
                     match = False
                 elif f.operator == Operator.NE and value == f.value:
@@ -138,101 +148,99 @@ class NoSQLKVAdapter:
                     match = False
                 elif f.operator == Operator.CONTAINS and (not value or f.value not in str(value)):
                     match = False
-                elif f.operator == Operator.STARTS_WITH and (not value or not str(value).startswith(f.value)):
+                elif f.operator == Operator.STARTS_WITH and (
+                    not value or not str(value).startswith(f.value)
+                ):
                     match = False
-                elif f.operator == Operator.ENDS_WITH and (not value or not str(value).endswith(f.value)):
+                elif f.operator == Operator.ENDS_WITH and (
+                    not value or not str(value).endswith(f.value)
+                ):
                     match = False
-                
+
                 if not match:
                     break
-            
+
             if match:
                 filtered.append(item)
-        
+
         return filtered
-    
+
     def _apply_ordering(self, results: List[JsonDict], builder: QueryBuilder) -> List[JsonDict]:
         """Apply ordering"""
         if not builder.order_by_fields:
             return results
-        
+
         for field, desc in reversed(builder.order_by_fields):
-            results = sorted(
-                results,
-                key=lambda x: x.get(field, ''),
-                reverse=desc
-            )
-        
+            results = sorted(results, key=lambda x: x.get(field, ""), reverse=desc)
+
         return results
-    
+
     def _apply_pagination(self, results: List[JsonDict], builder: QueryBuilder) -> List[JsonDict]:
         """Apply skip/take"""
         if builder.skip_count:
-            results = results[builder.skip_count:]
-        
+            results = results[builder.skip_count :]
+
         if builder.take_count:
-            results = results[:builder.take_count]
-        
+            results = results[: builder.take_count]
+
         return results
-    
+
     def _apply_projection(self, results: List[JsonDict], builder: QueryBuilder) -> List[JsonDict]:
-        """Apply field selection"""
-        if not builder.select_fields:
+
+        fields = builder.selected_fields
+        if not fields:
             return results
-        
-        return [
-            {k: v for k, v in item.items() if k in builder.select_fields}
-            for item in results
-        ]
-    
+
+        field_set = set(fields)
+
+        return [{k: v for k, v in item.items() if k in field_set} for item in results]
+
     # Abstract methods to implement
     def _put_raw(self, model: type, pk: str, rk: str, data: JsonDict) -> JsonDict:
         raise NotImplementedError
-    
+
     def _get_raw(self, model: type, pk: str, rk: str) -> Optional[JsonDict]:
         raise NotImplementedError
-    
-    def _query_raw(self, model: type, filters: Dict[str, Any], limit: Optional[int]) -> List[JsonDict]:
+
+    def _query_raw(
+        self, model: type, filters: Dict[str, Any], limit: Optional[int]
+    ) -> List[JsonDict]:
         raise NotImplementedError
-    
+
     def _delete_raw(self, model: type, pk: str, rk: str, etag: Optional[str]) -> JsonDict:
         raise NotImplementedError
-    
+
     # Protocol implementation
     def put(self, model: type, data: JsonDict) -> JsonDict:
         pk, rk = self._get_pk_rk(model, data)
         store_data, _ = self._check_overflow(data)
         return self._put_raw(model, pk, rk, store_data)
-    
+
     def query(
         self,
         model: type,
         query: Optional[Lookup] = None,
         limit: Optional[int] = None,
         no_cache: bool = False,
-        cache_ttl: Optional[int] = None
+        cache_ttl: Optional[int] = None,
     ) -> List[JsonDict]:
         results = self._query_raw(model, query or {}, limit)
         return [self._retrieve_overflow(r) for r in results]
-    
+
     def query_page(
-        self,
-        model: type,
-        query: Lookup,
-        page_size: int,
-        continuation_token: Optional[str] = None
+        self, model: type, query: Lookup, page_size: int, continuation_token: Optional[str] = None
     ) -> Tuple[List[JsonDict], Optional[str]]:
         # Basic implementation - override per provider
         offset = int(continuation_token) if continuation_token else 0
         results = self.query(model, query, limit=page_size + 1)
-        
+
         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
-    
+
     def patch(
         self,
         model: type,
@@ -240,64 +248,68 @@ class NoSQLKVAdapter:
         data: JsonDict,
         *,
         etag: Optional[str] = None,
-        replace: bool = False
+        replace: bool = False,
     ) -> JsonDict:
         if isinstance(entity_id, dict):
-            pk = entity_id.get('partition_key') or entity_id.get('pk')
-            rk = entity_id.get('row_key') or entity_id.get('rk') or entity_id.get('id')
+            pk = entity_id.get("partition_key") or entity_id.get("pk")
+            rk = entity_id.get("row_key") or entity_id.get("rk") or entity_id.get("id")
         else:
-            pk, rk = self._get_pk_rk(model, {'id': entity_id})
-        
+            pk, rk = self._get_pk_rk(model, {"id": entity_id})
+
         if not replace:
-            existing = self._get_raw(model, pk, rk) # type: ignore
+            existing = self._get_raw(model, pk, rk)  # type: ignore
             if existing:
                 existing = self._retrieve_overflow(existing)
                 existing.update(data)
                 data = existing
-        
+
         store_data, _ = self._check_overflow(data)
-        return self._put_raw(model, pk, rk, store_data) # type: ignore
-    
+        return self._put_raw(model, pk, rk, store_data)  # type: ignore
+
     def upsert(self, model: type, data: JsonDict, *, replace: bool = False) -> JsonDict:
         return self.put(model, data)
-    
+
     def delete(
-        self,
-        model: type,
-        entity_id: Union[Any, Lookup],
-        *,
-        etag: Optional[str] = None
+        self, model: type, entity_id: Union[Any, Lookup], *, etag: Optional[str] = None
     ) -> JsonDict:
         if isinstance(entity_id, dict):
-            pk = entity_id.get('partition_key') or entity_id.get('pk')
-            rk = entity_id.get('row_key') or entity_id.get('rk') or entity_id.get('id')
+            pk = entity_id.get("partition_key") or entity_id.get("pk")
+            rk = entity_id.get("row_key") or entity_id.get("rk") or entity_id.get("id")
         else:
-            pk, rk = self._get_pk_rk(model, {'id': entity_id})
-        
-        return self._delete_raw(model, pk, rk, etag) # type: ignore
-    
+            pk, rk = self._get_pk_rk(model, {"id": entity_id})
+
+        return self._delete_raw(model, pk, rk, etag)  # type: ignore
+
+    def query_linq_rows(self, model: type, builder: QueryBuilder) -> List[JsonDict]:
+        """
+        Typed wrapper for queries that return rows.
+        Use this when builder.count_only is False.
+        """
+        result = self.query_linq(model, builder)
+        return cast(List[JsonDict], result)
+
     def query_linq(self, model: type, builder: QueryBuilder) -> Union[List[JsonDict], int]:
         """LINQ-style query"""
         results = self._query_raw(model, {}, None)
         results = [self._retrieve_overflow(r) for r in results]
-        
+
         results = self._apply_filters(results, builder)
-        
+
         if builder.count_only:
             return len(results)
-        
+
         results = self._apply_ordering(results, builder)
         results = self._apply_pagination(results, builder)
         results = self._apply_projection(results, builder)
-        
+
         if builder.distinct:
             seen = set()
             unique = []
             for r in results:
-                key = json.dumps(r, sort_keys=True,default=json_safe)
+                key = json.dumps(r, sort_keys=True, default=json_safe)
                 if key not in seen:
                     seen.add(key)
                     unique.append(r)
             results = unique
-        
-        return results
+
+        return results

polydb/base/ObjectStorageAdapter.py

@@ -1,6 +1,7 @@
-from polydb.utils import setup_logger
+from ..errors import StorageError
+from ..utils import setup_logger
 from abc import ABC, abstractmethod
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 
 class ObjectStorageAdapter(ABC):
@@ -10,19 +11,34 @@ class ObjectStorageAdapter(ABC):
         self.logger = setup_logger(self.__class__.__name__)
 
     def put(
-        self, key: str, data: bytes, optimize: bool = True, media_type: Optional[str] = None
+        self,
+        key: str,
+        data: bytes,
+        fileName: str = "",
+        optimize: bool = True,
+        media_type: Optional[str] = None,
+        metadata: Dict[str, Any] | None = None,
     ) -> str:
         """Store object with optional optimization"""
         if optimize and media_type:
             data = self._optimize_media(data, media_type)
-        return self._put_raw(key, data)
+        return self._put_raw(
+            key=key, data=data, fileName=fileName, media_type=media_type, metadata=metadata
+        )
 
     def _optimize_media(self, data: bytes, media_type: str) -> bytes:
         """Optimize images and videos - placeholder for implementation"""
         return data
 
     @abstractmethod
-    def _put_raw(self, key: str, data: bytes) -> str:
+    def _put_raw(
+        self,
+        key: str,
+        data: bytes,
+        fileName: str = "",
+        media_type: Optional[str] = None,
+        metadata: Dict[str, Any] | None = None,
+    ) -> str:
         """Provider-specific put"""
         pass
 
@@ -39,4 +55,24 @@ class ObjectStorageAdapter(ABC):
     @abstractmethod
     def list(self, prefix: str = "") -> List[str]:
         """List objects with prefix"""
-        pass
+        pass
+
+    def upload(self, key: str, data: bytes, **kwargs) -> str:
+        """
+        Alias for put().
+        Accepts kwargs so callers can pass optimize/media_type without breaking.
+        """
+        return self.put(key, data, **kwargs)
+
+    def download(self, key: str) -> bytes:
+        """
+        Alias for get() but guarantees bytes or raises.
+        This matches how your tests expect download() to behave.
+        """
+        if not key:
+            raise StorageError("Key cannot be empty")
+
+        data = self.get(key)
+        if data is None:
+            raise StorageError(f"Object not found: {key}")
+        return data

polydb/base/QueueAdapter.py

@@ -22,6 +22,6 @@ class QueueAdapter(ABC):
         pass
 
     @abstractmethod
-    def delete(self, message_id: str, queue_name: str = "default") -> bool:
+    def delete(self, message_id: str, queue_name: str = "default", pop_receipt: str = "") -> bool:
         """Delete message from queue"""
-        pass
+        pass

polydb/base/SharedFilesAdapter.py

@@ -17,7 +17,7 @@ class SharedFilesAdapter(ABC):
         pass
 
     @abstractmethod
-    def read(self, path: str) -> bytes:
+    def read(self, path: str) -> bytes | None:
         """Read file"""
         pass
 
@@ -29,4 +29,4 @@ class SharedFilesAdapter(ABC):
     @abstractmethod
     def list(self, directory: str = "/") -> List[str]:
         """List files in directory"""
-        pass
+        pass