altcodepro-polydb-python 2.3.24__tar.gz → 2.3.26__tar.gz

{altcodepro_polydb_python-2.3.24/src/altcodepro_polydb_python.egg-info → altcodepro_polydb_python-2.3.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.3.24
+Version: 2.3.26
 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

{altcodepro_polydb_python-2.3.24 → altcodepro_polydb_python-2.3.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "altcodepro-polydb-python"
-version = "2.3.24"
+version = "2.3.26"
 description = "Production-ready multi-cloud database abstraction layer with connection pooling, retry logic, and thread safety"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.11"

{altcodepro_polydb_python-2.3.24 → altcodepro_polydb_python-2.3.26/src/altcodepro_polydb_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.3.24
+Version: 2.3.26
 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

{altcodepro_polydb_python-2.3.24 → altcodepro_polydb_python-2.3.26}/src/altcodepro_polydb_python.egg-info/SOURCES.txt

@@ -78,6 +78,7 @@ src/polydb/services/security_service.py
 tests/test_atomic_decrement.py
 tests/test_aws.py
 tests/test_azure.py
+tests/test_azure_table_empty_filter.py
 tests/test_blockchain.py
 tests/test_cloud_factory.py
 tests/test_gcp.py

{altcodepro_polydb_python-2.3.24 → altcodepro_polydb_python-2.3.26}/src/polydb/__init__.py

@@ -8,7 +8,7 @@ __version__ = "2.2.3"
 
 from .cloudDatabaseFactory import CloudDatabaseFactory
 from .databaseFactory import DatabaseFactory
-from .models import CloudProvider, PartitionConfig
+from .models import CloudProvider, PartitionConfig, MongoConfig, CosmosMongoConfig
 from .query import QueryBuilder, Operator
 from .audit.context import AuditContext
 from .cache import RedisCacheEngine as CacheEngine
@@ -36,6 +36,8 @@ __all__ = [
     # Models & Config
     "CloudProvider",
     "PartitionConfig",
+    "MongoConfig",
+    "CosmosMongoConfig",
     # Query
     "QueryBuilder",
     "Operator",

{altcodepro_polydb_python-2.3.24 → altcodepro_polydb_python-2.3.26}/src/polydb/adapters/AzureTableStorageAdapter.py

@@ -567,7 +567,18 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
                     sval = str(ev).replace("'", "''")
                     parts.append(f"{sk} eq '{sval}'")
 
-            query_filter = " and ".join(parts) if parts else None
+            # Empty-filter contract: if the caller passed filter keys but every
+            # condition dropped out (e.g. all values None/unresolvable), the query
+            # must match NOTHING — return [] (→ None for a single-object read).
+            # Returning all entities here (query_filter=None) is how an unmatched
+            # read_one accidentally returned a stray context row. Only a genuinely
+            # empty filter dict means "list all".
+            if not parts:
+                if eff_filters:
+                    return []
+                query_filter = None
+            else:
+                query_filter = " and ".join(parts)
 
             entities = table_client.query_entities(query_filter=query_filter)
 
@@ -670,6 +681,10 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
             else:
                 sval = str(ev).replace("'", "''")
                 parts.append(f"{sk} eq '{sval}'")
+        # Same empty-filter contract as _query_raw: filter keys that all resolved
+        # to no condition must match NOTHING, not list the whole table.
+        if not parts and eff_filters:
+            return PageResult(items=[], next_cursor=None, has_more=False)
         query_filter = " and ".join(parts) if parts else None
 
         azure_ct = None

{altcodepro_polydb_python-2.3.24 → altcodepro_polydb_python-2.3.26}/src/polydb/models.py

@@ -323,3 +323,38 @@ class MongoConfig(StorageConfig):
         super().__init__(CloudProvider.MONGODB, name)
         self.mongo_uri = mongo_uri
         self.db_name = db_name
+
+
+class CosmosMongoConfig(MongoConfig):
+    """Azure Cosmos DB via the **MongoDB API**.
+
+    Cosmos-for-Mongo speaks the MongoDB wire protocol, so it needs no adapter of
+    its own — it rides the existing ``MongoDBAdapter`` (and thus the whole polydb
+    stack) unchanged. This gives the best of both: Azure-native, serverless /
+    autoscale, managed billing + monitoring **and** portability — the same app
+    runs on MongoDB Atlas by swapping the connection string.
+
+    Pass a full ``connection_string`` (recommended — works for both RU and vCore),
+    or ``account`` + ``key`` to build the standard Cosmos-for-Mongo (RU) URI.
+    """
+
+    def __init__(
+        self,
+        name: str = "cosmos",
+        *,
+        connection_string: str = "",
+        account: str = "",
+        key: str = "",
+        db_name: str = "",
+        port: int = 10255,
+    ):
+        uri = connection_string
+        if not uri and account and key:
+            uri = (
+                f"mongodb://{account}:{key}@{account}.mongo.cosmos.azure.com:{port}/"
+                f"?ssl=true&replicaSet=globaldb&retrywrites=false"
+                f"&maxIdleTimeMS=120000&appName=@{account}@"
+            )
+        super().__init__(name=name, mongo_uri=uri, db_name=db_name)
+        self.is_cosmos = True
+        self.account = account

altcodepro_polydb_python-2.3.26/src/polydb/utils.py

@@ -0,0 +1,94 @@
+# src/polydb/utils.py
+"""
+Utility functions for validation and logging
+"""
+
+import os
+import re
+import logging
+from typing import Dict, Any
+from .errors import ValidationError
+
+# Loggers already configured by setup_logger(), so per-request adapter
+# construction doesn't reconfigure (and re-clobber) them repeatedly.
+_configured_loggers: set[str] = set()
+
+
+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):
+        raise ValidationError(
+            f"Invalid table name: '{table}'. Only alphanumeric, underscore, and hyphen allowed."
+        )
+    return table
+
+
+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):
+        raise ValidationError(
+            f"Invalid column name: '{column}'. Only alphanumeric and underscore allowed."
+        )
+    return column
+
+
+def validate_columns(data: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Validate all column names in data dictionary
+    """
+    for key in data.keys():
+        validate_column_name(key)
+    return data
+
+
+def setup_logger(name: str, level: int = logging.INFO) -> logging.Logger:
+    """Return a logger, configuring it at most once.
+
+    Adapters are constructed per request, so running the full setup on every
+    call would (a) reset a level the embedding app deliberately set and (b)
+    re-attach a duplicate plain-text handler — which is why "Initialized Azure
+    Queue Storage client" spammed on every request in both plain and JSON form.
+
+    Behaviour:
+    * Idempotent — a given logger name is configured only once.
+    * Host-managed root — when the embedding app owns root logging (it sets the
+      ``ALTCODEPRO_ROOT_LOGGING_MANAGED`` sentinel), polydb attaches NO handler
+      of its own and does NOT force a level. Records propagate to the host's
+      formatter and honour whatever level the host pinned (so the host can
+      quiet noisy adapters). This is the standard "library shouldn't seize
+      logging" contract.
+    * Standalone — with no host managing root, keep the original behaviour:
+      set the level and install a plain StreamHandler.
+    """
+    logger = logging.getLogger(name)
+    if name in _configured_loggers:
+        return logger
+    _configured_loggers.add(name)
+
+    host_managed = bool(os.getenv("ALTCODEPRO_ROOT_LOGGING_MANAGED"))
+    if host_managed:
+        # Let the host own formatting and level; just propagate.
+        return logger
+
+    # Respect a level the caller already pinned explicitly on this logger.
+    if logger.level == logging.NOTSET:
+        logger.setLevel(level)
+
+    # Clear existing handlers to avoid duplication in multiprocess scenarios
+    if logger.handlers:
+        logger.handlers.clear()
+
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+
+    return logger

altcodepro_polydb_python-2.3.26/tests/test_azure_table_empty_filter.py

@@ -0,0 +1,70 @@
+"""Unit tests for the Azure Table empty-filter contract (no Azurite needed).
+
+Contract: a filter that carried keys but resolved to no conditions (e.g. every
+value was None/unresolvable) must match NOTHING — [] for a query, None for
+read_one — never a full-table scan that returns a stray context row. Only a
+genuinely empty filter dict ({}) means "list all".
+
+This is the bug where read_one("Plan", {tier: None}) returned an unrelated User
+row because the empty query_filter scanned the whole table.
+"""
+
+import pytest
+
+pytest.importorskip("azure.data.tables")  # adapter needs the SDK to import
+
+from polydb.adapters.AzureTableStorageAdapter import AzureTableStorageAdapter  # noqa: E402
+
+
+class _Model:
+    __name__ = "Plan"
+
+
+class _FakeTableClient:
+    def __init__(self, entities):
+        self.entities = entities
+        self.calls = []
+
+    def query_entities(self, query_filter=None, **kw):
+        self.calls.append(query_filter)
+        # Emulate Azure Table: a None filter returns EVERY entity.
+        return list(self.entities) if query_filter is None else []
+
+
+_STRAY = [{"PartitionKey": "t1", "RowKey": "user@x.com",
+           "__polydb_model__": "User", "email": "user@x.com"}]
+
+
+def _adapter(fake):
+    adp = object.__new__(AzureTableStorageAdapter)  # bypass live-connection __init__
+    adp._get_table_client = lambda model: fake
+    return adp
+
+
+def test_none_valued_filter_matches_nothing():
+    fake = _FakeTableClient(_STRAY)
+    res = _adapter(fake)._query_raw(_Model, {"tier": None}, 1)
+    assert res == []                      # no stray record
+    assert fake.calls == []               # and no full-table scan was issued
+
+
+def test_empty_filter_lists_all():
+    fake = _FakeTableClient(_STRAY)
+    res = _adapter(fake)._query_raw(_Model, {}, 10)
+    assert fake.calls == [None]           # genuine list-all
+    assert len(res) == 1
+
+
+def test_real_filter_queries_normally():
+    fake = _FakeTableClient(_STRAY)
+    _adapter(fake)._query_raw(_Model, {"tier": "free"}, 1)
+    assert fake.calls and "tier eq 'free'" in (fake.calls[0] or "")
+
+
+def test_query_paged_none_valued_filter_matches_nothing():
+    from polydb.models import PageRequest
+
+    fake = _FakeTableClient(_STRAY)
+    page = _adapter(fake).query_paged(_Model, PageRequest(filters={"tier": None}, limit=10))
+    assert page.items == [] and page.has_more is False
+    assert fake.calls == []               # short-circuited before any scan

altcodepro_polydb_python-2.3.24/src/polydb/utils.py

@@ -1,61 +0,0 @@
-# src/polydb/utils.py
-"""
-Utility functions for validation and logging
-"""
-
-import re
-import logging
-from typing import Dict, Any
-from .errors import ValidationError
-
-
-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):
-        raise ValidationError(
-            f"Invalid table name: '{table}'. Only alphanumeric, underscore, and hyphen allowed."
-        )
-    return table
-
-
-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):
-        raise ValidationError(
-            f"Invalid column name: '{column}'. Only alphanumeric and underscore allowed."
-        )
-    return column
-
-
-def validate_columns(data: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Validate all column names in data dictionary
-    """
-    for key in data.keys():
-        validate_column_name(key)
-    return data
-
-
-def setup_logger(name: str, level: int = logging.INFO) -> logging.Logger:
-    """Setup logger with consistent format"""
-    logger = logging.getLogger(name)
-    logger.setLevel(level)
-    
-    # Clear existing handlers to avoid duplication in multiprocess scenarios
-    if logger.hasHandlers():
-        logger.handlers.clear()
-    
-    handler = logging.StreamHandler()
-    formatter = logging.Formatter(
-        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-    )
-    handler.setFormatter(formatter)
-    logger.addHandler(handler)
-    
-    return logger