ducpy 3.3.6__tar.gz → 3.3.8__tar.gz

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

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

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

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

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

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

{ducpy-3.3.6 → 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.6 → ducpy-3.3.8}/packages/ducrs/Cargo.toml

@@ -7,6 +7,15 @@ license = "MIT"
 authors = ["Ducflair support@ducflair.com"]
 repository = "https://github.com/ducflair/duc/tree/main/packages/ducrs"
 readme = "README.md"
+include = [
+  "src/**",
+  "build.rs",
+  "Cargo.toml",
+  "README.md",
+  "LICENSE",
+  "schema/*.sql",
+  "schema/migrations/*.sql",
+]
 
 [dependencies]
 base64 = "0.21.5"

{ducpy-3.3.6 → 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.6 → 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.6 → 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.6 → 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.6 → 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.6 → ducpy-3.3.8}/src/ducpy/builders/state_builders.py

@@ -446,9 +446,9 @@ def create_local_state_from_base(base: BaseStateParams, **kwargs) -> DucLocalSta
         current_item_stroke=kwargs.get('current_item_stroke', None),
         current_item_background=kwargs.get('current_item_background', None),
         current_item_opacity=kwargs.get('current_item_opacity', 1.0),
-        current_item_font_family=kwargs.get('current_item_font_family', "Virgil"),
+        current_item_font_family=kwargs.get('current_item_font_family', "Roboto Mono"),
         current_item_font_size=kwargs.get('current_item_font_size', 20.0),
-        current_item_text_align=kwargs.get('current_item_text_align', None),
+        current_item_text_align=kwargs.get('current_item_text_align', TEXT_ALIGN.LEFT),
         current_item_roundness=kwargs.get('current_item_roundness', 0.0),
         current_item_start_line_head=kwargs.get('current_item_start_line_head', None),
         current_item_end_line_head=kwargs.get('current_item_end_line_head', None),
@@ -457,7 +457,7 @@ def create_local_state_from_base(base: BaseStateParams, **kwargs) -> DucLocalSta
         objects_snap_mode_enabled=kwargs.get('objects_snap_mode_enabled', True),
         grid_mode_enabled=kwargs.get('grid_mode_enabled', True),
         outline_mode_enabled=kwargs.get('outline_mode_enabled', False),
-        manual_save_mode=kwargs.get('manual_save_mode', None),
+        manual_save_mode=kwargs.get('manual_save_mode', False),
         decimal_places=kwargs.get('decimal_places', 2),
     )
 

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

@@ -16,7 +16,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 import ducpy_native
 from ducpy.utils.convert import (deep_snake_to_camel, snake_to_camel,
-                                 to_serializable)
+                                 to_serializable, _flatten_dict)
 
 logger = logging.getLogger(__name__)
 
@@ -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] = {
@@ -104,22 +51,6 @@ _ELEMENT_CLASS_TO_TYPE: Dict[str, str] = {
     "DucModelElement": "model",
 }
 
-# Keys in the asdict() output that should be flattened (merged into the parent),
-# mirroring Rust's #[serde(flatten)] on base / styles / linear_base / stack_element_base.
-_FLATTEN_KEYS = frozenset({"base", "styles", "linear_base", "stack_element_base"})
-
-
-def _flatten_dict(d: dict) -> dict:
-    """Recursively flatten nested dicts whose key is in ``_FLATTEN_KEYS``."""
-    result: dict = {}
-    for k, v in d.items():
-        if k in _FLATTEN_KEYS and isinstance(v, dict):
-            result.update(_flatten_dict(v))
-        else:
-            result[k] = v
-    return result
-
-
 def _element_to_camel(wrapper_or_element: Any) -> dict:
     """Convert an element (or ElementWrapper) to the camelCase dict Rust expects."""
     el = wrapper_or_element

{ducpy-3.3.6 → ducpy-3.3.8}/src/ducpy/utils/convert.py

@@ -65,11 +65,19 @@ def deep_snake_to_camel(obj: Any) -> Any:
 
 
 def _flatten_dict(d: dict) -> dict:
-    """Recursively flatten keys that Rust serde #[serde(flatten)] would flatten."""
+    """Recursively flatten keys that Rust serde #[serde(flatten)] would flatten.
+
+    Walks the entire dict so that nested flatten keys (e.g. ``stack_element_base``
+    -> ``stack_base`` -> ``styles``) are all merged into the appropriate level.
+    """
     result: dict = {}
     for k, v in d.items():
-        if k in _FLATTEN_KEYS and isinstance(v, dict):
-            result.update(_flatten_dict(v))
+        if isinstance(v, dict):
+            v = _flatten_dict(v)
+            if k in _FLATTEN_KEYS:
+                result.update(v)
+            else:
+                result[k] = v
         else:
             result[k] = v
     return result

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.6/packages/ducrs/.gitignore

@@ -1,21 +0,0 @@
-# Generated by Cargo
-# will have compiled files and executables
-debug/
-target/
-
-# Remove Cargo.lock from gitignore if creating an executable, leave it for libraries
-# More information here https://doc.rust-lang.org/cargo/guide/cargo-toml-vs-cargo-lock.html
-Cargo.lock
-
-# These are backup files generated by rustfmt
-**/*.rs.bk
-
-# MSVC Windows builds of rustc generate these, which store debugging information
-*.pdb
-
-# RustRover
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/

ducpy-3.3.6/packages/ducrs/package.json

@@ -1,13 +0,0 @@
-{
-  "name": "ducrs",
-  "version": "0.0.0-development",
-  "private": true,
-  "scripts": {
-    "build": "cargo build --release",
-    "test": "cargo test",
-    "semantic-release": "semantic-release"
-  },
-  "devDependencies": {
-    "semantic-release": "^24.1.2"
-  }
-}

ducpy-3.3.6/packages/ducrs/release.config.cjs

@@ -1,31 +0,0 @@
-module.exports = {
-  branches: ["main", { name: "next", prerelease: true }, { name: "dev", prerelease: true }],
-  plugins: [
-    [
-      require.resolve("../../scripts/semrel-path-filter.cjs"),
-      {
-        paths: [
-          "packages/ducrs"
-        ],
-        analyzer: { preset: "conventionalcommits" },
-        notes: { preset: "conventionalcommits" },
-      },
-    ],
-    [
-      "@semantic-release/github",
-    ],
-    [
-      "@semantic-release/exec",
-      {
-        // Prepare step: Set the crate version and build the project
-        prepareCmd:
-          "cargo set-version ${nextRelease.version} && cargo build --release",
-
-        // Publish step: Publish the crate to crates.io
-        publishCmd:
-          "cargo publish --allow-dirty --token ${process.env.CARGO_REGISTRY_TOKEN}",
-      },
-    ],
-  ],
-  tagFormat: "ducrs@${version}",
-};

ducpy-3.3.6/packages/ducrs/sst-env.d.ts

@@ -1,10 +0,0 @@
-/* This file is auto-generated by SST. Do not edit. */
-/* tslint:disable */
-/* eslint-disable */
-/* deno-fmt-ignore-file */
-/* biome-ignore-all lint: auto-generated */
-
-/// <reference path="../../sst-env.d.ts" />
-
-import "sst"
-export {}

ducpy-3.3.6/packages/ducrs/tests/.gitignore

@@ -1,2 +0,0 @@
-inputs
-output