diff --git a/schemas/_operation_objects.py b/schemas/_operation_objects.py index d14290783fae81b8d59b7320e71ffb9ac44076b1..93482c31a7597cedc1182388da7e8bf334afc79d 100644 --- a/schemas/_operation_objects.py +++ b/schemas/_operation_objects.py @@ -12,16 +12,19 @@ from schemas.operations import ( ) -class ApiOperationObjectCommons(PreconfiguredBaseModel): +class ApiOperationObjectCommonsBase(PreconfiguredBaseModel): trx_id: TransactionId block: HiveInt trx_in_block: HiveInt op_in_trx: HiveInt virtual_op: bool - operation_id: HiveInt timestamp: HiveDateTime +class ApiOperationObjectCommons(ApiOperationObjectCommonsBase): + operation_id: HiveInt + + class Hf26ApiOperationObject(ApiOperationObjectCommons): op: AnyHf26Operation @@ -42,5 +45,5 @@ class Hf26ApiAllOperationObject(ApiOperationObjectCommons): op: AnyHf26Operation -class LegacyApiAllOperationObject(ApiOperationObjectCommons): +class LegacyApiAllOperationObject(ApiOperationObjectCommonsBase): op: AnyLegacyOperation diff --git a/schemas/_preconfigured_base_model.py b/schemas/_preconfigured_base_model.py index c295c92d31a0579168c3feb67f6eaf6d3d6c9081..48a64cc1467ae30c5b4f9151737a14b5f2f6a776 100644 --- a/schemas/_preconfigured_base_model.py +++ b/schemas/_preconfigured_base_model.py @@ -7,6 +7,7 @@ from __future__ import annotations import copy from dataclasses import dataclass +from datetime import datetime from enum import IntEnum from json import dumps as pretty_json_dumps from pathlib import Path @@ -15,8 +16,10 @@ from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast, get_args, get_ori import msgspec from typing_extensions import Self +from schemas.policies.extra_fields import ExtraFieldsPolicy + if TYPE_CHECKING: - from collections.abc import Iterable, Iterator + from collections.abc import Iterable from schemas.decoders import DecoderFactory @@ -37,23 +40,37 @@ class SwapType(IntEnum): ITERABLE = 1 # iterate over collection and replace all values -class PreconfiguredBaseModel(msgspec.Struct, omit_defaults=True): +class PreconfiguredBaseModel( + msgspec.Struct, omit_defaults=True, forbid_unknown_fields=not ExtraFieldsPolicy.is_allowed() +): def __post_init__(self) -> None: - from schemas.policies.disable_swap_types import DisableSwapTypes + from schemas.policies.disable_swap_types import DisableSwapTypesPolicy - if not DisableSwapTypes.is_disabled(): + if not DisableSwapTypesPolicy.is_disabled(): self.__swap_to_registered_types() @classmethod def __is_aliased_field_name(cls, field_name: str) -> bool: return field_name in {"id", "from", "json", "schema", "open", "field", "input", "hex", "type"} - def __getitem__(self, key: str) -> Any: + def __getitem__(self, key: str | int) -> Any: """ This allows using any schema from this repo as dictionary """ - key = self.__get_field_name(key) - return getattr(self, key) + key_str = self.__get_field_name(key) + value = getattr(self, key_str) + if isinstance(key, int): + """ + This if statement is support for direct dict conversions: + ```python + dict(ChildOdPreconfiguredBaseModel()) + ``` + Alternative solution is to implement __iter__ but it was + abandoned in favor of this solution, because __iter__ + is used in different projects. + """ + return [key_str, value] + return value def __setitem__(self, key: str, value: Any) -> None: """ @@ -62,7 +79,9 @@ class PreconfiguredBaseModel(msgspec.Struct, omit_defaults=True): key = self.__get_field_name(key) setattr(self, key, value) - def __get_field_name(self, name: str) -> str: + def __get_field_name(self, name: str | int) -> str: + if isinstance(name, int): + return self.__struct_fields__[name] if not hasattr(self, name) and self.__is_aliased_field_name(name): name = f"{name}_" @@ -72,7 +91,7 @@ class PreconfiguredBaseModel(msgspec.Struct, omit_defaults=True): return name def __contains__(self, key: str) -> bool: - return key in self.shallow_dict() + return key in self.dict() def json( # noqa: PLR0913 self, @@ -83,6 +102,7 @@ class PreconfiguredBaseModel(msgspec.Struct, omit_defaults=True): exclude_none: bool = False, remove_whitespaces: bool = False, exclude: set[str] | None = None, + indent: int | None = None, ) -> str: data = self.__as_builtins( str_keys=str_keys, builtin_types=builtin_types, order=order, exclude_none=exclude_none, exclude=exclude @@ -90,14 +110,7 @@ class PreconfiguredBaseModel(msgspec.Struct, omit_defaults=True): if remove_whitespaces: return msgspec.json.encode(data, order=order).decode() - return pretty_json_dumps(data, sort_keys=(order == "sorted"), ensure_ascii=False) - - def shallow_dict(self) -> dict[str, Any]: - result: dict[str, Any] = {} - for key, value in self.dict().items(): - if value is not None: - result[key.strip("_")] = getattr(self, key) - return result + return pretty_json_dumps(data, sort_keys=(order == "sorted"), ensure_ascii=False, indent=indent) def dict( self, @@ -113,25 +126,24 @@ class PreconfiguredBaseModel(msgspec.Struct, omit_defaults=True): else {} ) - for key, value in dict(self).items(): + struct_data = msgspec.structs.asdict(self) + + for key, value in struct_data.items(): + key_clean = key.strip("_") + if exclude_none and value is None: continue - if exclude_defaults and key in defaults and value == defaults[key]: + if exclude_defaults and key_clean in defaults and value == defaults[key_clean]: continue - if exclude is not None and key in exclude: + if exclude is not None and key_clean in exclude: continue - data[key] = value + data[key_clean] = value return data - def __iter__(self) -> Iterator[tuple[str, Any]]: - """Allow the object to be converted to a dictionary using dict().""" - for key, item in msgspec.structs.asdict(self).items(): - yield (key.strip("_"), item) # Strip underscores from keys to match dict() behavior - def __as_builtins( self, str_keys: bool = False, @@ -243,7 +255,7 @@ class PreconfiguredBaseModel(msgspec.Struct, omit_defaults=True): current_member_value = getattr(self, member_name) is_buildins = any( isinstance(current_member_value, builtin_type) - for builtin_type in [int, str, bool, float, dict, tuple, list, set] + for builtin_type in [int, str, bool, float, dict, tuple, list, set, datetime] ) is_supported_iterable_buildins = ( any(isinstance(current_member_value, builtin_type) for builtin_type in [list, set]) @@ -335,5 +347,18 @@ class PreconfiguredBaseModel(msgspec.Struct, omit_defaults=True): def __hash__(self) -> int: return hash(self.json()) + def humanize(self) -> str: + """ + Returns a human-readable string representation of the model. + """ + from schemas.encoders import get_hf26_encoder + + encoder = get_hf26_encoder() + + return " ".join(f"{k}={encoder.encode(v).decode()}" for k, v in self.dict(exclude_none=True).items()) + + def __str__(self) -> str: + return self.humanize() + BaseModelT = TypeVar("BaseModelT", bound=PreconfiguredBaseModel) diff --git a/schemas/apis/account_history_api/response_schemas.py b/schemas/apis/account_history_api/response_schemas.py index 06a9a8d25896a5cf7e6a676709648a548ea30824..be29cf8bcb44d0e775749410118464864d6694f1 100644 --- a/schemas/apis/account_history_api/response_schemas.py +++ b/schemas/apis/account_history_api/response_schemas.py @@ -12,6 +12,7 @@ from schemas.apis.account_history_api.fundaments_of_responses import EnumVirtual from schemas.fields.hex import Signature, TransactionId from schemas.fields.hive_datetime import HiveDateTime from schemas.fields.hive_int import HiveInt +from schemas.fields.integers import Uint16t, Uint32t from schemas.operations import Hf26OperationRepresentation @@ -34,8 +35,8 @@ class GetTransactionBase(PreconfiguredBaseModel): block_num: HiveInt expiration: HiveDateTime extensions: list[Any] - ref_block_num: HiveInt - ref_block_prefix: HiveInt + ref_block_num: Uint16t + ref_block_prefix: Uint32t signatures: list[Signature] transaction_id: TransactionId transaction_num: HiveInt diff --git a/schemas/apis/app_status_api/rc_stats.py b/schemas/apis/app_status_api/rc_stats.py index 1d23e89b6079230b5a915ad6a39e54edb14b3ea0..d8da3c332c0a33ab8265995dcb966eb301e97789 100644 --- a/schemas/apis/app_status_api/rc_stats.py +++ b/schemas/apis/app_status_api/rc_stats.py @@ -120,22 +120,22 @@ class RegularRcPayerStats(PreconfiguredBaseModel): class FullRcPayerStats(RegularRcPayerStats): cost: RcHiveIntTuple = field( default_factory=lambda: RcHiveIntTuple( - history_rc=HiveInt(0), - tokens_rc=HiveInt(0), - market_rc=HiveInt(0), - state_rc=HiveInt(0), - exec_rc=HiveInt(0), + history_rc=0, + tokens_rc=0, + market_rc=0, + state_rc=0, + exec_rc=0, ) ) """total costs of resources by payers""" usage: ResourceConsumptionHiveIntTuple = field( default_factory=lambda: ResourceConsumptionHiveIntTuple( - history_bytes=HiveInt(0), - tokens=HiveInt(0), - market_bytes=HiveInt(0), - state_hbytes=HiveInt(0), - exec_ns=HiveInt(0), + history_bytes=0, + tokens=0, + market_bytes=0, + state_hbytes=0, + exec_ns=0, ) ) """average usage of resources by payers""" diff --git a/schemas/apis/block_api/response_schemas.py b/schemas/apis/block_api/response_schemas.py index 3210f29461b587028dc27a05aa0bce42e622f638..8b6f481de0f4ea9a7561f64d31b7c770911de79c 100644 --- a/schemas/apis/block_api/response_schemas.py +++ b/schemas/apis/block_api/response_schemas.py @@ -1,31 +1,10 @@ from __future__ import annotations -from typing import NoReturn, cast - -from typing_extensions import Self +from typing import cast from schemas._preconfigured_base_model import PreconfiguredBaseModel from schemas.apis.block_api.fundaments_of_responses import GetBlockHeaderFundament, Hf26Block from schemas.fields.hive_list import HiveList -from schemas.optional_response import OptionalResponse - - -class EmptyResponse(PreconfiguredBaseModel, OptionalResponse): - def is_set(self) -> bool: - return False - - @property - def ensure(self) -> NoReturn: - raise ValueError("Member is not set") - - -class NonEmptyResponse(OptionalResponse): - def is_set(self) -> bool: - return True - - @property - def ensure(self) -> Self: - return self class GetBlockBaseEnsured(PreconfiguredBaseModel): diff --git a/schemas/apis/condenser_api/fundaments_of_responses.py b/schemas/apis/condenser_api/fundaments_of_responses.py index cbda406c0817fa3044e802b309aa01d94872bc93..904f9a84bcf474220a395a7db1ff4f4836b38fa2 100644 --- a/schemas/apis/condenser_api/fundaments_of_responses.py +++ b/schemas/apis/condenser_api/fundaments_of_responses.py @@ -15,7 +15,7 @@ from schemas.fields.basic import ( Permlink, Url, ) -from schemas.fields.compound import Proposal +from schemas.fields.compound import ProposalFundament from schemas.fields.hive_datetime import HiveDateTime from schemas.fields.hive_int import HiveInt @@ -28,8 +28,8 @@ class HiveMindResponses(PreconfiguredBaseModel): data: dict[str, Any] -class FindProposalsFundament(Proposal): - status: str | None = field(default=None) # type: ignore [assignment] +class FindProposalsFundament(ProposalFundament): + status: str | None = None class GetAccountReputationsFundament(PreconfiguredBaseModel): @@ -37,11 +37,11 @@ class GetAccountReputationsFundament(PreconfiguredBaseModel): reputation: HiveInt -class GetAccountsFundament(fundaments_database_api.AccountItemFundament, kw_only=True): +class GetAccountsFundament(fundaments_database_api.AccountItemBase, kw_only=True): """Base for this response is list_accounts from database api. Some additional fields are here and two excluded""" - last_post_edit: HiveDateTime | None = field(default=None) # type: ignore [assignment] - is_smt: bool | None = field(default=None) # type: ignore [assignment] + last_post_edit: HiveDateTime | None = None + is_smt: bool | None = None post_history: list[str] vote_history: list[str] @@ -57,7 +57,7 @@ class GetAccountsFundament(fundaments_database_api.AccountItemFundament, kw_only class GetAccountHistoryFundament(LegacyApiAllOperationObject, kw_only=True): - operation_id: HiveInt = field(default=None) # type: ignore [assignment] + operation_id: HiveInt | None = None class GetActiveVotesFundament(PreconfiguredBaseModel, kw_only=True): @@ -86,21 +86,21 @@ class ActiveVotes(PreconfiguredBaseModel, kw_only=True): voter: AccountName -class GetCommentDiscussionsByPayoutFundament(fundaments_database_api.FindCommentsFundament, kw_only=True): - id_: HiveInt | None = field(default=None) # type: ignore [assignment] - abs_rshares: HiveInt | None = field(default=None) # type: ignore [assignment] - vote_rshares: HiveInt | None = field(default=None) # type: ignore [assignment] - children_abs_rshares: HiveInt | None = field(default=None) # type: ignore [assignment] - max_cashout_time: HiveDateTime | None = field(default=None) # type: ignore [assignment] - total_vote_weight: HiveInt | None = field(default=None) # type: ignore [assignment] - reward_weight: HiveInt | None = field(default=None) # type: ignore [assignment] - author_rewards: HiveInt | None = field(default=None) # type: ignore [assignment] - net_votes: HiveInt | None = field(default=None) # type: ignore [assignment] - root_author: OptionallyEmptyAccountName | None = field(default=None) # type: ignore [assignment] - root_permlink: Permlink | None = field(default=None) # type: ignore [assignment] - allow_replies: bool | None = field(default=None) # type: ignore [assignment] - allow_votes: bool | None = field(default=None) # type: ignore [assignment] - allow_curation_rewards: bool | None = field(default=None) # type: ignore [assignment] +class GetCommentDiscussionsByPayoutFundament(fundaments_database_api.FindCommentsBase, kw_only=True): + id_: HiveInt | None = field(name="id", default=None) + abs_rshares: HiveInt | None = None + vote_rshares: HiveInt | None = None + children_abs_rshares: HiveInt | None = None + max_cashout_time: HiveDateTime | None = None + total_vote_weight: HiveInt | None = None + reward_weight: HiveInt | None = None + author_rewards: HiveInt | None = None + net_votes: HiveInt | None = None + root_author: OptionallyEmptyAccountName | None = None + root_permlink: Permlink | None = None + allow_replies: bool | None = None + allow_votes: bool | None = None + allow_curation_rewards: bool | None = None pending_payout_value: AssetHbd promoted: AssetHbd @@ -152,7 +152,7 @@ class FollowFundament(PreconfiguredBaseModel, kw_only=True): class GetOpsInBlockFundament(LegacyApiAllOperationObject, kw_only=True): """just operation_id from base excluded, rest the same""" - operation_id: HiveInt | None = field(default=None) # type: ignore [assignment] + operation_id: HiveInt | None = None class GetTrendingTagsFundament(PreconfiguredBaseModel, kw_only=True): @@ -164,8 +164,8 @@ class GetTrendingTagsFundament(PreconfiguredBaseModel, kw_only=True): trending: str | None = None -class ListProposalsFundament(Proposal, kw_only=True): - status: str | None = field(default=None) # type: ignore [assignment] +class ListProposalsFundament(ProposalFundament, kw_only=True): + status: str | None = None class ListRcDirectDelegationsFundament(PreconfiguredBaseModel, kw_only=True): @@ -174,9 +174,9 @@ class ListRcDirectDelegationsFundament(PreconfiguredBaseModel, kw_only=True): delegated_rc: HiveInt -class LookupAccountNamesFundament(fundaments_database_api.AccountItemFundament, kw_only=True): - last_post_edit: HiveDateTime | None = field(default=None) # type: ignore [assignment] - is_smt: bool | None = field(default=None) # type: ignore [assignment] +class LookupAccountNamesFundament(fundaments_database_api.AccountItemBase, kw_only=True): + last_post_edit: HiveDateTime | None = None + is_smt: bool | None = None voting_power: HiveInt diff --git a/schemas/apis/database_api/fundaments_of_reponses.py b/schemas/apis/database_api/fundaments_of_reponses.py index 8c6d7810396e212ca4a764f8f9721e2b3b049877..759d8824e2f6a8b287662fb4a3c8692828afa167 100644 --- a/schemas/apis/database_api/fundaments_of_reponses.py +++ b/schemas/apis/database_api/fundaments_of_reponses.py @@ -20,7 +20,7 @@ from schemas.fields.compound import ( from schemas.fields.hex import Sha256 from schemas.fields.hive_datetime import HiveDateTime from schemas.fields.hive_int import HiveInt -from schemas.fields.resolvables import AssetUnion, AssetUnionAssetHiveAssetHbd, JsonString +from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd, JsonString from schemas.fields.version import HardforkVersion, Version @@ -31,7 +31,7 @@ class FindAccountRecoveryRequestsFundament(PreconfiguredBaseModel, kw_only=True) expires: HiveDateTime -class AccountItemFundament(PreconfiguredBaseModel, kw_only=True): +class AccountItemBase(PreconfiguredBaseModel, kw_only=True): """Base class for FindAccount and ListAccounts""" id_: HiveInt = field(name="id") @@ -88,16 +88,21 @@ class AccountItemFundament(PreconfiguredBaseModel, kw_only=True): witnesses_voted_for: HiveInt last_post: HiveDateTime last_root_post: HiveDateTime - last_post_edit: HiveDateTime last_vote_time: HiveDateTime post_bandwidth: HiveInt pending_claimed_accounts: HiveInt open_recurrent_transfers: HiveInt - is_smt: bool governance_vote_expiration_ts: HiveDateTime delayed_votes: list[DelayedVotes] = field(default_factory=lambda: []) # noqa: PIE807 +class AccountItemFundament(AccountItemBase, kw_only=True): + """Base class for FindAccount and ListAccounts""" + + last_post_edit: HiveDateTime + is_smt: bool + + class FindChangeRecoveryAccountRequestsFundament(PreconfiguredBaseModel, kw_only=True): id_: HiveInt = field(name="id") account_to_recover: OptionallyEmptyAccountName @@ -114,8 +119,7 @@ class FindCollateralizedConversionRequestsFundament(PreconfiguredBaseModel, kw_o conversion_date: HiveDateTime -class FindCommentsFundament(PreconfiguredBaseModel, kw_only=True): - id_: HiveInt = field(name="id") +class FindCommentsBase(PreconfiguredBaseModel, kw_only=True): author: OptionallyEmptyAccountName permlink: Permlink category: str @@ -130,26 +134,30 @@ class FindCommentsFundament(PreconfiguredBaseModel, kw_only=True): depth: HiveInt children: HiveInt net_rshares: HiveInt + cashout_time: HiveDateTime + total_payout_value: AssetHbd + curator_payout_value: AssetHbd + max_accepted_payout: AssetHbd + percent_hbd: HiveInt + beneficiaries: list[Any] + was_voted_on: bool | None = None + + +class FindCommentsFundament(FindCommentsBase, kw_only=True): + id_: HiveInt = field(name="id") abs_rshares: HiveInt vote_rshares: HiveInt children_abs_rshares: HiveInt - cashout_time: HiveDateTime max_cashout_time: HiveDateTime total_vote_weight: HiveInt reward_weight: HiveInt - total_payout_value: AssetHbd - curator_payout_value: AssetHbd author_rewards: HiveInt net_votes: HiveInt root_author: OptionallyEmptyAccountName root_permlink: Permlink - max_accepted_payout: AssetHbd - percent_hbd: HiveInt allow_replies: bool allow_votes: bool allow_curation_rewards: bool - beneficiaries: list[Any] - was_voted_on: bool | None = None class FindDeclineVotingRightsRequestsFundament(PreconfiguredBaseModel, kw_only=True): @@ -170,7 +178,7 @@ class EscrowsFundament(PreconfiguredBaseModel, kw_only=True): escrow_expiration: HiveDateTime hbd_balance: AssetHbd hive_balance: AssetHive - pending_fee: AssetUnion[AssetHbd, AssetHive] + pending_fee: AssetUnionAssetHiveAssetHbd to_approved: bool agent_approved: bool disputed: bool diff --git a/schemas/apis/database_api/response_schemas.py b/schemas/apis/database_api/response_schemas.py index 1a8ad3a210028c855de38847400c49fe89533759..96235a6b6b69cbac0e5e18dcaee0025543b00963 100644 --- a/schemas/apis/database_api/response_schemas.py +++ b/schemas/apis/database_api/response_schemas.py @@ -144,9 +144,6 @@ class GetCommentPendingPayouts(PreconfiguredBaseModel, kw_only=True): class GetConfigOrig(PreconfiguredBaseModel, kw_only=True): """ This response includes just one dict, so also doesn't need fundament class - To use this class choose type of Assets so: - Legacy -> GetConfig[AssetHiveLegacy, AssetHbdLegacy](parameters) - HF26 -> GetConfig[AssetHiveNai, AssetHbdNai](parameters) """ HIVE_CHAIN_ID: Hex diff --git a/schemas/base.py b/schemas/base.py new file mode 100644 index 0000000000000000000000000000000000000000..252c813e51f3ee945d34b24150a65eebfb14fca3 --- /dev/null +++ b/schemas/base.py @@ -0,0 +1,11 @@ +"""Aliases and exported symbols from msgspec used throughout the project.""" + +from __future__ import annotations + +from msgspec import Meta, convert, field + +__all__ = [ + "field", + "Meta", + "convert", +] diff --git a/schemas/errors.py b/schemas/errors.py new file mode 100644 index 0000000000000000000000000000000000000000..9a0c1584ee19812ebea1476828a82c290d37a89d --- /dev/null +++ b/schemas/errors.py @@ -0,0 +1,7 @@ +"""Aliases and exported symbols from msgspec used throughout the project.""" + +from __future__ import annotations + +from msgspec import DecodeError, ValidationError + +__all__ = ["ValidationError", "DecodeError"] diff --git a/schemas/fields/_init_validators.py b/schemas/fields/_init_validators.py index 691eacf3a659699fc743905edd536ec4dac94082..e72129079ac9ddbbdf34fc810fe38d39a358cd81 100644 --- a/schemas/fields/_init_validators.py +++ b/schemas/fields/_init_validators.py @@ -47,15 +47,14 @@ def get_copy_of_registered_types() -> RegisteredTypes: class InitValidator(Serializable, Generic[T]): """Base class for types that performs validation during initialization and decode using msgspec library.""" - def __new__(cls, obj: Any, *, skip_validation: bool = False) -> Self: # noqa: ARG003 - return super().__new__(cls) + def __new__(cls, obj: Any, *args: Any, skip_validation: bool = False, **kwargs: Any) -> InitValidator[T]: + if not skip_validation: + obj = cls.validate(obj) + return cast(InitValidator[T], super().__new__(cls, obj, *args, **kwargs)) @classmethod - def validate(cls, value: T) -> Self: - return cls( - msgspec.convert(value, type=Annotated[cls._covered_type(), cls._meta()], strict=False), - skip_validation=True, - ) + def validate(cls, value: T) -> T: + return msgspec.convert(value, type=cast(type[T], Annotated[cls._covered_type(), cls._meta()]), strict=False) _not_implemented_msg = "Make sure to use types created using InitValidator.factory() classmethod" @@ -63,6 +62,10 @@ class InitValidator(Serializable, Generic[T]): def _meta(cls) -> msgspec.Meta: raise NotImplementedError(cls._not_implemented_msg) + @classmethod + def meta(cls) -> msgspec.Meta: + return cls._meta() + @classmethod def _covered_type(cls) -> type[T]: raise NotImplementedError(cls._not_implemented_msg) @@ -86,7 +89,7 @@ class InitValidator(Serializable, Generic[T]): return meta @classmethod - def validate(cls, value: T) -> Self: + def validate(cls, value: T) -> T: validated = pre_validator(value) if not skip_default_validation: validated = super().validate(validated) @@ -104,23 +107,13 @@ class InitValidator(Serializable, Generic[T]): return self._covered_type()(self) # type: ignore[call-arg] -class ValidatorString(str, InitValidator[str]): - def __new__(cls, obj: Any, *, skip_validation: bool = False) -> Self: - if not skip_validation: - cls.validate(cls._covered_type()(obj)) - return super().__new__(cls, obj) - +class ValidatorString(InitValidator[str], str): @classmethod def _covered_type(cls) -> type[str]: return str -class ValidatorInt(int, InitValidator[int]): - def __new__(cls, obj: Any, *, skip_validation: bool = False) -> Self: - if not skip_validation: - cls.validate(cls._covered_type()(obj)) - return super().__new__(cls, obj) - +class ValidatorInt(InitValidator[int], int): @classmethod def _covered_type(cls) -> type[int]: return int diff --git a/schemas/fields/assets/_base.py b/schemas/fields/assets/_base.py index f5428f378302d3a3b567d89baf97144dda70a165..537d04a699e79fe7fd02c07f4b208521d039a46c 100644 --- a/schemas/fields/assets/_base.py +++ b/schemas/fields/assets/_base.py @@ -3,7 +3,7 @@ from __future__ import annotations import contextlib import operator import re -from abc import ABC, abstractmethod +from abc import ABC, ABCMeta, abstractmethod from decimal import Decimal from typing import TYPE_CHECKING, Any @@ -14,7 +14,7 @@ from schemas.fields.assets._symbol import HbdSymbolType, HiveSymbolType, VestsSy from schemas.fields.assets._validators import validate_nai, validate_precision from schemas.fields.assets.asset_info import AssetInfo from schemas.fields.hive_int import HiveInt, HiveIntFactory -from schemas.fields.serializable import Serializable +from schemas.fields.serializable import OverrideTypeNameMeta, Serializable if TYPE_CHECKING: # nofmt from collections.abc import Callable @@ -24,7 +24,35 @@ else: AssetNaiAmount = HiveIntFactory.factory("AssetNaiAmount", msgspec.Meta(ge=0)) -class AssetBase(Serializable, ABC): +class MetaAsset(OverrideTypeNameMeta, ABCMeta): + """ + This implementation is because of HiddenAssetType which can be used in isinstance context. + """ + + def __instancecheck__(cls: type[Any], instance: Any) -> bool: + if issubclass(cls, AssetBase): + instance_t = type(instance) + if issubclass(instance_t, AssetBase): + return cls._compare_asset_types(instance_t) + return False + return False + + def _compare_asset_types(cls, other: type[AssetBase]) -> bool: + assert issubclass(cls, AssetBase) and issubclass(other, AssetBase), "Both classes must be AssetBase subclasses" + if (cls is AssetBase) or (cls is HiddenAssetBase): + return True + if issubclass(cls, HiddenAssetBase) and (not issubclass(other, HiddenAssetBase)): + other_nai = other.get_asset_information().nai + return any(other_nai == allowed.get_asset_information().nai for allowed in cls.allowed_types()) + if issubclass(other, HiddenAssetBase) and (not issubclass(cls, HiddenAssetBase)): + cls_nai = cls.get_asset_information().nai + return any(cls_nai == allowed.get_asset_information().nai for allowed in other.allowed_types()) + if (not issubclass(other, HiddenAssetBase)) and (not issubclass(cls, HiddenAssetBase)): + return cls.get_asset_information().nai == other.get_asset_information().nai + return True + + +class AssetBase(Serializable, ABC, metaclass=MetaAsset): def __init__(self, amount: int, precision: HiveInt | None = None, nai: str | None = None): self.__amount = AssetNaiAmount(amount) self.validate(precision, nai) @@ -207,9 +235,7 @@ class AssetBase(Serializable, ABC): return float(self.amount / (10**info.precision)) def token(self, testnet: bool | None = None) -> str: - return self.get_asset_information().get_symbol( - testnet=self._is_default_symbol_testnet() if testnet is None else testnet - ) + return self.get_asset_information().get_symbol(testnet=testnet) def as_legacy(self, *, testnet: bool | None = None) -> str: return f"{self.pretty_amount()} {self.token(testnet=testnet)}" @@ -258,33 +284,46 @@ class AssetBase(Serializable, ABC): converted = self.__convert_to_asset(other) return converted.copy(amount=int(float(operator_(self.int_amount, converted.int_amount)))) - def _is_default_symbol_testnet(self) -> bool: - return False + def __hash__(self) -> int: + return hash(self.as_serialized_nai()) + + +class HiddenAssetBase(AssetBase): + @classmethod + @abstractmethod + def allowed_types(cls) -> list[type[AssetBase]]: + """ + Returns a list of allowed asset types for this AssetUnion. + This method should be implemented by subclasses to specify which asset types are allowed. + """ + raise NotImplementedError("This method should be implemented by subclasses to specify allowed asset types.") class AssetHive(AssetBase): @staticmethod def get_asset_information() -> AssetInfo: - return HiveSymbolType.get_asset_information() + return HiveSymbolType.get_asset_information(testnet=False) class AssetHbd(AssetBase): @staticmethod def get_asset_information() -> AssetInfo: - return HbdSymbolType.get_asset_information() + return HbdSymbolType.get_asset_information(testnet=False) class AssetVests(AssetBase): @staticmethod def get_asset_information() -> AssetInfo: - return VestsSymbolType.get_asset_information() + return VestsSymbolType.get_asset_information(testnet=False) class AssetTests(AssetHive): - def _is_default_symbol_testnet(self) -> bool: - return True + @staticmethod + def get_asset_information() -> AssetInfo: + return HiveSymbolType.get_asset_information(testnet=True) class AssetTbd(AssetHbd): - def _is_default_symbol_testnet(self) -> bool: - return True + @staticmethod + def get_asset_information() -> AssetInfo: + return HbdSymbolType.get_asset_information(testnet=True) diff --git a/schemas/fields/assets/_symbol.py b/schemas/fields/assets/_symbol.py index cfe33739caf1e43f6e601c1856e4cc89cfb52ab5..71afe046d11384a40b4dd47cada3cd88bd1f4f62 100644 --- a/schemas/fields/assets/_symbol.py +++ b/schemas/fields/assets/_symbol.py @@ -29,14 +29,14 @@ class AssetSymbolType(PreconfiguredBaseModel): # impossible to inherit from ABC @staticmethod @abstractmethod - def get_asset_information() -> AssetInfo: + def get_asset_information(testnet: bool = False) -> AssetInfo: """This method returns asset details.""" class HiveSymbolType(AssetSymbolType): @staticmethod - def get_asset_information() -> AssetInfo: - return AssetInfo(precision=HiveInt(3), nai="@@000000021", symbol=("HIVE", "TESTS")) + def get_asset_information(testnet: bool = False) -> AssetInfo: + return AssetInfo(precision=HiveInt(3), nai="@@000000021", symbol=("HIVE", "TESTS"), testnet=testnet) decimals: HiveInt = get_asset_information().precision nai: str = get_asset_information().nai @@ -44,8 +44,8 @@ class HiveSymbolType(AssetSymbolType): class HbdSymbolType(AssetSymbolType): @staticmethod - def get_asset_information() -> AssetInfo: - return AssetInfo(precision=HiveInt(3), nai="@@000000013", symbol=("HBD", "TBD")) + def get_asset_information(testnet: bool = False) -> AssetInfo: + return AssetInfo(precision=HiveInt(3), nai="@@000000013", symbol=("HBD", "TBD"), testnet=testnet) decimals: HiveInt = get_asset_information().precision nai: str = get_asset_information().nai @@ -53,8 +53,8 @@ class HbdSymbolType(AssetSymbolType): class VestsSymbolType(AssetSymbolType): @staticmethod - def get_asset_information() -> AssetInfo: - return AssetInfo(precision=HiveInt(6), nai="@@000000037", symbol=("VESTS", "VESTS")) + def get_asset_information(testnet: bool = False) -> AssetInfo: + return AssetInfo(precision=HiveInt(6), nai="@@000000037", symbol=("VESTS", "VESTS"), testnet=testnet) decimals: HiveInt = get_asset_information().precision nai: str = get_asset_information().nai diff --git a/schemas/fields/assets/asset_info.py b/schemas/fields/assets/asset_info.py index 0a2206d71975808dbd37bc058adffacaf8b89f0a..6b9cc10d9c21560d5289f54a74275ee826c74772 100644 --- a/schemas/fields/assets/asset_info.py +++ b/schemas/fields/assets/asset_info.py @@ -1,7 +1,7 @@ from __future__ import annotations from dataclasses import dataclass -from typing import ClassVar +from typing import Any, ClassVar from schemas.fields.hive_int import HiveInt @@ -10,16 +10,28 @@ __all__ = [ ] -@dataclass +@dataclass(frozen=True) class AssetInfo: precision: HiveInt nai: str symbol: tuple[str, str] + testnet: bool class AssetConfig: - testnet_asset: ClassVar[bool] = False + testnet_asset: ClassVar[bool | None] = None def get_symbol(self, testnet: bool | None = None) -> str: - if testnet is not None: - return self.symbol[int(testnet)] - return self.symbol[int(AssetInfo.AssetConfig.testnet_asset)] + if AssetInfo.AssetConfig.testnet_asset is None: + if testnet is None: + testnet = self.testnet + else: + testnet = AssetInfo.AssetConfig.testnet_asset + return self.symbol[int(testnet)] + + def __eq__(self, other: Any) -> bool: + if not isinstance(other, AssetInfo): + return False + return self.nai == other.nai + + def __hash__(self) -> int: + return hash(self.nai) diff --git a/schemas/fields/compound.py b/schemas/fields/compound.py index 18ffc766f380f04b3688f6bb62fde60f25c628ea..a497c7d885c808d9a8b6fe94d44450d8efab55aa 100644 --- a/schemas/fields/compound.py +++ b/schemas/fields/compound.py @@ -49,8 +49,8 @@ class HbdExchangeRate(PreconfiguredBaseModel): class LegacyChainProperties(PreconfiguredBaseModel): account_creation_fee: AssetHive - maximum_block_size: Uint32t = Uint32t(HIVE_MAX_BLOCK_SIZE) - hbd_interest_rate: Uint16t = Uint16t(HIVE_HBD_INTEREST_RATE) + maximum_block_size: Uint32t = HIVE_MAX_BLOCK_SIZE + hbd_interest_rate: Uint16t = HIVE_HBD_INTEREST_RATE class Manabar(PreconfiguredBaseModel): @@ -63,7 +63,7 @@ class Price(PreconfiguredBaseModel): quote: AnyAsset -class Proposal(PreconfiguredBaseModel, kw_only=True): +class ProposalFundament(PreconfiguredBaseModel, kw_only=True): id_: HiveInt = field(name="id") proposal_id: HiveInt creator: AccountName @@ -74,6 +74,9 @@ class Proposal(PreconfiguredBaseModel, kw_only=True): subject: str permlink: str total_votes: HiveInt + + +class Proposal(ProposalFundament, kw_only=True): status: str diff --git a/schemas/fields/hive_int.py b/schemas/fields/hive_int.py index f8e3654d3d6594c94ce7c67396d3419d51cbb2f9..29e9624fb4cefddb5df9da845fab7a6ef6e015b5 100644 --- a/schemas/fields/hive_int.py +++ b/schemas/fields/hive_int.py @@ -3,7 +3,6 @@ from __future__ import annotations from typing import TYPE_CHECKING, Any import msgspec -from typing_extensions import Self from schemas.fields._init_validators import InitValidator @@ -12,12 +11,7 @@ __all__ = [ ] -class HiveIntFactory(int, InitValidator[int]): - def __new__(cls, obj: Any, *, skip_validation: bool = False) -> Self: - if not skip_validation: - cls.validate(obj) - return super().__new__(cls, obj) - +class HiveIntFactory(InitValidator[int], int): @classmethod def _covered_type(cls) -> type[int]: return int @@ -30,7 +24,7 @@ class HiveIntFactory(int, InitValidator[int]): return str(self) @classmethod - def validate(cls, value: Any) -> Self: + def validate(cls, value: Any) -> int: error_template = msgspec.ValidationError("The value could only be int or string that can be converted to int!") if not isinstance(value, (HiveIntFactory, str)) and type(value) is not int: raise error_template diff --git a/schemas/fields/resolvables.py b/schemas/fields/resolvables.py index 7f677b6a36a2ecab3edfb264f579acde436dd7d7..45a370fb48e0a297a6099440741741ca1f909974 100644 --- a/schemas/fields/resolvables.py +++ b/schemas/fields/resolvables.py @@ -8,6 +8,7 @@ import msgspec from schemas._preconfigured_base_model import PreconfiguredBaseModel from schemas.fields.assets import AssetBase, AssetHbd, AssetHive, AssetVests +from schemas.fields.assets._base import HiddenAssetBase from schemas.fields.assets.asset_info import AssetInfo from schemas.fields.hive_int import HiveInt from schemas.fields.serializable import Serializable @@ -68,27 +69,31 @@ class JsonString(Resolvable["JsonString[AnyResolvedT]", Any], Generic[AnyResolve if isinstance(value, JsonString): self.value = value.value else: - self.value = value + self.value = self._resolve_impl(value=value) @staticmethod - def resolve(incoming_cls: type, value: Any) -> JsonString[AnyResolvedT]: # noqa: ARG004 + def _resolve_impl(value: Any) -> Any: assert value is not None, "Value must not be None for JsonString.resolve" if isinstance(value, str): if len(value) == 0: - return JsonString("") + return "" try: parsed = msgspec.json.decode(value) if isinstance(parsed, str): - return JsonString(value) - return JsonString(parsed) + return value + return parsed # noqa: TRY300 except (ValueError, TypeError) as error: raise ValueError(f"Value is not a valid json string! Received `{value}`") from error if isinstance(value, dict | list | tuple | str | int | float | bool): - return JsonString(value) + return value if isinstance(value, PreconfiguredBaseModel): - return JsonString(value) + return value raise ValueError(f"Value is not a valid type! Received `{value}` with type `{type(value)}`") + @staticmethod + def resolve(incoming_cls: type, value: Any) -> JsonString[AnyResolvedT]: # noqa: ARG004 + return JsonString(JsonString._resolve_impl(value)) + def __eq__(self, other: object) -> bool: if isinstance(other, JsonString): return bool(self.value == other.value) @@ -158,20 +163,24 @@ def create_hidden_asset(base: T, source_asset: AssetBase) -> T: def get_asset_information() -> AssetInfo: return source_asset.get_asset_information() + @classmethod + def allowed_types(cls) -> list[type[AssetBase]]: + return [type(source_asset)] + return HiddenAssetType(amount=source_asset.amount, precision=source_asset.precision(), nai=source_asset.nai()) class AssetUnion( - AssetBase, + HiddenAssetBase, Resolvable["AssetUnion[AssetResolved1T, AssetResolved2T]", dict[str, Any] | str], Generic[AssetResolved1T, AssetResolved2T], ): @staticmethod def resolve(incoming_cls: type, value: dict[str, Any] | str) -> AssetUnion[AssetResolved1T, AssetResolved2T]: - assets = cast(tuple[type[AssetBase], type[AssetBase]], get_args(incoming_cls)) + assert issubclass(incoming_cls, HiddenAssetBase), "Incoming class must be a HiddenAssetBase subclass" return cast( AssetUnion[AssetResolved1T, AssetResolved2T], - create_hidden_asset(AssetUnion, deduce_asset(value, list(assets))), + create_hidden_asset(AssetUnion, deduce_asset(value, incoming_cls.allowed_types())), ) def serialize(self) -> dict[str, str | HiveInt]: @@ -180,8 +189,19 @@ class AssetUnion( def serialize_as_legacy(self) -> Any: return self.as_legacy() + @classmethod + def factory(cls, name: str, allowed_assets: list[type[AssetBase]]) -> type[AssetUnion[AssetBase, AssetBase]]: + class FactoryAssetUnion(AssetUnion[AssetBase, AssetBase]): + __name__ = name -class AnyAssetImpl(AssetBase, Resolvable["AnyAssetImpl", dict[str, Any] | str]): + @classmethod + def allowed_types(cls) -> list[type[AssetBase]]: + return allowed_assets + + return FactoryAssetUnion + + +class AnyAssetImpl(HiddenAssetBase, Resolvable["AnyAssetImpl", dict[str, Any] | str]): @staticmethod def resolve(incoming_cls: type, value: dict[str, Any] | str) -> AnyAssetImpl: # noqa: ARG004 return cast( @@ -194,12 +214,16 @@ class AnyAssetImpl(AssetBase, Resolvable["AnyAssetImpl", dict[str, Any] | str]): def serialize_as_legacy(self) -> Any: return self.as_legacy() + @classmethod + def allowed_types(cls) -> list[type[AssetBase]]: + return [AssetHbd, AssetHive, AssetVests] + if TYPE_CHECKING: AssetUnionAssetHiveAssetHbd = AssetHive | AssetHbd AssetUnionAssetHiveAssetVests = AssetHive | AssetVests AnyAsset = AssetHive | AssetHbd | AssetVests else: - AssetUnionAssetHiveAssetHbd = AssetUnion[AssetHive, AssetHbd] - AssetUnionAssetHiveAssetVests = AssetUnion[AssetHive, AssetVests] + AssetUnionAssetHiveAssetHbd = AssetUnion.factory("AssetUnionAssetHiveAssetHbd", [AssetHive, AssetHbd]) + AssetUnionAssetHiveAssetVests = AssetUnion.factory("AssetUnionAssetHiveAssetVests", [AssetHive, AssetVests]) AnyAsset = AnyAssetImpl diff --git a/schemas/fields/serializable.py b/schemas/fields/serializable.py index df471b3a3d7ad151fb4f00f7680dc4d56d071e0a..f97370dfa52cea106f67d9d63fedff24348f6efd 100644 --- a/schemas/fields/serializable.py +++ b/schemas/fields/serializable.py @@ -10,6 +10,11 @@ class OverrideTypeNameMeta(ABCMeta): class Serializable(ABC, metaclass=OverrideTypeNameMeta): + def __new__(cls, *args: Any, **kwargs: Any) -> Serializable: + if super().__new__ == object.__new__: + return super().__new__(cls) + return super().__new__(cls, *args, **kwargs) + @abstractmethod def serialize(self) -> Any: """ diff --git a/schemas/filter.py b/schemas/filter.py index df5e3f3293c39986cd9345445f353f8f40f6b558..ff065e754f2bbd24f479a8337da4ef3a3f2ccfb4 100644 --- a/schemas/filter.py +++ b/schemas/filter.py @@ -53,8 +53,7 @@ def build_vop_filter(*vops: type[VirtualOperation]) -> int: Learn more: https://developers.hive.io/apidefinitions/#account_history_api.enum_virtual_ops """ - def vop_offset(vop: type[Operation]) -> int: - assert issubclass(vop, VirtualOperation) + def vop_offset(vop: type[VirtualOperation]) -> int: return vop.vop_offset() return _build_any_filter(vop_offset, *vops) diff --git a/schemas/operation.py b/schemas/operation.py index 752b7cd18736c3921e63b85a204b28865f65fea3..cc4c7ee8c871822f6fd5a146b9065f43fb5f2e5a 100644 --- a/schemas/operation.py +++ b/schemas/operation.py @@ -4,23 +4,34 @@ from abc import abstractmethod from schemas._preconfigured_base_model import PreconfiguredBaseModel -__all__ = [ - "Operation", -] +__all__ = ["Operation", "OperationBase", "OperationExtension"] -class Operation(PreconfiguredBaseModel): - """Base class for all operations to provide valid json serialization""" +class Representible(PreconfiguredBaseModel): + """Prootocol to be used by HF26Representation and LegacyRepresentation.""" @classmethod @abstractmethod def get_name(cls) -> str: """ - Get the name of the operation. + Get the name of the object inheriting from this class. e.g. `transfer` for `TransferOperation` """ + +class OperationExtension(Representible): + """Base class for all operation extensions to provide valid json serialization""" + + +class OperationBase(Representible): + """Base class for all virtual and non virtual operations to provide valid json serialization""" + + @classmethod + @abstractmethod + def offset(cls) -> int: + """Get the offset of the operation.""" + @classmethod def get_name_with_suffix(cls) -> str: """ @@ -30,7 +41,6 @@ class Operation(PreconfiguredBaseModel): """ return f"{cls.get_name()}_operation" - @classmethod - @abstractmethod - def offset(cls) -> int: - """Get the offset of the operation.""" + +class Operation(OperationBase): + """Base class for all operations to provide valid json serialization""" diff --git a/schemas/operations/__init__.py b/schemas/operations/__init__.py index 118000163653ed962554d5b8e4080ae4b5587658..90b2141dbf8622cbbab658f297103f1a4d296ef8 100644 --- a/schemas/operations/__init__.py +++ b/schemas/operations/__init__.py @@ -1,5 +1,7 @@ from __future__ import annotations +from typing import overload + from schemas.operation import Operation from schemas.operations.account_create_operation import ( AccountCreateOperation, @@ -201,6 +203,7 @@ from schemas.operations.witness_set_properties_operation import WitnessSetProper from schemas.operations.witness_update_operation import ( WitnessUpdateOperation, ) +from schemas.virtual_operation import VirtualOperation __all__ = [ # ANY OPERATION BY TYPE @@ -612,9 +615,29 @@ LegacyRepresentationAndValuePairs = ( HF26RepresentationAndValuePairs = HF26RepresentationAndValuePairsNonVirtual | HF26RepresentationAndValuePairsVirtual -def convert_to_representation(operation: Operation) -> Hf26OperationRepresentation: - return HF26RepresentationAndValuePairsNonVirtual[type(operation)](value=operation) # type: ignore[arg-type] +@overload +def convert_to_representation(op: Operation) -> Hf26OperationRepresentation: ... + + +@overload +def convert_to_representation(op: VirtualOperation) -> Hf26VirtualOperationRepresentation: ... + + +def convert_to_representation( + op: Operation | VirtualOperation, +) -> Hf26OperationRepresentation | Hf26VirtualOperationRepresentation: + return HF26RepresentationAndValuePairs[type(op)](value=op) # type: ignore[index, arg-type] + + +@overload +def convert_to_representation_legacy(op: VirtualOperation) -> LegacyVirtualOperationRepresentation: ... + + +@overload +def convert_to_representation_legacy(op: Operation) -> LegacyOperationRepresentation: ... -def convert_to_representation_legacy(operation: Operation) -> LegacyOperationRepresentation: - return LegacyRepresentationAndValuePairsNonVirtual[type(operation)](value=operation) # type: ignore[arg-type] +def convert_to_representation_legacy( + op: Operation | VirtualOperation, +) -> LegacyOperationRepresentation | LegacyVirtualOperationRepresentation: + return LegacyRepresentationAndValuePairs[type(op)](value=op) # type: ignore[index, arg-type] diff --git a/schemas/operations/cancel_transfer_from_savings_operation.py b/schemas/operations/cancel_transfer_from_savings_operation.py index 04782a5cda1089501915ade8d5230c906c0fcb88..a6605bc891873667e0676faddfc78def44b1e438 100644 --- a/schemas/operations/cancel_transfer_from_savings_operation.py +++ b/schemas/operations/cancel_transfer_from_savings_operation.py @@ -8,7 +8,7 @@ from schemas.fields.basic import AccountName from schemas.fields.integers import Uint32t from schemas.operation import Operation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class CancelTransferFromSavingsOperation(Operation): diff --git a/schemas/operations/collateralized_convert_operation.py b/schemas/operations/collateralized_convert_operation.py index 062d6761dfb1dfff7a69ff9164860e9e242dfe3b..0b5a4c4ee7dca700673d199930a7fd31717b32f4 100644 --- a/schemas/operations/collateralized_convert_operation.py +++ b/schemas/operations/collateralized_convert_operation.py @@ -7,7 +7,7 @@ from schemas.fields.basic import AccountName from schemas.fields.integers import Uint32t from schemas.operation import Operation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class CollateralizedConvertOperation(Operation, kw_only=True): diff --git a/schemas/operations/comment_options_operation.py b/schemas/operations/comment_options_operation.py index dd8819db4ef397409deab82dfe197470a752f26c..0866ca5d5f25535902539a6385a65c4117786316 100644 --- a/schemas/operations/comment_options_operation.py +++ b/schemas/operations/comment_options_operation.py @@ -4,7 +4,7 @@ from typing import Any, Final from msgspec import field -from schemas.fields.assets._base import AssetHbd, AssetNaiAmount +from schemas.fields.assets._base import AssetHbd from schemas.fields.basic import AccountName from schemas.fields.integers import Uint16t from schemas.hive_constants import HIVE_100_PERCENT @@ -12,14 +12,14 @@ from schemas.operation import Operation DEFAULT_ALLOW_VOTES: Final[bool] = True DEFAULT_ALLOW_CURATION_REWARDS: Final[bool] = True -DEFAULT_MAX_ACCEPTED_PAYOUT: Final[AssetHbd] = AssetHbd(amount=AssetNaiAmount(1000000000)) +DEFAULT_MAX_ACCEPTED_PAYOUT: Final[AssetHbd] = AssetHbd(amount=1000000000) class CommentOptionsOperation(Operation): author: AccountName permlink: str - max_accepted_payout: AssetHbd = field(default=DEFAULT_MAX_ACCEPTED_PAYOUT) - percent_hbd: Uint16t = Uint16t(HIVE_100_PERCENT) + max_accepted_payout: AssetHbd = field(default_factory=lambda: DEFAULT_MAX_ACCEPTED_PAYOUT.copy()) + percent_hbd: Uint16t = HIVE_100_PERCENT allow_votes: bool = DEFAULT_ALLOW_VOTES allow_curation_rewards: bool = DEFAULT_ALLOW_CURATION_REWARDS extensions: list[Any] = field(default_factory=list) diff --git a/schemas/operations/convert_operation.py b/schemas/operations/convert_operation.py index 39a2966ce8736101a5c0d45130ceb53473317700..d7131f9898b9a3150c74c21a68644d3a8ee877c3 100644 --- a/schemas/operations/convert_operation.py +++ b/schemas/operations/convert_operation.py @@ -7,7 +7,7 @@ from schemas.fields.basic import AccountName from schemas.fields.integers import Uint32t from schemas.operation import Operation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class ConvertOperation(Operation, kw_only=True): diff --git a/schemas/operations/custom/custom_base_operation.py b/schemas/operations/custom/custom_base_operation.py index f6003557ddb9fa4d005480e63878046bc0386a5f..1864dc35e57da00a3eaf21a2850a1b97bc71f762 100644 --- a/schemas/operations/custom/custom_base_operation.py +++ b/schemas/operations/custom/custom_base_operation.py @@ -5,7 +5,7 @@ from typing import Final from schemas.fields.integers import Uint32t from schemas.operation import Operation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class CustomBaseOperation(Operation): diff --git a/schemas/operations/escrow_approve_operation.py b/schemas/operations/escrow_approve_operation.py index 4ef36e8fad116b415613c7a91fa3a593a203e9e7..d029bd7d1cf45bd0549af34d318b11fb1eb0b109 100644 --- a/schemas/operations/escrow_approve_operation.py +++ b/schemas/operations/escrow_approve_operation.py @@ -8,7 +8,7 @@ from schemas.fields.basic import AccountName from schemas.fields.integers import Uint32t from schemas.operation import Operation -DEFAULT_ESCROW_ID: Final[Uint32t] = Uint32t(30) +DEFAULT_ESCROW_ID: Final[Uint32t] = 30 DEFAULT_APPROVE: Final[bool] = True diff --git a/schemas/operations/escrow_dispute_operation.py b/schemas/operations/escrow_dispute_operation.py index fd4d22ae8d19e0bad60704f25ff9e73a68dd1698..64ef8234a705af7fb91f14e0b6a2588f55ba8514 100644 --- a/schemas/operations/escrow_dispute_operation.py +++ b/schemas/operations/escrow_dispute_operation.py @@ -8,7 +8,7 @@ from schemas.fields.basic import AccountName from schemas.fields.integers import Uint32t from schemas.operation import Operation -DEFAULT_ESCROW_ID: Final[Uint32t] = Uint32t(30) +DEFAULT_ESCROW_ID: Final[Uint32t] = 30 class EscrowDisputeOperation(Operation, kw_only=True): diff --git a/schemas/operations/escrow_release_operation.py b/schemas/operations/escrow_release_operation.py index 2db9bf76577da94c4cae7c6e90faa70d6837cedc..ced0e392a21e6e3b36cbaf37f895b3ff6361eeb8 100644 --- a/schemas/operations/escrow_release_operation.py +++ b/schemas/operations/escrow_release_operation.py @@ -11,7 +11,7 @@ from schemas.fields.basic import ( from schemas.fields.integers import Uint32t from schemas.operation import Operation -DEFAULT_ESCROW_ID: Final[Uint32t] = Uint32t(30) +DEFAULT_ESCROW_ID: Final[Uint32t] = 30 class EscrowReleaseOperation(Operation, kw_only=True): diff --git a/schemas/operations/escrow_transfer_operation.py b/schemas/operations/escrow_transfer_operation.py index b25d18bbf86f5ebe589ba663845a73bab891b8b3..2858b681e401d649e2840fac9733e1f9d811736c 100644 --- a/schemas/operations/escrow_transfer_operation.py +++ b/schemas/operations/escrow_transfer_operation.py @@ -13,7 +13,7 @@ from schemas.fields.integers import Uint32t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.operation import Operation -DEFAULT_ESCROW_ID: Final[Uint32t] = Uint32t(30) +DEFAULT_ESCROW_ID: Final[Uint32t] = 30 class EscrowTransferOperation(Operation, kw_only=True): diff --git a/schemas/operations/extensions/comment_options_extensions.py b/schemas/operations/extensions/comment_options_extensions.py index c3cafb359ca55a4c3813f16253cfe97ef4eb3a9f..5f0fd966067496650e9dc9f2a6765a3199f067e3 100644 --- a/schemas/operations/extensions/comment_options_extensions.py +++ b/schemas/operations/extensions/comment_options_extensions.py @@ -3,7 +3,7 @@ from __future__ import annotations from schemas._preconfigured_base_model import PreconfiguredBaseModel from schemas.fields.basic import AccountName from schemas.fields.integers import Uint16t -from schemas.operation import Operation +from schemas.operation import OperationExtension class BeneficiaryRoute(PreconfiguredBaseModel): @@ -11,7 +11,7 @@ class BeneficiaryRoute(PreconfiguredBaseModel): weight: Uint16t -class CommentPayoutBeneficiaries(Operation): +class CommentPayoutBeneficiaries(OperationExtension): @classmethod def get_name(cls) -> str: return "comment_payout_beneficiaries" diff --git a/schemas/operations/extensions/generate_representation_types.py b/schemas/operations/extensions/generate_representation_types.py index 62fa85db7428659af9985dda0dacf6e5a6237015..2565cc65a682b81cabe1f720ab4752313b5d6570 100644 --- a/schemas/operations/extensions/generate_representation_types.py +++ b/schemas/operations/extensions/generate_representation_types.py @@ -26,7 +26,7 @@ def collect_and_write_api_imports(code: str) -> str: code += "from schemas.operations.extensions.comment_options_extensions import CommentPayoutBeneficiaries\n" code += "from schemas.operations.extensions.recurrent_transfer_extensions import RecurrentTransferPairId\n" code += "from schemas.operations.extensions.update_proposal_extensions import UpdateProposalEndDate\n" - code += "from schemas.operations.representation_types import HF26Representation, LegacyRepresentation\n" + code += "from schemas.operations.representation_types import HF26Representation\n" code += "\n\n" return code @@ -34,11 +34,9 @@ def collect_and_write_api_imports(code: str) -> str: def write_representations_classes(code: str) -> str: for operation_name in all_operations[0:3]: if "Generic" not in operation_name: - code += f"""class HF26Representation{operation_name}Operation(HF26Representation, tag={operation_name}.get_name_with_suffix()): + code += f"""class HF26Representation{operation_name}OperationExtension(HF26Representation[{operation_name}], tag={operation_name}.get_name()): value: {operation_name}\n\n\n""" - code += f"""class LegacyRepresentation{operation_name}Operation(LegacyRepresentation, tag={operation_name}.get_name(), array_like=True): - value: {operation_name[:-6] if "Legacy" in operation_name else operation_name}\n\n\n""" return code diff --git a/schemas/operations/extensions/recurrent_transfer_extensions.py b/schemas/operations/extensions/recurrent_transfer_extensions.py index ca0b387174169ec949a5c6f336e0414d1b895acc..e2ca74c308928bfd5b2d5da94e8ae928e937ef39 100644 --- a/schemas/operations/extensions/recurrent_transfer_extensions.py +++ b/schemas/operations/extensions/recurrent_transfer_extensions.py @@ -1,12 +1,12 @@ from __future__ import annotations from schemas.fields.integers import Uint8t -from schemas.operation import Operation +from schemas.operation import OperationExtension -DEFAULT_PAIR_ID: Uint8t = Uint8t(0) +DEFAULT_PAIR_ID: Uint8t = 0 -class RecurrentTransferPairId(Operation): +class RecurrentTransferPairId(OperationExtension): @classmethod def get_name(cls) -> str: return "recurrent_transfer_pair_id" diff --git a/schemas/operations/extensions/representation_types.py b/schemas/operations/extensions/representation_types.py index 348118a51ef8999cd43361a092acf655c3a50546..711f29833d6d557ba3a6fac4bf03dd521f9a22ca 100644 --- a/schemas/operations/extensions/representation_types.py +++ b/schemas/operations/extensions/representation_types.py @@ -9,28 +9,16 @@ from __future__ import annotations from schemas.operations.extensions.comment_options_extensions import CommentPayoutBeneficiaries from schemas.operations.extensions.recurrent_transfer_extensions import RecurrentTransferPairId from schemas.operations.extensions.update_proposal_extensions import UpdateProposalEndDate -from schemas.operations.representation_types import HF26Representation, LegacyRepresentation +from schemas.operations.representation_types import HF26Representation -class HF26RepresentationCommentPayoutBeneficiariesOperation(HF26Representation, tag=CommentPayoutBeneficiaries.get_name_with_suffix()): +class HF26RepresentationCommentPayoutBeneficiariesOperationExtension(HF26Representation[CommentPayoutBeneficiaries], tag=CommentPayoutBeneficiaries.get_name()): value: CommentPayoutBeneficiaries -class LegacyRepresentationCommentPayoutBeneficiariesOperation(LegacyRepresentation, tag=CommentPayoutBeneficiaries.get_name(), array_like=True): - value: CommentPayoutBeneficiaries - - -class HF26RepresentationRecurrentTransferPairIdOperation(HF26Representation, tag=RecurrentTransferPairId.get_name_with_suffix()): +class HF26RepresentationRecurrentTransferPairIdOperationExtension(HF26Representation[RecurrentTransferPairId], tag=RecurrentTransferPairId.get_name()): value: RecurrentTransferPairId -class LegacyRepresentationRecurrentTransferPairIdOperation(LegacyRepresentation, tag=RecurrentTransferPairId.get_name(), array_like=True): - value: RecurrentTransferPairId - - -class HF26RepresentationUpdateProposalEndDateOperation(HF26Representation, tag=UpdateProposalEndDate.get_name_with_suffix()): - value: UpdateProposalEndDate - - -class LegacyRepresentationUpdateProposalEndDateOperation(LegacyRepresentation, tag=UpdateProposalEndDate.get_name(), array_like=True): +class HF26RepresentationUpdateProposalEndDateOperationExtension(HF26Representation[UpdateProposalEndDate], tag=UpdateProposalEndDate.get_name()): value: UpdateProposalEndDate diff --git a/schemas/operations/extensions/update_proposal_extensions.py b/schemas/operations/extensions/update_proposal_extensions.py index 92b9c1a54e48436397db121879416c3f28ea9b8d..a5be7dbc3aeca63eea1b7152ae061c67c055e8d5 100644 --- a/schemas/operations/extensions/update_proposal_extensions.py +++ b/schemas/operations/extensions/update_proposal_extensions.py @@ -1,10 +1,10 @@ from __future__ import annotations from schemas.fields.hive_datetime import HiveDateTime -from schemas.operation import Operation +from schemas.operation import OperationExtension -class UpdateProposalEndDate(Operation): +class UpdateProposalEndDate(OperationExtension): @classmethod def get_name(cls) -> str: return "update_proposal_end_date" diff --git a/schemas/operations/generate_representation_types.py b/schemas/operations/generate_representation_types.py index 869fc8c6dc75715a494ba3d31406ac6c4a1df83a..9b7135472aef3ce339958164d209749f5d55610a 100644 --- a/schemas/operations/generate_representation_types.py +++ b/schemas/operations/generate_representation_types.py @@ -23,9 +23,9 @@ def ignore_liners_and_add_automation_generation_information(code: str) -> str: def collect_and_write_api_imports(code: str) -> str: code += "from __future__ import annotations\n\n" - code += "from typing import Any, Literal, overload\n\n" + code += "from typing import Any, Generic, Literal, TypeVar, overload\n\n" code += "from schemas._preconfigured_base_model import DictStrAny, PreconfiguredBaseModel\n" - code += "from schemas.operation import Operation\n" + code += "from schemas.operation import Representible, OperationBase\n" for operation_name in all_operations[7:]: if "Legacy" not in operation_name and "Generic" not in operation_name: @@ -36,8 +36,10 @@ def collect_and_write_api_imports(code: str) -> str: def write_hf26representation_and_legacy_representation(code: str) -> str: - code += """class HF26Representation(PreconfiguredBaseModel): - value: Operation + code += """GenericRepresentibleT = TypeVar("GenericRepresentibleT", bound=Representible) + +class HF26Representation(PreconfiguredBaseModel, Generic[GenericRepresentibleT]): + value: GenericRepresentibleT def shallow_dict(self) -> dict[str, Any]: return {"type":self.type_, "value": self.value} @@ -49,16 +51,18 @@ def write_hf26representation_and_legacy_representation(code: str) -> str: @property def type_(self) -> str: - return self.value.get_name_with_suffix() + if isinstance(self.value, OperationBase): + return self.value.get_name_with_suffix() + return self.value.get_name() @overload def __getitem__(self, idx: Literal[0]) -> str: ... @overload - def __getitem__(self, idx: Literal[1]) -> Operation: ... + def __getitem__(self, idx: Literal[1]) -> GenericRepresentibleT: ... @overload def __getitem__(self, idx: str) -> Any: ... - def __getitem__(self, idx: Literal[0, 1] | str) -> str | Operation | Any: + def __getitem__(self, idx: Literal[0, 1] | str) -> str | GenericRepresentibleT | Any: if idx == 0: return self.type_ if idx == 1: @@ -66,8 +70,8 @@ def write_hf26representation_and_legacy_representation(code: str) -> str: return super().__getitem__(idx) -class LegacyRepresentation(PreconfiguredBaseModel): - value: Operation +class LegacyRepresentation(PreconfiguredBaseModel, Generic[GenericRepresentibleT]): + value: GenericRepresentibleT @property def type_(self) -> str: @@ -76,9 +80,9 @@ class LegacyRepresentation(PreconfiguredBaseModel): @overload # type: ignore [override] def __getitem__(self, idx: Literal[0]) -> str: ... @overload - def __getitem__(self, idx: Literal[1]) -> Operation: ... + def __getitem__(self, idx: Literal[1]) -> GenericRepresentibleT: ... - def __getitem__(self, idx: Literal[0, 1]) -> str | Operation: + def __getitem__(self, idx: Literal[0, 1]) -> str | GenericRepresentibleT: if idx == 0: return self.type_ if idx == 1: @@ -91,10 +95,10 @@ class LegacyRepresentation(PreconfiguredBaseModel): def write_representations_classes(code: str) -> str: for operation_name in all_operations[7:]: if "Generic" not in operation_name: - code += f"""class HF26Representation{operation_name}(HF26Representation, tag={operation_name}.get_name_with_suffix()): + code += f"""class HF26Representation{operation_name}(HF26Representation[{operation_name}], tag={operation_name}.get_name_with_suffix()): value: {operation_name}\n\n\n""" - code += f"""class LegacyRepresentation{operation_name}(LegacyRepresentation, tag={operation_name}.get_name(), array_like=True): + code += f"""class LegacyRepresentation{operation_name}(LegacyRepresentation[{operation_name}], tag={operation_name}.get_name(), array_like=True): value: {operation_name if "WitnessUpdateOperation" not in operation_name else "WitnessUpdateOperationLegacy"}\n\n\n""" return code diff --git a/schemas/operations/limit_order_cancel_operation.py b/schemas/operations/limit_order_cancel_operation.py index ea3a530575dfd87d33ddb24bef46354cbcd51153..3f5d81decfba6865fbc8c74fa7b2d58789970be5 100644 --- a/schemas/operations/limit_order_cancel_operation.py +++ b/schemas/operations/limit_order_cancel_operation.py @@ -6,7 +6,7 @@ from schemas.fields.basic import AccountName from schemas.fields.integers import Uint32t from schemas.operation import Operation -DEFAULT_ORDER_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_ORDER_ID: Final[Uint32t] = 0 class LimitOrderCancelOperation(Operation): diff --git a/schemas/operations/limit_order_create_operation.py b/schemas/operations/limit_order_create_operation.py index 0fb4cd4ea2f20c8e1d5fc841b4b3a8b01fe505c4..c13deb411329095513a95ac4d625dbcd3b355365 100644 --- a/schemas/operations/limit_order_create_operation.py +++ b/schemas/operations/limit_order_create_operation.py @@ -10,7 +10,7 @@ from schemas.fields.integers import Uint32t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.operation import Operation -DEFAULT_ORDER_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_ORDER_ID: Final[Uint32t] = 0 DEFAULT_FILL_OR_KILL: Final[bool] = False diff --git a/schemas/operations/pow2_operation.py b/schemas/operations/pow2_operation.py index ba495d3b9a3c516fa43a1579b28e62b21f1f81b6..93a14f6630741ffbf6f19edf6b6987a5d3dbfc39 100644 --- a/schemas/operations/pow2_operation.py +++ b/schemas/operations/pow2_operation.py @@ -20,12 +20,12 @@ DEFAULT_FILL_OR_KILL: Final[bool] = False class Pow2Input(PreconfiguredBaseModel): worker_account: AccountName prev_block: TransactionId - nonce: Uint64t = field(default_factory=lambda: Uint64t(0)) + nonce: Uint64t = field(default_factory=lambda: 0) class Pow2(PreconfiguredBaseModel): input_: Pow2Input = field(name="input") - pow_summary: Uint32t = field(default_factory=lambda: Uint32t(0)) + pow_summary: Uint32t = field(default_factory=lambda: 0) class EquihashPow(PreconfiguredBaseModel, kw_only=True): diff --git a/schemas/operations/recurrent_transfer_operation.py b/schemas/operations/recurrent_transfer_operation.py index 50a857831520eb4f69dced9d624a1228a0b34d0e..d493546be34d8416407f03d1955d980db1e34b57 100644 --- a/schemas/operations/recurrent_transfer_operation.py +++ b/schemas/operations/recurrent_transfer_operation.py @@ -11,8 +11,8 @@ from schemas.fields.integers import Uint16t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.operation import Operation -DEFAULT_RECURRENCE: Final[Uint16t] = Uint16t(0) -DEFAULT_EXECUTIONS: Final[Uint16t] = Uint16t(0) +DEFAULT_RECURRENCE: Final[Uint16t] = 0 +DEFAULT_EXECUTIONS: Final[Uint16t] = 0 class RecurrentTransferOperation(Operation, kw_only=True): diff --git a/schemas/operations/representation_types.py b/schemas/operations/representation_types.py index 09ebf18769318dfb55b7dc28bb1b9bdf316d53b8..edfdc799208c901ca201be9390f6891f407d9051 100644 --- a/schemas/operations/representation_types.py +++ b/schemas/operations/representation_types.py @@ -6,10 +6,10 @@ from __future__ import annotations -from typing import Any, Literal, overload +from typing import Any, Generic, Literal, TypeVar, overload from schemas._preconfigured_base_model import DictStrAny, PreconfiguredBaseModel -from schemas.operation import Operation +from schemas.operation import OperationBase, Representible from schemas.operations.account_create_operation import AccountCreateOperation from schemas.operations.account_create_with_delegation_operation import AccountCreateWithDelegationOperation from schemas.operations.account_update2_operation import AccountUpdate2Operation @@ -63,9 +63,10 @@ from schemas.operations.witness_block_approve_operation import WitnessBlockAppro from schemas.operations.witness_set_properties_operation import WitnessSetPropertiesOperation from schemas.operations.witness_update_operation import WitnessUpdateOperation, WitnessUpdateOperationLegacy +GenericRepresentibleT = TypeVar("GenericRepresentibleT", bound=Representible) -class HF26Representation(PreconfiguredBaseModel): - value: Operation +class HF26Representation(PreconfiguredBaseModel, Generic[GenericRepresentibleT]): + value: GenericRepresentibleT def shallow_dict(self) -> dict[str, Any]: return {"type":self.type_, "value": self.value} @@ -77,16 +78,18 @@ class HF26Representation(PreconfiguredBaseModel): @property def type_(self) -> str: - return self.value.get_name_with_suffix() + if isinstance(self.value, OperationBase): + return self.value.get_name_with_suffix() + return self.value.get_name() @overload def __getitem__(self, idx: Literal[0]) -> str: ... @overload - def __getitem__(self, idx: Literal[1]) -> Operation: ... + def __getitem__(self, idx: Literal[1]) -> GenericRepresentibleT: ... @overload - def __getitem__(self, idx: str) -> Any: ... + def __getitem__(self, idx: str | int) -> Any: ... - def __getitem__(self, idx: Literal[0, 1] | str) -> str | Operation | Any: + def __getitem__(self, idx: Literal[0, 1] | str | int) -> str | GenericRepresentibleT | Any: if idx == 0: return self.type_ if idx == 1: @@ -94,8 +97,8 @@ class HF26Representation(PreconfiguredBaseModel): return super().__getitem__(idx) -class LegacyRepresentation(PreconfiguredBaseModel): - value: Operation +class LegacyRepresentation(PreconfiguredBaseModel, Generic[GenericRepresentibleT]): + value: GenericRepresentibleT @property def type_(self) -> str: @@ -104,426 +107,426 @@ class LegacyRepresentation(PreconfiguredBaseModel): @overload # type: ignore [override] def __getitem__(self, idx: Literal[0]) -> str: ... @overload - def __getitem__(self, idx: Literal[1]) -> Operation: ... + def __getitem__(self, idx: Literal[1]) -> GenericRepresentibleT: ... - def __getitem__(self, idx: Literal[0, 1]) -> str | Operation: + def __getitem__(self, idx: Literal[0, 1]) -> str | GenericRepresentibleT: if idx == 0: return self.type_ if idx == 1: return self.value raise ValueError("Index out of bound <0; 1>") -class HF26RepresentationAccountCreateOperation(HF26Representation, tag=AccountCreateOperation.get_name_with_suffix()): +class HF26RepresentationAccountCreateOperation(HF26Representation[AccountCreateOperation], tag=AccountCreateOperation.get_name_with_suffix()): value: AccountCreateOperation -class LegacyRepresentationAccountCreateOperation(LegacyRepresentation, tag=AccountCreateOperation.get_name(), array_like=True): +class LegacyRepresentationAccountCreateOperation(LegacyRepresentation[AccountCreateOperation], tag=AccountCreateOperation.get_name(), array_like=True): value: AccountCreateOperation -class HF26RepresentationAccountCreateWithDelegationOperation(HF26Representation, tag=AccountCreateWithDelegationOperation.get_name_with_suffix()): +class HF26RepresentationAccountCreateWithDelegationOperation(HF26Representation[AccountCreateWithDelegationOperation], tag=AccountCreateWithDelegationOperation.get_name_with_suffix()): value: AccountCreateWithDelegationOperation -class LegacyRepresentationAccountCreateWithDelegationOperation(LegacyRepresentation, tag=AccountCreateWithDelegationOperation.get_name(), array_like=True): +class LegacyRepresentationAccountCreateWithDelegationOperation(LegacyRepresentation[AccountCreateWithDelegationOperation], tag=AccountCreateWithDelegationOperation.get_name(), array_like=True): value: AccountCreateWithDelegationOperation -class HF26RepresentationAccountUpdate2Operation(HF26Representation, tag=AccountUpdate2Operation.get_name_with_suffix()): +class HF26RepresentationAccountUpdate2Operation(HF26Representation[AccountUpdate2Operation], tag=AccountUpdate2Operation.get_name_with_suffix()): value: AccountUpdate2Operation -class LegacyRepresentationAccountUpdate2Operation(LegacyRepresentation, tag=AccountUpdate2Operation.get_name(), array_like=True): +class LegacyRepresentationAccountUpdate2Operation(LegacyRepresentation[AccountUpdate2Operation], tag=AccountUpdate2Operation.get_name(), array_like=True): value: AccountUpdate2Operation -class HF26RepresentationAccountUpdateOperation(HF26Representation, tag=AccountUpdateOperation.get_name_with_suffix()): +class HF26RepresentationAccountUpdateOperation(HF26Representation[AccountUpdateOperation], tag=AccountUpdateOperation.get_name_with_suffix()): value: AccountUpdateOperation -class LegacyRepresentationAccountUpdateOperation(LegacyRepresentation, tag=AccountUpdateOperation.get_name(), array_like=True): +class LegacyRepresentationAccountUpdateOperation(LegacyRepresentation[AccountUpdateOperation], tag=AccountUpdateOperation.get_name(), array_like=True): value: AccountUpdateOperation -class HF26RepresentationAccountWitnessProxyOperation(HF26Representation, tag=AccountWitnessProxyOperation.get_name_with_suffix()): +class HF26RepresentationAccountWitnessProxyOperation(HF26Representation[AccountWitnessProxyOperation], tag=AccountWitnessProxyOperation.get_name_with_suffix()): value: AccountWitnessProxyOperation -class LegacyRepresentationAccountWitnessProxyOperation(LegacyRepresentation, tag=AccountWitnessProxyOperation.get_name(), array_like=True): +class LegacyRepresentationAccountWitnessProxyOperation(LegacyRepresentation[AccountWitnessProxyOperation], tag=AccountWitnessProxyOperation.get_name(), array_like=True): value: AccountWitnessProxyOperation -class HF26RepresentationAccountWitnessVoteOperation(HF26Representation, tag=AccountWitnessVoteOperation.get_name_with_suffix()): +class HF26RepresentationAccountWitnessVoteOperation(HF26Representation[AccountWitnessVoteOperation], tag=AccountWitnessVoteOperation.get_name_with_suffix()): value: AccountWitnessVoteOperation -class LegacyRepresentationAccountWitnessVoteOperation(LegacyRepresentation, tag=AccountWitnessVoteOperation.get_name(), array_like=True): +class LegacyRepresentationAccountWitnessVoteOperation(LegacyRepresentation[AccountWitnessVoteOperation], tag=AccountWitnessVoteOperation.get_name(), array_like=True): value: AccountWitnessVoteOperation -class HF26RepresentationCancelTransferFromSavingsOperation(HF26Representation, tag=CancelTransferFromSavingsOperation.get_name_with_suffix()): +class HF26RepresentationCancelTransferFromSavingsOperation(HF26Representation[CancelTransferFromSavingsOperation], tag=CancelTransferFromSavingsOperation.get_name_with_suffix()): value: CancelTransferFromSavingsOperation -class LegacyRepresentationCancelTransferFromSavingsOperation(LegacyRepresentation, tag=CancelTransferFromSavingsOperation.get_name(), array_like=True): +class LegacyRepresentationCancelTransferFromSavingsOperation(LegacyRepresentation[CancelTransferFromSavingsOperation], tag=CancelTransferFromSavingsOperation.get_name(), array_like=True): value: CancelTransferFromSavingsOperation -class HF26RepresentationChangeRecoveryAccountOperation(HF26Representation, tag=ChangeRecoveryAccountOperation.get_name_with_suffix()): +class HF26RepresentationChangeRecoveryAccountOperation(HF26Representation[ChangeRecoveryAccountOperation], tag=ChangeRecoveryAccountOperation.get_name_with_suffix()): value: ChangeRecoveryAccountOperation -class LegacyRepresentationChangeRecoveryAccountOperation(LegacyRepresentation, tag=ChangeRecoveryAccountOperation.get_name(), array_like=True): +class LegacyRepresentationChangeRecoveryAccountOperation(LegacyRepresentation[ChangeRecoveryAccountOperation], tag=ChangeRecoveryAccountOperation.get_name(), array_like=True): value: ChangeRecoveryAccountOperation -class HF26RepresentationClaimAccountOperation(HF26Representation, tag=ClaimAccountOperation.get_name_with_suffix()): +class HF26RepresentationClaimAccountOperation(HF26Representation[ClaimAccountOperation], tag=ClaimAccountOperation.get_name_with_suffix()): value: ClaimAccountOperation -class LegacyRepresentationClaimAccountOperation(LegacyRepresentation, tag=ClaimAccountOperation.get_name(), array_like=True): +class LegacyRepresentationClaimAccountOperation(LegacyRepresentation[ClaimAccountOperation], tag=ClaimAccountOperation.get_name(), array_like=True): value: ClaimAccountOperation -class HF26RepresentationClaimRewardBalanceOperation(HF26Representation, tag=ClaimRewardBalanceOperation.get_name_with_suffix()): +class HF26RepresentationClaimRewardBalanceOperation(HF26Representation[ClaimRewardBalanceOperation], tag=ClaimRewardBalanceOperation.get_name_with_suffix()): value: ClaimRewardBalanceOperation -class LegacyRepresentationClaimRewardBalanceOperation(LegacyRepresentation, tag=ClaimRewardBalanceOperation.get_name(), array_like=True): +class LegacyRepresentationClaimRewardBalanceOperation(LegacyRepresentation[ClaimRewardBalanceOperation], tag=ClaimRewardBalanceOperation.get_name(), array_like=True): value: ClaimRewardBalanceOperation -class HF26RepresentationCollateralizedConvertOperation(HF26Representation, tag=CollateralizedConvertOperation.get_name_with_suffix()): +class HF26RepresentationCollateralizedConvertOperation(HF26Representation[CollateralizedConvertOperation], tag=CollateralizedConvertOperation.get_name_with_suffix()): value: CollateralizedConvertOperation -class LegacyRepresentationCollateralizedConvertOperation(LegacyRepresentation, tag=CollateralizedConvertOperation.get_name(), array_like=True): +class LegacyRepresentationCollateralizedConvertOperation(LegacyRepresentation[CollateralizedConvertOperation], tag=CollateralizedConvertOperation.get_name(), array_like=True): value: CollateralizedConvertOperation -class HF26RepresentationCommentOperation(HF26Representation, tag=CommentOperation.get_name_with_suffix()): +class HF26RepresentationCommentOperation(HF26Representation[CommentOperation], tag=CommentOperation.get_name_with_suffix()): value: CommentOperation -class LegacyRepresentationCommentOperation(LegacyRepresentation, tag=CommentOperation.get_name(), array_like=True): +class LegacyRepresentationCommentOperation(LegacyRepresentation[CommentOperation], tag=CommentOperation.get_name(), array_like=True): value: CommentOperation -class HF26RepresentationCommentOptionsOperation(HF26Representation, tag=CommentOptionsOperation.get_name_with_suffix()): +class HF26RepresentationCommentOptionsOperation(HF26Representation[CommentOptionsOperation], tag=CommentOptionsOperation.get_name_with_suffix()): value: CommentOptionsOperation -class LegacyRepresentationCommentOptionsOperation(LegacyRepresentation, tag=CommentOptionsOperation.get_name(), array_like=True): +class LegacyRepresentationCommentOptionsOperation(LegacyRepresentation[CommentOptionsOperation], tag=CommentOptionsOperation.get_name(), array_like=True): value: CommentOptionsOperation -class HF26RepresentationConvertOperation(HF26Representation, tag=ConvertOperation.get_name_with_suffix()): +class HF26RepresentationConvertOperation(HF26Representation[ConvertOperation], tag=ConvertOperation.get_name_with_suffix()): value: ConvertOperation -class LegacyRepresentationConvertOperation(LegacyRepresentation, tag=ConvertOperation.get_name(), array_like=True): +class LegacyRepresentationConvertOperation(LegacyRepresentation[ConvertOperation], tag=ConvertOperation.get_name(), array_like=True): value: ConvertOperation -class HF26RepresentationCreateClaimedAccountOperation(HF26Representation, tag=CreateClaimedAccountOperation.get_name_with_suffix()): +class HF26RepresentationCreateClaimedAccountOperation(HF26Representation[CreateClaimedAccountOperation], tag=CreateClaimedAccountOperation.get_name_with_suffix()): value: CreateClaimedAccountOperation -class LegacyRepresentationCreateClaimedAccountOperation(LegacyRepresentation, tag=CreateClaimedAccountOperation.get_name(), array_like=True): +class LegacyRepresentationCreateClaimedAccountOperation(LegacyRepresentation[CreateClaimedAccountOperation], tag=CreateClaimedAccountOperation.get_name(), array_like=True): value: CreateClaimedAccountOperation -class HF26RepresentationCreateProposalOperation(HF26Representation, tag=CreateProposalOperation.get_name_with_suffix()): +class HF26RepresentationCreateProposalOperation(HF26Representation[CreateProposalOperation], tag=CreateProposalOperation.get_name_with_suffix()): value: CreateProposalOperation -class LegacyRepresentationCreateProposalOperation(LegacyRepresentation, tag=CreateProposalOperation.get_name(), array_like=True): +class LegacyRepresentationCreateProposalOperation(LegacyRepresentation[CreateProposalOperation], tag=CreateProposalOperation.get_name(), array_like=True): value: CreateProposalOperation -class HF26RepresentationCustomBinaryOperation(HF26Representation, tag=CustomBinaryOperation.get_name_with_suffix()): +class HF26RepresentationCustomBinaryOperation(HF26Representation[CustomBinaryOperation], tag=CustomBinaryOperation.get_name_with_suffix()): value: CustomBinaryOperation -class LegacyRepresentationCustomBinaryOperation(LegacyRepresentation, tag=CustomBinaryOperation.get_name(), array_like=True): +class LegacyRepresentationCustomBinaryOperation(LegacyRepresentation[CustomBinaryOperation], tag=CustomBinaryOperation.get_name(), array_like=True): value: CustomBinaryOperation -class HF26RepresentationCustomJsonOperation(HF26Representation, tag=CustomJsonOperation.get_name_with_suffix()): +class HF26RepresentationCustomJsonOperation(HF26Representation[CustomJsonOperation], tag=CustomJsonOperation.get_name_with_suffix()): value: CustomJsonOperation -class LegacyRepresentationCustomJsonOperation(LegacyRepresentation, tag=CustomJsonOperation.get_name(), array_like=True): +class LegacyRepresentationCustomJsonOperation(LegacyRepresentation[CustomJsonOperation], tag=CustomJsonOperation.get_name(), array_like=True): value: CustomJsonOperation -class HF26RepresentationCustomOperation(HF26Representation, tag=CustomOperation.get_name_with_suffix()): +class HF26RepresentationCustomOperation(HF26Representation[CustomOperation], tag=CustomOperation.get_name_with_suffix()): value: CustomOperation -class LegacyRepresentationCustomOperation(LegacyRepresentation, tag=CustomOperation.get_name(), array_like=True): +class LegacyRepresentationCustomOperation(LegacyRepresentation[CustomOperation], tag=CustomOperation.get_name(), array_like=True): value: CustomOperation -class HF26RepresentationDeclineVotingRightsOperation(HF26Representation, tag=DeclineVotingRightsOperation.get_name_with_suffix()): +class HF26RepresentationDeclineVotingRightsOperation(HF26Representation[DeclineVotingRightsOperation], tag=DeclineVotingRightsOperation.get_name_with_suffix()): value: DeclineVotingRightsOperation -class LegacyRepresentationDeclineVotingRightsOperation(LegacyRepresentation, tag=DeclineVotingRightsOperation.get_name(), array_like=True): +class LegacyRepresentationDeclineVotingRightsOperation(LegacyRepresentation[DeclineVotingRightsOperation], tag=DeclineVotingRightsOperation.get_name(), array_like=True): value: DeclineVotingRightsOperation -class HF26RepresentationDelegateRcOperation(HF26Representation, tag=DelegateRcOperation.get_name_with_suffix()): +class HF26RepresentationDelegateRcOperation(HF26Representation[DelegateRcOperation], tag=DelegateRcOperation.get_name_with_suffix()): value: DelegateRcOperation -class LegacyRepresentationDelegateRcOperation(LegacyRepresentation, tag=DelegateRcOperation.get_name(), array_like=True): +class LegacyRepresentationDelegateRcOperation(LegacyRepresentation[DelegateRcOperation], tag=DelegateRcOperation.get_name(), array_like=True): value: DelegateRcOperation -class HF26RepresentationDelegateVestingSharesOperation(HF26Representation, tag=DelegateVestingSharesOperation.get_name_with_suffix()): +class HF26RepresentationDelegateVestingSharesOperation(HF26Representation[DelegateVestingSharesOperation], tag=DelegateVestingSharesOperation.get_name_with_suffix()): value: DelegateVestingSharesOperation -class LegacyRepresentationDelegateVestingSharesOperation(LegacyRepresentation, tag=DelegateVestingSharesOperation.get_name(), array_like=True): +class LegacyRepresentationDelegateVestingSharesOperation(LegacyRepresentation[DelegateVestingSharesOperation], tag=DelegateVestingSharesOperation.get_name(), array_like=True): value: DelegateVestingSharesOperation -class HF26RepresentationDeleteCommentOperation(HF26Representation, tag=DeleteCommentOperation.get_name_with_suffix()): +class HF26RepresentationDeleteCommentOperation(HF26Representation[DeleteCommentOperation], tag=DeleteCommentOperation.get_name_with_suffix()): value: DeleteCommentOperation -class LegacyRepresentationDeleteCommentOperation(LegacyRepresentation, tag=DeleteCommentOperation.get_name(), array_like=True): +class LegacyRepresentationDeleteCommentOperation(LegacyRepresentation[DeleteCommentOperation], tag=DeleteCommentOperation.get_name(), array_like=True): value: DeleteCommentOperation -class HF26RepresentationEscrowApproveOperation(HF26Representation, tag=EscrowApproveOperation.get_name_with_suffix()): +class HF26RepresentationEscrowApproveOperation(HF26Representation[EscrowApproveOperation], tag=EscrowApproveOperation.get_name_with_suffix()): value: EscrowApproveOperation -class LegacyRepresentationEscrowApproveOperation(LegacyRepresentation, tag=EscrowApproveOperation.get_name(), array_like=True): +class LegacyRepresentationEscrowApproveOperation(LegacyRepresentation[EscrowApproveOperation], tag=EscrowApproveOperation.get_name(), array_like=True): value: EscrowApproveOperation -class HF26RepresentationEscrowDisputeOperation(HF26Representation, tag=EscrowDisputeOperation.get_name_with_suffix()): +class HF26RepresentationEscrowDisputeOperation(HF26Representation[EscrowDisputeOperation], tag=EscrowDisputeOperation.get_name_with_suffix()): value: EscrowDisputeOperation -class LegacyRepresentationEscrowDisputeOperation(LegacyRepresentation, tag=EscrowDisputeOperation.get_name(), array_like=True): +class LegacyRepresentationEscrowDisputeOperation(LegacyRepresentation[EscrowDisputeOperation], tag=EscrowDisputeOperation.get_name(), array_like=True): value: EscrowDisputeOperation -class HF26RepresentationEscrowReleaseOperation(HF26Representation, tag=EscrowReleaseOperation.get_name_with_suffix()): +class HF26RepresentationEscrowReleaseOperation(HF26Representation[EscrowReleaseOperation], tag=EscrowReleaseOperation.get_name_with_suffix()): value: EscrowReleaseOperation -class LegacyRepresentationEscrowReleaseOperation(LegacyRepresentation, tag=EscrowReleaseOperation.get_name(), array_like=True): +class LegacyRepresentationEscrowReleaseOperation(LegacyRepresentation[EscrowReleaseOperation], tag=EscrowReleaseOperation.get_name(), array_like=True): value: EscrowReleaseOperation -class HF26RepresentationEscrowTransferOperation(HF26Representation, tag=EscrowTransferOperation.get_name_with_suffix()): +class HF26RepresentationEscrowTransferOperation(HF26Representation[EscrowTransferOperation], tag=EscrowTransferOperation.get_name_with_suffix()): value: EscrowTransferOperation -class LegacyRepresentationEscrowTransferOperation(LegacyRepresentation, tag=EscrowTransferOperation.get_name(), array_like=True): +class LegacyRepresentationEscrowTransferOperation(LegacyRepresentation[EscrowTransferOperation], tag=EscrowTransferOperation.get_name(), array_like=True): value: EscrowTransferOperation -class HF26RepresentationFeedPublishOperation(HF26Representation, tag=FeedPublishOperation.get_name_with_suffix()): +class HF26RepresentationFeedPublishOperation(HF26Representation[FeedPublishOperation], tag=FeedPublishOperation.get_name_with_suffix()): value: FeedPublishOperation -class LegacyRepresentationFeedPublishOperation(LegacyRepresentation, tag=FeedPublishOperation.get_name(), array_like=True): +class LegacyRepresentationFeedPublishOperation(LegacyRepresentation[FeedPublishOperation], tag=FeedPublishOperation.get_name(), array_like=True): value: FeedPublishOperation -class HF26RepresentationFollowOperation(HF26Representation, tag=FollowOperation.get_name_with_suffix()): +class HF26RepresentationFollowOperation(HF26Representation[FollowOperation], tag=FollowOperation.get_name_with_suffix()): value: FollowOperation -class LegacyRepresentationFollowOperation(LegacyRepresentation, tag=FollowOperation.get_name(), array_like=True): +class LegacyRepresentationFollowOperation(LegacyRepresentation[FollowOperation], tag=FollowOperation.get_name(), array_like=True): value: FollowOperation -class HF26RepresentationLimitOrderCancelOperation(HF26Representation, tag=LimitOrderCancelOperation.get_name_with_suffix()): +class HF26RepresentationLimitOrderCancelOperation(HF26Representation[LimitOrderCancelOperation], tag=LimitOrderCancelOperation.get_name_with_suffix()): value: LimitOrderCancelOperation -class LegacyRepresentationLimitOrderCancelOperation(LegacyRepresentation, tag=LimitOrderCancelOperation.get_name(), array_like=True): +class LegacyRepresentationLimitOrderCancelOperation(LegacyRepresentation[LimitOrderCancelOperation], tag=LimitOrderCancelOperation.get_name(), array_like=True): value: LimitOrderCancelOperation -class HF26RepresentationLimitOrderCreate2Operation(HF26Representation, tag=LimitOrderCreate2Operation.get_name_with_suffix()): +class HF26RepresentationLimitOrderCreate2Operation(HF26Representation[LimitOrderCreate2Operation], tag=LimitOrderCreate2Operation.get_name_with_suffix()): value: LimitOrderCreate2Operation -class LegacyRepresentationLimitOrderCreate2Operation(LegacyRepresentation, tag=LimitOrderCreate2Operation.get_name(), array_like=True): +class LegacyRepresentationLimitOrderCreate2Operation(LegacyRepresentation[LimitOrderCreate2Operation], tag=LimitOrderCreate2Operation.get_name(), array_like=True): value: LimitOrderCreate2Operation -class HF26RepresentationLimitOrderCreateOperation(HF26Representation, tag=LimitOrderCreateOperation.get_name_with_suffix()): +class HF26RepresentationLimitOrderCreateOperation(HF26Representation[LimitOrderCreateOperation], tag=LimitOrderCreateOperation.get_name_with_suffix()): value: LimitOrderCreateOperation -class LegacyRepresentationLimitOrderCreateOperation(LegacyRepresentation, tag=LimitOrderCreateOperation.get_name(), array_like=True): +class LegacyRepresentationLimitOrderCreateOperation(LegacyRepresentation[LimitOrderCreateOperation], tag=LimitOrderCreateOperation.get_name(), array_like=True): value: LimitOrderCreateOperation -class HF26RepresentationPow2Operation(HF26Representation, tag=Pow2Operation.get_name_with_suffix()): +class HF26RepresentationPow2Operation(HF26Representation[Pow2Operation], tag=Pow2Operation.get_name_with_suffix()): value: Pow2Operation -class LegacyRepresentationPow2Operation(LegacyRepresentation, tag=Pow2Operation.get_name(), array_like=True): +class LegacyRepresentationPow2Operation(LegacyRepresentation[Pow2Operation], tag=Pow2Operation.get_name(), array_like=True): value: Pow2Operation -class HF26RepresentationPowOperation(HF26Representation, tag=PowOperation.get_name_with_suffix()): +class HF26RepresentationPowOperation(HF26Representation[PowOperation], tag=PowOperation.get_name_with_suffix()): value: PowOperation -class LegacyRepresentationPowOperation(LegacyRepresentation, tag=PowOperation.get_name(), array_like=True): +class LegacyRepresentationPowOperation(LegacyRepresentation[PowOperation], tag=PowOperation.get_name(), array_like=True): value: PowOperation -class HF26RepresentationRecoverAccountOperation(HF26Representation, tag=RecoverAccountOperation.get_name_with_suffix()): +class HF26RepresentationRecoverAccountOperation(HF26Representation[RecoverAccountOperation], tag=RecoverAccountOperation.get_name_with_suffix()): value: RecoverAccountOperation -class LegacyRepresentationRecoverAccountOperation(LegacyRepresentation, tag=RecoverAccountOperation.get_name(), array_like=True): +class LegacyRepresentationRecoverAccountOperation(LegacyRepresentation[RecoverAccountOperation], tag=RecoverAccountOperation.get_name(), array_like=True): value: RecoverAccountOperation -class HF26RepresentationRecurrentTransferOperation(HF26Representation, tag=RecurrentTransferOperation.get_name_with_suffix()): +class HF26RepresentationRecurrentTransferOperation(HF26Representation[RecurrentTransferOperation], tag=RecurrentTransferOperation.get_name_with_suffix()): value: RecurrentTransferOperation -class LegacyRepresentationRecurrentTransferOperation(LegacyRepresentation, tag=RecurrentTransferOperation.get_name(), array_like=True): +class LegacyRepresentationRecurrentTransferOperation(LegacyRepresentation[RecurrentTransferOperation], tag=RecurrentTransferOperation.get_name(), array_like=True): value: RecurrentTransferOperation -class HF26RepresentationRemoveProposalOperation(HF26Representation, tag=RemoveProposalOperation.get_name_with_suffix()): +class HF26RepresentationRemoveProposalOperation(HF26Representation[RemoveProposalOperation], tag=RemoveProposalOperation.get_name_with_suffix()): value: RemoveProposalOperation -class LegacyRepresentationRemoveProposalOperation(LegacyRepresentation, tag=RemoveProposalOperation.get_name(), array_like=True): +class LegacyRepresentationRemoveProposalOperation(LegacyRepresentation[RemoveProposalOperation], tag=RemoveProposalOperation.get_name(), array_like=True): value: RemoveProposalOperation -class HF26RepresentationRequestAccountRecoveryOperation(HF26Representation, tag=RequestAccountRecoveryOperation.get_name_with_suffix()): +class HF26RepresentationRequestAccountRecoveryOperation(HF26Representation[RequestAccountRecoveryOperation], tag=RequestAccountRecoveryOperation.get_name_with_suffix()): value: RequestAccountRecoveryOperation -class LegacyRepresentationRequestAccountRecoveryOperation(LegacyRepresentation, tag=RequestAccountRecoveryOperation.get_name(), array_like=True): +class LegacyRepresentationRequestAccountRecoveryOperation(LegacyRepresentation[RequestAccountRecoveryOperation], tag=RequestAccountRecoveryOperation.get_name(), array_like=True): value: RequestAccountRecoveryOperation -class HF26RepresentationResetAccountOperation(HF26Representation, tag=ResetAccountOperation.get_name_with_suffix()): +class HF26RepresentationResetAccountOperation(HF26Representation[ResetAccountOperation], tag=ResetAccountOperation.get_name_with_suffix()): value: ResetAccountOperation -class LegacyRepresentationResetAccountOperation(LegacyRepresentation, tag=ResetAccountOperation.get_name(), array_like=True): +class LegacyRepresentationResetAccountOperation(LegacyRepresentation[ResetAccountOperation], tag=ResetAccountOperation.get_name(), array_like=True): value: ResetAccountOperation -class HF26RepresentationSetResetAccountOperation(HF26Representation, tag=SetResetAccountOperation.get_name_with_suffix()): +class HF26RepresentationSetResetAccountOperation(HF26Representation[SetResetAccountOperation], tag=SetResetAccountOperation.get_name_with_suffix()): value: SetResetAccountOperation -class LegacyRepresentationSetResetAccountOperation(LegacyRepresentation, tag=SetResetAccountOperation.get_name(), array_like=True): +class LegacyRepresentationSetResetAccountOperation(LegacyRepresentation[SetResetAccountOperation], tag=SetResetAccountOperation.get_name(), array_like=True): value: SetResetAccountOperation -class HF26RepresentationSetWithdrawVestingRouteOperation(HF26Representation, tag=SetWithdrawVestingRouteOperation.get_name_with_suffix()): +class HF26RepresentationSetWithdrawVestingRouteOperation(HF26Representation[SetWithdrawVestingRouteOperation], tag=SetWithdrawVestingRouteOperation.get_name_with_suffix()): value: SetWithdrawVestingRouteOperation -class LegacyRepresentationSetWithdrawVestingRouteOperation(LegacyRepresentation, tag=SetWithdrawVestingRouteOperation.get_name(), array_like=True): +class LegacyRepresentationSetWithdrawVestingRouteOperation(LegacyRepresentation[SetWithdrawVestingRouteOperation], tag=SetWithdrawVestingRouteOperation.get_name(), array_like=True): value: SetWithdrawVestingRouteOperation -class HF26RepresentationTransferFromSavingsOperation(HF26Representation, tag=TransferFromSavingsOperation.get_name_with_suffix()): +class HF26RepresentationTransferFromSavingsOperation(HF26Representation[TransferFromSavingsOperation], tag=TransferFromSavingsOperation.get_name_with_suffix()): value: TransferFromSavingsOperation -class LegacyRepresentationTransferFromSavingsOperation(LegacyRepresentation, tag=TransferFromSavingsOperation.get_name(), array_like=True): +class LegacyRepresentationTransferFromSavingsOperation(LegacyRepresentation[TransferFromSavingsOperation], tag=TransferFromSavingsOperation.get_name(), array_like=True): value: TransferFromSavingsOperation -class HF26RepresentationTransferOperation(HF26Representation, tag=TransferOperation.get_name_with_suffix()): +class HF26RepresentationTransferOperation(HF26Representation[TransferOperation], tag=TransferOperation.get_name_with_suffix()): value: TransferOperation -class LegacyRepresentationTransferOperation(LegacyRepresentation, tag=TransferOperation.get_name(), array_like=True): +class LegacyRepresentationTransferOperation(LegacyRepresentation[TransferOperation], tag=TransferOperation.get_name(), array_like=True): value: TransferOperation -class HF26RepresentationTransferToSavingsOperation(HF26Representation, tag=TransferToSavingsOperation.get_name_with_suffix()): +class HF26RepresentationTransferToSavingsOperation(HF26Representation[TransferToSavingsOperation], tag=TransferToSavingsOperation.get_name_with_suffix()): value: TransferToSavingsOperation -class LegacyRepresentationTransferToSavingsOperation(LegacyRepresentation, tag=TransferToSavingsOperation.get_name(), array_like=True): +class LegacyRepresentationTransferToSavingsOperation(LegacyRepresentation[TransferToSavingsOperation], tag=TransferToSavingsOperation.get_name(), array_like=True): value: TransferToSavingsOperation -class HF26RepresentationTransferToVestingOperation(HF26Representation, tag=TransferToVestingOperation.get_name_with_suffix()): +class HF26RepresentationTransferToVestingOperation(HF26Representation[TransferToVestingOperation], tag=TransferToVestingOperation.get_name_with_suffix()): value: TransferToVestingOperation -class LegacyRepresentationTransferToVestingOperation(LegacyRepresentation, tag=TransferToVestingOperation.get_name(), array_like=True): +class LegacyRepresentationTransferToVestingOperation(LegacyRepresentation[TransferToVestingOperation], tag=TransferToVestingOperation.get_name(), array_like=True): value: TransferToVestingOperation -class HF26RepresentationUpdateProposalOperation(HF26Representation, tag=UpdateProposalOperation.get_name_with_suffix()): +class HF26RepresentationUpdateProposalOperation(HF26Representation[UpdateProposalOperation], tag=UpdateProposalOperation.get_name_with_suffix()): value: UpdateProposalOperation -class LegacyRepresentationUpdateProposalOperation(LegacyRepresentation, tag=UpdateProposalOperation.get_name(), array_like=True): +class LegacyRepresentationUpdateProposalOperation(LegacyRepresentation[UpdateProposalOperation], tag=UpdateProposalOperation.get_name(), array_like=True): value: UpdateProposalOperation -class HF26RepresentationUpdateProposalVotesOperation(HF26Representation, tag=UpdateProposalVotesOperation.get_name_with_suffix()): +class HF26RepresentationUpdateProposalVotesOperation(HF26Representation[UpdateProposalVotesOperation], tag=UpdateProposalVotesOperation.get_name_with_suffix()): value: UpdateProposalVotesOperation -class LegacyRepresentationUpdateProposalVotesOperation(LegacyRepresentation, tag=UpdateProposalVotesOperation.get_name(), array_like=True): +class LegacyRepresentationUpdateProposalVotesOperation(LegacyRepresentation[UpdateProposalVotesOperation], tag=UpdateProposalVotesOperation.get_name(), array_like=True): value: UpdateProposalVotesOperation -class HF26RepresentationVoteOperation(HF26Representation, tag=VoteOperation.get_name_with_suffix()): +class HF26RepresentationVoteOperation(HF26Representation[VoteOperation], tag=VoteOperation.get_name_with_suffix()): value: VoteOperation -class LegacyRepresentationVoteOperation(LegacyRepresentation, tag=VoteOperation.get_name(), array_like=True): +class LegacyRepresentationVoteOperation(LegacyRepresentation[VoteOperation], tag=VoteOperation.get_name(), array_like=True): value: VoteOperation -class HF26RepresentationWithdrawVestingOperation(HF26Representation, tag=WithdrawVestingOperation.get_name_with_suffix()): +class HF26RepresentationWithdrawVestingOperation(HF26Representation[WithdrawVestingOperation], tag=WithdrawVestingOperation.get_name_with_suffix()): value: WithdrawVestingOperation -class LegacyRepresentationWithdrawVestingOperation(LegacyRepresentation, tag=WithdrawVestingOperation.get_name(), array_like=True): +class LegacyRepresentationWithdrawVestingOperation(LegacyRepresentation[WithdrawVestingOperation], tag=WithdrawVestingOperation.get_name(), array_like=True): value: WithdrawVestingOperation -class HF26RepresentationWitnessBlockApproveOperation(HF26Representation, tag=WitnessBlockApproveOperation.get_name_with_suffix()): +class HF26RepresentationWitnessBlockApproveOperation(HF26Representation[WitnessBlockApproveOperation], tag=WitnessBlockApproveOperation.get_name_with_suffix()): value: WitnessBlockApproveOperation -class LegacyRepresentationWitnessBlockApproveOperation(LegacyRepresentation, tag=WitnessBlockApproveOperation.get_name(), array_like=True): +class LegacyRepresentationWitnessBlockApproveOperation(LegacyRepresentation[WitnessBlockApproveOperation], tag=WitnessBlockApproveOperation.get_name(), array_like=True): value: WitnessBlockApproveOperation -class HF26RepresentationWitnessSetPropertiesOperation(HF26Representation, tag=WitnessSetPropertiesOperation.get_name_with_suffix()): +class HF26RepresentationWitnessSetPropertiesOperation(HF26Representation[WitnessSetPropertiesOperation], tag=WitnessSetPropertiesOperation.get_name_with_suffix()): value: WitnessSetPropertiesOperation -class LegacyRepresentationWitnessSetPropertiesOperation(LegacyRepresentation, tag=WitnessSetPropertiesOperation.get_name(), array_like=True): +class LegacyRepresentationWitnessSetPropertiesOperation(LegacyRepresentation[WitnessSetPropertiesOperation], tag=WitnessSetPropertiesOperation.get_name(), array_like=True): value: WitnessSetPropertiesOperation -class HF26RepresentationWitnessUpdateOperation(HF26Representation, tag=WitnessUpdateOperation.get_name_with_suffix()): +class HF26RepresentationWitnessUpdateOperation(HF26Representation[WitnessUpdateOperation], tag=WitnessUpdateOperation.get_name_with_suffix()): value: WitnessUpdateOperation -class LegacyRepresentationWitnessUpdateOperation(LegacyRepresentation, tag=WitnessUpdateOperation.get_name(), array_like=True): +class LegacyRepresentationWitnessUpdateOperation(LegacyRepresentation[WitnessUpdateOperation], tag=WitnessUpdateOperation.get_name(), array_like=True): value: WitnessUpdateOperationLegacy diff --git a/schemas/operations/set_withdraw_vesting_route_operation.py b/schemas/operations/set_withdraw_vesting_route_operation.py index 2db8d42820689d2fdbb8953fb8e422cbb30d8092..cb467742dd1693e038e8b225b7951bf58d550c5d 100644 --- a/schemas/operations/set_withdraw_vesting_route_operation.py +++ b/schemas/operations/set_withdraw_vesting_route_operation.py @@ -6,7 +6,7 @@ from schemas.fields.basic import AccountName from schemas.fields.integers import Uint16t from schemas.operation import Operation -DEFAULT_PERCENT: Final[Uint16t] = Uint16t(0) +DEFAULT_PERCENT: Final[Uint16t] = 0 DEFAULT_AUTO_VEST: Final[bool] = False diff --git a/schemas/operations/transfer_from_savings_operation.py b/schemas/operations/transfer_from_savings_operation.py index 563a165c53626057692bc7b42885aad3117e0d25..f60d5296bf5f120d2394e8ad88294455aafc0dca 100644 --- a/schemas/operations/transfer_from_savings_operation.py +++ b/schemas/operations/transfer_from_savings_operation.py @@ -11,7 +11,7 @@ from schemas.fields.integers import Uint32t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.operation import Operation -DEFAULT_TYPE_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_TYPE_ID: Final[Uint32t] = 0 class TransferFromSavingsOperation(Operation, kw_only=True): diff --git a/schemas/operations/virtual/collateralized_convert_immediate_conversion_operation.py b/schemas/operations/virtual/collateralized_convert_immediate_conversion_operation.py index 31e25c8d5582b631e4dec415a7d84b63faf18790..fe5d80833bd782d93ee2519522ebb208ddd74587 100644 --- a/schemas/operations/virtual/collateralized_convert_immediate_conversion_operation.py +++ b/schemas/operations/virtual/collateralized_convert_immediate_conversion_operation.py @@ -9,7 +9,7 @@ from schemas.fields.basic import ( from schemas.fields.integers import Uint32t from schemas.virtual_operation import VirtualOperation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class CollateralizedConvertImmediateConversionOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/effective_comment_vote_operation.py b/schemas/operations/virtual/effective_comment_vote_operation.py index 77cf3c8be2428fb3ddea5ece29a0a3ee50f07bee..4a506c18d602d6b2f1f2334161062371b20c0fda 100644 --- a/schemas/operations/virtual/effective_comment_vote_operation.py +++ b/schemas/operations/virtual/effective_comment_vote_operation.py @@ -9,9 +9,9 @@ from schemas.fields.basic import ( from schemas.fields.integers import Int64t, Uint64t from schemas.virtual_operation import VirtualOperation -DEFAULT_WEIGHT: Final[Uint64t] = Uint64t(0) -DEFAULT_RSHARES: Final[Int64t] = Int64t(0) -DEFAULT_TOTAL_VOTE_WEIGHT: Final[Uint64t] = Uint64t(0) +DEFAULT_WEIGHT: Final[Uint64t] = 0 +DEFAULT_RSHARES: Final[Int64t] = 0 +DEFAULT_TOTAL_VOTE_WEIGHT: Final[Uint64t] = 0 class EffectiveCommentVoteOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/escrow_approved_operation.py b/schemas/operations/virtual/escrow_approved_operation.py index f10854a133304ef651bd3b9c37a54bce17d67db3..babc573565f3e7df58c545c6d9d81ce75eccf075 100644 --- a/schemas/operations/virtual/escrow_approved_operation.py +++ b/schemas/operations/virtual/escrow_approved_operation.py @@ -11,7 +11,7 @@ from schemas.fields.integers import Uint32t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.virtual_operation import VirtualOperation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class EscrowApprovedOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/escrow_rejected_operation.py b/schemas/operations/virtual/escrow_rejected_operation.py index ac8dbd91d2f0d72f70b22250c5aaa52677dd7b77..6925c4f935cf60c8a2fefd747b8e66148fa43437 100644 --- a/schemas/operations/virtual/escrow_rejected_operation.py +++ b/schemas/operations/virtual/escrow_rejected_operation.py @@ -12,7 +12,7 @@ from schemas.fields.integers import Uint32t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.virtual_operation import VirtualOperation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class EscrowRejectedOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/failed_recurrent_transfer_operation.py b/schemas/operations/virtual/failed_recurrent_transfer_operation.py index b9cfdfedae72144d08b940bda9a5e0d5c229f7e7..a991b5e00f82e770d1833533873a54f07e3a875a 100644 --- a/schemas/operations/virtual/failed_recurrent_transfer_operation.py +++ b/schemas/operations/virtual/failed_recurrent_transfer_operation.py @@ -11,8 +11,8 @@ from schemas.fields.integers import Uint8t, Uint16t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.virtual_operation import VirtualOperation -DEFAULT_CONSECUTIVE_FAILURES: Final[Uint8t] = Uint8t(0) -DEFAULT_REMAINING_EXECUTIONS: Final[Uint16t] = Uint16t(0) +DEFAULT_CONSECUTIVE_FAILURES: Final[Uint8t] = 0 +DEFAULT_REMAINING_EXECUTIONS: Final[Uint16t] = 0 DEFAULT_DELETED: Final[bool] = False diff --git a/schemas/operations/virtual/fill_collateralized_convert_request_operation.py b/schemas/operations/virtual/fill_collateralized_convert_request_operation.py index 056f9b0548c908761f487a70b5f70b34341e4eb1..52c5c11322e548a383767bbd1598c3cfab2b30d2 100644 --- a/schemas/operations/virtual/fill_collateralized_convert_request_operation.py +++ b/schemas/operations/virtual/fill_collateralized_convert_request_operation.py @@ -9,7 +9,7 @@ from schemas.fields.basic import ( from schemas.fields.integers import Uint32t from schemas.virtual_operation import VirtualOperation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class FillCollateralizedConvertRequestOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/fill_convert_request_operation.py b/schemas/operations/virtual/fill_convert_request_operation.py index 810aafca9c64fc1deac2743a9d44ea0d6313b1cc..2f871cb2aae3100adbd204cf61a0140e65c62bf9 100644 --- a/schemas/operations/virtual/fill_convert_request_operation.py +++ b/schemas/operations/virtual/fill_convert_request_operation.py @@ -9,7 +9,7 @@ from schemas.fields.basic import ( from schemas.fields.integers import Uint32t from schemas.virtual_operation import VirtualOperation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class FillConvertRequestOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/fill_order_operation.py b/schemas/operations/virtual/fill_order_operation.py index 70ada257afc99944b84165bcd02e91784f71e45b..f6f29f3fae0257078277a50f4bb26fd92b3d91f4 100644 --- a/schemas/operations/virtual/fill_order_operation.py +++ b/schemas/operations/virtual/fill_order_operation.py @@ -9,8 +9,8 @@ from schemas.fields.integers import Uint32t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.virtual_operation import VirtualOperation -DEFAULT_CURRENT_ORDERID: Final[Uint32t] = Uint32t(0) -DEFAULT_OPEN_ORDERID: Final[Uint32t] = Uint32t(0) +DEFAULT_CURRENT_ORDERID: Final[Uint32t] = 0 +DEFAULT_OPEN_ORDERID: Final[Uint32t] = 0 class FillOrderOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/fill_recurrent_transfer_operation.py b/schemas/operations/virtual/fill_recurrent_transfer_operation.py index c3ae29699343c0ed533d9d85ae4dcfd499253d06..feb38363c643a9f7c20ed130b551516204eca836 100644 --- a/schemas/operations/virtual/fill_recurrent_transfer_operation.py +++ b/schemas/operations/virtual/fill_recurrent_transfer_operation.py @@ -11,7 +11,7 @@ from schemas.fields.integers import Uint16t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.virtual_operation import VirtualOperation -DEFAULT_REMAINING_EXECUTIONS: Final[Uint16t] = Uint16t(0) +DEFAULT_REMAINING_EXECUTIONS: Final[Uint16t] = 0 class FillRecurrentTransferOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/fill_transfer_from_savings_operation.py b/schemas/operations/virtual/fill_transfer_from_savings_operation.py index 100b2fe9761c24ffa009cbc67a2635ec83044019..339e529c33662ddb2c77c7c0ad693f77de97655f 100644 --- a/schemas/operations/virtual/fill_transfer_from_savings_operation.py +++ b/schemas/operations/virtual/fill_transfer_from_savings_operation.py @@ -11,7 +11,7 @@ from schemas.fields.integers import Uint32t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.virtual_operation import VirtualOperation -DEFAULT_REQUEST_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_REQUEST_ID: Final[Uint32t] = 0 class FillTransferFromSavingsOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/generate_representation_types.py b/schemas/operations/virtual/generate_representation_types.py index f2ef29a7a359196520faf122838bfc017b35bfc9..b1aa0991333a5d11890b9c99d01242f17a14a315 100644 --- a/schemas/operations/virtual/generate_representation_types.py +++ b/schemas/operations/virtual/generate_representation_types.py @@ -38,10 +38,10 @@ def collect_and_write_api_imports(code: str) -> str: def write_representations_classes(code: str) -> str: for operation_name in all_operations[3:-32]: if "Generic" not in operation_name: - code += f"""class HF26Representation{operation_name}(HF26Representation, tag={operation_name}.get_name_with_suffix()): + code += f"""class HF26Representation{operation_name}(HF26Representation[{operation_name}], tag={operation_name}.get_name_with_suffix()): value: {operation_name}\n\n\n""" - code += f"""class LegacyRepresentation{operation_name}(LegacyRepresentation, tag={operation_name}.get_name(), array_like=True): + code += f"""class LegacyRepresentation{operation_name}(LegacyRepresentation[{operation_name}], tag={operation_name}.get_name(), array_like=True): value: {operation_name[:-6] if "Legacy" in operation_name else operation_name}\n\n\n""" return code diff --git a/schemas/operations/virtual/hardfork_operation.py b/schemas/operations/virtual/hardfork_operation.py index a23dd187155398028b6762d0cbd904789f741899..0e1869f8c704def58bea6ec43f439fe57d775879 100644 --- a/schemas/operations/virtual/hardfork_operation.py +++ b/schemas/operations/virtual/hardfork_operation.py @@ -5,7 +5,7 @@ from typing import Final from schemas.fields.integers import Uint32t from schemas.virtual_operation import VirtualOperation -DEFAULT_HARDFORK_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_HARDFORK_ID: Final[Uint32t] = 0 class HardforkOperation(VirtualOperation): diff --git a/schemas/operations/virtual/limit_order_cancelled_operation.py b/schemas/operations/virtual/limit_order_cancelled_operation.py index 35d60c66f7cb1c290cd5caf5eef470f1e90cdef1..e23ddb1f7ed31be85fbdd14c08a7d0e78634f046 100644 --- a/schemas/operations/virtual/limit_order_cancelled_operation.py +++ b/schemas/operations/virtual/limit_order_cancelled_operation.py @@ -9,7 +9,7 @@ from schemas.fields.integers import Uint32t from schemas.fields.resolvables import AssetUnionAssetHiveAssetHbd from schemas.virtual_operation import VirtualOperation -DEFAULT_ORDERID: Final[Uint32t] = Uint32t(0) +DEFAULT_ORDERID: Final[Uint32t] = 0 class LimitOrderCancelledOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/proposal_fee_operation.py b/schemas/operations/virtual/proposal_fee_operation.py index a768c1cbd2c1cbe25da21cbeee12eba6f0187e96..8f3b5570861b5cab14b595b19d9aa06c372b28a7 100644 --- a/schemas/operations/virtual/proposal_fee_operation.py +++ b/schemas/operations/virtual/proposal_fee_operation.py @@ -7,7 +7,7 @@ from schemas.fields.basic import AccountName from schemas.fields.integers import Uint32t from schemas.virtual_operation import VirtualOperation -DEFAULT_PROPOSAL_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_PROPOSAL_ID: Final[Uint32t] = 0 class ProposalFeeOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/proposal_pay_operation.py b/schemas/operations/virtual/proposal_pay_operation.py index c9cc67a5b294b8462411a9b69836820c1ed2dbfb..1d62b6381ae56525728d0e84ea9063d4b9c5a55f 100644 --- a/schemas/operations/virtual/proposal_pay_operation.py +++ b/schemas/operations/virtual/proposal_pay_operation.py @@ -9,7 +9,7 @@ from schemas.fields.basic import ( from schemas.fields.integers import Uint32t from schemas.virtual_operation import VirtualOperation -DEFAULT_PROPOSAL_ID: Final[Uint32t] = Uint32t(0) +DEFAULT_PROPOSAL_ID: Final[Uint32t] = 0 class ProposalPayOperation(VirtualOperation, kw_only=True): diff --git a/schemas/operations/virtual/representation_types.py b/schemas/operations/virtual/representation_types.py index 0ed397bbbb0167ab46c818d1da9488d448b64494..7a5f266d00a66b0b5587cc39f810fd67fbba33b8 100644 --- a/schemas/operations/virtual/representation_types.py +++ b/schemas/operations/virtual/representation_types.py @@ -56,345 +56,345 @@ from schemas.operations.virtual.transfer_to_vesting_completed_operation import T from schemas.operations.virtual.vesting_shares_split_operation import VestingSharesSplitOperation -class HF26RepresentationAccountCreatedOperation(HF26Representation, tag=AccountCreatedOperation.get_name_with_suffix()): +class HF26RepresentationAccountCreatedOperation(HF26Representation[AccountCreatedOperation], tag=AccountCreatedOperation.get_name_with_suffix()): value: AccountCreatedOperation -class LegacyRepresentationAccountCreatedOperation(LegacyRepresentation, tag=AccountCreatedOperation.get_name(), array_like=True): +class LegacyRepresentationAccountCreatedOperation(LegacyRepresentation[AccountCreatedOperation], tag=AccountCreatedOperation.get_name(), array_like=True): value: AccountCreatedOperation -class HF26RepresentationAuthorRewardOperation(HF26Representation, tag=AuthorRewardOperation.get_name_with_suffix()): +class HF26RepresentationAuthorRewardOperation(HF26Representation[AuthorRewardOperation], tag=AuthorRewardOperation.get_name_with_suffix()): value: AuthorRewardOperation -class LegacyRepresentationAuthorRewardOperation(LegacyRepresentation, tag=AuthorRewardOperation.get_name(), array_like=True): +class LegacyRepresentationAuthorRewardOperation(LegacyRepresentation[AuthorRewardOperation], tag=AuthorRewardOperation.get_name(), array_like=True): value: AuthorRewardOperation -class HF26RepresentationChangedRecoveryAccountOperation(HF26Representation, tag=ChangedRecoveryAccountOperation.get_name_with_suffix()): +class HF26RepresentationChangedRecoveryAccountOperation(HF26Representation[ChangedRecoveryAccountOperation], tag=ChangedRecoveryAccountOperation.get_name_with_suffix()): value: ChangedRecoveryAccountOperation -class LegacyRepresentationChangedRecoveryAccountOperation(LegacyRepresentation, tag=ChangedRecoveryAccountOperation.get_name(), array_like=True): +class LegacyRepresentationChangedRecoveryAccountOperation(LegacyRepresentation[ChangedRecoveryAccountOperation], tag=ChangedRecoveryAccountOperation.get_name(), array_like=True): value: ChangedRecoveryAccountOperation -class HF26RepresentationClearNullAccountBalanceOperation(HF26Representation, tag=ClearNullAccountBalanceOperation.get_name_with_suffix()): +class HF26RepresentationClearNullAccountBalanceOperation(HF26Representation[ClearNullAccountBalanceOperation], tag=ClearNullAccountBalanceOperation.get_name_with_suffix()): value: ClearNullAccountBalanceOperation -class LegacyRepresentationClearNullAccountBalanceOperation(LegacyRepresentation, tag=ClearNullAccountBalanceOperation.get_name(), array_like=True): +class LegacyRepresentationClearNullAccountBalanceOperation(LegacyRepresentation[ClearNullAccountBalanceOperation], tag=ClearNullAccountBalanceOperation.get_name(), array_like=True): value: ClearNullAccountBalanceOperation -class HF26RepresentationCollateralizedConvertImmediateConversionOperation(HF26Representation, tag=CollateralizedConvertImmediateConversionOperation.get_name_with_suffix()): +class HF26RepresentationCollateralizedConvertImmediateConversionOperation(HF26Representation[CollateralizedConvertImmediateConversionOperation], tag=CollateralizedConvertImmediateConversionOperation.get_name_with_suffix()): value: CollateralizedConvertImmediateConversionOperation -class LegacyRepresentationCollateralizedConvertImmediateConversionOperation(LegacyRepresentation, tag=CollateralizedConvertImmediateConversionOperation.get_name(), array_like=True): +class LegacyRepresentationCollateralizedConvertImmediateConversionOperation(LegacyRepresentation[CollateralizedConvertImmediateConversionOperation], tag=CollateralizedConvertImmediateConversionOperation.get_name(), array_like=True): value: CollateralizedConvertImmediateConversionOperation -class HF26RepresentationCommentBenefactorRewardOperation(HF26Representation, tag=CommentBenefactorRewardOperation.get_name_with_suffix()): +class HF26RepresentationCommentBenefactorRewardOperation(HF26Representation[CommentBenefactorRewardOperation], tag=CommentBenefactorRewardOperation.get_name_with_suffix()): value: CommentBenefactorRewardOperation -class LegacyRepresentationCommentBenefactorRewardOperation(LegacyRepresentation, tag=CommentBenefactorRewardOperation.get_name(), array_like=True): +class LegacyRepresentationCommentBenefactorRewardOperation(LegacyRepresentation[CommentBenefactorRewardOperation], tag=CommentBenefactorRewardOperation.get_name(), array_like=True): value: CommentBenefactorRewardOperation -class HF26RepresentationCommentPayoutUpdateOperation(HF26Representation, tag=CommentPayoutUpdateOperation.get_name_with_suffix()): +class HF26RepresentationCommentPayoutUpdateOperation(HF26Representation[CommentPayoutUpdateOperation], tag=CommentPayoutUpdateOperation.get_name_with_suffix()): value: CommentPayoutUpdateOperation -class LegacyRepresentationCommentPayoutUpdateOperation(LegacyRepresentation, tag=CommentPayoutUpdateOperation.get_name(), array_like=True): +class LegacyRepresentationCommentPayoutUpdateOperation(LegacyRepresentation[CommentPayoutUpdateOperation], tag=CommentPayoutUpdateOperation.get_name(), array_like=True): value: CommentPayoutUpdateOperation -class HF26RepresentationCommentRewardOperation(HF26Representation, tag=CommentRewardOperation.get_name_with_suffix()): +class HF26RepresentationCommentRewardOperation(HF26Representation[CommentRewardOperation], tag=CommentRewardOperation.get_name_with_suffix()): value: CommentRewardOperation -class LegacyRepresentationCommentRewardOperation(LegacyRepresentation, tag=CommentRewardOperation.get_name(), array_like=True): +class LegacyRepresentationCommentRewardOperation(LegacyRepresentation[CommentRewardOperation], tag=CommentRewardOperation.get_name(), array_like=True): value: CommentRewardOperation -class HF26RepresentationConsolidateTreasuryBalanceOperation(HF26Representation, tag=ConsolidateTreasuryBalanceOperation.get_name_with_suffix()): +class HF26RepresentationConsolidateTreasuryBalanceOperation(HF26Representation[ConsolidateTreasuryBalanceOperation], tag=ConsolidateTreasuryBalanceOperation.get_name_with_suffix()): value: ConsolidateTreasuryBalanceOperation -class LegacyRepresentationConsolidateTreasuryBalanceOperation(LegacyRepresentation, tag=ConsolidateTreasuryBalanceOperation.get_name(), array_like=True): +class LegacyRepresentationConsolidateTreasuryBalanceOperation(LegacyRepresentation[ConsolidateTreasuryBalanceOperation], tag=ConsolidateTreasuryBalanceOperation.get_name(), array_like=True): value: ConsolidateTreasuryBalanceOperation -class HF26RepresentationCurationRewardOperation(HF26Representation, tag=CurationRewardOperation.get_name_with_suffix()): +class HF26RepresentationCurationRewardOperation(HF26Representation[CurationRewardOperation], tag=CurationRewardOperation.get_name_with_suffix()): value: CurationRewardOperation -class LegacyRepresentationCurationRewardOperation(LegacyRepresentation, tag=CurationRewardOperation.get_name(), array_like=True): +class LegacyRepresentationCurationRewardOperation(LegacyRepresentation[CurationRewardOperation], tag=CurationRewardOperation.get_name(), array_like=True): value: CurationRewardOperation -class HF26RepresentationDeclinedVotingRightsOperation(HF26Representation, tag=DeclinedVotingRightsOperation.get_name_with_suffix()): +class HF26RepresentationDeclinedVotingRightsOperation(HF26Representation[DeclinedVotingRightsOperation], tag=DeclinedVotingRightsOperation.get_name_with_suffix()): value: DeclinedVotingRightsOperation -class LegacyRepresentationDeclinedVotingRightsOperation(LegacyRepresentation, tag=DeclinedVotingRightsOperation.get_name(), array_like=True): +class LegacyRepresentationDeclinedVotingRightsOperation(LegacyRepresentation[DeclinedVotingRightsOperation], tag=DeclinedVotingRightsOperation.get_name(), array_like=True): value: DeclinedVotingRightsOperation -class HF26RepresentationDelayedVotingOperation(HF26Representation, tag=DelayedVotingOperation.get_name_with_suffix()): +class HF26RepresentationDelayedVotingOperation(HF26Representation[DelayedVotingOperation], tag=DelayedVotingOperation.get_name_with_suffix()): value: DelayedVotingOperation -class LegacyRepresentationDelayedVotingOperation(LegacyRepresentation, tag=DelayedVotingOperation.get_name(), array_like=True): +class LegacyRepresentationDelayedVotingOperation(LegacyRepresentation[DelayedVotingOperation], tag=DelayedVotingOperation.get_name(), array_like=True): value: DelayedVotingOperation -class HF26RepresentationDhfConversionOperation(HF26Representation, tag=DhfConversionOperation.get_name_with_suffix()): +class HF26RepresentationDhfConversionOperation(HF26Representation[DhfConversionOperation], tag=DhfConversionOperation.get_name_with_suffix()): value: DhfConversionOperation -class LegacyRepresentationDhfConversionOperation(LegacyRepresentation, tag=DhfConversionOperation.get_name(), array_like=True): +class LegacyRepresentationDhfConversionOperation(LegacyRepresentation[DhfConversionOperation], tag=DhfConversionOperation.get_name(), array_like=True): value: DhfConversionOperation -class HF26RepresentationDhfFundingOperation(HF26Representation, tag=DhfFundingOperation.get_name_with_suffix()): +class HF26RepresentationDhfFundingOperation(HF26Representation[DhfFundingOperation], tag=DhfFundingOperation.get_name_with_suffix()): value: DhfFundingOperation -class LegacyRepresentationDhfFundingOperation(LegacyRepresentation, tag=DhfFundingOperation.get_name(), array_like=True): +class LegacyRepresentationDhfFundingOperation(LegacyRepresentation[DhfFundingOperation], tag=DhfFundingOperation.get_name(), array_like=True): value: DhfFundingOperation -class HF26RepresentationEffectiveCommentVoteOperation(HF26Representation, tag=EffectiveCommentVoteOperation.get_name_with_suffix()): +class HF26RepresentationEffectiveCommentVoteOperation(HF26Representation[EffectiveCommentVoteOperation], tag=EffectiveCommentVoteOperation.get_name_with_suffix()): value: EffectiveCommentVoteOperation -class LegacyRepresentationEffectiveCommentVoteOperation(LegacyRepresentation, tag=EffectiveCommentVoteOperation.get_name(), array_like=True): +class LegacyRepresentationEffectiveCommentVoteOperation(LegacyRepresentation[EffectiveCommentVoteOperation], tag=EffectiveCommentVoteOperation.get_name(), array_like=True): value: EffectiveCommentVoteOperation -class HF26RepresentationEscrowApprovedOperation(HF26Representation, tag=EscrowApprovedOperation.get_name_with_suffix()): +class HF26RepresentationEscrowApprovedOperation(HF26Representation[EscrowApprovedOperation], tag=EscrowApprovedOperation.get_name_with_suffix()): value: EscrowApprovedOperation -class LegacyRepresentationEscrowApprovedOperation(LegacyRepresentation, tag=EscrowApprovedOperation.get_name(), array_like=True): +class LegacyRepresentationEscrowApprovedOperation(LegacyRepresentation[EscrowApprovedOperation], tag=EscrowApprovedOperation.get_name(), array_like=True): value: EscrowApprovedOperation -class HF26RepresentationEscrowRejectedOperation(HF26Representation, tag=EscrowRejectedOperation.get_name_with_suffix()): +class HF26RepresentationEscrowRejectedOperation(HF26Representation[EscrowRejectedOperation], tag=EscrowRejectedOperation.get_name_with_suffix()): value: EscrowRejectedOperation -class LegacyRepresentationEscrowRejectedOperation(LegacyRepresentation, tag=EscrowRejectedOperation.get_name(), array_like=True): +class LegacyRepresentationEscrowRejectedOperation(LegacyRepresentation[EscrowRejectedOperation], tag=EscrowRejectedOperation.get_name(), array_like=True): value: EscrowRejectedOperation -class HF26RepresentationExpiredAccountNotificationOperation(HF26Representation, tag=ExpiredAccountNotificationOperation.get_name_with_suffix()): +class HF26RepresentationExpiredAccountNotificationOperation(HF26Representation[ExpiredAccountNotificationOperation], tag=ExpiredAccountNotificationOperation.get_name_with_suffix()): value: ExpiredAccountNotificationOperation -class LegacyRepresentationExpiredAccountNotificationOperation(LegacyRepresentation, tag=ExpiredAccountNotificationOperation.get_name(), array_like=True): +class LegacyRepresentationExpiredAccountNotificationOperation(LegacyRepresentation[ExpiredAccountNotificationOperation], tag=ExpiredAccountNotificationOperation.get_name(), array_like=True): value: ExpiredAccountNotificationOperation -class HF26RepresentationFailedRecurrentTransferOperation(HF26Representation, tag=FailedRecurrentTransferOperation.get_name_with_suffix()): +class HF26RepresentationFailedRecurrentTransferOperation(HF26Representation[FailedRecurrentTransferOperation], tag=FailedRecurrentTransferOperation.get_name_with_suffix()): value: FailedRecurrentTransferOperation -class LegacyRepresentationFailedRecurrentTransferOperation(LegacyRepresentation, tag=FailedRecurrentTransferOperation.get_name(), array_like=True): +class LegacyRepresentationFailedRecurrentTransferOperation(LegacyRepresentation[FailedRecurrentTransferOperation], tag=FailedRecurrentTransferOperation.get_name(), array_like=True): value: FailedRecurrentTransferOperation -class HF26RepresentationFillCollateralizedConvertRequestOperation(HF26Representation, tag=FillCollateralizedConvertRequestOperation.get_name_with_suffix()): +class HF26RepresentationFillCollateralizedConvertRequestOperation(HF26Representation[FillCollateralizedConvertRequestOperation], tag=FillCollateralizedConvertRequestOperation.get_name_with_suffix()): value: FillCollateralizedConvertRequestOperation -class LegacyRepresentationFillCollateralizedConvertRequestOperation(LegacyRepresentation, tag=FillCollateralizedConvertRequestOperation.get_name(), array_like=True): +class LegacyRepresentationFillCollateralizedConvertRequestOperation(LegacyRepresentation[FillCollateralizedConvertRequestOperation], tag=FillCollateralizedConvertRequestOperation.get_name(), array_like=True): value: FillCollateralizedConvertRequestOperation -class HF26RepresentationFillConvertRequestOperation(HF26Representation, tag=FillConvertRequestOperation.get_name_with_suffix()): +class HF26RepresentationFillConvertRequestOperation(HF26Representation[FillConvertRequestOperation], tag=FillConvertRequestOperation.get_name_with_suffix()): value: FillConvertRequestOperation -class LegacyRepresentationFillConvertRequestOperation(LegacyRepresentation, tag=FillConvertRequestOperation.get_name(), array_like=True): +class LegacyRepresentationFillConvertRequestOperation(LegacyRepresentation[FillConvertRequestOperation], tag=FillConvertRequestOperation.get_name(), array_like=True): value: FillConvertRequestOperation -class HF26RepresentationFillOrderOperation(HF26Representation, tag=FillOrderOperation.get_name_with_suffix()): +class HF26RepresentationFillOrderOperation(HF26Representation[FillOrderOperation], tag=FillOrderOperation.get_name_with_suffix()): value: FillOrderOperation -class LegacyRepresentationFillOrderOperation(LegacyRepresentation, tag=FillOrderOperation.get_name(), array_like=True): +class LegacyRepresentationFillOrderOperation(LegacyRepresentation[FillOrderOperation], tag=FillOrderOperation.get_name(), array_like=True): value: FillOrderOperation -class HF26RepresentationFillRecurrentTransferOperation(HF26Representation, tag=FillRecurrentTransferOperation.get_name_with_suffix()): +class HF26RepresentationFillRecurrentTransferOperation(HF26Representation[FillRecurrentTransferOperation], tag=FillRecurrentTransferOperation.get_name_with_suffix()): value: FillRecurrentTransferOperation -class LegacyRepresentationFillRecurrentTransferOperation(LegacyRepresentation, tag=FillRecurrentTransferOperation.get_name(), array_like=True): +class LegacyRepresentationFillRecurrentTransferOperation(LegacyRepresentation[FillRecurrentTransferOperation], tag=FillRecurrentTransferOperation.get_name(), array_like=True): value: FillRecurrentTransferOperation -class HF26RepresentationFillTransferFromSavingsOperation(HF26Representation, tag=FillTransferFromSavingsOperation.get_name_with_suffix()): +class HF26RepresentationFillTransferFromSavingsOperation(HF26Representation[FillTransferFromSavingsOperation], tag=FillTransferFromSavingsOperation.get_name_with_suffix()): value: FillTransferFromSavingsOperation -class LegacyRepresentationFillTransferFromSavingsOperation(LegacyRepresentation, tag=FillTransferFromSavingsOperation.get_name(), array_like=True): +class LegacyRepresentationFillTransferFromSavingsOperation(LegacyRepresentation[FillTransferFromSavingsOperation], tag=FillTransferFromSavingsOperation.get_name(), array_like=True): value: FillTransferFromSavingsOperation -class HF26RepresentationFillVestingWithdrawOperation(HF26Representation, tag=FillVestingWithdrawOperation.get_name_with_suffix()): +class HF26RepresentationFillVestingWithdrawOperation(HF26Representation[FillVestingWithdrawOperation], tag=FillVestingWithdrawOperation.get_name_with_suffix()): value: FillVestingWithdrawOperation -class LegacyRepresentationFillVestingWithdrawOperation(LegacyRepresentation, tag=FillVestingWithdrawOperation.get_name(), array_like=True): +class LegacyRepresentationFillVestingWithdrawOperation(LegacyRepresentation[FillVestingWithdrawOperation], tag=FillVestingWithdrawOperation.get_name(), array_like=True): value: FillVestingWithdrawOperation -class HF26RepresentationHardforkHiveOperation(HF26Representation, tag=HardforkHiveOperation.get_name_with_suffix()): +class HF26RepresentationHardforkHiveOperation(HF26Representation[HardforkHiveOperation], tag=HardforkHiveOperation.get_name_with_suffix()): value: HardforkHiveOperation -class LegacyRepresentationHardforkHiveOperation(LegacyRepresentation, tag=HardforkHiveOperation.get_name(), array_like=True): +class LegacyRepresentationHardforkHiveOperation(LegacyRepresentation[HardforkHiveOperation], tag=HardforkHiveOperation.get_name(), array_like=True): value: HardforkHiveOperation -class HF26RepresentationHardforkHiveRestoreOperation(HF26Representation, tag=HardforkHiveRestoreOperation.get_name_with_suffix()): +class HF26RepresentationHardforkHiveRestoreOperation(HF26Representation[HardforkHiveRestoreOperation], tag=HardforkHiveRestoreOperation.get_name_with_suffix()): value: HardforkHiveRestoreOperation -class LegacyRepresentationHardforkHiveRestoreOperation(LegacyRepresentation, tag=HardforkHiveRestoreOperation.get_name(), array_like=True): +class LegacyRepresentationHardforkHiveRestoreOperation(LegacyRepresentation[HardforkHiveRestoreOperation], tag=HardforkHiveRestoreOperation.get_name(), array_like=True): value: HardforkHiveRestoreOperation -class HF26RepresentationHardforkOperation(HF26Representation, tag=HardforkOperation.get_name_with_suffix()): +class HF26RepresentationHardforkOperation(HF26Representation[HardforkOperation], tag=HardforkOperation.get_name_with_suffix()): value: HardforkOperation -class LegacyRepresentationHardforkOperation(LegacyRepresentation, tag=HardforkOperation.get_name(), array_like=True): +class LegacyRepresentationHardforkOperation(LegacyRepresentation[HardforkOperation], tag=HardforkOperation.get_name(), array_like=True): value: HardforkOperation -class HF26RepresentationIneffectiveDeleteCommentOperation(HF26Representation, tag=IneffectiveDeleteCommentOperation.get_name_with_suffix()): +class HF26RepresentationIneffectiveDeleteCommentOperation(HF26Representation[IneffectiveDeleteCommentOperation], tag=IneffectiveDeleteCommentOperation.get_name_with_suffix()): value: IneffectiveDeleteCommentOperation -class LegacyRepresentationIneffectiveDeleteCommentOperation(LegacyRepresentation, tag=IneffectiveDeleteCommentOperation.get_name(), array_like=True): +class LegacyRepresentationIneffectiveDeleteCommentOperation(LegacyRepresentation[IneffectiveDeleteCommentOperation], tag=IneffectiveDeleteCommentOperation.get_name(), array_like=True): value: IneffectiveDeleteCommentOperation -class HF26RepresentationInterestOperation(HF26Representation, tag=InterestOperation.get_name_with_suffix()): +class HF26RepresentationInterestOperation(HF26Representation[InterestOperation], tag=InterestOperation.get_name_with_suffix()): value: InterestOperation -class LegacyRepresentationInterestOperation(LegacyRepresentation, tag=InterestOperation.get_name(), array_like=True): +class LegacyRepresentationInterestOperation(LegacyRepresentation[InterestOperation], tag=InterestOperation.get_name(), array_like=True): value: InterestOperation -class HF26RepresentationLimitOrderCancelledOperation(HF26Representation, tag=LimitOrderCancelledOperation.get_name_with_suffix()): +class HF26RepresentationLimitOrderCancelledOperation(HF26Representation[LimitOrderCancelledOperation], tag=LimitOrderCancelledOperation.get_name_with_suffix()): value: LimitOrderCancelledOperation -class LegacyRepresentationLimitOrderCancelledOperation(LegacyRepresentation, tag=LimitOrderCancelledOperation.get_name(), array_like=True): +class LegacyRepresentationLimitOrderCancelledOperation(LegacyRepresentation[LimitOrderCancelledOperation], tag=LimitOrderCancelledOperation.get_name(), array_like=True): value: LimitOrderCancelledOperation -class HF26RepresentationLiquidityRewardOperation(HF26Representation, tag=LiquidityRewardOperation.get_name_with_suffix()): +class HF26RepresentationLiquidityRewardOperation(HF26Representation[LiquidityRewardOperation], tag=LiquidityRewardOperation.get_name_with_suffix()): value: LiquidityRewardOperation -class LegacyRepresentationLiquidityRewardOperation(LegacyRepresentation, tag=LiquidityRewardOperation.get_name(), array_like=True): +class LegacyRepresentationLiquidityRewardOperation(LegacyRepresentation[LiquidityRewardOperation], tag=LiquidityRewardOperation.get_name(), array_like=True): value: LiquidityRewardOperation -class HF26RepresentationPowRewardOperation(HF26Representation, tag=PowRewardOperation.get_name_with_suffix()): +class HF26RepresentationPowRewardOperation(HF26Representation[PowRewardOperation], tag=PowRewardOperation.get_name_with_suffix()): value: PowRewardOperation -class LegacyRepresentationPowRewardOperation(LegacyRepresentation, tag=PowRewardOperation.get_name(), array_like=True): +class LegacyRepresentationPowRewardOperation(LegacyRepresentation[PowRewardOperation], tag=PowRewardOperation.get_name(), array_like=True): value: PowRewardOperation -class HF26RepresentationProducerMissedOperation(HF26Representation, tag=ProducerMissedOperation.get_name_with_suffix()): +class HF26RepresentationProducerMissedOperation(HF26Representation[ProducerMissedOperation], tag=ProducerMissedOperation.get_name_with_suffix()): value: ProducerMissedOperation -class LegacyRepresentationProducerMissedOperation(LegacyRepresentation, tag=ProducerMissedOperation.get_name(), array_like=True): +class LegacyRepresentationProducerMissedOperation(LegacyRepresentation[ProducerMissedOperation], tag=ProducerMissedOperation.get_name(), array_like=True): value: ProducerMissedOperation -class HF26RepresentationProducerRewardOperation(HF26Representation, tag=ProducerRewardOperation.get_name_with_suffix()): +class HF26RepresentationProducerRewardOperation(HF26Representation[ProducerRewardOperation], tag=ProducerRewardOperation.get_name_with_suffix()): value: ProducerRewardOperation -class LegacyRepresentationProducerRewardOperation(LegacyRepresentation, tag=ProducerRewardOperation.get_name(), array_like=True): +class LegacyRepresentationProducerRewardOperation(LegacyRepresentation[ProducerRewardOperation], tag=ProducerRewardOperation.get_name(), array_like=True): value: ProducerRewardOperation -class HF26RepresentationProposalFeeOperation(HF26Representation, tag=ProposalFeeOperation.get_name_with_suffix()): +class HF26RepresentationProposalFeeOperation(HF26Representation[ProposalFeeOperation], tag=ProposalFeeOperation.get_name_with_suffix()): value: ProposalFeeOperation -class LegacyRepresentationProposalFeeOperation(LegacyRepresentation, tag=ProposalFeeOperation.get_name(), array_like=True): +class LegacyRepresentationProposalFeeOperation(LegacyRepresentation[ProposalFeeOperation], tag=ProposalFeeOperation.get_name(), array_like=True): value: ProposalFeeOperation -class HF26RepresentationProposalPayOperation(HF26Representation, tag=ProposalPayOperation.get_name_with_suffix()): +class HF26RepresentationProposalPayOperation(HF26Representation[ProposalPayOperation], tag=ProposalPayOperation.get_name_with_suffix()): value: ProposalPayOperation -class LegacyRepresentationProposalPayOperation(LegacyRepresentation, tag=ProposalPayOperation.get_name(), array_like=True): +class LegacyRepresentationProposalPayOperation(LegacyRepresentation[ProposalPayOperation], tag=ProposalPayOperation.get_name(), array_like=True): value: ProposalPayOperation -class HF26RepresentationProxyClearedOperation(HF26Representation, tag=ProxyClearedOperation.get_name_with_suffix()): +class HF26RepresentationProxyClearedOperation(HF26Representation[ProxyClearedOperation], tag=ProxyClearedOperation.get_name_with_suffix()): value: ProxyClearedOperation -class LegacyRepresentationProxyClearedOperation(LegacyRepresentation, tag=ProxyClearedOperation.get_name(), array_like=True): +class LegacyRepresentationProxyClearedOperation(LegacyRepresentation[ProxyClearedOperation], tag=ProxyClearedOperation.get_name(), array_like=True): value: ProxyClearedOperation -class HF26RepresentationReturnVestingDelegationOperation(HF26Representation, tag=ReturnVestingDelegationOperation.get_name_with_suffix()): +class HF26RepresentationReturnVestingDelegationOperation(HF26Representation[ReturnVestingDelegationOperation], tag=ReturnVestingDelegationOperation.get_name_with_suffix()): value: ReturnVestingDelegationOperation -class LegacyRepresentationReturnVestingDelegationOperation(LegacyRepresentation, tag=ReturnVestingDelegationOperation.get_name(), array_like=True): +class LegacyRepresentationReturnVestingDelegationOperation(LegacyRepresentation[ReturnVestingDelegationOperation], tag=ReturnVestingDelegationOperation.get_name(), array_like=True): value: ReturnVestingDelegationOperation -class HF26RepresentationShutDownWitnessOperation(HF26Representation, tag=ShutDownWitnessOperation.get_name_with_suffix()): +class HF26RepresentationShutDownWitnessOperation(HF26Representation[ShutDownWitnessOperation], tag=ShutDownWitnessOperation.get_name_with_suffix()): value: ShutDownWitnessOperation -class LegacyRepresentationShutDownWitnessOperation(LegacyRepresentation, tag=ShutDownWitnessOperation.get_name(), array_like=True): +class LegacyRepresentationShutDownWitnessOperation(LegacyRepresentation[ShutDownWitnessOperation], tag=ShutDownWitnessOperation.get_name(), array_like=True): value: ShutDownWitnessOperation -class HF26RepresentationSystemWarningOperation(HF26Representation, tag=SystemWarningOperation.get_name_with_suffix()): +class HF26RepresentationSystemWarningOperation(HF26Representation[SystemWarningOperation], tag=SystemWarningOperation.get_name_with_suffix()): value: SystemWarningOperation -class LegacyRepresentationSystemWarningOperation(LegacyRepresentation, tag=SystemWarningOperation.get_name(), array_like=True): +class LegacyRepresentationSystemWarningOperation(LegacyRepresentation[SystemWarningOperation], tag=SystemWarningOperation.get_name(), array_like=True): value: SystemWarningOperation -class HF26RepresentationTransferToVestingCompletedOperation(HF26Representation, tag=TransferToVestingCompletedOperation.get_name_with_suffix()): +class HF26RepresentationTransferToVestingCompletedOperation(HF26Representation[TransferToVestingCompletedOperation], tag=TransferToVestingCompletedOperation.get_name_with_suffix()): value: TransferToVestingCompletedOperation -class LegacyRepresentationTransferToVestingCompletedOperation(LegacyRepresentation, tag=TransferToVestingCompletedOperation.get_name(), array_like=True): +class LegacyRepresentationTransferToVestingCompletedOperation(LegacyRepresentation[TransferToVestingCompletedOperation], tag=TransferToVestingCompletedOperation.get_name(), array_like=True): value: TransferToVestingCompletedOperation -class HF26RepresentationVestingSharesSplitOperation(HF26Representation, tag=VestingSharesSplitOperation.get_name_with_suffix()): +class HF26RepresentationVestingSharesSplitOperation(HF26Representation[VestingSharesSplitOperation], tag=VestingSharesSplitOperation.get_name_with_suffix()): value: VestingSharesSplitOperation -class LegacyRepresentationVestingSharesSplitOperation(LegacyRepresentation, tag=VestingSharesSplitOperation.get_name(), array_like=True): +class LegacyRepresentationVestingSharesSplitOperation(LegacyRepresentation[VestingSharesSplitOperation], tag=VestingSharesSplitOperation.get_name(), array_like=True): value: VestingSharesSplitOperation diff --git a/schemas/operations/vote_operation.py b/schemas/operations/vote_operation.py index ab4aa9cd9854170ca5a7837089587d7dc7ff6508..1baa28495403560a04df58e8f290bb30286302b9 100644 --- a/schemas/operations/vote_operation.py +++ b/schemas/operations/vote_operation.py @@ -6,7 +6,7 @@ from schemas.fields.basic import AccountName from schemas.fields.integers import Int16t from schemas.operation import Operation -DEFAULT_WEIGHT: Final[Int16t] = Int16t(0) +DEFAULT_WEIGHT: Final[Int16t] = 0 class VoteOperation(Operation): diff --git a/schemas/optional_response.py b/schemas/optional_response.py deleted file mode 100644 index f74d6e034230e38baaee5facbfc1d5d3ef53285d..0000000000000000000000000000000000000000 --- a/schemas/optional_response.py +++ /dev/null @@ -1,15 +0,0 @@ -from __future__ import annotations - -from typing import TYPE_CHECKING - -if TYPE_CHECKING: - from typing_extensions import Self - - -class OptionalResponse: - def is_set(self) -> bool: - raise NotImplementedError("This method should be implemented in subclasses") - - @property - def ensure(self) -> Self: - raise NotImplementedError("This method should be implemented in subclasses") diff --git a/schemas/policies/__init__.py b/schemas/policies/__init__.py index 2aae364c4d4a25338bf59760662cd5beb6fce0d9..61f42f67378d4463dfe7ad15851c5f66adb385f4 100644 --- a/schemas/policies/__init__.py +++ b/schemas/policies/__init__.py @@ -1,16 +1,17 @@ from __future__ import annotations -from schemas.policies.disable_swap_types import DisableSwapTypes -from schemas.policies.missing_fields_in_get_config import MissingFieldsInGetConfig +from schemas.policies.disable_swap_types import DisableSwapTypesPolicy +from schemas.policies.extra_fields import ExtraFieldsPolicy +from schemas.policies.missing_fields_in_get_config import MissingFieldsInGetConfigPolicy from schemas.policies.policy import Policy, set_policies -from schemas.policies.testnet_assets import TestnetAssets +from schemas.policies.testnet_assets import TestnetAssetsPolicy __all__ = [ "set_policies", "Policy", # PREDEFINED POLICIES - "MissingFieldsInGetConfig", - "TestnetAssets", - "Extra", - "DisableSwapTypes", + "MissingFieldsInGetConfigPolicy", + "TestnetAssetsPolicy", + "DisableSwapTypesPolicy", + "ExtraFieldsPolicy", ] diff --git a/schemas/policies/disable_swap_types.py b/schemas/policies/disable_swap_types.py index 1c4a0695d71b58679b7cc6f3ed762b3ce2ae6c48..6ab132c6947cc6962874b037c414c3c193b493bd 100644 --- a/schemas/policies/disable_swap_types.py +++ b/schemas/policies/disable_swap_types.py @@ -7,13 +7,13 @@ from schemas.policies.policy import Policy @dataclass -class DisableSwapTypes(Policy): +class DisableSwapTypesPolicy(Policy): is_swap_types_disabled: ClassVar[bool] = False disabled: bool = False def apply(self) -> None: - DisableSwapTypes.is_swap_types_disabled = self.disabled + DisableSwapTypesPolicy.is_swap_types_disabled = self.disabled @classmethod def is_disabled(cls) -> bool: - return DisableSwapTypes.is_swap_types_disabled + return DisableSwapTypesPolicy.is_swap_types_disabled diff --git a/schemas/policies/extra_fields.py b/schemas/policies/extra_fields.py new file mode 100644 index 0000000000000000000000000000000000000000..b00ffa49857a0a1df437721e729df6304df7acec --- /dev/null +++ b/schemas/policies/extra_fields.py @@ -0,0 +1,19 @@ +from __future__ import annotations + +from dataclasses import dataclass +from typing import ClassVar + +from schemas.policies.policy import Policy + + +@dataclass +class ExtraFieldsPolicy(Policy): + is_extra_fields_enabled: ClassVar[bool] = False + allow: bool = False + + def apply(self) -> None: + ExtraFieldsPolicy.is_extra_fields_enabled = self.allow + + @classmethod + def is_allowed(cls) -> bool: + return ExtraFieldsPolicy.is_extra_fields_enabled diff --git a/schemas/policies/missing_fields_in_get_config.py b/schemas/policies/missing_fields_in_get_config.py index c171fcaff4db5240509e7f98fc57510d0c1da2fe..dc4e14d4857b3401038c3cb708db9fa42675ad0b 100644 --- a/schemas/policies/missing_fields_in_get_config.py +++ b/schemas/policies/missing_fields_in_get_config.py @@ -6,7 +6,7 @@ from schemas.policies.policy import Policy @dataclass -class MissingFieldsInGetConfig(Policy): +class MissingFieldsInGetConfigPolicy(Policy): allow: bool def apply(self) -> None: diff --git a/schemas/policies/testnet_assets.py b/schemas/policies/testnet_assets.py index a94f1afa479af6076e37bbdd2e4292ee684e3f26..40a9431c7dfa2d1e43a76342db7490bd9b98a9d1 100644 --- a/schemas/policies/testnet_assets.py +++ b/schemas/policies/testnet_assets.py @@ -2,13 +2,14 @@ from __future__ import annotations from dataclasses import dataclass -from schemas.fields.assets.asset_info import AssetInfo from schemas.policies.policy import Policy @dataclass -class TestnetAssets(Policy): +class TestnetAssetsPolicy(Policy): use_testnet_assets: bool def apply(self) -> None: + from schemas.fields.assets.asset_info import AssetInfo + AssetInfo.AssetConfig.testnet_asset = self.use_testnet_assets diff --git a/schemas/transaction.py b/schemas/transaction.py index 742a58ab6df4e9b0b52ecf33f861202ae726cfe3..0679ddc40c344f3319121243e98549e8c7940bc5 100644 --- a/schemas/transaction.py +++ b/schemas/transaction.py @@ -9,6 +9,7 @@ from schemas._preconfigured_base_model import PreconfiguredBaseModel from schemas.fields.hex import Signature, TransactionId from schemas.fields.hive_datetime import HiveDateTime from schemas.fields.hive_int import HiveInt +from schemas.fields.integers import Uint16t, Uint32t from schemas.operations import ( Hf26OperationRepresentation, Hf26Operations, @@ -30,8 +31,8 @@ __all__ = [ class TransactionCommon(PreconfiguredBaseModel): - ref_block_num: HiveInt - ref_block_prefix: HiveInt + ref_block_num: Uint16t + ref_block_prefix: Uint32t expiration: HiveDateTime extensions: list[Any] signatures: list[Signature] @@ -64,7 +65,7 @@ class TransactionUserFriendly(Transaction): custom_decoder_factory = get_hf26_decoder parsed = Transaction.parse_raw(raw, custom_decoder_factory=custom_decoder_factory) - shallowed = parsed.shallow_dict() + shallowed = parsed.dict() shallowed.pop("operations") return cls(operations=[repr_op.value for repr_op in parsed.operations], **shallowed) @@ -85,7 +86,7 @@ class TransactionLegacyUserFriendly(TransactionLegacy): custom_decoder_factory = get_hf26_decoder parsed = TransactionLegacy.parse_raw(raw, custom_decoder_factory=custom_decoder_factory) - shallowed = parsed.shallow_dict() + shallowed = parsed.dict() shallowed.pop("operations") return cls(operations=[repr_op.value for repr_op in parsed.operations], **shallowed) diff --git a/schemas/virtual_operation.py b/schemas/virtual_operation.py index 64da2cf423ed20733691dc9a679a085795ac8972..6be6f06962d58d451c7439dfbdf68ff1f2e97a19 100644 --- a/schemas/virtual_operation.py +++ b/schemas/virtual_operation.py @@ -1,13 +1,13 @@ from __future__ import annotations -from schemas.operation import Operation +from schemas.operation import OperationBase __all__ = [ "VirtualOperation", ] -class VirtualOperation(Operation): +class VirtualOperation(OperationBase): """Base class for all virtual operations""" @classmethod diff --git a/tests/test_database_api/test_database_api_responses_schemas.py b/tests/test_database_api/test_database_api_responses_schemas.py index 3a87747eb9ea69cbfe48c58956dc8d405251f51d..ab8dc3f10d1b08e56aeb5a17adb7138e34b23cc9 100644 --- a/tests/test_database_api/test_database_api_responses_schemas.py +++ b/tests/test_database_api/test_database_api_responses_schemas.py @@ -5,7 +5,7 @@ from typing import Any import pytest from schemas.apis import database_api -from schemas.policies.missing_fields_in_get_config import MissingFieldsInGetConfig +from schemas.policies.missing_fields_in_get_config import MissingFieldsInGetConfigPolicy from tests.conftest import verify_serialization_and_deserialization from . import responses_from_api @@ -74,12 +74,12 @@ def test_schemas_of_database_api_responses(parameters: dict[str, Any], schema: A def test_get_config_policy() -> None: try: - MissingFieldsInGetConfig(allow=True).apply() + MissingFieldsInGetConfigPolicy(allow=True).apply() from schemas.apis import database_api database_api.GetConfig() # type: ignore[call-arg] finally: - MissingFieldsInGetConfig(allow=False).apply() # this is in finally so it won't interfere other tests + MissingFieldsInGetConfigPolicy(allow=False).apply() # this is in finally so it won't interfere other tests with pytest.raises(TypeError): database_api.GetConfig() # type: ignore[call-arg] diff --git a/tests/unit/test_humanize.py b/tests/unit/test_humanize.py new file mode 100644 index 0000000000000000000000000000000000000000..e2f5cabce380f871f7f8d56c7f4d890c5c80c106 --- /dev/null +++ b/tests/unit/test_humanize.py @@ -0,0 +1,30 @@ +from __future__ import annotations + +import pytest + +from schemas._preconfigured_base_model import PreconfiguredBaseModel + + +class HumanizeTestCase(PreconfiguredBaseModel): + field_a: str + field_b: int | None + field_c: int | None = None + field_d: int = 1 + + +@pytest.mark.parametrize( + ("a", "b", "c", "expected_humanize_output"), + ( + ("abc1", 2, 3, """field_a="abc1" field_b=2 field_c=3 field_d=1"""), + ("abc4", None, 6, """field_a="abc4" field_c=6 field_d=1"""), + ("abc7", 8, None, """field_a="abc7" field_b=8 field_d=1"""), + ("abc0", 0, 0, """field_a="abc0" field_b=0 field_c=0 field_d=1"""), + ("abc10", None, None, """field_a="abc10" field_d=1"""), + ), +) +def test_humanize(a: str, b: int | None, c: int | None, expected_humanize_output: str) -> None: + """ + This function returns a human-readable string representation of the Test model. + """ + test_instance = HumanizeTestCase(field_a=a, field_b=b, field_c=c) + assert test_instance.humanize() == expected_humanize_output diff --git a/tests/unit/test_swap_types.py b/tests/unit/test_swap_types.py index 98cdaf7491f563cf09d84339c8d8e9c5ddebf902..7534501e59b3d75c24f2b5a5bfd97a816e67b986 100644 --- a/tests/unit/test_swap_types.py +++ b/tests/unit/test_swap_types.py @@ -1,5 +1,6 @@ from __future__ import annotations +from datetime import datetime from typing import TYPE_CHECKING, Any import msgspec @@ -20,6 +21,7 @@ from schemas.fields.basic import ( WitnessUrl, ) from schemas.fields.hex import Hex, Sha256, Signature, TransactionId +from schemas.fields.hive_datetime import HiveDateTime from schemas.fields.hive_int import HiveInt from schemas.fields.integers import Int16t, Int64t, Uint8t, Uint16t, Uint32t, Uint64t from schemas.fields.resolvables import JsonString @@ -38,6 +40,7 @@ from schemas.fields.resolvables import JsonString (Signature, Signature, "A" * 130), (TransactionId, TransactionId, "B" * 40), (HiveInt, HiveInt, 12), + (HiveDateTime, HiveDateTime, datetime.now()), (HiveInt, HiveInt, "12"), (AssetNaiAmount, AssetNaiAmount, 12), (AssetNaiAmount, AssetNaiAmount, "12"), @@ -66,13 +69,24 @@ def test_swap_types(type_in_class: type[Any], type_to_check: type[Any], value_in class TestClass(PreconfiguredBaseModel): value: Any + class TestClassWithDefault(PreconfiguredBaseModel): + value: Any = value_in_class_init + else: TestClass = msgspec.defstruct( # noqa: N806 "TestStruct", bases=(PreconfiguredBaseModel,), fields=[("value", type_in_class)] ) + TestClassWithDefault = msgspec.defstruct( # noqa: N806 + "TestClassWithDefault", + bases=(PreconfiguredBaseModel,), + fields=[("value", type_in_class, msgspec.field(default_factory=lambda: value_in_class_init))], + ) + # ACT instance = TestClass(value=value_in_class_init) + instance_with_default = TestClassWithDefault() # ASSERT assert isinstance(instance.value, type_to_check) + assert isinstance(instance_with_default.value, type_to_check)