ducpy 3.1.0__tar.gz → 3.2.0__tar.gz

{ducpy-3.1.0 → ducpy-3.2.0}/Cargo.lock

@@ -411,7 +411,7 @@ dependencies = [
 
 [[package]]
 name = "ducpy-native"
-version = "3.1.0"
+version = "3.2.0"
 dependencies = [
  "duc",
  "pyo3",
@@ -713,10 +713,11 @@ checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
 
 [[package]]
 name = "hipdf"
-version = "1.3.5"
+version = "1.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3b986659f7ff291144addff668450799e4c2cd69686601cd48dfe23d7afc316"
+checksum = "2dfe672796312ef1e60b2866d6dac03b67c32dc7276a71c6d34b573dd00502f1"
 dependencies = [
+ "image",
  "jpeg-decoder",
  "lopdf",
  "miniz_oxide",
@@ -764,6 +765,7 @@ dependencies = [
  "byteorder-lite",
  "color_quant",
  "gif",
+ "image-webp",
  "moxcms",
  "num-traits",
  "png 0.18.0",
@@ -2477,18 +2479,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.8.41"
+version = "0.8.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96e13bc581734df6250836c59a5f44f3c57db9f9acb9dc8e3eaabdaf6170254d"
+checksum = "f2578b716f8a7a858b7f02d5bd870c14bf4ddbbcf3a4c05414ba6503640505e3"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.41"
+version = "0.8.42"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3545ea9e86d12ab9bba9fcd99b54c1556fd3199007def5a03c375623d05fac1c"
+checksum = "7e6cc098ea4d3bd6246687de65af3f920c430e236bee1e3bf2e441463f08a02f"
 dependencies = [
  "proc-macro2",
  "quote",

{ducpy-3.1.0 → ducpy-3.2.0}/Cargo.toml

@@ -2,7 +2,6 @@
 resolver = "2"
 members = ["packages/ducrs", "packages/ducpy/crate"]
 
-
 [profile.release]
 lto = true
 opt-level = "s"

{ducpy-3.1.0 → ducpy-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ducpy
-Version: 3.1.0
+Version: 3.2.0
 Classifier: License :: OSI Approved :: MIT License
 Requires-Dist: nanoid>=2.0.0
 License-File: LICENSE
@@ -19,7 +19,7 @@ Project-URL: Source, https://github.com/ducflair/duc/tree/main/packages/ducpy
 
 <p align="center">
   <br/>
-  <a href="https://duc.ducflair.com" target="_blank"><img width="256px" src="https://raw.githubusercontent.com/ducflair/assets/refs/heads/main/src/duc/duc-extended.png" /></a>
+  <a href="https://duc.ducflair.com" target="_blank"><img width="256px" src="https://cdn.jsdelivr.net/gh/ducflair/assets@main/src/duc/duc-extended.png" /></a>
   <p align="center">2D CAD File Format</p>
   <p align="center" style="align: center;">
     <a href="https://pypi.org/project/ducpy/"><img src="https://shields.io/badge/Pip-blue?logo=Pypi&logoColor=white&style=round-square" alt="Pip" /></a>

{ducpy-3.1.0 → ducpy-3.2.0}/README.md

@@ -2,7 +2,7 @@
 
 <p align="center">
   <br/>
-  <a href="https://duc.ducflair.com" target="_blank"><img width="256px" src="https://raw.githubusercontent.com/ducflair/assets/refs/heads/main/src/duc/duc-extended.png" /></a>
+  <a href="https://duc.ducflair.com" target="_blank"><img width="256px" src="https://cdn.jsdelivr.net/gh/ducflair/assets@main/src/duc/duc-extended.png" /></a>
   <p align="center">2D CAD File Format</p>
   <p align="center" style="align: center;">
     <a href="https://pypi.org/project/ducpy/"><img src="https://shields.io/badge/Pip-blue?logo=Pypi&logoColor=white&style=round-square" alt="Pip" /></a>

{ducpy-3.1.0 → ducpy-3.2.0}/packages/ducpy/crate/Cargo.toml

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

{ducpy-3.1.0 → ducpy-3.2.0}/packages/ducrs/README.md

@@ -2,7 +2,7 @@
 
 <p align="center">
   <br/>
-  <a href="https://duc.ducflair.com" target="_blank"><img width="256px" src="https://raw.githubusercontent.com/ducflair/assets/refs/heads/main/src/duc/duc-extended.png" /></a>
+  <a href="https://duc.ducflair.com" target="_blank"><img width="256px" src="https://cdn.jsdelivr.net/gh/ducflair/assets@main/src/duc/duc-extended.png" /></a>
   <p align="center">2D CAD File Format</p>
   <p align="center" style="align: center;">
     <a href="https://crates.io/crates/duc/"><img src="https://shields.io/badge/Crates-FFC933?logo=Rust&logoColor=646464&style=round-square" alt="Crates" /></a>

{ducpy-3.1.0 → ducpy-3.2.0}/packages/ducrs/src/api/version_control.rs

@@ -313,7 +313,7 @@ impl<'a> VersionControl<'a> {
         self.conn.with(|c| {
             c.query_row(
                 "SELECT current_version, current_schema_version, chain_count,
-                        last_pruned, total_size
+                        total_size
                  FROM version_graph WHERE id = 1",
                 [],
                 |row| {
@@ -321,8 +321,7 @@ impl<'a> VersionControl<'a> {
                         current_version: row.get(0)?,
                         current_schema_version: row.get(1)?,
                         chain_count: row.get(2)?,
-                        last_pruned: row.get::<_, Option<i64>>(3)?.unwrap_or(0),
-                        total_size: row.get::<_, Option<i64>>(4)?.unwrap_or(0),
+                        total_size: row.get::<_, Option<i64>>(3)?.unwrap_or(0),
                     })
                 },
             )
@@ -465,93 +464,6 @@ impl<'a> VersionControl<'a> {
         })
     }
 
-    // ────────────────────────────────────────────────────────────────────────
-    // WRITE — Pruning
-    // ────────────────────────────────────────────────────────────────────────
-
-    /// Prune old deltas that precede the given `keep_after_version`.
-    /// Checkpoints are never pruned (they are self-contained recovery points).
-    /// Returns the number of deltas removed.
-    pub fn prune_deltas_before(&self, keep_after_version: i64) -> DbResult<usize> {
-        self.conn.with(|c| {
-            let removed = c
-                .execute(
-                    "DELETE FROM deltas WHERE version_number < ?1",
-                    [keep_after_version],
-                )
-                .map_err(DbError::from)?;
-
-            // Update last_pruned timestamp
-            let now_ms = std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap_or_default()
-                .as_millis() as i64;
-
-            c.execute(
-                "UPDATE version_graph SET last_pruned = ?1 WHERE id = 1",
-                [now_ms],
-            )
-            .map_err(DbError::from)?;
-
-            // Recalculate total_size
-            self.recalculate_total_size(c)?;
-
-            Ok(removed)
-        })
-    }
-
-    /// Remove ALL versions (checkpoints + deltas) that are strictly older than
-    /// `keep_after_version`, except the most recent checkpoint before that
-    /// boundary (needed as a recovery base).
-    pub fn prune_before(&self, keep_after_version: i64) -> DbResult<usize> {
-        self.conn.with(|c| {
-            // Find the latest checkpoint at or before the boundary — keep it
-            let safe_cp_version: Option<i64> = c
-                .query_row(
-                    "SELECT MAX(version_number) FROM checkpoints
-                     WHERE version_number <= ?1",
-                    [keep_after_version],
-                    |row| row.get(0),
-                )
-                .optional()
-                .map_err(DbError::from)?
-                .flatten();
-
-            let safe_version = safe_cp_version.unwrap_or(0);
-
-            // Delete deltas before the safe checkpoint
-            let del_deltas = c
-                .execute(
-                    "DELETE FROM deltas WHERE version_number < ?1",
-                    [safe_version],
-                )
-                .map_err(DbError::from)?;
-
-            // Delete checkpoints before the safe checkpoint (keep the safe one)
-            let del_cps = c
-                .execute(
-                    "DELETE FROM checkpoints WHERE version_number < ?1",
-                    [safe_version],
-                )
-                .map_err(DbError::from)?;
-
-            let now_ms = std::time::SystemTime::now()
-                .duration_since(std::time::UNIX_EPOCH)
-                .unwrap_or_default()
-                .as_millis() as i64;
-
-            c.execute(
-                "UPDATE version_graph SET last_pruned = ?1 WHERE id = 1",
-                [now_ms],
-            )
-            .map_err(DbError::from)?;
-
-            self.recalculate_total_size(c)?;
-
-            Ok(del_deltas + del_cps)
-        })
-    }
-
     // ────────────────────────────────────────────────────────────────────────
     // WRITE — Revert
     // ────────────────────────────────────────────────────────────────────────
@@ -808,7 +720,7 @@ pub(crate) fn read_version_graph_inner(
     let mut vg_stmt = conn
         .prepare(
             "SELECT current_version, current_schema_version, user_checkpoint_version_id,
-                    latest_version_id, chain_count, last_pruned, total_size
+                    latest_version_id, chain_count, total_size
              FROM version_graph WHERE id = 1",
         )
         .map_err(DbError::from)?;
@@ -819,8 +731,7 @@ pub(crate) fn read_version_graph_inner(
                 current_version: row.get(0)?,
                 current_schema_version: row.get(1)?,
                 chain_count: row.get(4)?,
-                last_pruned: row.get::<_, Option<i64>>(5)?.unwrap_or(0),
-                total_size: row.get::<_, Option<i64>>(6)?.unwrap_or(0),
+                total_size: row.get::<_, Option<i64>>(5)?.unwrap_or(0),
             },
             row.get::<_, Option<String>>(2)?.unwrap_or_default(),
             row.get::<_, Option<String>>(3)?.unwrap_or_default(),

ducpy-3.2.0/packages/ducrs/src/lib.rs

@@ -0,0 +1,298 @@
+#[allow(unused_imports)]
+#[allow(non_camel_case_types)]
+#[allow(non_snake_case)]
+#[allow(non_upper_case_globals)]
+pub mod parse;
+pub mod serde_utils;
+pub mod serialize;
+pub mod types;
+
+// SQLite storage layer and high-level document API
+pub mod db;
+pub mod api;
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashSet;
+    use std::fs;
+    use std::path::{Path, PathBuf};
+
+    use crate::parse;
+    use crate::serialize;
+    use crate::types::*;
+
+    fn assets_dir() -> PathBuf {
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/testing/duc-files")
+    }
+
+    fn all_duc_files() -> Vec<PathBuf> {
+        let dir = assets_dir();
+        assert!(dir.exists(), "assets dir missing: {}", dir.display());
+        let mut files: Vec<PathBuf> = fs::read_dir(&dir)
+            .expect("read assets dir")
+            .filter_map(|e| e.ok())
+            .map(|e| e.path())
+            .filter(|p| p.extension().is_some_and(|ext| ext == "duc"))
+            .collect();
+        files.sort();
+        assert!(!files.is_empty(), "no .duc files in {}", dir.display());
+        files
+    }
+
+    fn load(path: &Path) -> Vec<u8> {
+        fs::read(path).unwrap_or_else(|e| panic!("read {}: {e}", path.display()))
+    }
+
+    // ── Parse every asset ────────────────────────────────────────────────────
+
+    #[test]
+    fn parse_all_assets() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            assert!(!state.version.is_empty(), "{}: version must not be empty", path.display());
+            assert!(!state.source.is_empty(), "{}: source must not be empty", path.display());
+            assert!(!state.elements.is_empty() || !state.layers.is_empty(),
+                "{}: must have elements or layers", path.display());
+        }
+    }
+
+    // ── Round-trip: parse → serialize → re-parse preserves data ──────────────
+
+    #[test]
+    fn roundtrip_all_assets() {
+        for path in all_duc_files() {
+            let original = load(&path);
+            let parsed = parse::parse(&original)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            let serialized = serialize::serialize(&parsed)
+                .unwrap_or_else(|e| panic!("serialize {} failed: {e}", path.display()));
+            assert!(!serialized.is_empty(), "{}: serialized must not be empty", path.display());
+
+            let reparsed = parse::parse(&serialized)
+                .unwrap_or_else(|e| panic!("re-parse {} failed: {e}", path.display()));
+
+            assert_eq!(
+                parsed.elements.len(), reparsed.elements.len(),
+                "{}: element count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.layers.len(), reparsed.layers.len(),
+                "{}: layer count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.blocks.len(), reparsed.blocks.len(),
+                "{}: block count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.block_instances.len(), reparsed.block_instances.len(),
+                "{}: block instance count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.groups.len(), reparsed.groups.len(),
+                "{}: group count mismatch", path.display()
+            );
+            assert_eq!(
+                parsed.regions.len(), reparsed.regions.len(),
+                "{}: region count mismatch", path.display()
+            );
+        }
+    }
+
+    // ── Lazy parse skips external files ──────────────────────────────────────
+
+    #[test]
+    fn lazy_parse_skips_external_files() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let full = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+            let lazy = parse::parse_lazy(&buf)
+                .unwrap_or_else(|e| panic!("parse_lazy {} failed: {e}", path.display()));
+
+            assert!(lazy.external_files.is_none(), "{}: lazy parse must omit external_files", path.display());
+            assert!(lazy.external_files_data.is_none(), "{}: lazy parse must omit external_files_data", path.display());
+            assert_eq!(full.elements.len(), lazy.elements.len(), "{}: element count diverged", path.display());
+            assert_eq!(full.layers.len(), lazy.layers.len(), "{}: layer count diverged", path.display());
+        }
+    }
+
+    // ── Element IDs are unique within each file ──────────────────────────────
+
+    #[test]
+    fn element_ids_unique() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            let mut seen = HashSet::new();
+            for wrapper in &state.elements {
+                let id = element_id(&wrapper.element);
+                assert!(seen.insert(id.clone()), "{}: duplicate element id '{id}'", path.display());
+            }
+        }
+    }
+
+    // ── Every element references a valid layer ───────────────────────────────
+
+    #[test]
+    fn element_layer_refs_valid() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            let layer_ids: HashSet<String> = state.layers.iter().map(|l| l.id.clone()).collect();
+
+            for wrapper in &state.elements {
+                let base = element_base(&wrapper.element);
+                if let Some(ref lid) = base.layer_id {
+                    assert!(
+                        layer_ids.contains(lid),
+                        "{}: element '{}' references non-existent layer '{lid}'",
+                        path.display(), base.id
+                    );
+                }
+            }
+        }
+    }
+
+    // ── Block instances reference valid blocks ───────────────────────────────
+
+    #[test]
+    fn block_instance_refs_valid() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            let block_ids: HashSet<String> = state.blocks.iter().map(|b| b.id.clone()).collect();
+
+            for inst in &state.block_instances {
+                assert!(
+                    block_ids.contains(&inst.block_id),
+                    "{}: block instance '{}' references non-existent block '{}'",
+                    path.display(), inst.id, inst.block_id
+                );
+            }
+        }
+    }
+
+    // ── External files: list ↔ get round-trip ────────────────────────────────
+
+    #[test]
+    fn external_files_list_get_consistent() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let listing = parse::list_external_files(&buf)
+                .unwrap_or_else(|e| panic!("list_external_files {} failed: {e}", path.display()));
+
+            for meta in &listing {
+                let file = parse::get_external_file(&buf, &meta.id)
+                    .unwrap_or_else(|e| panic!("get_external_file {} id={} failed: {e}", path.display(), meta.id));
+                assert!(file.is_some(), "{}: listed file '{}' not found via get", path.display(), meta.id);
+                let loaded = file.unwrap();
+                assert_eq!(loaded.file.id, meta.id);
+                assert!(!loaded.file.revisions.is_empty(), "{}: file '{}' has no revisions", path.display(), meta.id);
+            }
+        }
+    }
+
+    // ── DB layer: open in-memory, schema bootstraps correctly ────────────────
+
+    #[test]
+    fn db_open_memory_and_schema() {
+        use crate::api::DucDocument;
+
+        let doc = DucDocument::open_memory().expect("open_memory");
+        let version = doc.schema_version().expect("schema_version");
+        assert!(version > 0, "schema version must be positive, got {version}");
+    }
+
+    // ── Compression: serialized output is smaller than raw SQLite ────────────
+
+    #[test]
+    fn serialized_is_compressed() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            assert!(!parse::is_sqlite_header(&buf), "{}: assets should be compressed, not raw SQLite", path.display());
+
+            let raw = parse::decompress_duc_bytes(&buf)
+                .unwrap_or_else(|e| panic!("decompress {} failed: {e}", path.display()));
+
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+            let recompressed = serialize::serialize(&state)
+                .unwrap_or_else(|e| panic!("serialize {} failed: {e}", path.display()));
+
+            assert!(
+                recompressed.len() < raw.len(),
+                "{}: compressed ({} B) should be smaller than raw SQLite ({} B)",
+                path.display(), recompressed.len(), raw.len()
+            );
+        }
+    }
+
+    // ── Global state invariants ──────────────────────────────────────────────
+
+    #[test]
+    fn global_state_valid() {
+        for path in all_duc_files() {
+            let buf = load(&path);
+            let state = parse::parse(&buf)
+                .unwrap_or_else(|e| panic!("parse {} failed: {e}", path.display()));
+
+            if let Some(ref gs) = state.duc_global_state {
+                assert!(!gs.view_background_color.is_empty(), "{}: background color must not be empty", path.display());
+                assert!(!gs.main_scope.is_empty(), "{}: main_scope must not be empty", path.display());
+            }
+        }
+    }
+
+    // ── Error handling: garbage input produces a clear error ──────────────────
+
+    #[test]
+    fn parse_rejects_garbage() {
+        let cases: &[(&str, &[u8])] = &[
+            ("empty", &[]),
+            ("random", &[0xFF; 64]),
+            ("text", b"Not a DUC file"),
+        ];
+        for (label, data) in cases {
+            assert!(
+                parse::parse(data).is_err(),
+                "parse should reject {label} input"
+            );
+        }
+    }
+
+    // ── Helpers ──────────────────────────────────────────────────────────────
+
+    fn element_id(el: &DucElementEnum) -> String {
+        element_base(el).id.clone()
+    }
+
+    fn element_base(el: &DucElementEnum) -> &DucElementBase {
+        match el {
+            DucElementEnum::DucRectangleElement(e) => &e.base,
+            DucElementEnum::DucPolygonElement(e) => &e.base,
+            DucElementEnum::DucEllipseElement(e) => &e.base,
+            DucElementEnum::DucEmbeddableElement(e) => &e.base,
+            DucElementEnum::DucPdfElement(e) => &e.base,
+            DucElementEnum::DucTableElement(e) => &e.base,
+            DucElementEnum::DucImageElement(e) => &e.base,
+            DucElementEnum::DucTextElement(e) => &e.base,
+            DucElementEnum::DucLinearElement(e) => &e.linear_base.base,
+            DucElementEnum::DucArrowElement(e) => &e.linear_base.base,
+            DucElementEnum::DucFreeDrawElement(e) => &e.base,
+            DucElementEnum::DucFrameElement(e) => &e.stack_element_base.base,
+            DucElementEnum::DucPlotElement(e) => &e.stack_element_base.base,
+            DucElementEnum::DucDocElement(e) => &e.base,
+            DucElementEnum::DucModelElement(e) => &e.base,
+        }
+    }
+}