Michelson types

Base class

class pytezos.michelson.types.base.MichelsonType[source]
aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')MichelsonType[source]
args: List[Union[Type[MichelsonType], Any]] = []
classmethod as_micheline_expr() → dict[source]
attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)[source]
classmethod create_type(args: List[Type[Micheline]], annots: Optional[list] = None, **kwargs) → Type[MichelsonType][source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)MichelsonType[source]
duplicate()[source]
field_name: Optional[str] = None
forge(mode='readable') → bytes[source]
classmethod from_literal(literal: Type[pytezos.michelson.micheline.Micheline])MichelsonType[source]
classmethod from_micheline_value(val_expr)MichelsonType[source]
classmethod from_python_object(py_obj)MichelsonType[source]
classmethod generate_pydoc(definitions: List[Tuple[str, str]], inferred_name=None, comparable=False) → str[source]
classmethod get_anon_type() → Type[MichelsonType][source]
classmethod is_big_map_friendly()[source]
classmethod is_comparable()[source]
classmethod is_duplicable()[source]
classmethod is_packable()[source]
classmethod is_passable()[source]
classmethod is_pushable()[source]
classmethod is_storable()[source]
static match(expr) → Type[MichelsonType][source]
merge_lazy_diff(lazy_diff: List[dict])MichelsonType[source]
pack(legacy=False) → bytes[source]
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
type_name: Optional[str] = None
classmethod unpack(data: bytes)MichelsonType[source]
pytezos.michelson.types.base.generate_pydoc(ty: Type[pytezos.michelson.types.base.MichelsonType], title=None)[source]
pytezos.michelson.types.base.parse_name(annots: List[str], prefix: str) → Optional[str][source]
class pytezos.michelson.types.base.undefined[source]

Core types

class pytezos.michelson.types.core.BoolType(value: bool)[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)BoolType[source]
classmethod from_micheline_value(val_expr)BoolType[source]
classmethod from_python_object(py_obj)BoolType[source]
classmethod from_value(value: bool)[source]
prim: Optional[str] = 'bool'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.core.BytesType(value: bytes = b'')[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)BytesType[source]
classmethod from_micheline_value(val_expr)BytesType[source]
classmethod from_python_object(py_obj)BytesType[source]
classmethod from_value(value: bytes)[source]
prim: Optional[str] = 'bytes'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.core.FalseLiteral[source]
prim: Optional[str] = 'False'
class pytezos.michelson.types.core.IntType(value: int = 0)[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)IntType[source]
classmethod from_micheline_value(val_expr)IntType[source]
classmethod from_python_object(py_obj)IntType[source]
classmethod from_value(value: int)IntType[source]
prim: Optional[str] = 'int'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.core.NatType(value: int = 0)[source]
classmethod from_micheline_value(val_expr)NatType[source]
classmethod from_python_object(py_obj)NatType[source]
classmethod from_value(value: int)NatType[source]
prim: Optional[str] = 'nat'
class pytezos.michelson.types.core.NeverType[source]
prim: Optional[str] = 'never'
class pytezos.michelson.types.core.StringType(value: str = '')[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)StringType[source]
classmethod from_micheline_value(val_expr)StringType[source]
classmethod from_python_object(py_obj)StringType[source]
classmethod from_value(value: str)StringType[source]
prim: Optional[str] = 'string'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.core.TrueLiteral[source]
prim: Optional[str] = 'True'
class pytezos.michelson.types.core.UnitLiteral[source]
prim: Optional[str] = 'Unit'
class pytezos.michelson.types.core.UnitType[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)UnitType[source]
classmethod from_micheline_value(val_expr)UnitType[source]
classmethod from_python_object(py_obj)UnitType[source]
prim: Optional[str] = 'unit'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.core.unit[source]

Domain types

class pytezos.michelson.types.domain.AddressType(value: str = '')[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)AddressType[source]
classmethod from_micheline_value(val_expr)AddressType[source]
classmethod from_python_object(py_obj)AddressType[source]
classmethod from_value(value: str)AddressType[source]
prim: Optional[str] = 'address'
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.domain.ChainIdType(value: str = '')[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)ChainIdType[source]
classmethod from_micheline_value(val_expr)ChainIdType[source]
classmethod from_python_object(py_obj)ChainIdType[source]
classmethod from_value(value: str)ChainIdType[source]
prim: Optional[str] = 'chain_id'
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.domain.ContractType(value: str = '')[source]
classmethod from_python_object(py_obj)ContractType[source]
classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)[source]
get_address() → str[source]
get_entrypoint() → str[source]
prim: Optional[str] = 'contract'
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.domain.KeyHashType(value: str = '')[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)KeyHashType[source]
classmethod from_micheline_value(val_expr)KeyHashType[source]
classmethod from_value(value: str)KeyHashType[source]
classmethod parse_python_object(py_obj)[source]
prim: Optional[str] = 'key_hash'
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.domain.KeyType(value: str = '')[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)KeyType[source]
classmethod from_micheline_value(val_expr)KeyType[source]
classmethod from_value(value: str)KeyType[source]
classmethod parse_python_object(py_obj)KeyType[source]
prim: Optional[str] = 'key'
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.domain.LambdaType(value: Type[pytezos.michelson.micheline.Micheline])[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)LambdaType[source]
classmethod from_micheline_value(val_expr)LambdaType[source]
classmethod from_python_object(py_obj)LambdaType[source]
classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)[source]
prim: Optional[str] = 'lambda'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.domain.MutezType(value: int = 0)[source]
classmethod from_python_object(py_obj)MutezType[source]
classmethod from_value(value: int)MutezType[source]
prim: Optional[str] = 'mutez'
class pytezos.michelson.types.domain.SignatureType(value: str = '')[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)SignatureType[source]
classmethod from_micheline_value(val_expr)SignatureType[source]
classmethod from_python_object(py_obj)SignatureType[source]
classmethod from_value(value: str)SignatureType[source]
prim: Optional[str] = 'signature'
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.domain.TimestampType(value: int = 0)[source]
classmethod from_micheline_value(val_expr)TimestampType[source]
classmethod from_python_object(py_obj)TimestampType[source]
classmethod from_value(value: int)TimestampType[source]
prim: Optional[str] = 'timestamp'
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]

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)[source]
aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')BigMapType[source]
attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)BigMapType[source]
duplicate()[source]
static empty(key_type: Type[pytezos.michelson.types.base.MichelsonType], val_type: Type[pytezos.michelson.types.base.MichelsonType])BigMapType[source]
static from_items(items: List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]])[source]
classmethod from_micheline_value(val_expr)BigMapType[source]
classmethod from_python_object(py_obj: Union[int, dict])BigMapType[source]
classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)[source]
get(key: pytezos.michelson.types.base.MichelsonType, dup=True) → Optional[pytezos.michelson.types.base.MichelsonType][source]
get_key_hash(key_obj)[source]
merge_lazy_diff(lazy_diff: List[dict])BigMapType[source]
prim: Optional[str] = 'big_map'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
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][source]
pytezos.michelson.types.big_map.big_map_diff_to_lazy_diff(big_map_diff: List[dict])[source]

BLS types

class pytezos.michelson.types.bls.BLS12_381_FrType(value: int)[source]
static bytes_to_int(value: bytes) → int[source]
classmethod from_micheline_value(val_expr) → IntType[source]
classmethod from_python_object(py_obj)BLS12_381_FrType[source]
classmethod from_value(value: int)BLS12_381_FrType[source]
modulus = 52435875175126190479447740508185965837690552500527637822603658699938581184513
prim: Optional[str] = 'bls12_381_fr'
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.bls.BLS12_381_G1Type(value: bytes = b'')[source]
classmethod from_point(point: Tuple[py_ecc.fields.optimized_bls12_381_FQ])BLS12_381_G1Type[source]
classmethod from_value(value: bytes)[source]
prim: Optional[str] = 'bls12_381_g1'
to_point() → Tuple[py_ecc.fields.optimized_bls12_381_FQ][source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.bls.BLS12_381_G2Type(value: bytes = b'')[source]
classmethod from_point(point: Tuple[py_ecc.fields.optimized_bls12_381_FQ2])BLS12_381_G2Type[source]
classmethod from_value(value: bytes)[source]
prim: Optional[str] = 'bls12_381_g2'
to_point() → Tuple[py_ecc.fields.optimized_bls12_381_FQ2][source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]

List type

class pytezos.michelson.types.list.ListType(items: List[pytezos.michelson.types.base.MichelsonType])[source]
aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')[source]
attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)ListType[source]
static empty(item_type: Type[pytezos.michelson.types.base.MichelsonType])[source]
static from_items(items: List[pytezos.michelson.types.base.MichelsonType])[source]
classmethod from_micheline_value(val_expr: list)ListType[source]
classmethod from_python_object(py_obj)ListType[source]
classmethod generate_pydoc(definitions: List[Tuple[str, str]], inferred_name=None, comparable=False)[source]
merge_lazy_diff(lazy_diff: List[dict]) → MichelsonType[source]
prepend(item: pytezos.michelson.types.base.MichelsonType)ListType[source]
prim: Optional[str] = 'list'
split_head() → Tuple[pytezos.michelson.types.base.MichelsonType, ListType][source]
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]

Map type

class pytezos.michelson.types.map.EltLiteral[source]
prim: Optional[str] = 'Elt'
class pytezos.michelson.types.map.MapType(items: List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]])[source]
aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')[source]
attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)[source]
classmethod check_constraints(items: List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]])[source]
contains(key: pytezos.michelson.types.base.MichelsonType)[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)MapType[source]
static empty(key_type: Type[pytezos.michelson.types.base.MichelsonType], val_type: Type[pytezos.michelson.types.base.MichelsonType])MapType[source]
static from_items(items: List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]])MapType[source]
classmethod from_micheline_value(val_expr)MapType[source]
classmethod from_python_object(py_obj)MapType[source]
classmethod generate_pydoc(definitions: List[Tuple[str, str]], inferred_name=None, comparable=False)[source]
get(key: pytezos.michelson.types.base.MichelsonType, dup=True) → Optional[pytezos.michelson.types.base.MichelsonType][source]
merge_lazy_diff(lazy_diff: List[dict])MapType[source]
classmethod parse_micheline_value(val_expr) → List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]][source]
classmethod parse_python_object(py_obj) → List[Tuple[pytezos.michelson.types.base.MichelsonType, pytezos.michelson.types.base.MichelsonType]][source]
prim: Optional[str] = 'map'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False) → dict[source]
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][source]

Operation type

class pytezos.michelson.types.operation.OperationType(content: dict, ty: Optional[Type[pytezos.michelson.types.base.MichelsonType]] = None)[source]
classmethod delegation(source: str, delegate: Optional[str] = None)OperationType[source]
classmethod origination(source: str, script: Type[pytezos.michelson.micheline.MichelineSequence], storage: pytezos.michelson.types.base.MichelsonType, balance: int = 0, delegate: Optional[str] = None)OperationType[source]
prim: Optional[str] = 'operation'
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
classmethod transaction(source: str, destination: str, amount: int, entrypoint: str, parameter: pytezos.michelson.types.base.MichelsonType)OperationType[source]

Option type

class pytezos.michelson.types.option.NoneLiteral[source]
prim: Optional[str] = 'None'
class pytezos.michelson.types.option.OptionType(item: Optional[pytezos.michelson.types.base.MichelsonType])[source]
aggregate_lazy_diff(lazy_diff: List[dict], mode='readable') → MichelsonType[source]
attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)OptionType[source]
classmethod from_micheline_value(val_expr)[source]
classmethod from_python_object(py_obj)[source]
static from_some(item: pytezos.michelson.types.base.MichelsonType)OptionType[source]
classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)[source]
get_some()pytezos.michelson.types.base.MichelsonType[source]
is_none() → bool[source]
merge_lazy_diff(lazy_diff: List[dict]) → MichelsonType[source]
static none(some_type: Type[pytezos.michelson.types.base.MichelsonType])OptionType[source]
prim: Optional[str] = 'option'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.option.SomeLiteral[source]
prim: Optional[str] = 'Some'

Pair type

class pytezos.michelson.types.pair.PairLiteral[source]
prim: Optional[str] = 'Pair'
class pytezos.michelson.types.pair.PairType(items: Tuple[pytezos.michelson.types.base.MichelsonType, ])[source]
access_comb(idx: int)pytezos.michelson.types.base.MichelsonType[source]
aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')[source]
attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)[source]
classmethod create_type(args: List[Type[Micheline]], annots: Optional[list] = None, **kwargs) → Type[PairType][source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)PairType[source]
static from_comb(items: List[pytezos.michelson.types.base.MichelsonType])PairType[source]
classmethod from_micheline_value(val_expr)PairType[source]
classmethod from_python_object(py_obj)PairType[source]
classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)[source]
classmethod init(items: List[pytezos.michelson.types.base.MichelsonType])PairType[source]
iter_comb(include_nodes=False) → Generator[pytezos.michelson.types.base.MichelsonType, None, None][source]
classmethod iter_type_args(entrypoints=False, path='') → Generator[Tuple[str, Type[pytezos.michelson.types.base.MichelsonType]], None, None][source]
iter_values(path='') → Generator[Tuple[str, pytezos.michelson.types.base.MichelsonType], None, None][source]
merge_lazy_diff(lazy_diff: List[dict])PairType[source]
prim: Optional[str] = 'pair'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False) → Union[dict, tuple][source]
update_comb(idx: int, element: pytezos.michelson.types.base.MichelsonType)PairType[source]

Sapling type

class pytezos.michelson.types.sapling.SaplingStateType(ptr: Optional[int] = None)[source]
aggregate_lazy_diff(lazy_diff: List[dict], mode='readable') → MichelsonType[source]
attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)[source]
static empty(memo_size: int)[source]
classmethod from_micheline_value(val_expr)SaplingStateType[source]
merge_lazy_diff(lazy_diff: List[dict]) → MichelsonType[source]
prim: Optional[str] = 'sapling_state'
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]
class pytezos.michelson.types.sapling.SaplingTransactionType[source]
prim: Optional[str] = 'sapling_transaction'

Set type

class pytezos.michelson.types.set.SetType(items: List[pytezos.michelson.types.base.MichelsonType])[source]
add(item: pytezos.michelson.types.base.MichelsonType)SetType[source]
classmethod check_constraints(items: List[pytezos.michelson.types.base.MichelsonType])[source]
contains(item: pytezos.michelson.types.base.MichelsonType) → bool[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)[source]
static empty(item_type: Type[pytezos.michelson.types.base.MichelsonType])SetType[source]
static from_items(items: List[pytezos.michelson.types.base.MichelsonType])SetType[source]
classmethod from_micheline_value(val_expr)SetType[source]
classmethod from_python_object(py_obj)SetType[source]
classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)[source]
prim: Optional[str] = 'set'
remove(item: pytezos.michelson.types.base.MichelsonType)SetType[source]
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]

Or type

class pytezos.michelson.types.sum.LeftLiteral[source]
prim: Optional[str] = 'Left'
class pytezos.michelson.types.sum.OrType(items: Tuple[Union[pytezos.michelson.types.base.undefined, pytezos.michelson.types.base.MichelsonType], ])[source]
aggregate_lazy_diff(lazy_diff: List[dict], mode='readable')[source]
attach_context(context: pytezos.context.abstract.AbstractContext, big_map_copy=False)[source]
classmethod create_type(args: List[Type[Micheline]], annots: Optional[list] = None, **kwargs) → Type[OrType][source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)[source]
static from_left(left: pytezos.michelson.types.base.MichelsonType, right_type: Type[pytezos.michelson.types.base.MichelsonType])[source]
classmethod from_micheline_value(val_expr)OrType[source]
classmethod from_python_object(py_obj)OrType[source]
static from_right(right: pytezos.michelson.types.base.MichelsonType, left_type: Type[pytezos.michelson.types.base.MichelsonType])[source]
classmethod generate_pydoc(definitions: list, inferred_name=None, comparable=False)[source]
is_enum: bool
is_left() → bool[source]
is_right() → bool[source]
classmethod iter_type_args(entrypoints=False, path='') → Generator[Tuple[str, Type[pytezos.michelson.types.base.MichelsonType]], None, None][source]
iter_values(path='') → Generator[Tuple[str, pytezos.michelson.types.base.MichelsonType], None, None][source]
merge_lazy_diff(lazy_diff: List[dict])OrType[source]
prim: Optional[str] = 'or'
resolve()pytezos.michelson.types.base.MichelsonType[source]
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False) → Union[tuple, dict][source]
class pytezos.michelson.types.sum.RightLiteral[source]
prim: Optional[str] = 'Right'

Ticket type

class pytezos.michelson.types.ticket.TicketType(ticketer: str, item: pytezos.michelson.types.base.MichelsonType, amount: int)[source]
static create(ticketer: str, item: pytezos.michelson.types.base.MichelsonType, amount: int)TicketType[source]
classmethod dummy(context: pytezos.context.abstract.AbstractContext)[source]
classmethod from_comb(comb: pytezos.michelson.types.pair.PairType)TicketType[source]
classmethod from_micheline_value(val_expr)TicketType[source]
classmethod from_python_object(py_obj) → MichelsonType[source]
classmethod generate_pydoc(definitions: List[Tuple[str, str]], inferred_name=None, comparable=False) → str[source]
static join(left: TicketType, right: TicketType) → Optional[TicketType][source]
merge_lazy_diff(lazy_diff: List[dict]) → MichelsonType[source]
prim: Optional[str] = 'ticket'
split(amount_left: int, amount_right: int) → Optional[Tuple[TicketType, TicketType]][source]
to_comb()pytezos.michelson.types.pair.PairType[source]
to_literal() → Type[pytezos.michelson.micheline.Micheline][source]
to_micheline_value(mode='readable', lazy_diff=False)[source]
to_python_object(try_unpack=False, lazy_diff=False, comparable=False)[source]