ducpy 3.3.5__tar.gz → 3.3.7__tar.gz

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

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

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

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

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

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

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

@@ -7,6 +7,17 @@ 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/duc.sql",
+  "schema/version_control.sql",
+  "schema/search.sql",
+  "schema/migrations/*.sql",
+]
 
 [dependencies]
 base64 = "0.21.5"

{ducpy-3.3.5 → ducpy-3.3.7}/packages/ducrs/src/parse.rs

@@ -1460,17 +1460,20 @@ fn read_pdf_element(conn: &Connection, base: DucElementBase) -> ParseResult<DucE
 }
 
 fn read_doc_element(conn: &Connection, base: DucElementBase) -> ParseResult<DucElementEnum> {
+    let id = base.id.clone();
     let (file_id, grid_config) = read_document_grid_config(conn, &base.id)?;
     let mut stmt = conn.prepare_cached(
         "SELECT text FROM element_doc WHERE element_id = ?1"
     )?;
     let text: String = stmt.query_row(params![base.id], |row| row.get(0))?;
+    let referenced_file_ids = read_doc_referenced_file_ids(conn, &id)?;
     Ok(DucElementEnum::DucDocElement(DucDocElement {
         base,
         style: DucDocStyle {},
         text,
         grid_config,
         file_id,
+        referenced_file_ids,
     }))
 }
 
@@ -1512,11 +1515,7 @@ fn read_model_element(conn: &Connection, base: DucElementBase) -> ParseResult<Du
         Ok((row.get::<_, Option<String>>(0)?, row.get::<_, Option<String>>(1)?, row.get::<_, Option<Vec<u8>>>(2)?))
     })?;
 
-    let mut f_stmt = conn.prepare_cached(
-        "SELECT file_id FROM model_element_files WHERE element_id = ?1 ORDER BY sort_order"
-    )?;
-    let file_ids: Vec<String> = f_stmt.query_map(params![id], |row| row.get(0))?
-        .collect::<Result<Vec<_>, _>>()?;
+    let file_ids = read_element_file_ids(conn, &id)?;
 
     let viewer_state = read_model_viewer_state(conn, &id)?;
 
@@ -1525,6 +1524,36 @@ fn read_model_element(conn: &Connection, base: DucElementBase) -> ParseResult<Du
     }))
 }
 
+fn read_element_file_ids(conn: &Connection, element_id: &str) -> ParseResult<Vec<String>> {
+    let mut stmt = conn.prepare_cached(
+        "SELECT file_id FROM model_element_files WHERE element_id = ?1 ORDER BY sort_order"
+    )?;
+    let file_ids = stmt.query_map(params![element_id], |row| row.get(0))?
+        .collect::<Result<Vec<_>, _>>()?;
+    Ok(file_ids)
+}
+
+fn read_doc_referenced_file_ids(conn: &Connection, element_id: &str) -> ParseResult<Vec<String>> {
+    if !table_exists(conn, "doc_element_referenced_files")? {
+        return Ok(Vec::new());
+    }
+
+    let mut stmt = conn.prepare_cached(
+        "SELECT file_id FROM doc_element_referenced_files WHERE element_id = ?1 ORDER BY sort_order"
+    )?;
+    let file_ids = stmt.query_map(params![element_id], |row| row.get(0))?
+        .collect::<Result<Vec<_>, _>>()?;
+    Ok(file_ids)
+}
+
+fn table_exists(conn: &Connection, table_name: &str) -> ParseResult<bool> {
+    Ok(conn.query_row(
+        "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?1)",
+        params![table_name],
+        |row| row.get::<_, i64>(0),
+    )? != 0)
+}
+
 fn read_model_viewer_state(conn: &Connection, element_id: &str) -> ParseResult<Option<Viewer3DState>> {
     let mut stmt = conn.prepare_cached(
         "SELECT

{ducpy-3.3.5 → ducpy-3.3.7}/packages/ducrs/src/serialize.rs

@@ -456,6 +456,7 @@ fn write_element_wrapper(tx: &Transaction, wrapper: &ElementWrapper) -> Serializ
                 "INSERT INTO element_doc (element_id, text) VALUES (?1, ?2)",
                 params![e.base.id, e.text],
             )?;
+            write_doc_referenced_file_ids(tx, &e.base.id, &e.referenced_file_ids)?;
         }
         DucElementEnum::DucTableElement(e) => {
             write_base_element(tx, "table", &e.base)?;
@@ -834,14 +835,7 @@ fn write_model_element(tx: &Transaction, e: &DucModelElement) -> SerializeResult
         params![e.base.id, e.model_type, e.code, e.thumbnail],
     )?;
 
-    {
-        let mut stmt = tx.prepare_cached(
-            "INSERT INTO model_element_files (element_id, file_id, sort_order) VALUES (?1, ?2, ?3)"
-        )?;
-        for (i, fid) in e.file_ids.iter().enumerate() {
-            stmt.execute(params![e.base.id, fid, i as i32])?;
-        }
-    }
+    write_element_file_ids(tx, &e.base.id, &e.file_ids)?;
 
     if let Some(ref vs) = e.viewer_state {
         write_model_viewer_state(tx, &e.base.id, vs)?;
@@ -850,6 +844,26 @@ fn write_model_element(tx: &Transaction, e: &DucModelElement) -> SerializeResult
     Ok(())
 }
 
+fn write_element_file_ids(tx: &Transaction, element_id: &str, file_ids: &[String]) -> SerializeResult<()> {
+    let mut stmt = tx.prepare_cached(
+        "INSERT INTO model_element_files (element_id, file_id, sort_order) VALUES (?1, ?2, ?3)"
+    )?;
+    for (i, fid) in file_ids.iter().enumerate() {
+        stmt.execute(params![element_id, fid, i as i32])?;
+    }
+    Ok(())
+}
+
+fn write_doc_referenced_file_ids(tx: &Transaction, element_id: &str, file_ids: &[String]) -> SerializeResult<()> {
+    let mut stmt = tx.prepare_cached(
+        "INSERT INTO doc_element_referenced_files (element_id, file_id, sort_order) VALUES (?1, ?2, ?3)"
+    )?;
+    for (i, fid) in file_ids.iter().enumerate() {
+        stmt.execute(params![element_id, fid, i as i32])?;
+    }
+    Ok(())
+}
+
 fn write_model_viewer_state(tx: &Transaction, element_id: &str, vs: &Viewer3DState) -> SerializeResult<()> {
     let cam = &vs.camera;
     let disp = &vs.display;

{ducpy-3.3.5 → ducpy-3.3.7}/packages/ducrs/src/types.rs

@@ -1045,6 +1045,8 @@ pub struct DucDocElement {
     pub text: String,
     pub grid_config: DocumentGridConfig,
     pub file_id: Option<String>,
+    #[serde(default)]
+    pub referenced_file_ids: Vec<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]

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

@@ -51,6 +51,10 @@ dev = [
     "sphinx-autoapi>=3.6.0",
     "pytest>=8.3.5",
     "rich>=13.0.0",
+    "typst>=0.14.9",
+    "build123d>=0.10.0",
+    "ocp-vscode>=3.4.0",
+    "ifcopenshell>=0.8.5",
 ]
 
 

{ducpy-3.3.5 → ducpy-3.3.7}/schema/duc.sql

@@ -1,7 +1,7 @@
 -- "DUC_" in ASCII
 -- Apply in order: duc.sql → version_control.sql → search.sql
 PRAGMA application_id = 1146569567;
-PRAGMA user_version = 3000003;
+PRAGMA user_version = 3000004;
 PRAGMA journal_mode = WAL;
 PRAGMA foreign_keys = ON;
 PRAGMA synchronous = NORMAL;
@@ -702,6 +702,16 @@ CREATE TABLE element_doc (
     text       TEXT NOT NULL DEFAULT ''
 );  -- no WITHOUT ROWID: implicit integer rowid needed for FTS5 content sync
 
+-- External files referenced by a doc element's Typst source (images, data files, etc.).
+CREATE TABLE doc_element_referenced_files (
+    element_id TEXT NOT NULL REFERENCES element_doc(element_id) ON DELETE CASCADE,
+    file_id    TEXT NOT NULL,
+    sort_order INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (element_id, file_id)
+) WITHOUT ROWID;
+
+CREATE INDEX idx_doc_referenced_files_file ON doc_element_referenced_files(file_id);
+
 -- Table element. Source of truth is the linked xlsx file.
 CREATE TABLE element_table (
     element_id TEXT PRIMARY KEY REFERENCES elements(id) ON DELETE CASCADE,
@@ -844,4 +854,4 @@ CREATE INDEX idx_external_file_revisions_file ON external_file_revisions(file_id
 CREATE TABLE external_file_revision_data (
     revision_id TEXT PRIMARY KEY REFERENCES external_file_revisions(id) ON DELETE CASCADE,
     data        BLOB NOT NULL
-) WITHOUT ROWID;
+) WITHOUT ROWID;

ducpy-3.3.7/schema/migrations/3000003_to_3000004.sql

@@ -0,0 +1,41 @@
+-- Migration: 3000003 → 3000004
+-- Rename element_model.svg_path (TEXT) to thumbnail (BLOB), and add dedicated
+-- references for external files used by doc element Typst source.
+
+CREATE TABLE element_model_new (
+    element_id TEXT PRIMARY KEY REFERENCES elements(id) ON DELETE CASCADE,
+    model_type TEXT,
+    code       TEXT,
+    thumbnail  BLOB
+);
+
+INSERT INTO element_model_new (element_id, model_type, code, thumbnail)
+SELECT element_id, model_type, code, CAST(svg_path AS BLOB)
+FROM element_model;
+
+DROP TABLE element_model;
+
+ALTER TABLE element_model_new RENAME TO element_model;
+
+CREATE INDEX idx_element_model_type ON element_model(model_type);
+
+CREATE TABLE IF NOT EXISTS doc_element_referenced_files (
+    element_id TEXT NOT NULL REFERENCES element_doc(element_id) ON DELETE CASCADE,
+    file_id    TEXT NOT NULL,
+    sort_order INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (element_id, file_id)
+) WITHOUT ROWID;
+
+CREATE INDEX IF NOT EXISTS idx_doc_referenced_files_file ON doc_element_referenced_files(file_id);
+
+-- Defensive cleanup for prerelease files that may have stored doc references in
+-- model_element_files before this dedicated table existed.
+INSERT OR IGNORE INTO doc_element_referenced_files (element_id, file_id, sort_order)
+SELECT mf.element_id, mf.file_id, mf.sort_order
+FROM model_element_files mf
+INNER JOIN element_doc d ON d.element_id = mf.element_id;
+
+DELETE FROM model_element_files
+WHERE element_id IN (SELECT element_id FROM element_doc);
+
+PRAGMA user_version = 3000004;

{ducpy-3.3.5 → ducpy-3.3.7}/src/ducpy/__init__.py

@@ -27,6 +27,6 @@ from .classes import *
 from .enums import *
 from .parse import (DucData, get_external_file, list_external_files, parse_duc,
                     parse_duc_lazy)
-from .serialize import DUC_SCHEMA_VERSION, serialize_duc
+from .serialize import DUC_SCHEMA_VERSION, DucSerializationValidationError, serialize_duc
 from .search import *
 from .utils import *

{ducpy-3.3.5 → ducpy-3.3.7}/src/ducpy/builders/element_builders.py

@@ -55,45 +55,46 @@ def _create_element_wrapper(element_class, base_params, element_params, explicit
     base_params.setdefault('region_ids', [])
     base_params.setdefault('instance_id', None)
 
-    base_params.setdefault('styles', DucElementStylesBase(
-        roundness=0.0,
-        stroke=[ElementStroke(
-            content=ElementContentBase(
-                preference=None,
-                src="",
-                visible=True,
-                opacity=1.0,
-                tiling=None,
-                hatch=None,
-                image_filter=DucImageFilter(brightness=1.0, contrast=1.0)
-            ),
-            width=DEFAULT_STROKE_WIDTH,
-            style=StrokeStyle(
-                preference=STROKE_PREFERENCE.SOLID,
-                dash=None,
-                dash_line_override=None,
-                cap=None,
-                join=None,
-                dash_cap=None,
-                miter_limit=None
-            ),
-            placement=STROKE_PLACEMENT.CENTER,
-            stroke_sides=None
-        )],
-        background=[ElementBackground(
-            content=ElementContentBase(
-                preference=None,
-                src="",
-                visible=True,
-                opacity=1.0,
-                tiling=None,
-                hatch=None,
-                image_filter=DucImageFilter(brightness=1.0, contrast=1.0)
-            )
-        )],
-        opacity=1.0,
-        blending=None
-    ))
+    if base_params.get('styles') is None:
+        base_params['styles'] = DucElementStylesBase(
+            roundness=0.0,
+            stroke=[ElementStroke(
+                content=ElementContentBase(
+                    preference=None,
+                    src="",
+                    visible=True,
+                    opacity=1.0,
+                    tiling=None,
+                    hatch=None,
+                    image_filter=DucImageFilter(brightness=1.0, contrast=1.0)
+                ),
+                width=DEFAULT_STROKE_WIDTH,
+                style=StrokeStyle(
+                    preference=STROKE_PREFERENCE.SOLID,
+                    dash=None,
+                    dash_line_override=None,
+                    cap=None,
+                    join=None,
+                    dash_cap=None,
+                    miter_limit=None
+                ),
+                placement=STROKE_PLACEMENT.CENTER,
+                stroke_sides=None
+            )],
+            background=[ElementBackground(
+                content=ElementContentBase(
+                    preference=None,
+                    src="",
+                    visible=True,
+                    opacity=1.0,
+                    tiling=None,
+                    hatch=None,
+                    image_filter=DucImageFilter(brightness=1.0, contrast=1.0)
+                )
+            )],
+            opacity=1.0,
+            blending=None
+        )
 
     base_element = DucElementBase(**base_params)
 
@@ -168,8 +169,9 @@ def _create_element_wrapper(element_class, base_params, element_params, explicit
             base=base_element,
             style=element_params.get('style') or DucDocStyle(),
             text=element_params.get('text', ""),
-            grid_config=element_params.get('grid_config', default_grid_config),
+            grid_config=element_params.get('grid_config') or default_grid_config,
             file_id=element_params.get('file_id'),
+            referenced_file_ids=element_params.get('referenced_file_ids') or [],
         )
     elif element_class == DucFrameElement:
         stack_base = element_params.get('stack_base')
@@ -698,6 +700,8 @@ class DocElementBuilder(ElementSpecificBuilder):
         self.extra["style"] = style; return self
     def with_file_id(self, file_id: str):
         self.extra["file_id"] = file_id; return self
+    def with_referenced_file_ids(self, referenced_file_ids: List[str]):
+        self.extra["referenced_file_ids"] = referenced_file_ids; return self
     def with_grid_config(self, grid_config: DocumentGridConfig):
         self.extra["grid_config"] = grid_config; return self
 
@@ -707,6 +711,7 @@ class DocElementBuilder(ElementSpecificBuilder):
             "style": self.extra.get('style'),
             "text": self.extra.get('text', ""),
             "file_id": self.extra.get('file_id'),
+            "referenced_file_ids": self.extra.get('referenced_file_ids', []),
             "grid_config": self.extra.get('grid_config'),
         }
         return _create_element_wrapper(DucDocElement, base_params, element_params,
@@ -727,11 +732,12 @@ class EmbeddableElementBuilder(ElementSpecificBuilder):
 
 class ModelElementBuilder(ElementSpecificBuilder):
     def with_model_type(self, model_type: str):
+        valid_types = {"python", "ifc", "dxf", "dwg", "step", "stl"}
+        if model_type not in valid_types:
+            raise ValueError(f"Invalid model_type: {model_type}. Allowed types: {sorted(list(valid_types))}")
         self.extra["model_type"] = model_type; return self
     def with_code(self, code: str):
         self.extra["code"] = code; return self
-    def with_svg_path(self, svg_path: str):
-        self.extra["svg_path"] = svg_path; return self
     def with_file_ids(self, file_ids: List[str]):
         self.extra["file_ids"] = file_ids; return self
     def with_viewer_state(self, viewer_state):
@@ -739,11 +745,15 @@ class ModelElementBuilder(ElementSpecificBuilder):
 
     def build(self) -> ElementWrapper:
         base_params = self.base.__dict__.copy()
+        model_type = self.extra.get('model_type', 'python')
+        valid_types = {"python", "ifc", "dxf", "dwg", "step", "stl"}
+        if model_type not in valid_types:
+            raise ValueError(f"Invalid model_type: {model_type}. Allowed types: {sorted(list(valid_types))}")
+        
         element_params = {
             "file_ids": self.extra.get('file_ids', []),
-            "model_type": self.extra.get('model_type'),
+            "model_type": model_type,
             "code": self.extra.get('code'),
-            "svg_path": self.extra.get('svg_path'),
             "viewer_state": self.extra.get('viewer_state'),
         }
         return _create_element_wrapper(DucModelElement, base_params, element_params,

{ducpy-3.3.5 → ducpy-3.3.7}/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.5 → ducpy-3.3.7}/src/ducpy/classes/ElementsClass.py

@@ -393,6 +393,7 @@ class DucDocElement:
     text: str
     grid_config: DocumentGridConfig
     file_id: Optional[str] = None
+    referenced_file_ids: Optional[List[str]] = None
 
 @dataclass
 class DucTableElement:
@@ -482,6 +483,13 @@ class DucModelElement:
     thumbnail: Optional[bytes] = None
     viewer_state: Optional[Viewer3DState] = None
 
+    def __post_init__(self):
+        valid_types = {"python", "ifc", "dxf", "dwg", "step", "stl"}
+        if self.model_type is None:
+            self.model_type = "python"
+        if self.model_type not in valid_types:
+            raise ValueError(f"Invalid model_type: {self.model_type}. Allowed types: {sorted(list(valid_types))}")
+
 
 # =============== BLOCK DEFINITIONS ===============