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]¶