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.

[schoeller]

Without knowing what I do I have discovered a pickle interface for Ge.Point2d, Ge.Point3d and PyDbHandle. When I run

import traceback
from pyrx_imp import Ap, Db, Ge

from serialize import dump, dumps
from serialize import load, loads

@Ap.Command()
def serializetest():
    try:
        db = Db.curDb()
        p2 = Ge.Point3d(50, 25, 0)
        print(dumps(p2, fmt='yaml'))
        tmp = dumps(p2, fmt='yaml')
        tmp = loads(tmp, fmt='yaml')
        print(tmp)

    except Exception as err:
        traceback.print_exception(err)

I receive the output

: SERIALIZETEST
b'!!python/object/apply:PyGe.Point3d\n- 50.0\n- 25.0\n- 0.0\n'
(50.00000000000000,25.00000000000000,0.00000000000000)

To my disorientated understanding this respresents a complete workthrough for pickling. Is it correct thus to assume, that when adding the method .def_pickle and a function which returns a string like toString() in makePyDbHandleWrapper this would suffice for serialization/deserialization of other objects like TextStyleTableRecord?

Don't know whether this leads anywhere...

Best

Seb

[CEXT-Dan]

Unfortunately, I don’t think pickle would work on Database objects due to them having ownership and relationships with other objects.
Grzegorz's idea of having a factory class would be the best. In that case you can do something like,

If: Style is in the database, update the properties
Else: add a new style and update the properties

[CEXT-Dan]

BTW, I had mentioned DXF, consider this sample where you can make a text style, you would need to look up the DXF codes, but this would be easy to serialize

import traceback
from pyrx_imp import Ap, Db, Ge, Ed


@Ap.Command()
def doit():
    try:
        db = Db.curDb()
        print(Db.Core.entGet(db.textstyle()))  # standard
    except Exception as err:
        traceback.print_exception(err)


@Ap.Command()
def doit2():
    try:
        db = Db.curDb()

        # make standard2
        style = [
            (0, "STYLE"),
            (5, "11"),
            (100, "AcDbSymbolTableRecord"),
            (100, "AcDbTextStyleTableRecord"),
            (2, "Standard2"),
            (70, 0),
            (40, 0.0),
            (41, 1.0),
            (50, 0.0),
            (71, 0),
            (42, 0.2),
            (3, "arial.ttf"),
            (4, ""),
        ]

        print(Db.Core.entMake(style))

    except Exception as err:
        traceback.print_exception(err)

[schoeller]

I am giving up on CvDbStyleManager import/export for the mo. Would like to mark both responses as answer, but not possible. Cheers for reaching out.

[schoeller]

Have attemped different to previous implementation the following approach:

import traceback
from pyrx_imp import Ap, Db

from serialize import dumps
from serialize import register_class

def user_to_builtin(u):
    return

def user_from_builtin(c):
    return

@Ap.Command()
def doit():
    try:
        db = Db.curDb()
        print(Db.Core.entGet(db.textstyle()))  # standard
        register_class(Db.TextStyleTableRecord, user_to_builtin, user_from_builtin)

        dumps(Db.Core.entGet(db.textstyle()), fmt='yaml')

    except Exception as err:
        traceback.print_exception(err)

It throws:

RuntimeError: Pickling of "PyDb.ObjectId" instances is not enabled (http://www.boost.org/libs/python/doc/v2/pickle.html)

Dunno whether pickling of objectids would lead to anything. If-Else structure would also be required I suppose. Any plans to support pickling for objedids?

[CEXT-Dan]

I did not add ObjectIds because you can’t deserialize them in a way CAD will accept, they are assigned by the application, and are different between sessions.
If your plan is to use entmake, the list should not contain ObjectIds .