trimatix / carica Goto Github PK

like what schemathesis do

especially useful for union

This may well require a separate package to keep the synchronous version fast

Allow async serialize/deserialize

just return list(self.__dataclass_fields__.keys())

exclude test files from coverage reports and PR commenter

Allow a model's serialize to fail partially by adding a callback parameter. E.g SerializableDataclass attempts to serialize each Serializable field. If one throws an exception, pass it to the callback, then carry ok serializing the others.

#6 would be ideal for this

• unindented keyword arguments:

myCallable(
myKwarg=1
)

myKwarg identified as variable

Placed on a variable in cfg to require that the variable be specified in TOML. x could be an Optional allowing the variable to still be given as null, but it must be supplied as such in TOML, not just left to its default.

to reproduce:

1. python -m pip install carica
2. python
3. import carica
4. observe error
5. import tomlkit
6. observe error

e.g cannot parameterize generics with other generics

if not enough code is covered, the action fails before the comment can be made. Move the commenter to a separate action on the same trigger.

It's annoying to have to write my own type hints to guarantee that my types with serialize to dict

TSelf = TypeVar("TSelf", bound="SerializesToType")
TSerialized = TypeVar("TSerialized", bound="PrimativeType")

class SerializesToType(Generic[TSerialized]):
    def serialize(self, **kwargs) -> TSerialized: ...

    @classmethod
    def deserialize(cls: Type[TSelf], data: TSerialized, **kwargs) -> TSelf: ..

x: SerializesToType[Dict[str, PrimativeType]] = MyClass()
y: Dict[str, PrimativeType] = x.serialize()

Just inherit dict but with value auto-serializing serialize/deserialize methods (similar to SerializableDataclass)

effectively makes your class work like a serializabledataclass

Stack on top of a @property call to mark a property as a field in the objects serialised JSON

Probably also include "JSON property name override" and "required" params

Is there a way to swap serialize out for a private _serialize that can optionally call preserialize/postserialize methods around the overloaded methods?

Configurable comment prefix that will make a comment detected as a section/header (e.g "###")

These are saved to file

Need to consider that variable ordering is NOT guaranteed, since tables must come last. One possible solution is, if a table did not come last in the module, add another copy of the must recent section/header in the module before that table

SerializableType.deserialize requires any implementing classes to return SerializableType and not their own class.

Fix this with something similar to:

TSelf = TypeVar("TSelf", bound="SerializableType")

class SerializableType(Protocol):
    def serialize(self, **kwargs) -> PrimativeType: ...

    @classmethod
    def deserialize(cls: Type[TSelf], data: PrimativeType, **kwargs) -> TSelf: ..

Probably for the far far future

This feature is mostly complete but tests fail under certain conditions when saving preceeding comments for structural variables (tables and arrays).

Variable is not ordering is not guaranteed. This is due to the TOML spec requiring that structural variables appear at the end of a document to resolve ambiguities in the variable heirarchy.
Since ordering is not guaranteed, and tomlkit does not explicitly know that preceeding comments are associated with variables, structural variables can be moved around during document rendering, with their preceeding comments left behind in undesirable locations in the document.

An unideal solution to this problem could make use of reflection, in a sense. A tomlkit document maintains two private fields:

• _body: A list of (key (name), value) tuples
• _map: A dictionary mapping a key (name) to the index of the key in _body.
  It may be possible to manipulate the rendering order of the document by manually moving the index of preceeding comments to just before the new table location. Depending on when reordering takes place, this may or may not be feasible.

there may be other easier solutions, or if all else fails, we can just manipulate the rendered string.

Use the Karma theme

https://stackoverflow.com/questions/9575409/calling-parent-class-init-with-multiple-inheritance-whats-the-right-way

def __init__(self, *args, **kwargs):
    super().__init__(*args, **kwargs)

Read a config file into dict, update the values in the dict with the values in a module, but only those keys that already exist, and write the dict back to the same file including comments etc

Is there a way to preserve ALL formatting e.g added whitespace? Does tomlkit do that?

• allows for deeper configuration of carica (e.g #53)
• allows for stateful config management (e.g #8)

e.g cannot deserialize a List[SerializableType]

had a lot of details trying to accomplish this, see the commit history of this PR for details: #59

in order to overcome limiting dataclass field hints to a primative Unions, all types in the union are recursed over and the first successful deserialize is accepted.

Instead, all types in the union should be attempted, and the 'best match' selected. This could be quite slow, so perhaps parameterize this in carica configuration?