ducpy 3.3.7__tar.gz → 3.3.8__tar.gz

{ducpy-3.3.7 → ducpy-3.3.8}/Cargo.lock

@@ -412,7 +412,7 @@ dependencies = [
 
 [[package]]
 name = "ducpy-native"
-version = "3.3.7"
+version = "3.3.8"
 dependencies = [
  "duc",
  "pyo3",

{ducpy-3.3.7 → ducpy-3.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducpy
-Version: 3.3.7
+Version: 3.3.8
 Classifier: License :: OSI Approved :: MIT License
 Requires-Dist: nanoid>=2.0.0
 License-File: LICENSE

{ducpy-3.3.7 → ducpy-3.3.8}/packages/ducpy/crate/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "ducpy-native"
-version = "3.3.7"
+version = "3.3.8"
 edition = "2021"
 description = "Python native extension for the duc file format (used by ducpy)"
 publish = false

{ducpy-3.3.7 → ducpy-3.3.8}/packages/ducpy/crate/src/lib.rs

@@ -58,6 +58,45 @@ fn list_external_files(py: Python<'_>, buf: &[u8]) -> PyResult<PyObject> {
         .map_err(|e| pyo3::exceptions::PyValueError::new_err(format!("{e}")))
 }
 
+/// Returns the current DUC schema version as a semver string (e.g. "3.0.0").
+#[pyfunction]
+fn get_schema_version() -> PyResult<String> {
+    Ok(duc::db::bootstrap::CURRENT_SCHEMA_VERSION_SEMVER.into())
+}
+
+/// Returns the raw integer schema version (e.g. 3000000).
+#[pyfunction]
+fn get_schema_version_int() -> PyResult<i64> {
+    Ok(duc::db::bootstrap::current_schema_version_int())
+}
+
+/// Returns the canonical `duc.sql` schema string.
+#[pyfunction]
+fn get_duc_schema_sql() -> PyResult<String> {
+    Ok(duc::db::bootstrap::DUC_SCHEMA_SQL.into())
+}
+
+/// Returns the `version_control.sql` schema string.
+#[pyfunction]
+fn get_version_control_schema_sql() -> PyResult<String> {
+    Ok(duc::db::bootstrap::VERSION_CONTROL_SCHEMA_SQL.into())
+}
+
+/// Returns the `search.sql` schema string.
+#[pyfunction]
+fn get_search_schema_sql() -> PyResult<String> {
+    Ok(duc::db::bootstrap::SEARCH_SCHEMA_SQL.into())
+}
+
+/// Returns all migrations as a list of `(from_version, to_version, sql)` tuples.
+#[pyfunction]
+fn get_migrations(_py: Python<'_>) -> PyResult<Vec<(i64, i64, String)>> {
+    Ok(duc::db::bootstrap::MIGRATIONS
+        .iter()
+        .map(|(f, t, sql)| (*f, *t, sql.to_string()))
+        .collect())
+}
+
 /// Native duc file format operations.
 #[pymodule]
 fn ducpy_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
@@ -66,5 +105,11 @@ fn ducpy_native(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(serialize_duc, m)?)?;
     m.add_function(wrap_pyfunction!(get_external_file, m)?)?;
     m.add_function(wrap_pyfunction!(list_external_files, m)?)?;
+    m.add_function(wrap_pyfunction!(get_schema_version, m)?)?;
+    m.add_function(wrap_pyfunction!(get_schema_version_int, m)?)?;
+    m.add_function(wrap_pyfunction!(get_duc_schema_sql, m)?)?;
+    m.add_function(wrap_pyfunction!(get_version_control_schema_sql, m)?)?;
+    m.add_function(wrap_pyfunction!(get_search_schema_sql, m)?)?;
+    m.add_function(wrap_pyfunction!(get_migrations, m)?)?;
     Ok(())
 }

{ducpy-3.3.7 → ducpy-3.3.8}/packages/ducrs/Cargo.toml

@@ -13,9 +13,7 @@ include = [
   "Cargo.toml",
   "README.md",
   "LICENSE",
-  "schema/duc.sql",
-  "schema/version_control.sql",
-  "schema/search.sql",
+  "schema/*.sql",
   "schema/migrations/*.sql",
 ]
 

{ducpy-3.3.7 → ducpy-3.3.8}/packages/ducrs/build.rs

@@ -25,6 +25,7 @@ fn decode_user_version_to_semver(user_version: u32) -> String {
 }
 
 fn find_schema_dir(manifest_dir: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    // 1. Explicit override.
     if let Ok(path) = env::var("DUC_SCHEMA_DIR") {
         let candidate = PathBuf::from(path);
         if candidate.join("duc.sql").is_file() {
@@ -32,22 +33,25 @@ fn find_schema_dir(manifest_dir: &Path) -> Result<PathBuf, Box<dyn std::error::E
         }
     }
 
-    for ancestor in manifest_dir.ancestors() {
-        for candidate in [
-            ancestor.join("schema"),
-            ancestor.join("packages").join("ducpy").join("schema"),
-        ] {
-            if candidate.join("duc.sql").is_file() {
-                return Ok(candidate);
-            }
-        }
+    // 2. Schema inside the crate directory (symlink in dev, real files after
+    //    `cargo publish` dereferences the symlink into the tarball).
+    let bundled = manifest_dir.join("schema");
+    if bundled.join("duc.sql").is_file() {
+        return Ok(bundled);
     }
 
-    Err(format!(
-        "Could not locate schema/duc.sql from {}. Set DUC_SCHEMA_DIR to a directory containing duc.sql.",
-        manifest_dir.display()
-    )
-    .into())
+    // 3. Local workspace: walk up to the repo root `schema/`.
+    let source = manifest_dir
+        .ancestors()
+        .map(|a| a.join("schema"))
+        .find(|p| p.join("duc.sql").is_file())
+        .ok_or_else(|| {
+            format!(
+                "Could not locate schema/duc.sql from {}. Set DUC_SCHEMA_DIR to a directory containing duc.sql.",
+                manifest_dir.display()
+            )
+        })?;
+    Ok(source)
 }
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
@@ -106,7 +110,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let mut reg = String::from(
         "// Auto-generated by build.rs — do not edit by hand.\n\
          // Each entry: (from_version, to_version, sql).\n\
-         pub(crate) static MIGRATIONS: &[(i64, i64, &str)] = &[\n",
+         pub static MIGRATIONS: &[(i64, i64, &str)] = &[\n",
     );
     for (from, to, sql) in &migrations {
         reg.push_str(&format!("    ({from}i64, {to}i64, \""));
@@ -149,4 +153,4 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     println!("cargo:rerun-if-changed=build.rs");
 
     Ok(())
-} 
+}

{ducpy-3.3.7 → ducpy-3.3.8}/packages/ducrs/src/db/bootstrap.rs

@@ -32,10 +32,24 @@ const CURRENT_VERSION: i64 = {
     val
 };
 
+/// Runtime accessor for the compile-time schema version integer.
+pub fn current_schema_version_int() -> i64 {
+    CURRENT_VERSION
+}
+
 // Migration registry auto-generated by build.rs from `schema/migrations/*.sql`.
 // Each entry is (from_version, to_version, sql). Sorted ascending by from_version.
 include!(concat!(env!("OUT_DIR"), "/migrations_registry.rs"));
 
+// ── Public re-exports for downstream crates ─────────────────────────────
+
+/// Current schema version as a semver string (generated at build time).
+pub const CURRENT_SCHEMA_VERSION_SEMVER: &str = env!("DUC_SCHEMA_VERSION");
+
+pub const DUC_SCHEMA_SQL: &str = DUC_SCHEMA;
+pub const VERSION_CONTROL_SCHEMA_SQL: &str = VERSION_CONTROL_SCHEMA;
+pub const SEARCH_SCHEMA_SQL: &str = SEARCH_SCHEMA;
+
 /// Per-connection PRAGMAs that must be re-applied on every open (they are
 /// either ephemeral or take effect only after the first statement on the
 /// connection).

{ducpy-3.3.7 → ducpy-3.3.8}/packages/ducrs/src/db/mod.rs

@@ -3,7 +3,7 @@
 //! Call [`open_file`] or [`open_memory`] instead of calling `rusqlite::Connection`
 //! directly. Internally they dispatch to the correct backend for each compile target.
 
-mod bootstrap;
+pub mod bootstrap;
 
 #[cfg(not(all(target_family = "wasm", target_os = "unknown")))]
 mod native;

{ducpy-3.3.7 → ducpy-3.3.8}/pyproject.toml

@@ -34,8 +34,6 @@ python-packages = ["ducpy", "ducpy_native"]
 module-name = "ducpy_native"
 include = [
     { path = "LICENSE", format = "sdist" },
-    { path = "schema/**/*", format = "sdist" },
-    { path = "schema/**/*", format = "wheel" }
 ]
 manifest-path = "packages/ducpy/crate/Cargo.toml"
 python-source = "src"

{ducpy-3.3.7 → ducpy-3.3.8}/src/ducpy/builders/sql_builder.py

@@ -29,67 +29,33 @@ Usage::
 from __future__ import annotations
 
 import os
-import re
 import sqlite3
 import tempfile
 from pathlib import Path
 from typing import Any, List, Optional, Union
 
-__all__ = ["DucSQL"]
-
-
-_MIGRATION_RE = re.compile(r"^(\d+)_to_(\d+)$")
+import ducpy_native
 
-
-def _find_schema_dir() -> Optional[Path]:
-    env_path = os.environ.get("DUC_SCHEMA_DIR")
-    if env_path:
-        candidate = Path(env_path)
-        if (candidate / "duc.sql").exists():
-            return candidate
-
-    current = Path(__file__).resolve()
-    for parent in current.parents:
-        candidate = parent / "schema"
-        if (candidate / "duc.sql").exists():
-            return candidate
-    return None
+__all__ = ["DucSQL"]
 
 
 def _get_current_schema_version() -> int:
-    """Read the target user_version from duc.sql — mirrors Rust's CURRENT_VERSION."""
-    schema_dir = _find_schema_dir()
-    if schema_dir is None:
-        return 0
-    duc_sql = (schema_dir / "duc.sql").read_text(encoding="utf-8")
-    m = re.search(r"PRAGMA\s+user_version\s*=\s*(\d+)", duc_sql, re.IGNORECASE)
-    return int(m.group(1)) if m else 0
+    """Current schema version integer (e.g. 3000000) — from the Rust crate."""
+    return ducpy_native.get_schema_version_int()
 
 
 def _read_migrations() -> list[tuple[int, int, str]]:
-    """Load all migration SQL files from schema/migrations/, sorted by from_version."""
-    schema_dir = _find_schema_dir()
-    if schema_dir is None:
-        return []
-    migrations_dir = schema_dir / "migrations"
-    if not migrations_dir.exists():
-        return []
-    result: list[tuple[int, int, str]] = []
-    for path in sorted(migrations_dir.glob("*.sql")):
-        m = _MIGRATION_RE.match(path.stem)
-        if m:
-            result.append((int(m.group(1)), int(m.group(2)), path.read_text(encoding="utf-8")))
-    result.sort(key=lambda x: x[0])
-    return result
+    """All migrations as (from_version, to_version, sql) — from the Rust crate."""
+    raw = ducpy_native.get_migrations()
+    # get_migrations returns list of tuples with i64 values
+    return [(int(f), int(t), sql) for f, t, sql in raw]
 
 
 def _apply_migrations(conn: sqlite3.Connection) -> None:
     """Walk the migration chain until user_version reaches the current schema version.
 
-    Mirrors the migration logic in Rust's ``bootstrap.rs``:
-    reads ``schema/migrations/{from}_to_{to}.sql`` files in order and executes
-    them until ``PRAGMA user_version`` matches the version declared in ``duc.sql``.
-    Safe to call on already-current or brand-new databases.
+    Mirrors the migration logic in Rust's ``bootstrap.rs``. Safe to call on
+    already-current or brand-new databases.
     """
     user_version: int = conn.execute("PRAGMA user_version").fetchone()[0]
     if user_version == 0:
@@ -112,18 +78,12 @@ def _apply_migrations(conn: sqlite3.Connection) -> None:
 
 
 def _read_schema_sql() -> str:
-    schema_dir = _find_schema_dir()
-    if schema_dir is None:
-        raise FileNotFoundError(
-            "Could not locate schema/duc.sql. "
-            "Ensure you are running from within the DUC repository."
-        )
-    parts: list[str] = []
-    for filename in ("duc.sql", "version_control.sql", "search.sql"):
-        path = schema_dir / filename
-        if path.exists():
-            parts.append(path.read_text(encoding="utf-8"))
-    return "\n".join(parts)
+    """Concatenate the three schema SQL strings shipped by the Rust crate."""
+    return "\n".join([
+        ducpy_native.get_duc_schema_sql(),
+        ducpy_native.get_version_control_schema_sql(),
+        ducpy_native.get_search_schema_sql(),
+    ])
 
 
 def _apply_pragmas(conn: sqlite3.Connection) -> None:

{ducpy-3.3.7 → ducpy-3.3.8}/src/ducpy/serialize.py

@@ -29,61 +29,8 @@ class DucSerializationValidationError(ValueError):
         super().__init__("Embedded code validation failed:\n" + "\n".join(f"- {failure}" for failure in failures))
 
 
-def _find_schema_file() -> Path | None:
-    env_path = Path(os.environ["DUC_SCHEMA_DIR"]) if "DUC_SCHEMA_DIR" in os.environ else None
-    if env_path is not None:
-        candidate = env_path / "duc.sql"
-        if candidate.exists():
-            return candidate
-
-    current = Path(__file__).resolve()
-    for parent in current.parents:
-        candidate = parent / "schema" / "duc.sql"
-        if candidate.exists():
-            return candidate
-
-    return None
-
-
-def _decode_user_version_to_semver(user_version: int) -> str:
-    """Decode sqlite-style schema user_version to semver.
-
-    Encoding convention:
-        major * 1_000_000 + minor * 1_000 + patch
-    """
-    if user_version < 0:
-        return "0.0.0"
-
-    major = user_version // 1_000_000
-    minor = (user_version % 1_000_000) // 1_000
-    patch = user_version % 1_000
-    return f"{major}.{minor}.{patch}"
-
-
-def _read_schema_version_fallback() -> str:
-    """Resolve schema version directly from repository `schema/duc.sql`.
-
-    This is used when `ducpy._version` isn't available (for example, in clean
-    CI environments before setup-time generation has run).
-    """
-    try:
-        schema_path = _find_schema_file()
-        if schema_path is None:
-            return "0.0.0"
-        content = schema_path.read_text(encoding="utf-8")
-        match = re.search(r"PRAGMA\s+user_version\s*=\s*(\d+)\s*;", content)
-        if match:
-            return _decode_user_version_to_semver(int(match.group(1)))
-    except Exception as exc:  # pragma: no cover - defensive fallback for CI/runtime variance
-        logger.warning("Failed to resolve schema version fallback from duc.sql: %s", exc)
-
-    return "0.0.0"
-
-
-try:
-    from ducpy._version import DUC_SCHEMA_VERSION
-except ModuleNotFoundError:
-    DUC_SCHEMA_VERSION = _read_schema_version_fallback()
+# Single source of truth for the schema version — comes from the Rust crate.
+DUC_SCHEMA_VERSION = ducpy_native.get_schema_version()
 
 # Map Python element class names → Rust serde type tag strings.
 _ELEMENT_CLASS_TO_TYPE: Dict[str, str] = {

ducpy-3.3.8/src/ducpy_native/__init__.py

@@ -0,0 +1,28 @@
+"""Python shim for the compiled :mod:`ducpy_native` extension.
+
+When built with maturin (``module-name = "ducpy_native"`` and
+``python-source = "src"``), the compiled extension is emitted as the
+submodule ``ducpy_native.ducpy_native``. Re-export the extension symbols at the
+package root so existing imports like ``import ducpy_native`` continue to work.
+"""
+
+from .ducpy_native import (get_external_file,  # type: ignore[attr-defined]
+                           list_external_files, parse_duc, parse_duc_lazy,
+                           serialize_duc, get_schema_version,
+                           get_schema_version_int, get_duc_schema_sql,
+                           get_version_control_schema_sql,
+                           get_search_schema_sql, get_migrations)
+
+__all__ = [
+    "parse_duc",
+    "parse_duc_lazy",
+    "serialize_duc",
+    "get_external_file",
+    "list_external_files",
+    "get_schema_version",
+    "get_schema_version_int",
+    "get_duc_schema_sql",
+    "get_version_control_schema_sql",
+    "get_search_schema_sql",
+    "get_migrations",
+]

ducpy-3.3.7/src/ducpy/_version.py

@@ -1,3 +0,0 @@
-# This file is auto-generated by setup.py when the package is built.
-# Do not edit this file manually.
-DUC_SCHEMA_VERSION = "3.0.0"

ducpy-3.3.7/src/ducpy_native/__init__.py

@@ -1,19 +0,0 @@
-"""Python shim for the compiled :mod:`ducpy_native` extension.
-
-When built with maturin (``module-name = \"ducpy_native\"`` and
-``python-source = \"src\"``), the compiled extension is emitted as the
-submodule ``ducpy_native.ducpy_native``. Re-export the extension symbols at the
-package root so existing imports like ``import ducpy_native`` continue to work.
-"""
-
-from .ducpy_native import (get_external_file,  # type: ignore[attr-defined]
-                           list_external_files, parse_duc, parse_duc_lazy,
-                           serialize_duc)
-
-__all__ = [
-	"parse_duc",
-	"parse_duc_lazy",
-	"serialize_duc",
-	"get_external_file",
-	"list_external_files",
-]