Reuse computed csfield as a scratch property

[dogtopus]

In one of my projects I reused DataclassStruct as generic Python objects, with different DataclassStructs inheriting the same abstract class for common behaviors. One of the Structs however has data that cannot be parsed into a variable-length Python list losslessly, so I introduced a computed length field that pulls the length value from its parent, where that value is stored, and implemented the business-logic-related generic stuff defined in the abstract class using that length field. The problem is that when building using such Struct, with the older version of construct-typing, I get a partially generated init that does not allow me to pass values to the computed field, and with 0.8.x I still wasn't able to easily pass values to it since none of the newly introduced helpers allow me to define a computed field that can intentionally be initialized from Python side.

To get around this, I currently define a new property that automatically chooses values between a computed private csfield_noinit and a stock dataclass public field (created manually with subcon=Pass metadata) when it was read. It's ugly and I'm surprised that accessing that property from the parent Struct using this actually worked, but it mostly does what I want, however it would still be nice if the computed field can just be initialized with regular init, defined by a different helper than csfield of course.

[timrid]

I don't quite understand the problem yet. Could you please write a short code example showing what you did with the old version, what you're doing with v0.8.x, and how you'd prefer it to work with the new version?

[dogtopus]

It would be something like this:

@dataclass
class ParentContainer(DataclassMixin):
    _effective_obj_size: int | None = csfield_noinit(Int8ul, Rebuild(this.obj.size))
    # pre-0.8.x this was
    #_effective_obj_size: int = csfield(Int8ul, Rebuild(this.obj.size))
    obj: DataContainer = csfield(CsDataContainer)  # In real implementation this is a csfield(Switch(...)) that selects from a few DataContainer-likes by an object kind field also located in ParentContainer. Simply put, the DataContainer may or may not have the ability to self-describe its length with len(DataContainer.raw_data), and this affects how DataContainer.effective_size is implemented.


CsParentContainer = DataclassStruct(ParentContainer)


# Before 0.8.x I have something like this for the data container:
@dataclass
class DataContainer(DataclassMixin, DataABC):
    _effective_size: int = csfield(Computed(this._._effective_obj_size))
    # Fixed size lookup table that has its real number of elements described in effective_size. This cannot be stored within raw_data or its metadata (like len())
    raw_data: list[int] = csfield(Array(16 * 16, Int32ul))

    @property
    @override
    def effective_size(self) -> int:
        return self._effective_size

    # ... other processing that derive things from raw_data and effective_size, and also builds DataContainer from other types of input other than just raw data.


# Currently it's implemented as such
@dataclass
class DataContainer(DataclassMixin, DataABC):
    _effective_size: int | None = csfield_noinit(Computed(this._._effective_obj_size))
    raw_data: list[int] = csfield(Array(16 * 16, Int32ul))
    effective_size_from_dc: int = field(default=0, metadata={'subcon': Pass})

    @property
    @override
    def effective_size(self) -> int:
        if self._effective_size is not None and self._effective_size != self.effective_size_from_dc:
            self.effective_size_from_dc = self._effective_size
        return self.effective_size_from_dc

    # ... other processing that derive things from raw_data and effective_size, and also builds DataContainer from other types of input other than just raw data.


# Ideally I want something like this
@dataclass
class DataContainer(DataclassMixin, DataABC):
    # init will require the caller to pass an int to effective_size_temp, but the value will not be used directly in the building of DataContainer, but rather the ParentContainer
    effective_size_temp: int = csfield_nobacking(Computed(this._._effective_obj_size), dc_default=0)
    raw_data: list[int] = csfield(Array(16 * 16, Int32ul))

    @property
    @override
    def effective_size(self) -> int:
        return self.effective_size_temp

    # ... other processing that derive things from raw_data and effective_size, and also builds DataContainer from other types of input other than just raw data.