Michelson types

Base class

class pytezos.michelson.types.base.MichelsonType

aggregate_lazy_diff(lazy_diff: List[dict], mode='readable') → pytezos.michelson.types.base.MichelsonType

args: List[Union[Type[MichelsonType], Any]] = []

classmethod as_micheline_expr() → dict

attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)

classmethod create_type(args: List[Type[pytezos.michelson.micheline.Micheline]], annots: Optional[list] = None, **kwargs) → Type[pytezos.michelson.types.base.MichelsonType]

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.base.MichelsonType

duplicate()

field_name: Optional[str] = None

forge(mode='readable') → bytes

classmethod from_literal(literal: Type[pytezos.michelson.micheline.Micheline]) → pytezos.michelson.types.base.MichelsonType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.base.MichelsonType

classmethod from_python_object(py_obj) → pytezos.michelson.types.base.MichelsonType

classmethod generate_pydoc(definitions: List[Tuple[str, str]], inferred_name=None, comparable=False) → str

classmethod get_anon_type() → Type[pytezos.michelson.types.base.MichelsonType]

classmethod is_big_map_friendly()

classmethod is_comparable()

classmethod is_duplicable()

classmethod is_packable()

classmethod is_passable()

classmethod is_pushable()

classmethod is_storable()

static match(expr) → Type[pytezos.michelson.types.base.MichelsonType]

merge_lazy_diff(lazy_diff: List[dict]) → pytezos.michelson.types.base.MichelsonType

pack(legacy=False) → bytes

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff: Optional[bool] = False)

to_python_object(try_unpack=False, lazy_diff: Optional[bool] = False, comparable=False)

type_name: Optional[str] = None

classmethod unpack(data: bytes) → pytezos.michelson.types.base.MichelsonType

pytezos.michelson.types.base.generate_pydoc(ty: Type[pytezos.michelson.types.base.MichelsonType], title=None)

pytezos.michelson.types.base.parse_name(annots: List[str], prefix: str) → Optional[str]

class pytezos.michelson.types.base.undefined

Core types

class pytezos.michelson.types.core.BoolType(value: bool)

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.core.BoolType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.core.BoolType

classmethod from_python_object(py_obj) → pytezos.michelson.types.core.BoolType

classmethod from_value(value: bool)

prim: Optional[str] = 'bool'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.core.BytesType(value: bytes = b'')

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.core.BytesType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.core.BytesType

classmethod from_python_object(py_obj) → pytezos.michelson.types.core.BytesType

classmethod from_value(value: bytes)

prim: Optional[str] = 'bytes'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.core.FalseLiteral

prim: Optional[str] = 'False'

class pytezos.michelson.types.core.IntType(value: int = 0)

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.core.IntType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.core.IntType

classmethod from_python_object(py_obj) → pytezos.michelson.types.core.IntType

classmethod from_value(value: int) → pytezos.michelson.types.core.IntType

prim: Optional[str] = 'int'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.core.NatType(value: int = 0)

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.core.NatType

classmethod from_python_object(py_obj) → pytezos.michelson.types.core.NatType

classmethod from_value(value: int) → pytezos.michelson.types.core.NatType

prim: Optional[str] = 'nat'

class pytezos.michelson.types.core.NeverType

prim: Optional[str] = 'never'

class pytezos.michelson.types.core.StringType(value: str = '')

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.core.StringType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.core.StringType

classmethod from_python_object(py_obj) → pytezos.michelson.types.core.StringType

classmethod from_value(value: str) → pytezos.michelson.types.core.StringType

prim: Optional[str] = 'string'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.core.TrueLiteral

prim: Optional[str] = 'True'

class pytezos.michelson.types.core.UnitLiteral

prim: Optional[str] = 'Unit'

class pytezos.michelson.types.core.UnitType

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.core.UnitType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.core.UnitType

classmethod from_python_object(py_obj) → pytezos.michelson.types.core.UnitType

prim: Optional[str] = 'unit'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.core.unit

Domain types

class pytezos.michelson.types.domain.AddressType(value: str = '')

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.domain.AddressType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.domain.AddressType

classmethod from_python_object(py_obj) → pytezos.michelson.types.domain.AddressType

classmethod from_value(value: str) → pytezos.michelson.types.domain.AddressType

prim: Optional[str] = 'address'

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.domain.ChainIdType(value: str = '')

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.domain.ChainIdType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.domain.ChainIdType

classmethod from_python_object(py_obj) → pytezos.michelson.types.domain.ChainIdType

classmethod from_value(value: str) → pytezos.michelson.types.domain.ChainIdType

prim: Optional[str] = 'chain_id'

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.domain.ContractType(value: str = '')

classmethod from_python_object(py_obj) → pytezos.michelson.types.domain.ContractType

classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)

get_address() → str

get_entrypoint() → str

prim: Optional[str] = 'contract'

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.domain.KeyHashType(value: str = '')

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.domain.KeyHashType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.domain.KeyHashType

classmethod from_value(value: str) → pytezos.michelson.types.domain.KeyHashType

classmethod parse_python_object(py_obj)

prim: Optional[str] = 'key_hash'

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.domain.KeyType(value: str = '')

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.domain.KeyType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.domain.KeyType

classmethod from_value(value: str) → pytezos.michelson.types.domain.KeyType

classmethod parse_python_object(py_obj) → pytezos.michelson.types.domain.KeyType

property prefix: str

prim: Optional[str] = 'key'

property raw: bytes

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.domain.LambdaType(value: Type[pytezos.michelson.micheline.Micheline])

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.domain.LambdaType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.domain.LambdaType

classmethod from_python_object(py_obj) → pytezos.michelson.types.domain.LambdaType

classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)

prim: Optional[str] = 'lambda'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.domain.MutezType(value: int = 0)

classmethod from_python_object(py_obj) → pytezos.michelson.types.domain.MutezType

classmethod from_value(value: int) → pytezos.michelson.types.domain.MutezType

prim: Optional[str] = 'mutez'

class pytezos.michelson.types.domain.SignatureType(value: str = '')

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.domain.SignatureType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.domain.SignatureType

classmethod from_python_object(py_obj) → pytezos.michelson.types.domain.SignatureType

classmethod from_value(value: str) → pytezos.michelson.types.domain.SignatureType

prim: Optional[str] = 'signature'

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.domain.TimestampType(value: int = 0)

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.domain.TimestampType

classmethod from_python_object(py_obj) → pytezos.michelson.types.domain.TimestampType

classmethod from_value(value: int) → pytezos.michelson.types.domain.TimestampType

prim: Optional[str] = 'timestamp'

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

Big map type

class pytezos.michelson.types.big_map.BigMapType(items: List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]], ptr: Optional[int] = None, removed_keys: Optional[List[pytezos.michelson.types.base.MichelsonType]] = None)

aggregate_lazy_diff(lazy_diff: List[dict], mode='readable') → pytezos.michelson.types.big_map.BigMapType

attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.big_map.BigMapType

duplicate()

static empty(key_type: Type[pytezos.michelson.types.base.MichelsonType], val_type: Type[pytezos.michelson.types.base.MichelsonType]) → pytezos.michelson.types.big_map.BigMapType

static from_items(items: List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]])

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.big_map.BigMapType

classmethod from_python_object(py_obj: Union[int, dict]) → pytezos.michelson.types.big_map.BigMapType

classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)

get(key: pytezos.michelson.types.base.MichelsonType, dup=True) → Optional[pytezos.michelson.types.base.MichelsonType]

get_key_hash(key_obj)

merge_lazy_diff(lazy_diff: List[dict]) → pytezos.michelson.types.big_map.BigMapType

prim: Optional[str] = 'big_map'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff: Optional[bool] = False)

to_python_object(try_unpack=False, lazy_diff: Optional[bool] = False, comparable=False)

update(key: pytezos.michelson.types.base.MichelsonType, val: Optional[pytezos.michelson.types.base.MichelsonType]) → Tuple[Optional[pytezos.michelson.types.base.MichelsonType], pytezos.michelson.types.base.MichelsonType]

pytezos.michelson.types.big_map.big_map_diff_to_lazy_diff(big_map_diff: List[dict])

BLS types

class pytezos.michelson.types.bls.BLS12_381_FrType(value: int)

static bytes_to_int(value: bytes) → int

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.core.IntType

classmethod from_python_object(py_obj) → pytezos.michelson.types.bls.BLS12_381_FrType

classmethod from_value(value: int) → pytezos.michelson.types.bls.BLS12_381_FrType

modulus = 52435875175126190479447740508185965837690552500527637822603658699938581184513

prim: Optional[str] = 'bls12_381_fr'

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.bls.BLS12_381_G1Type(value: bytes = b'')

classmethod from_point(point: Tuple[py_ecc.fields.optimized_bls12_381_FQ, py_ecc.fields.optimized_bls12_381_FQ, py_ecc.fields.optimized_bls12_381_FQ]) → pytezos.michelson.types.bls.BLS12_381_G1Type

classmethod from_value(value: bytes)

prim: Optional[str] = 'bls12_381_g1'

to_point() → Tuple[py_ecc.fields.optimized_bls12_381_FQ, py_ecc.fields.optimized_bls12_381_FQ, py_ecc.fields.optimized_bls12_381_FQ]

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.bls.BLS12_381_G2Type(value: bytes = b'')

classmethod from_point(point: Tuple[py_ecc.fields.optimized_bls12_381_FQ2, py_ecc.fields.optimized_bls12_381_FQ2, py_ecc.fields.optimized_bls12_381_FQ2]) → pytezos.michelson.types.bls.BLS12_381_G2Type

classmethod from_value(value: bytes)

prim: Optional[str] = 'bls12_381_g2'

to_point() → Tuple[py_ecc.fields.optimized_bls12_381_FQ2, py_ecc.fields.optimized_bls12_381_FQ2, py_ecc.fields.optimized_bls12_381_FQ2]

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

List type

class pytezos.michelson.types.list.ListType(items: List[pytezos.michelson.types.base.MichelsonType])

aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')

attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.list.ListType

static empty(item_type: Type[pytezos.michelson.types.base.MichelsonType])

static from_items(items: List[pytezos.michelson.types.base.MichelsonType])

classmethod from_micheline_value(val_expr: list) → pytezos.michelson.types.list.ListType

classmethod from_python_object(py_obj) → pytezos.michelson.types.list.ListType

classmethod generate_pydoc(definitions: List[Tuple[str, str]], inferred_name=None, comparable=False)

merge_lazy_diff(lazy_diff: List[dict]) → pytezos.michelson.types.base.MichelsonType

prepend(item: pytezos.michelson.types.base.MichelsonType) → pytezos.michelson.types.list.ListType

prim: Optional[str] = 'list'

split_head() → Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.list.ListType]

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

Map type

class pytezos.michelson.types.map.EltLiteral

prim: Optional[str] = 'Elt'

class pytezos.michelson.types.map.MapType(items: List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]])

aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')

attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)

classmethod check_constraints(items: List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]])

contains(key: pytezos.michelson.types.base.MichelsonType)

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.map.MapType

static empty(key_type: Type[pytezos.michelson.types.base.MichelsonType], val_type: Type[pytezos.michelson.types.base.MichelsonType]) → pytezos.michelson.types.map.MapType

static from_items(items: List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]]) → pytezos.michelson.types.map.MapType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.map.MapType

classmethod from_python_object(py_obj) → pytezos.michelson.types.map.MapType

classmethod generate_pydoc(definitions: List[Tuple[str, str]], inferred_name=None, comparable=False)

get(key: pytezos.michelson.types.base.MichelsonType, dup=True) → Optional[pytezos.michelson.types.base.MichelsonType]

merge_lazy_diff(lazy_diff: List[dict]) → pytezos.michelson.types.map.MapType

classmethod parse_micheline_value(val_expr) → List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]]

classmethod parse_python_object(py_obj) → List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]]

prim: Optional[str] = 'map'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False) → dict

update(key: pytezos.michelson.types.base.MichelsonType, val: Optional[pytezos.michelson.types.base.MichelsonType]) → Tuple[Optional[pytezos.michelson.types.base.MichelsonType], pytezos.michelson.types.base.MichelsonType]

Operation type

class pytezos.michelson.types.operation.OperationType(content: dict, ty: Optional[Type[pytezos.michelson.types.base.MichelsonType]] = None)

classmethod delegation(source: str, delegate: Optional[str] = None) → pytezos.michelson.types.operation.OperationType

classmethod origination(source: str, script: Type[pytezos.michelson.micheline.MichelineSequence], storage: pytezos.michelson.types.base.MichelsonType, balance: int = 0, delegate: Optional[str] = None) → pytezos.michelson.types.operation.OperationType

prim: Optional[str] = 'operation'

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

classmethod transaction(source: str, destination: str, amount: int, entrypoint: str, parameter: pytezos.michelson.types.base.MichelsonType) → pytezos.michelson.types.operation.OperationType

Option type

class pytezos.michelson.types.option.NoneLiteral

prim: Optional[str] = 'None'

class pytezos.michelson.types.option.OptionType(item: Optional[pytezos.michelson.types.base.MichelsonType])

aggregate_lazy_diff(lazy_diff: List[dict], mode='readable') → pytezos.michelson.types.base.MichelsonType

attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.option.OptionType

classmethod from_micheline_value(val_expr)

classmethod from_python_object(py_obj)

static from_some(item: pytezos.michelson.types.base.MichelsonType) → pytezos.michelson.types.option.OptionType

classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)

get_some() → pytezos.michelson.types.base.MichelsonType

is_none() → bool

merge_lazy_diff(lazy_diff: List[dict]) → pytezos.michelson.types.base.MichelsonType

static none(some_type: Type[pytezos.michelson.types.base.MichelsonType]) → pytezos.michelson.types.option.OptionType

prim: Optional[str] = 'option'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.option.SomeLiteral

prim: Optional[str] = 'Some'

Pair type

class pytezos.michelson.types.pair.PairLiteral

prim: Optional[str] = 'Pair'

class pytezos.michelson.types.pair.PairType(items: Tuple[pytezos.michelson.types.base.MichelsonType, ...])

access_comb(idx: int) → pytezos.michelson.types.base.MichelsonType

aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')

attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)

classmethod create_type(args: List[Type[pytezos.michelson.micheline.Micheline]], annots: Optional[list] = None, **kwargs) → Type[pytezos.michelson.types.pair.PairType]

classmethod dummy(context: pytezos.context.abstract.AbstractContext) → pytezos.michelson.types.pair.PairType

static from_comb(items: List[pytezos.michelson.types.base.MichelsonType]) → pytezos.michelson.types.pair.PairType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.pair.PairType

classmethod from_python_object(py_obj) → pytezos.michelson.types.pair.PairType

classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)

classmethod init(items: List[pytezos.michelson.types.base.MichelsonType]) → pytezos.michelson.types.pair.PairType

iter_comb(include_nodes=False) → Generator[pytezos.michelson.types.base.MichelsonType, None, None]

classmethod iter_type_args(entrypoints=False, path='') → Generator[Tuple[str, Type[pytezos.michelson.types.base.MichelsonType]], None, None]

iter_values(path='') → Generator[Tuple[str, pytezos.michelson.types.base.MichelsonType], None, None]

merge_lazy_diff(lazy_diff: List[dict]) → pytezos.michelson.types.pair.PairType

prim: Optional[str] = 'pair'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False) → Union[dict, tuple]

update_comb(idx: int, element: pytezos.michelson.types.base.MichelsonType) → pytezos.michelson.types.pair.PairType

Sapling type

class pytezos.michelson.types.sapling.SaplingStateType(ptr: Optional[int] = None)

aggregate_lazy_diff(lazy_diff: List[dict], mode='readable') → pytezos.michelson.types.base.MichelsonType

attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)

static empty(memo_size: int)

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.sapling.SaplingStateType

merge_lazy_diff(lazy_diff: List[dict]) → pytezos.michelson.types.base.MichelsonType

prim: Optional[str] = 'sapling_state'

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

class pytezos.michelson.types.sapling.SaplingTransactionType

prim: Optional[str] = 'sapling_transaction'

Set type

class pytezos.michelson.types.set.SetType(items: List[pytezos.michelson.types.base.MichelsonType])

add(item: pytezos.michelson.types.base.MichelsonType) → pytezos.michelson.types.set.SetType

classmethod check_constraints(items: List[pytezos.michelson.types.base.MichelsonType])

contains(item: pytezos.michelson.types.base.MichelsonType) → bool

classmethod dummy(context: pytezos.context.abstract.AbstractContext)

static empty(item_type: Type[pytezos.michelson.types.base.MichelsonType]) → pytezos.michelson.types.set.SetType

static from_items(items: List[pytezos.michelson.types.base.MichelsonType]) → pytezos.michelson.types.set.SetType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.set.SetType

classmethod from_python_object(py_obj) → pytezos.michelson.types.set.SetType

classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)

prim: Optional[str] = 'set'

remove(item: pytezos.michelson.types.base.MichelsonType) → pytezos.michelson.types.set.SetType

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)

Or type

class pytezos.michelson.types.sum.LeftLiteral

prim: Optional[str] = 'Left'

class pytezos.michelson.types.sum.OrType(items: Tuple[Union[pytezos.michelson.types.base.undefined, pytezos.michelson.types.base.MichelsonType], ...])

aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')

attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)

classmethod create_type(args: List[Type[pytezos.michelson.micheline.Micheline]], annots: Optional[list] = None, **kwargs) → Type[pytezos.michelson.types.sum.OrType]

classmethod dummy(context: pytezos.context.abstract.AbstractContext)

static from_left(left: pytezos.michelson.types.base.MichelsonType, right_type: Type[pytezos.michelson.types.base.MichelsonType])

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.sum.OrType

classmethod from_python_object(py_obj) → pytezos.michelson.types.sum.OrType

static from_right(right: pytezos.michelson.types.base.MichelsonType, left_type: Type[pytezos.michelson.types.base.MichelsonType])

classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)

is_enum: bool

is_left() → bool

is_right() → bool

classmethod iter_type_args(entrypoints=False, path='') → Generator[Tuple[str, Type[pytezos.michelson.types.base.MichelsonType]], None, None]

iter_values(path='') → Generator[Tuple[str, pytezos.michelson.types.base.MichelsonType], None, None]

merge_lazy_diff(lazy_diff: List[dict]) → pytezos.michelson.types.sum.OrType

prim: Optional[str] = 'or'

resolve() → pytezos.michelson.types.base.MichelsonType

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False) → Union[tuple, dict]

class pytezos.michelson.types.sum.RightLiteral

prim: Optional[str] = 'Right'

Ticket type

class pytezos.michelson.types.ticket.TicketType(ticketer: str, item: pytezos.michelson.types.base.MichelsonType, amount: int)

static create(ticketer: str, item: pytezos.michelson.types.base.MichelsonType, amount: int) → pytezos.michelson.types.ticket.TicketType

classmethod dummy(context: pytezos.context.abstract.AbstractContext)

classmethod from_comb(comb: pytezos.michelson.types.pair.PairType) → pytezos.michelson.types.ticket.TicketType

classmethod from_micheline_value(val_expr) → pytezos.michelson.types.ticket.TicketType

classmethod from_python_object(py_obj) → pytezos.michelson.types.base.MichelsonType

classmethod generate_pydoc(definitions: List[Tuple[str, str]], inferred_name=None, comparable=False) → str

static join(left: pytezos.michelson.types.ticket.TicketType, right: pytezos.michelson.types.ticket.TicketType) → Optional[pytezos.michelson.types.ticket.TicketType]

merge_lazy_diff(lazy_diff: List[dict]) → pytezos.michelson.types.base.MichelsonType

prim: Optional[str] = 'ticket'

split(amount_left: int, amount_right: int) → Optional[Tuple[pytezos.michelson.types.ticket.TicketType, pytezos.michelson.types.ticket.TicketType]]

to_comb() → pytezos.michelson.types.pair.PairType

to_literal() → Type[pytezos.michelson.micheline.Micheline]

to_micheline_value(mode='readable', lazy_diff=False)

to_python_object(try_unpack=False, lazy_diff=False, comparable=False)