I ask because I find myself writing the following pattern a lot, which the above is essentially sugar for.

class MyDataClass:
   foo_str: str

   def __post_init__(self):
       self.foo = decoder(self.foo_str)

   @classmethod
   def from_foo(cls, foo: Foo):
       return cls(foo_str=encoder(foo))

[flyte-core]

AFAIK the default encoder and decoder (without additional metadata), assumes a serialization to string. If I understand correctly, you can also specify

mm_field

to specify an alternate intermediate marshmallow type in the schema, which then needs to match up with the return/call signature of your encoder/decoder respectively.

But I haven't tried that

If you're asking what I personally use this for, I like to use it for serializing type and function objects. So for example:

def import_from_str(obj_qual_name: str):
    module_str, obj_qual_name = obj_qual_name.rsplit(sep='.', maxsplit=1)
    module = importlib.import_module(module_str)
    return getattr(module, obj_qual_name)


def full_name_from_obj(obj) -> str:
    return f'{inspect.getmodule(obj).__name__}.{obj.__qualname__}'


TYPE_SERIALIZER = config(
    encoder=full_name_from_obj,
    decoder=import_from_str
)


@dataclass_json
@dataclass
class ModelSpec:
    model: Type[PreTrainedModel]
    preprocessor_factory: Type[PreprocessorFactory] = field(metadata=TYPE_SERIALIZER)
    training_args: Dict = field(default_factory=dict)
    model_weights: PyTorchCheckpoint
    model_args: Dict = field(default_factory=dict)
    weight_preprocessing: Callable = field(metadata=TYPE_SERIALIZER, default=noop)