pyk.kast.att module

class AnyType

Bases: AttType[Any]

from_dict(obj: Any) → Any

parse(text: str) → Any

to_dict(value: Any) → Any

unparse(value: Any) → str

final class AttEntry(key: 'AttKey[T]', value: 'T')

Bases: Generic[T]

key: AttKey[T]

value: T

final class AttKey(name: 'str', *, type: 'AttType[T]')

Bases: Generic[T]

name: str

type: AttType[T]

class AttType

Bases: Generic[T], ABC

abstract from_dict(obj: Any) → T

abstract parse(text: str) → T

abstract to_dict(value: T) → Any

abstract unparse(value: T) → str | None

class Atts

Bases: object

ALIAS: Final = AttKey(name='alias')

ALIAS_REC: Final = AttKey(name='alias-rec')

ANYWHERE: Final = AttKey(name='anywhere')

ASSOC: Final = AttKey(name='assoc')

AVOID: Final = AttKey(name='avoid')

BRACKET: Final = AttKey(name='bracket')

BRACKET_LABEL: Final = AttKey(name='bracketLabel')

CELL: Final = AttKey(name='cell')

CELL_COLLECTION: Final = AttKey(name='cellCollection')

CELL_FRAGMENT: Final = AttKey(name='cellFragment')

CELL_NAME: Final = AttKey(name='cellName')

CELL_OPT_ABSENT: Final = AttKey(name='cellOptAbsent')

CIRCULARITY: Final = AttKey(name='circularity')

COLOR: Final = AttKey(name='color')

COLORS: Final = AttKey(name='colors')

COMM: Final = AttKey(name='comm')

CONCAT: Final = AttKey(name='concat')

CONCRETE: Final = AttKey(name='concrete')

CONSTRUCTOR: Final = AttKey(name='constructor')

DEPENDS: Final = AttKey(name='depends')

DIGEST: Final = AttKey(name='digest')

ELEMENT: Final = AttKey(name='element')

EXIT: Final = AttKey(name='exit')

FORMAT: Final = AttKey(name='format')

FRESH_GENERATOR: Final = AttKey(name='freshGenerator')

FUNCTION: Final = AttKey(name='function')

FUNCTIONAL: Final = AttKey(name='functional')

GROUP: Final = AttKey(name='group')

HAS_DOMAIN_VALUES: Final = AttKey(name='hasDomainValues')

HOOK: Final = AttKey(name='hook')

IDEM: Final = AttKey(name='idem')

IMPURE: Final = AttKey(name='impure')

INDEX: Final = AttKey(name='index')

INITIALIZER: Final = AttKey(name='initializer')

INJECTIVE: Final = AttKey(name='injective')

LABEL: Final = AttKey(name='label')

LEFT: Final = AttKey(name='left')

LOCATION: Final = AttKey(name='org.kframework.attributes.Location')

MACRO: Final = AttKey(name='macro')

MACRO_REC: Final = AttKey(name='macro-rec')

MAINCELL: Final = AttKey(name='maincell')

MULTIPLICITY: Final = AttKey(name='multiplicity')

NO_EVALUATORS: Final = AttKey(name='no-evaluators')

OVERLOAD: Final = AttKey(name='overload')

OWISE: Final = AttKey(name='owise')

PREDICATE: Final = AttKey(name='predicate')

PREFER: Final = AttKey(name='prefer')

PRIORITIES: Final = AttKey(name='priorities')

PRIORITY: Final = AttKey(name='priority')

PRIVATE: Final = AttKey(name='private')

PRODUCTION: Final = AttKey(name='org.kframework.definition.Production')

PROJECTION: Final = AttKey(name='projection')

RETURNS_UNIT: Final = AttKey(name='returnsUnit')

RIGHT: Final = AttKey(name='right')

SEQSTRICT: Final = AttKey(name='seqstrict')

SIMPLIFICATION: Final = AttKey(name='simplification')

SMTLEMMA: Final = AttKey(name='smt-lemma')

SORT: Final = AttKey(name='org.kframework.kore.Sort')

SOURCE: Final = AttKey(name='org.kframework.attributes.Source')

STRICT: Final = AttKey(name='strict')

SYMBOL: Final = AttKey(name='symbol')

SYMBOLIC: Final = AttKey(name='symbolic')

SYNTAX_MODULE: Final = AttKey(name='syntaxModule')

TERMINALS: Final = AttKey(name='terminals')

TERMINATOR_SYMBOL: Final = AttKey(name='terminator-symbol')

TOKEN: Final = AttKey(name='token')

TOTAL: Final = AttKey(name='total')

TRUSTED: Final = AttKey(name='trusted')

TYPE: Final = AttKey(name='type')

UNIQUE_ID: Final = AttKey(name='UNIQUE_ID')

UNIT: Final = AttKey(name='unit')

UNPARSE_AVOID: Final = AttKey(name='unparseAvoid')

UPDATE: Final = AttKey(name='update')

USER_LIST: Final = AttKey(name='userList')

WRAP_ELEMENT: Final = AttKey(name='wrapElement')

classmethod keys() → FrozenDict[str, AttKey]

class ColorType

Bases: AttType[Color]

from_dict(obj: Any) → Color

parse(text: str) → Color

to_dict(value: Color) → str

unparse(value: Color) → str

class ColorsType

Bases: AttType[tuple[Color, …]]

from_dict(obj: Any) → tuple[Color, ...]

parse(text: str) → tuple[Color, ...]

to_dict(value: tuple[Color, ...]) → str

unparse(value: tuple[Color, ...]) → str

final class Format(tokens: 'Iterable[str]' = ())

Bases: object

classmethod parse(s: str) → Format

tokens: tuple[str, ...]

unparse() → str

class FormatType

Bases: AttType[Format]

from_dict(obj: Any) → Format

parse(text: str) → Format

to_dict(value: Format) → Any

unparse(value: Format) → str

class IntType

Bases: AttType[int]

from_dict(obj: Any) → int

parse(text: str) → int

to_dict(value: int) → str

unparse(value: int) → str

final class KAtt(entries: 'Iterable[AttEntry]' = ())

Bases: KAst, Mapping[AttKey, Any]

atts: FrozenDict[AttKey, Any]

discard(keys: Container[AttKey]) → KAtt

drop_source() → KAtt

entries() → Iterator[AttEntry]

classmethod from_dict(d: Mapping[str, Any]) → KAtt

get(key: AttKey[T], /) → T | None

get(key: AttKey[T], /, default: U) → T | U

classmethod parse(d: Mapping[str, str]) → KAtt

property pretty: str

to_dict() → dict[str, Any]

update(entries: Iterable[AttEntry]) → KAtt

class LocationType

Bases: AttType[tuple[int, int, int, int]]

from_dict(obj: Any) → tuple[int, int, int, int]

parse(text: str) → tuple[int, int, int, int]

to_dict(value: tuple[int, int, int, int]) → Any

unparse(value: tuple[int, int, int, int]) → str

class NoneType

Bases: AttType[None]

from_dict(obj: Any) → None

parse(text: str) → None

to_dict(value: None) → Any

unparse(value: None) → None

class OptionalType(value_type: AttType[T])

Bases: Generic[T], AttType[T | None]

from_dict(obj: Any) → T | None

parse(text: str) → T | None

to_dict(value: T | None) → Any

unparse(value: T | None) → str | None

class PathType

Bases: AttType[Path]

from_dict(obj: Any) → Path

parse(text: str) → Path

to_dict(value: Path) → Any

unparse(value: Path) → str

class StrType

Bases: AttType[str]

from_dict(obj: Any) → str

parse(text: str) → str

to_dict(value: str) → Any

unparse(value: str) → str

class WithKAtt

Bases: ABC

att: KAtt

abstract let_att(att: KAtt) → W

map_att(f: Callable[[KAtt], KAtt]) → W

update_atts(entries: Iterable[AttEntry]) → W