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, name, version, archived, data)

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__ Undocumented
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 string Decodes this entry into a string of tokens
Method tokens No summary
Class Variable clock_tokens Tokens which interface with the RTC
Class Variable min_calc_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 component which is loaded on-calc
Method clear Clears this entry's data
Method data The component's user data
Method get_length Determines the length of this entry's user data section
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 No class docstring; 3/3 properties, 0/1 class variable, 1/1 method documented
Class Method get_extension Determines the file extension for a targeted model based on its contents
Class Method get_type Gets the subclass corresponding to a type ID, type name, or file extension if one is registered
Class Method open Creates a new entry from a file given a filename
Static Method next_entry_length Helper function to determine the length of the next entry in a bytestream
Method __init__ Creates an empty entry with specified meta and data values
Method __len__ No summary
Method archive Archives this entry
Method archived Whether the entry is archived
Method bytes The bytes contained in this entry, without any var file header or metadata.
Method dict No summary
Method export Exports this entry to a TIVarFile with a specified name and header
Method load_dict Loads this component 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 summary No summary
Method supported_by Determines whether a given model supports this entry
Method type_id The type ID of the entry
Method unarchive Unarchives this entry
Method version The version number of the entry
Class Variable base_meta_length Undocumented
Class Variable extension The base file extension used for this entry
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 for_flash Whether this entry supports flash chips
Property meta The meta section of this entry
Method __init_subclass__ Undocumented
Class Variable _type_ids Undocumented

Inherited from TIComponent (via SizedEntry, TIEntry):

Class Method get Converts bytes -> TIComponent
Class Method register Registers a subtype with this class for coercion
Class Method set Converts TIComponent -> bytes
Method __bool__ No summary
Method __bytes__ No summary
Method __copy__ No summary
Method __eq__ Determines if two components are the same type and have the same bytes
Method __str__ No summary
Method coerce Coerces this component to a subclass if possible using the component's type ID
Method json No summary
Method load_json Loads this component from a JSON dictionary representation
Method update Updates this component's metadata
Property is_empty Whether this component's data is empty
Class Variable _type_id Undocumented

Inherited from Dock (via SizedEntry, TIEntry, TIComponent):

Method load Loads data into an instance by delegating to Loader methods based on the input's type
Class Variable loaders Undocumented
def decode(data: bytes, *, model: TIModel = TI_84PCE, lang: str = None, mode: str = None) -> str: (source)

Decodes a byte stream into a string of tokens

Parameters
data:bytesThe token bytes to decode
model:TIModelA model for which compatibility is ensured (defaults to the TI-84+CE)
lang:strThe language used in string (defaults to the locale of model, or English, en)
mode:strThe form of token representation to use for output (defaults to display)
Returns
strA string of token representations
def encode(string: str, *, model: TIModel = TI_84PCE, 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:strThe text string to encode
model:TIModelA model to target when encoding (defaults to no specific model)
lang:strThe language used in string (defaults to the locale of model, or English, en)
mode:strThe tokenization mode to use (defaults to smart)
Returns
bytesA stream of token bytes
def __format__(self, format_spec: str) -> str: (source)
overrides tivars.file.TIComponent.__format__

Undocumented

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) -> 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

Returns
OsVersionThe minimum OsVersion this entry supports
def get_version(self) -> 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.

Returns
intThe version byte for this entry
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
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 | BytesIOThe bytes to load
def load_string(self, string: str, *, model: TIModel = TI_84PCE, lang: str = None, mode: str = None): (source)
overrides tivars.file.TIComponent.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:strThe string to load
model:TIModelThe model to target when encoding (defaults to no specific model)
lang:strThe language used in string (defaults to English, en)
mode:strThe tokenization mode to use (defaults to smart)
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 string(self, *, model: TIModel = TI_84PCE, lang: str = None, mode: str = None) -> str: (source)
overrides tivars.file.TIComponent.string
overridden in tivars.types.tokenized.TIProgram, tivars.types.tokenized.TIString

Decodes this entry into a string of tokens

Parameters
model:TIModelA model for which compatibility is ensured (defaults to the TI-84+CE)
lang:strThe language used in string (defaults to the locale of model, or English, en)
mode:strThe form of token representation to use for output (defaults to display)
Returns
strA string of token representations
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_calc_data_length: int = (source)
overrides tivars.var.SizedEntry.min_calc_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