dblift 3.3.3__tar.gz → 3.3.4__tar.gz

{dblift-3.3.3 → dblift-3.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.3.3
+Version: 3.3.4
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -115,8 +115,8 @@ Dynamic: license-file
 
 ![Python](https://img.shields.io/badge/Python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/License-Apache--2.0-blue)
-[![Unit Tests](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml)
-[![codecov](https://codecov.io/gh/cmodiano/dblift-oss/graph/badge.svg)](https://codecov.io/gh/cmodiano/dblift-oss)
+[![Unit Tests](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml)
+[![codecov](https://codecov.io/gh/dblift/dblift/graph/badge.svg)](https://codecov.io/gh/dblift/dblift)
 [![Security Policy](https://img.shields.io/badge/Security-Policy-green)](SECURITY.md)
 
 Application code usually has tests, CI pipelines, and pull request review. Database changes often skip one or more of those stages. DBLift is a Python-native migration toolkit that shows you exactly what SQL will run before it runs — and keeps the full migration lifecycle inside your Python workflow. No JVM required.

{dblift-3.3.3 → dblift-3.3.4}/README.md

@@ -6,8 +6,8 @@
 
 ![Python](https://img.shields.io/badge/Python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/License-Apache--2.0-blue)
-[![Unit Tests](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml)
-[![codecov](https://codecov.io/gh/cmodiano/dblift-oss/graph/badge.svg)](https://codecov.io/gh/cmodiano/dblift-oss)
+[![Unit Tests](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml)
+[![codecov](https://codecov.io/gh/dblift/dblift/graph/badge.svg)](https://codecov.io/gh/dblift/dblift)
 [![Security Policy](https://img.shields.io/badge/Security-Policy-green)](SECURITY.md)
 
 Application code usually has tests, CI pipelines, and pull request review. Database changes often skip one or more of those stages. DBLift is a Python-native migration toolkit that shows you exactly what SQL will run before it runs — and keeps the full migration lifecycle inside your Python workflow. No JVM required.

{dblift-3.3.3 → dblift-3.3.4}/core/logger/_formatters.py

@@ -6,6 +6,7 @@ from ``core.logger.log`` for back-compat. JSON / HTML formatters live in
 """
 
 import logging
+import sys
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Dict, Optional
@@ -15,6 +16,51 @@ from core.logger._levels import LogEvent, LogLevel
 _logger = logging.getLogger(__name__)
 
 
+def resolve_dblift_package_version() -> Optional[str]:
+    """Return the installed ``dblift`` distribution version for log banners.
+
+    Prefer ``importlib.metadata`` (correct for wheels and frozen binaries).
+    Avoid walking the filesystem first: under PyInstaller ``Path(__file__)``
+    can resolve to a unrelated ``__init__.py`` and print a stale version.
+    """
+    try:
+        from importlib.metadata import PackageNotFoundError, version
+    except ImportError:  # pragma: no cover - Python <3.8
+        from importlib_metadata import PackageNotFoundError, version  # type: ignore
+
+    try:
+        return version("dblift")
+    except PackageNotFoundError:
+        pass
+    except Exception as e:
+        _logger.debug(f"Could not get dblift version from importlib.metadata: {e}")
+
+    try:
+        import dblift  # type: ignore[import-untyped]
+
+        ver = getattr(dblift, "__version__", None)
+        if ver:
+            return str(ver)
+    except (ImportError, AttributeError):
+        pass
+
+    # Dev checkouts only (skip when frozen — MEIPASS layout is not a git tree)
+    if not getattr(sys, "frozen", False):
+        try:
+            init_file = Path(__file__).parent.parent.parent / "__init__.py"
+            if init_file.exists():
+                with open(init_file, "r", encoding="utf-8") as f:
+                    for line in f:
+                        if line.startswith("__version__"):
+                            parts = line.split("=", 1)
+                            if len(parts) == 2:
+                                return parts[1].strip().strip('"').strip("'")
+        except Exception as e:
+            _logger.debug(f"Could not read version from __init__.py: {e}")
+
+    return None
+
+
 class LogFormatter:
     """Base class for all log formatters."""
 
@@ -74,44 +120,7 @@ class TextFormatter(LogFormatter):
         current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         lines.append(f"Timestamp: {current_time}")
 
-        # Add Dblift version if available
-        # Try multiple methods to get the version, prioritizing source code
-        version = None
-
-        # Method 1: Try to read from source __init__.py file (most reliable for development)
-        try:
-            # Path from core/logger/_formatters.py to root __init__.py: up 3 levels
-            init_file = Path(__file__).parent.parent.parent / "__init__.py"
-            if init_file.exists():
-                with open(init_file, "r", encoding="utf-8") as f:
-                    for line in f:
-                        if line.startswith("__version__"):
-                            # Extract version from: __version__ = "x.y.z"
-                            parts = line.split("=", 1)
-                            if len(parts) == 2:
-                                version = parts[1].strip().strip('"').strip("'")
-                                break
-        except Exception as e:
-            _logger.debug(f"Could not read version from __init__.py: {e}")
-
-        # Method 2: Try to import directly from package (if source is in path)
-        if not version:
-            try:
-                import dblift  # type: ignore[import-untyped]
-
-                version = getattr(dblift, "__version__", None)
-            except (ImportError, AttributeError):
-                pass
-
-        # Method 3: Fallback to pkg_resources (for installed packages)
-        if not version:
-            try:
-                import pkg_resources  # type: ignore[import-untyped]
-
-                version = pkg_resources.get_distribution("dblift").version
-            except Exception as e:
-                _logger.debug(f"Could not get version from pkg_resources: {e}")
-
+        version = resolve_dblift_package_version()
         if version:
             lines.append(f"Dblift version: {version}")
 

{dblift-3.3.3 → dblift-3.3.4}/core/logger/formatters/jsonformatter.py

@@ -128,43 +128,11 @@ class JsonFormatter:
 
     def _get_version_info(self) -> Dict[str, Any]:
         """Return a dict with log_format_version and dblift_version."""
-        dblift_version = None
-
-        # Method 1: Try to read from source __init__.py file (most reliable for development)
-        try:
-            init_file = Path(__file__).parent.parent.parent.parent / "__init__.py"
-            if init_file.exists():
-                with open(init_file, "r", encoding="utf-8") as f:
-                    for line in f:
-                        if line.startswith("__version__"):
-                            parts = line.split("=", 1)
-                            if len(parts) == 2:
-                                dblift_version = parts[1].strip().strip('"').strip("'")
-                                break
-        except Exception as e:
-            _logger.debug(f"Could not read version from __init__.py: {e}")
-
-        # Method 2: Try to import directly from package (if source is in path)
-        if not dblift_version:
-            try:
-                import dblift  # type: ignore[import-untyped]
-
-                dblift_version = getattr(dblift, "__version__", None)
-            except (ImportError, AttributeError):
-                pass
-
-        # Method 3: Fallback to pkg_resources (for installed packages)
-        if not dblift_version:
-            try:
-                import pkg_resources  # type: ignore[import-untyped]
-
-                dblift_version = pkg_resources.get_distribution("dblift").version
-            except Exception as e:
-                _logger.debug(f"Could not get version from pkg_resources: {e}")
+        from core.logger._formatters import resolve_dblift_package_version
 
         return {
             "log_format_version": "1.0",
-            "dblift_version": dblift_version,
+            "dblift_version": resolve_dblift_package_version(),
         }
 
     def _build_time_metadata(self, result: OperationResult) -> Dict[str, Any]:

{dblift-3.3.3 → dblift-3.3.4}/db/plugins/duckdb/provider.py

@@ -27,12 +27,180 @@ class DuckDBProvider(SqlAlchemyProvider):
     def execute_statement(
         self, sql: str, schema: Optional[str] = None, params: Optional[List[Any]] = None
     ) -> int:
-        """Execute a SQL statement, optionally preparing the schema first."""
+        """Execute a SQL statement, optionally preparing the schema first.
+
+        DuckDB/SQLAlchemy often reports ``rowcount == -1`` for DML. For single
+        INSERT/UPDATE/DELETE statements without parameters, append
+        ``RETURNING 1`` so callers (e.g. data corrections ``expect=N``) get a
+        real affected-row count.
+        """
         if schema:
             self.create_schema_if_not_exists(schema)
             self.set_current_schema(schema)
+
+        if params is None:
+            counted = self._try_dml_rowcount_via_returning(sql)
+            if counted is not None:
+                return counted
         return super().execute_statement(sql, schema=schema, params=params)
 
+    def _try_dml_rowcount_via_returning(self, sql: str) -> Optional[int]:
+        """Return affected-row count using RETURNING, or None if not applicable.
+
+        Returns None only when the statement is not rewritten (caller falls back
+        to the default path). Once execution is attempted, errors propagate —
+        do not re-run a failed statement via super() (that masks the root cause
+        as a follow-on \"transaction is aborted\" error).
+        """
+        stripped = self._strip_sql_comments(sql.strip()).rstrip(";").strip()
+        if not stripped:
+            return None
+        # Already has a top-level RETURNING clause — do not double-append
+        if self._has_top_level_keyword(stripped, "RETURNING"):
+            return None
+        # Normalize whitespace for statement-type checks only
+        upper = " ".join(stripped.upper().split())
+        if not (
+            upper.startswith("INSERT ")
+            or upper.startswith("UPDATE ")
+            or upper.startswith("DELETE ")
+        ):
+            return None
+
+        # Multi-statement scripts: leave to super (no silent rewrite)
+        if self._has_top_level_semicolon(stripped):
+            return None
+
+        rewritten = f"{stripped} RETURNING 1"
+        conn = self._ensure_connection()
+        driver_sql = self._escape_driver_percent_literals(rewritten, conn.dialect.paramstyle)
+        result = conn.exec_driver_sql(driver_sql)
+        rows = result.fetchall()
+        if self._tx is None and not getattr(self, "_external_connection", False):
+            conn.commit()
+        return len(rows)
+
+    @staticmethod
+    def _strip_sql_comments(sql: str) -> str:
+        """Remove ``--`` / ``/* */`` comments (and blank lines).
+
+        Strips leading directives, full-line mid-statement comments, and
+        trailing *inline* ``--`` on DML lines so an appended ``RETURNING 1``
+        is not commented out and keyword detection is not confused by the
+        word ``returning`` inside comments.
+        """
+        s = sql.lstrip()
+        # Leading block comments only (line comments handled per-line below)
+        while s.startswith("/*"):
+            end = s.find("*/")
+            if end < 0:
+                return ""
+            s = s[end + 2 :].lstrip()
+
+        kept: List[str] = []
+        for raw in s.splitlines():
+            line = DuckDBProvider._strip_inline_trailing_comment(raw)
+            if not line or line.lstrip().startswith("--"):
+                continue
+            # Drop leftover full-line block comments
+            if line.lstrip().startswith("/*") and line.rstrip().endswith("*/"):
+                continue
+            kept.append(line)
+        return "\n".join(kept).strip()
+
+    @staticmethod
+    def _strip_inline_trailing_comment(line: str) -> str:
+        """Strip trailing ``--`` or ``/* … */`` outside string/identifier quotes."""
+        in_single = in_double = False
+        i = 0
+        n = len(line)
+        cut: Optional[int] = None
+        while i < n:
+            ch = line[i]
+            if ch == "'" and not in_double:
+                if in_single and i + 1 < n and line[i + 1] == "'":
+                    i += 2
+                    continue
+                in_single = not in_single
+            elif ch == '"' and not in_single:
+                if in_double and i + 1 < n and line[i + 1] == '"':
+                    i += 2
+                    continue
+                in_double = not in_double
+            elif not in_single and not in_double:
+                if ch == "-" and i + 1 < n and line[i + 1] == "-":
+                    cut = i
+                    break
+                if ch == "/" and i + 1 < n and line[i + 1] == "*":
+                    # Only treat as trailing comment if it runs to end of line
+                    close = line.find("*/", i + 2)
+                    if close >= 0 and line[close + 2 :].strip() == "":
+                        cut = i
+                        break
+            i += 1
+        if cut is not None:
+            return line[:cut].rstrip()
+        return line.rstrip()
+
+    @staticmethod
+    def _has_top_level_semicolon(sql: str) -> bool:
+        """True if ``sql`` contains a semicolon outside string/identifier quotes."""
+        in_single = in_double = False
+        i = 0
+        n = len(sql)
+        while i < n:
+            ch = sql[i]
+            if ch == "'" and not in_double:
+                # SQL escaped single quote ''
+                if in_single and i + 1 < n and sql[i + 1] == "'":
+                    i += 2
+                    continue
+                in_single = not in_single
+            elif ch == '"' and not in_single:
+                if in_double and i + 1 < n and sql[i + 1] == '"':
+                    i += 2
+                    continue
+                in_double = not in_double
+            elif ch == ";" and not in_single and not in_double:
+                return True
+            i += 1
+        return False
+
+    @staticmethod
+    def _has_top_level_keyword(sql: str, keyword: str) -> bool:
+        """True if ``keyword`` appears as a top-level token outside quotes.
+
+        Used instead of a raw substring search so values like
+        ``SET note = ' returning '`` or mid-line comments mentioning
+        ``returning`` do not skip the RETURNING rewrite.
+        """
+        kw = keyword.upper()
+        kw_len = len(kw)
+        in_single = in_double = False
+        i = 0
+        n = len(sql)
+        while i < n:
+            ch = sql[i]
+            if ch == "'" and not in_double:
+                if in_single and i + 1 < n and sql[i + 1] == "'":
+                    i += 2
+                    continue
+                in_single = not in_single
+            elif ch == '"' and not in_single:
+                if in_double and i + 1 < n and sql[i + 1] == '"':
+                    i += 2
+                    continue
+                in_double = not in_double
+            elif not in_single and not in_double:
+                if sql[i : i + kw_len].upper() == kw:
+                    before_ok = i == 0 or not (sql[i - 1].isalnum() or sql[i - 1] == "_")
+                    after = i + kw_len
+                    after_ok = after >= n or not (sql[after].isalnum() or sql[after] == "_")
+                    if before_ok and after_ok:
+                        return True
+            i += 1
+        return False
+
     def create_schema_if_not_exists(self, schema: str) -> None:
         """Create a DuckDB schema if it is missing."""
         rows = self.execute_query(

{dblift-3.3.3 → dblift-3.3.4}/dblift.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dblift
-Version: 3.3.3
+Version: 3.3.4
 Summary: A database migration tool that supports multiple databases with native Python drivers
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
@@ -115,8 +115,8 @@ Dynamic: license-file
 
 ![Python](https://img.shields.io/badge/Python-3.11%2B-blue)
 ![License](https://img.shields.io/badge/License-Apache--2.0-blue)
-[![Unit Tests](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/cmodiano/dblift-oss/actions/workflows/unit-tests.yml)
-[![codecov](https://codecov.io/gh/cmodiano/dblift-oss/graph/badge.svg)](https://codecov.io/gh/cmodiano/dblift-oss)
+[![Unit Tests](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml/badge.svg)](https://github.com/dblift/dblift/actions/workflows/unit-tests.yml)
+[![codecov](https://codecov.io/gh/dblift/dblift/graph/badge.svg)](https://codecov.io/gh/dblift/dblift)
 [![Security Policy](https://img.shields.io/badge/Security-Policy-green)](SECURITY.md)
 
 Application code usually has tests, CI pipelines, and pull request review. Database changes often skip one or more of those stages. DBLift is a Python-native migration toolkit that shows you exactly what SQL will run before it runs — and keeps the full migration lifecycle inside your Python workflow. No JVM required.

{dblift-3.3.3 → dblift-3.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dblift"
-version = "3.3.3"
+version = "3.3.4"
 description = "A database migration tool that supports multiple databases with native Python drivers"
 readme = "README.md"
 requires-python = ">=3.11"