tivars.types.tokenized.TokenizedEntry

class documentation

class TokenizedEntry(SizedEntry): (source)

Known subclasses: tivars.types.tokenized.TIEquation, tivars.types.tokenized.TIProgram, tivars.types.tokenized.TIString

Constructor: TokenizedEntry(init, for_flash, name, version, ...)

View In Hierarchy

Base class for all tokenized entries

A tokenized entry is a SizedEntry whose data comprises a stream of tokens.

Static Method	`decode`	Decodes a byte stream into a string of tokens
Static Method	`encode`	Encodes a string of token represented in text into a byte stream
Method	`__format__`	Formats this entry for string representations
Method	`__iter__`	No summary
Method	`get_min_os`	Determines the minimum OS that supports this entry's data
Method	`get_version`	Determines the version byte corresponding to given data for this entry type
Method	`lines`	Splits this entry into logical lines: lines separated by newlines or colons lying outside string literals
Method	`load_bytes`	Loads a byte string or bytestream into this entry
Method	`load_string`	Loads this entry from a string representation
Method	`load_tokens`	Loads this entry from a sequence of `TIToken` objects
Method	`tokens`	No summary
Class Variable	`clock_tokens`	Tokens which interface with the RTC
Class Variable	`min_data_length`	The minimum length of this entry's data
Class Variable	`versions`	The possible versions of this entry

Inherited from SizedEntry:

Method	`calc_data`	The data section of the entry which is loaded on-calc
Method	`clear`	Clears this entry's data
Method	`data`	The entry's user data
Method	`length`	The length of this entry's user data section
Method	`load_data_section`	Loads the data of this entry from a bytestream

Inherited from TIEntry (via SizedEntry):

Class	`Raw`	Raw bytes container for `TIEntry`
Class Method	`get`	Converts `bytes` -> `TIEntry`
Class Method	`get_type`	Gets the subclass corresponding to a type ID if one is registered
Class Method	`open`	Creates a new entry from a file given a filename
Class Method	`register`	Registers a subtype with this class for coercion
Class Method	`set`	Converts `TIEntry` -> `bytes`
Static Method	`next_entry_length`	Helper function to determine the length of the next entry in a bytestream
Method	`__bool__`	No summary
Method	`__bytes__`	No summary
Method	`__copy__`	No summary
Method	`__eq__`	Determines if two entries are the same type and have the same bytes
Method	`__init__`	Creates an empty entry with specified meta and data values
Method	`__len__`	No summary
Method	`__str__`	No summary
Method	`archive`	Archives this entry (if supported)
Method	`archived`	Whether the entry is archived
Method	`bytes`	The bytes contained in this entry, without any var file header or metadata.
Method	`coerce`	Coerces this entry to a subclass if possible using the entry's type ID
Method	`dict`	No summary
Method	`export`	Exports this entry to a `TIVar` with a specified name, header, and target model
Method	`load_dict`	Loads this entry from a JSON dictionary representation
Method	`load_from_file`	Loads this entry from a file given a file pointer and offset
Method	`meta_length`	The length of the meta section of the entry
Method	`name`	The name of the entry
Method	`save`	Saves this entry as a var file in the current directory given a filename and optional header and targeted model
Method	`string`	No summary
Method	`supported_by`	Determines whether a given model can support this entry
Method	`type_id`	The type ID of the entry
Method	`unarchive`	Unarchives this entry (if supported)
Method	`version`	The version number of the entry
Class Variable	`base_meta_length`	Undocumented
Class Variable	`extensions`	The file extension used for this entry per-model
Class Variable	`flash_meta_length`	Undocumented
Class Variable	`flash_only`	Whether this entry only supports flash chips
Class Variable	`leading_data_bytes`	Bytes that always begin this entry's data
Class Variable	`leading_name_byte`	Byte that always begins the name of this entry
Instance Variable	`raw`	Undocumented
Property	`calc_data_length`	The length of the data section of the entry
Property	`flash_bytes`	The flash bytes of this entry if they exist
Property	`is_empty`	Whether this entry's data is empty
Property	`meta`	The meta section of this entry
Method	`__init_subclass__`	Undocumented
Constant	`_T`	Undocumented
Class Variable	`_type_id`	Undocumented
Class Variable	`_type_ids`	Undocumented

Inherited from Dock (via SizedEntry, TIEntry):

Method	`load`	Loads data into an instance by delegating to `Loader` methods based on the input's type
Class Variable	`loaders`	Undocumented

@staticmethod

def decode(data: bytes, *, model: TIModel = None, lang: str = None, mode: str = None) -> str: (source) ¶

Decodes a byte stream into a string of tokens

Parameters
data:`bytes`	The token bytes to decode
model:`TIModel`	A model for which compatibility is ensured (defaults to the TI-84+CE)
lang:`str`	The language used in `string` (defaults to the locale of `model`, or English, `en`)
mode:`str`	The form of token representation to use for output (defaults to `display`)

Returns
`str`	A string of token representations

@staticmethod

def encode(string: str, *, model: TIModel = None, lang: str = None, mode: str = None) -> bytes: (source) ¶

Encodes a string of token represented in text into a byte stream

For detailed information on tokenization modes, see tivars.tokenizer.encode.

Parameters
string:`str`	The text string to encode
model:`TIModel`	A model to target when encoding (defaults to no specific model)
lang:`str`	The language used in `string` (defaults to the locale of `model`, or English, `en`)
mode:`str`	The tokenization mode to use (defaults to `smart`)

Returns
`bytes`	A stream of token bytes

def __format__(self, format_spec: str) -> str: (source) ¶

overrides tivars.var.TIEntry.__format__

Formats this entry for string representations

Parameters
format_spec:`str`	The format parameters

Returns
`str`	A string representation of this entry

def __iter__(self) -> Iterator[TIToken]: (source) ¶

overrides tivars.var.TIEntry.__iter__

overridden in tivars.types.gdb.TIGraphedEquation

Returns
`Iterator[TIToken]`	If this entry is a container or collection, an iterator over its elements

def get_min_os(self, data: bytes = None) -> OsVersion: (source) ¶

overrides tivars.var.TIEntry.get_min_os

overridden in tivars.types.tokenized.TIAsmProgram

Determines the minimum OS that supports this entry's data

Parameters
data:`bytes`	The data to find the minimum support for (defaults to this entry's data)

Returns
`OsVersion`	The minimum `OsVersion` this entry supports

def get_version(self, data: bytes = None) -> int: (source) ¶

overrides tivars.var.TIEntry.get_version

Determines the version byte corresponding to given data for this entry type

Entries which could contain non-backwards compatible data are assigned a version byte. If an entry's version exceeds the "version" of a calculator, transfer to the calculator will fail.

Parameters
data:`bytes`	The data to find the version of (defaults to this entry's data)

Returns
`int`	The version byte for `data`

def lines(self) -> list[list[TIToken]]: (source) ¶

Splits this entry into logical lines: lines separated by newlines or colons lying outside string literals

This method is not used to format entries with line numbers; only literal newlines are considered there. To split on just literal newlines or some other separator, use .string().split.

Returns
`list[list[TIToken]]`	The logical lines of this entry as lists of `TIToken` objects

@Loader[bytes, bytearray, BytesIO]

def load_bytes(self, data: bytes | BytesIO): (source) ¶

overrides tivars.var.SizedEntry.load_bytes

overridden in tivars.types.tokenized.TIProgram

Loads a byte string or bytestream into this entry

Parameters
data:`bytes \| BytesIO`	The bytes to load

@Loader[str]

def load_string(self, string: str, *, model: TIModel = None, lang: str = None, mode: str = None): (source) ¶

overrides tivars.var.TIEntry.load_string

overridden in tivars.types.gdb.TIGraphedEquation, tivars.types.tokenized.TIProgram, tivars.types.tokenized.TIString

Loads this entry from a string representation

For detailed information on tokenization modes, see tivars.tokenizer.encode.

Parameters
string:`str`	The string to load
model:`TIModel`	The model to target when encoding (defaults to no specific model)
lang:`str`	The language used in `string` (defaults to English, `en`)
mode:`str`	The tokenization mode to use (defaults to `smart`)

@Loader[Sequence[TIToken]]

def load_tokens(self, tokens: Sequence[TIToken]): (source) ¶

Loads this entry from a sequence of TIToken objects

Parameters
tokens:`Sequence[TIToken]`	The sequence of tokens to load

def tokens(self) -> list[TIToken]: (source) ¶

Returns
`list[TIToken]`	The tokens comprising this entry as a list of `TIToken` objects

clock_tokens: list[bytes] = (source) ¶

Tokens which interface with the RTC

These tokens influence the entry's version, though detecting the presence of the RTC has no current application.

min_data_length: int = (source) ¶

overrides tivars.var.SizedEntry.min_data_length

overridden in tivars.types.gdb.TIGraphedEquation

The minimum length of this entry's data

If an entry's data is fixed in size, this value is necessarily the length of the data

versions: list[int] = (source) ¶

overrides tivars.var.TIEntry.versions

The possible versions of this entry