Export/import object (with children) to clear text

[schoeller]

Dear all,

I would like to be able to develop (label) styles and export/import them in clear text. This way it is possible to store them for versioning in a repository. Import/export workflow should overwrite style independant of its objectId.

I have seen the following approaches

1. Object serialization
2. Get/set User data

Formats could be json, txt, csv etc. I would start out as follows:

import traceback

from pyrx_imp import Ap, Db, Cv

def PyRxCmd_doit9():
    try:
        db = Db.curDb()

        bt = Db.BlockTable(db.blockTableId())
        styleid = Cv.CvDbSymbolStyleManager.getManagerId(db)
        manager = Cv.CvDbSymbolStyleManager(styleid, Db.OpenMode.kForRead)
        for id in manager.ids(): 
            style = Cv.CvDbStyle(id)
            print(style.name())

    except Exception:
        traceback.print_exc()

Suggestions appreciated.

Best

Seb

[gswifort]

I need a deeper introduction to comment (I don't work on Bricscad). I don't fully understand what you want to do, what the goal is and what are the issues to solve.

[CEXT-Dan]

@gswifort
A simpler example would be, how to serialize a TextStyle in human readable form

@schoeller
It’s not trivial. I would have started with DXF codes, something like this. However, it seems Bricsys has not written DXF filers for these new objects.
Your only other option is to map out every value.

        db = Db.curDb()
        mgrid = Cv.CvDbStyleManager.getManager(db,Cv.StyleManagerType.eSymbolStyle)
        mgr = Cv.CvDbStyleManager(mgrid)
        for id in mgr.ids():
            print(Db.Core.entGet(id))

[gswifort]

Is it supposed to be something like this?

from __future__ import annotations

import json
import traceback
import typing as t

from pydantic import BaseModel
from pyrx_imp import Db
from PyRxDebug import startListener as PyRxCmd_debug  # noqa

if t.TYPE_CHECKING:
    import _typeshed as _t


class TextStyleModel(BaseModel):
    Name: str
    Font: tuple[str, bool, bool, int, int, int]
    IsVertical: bool
    IsAnnotative: str
    # ...

    @classmethod
    def fromTextStyleTableRecord(cls, ts: Db.TextStyleTableRecord) -> t.Self:
        name = ts.getName()
        font = ts.font()
        is_vertical = ts.isVertical()
        is_annotative = cls._get_enum_repr(ts.isAnnotative())
        # ...
        return cls(
            Name=name,
            Font=font,
            IsVertical=is_vertical,
            IsAnnotative=is_annotative,
            # ...
        )

    def toTextStyleTableRecord(self) -> Db.TextStyleTableRecord:
        ts = Db.TextStyleTableRecord()
        ts.setName(self.Name)
        ts.setFont(*self.Font, True)
        ts.setIsVertical(self.IsVertical)
        ts.setAnnotative(self._get_enum_from_repr(self.IsAnnotative))
        # ...
        return ts

    @classmethod
    def _get_enum_from_repr(cls, __repr: str, /):
        mod_name, enum_name, mem_name = __repr.split(".")
        mod = globals().get(mod_name)
        assert mod is not None
        enum = getattr(mod, enum_name)
        mem = getattr(enum, mem_name)
        return mem

    @classmethod
    def _get_enum_repr(cls, __enum, /) -> str:
        return repr(__enum).removeprefix("Py")

    def dump(self, filename: _t.FileDescriptorOrPath) -> None:
        data = self.model_dump(mode="json")
        with open(filename, "w", encoding="utf-8") as f:
            json.dump(data, f, indent=4)

    @classmethod
    def load(cls, filename: _t.FileDescriptorOrPath) -> t.Self:
        with open(filename, "r", encoding="utf-8") as f:
            data = json.load(f)
        self = cls.model_validate(data)
        return self


def main():
    FILENAME = "test.json"
    db = Db.curDb()
    tst = Db.TextStyleTable(db.textStyleTableId())
    ts = Db.TextStyleTableRecord(tst.recordIds()[0])

    model = TextStyleModel.fromTextStyleTableRecord(ts)
    model.dump(FILENAME)
    new_model = TextStyleModel.load(FILENAME)
    assert model == new_model
    new_ts = model.toTextStyleTableRecord()


def PyRxCmd_doit():
    try:
        main()
    except Exception:
        traceback.print_exc()

test.json:

{
    "Name": "Standard",
    "Font": [
        "Arial",
        false,
        false,
        0,
        2,
        32
    ],
    "IsVertical": false,
    "IsAnnotative": "Db.AnnotativeStates.kFalse"
}

[schoeller]

Is it supposed to be something like this?

thanks a ton for the suggestion. I will feed back.