ducpy 3.3.5__tar.gz → 3.3.6__tar.gz

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

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

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

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

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

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

{ducpy-3.3.5 → ducpy-3.3.6}/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.6}/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.6}/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.6}/packages/ducrs/tests/common/mod.rs

@@ -659,6 +659,7 @@ pub fn synthetic_roundtrip_state() -> ExportedDataState {
                     scale: 2.0,
                 },
                 file_id: Some("file-model".to_string()),
+                referenced_file_ids: vec!["file-model".to_string()],
             }),
         },
         ElementWrapper {

{ducpy-3.3.5 → ducpy-3.3.6}/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.6}/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.6/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.6}/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.6}/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.6}/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 ===============
 

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

@@ -7,9 +7,12 @@ from __future__ import annotations
 import logging
 import os
 import re
+import subprocess
+import sys
+import tempfile
 from dataclasses import asdict, is_dataclass
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple
 
 import ducpy_native
 from ducpy.utils.convert import (deep_snake_to_camel, snake_to_camel,
@@ -18,6 +21,14 @@ from ducpy.utils.convert import (deep_snake_to_camel, snake_to_camel,
 logger = logging.getLogger(__name__)
 
 
+class DucSerializationValidationError(ValueError):
+    """Raised when embedded element code fails validation before serialization."""
+
+    def __init__(self, failures: List[str]):
+        self.failures = failures
+        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:
@@ -200,6 +211,218 @@ def _convert_list(items: Optional[list]) -> Optional[list]:
     return [to_serializable(item) for item in items]
 
 
+def _element_label(element: Dict[str, Any]) -> str:
+    element_id = element.get("id") or element.get("elementId") or "unknown"
+    element_type = element.get("type") or "element"
+    return f"{element_type} {element_id}"
+
+
+def _find_revision(revisions: Any, active_revision_id: str) -> Optional[Dict[str, Any]]:
+    if not isinstance(revisions, dict):
+        return None
+    if active_revision_id in revisions:
+        return revisions[active_revision_id]
+    
+    # Try simple camelCase match fallback since deep_snake_to_camel converts keys
+    camel_id = snake_to_camel(active_revision_id)
+    if camel_id in revisions:
+        return revisions[camel_id]
+        
+    for r in revisions.values():
+        if isinstance(r, dict):
+            r_id = r.get("id") or r.get("key")
+            if r_id == active_revision_id or r_id == camel_id:
+                return r
+                
+    if revisions:
+        first_val = next(iter(revisions.values()))
+        if isinstance(first_val, dict):
+            return first_val
+            
+    return None
+
+
+def _write_python_external_files(
+    project_dir: Path,
+    files_meta: Optional[Dict[str, Any]],
+    files_data: Optional[Dict[str, bytes]],
+) -> Dict[str, str]:
+    resolved_paths: Dict[str, str] = {}
+    if not files_meta or not files_data:
+        return resolved_paths
+
+    for file_id, meta in files_meta.items():
+        if not isinstance(meta, dict):
+            continue
+
+        active_revision_id = meta.get("activeRevisionId") or meta.get("active_revision_id")
+        revisions = meta.get("revisions") or {}
+        revision = _find_revision(revisions, active_revision_id) if active_revision_id else None
+        if not active_revision_id or not isinstance(revision, dict):
+            continue
+
+        data = files_data.get(active_revision_id)
+        if data is None:
+            continue
+
+        source_name = revision.get("sourceName") or revision.get("source_name") or "file"
+        safe_name = re.sub(r"[^a-zA-Z0-9._-]", "_", str(source_name).strip() or "file")
+        target = project_dir / "scopture-files" / str(file_id) / safe_name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(bytes(data))
+        resolved_paths[file_id] = str(target.resolve())
+
+    return resolved_paths
+
+
+def _run_python_validation(
+    code: str,
+    label: str,
+    timeout_seconds: Optional[float],
+    files_meta: Optional[Dict[str, Any]] = None,
+    files_data: Optional[Dict[str, bytes]] = None,
+) -> Optional[str]:
+    with tempfile.TemporaryDirectory(prefix="ducpy-model-") as tmpdir:
+        tmp_path = Path(tmpdir)
+        resolved_files = _write_python_external_files(tmp_path, files_meta, files_data)
+
+        import json
+        resolved_files_json = json.dumps(resolved_files)
+
+        header = f"""
+import json
+import os
+import sys
+
+_RESOLVED_EXTERNAL_FILES = json.loads({repr(resolved_files_json)})
+
+def resolve_external_file(file_id):
+    if file_id in _RESOLVED_EXTERNAL_FILES:
+        return _RESOLVED_EXTERNAL_FILES[file_id]
+    raise FileNotFoundError(f"External file '{{file_id}}' not found in validation sandbox.")
+
+globals()["resolve_external_file"] = resolve_external_file
+import builtins
+builtins.resolve_external_file = resolve_external_file
+"""
+        script_path = tmp_path / "model.py"
+        script_path.write_text(header + "\n" + code, encoding="utf-8")
+
+        run_kwargs = {
+            "cwd": tmpdir,
+            "text": True,
+            "stdout": subprocess.PIPE,
+            "stderr": subprocess.PIPE,
+            "check": False,
+        }
+        if timeout_seconds is not None:
+            run_kwargs["timeout"] = timeout_seconds
+
+        try:
+            completed = subprocess.run(
+                [sys.executable, str(script_path)],
+                **run_kwargs,
+            )
+        except subprocess.TimeoutExpired as exc:
+            return f"{label}: Python validation timed out after {timeout_seconds:g}s"
+        except OSError as exc:
+            return f"{label}: failed to start Python validation: {exc}"
+
+    if completed.returncode == 0:
+        return None
+
+    output = (completed.stderr or completed.stdout or "Python process exited with an error").strip()
+    return f"{label}: Python validation failed\n{output}"
+
+
+def _write_typst_external_files(project_dir: Path, files_meta: Optional[Dict[str, Any]], files_data: Optional[Dict[str, bytes]]) -> None:
+    if not files_meta or not files_data:
+        return
+
+    for file_id, meta in files_meta.items():
+        if not isinstance(meta, dict):
+            continue
+
+        active_revision_id = meta.get("activeRevisionId") or meta.get("active_revision_id")
+        revisions = meta.get("revisions") or {}
+        revision = _find_revision(revisions, active_revision_id) if active_revision_id else None
+        if not active_revision_id or not isinstance(revision, dict):
+            continue
+
+        data = files_data.get(active_revision_id)
+        if data is None:
+            continue
+
+        source_name = revision.get("sourceName") or revision.get("source_name") or "file"
+        safe_name = re.sub(r"[^a-zA-Z0-9._-]", "_", str(source_name).strip() or "file")
+        target = project_dir / "scopture-files" / str(file_id) / safe_name
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(bytes(data))
+
+
+def _run_typst_validation(
+    code: str,
+    label: str,
+    timeout_seconds: float,
+    files_meta: Optional[Dict[str, Any]],
+    files_data: Optional[Dict[str, bytes]],
+) -> Optional[str]:
+    try:
+        import typst  # type: ignore[import-not-found]
+    except ModuleNotFoundError:
+        return f"{label}: Typst validation requires the 'typst' package. Install it with 'pip install typst'."
+
+    with tempfile.TemporaryDirectory(prefix="ducpy-typst-") as tmpdir:
+        project_dir = Path(tmpdir)
+        main_path = project_dir / "main.typ"
+        main_path.write_text(code.replace('"/scopture-files/', '"scopture-files/'), encoding="utf-8")
+        _write_typst_external_files(project_dir, files_meta, files_data)
+
+        try:
+            try:
+                typst.compile(str(main_path), format="pdf")
+            except TypeError:
+                typst.compile(str(main_path))
+        except Exception as exc:
+            return f"{label}: Typst validation failed\n{exc}"
+
+    return None
+
+
+def _validate_embedded_code(
+    elements: List[Any],
+    files_meta: Optional[Dict[str, Any]],
+    files_data: Optional[Dict[str, bytes]],
+    timeout_seconds: float,
+) -> None:
+    failures: List[str] = []
+
+    for element in elements:
+        if not isinstance(element, dict):
+            continue
+
+        element_type = element.get("type")
+        label = _element_label(element)
+
+        if element_type == "model":
+            code = element.get("code")
+            if isinstance(code, str) and code.strip():
+                error = _run_python_validation(code, label, timeout_seconds, files_meta, files_data)
+                if error:
+                    failures.append(error)
+            continue
+
+        if element_type == "doc":
+            text = element.get("text")
+            if isinstance(text, str) and text.strip():
+                error = _run_typst_validation(text, label, timeout_seconds, files_meta, files_data)
+                if error:
+                    failures.append(error)
+
+    if failures:
+        raise DucSerializationValidationError(failures)
+
+
 def serialize_duc(
     name: str,
     thumbnail: Optional[bytes] = None,
@@ -215,6 +438,8 @@ def serialize_duc(
     regions: Optional[list] = None,
     layers: Optional[list] = None,
     external_files: Optional[list] = None,
+    validate_embedded_code: bool = True,
+    validation_timeout_seconds: Optional[float] = None,
 ) -> bytes:
     """Serialize elements and document state to raw ``.duc`` binary format.
 
@@ -253,6 +478,12 @@ def serialize_duc(
         List of document layers.
     external_files : Optional[list], default=None
         List of external files (e.g., embedded images or PDFs).
+    validate_embedded_code : bool, default=True
+        Validate model Python code and document source before native serialization.
+        This is intended for server-side CPython usage and raises
+        DucSerializationValidationError with per-element diagnostics on failure.
+    validation_timeout_seconds : float, optional, default=None
+        Timeout used for each embedded code validation step. If None, no timeout is applied.
 
     Returns
     -------
@@ -263,12 +494,22 @@ def serialize_duc(
 
     files_meta, files_data = _convert_external_files(external_files)
 
+    serialized_elements = [_element_to_camel(e) for e in (elements or [])]
+
+    if validate_embedded_code:
+        _validate_embedded_code(
+            serialized_elements,
+            files_meta,
+            files_data,
+            validation_timeout_seconds,
+        )
+
     data: Dict[str, Any] = {
         "type": "duc",
         "version": DUC_SCHEMA_VERSION,
         "source": f"ducpy_{name}",
         "thumbnail": thumb,
-        "elements": [_element_to_camel(e) for e in (elements or [])],
+        "elements": serialized_elements,
         "blocks": _convert_list(blocks) or [],
         "blockInstances": _convert_list(block_instances) or [],
         "blockCollections": _convert_list(block_collections) or [],

{ducpy-3.3.5 → ducpy-3.3.6}/src/ducpy/utils/__init__.py

@@ -1,4 +1,5 @@
 from .constants import *
 from .rand_utils import *
 from .io import *
-from .mutate_utils import *
+from .mutate_utils import *
+from .convert import *

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

@@ -60,7 +60,7 @@ def deep_snake_to_camel(obj: Any) -> Any:
     if is_dataclass(obj) and not isinstance(obj, type):
         return deep_snake_to_camel(asdict(obj))
     if isinstance(obj, bytes):
-        return list(obj)
+        return obj
     return obj
 
 
@@ -80,7 +80,7 @@ def to_serializable(obj: Any) -> Any:
 
     Handles:
     - Dataclass instances → dict (recursively)
-    - bytes → list of ints
+    - bytes → bytes (native serializer accepts PyBytes for binary fields)
     - Nested base/styles/linear_base/stack_element_base → flattened
     - snake_case keys → camelCase keys
     """
@@ -97,5 +97,49 @@ def to_serializable(obj: Any) -> Any:
     if isinstance(obj, list):
         return [to_serializable(item) for item in obj]
     if isinstance(obj, bytes):
-        return list(obj)
+        return obj
     return obj
+
+
+def extract_embedded_code(func) -> str:
+    """Extracts the body of a Python function as a clean standalone script.
+
+    This is highly useful for defining CAD/BIM model generation code as actual,
+    syntax-highlighted Python functions inside examples/tests, and then serializing
+    them to DUC.
+
+    Args:
+        func: The Python function/callable to extract the body from.
+
+    Returns:
+        The body of the function as a clean, dedented string.
+    """
+    import inspect
+    import textwrap
+
+    if not callable(func):
+        raise TypeError(f"extract_embedded_code expects a callable, got {type(func).__name__}")
+
+    try:
+        source = inspect.getsource(func)
+    except OSError as exc:
+        raise ValueError(
+            f"Could not retrieve source code for {func.__name__ if hasattr(func, '__name__') else func}. "
+            "Ensure the function is defined in a physical file rather than dynamically."
+        ) from exc
+
+    lines = source.splitlines()
+
+    # Locate the starting 'def ' statement (skipping decorators)
+    try:
+        def_idx = next(i for i, line in enumerate(lines) if line.strip().startswith("def "))
+    except StopIteration:
+        # If no 'def ' was found (e.g. lambda), return the whole source dedented
+        return textwrap.dedent(source)
+
+    body_lines = lines[def_idx + 1:]
+
+    # Reconstruct and dedent the body
+    body_content = "\n".join(body_lines)
+    return textwrap.dedent(body_content)
+

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

@@ -1,20 +0,0 @@
--- Migration: 3000003 → 3000004
--- Rename element_model.svg_path (TEXT) to thumbnail (BLOB).
--- SQLite does not support ALTER COLUMN, so we recreate the table.
-
-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);