niqzart/pydantic-marshals

Library for creating partial pydantic models (automatic converters) from different mappings

 

pydantic-marshals's Issues

Support flattening JSON contents

Same as #5, but getting a model like:

{
  "a": 1,
  "b": "string",
}

From the Model class:

class DataAB(TypedDict):
    a: int
    b: str

class Model(Base):
    ...
    data: Mapped[DataAB] = mapped_column()
    # TODO check if using TypedDict is even possible here

Patch-like models from sqlalchemy

Support the following (syntax may differ):

class User(Base):
    ...
    name: Mapped[str] = mapped_column()
    description: Mapped[str | None] = mapped_coumn()

    ExampleModel = MappedModel.create(columns=[name], patch_like=True)

Test cases and behaviour:

{}  # not changing anything
{"name": "hey"}  # only setting name to "hey"
{"description": "test"}  # only setting description to "test"
{"description": null}  # setting description to None

List relationships in asyncio version sqlalchemy

• Describe why it doesn't work in docs
• Add a workaround (via selectinload & such)
• Allow adding such relationships normally?

https://docs.sqlalchemy.org/en/20/orm/extensions/asyncio.html#preventing-implicit-io-when-using-asyncsession

Optional Relationships v1

Type override for sqlalchemy columns

Tests for base

Github releases are out of date with ones at PyPI

Push to PyPI on main & tag pushes

Tests for PropertyFields

Unit tests for MappedModel

Actual documentation for implementaion for sqlalchemy

Support flattenning nested fields

It could be useful to be able to get a model like:

{
  "a_f": 1,
  "b_f": 2,
}

From B in this setup:

class A(Base):
    id: Mapped[int] = mapped_column(primary_key=True)
    a_f: Mapped[int] = mapped_column()

class B(Base):
    b_f: Mapped[int] = mapped_column(primary_key=True)
    a_id: Mapped[int] = mapped_column(ForeignKey("a.id"))
    a: Mapped[A] = relationship()

So a will be accessed via the relationship, but it's fields are not nested (i.e. it's not a.a_f)

Support arbitrary types assertion

This should work:

from pydantic_marshals.contains import assert_contains

class MyClass:
    pass

assert_contains(
    MyClass(),
    MyClass,
)

But instead this raises an error:

pydantic.errors.PydanticSchemaGenerationError: Unable to generate pydantic-core schema for <class '__main__.MyClass'>. Set `arbitrary_types_allowed=True` in the model_config to ignore this error or implement `__get_pydantic_core_schema__` on your type to fully support it.

If you got this error by calling handler(<some type>) within `__get_pydantic_core_schema__` then you likely need to call `handler.generate_schema(<some type>)` since we do not call `__get_pydantic_core_schema__` on `<some type>` otherwise to avoid infinite recursion.

For further information visit https://errors.pydantic.dev/2.6/u/schema-for-unknown-type

Input mode for models

Tests for RelationshipFields

Integrational test(s) for MappedModel

Support using pydantic model instances as type checkers

This should work:

from pydantic import BaseModel
from pydantic_marshals.contains import assert_contains

class MyModel(BaseModel):
    some_field: int

assert_contains(
    MyModel(some_field=3),
    MyModel(some_field=3),
)

But instead this raises an error:

RuntimeError: Couldn't convert field: (MyModel(some_field=3),)

Tests for ColumnFields

Optional Relationships v2