altcodepro-polydb-python 2.3.15__tar.gz → 2.3.17__tar.gz

{altcodepro_polydb_python-2.3.15/src/altcodepro_polydb_python.egg-info → altcodepro_polydb_python-2.3.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.3.15
+Version: 2.3.17
 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.15 → altcodepro_polydb_python-2.3.17}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "altcodepro-polydb-python"
-version = "2.3.15"
+version = "2.3.17"
 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.15 → altcodepro_polydb_python-2.3.17/src/altcodepro_polydb_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: altcodepro-polydb-python
-Version: 2.3.15
+Version: 2.3.17
 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.15 → altcodepro_polydb_python-2.3.17}/src/polydb/adapters/AzureTableStorageAdapter.py

@@ -31,6 +31,13 @@ _BASE64_RE = re.compile(r"^[A-Za-z0-9+/]*={0,2}$")
 # ensures model isolation across the same table
 _MODEL_FIELD = "__polydb_model__"
 
+# ─── NEW: HTTP transport tuning ──────────────────────────────────────────────
+# Default Azure SDK has no read timeout. A sync call from an async event loop
+# can park forever. These are overridable via env so ops can tune per env.
+_CONNECT_TIMEOUT = float(os.getenv("AZURE_TABLE_CONNECT_TIMEOUT", "10"))
+_READ_TIMEOUT = float(os.getenv("AZURE_TABLE_READ_TIMEOUT", "30"))
+_RETRY_TOTAL = int(os.getenv("AZURE_TABLE_RETRY_TOTAL", "3"))
+
 logging.getLogger("azure").setLevel(logging.ERROR)
 
 
@@ -43,6 +50,15 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
     - Blob overflow for entities > 1MB
     - Model isolation using __polydb_model__
     - Always returns id (derived from RowKey if missing)
+
+    Performance / safety guarantees:
+    - One TableServiceClient per adapter instance.
+    - One TableClient cached per table for the adapter's lifetime.
+    - create_table_if_not_exists runs ONCE per table per adapter lifetime.
+    - Explicit connect/read timeouts on the HTTP transport so a slow or
+      mis-configured endpoint fails fast instead of hanging the caller.
+    - No mutation of instance state inside read/write paths (was the
+      previous `self._table_client = ...` race hazard).
     """
 
     AZURE_TABLE_MAX_SIZE = 60 * 1024  # 1MB
@@ -67,6 +83,16 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
         self._client: Any = None
         self._blob_service = None
         self._client_lock = threading.Lock()
+
+        # ─── NEW: caches ────────────────────────────────────────────────────
+        # _ensured_tables: table names for which create_table_if_not_exists
+        # has already succeeded on this adapter instance.
+        # _table_clients_cache: TableClient handles by table name.
+        # _cache_lock: protects both caches from concurrent get/put.
+        self._ensured_tables: set[str] = set()
+        self._table_clients_cache: Dict[str, Any] = {}
+        self._cache_lock = threading.Lock()
+
         self._initialize_client()
 
     def _initialize_client(self):
@@ -76,9 +102,22 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
             with self._client_lock:
                 if not self._client:
-                    self._client = TableServiceClient.from_connection_string(self.connection_string)
+                    # ─── CHANGED: explicit transport timeouts + retry budget ──
+                    # connection_timeout / read_timeout are honoured by the
+                    # azure-core RequestsTransport. retry_total caps the
+                    # SDK's built-in retry policy so a hard failure surfaces
+                    # in seconds, not minutes.
+                    self._client = TableServiceClient.from_connection_string(
+                        self.connection_string,
+                        connection_timeout=_CONNECT_TIMEOUT,
+                        read_timeout=_READ_TIMEOUT,
+                        retry_total=_RETRY_TOTAL,
+                    )
                     self._blob_service = BlobServiceClient.from_connection_string(
-                        self.connection_string
+                        self.connection_string,
+                        connection_timeout=_CONNECT_TIMEOUT,
+                        read_timeout=_READ_TIMEOUT,
+                        retry_total=_RETRY_TOTAL,
                     )
 
                     try:
@@ -379,22 +418,50 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
     def _get_table_client(self, model: type):
         """
-        Get table client + automatically create the table if it doesn't exist.
-        This is the recommended pattern for Azure Table Storage.
+        Return a TableClient for the model, ensuring the table exists.
+
+        ─── CHANGED ────────────────────────────────────────────────────────
+        Both the table existence check AND the TableClient handle are now
+        cached per adapter instance. The previous version ran
+        create_table_if_not_exists on every read/write/query/delete — a
+        hot-loop seed of 100 records produced ~300 unnecessary network
+        round-trips. Now:
+
+          - First call for a table:  1 HTTP call (create_table_if_not_exists)
+                                     + 1 cheap local TableClient construction.
+          - All subsequent calls:    O(1) dict lookup, no network.
         """
         table_name = self._get_table_name(model)
 
-        try:
-            # This is the key call - creates the table if missing
-            self._client.create_table_if_not_exists(table_name)
-            logger.info(f"✅ Azure Table ensured/created: {table_name}")
-        except Exception as e:
-            # TableAlreadyExists is normal and safe to ignore
-            if "TableAlreadyExists" not in str(e) and "already exists" not in str(e).lower():
-                logger.warning(f"Could not create table {table_name}: {e}")
+        # Fast path: already ensured + client cached.
+        cached = self._table_clients_cache.get(table_name)
+        if cached is not None and table_name in self._ensured_tables:
+            return cached
+
+        with self._cache_lock:
+            # Re-check inside the lock to avoid duplicate ensures under
+            # concurrent first-touch.
+            cached = self._table_clients_cache.get(table_name)
+            already_ensured = table_name in self._ensured_tables
+
+            if not already_ensured:
+                try:
+                    self._client.create_table_if_not_exists(table_name)
+                    logger.info(f"✅ Azure Table ensured/created: {table_name}")
+                except Exception as e:
+                    # TableAlreadyExists is normal and safe to ignore
+                    msg = str(e)
+                    if "TableAlreadyExists" not in msg and "already exists" not in msg.lower():
+                        logger.warning(f"Could not create table {table_name}: {e}")
+                # Mark as ensured regardless — either it exists now or we
+                # logged the failure; we won't retry on every op.
+                self._ensured_tables.add(table_name)
+
+            if cached is None:
+                cached = self._client.get_table_client(table_name=table_name)
+                self._table_clients_cache[table_name] = cached
 
-        # Now return the client
-        return self._client.get_table_client(table_name=table_name)
+            return cached
 
     def _restore_overflow_properties(self, entity_dict: JsonDict) -> JsonDict:
         """Detect and restore any large properties stored in Blob Storage.
@@ -456,7 +523,12 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
     def _put_raw(self, model: type, pk: str, rk: str, data: JsonDict) -> JsonDict:
         try:
-            self._table_client = self._get_table_client(model)
+            # ─── CHANGED: local variable, not self._table_client ────────────
+            # The old pattern `self._table_client = self._get_table_client(...)`
+            # was a race hazard: two concurrent writes on different models
+            # could swap each other's client mid-call. Local variable is
+            # safe and identical in cost since the client is now cached.
+            table_client = self._get_table_client(model)
             safe_pk = self._sanitize_pk_rk(pk)
             safe_rk = self._sanitize_pk_rk(rk)
             # Pack entity (encoded for Azure Table)
@@ -506,8 +578,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
                 else:
                     reference_entity[k] = v
 
-            self._table_client = self._get_table_client(model)
-            self._table_client.upsert_entity(reference_entity)
+            table_client.upsert_entity(reference_entity)
 
             restored = self._unpack_entity(entity)
             restored["id"] = safe_rk
@@ -525,9 +596,10 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
         try:
             safe_pk = self._sanitize_pk_rk(pk)
             safe_rk = self._sanitize_pk_rk(rk)
-            self._table_client = self._get_table_client(model)
+            # ─── CHANGED: local variable ────────────────────────────────────
+            table_client = self._get_table_client(model)
 
-            entity = self._table_client.get_entity(safe_pk, safe_rk)
+            entity = table_client.get_entity(safe_pk, safe_rk)
             entity_dict = dict(entity)
 
             # Model isolation check
@@ -553,7 +625,8 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
         self, model: type, filters: Dict[str, Any], limit: Optional[int]
     ) -> List[JsonDict]:
         try:
-            self._table_client = self._get_table_client(model)
+            # ─── CHANGED: local variable ────────────────────────────────────
+            table_client = self._get_table_client(model)
 
             # Build query filter (your original logic kept unchanged)
             eff_filters = dict(filters or {})
@@ -590,7 +663,7 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
 
             query_filter = " and ".join(parts) if parts else None
 
-            entities = self._table_client.query_entities(query_filter=query_filter)
+            entities = table_client.query_entities(query_filter=query_filter)
 
             results: List[JsonDict] = []
             count = 0
@@ -620,13 +693,14 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
     @retry(max_attempts=3, delay=1.0, exceptions=(NoSQLError,))
     def _delete_raw(self, model: type, pk: str, rk: str, etag: Optional[str]) -> JsonDict:
         try:
-            self._table_client = self._get_table_client(model)
+            # ─── CHANGED: local variable ────────────────────────────────────
+            table_client = self._get_table_client(model)
             safe_pk = self._sanitize_pk_rk(pk)
             safe_rk = self._sanitize_pk_rk(rk)
 
             # read to check model + overflow
             try:
-                entity = self._table_client.get_entity(safe_pk, safe_rk)
+                entity = table_client.get_entity(safe_pk, safe_rk)
                 entity_dict = dict(entity)
 
                 if entity_dict.get(_MODEL_FIELD) != model.__qualname__:
@@ -639,8 +713,39 @@ class AzureTableStorageAdapter(NoSQLKVAdapter):
             except Exception:
                 pass
 
-            self._table_client.delete_entity(safe_pk, safe_rk, etag=etag)
+            table_client.delete_entity(safe_pk, safe_rk, etag=etag)
             return {"deleted": True, "PartitionKey": safe_pk, "RowKey": safe_rk, "id": safe_rk}
 
         except Exception as e:
             raise NoSQLError(f"Azure Table delete failed: {str(e)}")
+
+    # -----------------------------
+    # Lifecycle
+    # -----------------------------
+    def close(self) -> None:
+        """Close cached clients. Safe to call multiple times.
+
+        ─── NEW ─────────────────────────────────────────────────────────────
+        Hook this into PolyDB shutdown so HTTP sessions don't leak on
+        application exit. Caches are cleared so a re-init starts clean.
+        """
+        with self._cache_lock:
+            for tc in self._table_clients_cache.values():
+                try:
+                    tc.close()
+                except Exception:
+                    pass
+            self._table_clients_cache.clear()
+            self._ensured_tables.clear()
+
+        with self._client_lock:
+            if self._client is not None:
+                try:
+                    self._client.close()
+                except Exception:
+                    pass
+            if self._blob_service is not None:
+                try:
+                    self._blob_service.close()
+                except Exception:
+                    pass

{altcodepro_polydb_python-2.3.15 → altcodepro_polydb_python-2.3.17}/src/polydb/adapters/PostgreSQLAdapter.py

@@ -8,6 +8,9 @@ import hashlib
 from contextlib import contextmanager
 import json
 from datetime import datetime, date
+
+import psycopg2.extensions
+
 from ..errors import DatabaseError, ConnectionError
 from ..retry import retry
 from ..utils import validate_table_name, validate_column_name
@@ -32,13 +35,54 @@ class PostgreSQLAdapter:
         self._lock = threading.Lock()
         self._initialize_pool()
 
+    # ---------------------------------------------------------------------
+    # CONNECTION HYGIENE HELPERS
+    # ---------------------------------------------------------------------
+
+    def _is_idle(self, conn) -> bool:
+        """True iff the connection is not inside a (possibly aborted) transaction."""
+        try:
+            return conn.info.transaction_status == psycopg2.extensions.TRANSACTION_STATUS_IDLE
+        except Exception:
+            return False
+
+    def _drain_transaction(self, conn) -> None:
+        """Force the connection back to IDLE so it's safe to change session
+        settings (e.g. autocommit). Safe to call when already idle."""
+        if self._is_idle(conn):
+            return
+        try:
+            conn.rollback()
+        except Exception:
+            # Last resort: caller will surface a real error on next use.
+            pass
+
     def _ping_connection(self, conn) -> bool:
-        """Test if connection is still alive"""
+        """Test if connection is still alive.
+
+        psycopg2 auto-starts a transaction on the first statement after
+        commit/rollback, so we MUST rollback after the SELECT 1 — otherwise
+        the next caller inherits an active transaction and any attempt to
+        toggle autocommit raises ``set_session cannot be used inside a
+        transaction``.
+        """
         try:
             with conn.cursor() as cur:
                 cur.execute("SELECT 1")
+            # Clean up the auto-started transaction so the connection
+            # leaves this method in IDLE state.
+            try:
+                conn.rollback()
+            except Exception:
+                pass
             return True
         except Exception:
+            # Best-effort cleanup on a failed ping. The connection is
+            # almost certainly broken; the caller will close it.
+            try:
+                conn.rollback()
+            except Exception:
+                pass
             return False
 
     def _initialize_pool(self):
@@ -79,11 +123,15 @@ class PostgreSQLAdapter:
         try:
             conn = self._pool.getconn()  # type: ignore
 
-            # Critical: Validate connection for Azure transient issues
+            # Critical: Validate connection for Azure transient issues.
+            # _ping_connection rolls back its own SELECT 1 so the connection
+            # is returned to callers in IDLE state.
             if not self._ping_connection(conn):
                 self.logger.warning("Stale connection detected from pool, closing and retrying")
                 self._pool.putconn(conn, close=True)  # type: ignore
                 conn = self._pool.getconn()  # type: ignore # Get fresh connection
+                # New connection might still have been used before — make sure it's idle.
+                self._drain_transaction(conn)
 
             return conn
 
@@ -92,7 +140,13 @@ class PostgreSQLAdapter:
             raise ConnectionError(f"Could not obtain database connection: {e}") from e
 
     def _return_connection(self, conn: Any):
+        """Return a connection to the pool, defensively draining any
+        leftover transaction state. Belt-and-suspenders: every operation
+        in this adapter already commits/rolls-back before returning, but
+        if any path ever forgets, the pool still gets a clean connection.
+        """
         if self._pool and conn:
+            self._drain_transaction(conn)
             self._pool.putconn(conn)
 
     # ---------------------------------------------------------------------
@@ -110,8 +164,16 @@ class PostgreSQLAdapter:
             self._initialize_pool()
 
     def begin_transaction(self) -> Any:
-        """Begin a transaction and return the connection handle."""
+        """Begin a transaction and return the connection handle.
+
+        Defensively drains any leftover transaction state on the pooled
+        connection before toggling autocommit. Without this, a connection
+        that's still in TRANSACTION_STATUS_INTRANS (from a previous user
+        or from the pool's connection check) causes psycopg2 to raise
+        ``set_session cannot be used inside a transaction``.
+        """
         conn = self._get_connection()
+        self._drain_transaction(conn)
         conn.autocommit = False
         return conn
 
@@ -318,8 +380,16 @@ class PostgreSQLAdapter:
             results = [self._deserialize_row(dict(zip(columns, row))) for row in cursor.fetchall()]
             cursor.close()
 
+            if own_conn:
+                conn.commit()
+
             return results
         except Exception as e:
+            if own_conn:
+                try:
+                    conn.rollback()
+                except Exception:
+                    pass
             raise DatabaseError(f"Select failed: {str(e)}")
         finally:
             if own_conn and conn:

{altcodepro_polydb_python-2.3.15 → altcodepro_polydb_python-2.3.17}/src/polydb/databaseFactory.py

@@ -34,7 +34,7 @@ from .audit.manager import AuditManager
 from .audit.context import AuditContext
 from .query import Operator, QueryBuilder
 from .cloudDatabaseFactory import CloudDatabaseFactory
-
+import re as _re
 logger = logging.getLogger(__name__)
 
 _DEFAULT_RETRY = retry(
@@ -43,7 +43,32 @@ _DEFAULT_RETRY = retry(
     reraise=True,
 )
 
+_UNIQUE_VIOLATION_MARKERS = (
+    "23505",                                 # Postgres SQLSTATE
+    "duplicate key value violates",          # Postgres message
+    "unique constraint",                      # Postgres, generic
+    "UniqueViolation",                        # psycopg / SQLAlchemy class name
+    "Duplicate entry",                        # MySQL
+    "UNIQUE constraint failed",               # SQLite
+)
+_UNIQUE_KEY_RE = _re.compile(r"Key \(([^)]+)\)=")
+
+
+def _is_unique_violation(exc: BaseException) -> bool:
+    s = str(exc)
+    return any(m in s for m in _UNIQUE_VIOLATION_MARKERS)
+
 
+def _parse_unique_violation_columns(exc: BaseException) -> list[str]:
+    """
+    Pull the conflicting column names out of a Postgres unique-violation error.
+    Postgres formats them as:  Key (col1, col2)=(val1, val2) already exists.
+    Returns [] if the message doesn't carry that detail.
+    """
+    m = _UNIQUE_KEY_RE.search(str(exc))
+    if not m:
+        return []
+    return [c.strip() for c in m.group(1).split(",") if c.strip()]
 # ═══════════════════════════════════════════════════════════════════════════════
 # ENGINE CONFIG
 # ═══════════════════════════════════════════════════════════════════════════════
@@ -359,9 +384,7 @@ class DatabaseFactory:
             logger.error("Audit recording failed: %s", exc)
 
     def _run(self, fn: Callable[[], Any]) -> Any:
-        if not self._enable_retries:
-            return fn()
-        return _DEFAULT_RETRY(fn)()
+        return fn()
 
     def _is_sql(self, meta: ModelMeta, override: Optional[EngineOverride] = None) -> bool:
         if override and override.force_sql:
@@ -398,14 +421,32 @@ class DatabaseFactory:
         def _op() -> JsonDict:
             nonlocal after_plain, success, entity_id
             if self._is_sql(meta, engine_override):
-                result = adapters.sql.insert(meta.table, data)
+                try:
+                    result = adapters.sql.insert(meta.table, data)
+                except Exception as exc:
+                    if not _is_unique_violation(exc):
+                        raise
+                    # Half-ran scenario / re-activation / replay. The record already
+                    # exists with these unique-key columns. Preserve idempotent
+                    # "create or update" semantics by routing to UPDATE keyed on the
+                    # exact columns that conflicted (parsed from the Postgres error).
+                    conflict_cols = _parse_unique_violation_columns(exc)
+                    if not conflict_cols or not all(c in data for c in conflict_cols):
+                        # Can't determine the conflict — re-raise so the caller sees it.
+                        raise
+                    where = {c: data[c] for c in conflict_cols}
+                    logger.warning(
+                        "insert %s hit unique violation on %s — falling through to update",
+                        meta.table, conflict_cols,
+                    )
+                    # Drop the conflict columns from the UPDATE SET clause — they're
+                    # already the matching key.
+                    update_data = {k: v for k, v in data.items() if k not in conflict_cols}
+                    result = adapters.sql.update(meta.table, where, update_data)
             else:
                 result = adapters.nosql.put(
-                    (
-                        model
-                        if isinstance(model, type)
-                        else type(name, (), {"__polydb__": meta.__dict__})
-                    ),
+                    model if isinstance(model, type)
+                        else type(name, (), {"__polydb__": meta.__dict__}),
                     data,
                 )
             entity_id = result.get("id")
@@ -416,7 +457,6 @@ class DatabaseFactory:
             if self._enable_cache and self._cache:
                 self._cache.invalidate(name)
             return after_plain
-
         try:
             monitor = (
                 PerformanceMonitor(self.metrics, "create", name, None) if self.metrics else None

{altcodepro_polydb_python-2.3.15 → altcodepro_polydb_python-2.3.17}/src/polydb/retry.py

@@ -3,10 +3,33 @@
 Retry logic with exponential backoff and metrics hooks
 """
 
+import functools
 import time
 import logging
 from functools import wraps
 from typing import Callable, Optional, Tuple, Type
+logger = logging.getLogger(__name__)
+
+_NON_RETRYABLE_MARKERS = (
+    "23505",                          # Postgres unique_violation
+    "23503",                          # Postgres foreign_key_violation
+    "23502",                          # Postgres not_null_violation
+    "23514",                          # Postgres check_violation
+    "duplicate key value violates",
+    "unique constraint",
+    "UniqueViolation",
+    "Duplicate entry",
+    "UNIQUE constraint failed",
+    "PropertyValueTooLarge",
+    "ResourceNotFound",
+    "InvalidArgument",
+    "AuthenticationFailed",
+)
+
+
+def _is_non_retryable(exc: BaseException) -> bool:
+    s = str(exc)
+    return any(m in s for m in _NON_RETRYABLE_MARKERS)
 
 
 # Metrics hooks for enterprise monitoring