class SlotTransactionStats:
"""Slot transaction stats."""
num_transaction_entries: int = field(metadata=alias("numTransactionEntries"))
num_successful_transactions: int = field(metadata=alias("numSuccessfulTransactions"))
num_failed_transactions: int = field(metadata=alias("numFailedTransactions"))
max_transactions_per_entry: int = field(metadata=alias("maxTransactionsPerEntry"))
class RootJsonSchema:
schema: Union[str, UndefinedType] = field(default=Undefined,
metadata=alias("$schema"))
defs: list[JsonSchema] = field(default_factory=list,
metadata=alias("$defs"))
# This field schema is flattened inside the owning one
json_schema: JsonSchema = field(default=JsonSchema(), metadata=flatten)
class Foo:
bar: int = field(
default=0,
metadata=alias("foo_bar") | schema(title="foo! bar!", min=0, max=42)
| required,
)
baz: Annotated[int,
alias("foo_baz"),
schema(title="foo! baz!", min=0, max=32), required] = 0
def complete_data():
return [
..., # shortcut to include all the fields
Data.size,
(Data.get_details,
alias("details")), # add/override metadata using tuple
]
class VoteItem:
"""Vote data."""
vote_pubkey: str = field(metadata=alias("votePubkey"))
hash: str
slots: List[int]
timestamp: Optional[int]
class GraphAxis:
hashKey: str = field(default="", metadata=apischema.alias("$$hashKey"))
format: str = ""
logBase: int = 1
show: bool = True
mode: str = "time"
values: list = field(default_factory=list)
class AccountInfo:
"""Account information."""
lamports: int
owner: PublicKey
data: Union[Literal[""], Tuple[str, str], Dict[str, Any]]
executable: bool
rent_epoch: int = field(metadata=alias("rentEpoch"))
def lazy_model2() -> Type:
return make_dataclass("LazyModel",
[("a", int, field(metadata=alias("b")))])
from apischema import UndefinedType, alias, properties
from apischema.metadata import flatten, skip
from apischema.serialization import PassThroughOptions, pass_through
from apischema.utils import to_camel_case
@dataclass
class Flattened:
field: int
@mark.parametrize(
"option_and_field",
[
("aliaser", ("with_underscore", int)),
("aliased_fields", ("aliased", int, field(metadata=alias("toto")))),
("flattened_fields",
("flattened", Flattened, field(metadata=flatten))),
(
"properties_fields",
("properties", Dict[str, int], field(metadata=properties)),
),
("skipped_fields", ("skipped", int, field(metadata=skip))),
("skipped_if_fields", ("skippedif", Union[int, UndefinedType])),
],
)
@mark.parametrize("has_field", [False, True])
@mark.parametrize("has_option", [False, True])
@mark.parametrize("uuid_field", [False, True])
def test_pass_through_dataclasses(option_and_field, has_field, has_option,
uuid_field):
class SimpleModel2:
a: int = field(metadata=alias("b"))
class Foo:
bar: int = field(
default=0,
metadata=alias("foo_bar") | schema(title="foo! bar!", min=0, max=42)
| required,
)
class Foo:
field1: Any
field2: Any = field(metadata=alias(override=False))
field3: Any = field(metadata=alias("field03"))
field4: Any = field(metadata=alias("field04", override=False))
class Foo(TaggedUnion):
bar: Tagged[Bar]
# Tagged can have metadata like a dataclass fields
i: Tagged[int] = Tagged(alias("baz") | schema(min=0))
def bar(
self, param: Annotated[int, alias("arg") | schema(description="argument")]
) -> int:
return param
class DashboardTime:
from_: str = field(default="now-1h", metadata=apischema.alias("from"))
to: str = "now"
class Foo(Generic[V]):
values_with_priority: Dict[int, V] = field(
metadata=alias("values") | conversion(serialization=sort_by_priority))
class DataModel2:
a: int = field(metadata=alias("b"))
class Foo:
class_: str = field(metadata=alias("class"))
def prefixed_foo(baz: str, pfx: Annotated[str, alias("prefix")] = "") -> Foo:
return Foo(pfx + baz)
class Class:
not_aliased: int = field(metadata=alias(override=False))
not_prefixed: int = field(metadata=alias("not_overridden", override=False))
prefixed: int
prefixed_alias: str = field(metadata=alias("alias"))
class Foo:
values_with_priority: Dict[int, str] = field(
metadata=alias("values") | conversions(serializer=sort_by_priority))
