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

polydb/models.py

@@ -10,6 +10,7 @@ from enum import Enum
 
 class CloudProvider(Enum):
     """Supported cloud providers"""
+
     AZURE = "azure"
     AWS = "aws"
     GCP = "gcp"
@@ -17,11 +18,13 @@ class CloudProvider(Enum):
     MONGODB = "mongodb"
     S3_COMPATIBLE = "s3_compatible"
     POSTGRESQL = "postgresql"
+    BLOCKCHAIN = "blockchain"
 
 
 @dataclass
 class PartitionConfig:
     """Configuration for partition and row keys"""
+
     partition_key_template: str = "default_{id}"
     row_key_template: Optional[str] = None
     composite_keys: Optional[List[str]] = None
@@ -31,9 +34,68 @@ class PartitionConfig:
 @dataclass
 class QueryOptions:
     """LINQ-style query options"""
+
     filter_func: Optional[Callable] = None
     order_by: Optional[str] = None
     skip: int = 0
     take: Optional[int] = None
     select_fields: Optional[List[str]] = None
-    count_only: bool = False
+    count_only: bool = False
+
+
+# ============================================================
+# CONFIG CLASSES (TYPED)
+# ============================================================
+
+
+class StorageConfig:
+    def __init__(self, provider: CloudProvider, name: str = "default"):
+        self.provider = provider
+        self.name = name
+
+
+class AzureStorageConfig(StorageConfig):
+    def __init__(
+        self,
+        name: str = "default",
+        connection_string: Optional[str] = None,
+        container: Optional[str] = None,
+    ):
+        super().__init__(CloudProvider.AZURE, name)
+        self.connection_string = connection_string
+        self.container = container
+
+
+class S3StorageConfig(StorageConfig):
+    def __init__(
+        self,
+        name: str = "default",
+        endpoint: Optional[str] = None,
+        access_key: Optional[str] = None,
+        secret_key: Optional[str] = None,
+        bucket: Optional[str] = None,
+    ):
+        super().__init__(CloudProvider.S3_COMPATIBLE, name)
+        self.endpoint = endpoint
+        self.access_key = access_key
+        self.secret_key = secret_key
+        self.bucket = bucket
+
+
+class GCPStorageConfig(StorageConfig):
+    def __init__(self, name: str = "default", bucket: Optional[str] = None):
+        super().__init__(CloudProvider.GCP, name)
+        self.bucket = bucket
+
+
+class VercelStorageConfig(StorageConfig):
+    def __init__(self, name: str = "default", token: Optional[str] = None, timeout: int = 10):
+        super().__init__(CloudProvider.VERCEL, name)
+        self.token = token
+        self.timeout = timeout
+
+
+class BlockchainStorageConfig(StorageConfig):
+    def __init__(self, name: str = "default", ipfs_url: Optional[str] = None):
+        super().__init__(CloudProvider.BLOCKCHAIN, name)
+        self.ipfs_url = ipfs_url

polydb/query.py

@@ -1,8 +1,8 @@
 # src/polydb/query.py
-from __future__ import annotations
 
+from __future__ import annotations
 from dataclasses import dataclass, field
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from enum import Enum
 
 
@@ -29,122 +29,191 @@ class QueryFilter:
 
 @dataclass
 class QueryBuilder:
-    """LINQ-style query builder supporting all SQL clauses"""
-    
+    """LINQ-style query builder supporting SQL and NoSQL"""
+
     filters: List[QueryFilter] = field(default_factory=list)
-    order_by_fields: List[tuple[str, bool]] = field(default_factory=list)  # (field, desc)
+    order_by_fields: List[tuple[str, bool]] = field(default_factory=list)
+
     skip_count: int = 0
     take_count: Optional[int] = None
-    select_fields: Optional[List[str]] = None
+
+    selected_fields: Optional[List[str]] = None
     group_by_fields: Optional[List[str]] = None
-    distinct: bool = False
+
+    distinct_flag: bool = False
     count_only: bool = False
-    
-    def where(self, field: str, operator: Union[Operator, str], value: Any) -> QueryBuilder:
-        """Add filter condition"""
-        if isinstance(operator, str):
-            operator = Operator(operator)
-        self.filters.append(QueryFilter(field, operator, value))
+
+    # ------------------------------------------------
+    # FILTERS
+    # ------------------------------------------------
+
+    def where(
+        self, field: str, operator: Union["Operator", str, None], value: Any
+    ) -> "QueryBuilder":
+        # Allow legacy callers that pass "" meaning equality
+        if operator in ("", None):
+            op = Operator.EQ
+        elif isinstance(operator, Operator):
+            op = operator
+        else:
+            op = Operator(operator)
+
+        self.filters.append(QueryFilter(field=field, operator=op, value=value))
         return self
-    
+
+    # ------------------------------------------------
+    # ORDER
+    # ------------------------------------------------
+
     def order_by(self, field: str, descending: bool = False) -> QueryBuilder:
-        """Add ordering"""
         self.order_by_fields.append((field, descending))
         return self
-    
+
+    # ------------------------------------------------
+    # PAGINATION
+    # ------------------------------------------------
+
     def skip(self, count: int) -> QueryBuilder:
-        """Skip records"""
         self.skip_count = count
         return self
-    
+
     def take(self, count: int) -> QueryBuilder:
-        """Take records"""
         self.take_count = count
         return self
-    
+
+    # ------------------------------------------------
+    # SELECT
+    # ------------------------------------------------
+
     def select(self, *fields: str) -> QueryBuilder:
-        """Select specific fields"""
-        self.select_fields = list(fields)
+        self.selected_fields = list(fields)
+        return self
+
+    def select_fields(self, fields: List[str]) -> QueryBuilder:
+        self.selected_fields = fields
         return self
-    
+
+    # ------------------------------------------------
+    # GROUP
+    # ------------------------------------------------
+
     def group_by(self, *fields: str) -> QueryBuilder:
-        """Group by fields"""
         self.group_by_fields = list(fields)
         return self
-    
-    def distinct_on(self) -> QueryBuilder:
-        """Return distinct results"""
-        self.distinct = True
+
+    # ------------------------------------------------
+    # DISTINCT
+    # ------------------------------------------------
+
+    def distinct(self) -> QueryBuilder:
+        self.distinct_flag = True
         return self
-    
+
+    # ------------------------------------------------
+    # COUNT
+    # ------------------------------------------------
+
     def count(self) -> QueryBuilder:
-        """Return count only"""
         self.count_only = True
         return self
-    
+
+    # ------------------------------------------------
+    # SQL WHERE
+    # ------------------------------------------------
+
     def to_sql_where(self) -> tuple[str, List[Any]]:
-        """Convert to SQL WHERE clause"""
+
         if not self.filters:
             return "", []
-        
+
         clauses = []
         params = []
-        
+
         for f in self.filters:
+
             if f.operator == Operator.EQ:
                 clauses.append(f"{f.field} = %s")
                 params.append(f.value)
+
             elif f.operator == Operator.NE:
                 clauses.append(f"{f.field} != %s")
                 params.append(f.value)
+
             elif f.operator == Operator.GT:
                 clauses.append(f"{f.field} > %s")
                 params.append(f.value)
+
             elif f.operator == Operator.GTE:
                 clauses.append(f"{f.field} >= %s")
                 params.append(f.value)
+
             elif f.operator == Operator.LT:
                 clauses.append(f"{f.field} < %s")
                 params.append(f.value)
+
             elif f.operator == Operator.LTE:
                 clauses.append(f"{f.field} <= %s")
                 params.append(f.value)
+
             elif f.operator == Operator.IN:
-                placeholders = ','.join(['%s'] * len(f.value))
-                clauses.append(f"{f.field} IN ({placeholders})")
-                params.extend(f.value)
+
+                if isinstance(f.value, (list, tuple)):
+                    placeholders = ",".join(["%s"] * len(f.value))
+                    clauses.append(f"{f.field} IN ({placeholders})")
+                    params.extend(f.value)
+
+                else:
+                    clauses.append(f"{f.field} LIKE %s")
+                    params.append(f.value)
+
             elif f.operator == Operator.NOT_IN:
-                placeholders = ','.join(['%s'] * len(f.value))
+                placeholders = ",".join(["%s"] * len(f.value))
                 clauses.append(f"{f.field} NOT IN ({placeholders})")
                 params.extend(f.value)
+
             elif f.operator == Operator.CONTAINS:
                 clauses.append(f"{f.field} LIKE %s")
                 params.append(f"%{f.value}%")
+
             elif f.operator == Operator.STARTS_WITH:
                 clauses.append(f"{f.field} LIKE %s")
                 params.append(f"{f.value}%")
+
             elif f.operator == Operator.ENDS_WITH:
                 clauses.append(f"{f.field} LIKE %s")
                 params.append(f"%{f.value}")
-        
+
         return " AND ".join(clauses), params
-    
+
+    # ------------------------------------------------
+    # NOSQL FILTER
+    # ------------------------------------------------
+
     def to_nosql_filter(self) -> Dict[str, Any]:
-        """Convert to NoSQL filter dict"""
+
         result = {}
+
         for f in self.filters:
+
             if f.operator == Operator.EQ:
                 result[f.field] = f.value
+
             elif f.operator == Operator.IN:
                 result[f"{f.field}__in"] = f.value
+
             elif f.operator == Operator.GT:
                 result[f"{f.field}__gt"] = f.value
+
             elif f.operator == Operator.GTE:
                 result[f"{f.field}__gte"] = f.value
+
             elif f.operator == Operator.LT:
                 result[f"{f.field}__lt"] = f.value
+
             elif f.operator == Operator.LTE:
                 result[f"{f.field}__lte"] = f.value
+
             elif f.operator == Operator.CONTAINS:
                 result[f"{f.field}__contains"] = f.value
-        return result
+
+        return result