altcodepro-polydb-python 2.5.9__py3-none-any.whl → 2.5.11__py3-none-any.whl

polydb/security.py

@@ -3,17 +3,15 @@
 Security features: encryption, masking, row-level security
 """
 
-from typing import Dict, Any, List, Optional, Callable, Union
-from dataclasses import dataclass
-import hashlib
 import base64
-import os
 import json
-from functools import wraps
 import logging
+import os
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional, Union
 
-from .json_safe import json_safe
 from .errors import EncryptionConfigError
+from .json_safe import json_safe
 
 logger = logging.getLogger(__name__)
 
@@ -98,8 +96,8 @@ class FieldEncryption:
         if not active_raw:
             raise EncryptionConfigError(
                 "Field encryption is enabled but POLYDB_ENCRYPTION_KEY is not set. "
-                "Generate one with: python -c \"import os,base64; "
-                "print(base64.b64encode(os.urandom(32)).decode())\" and store it securely "
+                'Generate one with: python -c "import os,base64; '
+                'print(base64.b64encode(os.urandom(32)).decode())" and store it securely '
                 "(e.g. Azure Key Vault / AWS Secrets Manager / GCP Secret Manager) - do not "
                 "commit it or let it be generated on the fly."
             )
@@ -135,7 +133,7 @@ class FieldEncryption:
         if not isinstance(encrypted_data, str) or not encrypted_data.startswith("encrypted:"):
             return encrypted_data
 
-        payload = encrypted_data[len("encrypted:"):]
+        payload = encrypted_data[len("encrypted:") :]
         # Legacy format (pre key-versioning) has no key id segment - decrypt
         # with the active key for backward compatibility with existing data.
         key_id, _, b64_blob = payload.partition(":")

polydb/services/__init__.py

@@ -1,5 +1,5 @@
-from .compliance_service import ComplianceService, AuditEvent
-from .security_service import SecurityService, EncryptionConfigError
+from .compliance_service import AuditEvent, ComplianceService
+from .security_service import EncryptionConfigError, SecurityService
 
 __all__ = [
     "ComplianceService",

polydb/services/compliance_service.py

@@ -70,7 +70,8 @@ class ComplianceService:
                 logger.critical(
                     "compliance.audit_failure retry queue full — event dropped: "
                     "event_type=%s tenant_id=%s",
-                    event.event_type, event.tenant_id,
+                    event.event_type,
+                    event.tenant_id,
                 )
 
     async def start(self, *, writer: WriterFn) -> None:
@@ -122,14 +123,19 @@ class ComplianceService:
                     logger.critical(
                         "compliance.audit_failure retry queue full on re-enqueue — event lost: "
                         "event_type=%s tenant_id=%s",
-                        event.event_type, event.tenant_id,
+                        event.event_type,
+                        event.tenant_id,
                     )
 
     def _record_failure(self, event: AuditEvent, exc: Exception, step: str) -> None:
         logger.error(
             "compliance.audit_failure step=%s event_type=%s tenant_id=%s resource=%s/%s error=%s",
-            step, event.event_type, event.tenant_id,
-            event.resource_type, event.resource_id, exc,
+            step,
+            event.event_type,
+            event.tenant_id,
+            event.resource_type,
+            event.resource_id,
+            exc,
         )
         if self._metrics:
             try:

polydb/services/security_service.py

@@ -78,11 +78,10 @@ class SecurityService:
     def encrypt(self, value: str) -> str:
         """Encrypt *value*. Returns Fernet token (URL-safe base64 string)."""
         if not self._key:
-            raise EncryptionConfigError(
-                f"Cannot encrypt: {self.ENV_KEY} is not set."
-            )
+            raise EncryptionConfigError(f"Cannot encrypt: {self.ENV_KEY} is not set.")
         try:
             from cryptography.fernet import Fernet
+
             return Fernet(self._key).encrypt(value.encode("utf-8")).decode("ascii")
         except ImportError:
             raise EncryptionConfigError(
@@ -93,16 +92,13 @@ class SecurityService:
     def decrypt(self, value: str) -> str:
         """Decrypt a Fernet token produced by :meth:`encrypt`."""
         if not self._key:
-            raise EncryptionConfigError(
-                f"Cannot decrypt: {self.ENV_KEY} is not set."
-            )
+            raise EncryptionConfigError(f"Cannot decrypt: {self.ENV_KEY} is not set.")
         try:
             from cryptography.fernet import Fernet
+
             return Fernet(self._key).decrypt(value.encode("ascii")).decode("utf-8")
         except ImportError:
-            raise EncryptionConfigError(
-                "cryptography package is required for field encryption."
-            )
+            raise EncryptionConfigError("cryptography package is required for field encryption.")
         except Exception as exc:
             raise ValueError(f"Decryption failed: {exc}") from exc
 
@@ -122,9 +118,10 @@ class SecurityService:
             if len(decoded) != 32:
                 logger.error(
                     "%s decoded to %d bytes; Fernet requires exactly 32 bytes. "
-                    "Generate a valid key with: python -c \""
-                    "from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())\"",
-                    cls.ENV_KEY, len(decoded),
+                    'Generate a valid key with: python -c "'
+                    'from cryptography.fernet import Fernet; print(Fernet.generate_key().decode())"',
+                    cls.ENV_KEY,
+                    len(decoded),
                 )
                 return None
             return key_bytes

polydb/types.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Protocol, Tuple, Union, runtime_checkable, Literal
+from typing import Any, Dict, List, Literal, Optional, Protocol, Tuple, Union, runtime_checkable
 
 from .query import QueryBuilder
 
@@ -15,6 +15,7 @@ Lookup = Dict[str, Any]
 @dataclass(frozen=True)
 class ModelMeta:
     """Model metadata"""
+
     storage: StorageType
     table: Optional[str] = None
     collection: Optional[str] = None
@@ -28,72 +29,51 @@ class ModelMeta:
 @runtime_checkable
 class SQLAdapter(Protocol):
     """SQL adapter contract"""
-    
+
     def insert(self, table: str, data: JsonDict) -> JsonDict: ...
-    
+
     def select(
         self,
         table: str,
         query: Optional[Lookup] = None,
         limit: Optional[int] = None,
-        offset: Optional[int] = None
+        offset: Optional[int] = None,
     ) -> List[JsonDict]: ...
-    
+
     def select_page(
-        self,
-        table: str,
-        query: Lookup,
-        page_size: int,
-        continuation_token: Optional[str] = None
+        self, table: str, query: Lookup, page_size: int, continuation_token: Optional[str] = None
     ) -> Tuple[List[JsonDict], Optional[str]]: ...
-    
-    def update(
-        self,
-        table: str,
-        entity_id: Union[Any, Lookup],
-        data: JsonDict
-    ) -> JsonDict: ...
-    
+
+    def update(self, table: str, entity_id: Union[Any, Lookup], data: JsonDict) -> JsonDict: ...
+
     def upsert(self, table: str, data: JsonDict) -> JsonDict: ...
-    
-    def delete(
-        self,
-        table: str,
-        entity_id: Union[Any, Lookup]
-    ) -> JsonDict: ...
-    
-    def query_linq(
-        self,
-        table: str,
-        builder: QueryBuilder
-    ) -> Union[List[JsonDict], int]: ...
-    
+
+    def delete(self, table: str, entity_id: Union[Any, Lookup]) -> JsonDict: ...
+
+    def query_linq(self, table: str, builder: QueryBuilder) -> Union[List[JsonDict], int]: ...
+
     def execute(self, sql: str, params: Optional[List[Any]] = None) -> None: ...
 
 
 @runtime_checkable
 class NoSQLKVAdapter(Protocol):
     """NoSQL KV adapter contract"""
-    
+
     def put(self, model: type, data: JsonDict) -> JsonDict: ...
-    
+
     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]: ...
-    
+
     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]]: ...
-    
+
     def patch(
         self,
         model: type,
@@ -101,27 +81,13 @@ class NoSQLKVAdapter(Protocol):
         data: JsonDict,
         *,
         etag: Optional[str] = None,
-        replace: bool = False
-    ) -> JsonDict: ...
-    
-    def upsert(
-        self,
-        model: type,
-        data: JsonDict,
-        *,
-        replace: bool = False
+        replace: bool = False,
     ) -> JsonDict: ...
-    
+
+    def upsert(self, model: type, data: JsonDict, *, replace: bool = False) -> JsonDict: ...
+
     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: ...
-    
-    def query_linq(
-        self,
-        model: type,
-        builder: QueryBuilder
-    ) -> Union[List[JsonDict], int]: ...
+
+    def query_linq(self, model: type, builder: QueryBuilder) -> Union[List[JsonDict], int]: ...

polydb/utils.py

@@ -3,10 +3,11 @@
 Utility functions for validation and logging
 """
 
+import logging
 import os
 import re
-import logging
-from typing import Dict, Any
+from typing import Any, Dict
+
 from .errors import ValidationError
 
 # Loggers already configured by setup_logger(), so per-request adapter
@@ -19,7 +20,7 @@ def validate_table_name(table: str) -> str:
     Validate table name to prevent SQL injection
     Only allows alphanumeric, underscore, and hyphen
     """
-    if not re.match(r'^[a-zA-Z0-9_-]+$', table):
+    if not re.match(r"^[a-zA-Z0-9_-]+$", table):
         raise ValidationError(
             f"Invalid table name: '{table}'. Only alphanumeric, underscore, and hyphen allowed."
         )
@@ -31,7 +32,7 @@ def validate_column_name(column: str) -> str:
     Validate column name to prevent SQL injection
     Only allows alphanumeric and underscore
     """
-    if not re.match(r'^[a-zA-Z0-9_]+$', column):
+    if not re.match(r"^[a-zA-Z0-9_]+$", column):
         raise ValidationError(
             f"Invalid column name: '{column}'. Only alphanumeric and underscore allowed."
         )
@@ -85,10 +86,8 @@ def setup_logger(name: str, level: int = logging.INFO) -> logging.Logger:
         logger.handlers.clear()
 
     handler = logging.StreamHandler()
-    formatter = logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
+    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
     handler.setFormatter(formatter)
     logger.addHandler(handler)
 
-    return logger
+    return logger

polydb/validation.py

@@ -2,9 +2,12 @@
 """
 Model metadata validation and schema enforcement
 """
-from typing import Type, Dict, Any, List, Optional
+
 from dataclasses import dataclass
-from .errors import InvalidModelMetadataError, ValidationError
+from typing import Any, Dict, List, Type
+
+from .errors import InvalidModelMetadataError
+
 
 @dataclass
 class ValidationResult:
@@ -15,83 +18,82 @@ class ValidationResult:
 
 class ModelValidator:
     """Validates model metadata and schema"""
-    
-    REQUIRED_FIELDS = {'storage'}
-    VALID_STORAGE_TYPES = {'sql', 'nosql'}
-    SQL_REQUIRED_FIELDS = {'table'}
-    NOSQL_OPTIONAL_FIELDS = {'collection', 'pk_field', 'rk_field'}
-    
+
+    REQUIRED_FIELDS = {"storage"}
+    VALID_STORAGE_TYPES = {"sql", "nosql"}
+    SQL_REQUIRED_FIELDS = {"table"}
+    NOSQL_OPTIONAL_FIELDS = {"collection", "pk_field", "rk_field"}
+
     @classmethod
     def validate_model(cls, model: Type) -> ValidationResult:
         """Comprehensive model validation"""
         errors = []
         warnings = []
-        
+
         # Check __polydb__ exists
-        if not hasattr(model, '__polydb__'):
+        if not hasattr(model, "__polydb__"):
             errors.append(f"Model {model.__name__} missing __polydb__ metadata")
             return ValidationResult(valid=False, errors=errors, warnings=warnings)
-        
-        meta = getattr(model, '__polydb__')
-        
+
+        meta = getattr(model, "__polydb__")
+
         # Check it's a dict
         if not isinstance(meta, dict):
             errors.append(f"__polydb__ must be a dict, got {type(meta)}")
             return ValidationResult(valid=False, errors=errors, warnings=warnings)
-        
+
         # Check required fields
         for field in cls.REQUIRED_FIELDS:
             if field not in meta:
                 errors.append(f"Missing required field: {field}")
-        
+
         # Validate storage type
-        storage = meta.get('storage')
+        storage = meta.get("storage")
         if storage and storage not in cls.VALID_STORAGE_TYPES:
-            errors.append(f"Invalid storage type: {storage}. Must be one of {cls.VALID_STORAGE_TYPES}")
-        
+            errors.append(
+                f"Invalid storage type: {storage}. Must be one of {cls.VALID_STORAGE_TYPES}"
+            )
+
         # Storage-specific validation
-        if storage == 'sql':
+        if storage == "sql":
             for field in cls.SQL_REQUIRED_FIELDS:
                 if field not in meta:
                     errors.append(f"SQL storage requires field: {field}")
-        
-        elif storage == 'nosql':
+
+        elif storage == "nosql":
             # NoSQL has optional fields, warn if missing common ones
-            if 'pk_field' not in meta:
+            if "pk_field" not in meta:
                 warnings.append("No pk_field specified, will default to 'id'")
-            
-            if not meta.get('collection') and not meta.get('table'):
+
+            if not meta.get("collection") and not meta.get("table"):
                 warnings.append("No collection/table name specified, will use model name")
-        
+
         # Validate cache settings
-        if meta.get('cache') and not isinstance(meta.get('cache_ttl'), (int, type(None))):
+        if meta.get("cache") and not isinstance(meta.get("cache_ttl"), (int, type(None))):
             errors.append("cache_ttl must be an integer or None")
-        
+
         # Validate provider
-        valid_providers = {'azure', 'aws', 'gcp', 'vercel', 'mongodb', 'postgresql'}
-        provider = meta.get('provider')
+        valid_providers = {"azure", "aws", "gcp", "vercel", "mongodb", "postgresql"}
+        provider = meta.get("provider")
         if provider and provider.lower() not in valid_providers:
             warnings.append(f"Unusual provider: {provider}")
-        
-        return ValidationResult(
-            valid=len(errors) == 0,
-            errors=errors,
-            warnings=warnings
-        )
-    
+
+        return ValidationResult(valid=len(errors) == 0, errors=errors, warnings=warnings)
+
     @classmethod
     def validate_and_raise(cls, model: Type):
         """Validate and raise if invalid"""
         result = cls.validate_model(model)
-        
+
         if not result.valid:
             raise InvalidModelMetadataError(
                 f"Invalid model {model.__name__}: {', '.join(result.errors)}"
             )
-        
+
         # Log warnings
         if result.warnings:
             import logging
+
             logger = logging.getLogger(__name__)
             for warning in result.warnings:
                 logger.warning(f"{model.__name__}: {warning}")
@@ -99,22 +101,22 @@ class ModelValidator:
 
 class SchemaValidator:
     """Validates data against model schema"""
-    
+
     @staticmethod
     def validate_data(model: Type, data: Dict[str, Any]) -> ValidationResult:
         """Validate data against model requirements"""
         errors = []
         warnings = []
-        
-        meta = getattr(model, '__polydb__', {})
-        
+
+        meta = getattr(model, "__polydb__", {})
+
         # Check required keys exist
-        pk_field = meta.get('pk_field', 'id')
-        if pk_field not in data and not meta.get('auto_generate'):
+        pk_field = meta.get("pk_field", "id")
+        if pk_field not in data and not meta.get("auto_generate"):
             errors.append(f"Missing required field: {pk_field}")
-        
+
         # Check field types if type hints available
-        if hasattr(model, '__annotations__'):
+        if hasattr(model, "__annotations__"):
             annotations = model.__annotations__
             for field_name, expected_type in annotations.items():
                 if field_name in data:
@@ -123,9 +125,5 @@ class SchemaValidator:
                         warnings.append(
                             f"Field {field_name} expected {expected_type}, got {type(actual_value)}"
                         )
-        
-        return ValidationResult(
-            valid=len(errors) == 0,
-            errors=errors,
-            warnings=warnings
-        )
+
+        return ValidationResult(valid=len(errors) == 0, errors=errors, warnings=warnings)

altcodepro_polydb_python-2.5.9.dist-info/RECORD

@@ -1,73 +0,0 @@
-altcodepro_polydb_python-2.5.9.dist-info/licenses/LICENSE,sha256=9X8GLocsBwy-5aR5JGOt2SAMDDPs9Qv-YnqmHBHOXrw,1067
-polydb/PolyDB.py,sha256=MG7-nV59zDvrUQwXNEgV4eetHCeW9TYY9DQqtxu_r7k,23543
-polydb/__init__.py,sha256=JxB_TeZ2RfmcuZ7HOTeRPSpe4kA-Pxe25M6KN2MR8vw,1535
-polydb/advanced_query.py,sha256=JZUQr4wyC9ydrcO9VbZiH2ueiQiC4dxOX9hzG_JaFhs,6931
-polydb/batch.py,sha256=_DjWZa1ZXYSk6MLKqFe0eT7SYVRZtYNqZb9bI8Y2sao,4566
-polydb/cache.py,sha256=9UUHhiCVSWHQ-x-Ac_kIHYAadj0AQeqE4x8dwtyYFII,11781
-polydb/cloudDatabaseFactory.py,sha256=M2qtHJmZUr6ZSZY6RCOgC3MLmq5o9WJeKgVubU77chk,22943
-polydb/databaseFactory.py,sha256=xbv3w9flbfkC_5QLFIVNoXs5WFEwH_lH3PARwmJxtxU,53214
-polydb/decorators.py,sha256=L_WP2uXP_k8Ac49SUm-mthbM4jWI-XYfHXEyKzumOww,43062
-polydb/errors.py,sha256=ynQ732utRGA3nFan0tv1CVNxZgV07r7lidpFf-wVhSU,1830
-polydb/json_safe.py,sha256=R5PrqAGirqjYKPyy-8KH-lSXjLH0FPr2TSGozy4eheU,149
-polydb/models.py,sha256=HPOdcg0F1rPONJsnbwja75FDQ-38o94U1KsLktngwoI,12600
-polydb/monitoring.py,sha256=UMm3ybyRJjAQi-prXXMLl9zuHhnhMnYBzMD3XWK66y8,9571
-polydb/multitenancy.py,sha256=BfnSJRRyRl4ObM4noXDJhsGJHLESXzvYRsdKwic7TQc,8135
-polydb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polydb/query.py,sha256=72QbnQaljNGvIWktSD29BII0476MMjrJ-7dQmOcWuZc,8509
-polydb/registry.py,sha256=RD_elvFXcmhTdCyZDm2f3ej0elxqhArnSJ2aO9k5VCU,2352
-polydb/retry.py,sha256=tX8vniILKe1A_2MLXLACY5iGEBT_zSLYGggkzvxt618,4926
-polydb/schema.py,sha256=hI7uJM4WvH31A-h0kGZhCD5mCYcnrNvEega--_kvafE,6889
-polydb/security.py,sha256=KqV5cD19hLyIvykW2DkKCXuj1hBDLt3xQ1tFtz_sCQE,20202
-polydb/types.py,sha256=XB_85Un8_aWt4dSfpjIGotHbK3KBY2WurQGXr9EOxWY,2992
-polydb/utils.py,sha256=tS_KI1vt-VZ6JftbFxbnVxC0xpie1-zYikTGf1nSoFw,3183
-polydb/validation.py,sha256=a1o1d02k3c6PWQwkBbw_0nEmIgrdB5RR8OcpNQMn4cA,4810
-polydb/adapters/AWSSecretsManagerAdapter.py,sha256=W4B3xhQFcBAlNlwQ4uTgcDmRrOmZr6v-suC4qihTpJw,2747
-polydb/adapters/AzureBlobStorageAdapter.py,sha256=4vD55Z8DBTzBK66jIJbo5bNMY-AQ61MlP0-P2Fv_JgQ,7083
-polydb/adapters/AzureFileStorageAdapter.py,sha256=VZNprqlBXCuWUgtqClNT-NrQmRf-XFYEiRA2BLbf-Sc,7046
-polydb/adapters/AzureKeyVaultAdapter.py,sha256=7Nizs9qGh6cytbZNgV78f-odOO4Z6sUlwm_HQYqt-pc,2339
-polydb/adapters/AzureQueueAdapter.py,sha256=15w0QQMBM53NIg10MZqdoweJyYtYdgR-SbZVwFqx3BI,13660
-polydb/adapters/AzureTableStorageAdapter.py,sha256=s367vYgA40CkqPmCCQvvKRsGHA-AAo8a4GnPFvGsNxo,32025
-polydb/adapters/BlockchainBlobAdapter.py,sha256=D01Yua9mkKfaQrxKYApblIyI6DSP0dtNAh4Tav51HJ4,3299
-polydb/adapters/BlockchainFileAdapter.py,sha256=G749xOVpG20HuKS8zCgi6PMjoJNu-YXK7zitygjLdzM,8335
-polydb/adapters/BlockchainKVAdapter.py,sha256=UFYHyTgvdW-sZUBqyHEG3Cdx6wSTiF2QowEVWL3XPTg,4564
-polydb/adapters/BlockchainQueueAdapter.py,sha256=XsN5ag9Wulaelfkb3RCuBuSBw_4MUx9Wi3Gd3DBn7ME,4196
-polydb/adapters/DynamoDBAdapter.py,sha256=kULYZMa9hFxV2VHVO_VsJcTh9OqKR8vQg2ceO1OvYbk,19545
-polydb/adapters/EFSAdapter.py,sha256=Ca7-Esm3KNVm90Qo6tWmmftwk8Nq54DIzU3fAHX53io,2937
-polydb/adapters/FirestoreAdapter.py,sha256=WCYZ6EThZgDGsdJcKXBFXHckdLnIY9jvtVYHSb3z7ao,15260
-polydb/adapters/GCPFilestoreAdapter.py,sha256=yjFQQwsWYWc8mo8XwMViVTWb5_D--xAyTMvE-4AOpNM,3006
-polydb/adapters/GCPPubSubAdapter.py,sha256=NcxzvCqjWWNFuGUU5LS5IYSV32cg_AGwGmSBn_gXE6Y,10685
-polydb/adapters/GCPSecretManagerAdapter.py,sha256=ZFL2FGh7uTaBfpUo-HKXZAxS9s-w0w4yI_5I39KsG3A,2659
-polydb/adapters/GCPStorageAdapter.py,sha256=9yS1Jhcn5_rCRdZ5uOqcRW6Ba-UNb6VOYpwENP-C6Qk,7133
-polydb/adapters/KafkaQueueAdapter.py,sha256=JqzYGjeJtSLlL1jBqwWmBlnFKwwGIQUQzhsuM9wujm4,14411
-polydb/adapters/MongoDBAdapter.py,sha256=qB7RwQb3tvSLLPBiKV_BoAHCvl8Me3C02ieunj01Iew,11788
-polydb/adapters/PostgreSQLAdapter.py,sha256=tEzwFB-ENSOfOqDcGK5MUCN7cU7k4c1vFgm1fJUYf3A,43877
-polydb/adapters/RabbitMQAdapter.py,sha256=c6usZrKgvUYwkfhcGjGFPjZkCKscU2xH9Fh9Ov9frYE,19903
-polydb/adapters/S3Adapter.py,sha256=5R0zHAL2SkGFjp1L3bp-IU468bXYdSf6nKx974MN104,7586
-polydb/adapters/S3CompatibleAdapter.py,sha256=jpafqbAjA8-irdXBrfXa1QJySIzrcUQ6UrFt5h5FAEc,7006
-polydb/adapters/SQSAdapter.py,sha256=GhbbQKGA8P5teVdkeMZCl6aeH_8Dqi5qQJiJecwgV0A,8133
-polydb/adapters/VaultAdapter.py,sha256=6R1hpn-BlPEm4fwoKc6304GmLrQeJohFmlqijlolq68,2716
-polydb/adapters/VercelBlobAdapter.py,sha256=Hu1u8vE-3rvJMBDotnPKeRoVaH1Vl9PdM1hBKphgj2w,6983
-polydb/adapters/VercelFileAdapter.py,sha256=-fLRCi0AUbyXAR4nkHCV-wXkociHF2hzzEDqWtixIpE,1033
-polydb/adapters/VercelKVAdapter.py,sha256=jcuhXUcvhd3-QJUu1C_P4lN8DMu6qmjNQa3HwkzYcAE,10005
-polydb/adapters/VercelQueueAdapter.py,sha256=lpfKdl-BPiQZJlwlyichTIWwj2iX9iEykAgoUd2wxmI,3894
-polydb/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polydb/audit/AuditStorage.py,sha256=6luCS7hTNL5MH2kkn6QlBlBsH-3FLuEFwP-cmkugRss,10469
-polydb/audit/__init__.py,sha256=Z7-y5djq3glQ2Yun6nj-13Efpj3oGz9Qc0veS2g06Y4,245
-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=cSDkzW22FnsMvjQFvLQACQUm9lYFcnJ2Ew5mngBF9yQ,7043
-polydb/base/NoSQLKVAdapter.py,sha256=U64nXaeHd40GCZV4DQnogZRUxvI8HHLEhNBMv4oddq4,14491
-polydb/base/ObjectStorageAdapter.py,sha256=VeJ3qXET6H0xd3lJpE8-WSsKs8EyK9S0-9VNR0EJzME,2288
-polydb/base/QueueAdapter.py,sha256=rphkdq9LEErwAKbmapUiHDshiOvgzvS5ZgFoOS8m9xc,8207
-polydb/base/SecretsAdapter.py,sha256=HVk0H9637BkOJTykZNZbF2wKtSkFFj_-BZVpING6Hs4,989
-polydb/base/SharedFilesAdapter.py,sha256=kXbJmtn_cwEyAZ-1AvFrmesCLSwu43ycTV3S4BmwrO4,853
-polydb/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-polydb/observability/__init__.py,sha256=ZIMx5ODCBZI_FnROJFb11Q9E5kRq0ZcCp6_RmlwG53k,122
-polydb/observability/logging.py,sha256=gv1SshNjaSkmR98Uv7Qbwq3gkeQUzVCA4ichqHKL690,3923
-polydb/services/__init__.py,sha256=nMolMXzmhejRSm7f42kU9fCHF0GIpqpejN2kywuBsUQ,241
-polydb/services/compliance_service.py,sha256=-0ncX7PrXy4-NuyWXIv65cLUsqz0jXzb3LtsD8rlrXE,4983
-polydb/services/security_service.py,sha256=q7GzK6sbMnBBsc4fuL4oXTd-ui2b-MYQyrWTBvdVNSk,5062
-altcodepro_polydb_python-2.5.9.dist-info/METADATA,sha256=g6kOe5L6nI43-JRAMXNTkzAN0jWb5w0-81zAuohzqtw,15598
-altcodepro_polydb_python-2.5.9.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-altcodepro_polydb_python-2.5.9.dist-info/top_level.txt,sha256=WgLFWJoYjUhwvyPxJFl6jYLrVFuBJDX3OABf4ocwk_E,7
-altcodepro_polydb_python-2.5.9.dist-info/RECORD,,