pyk.kast.att module

class AnyType[source]

Bases: AttType[Any]

from_dict(obj: Any) → Any[source]
pretty(value: Any) → str[source]
to_dict(value: Any) → Any[source]
final class AttEntry(key: 'AttKey[T]', value: 'T')[source]

Bases: Generic[T]

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

Bases: Generic[T]

name: str
type: AttType[T]
class AttType[source]

Bases: Generic[T], ABC

abstract from_dict(obj: Any) → T[source]
abstract pretty(value: T) → str | None[source]
abstract to_dict(value: T) → Any[source]
class Atts[source]

Bases: object

ALIAS: Final = AttKey(name='alias')
ALIAS_REC: Final = AttKey(name='alias-rec')
ANYWHERE: Final = AttKey(name='anywhere')
ASSOC: Final = AttKey(name='assoc')
BRACKET: Final = AttKey(name='bracket')
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')
CONSTRUCTOR: Final = AttKey(name='constructor')
DEPENDS: Final = AttKey(name='depends')
DIGEST: Final = AttKey(name='digest')
ELEMENT: Final = AttKey(name='element')
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')
KLABEL: Final = AttKey(name='klabel')
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')
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')
RIGHT: Final = AttKey(name='right')
SEQSTRICT: Final = AttKey(name='seqstrict')
SIMPLIFICATION: Final = AttKey(name='simplification')
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')
TERMINALS: Final = AttKey(name='terminals')
TOKEN: Final = AttKey(name='token')
TOTAL: Final = AttKey(name='total')
TRUSTED: Final = AttKey(name='trusted')
UNIQUE_ID: Final = AttKey(name='UNIQUE_ID')
UNIT: Final = AttKey(name='unit')
UNPARSE_AVOID: Final = AttKey(name='unparseAvoid')
USER_LIST: Final = AttKey(name='userList')
WRAP_ELEMENT: Final = AttKey(name='wrapElement')
classmethod keys() → FrozenDict[str, AttKey][source]
final class Format(tokens: 'Iterable[str]' = ())[source]

Bases: object

classmethod parse(s: str) → Format[source]
tokens: tuple[str, ...]
unparse() → str[source]
class FormatType[source]

Bases: AttType[Format]

from_dict(obj: Any) → Format[source]
pretty(value: Format) → str[source]
to_dict(value: Format) → Any[source]
class IntType[source]

Bases: AttType[int]

from_dict(obj: Any) → int[source]
pretty(value: int) → str[source]
to_dict(value: int) → str[source]
final class KAtt(entries: 'Iterable[AttEntry]' = ())[source]

Bases: KAst, Mapping[AttKey, Any]

atts: FrozenDict[AttKey, Any]
discard(keys: Container[AttKey]) → KAtt[source]
drop_source() → KAtt[source]
entries() → Iterator[AttEntry][source]
classmethod from_dict(d: Mapping[str, Any]) → KAtt[source]
get(key: AttKey[T], /) → T | None[source]
get(key: AttKey[T], /, default: U) → T | U
property pretty: str
to_dict() → dict[str, Any][source]
update(entries: Iterable[AttEntry]) → KAtt[source]
class LocationType[source]

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

from_dict(obj: Any) → tuple[int, int, int, int][source]
pretty(value: tuple[int, int, int, int]) → str[source]
to_dict(value: tuple[int, int, int, int]) → Any[source]
class NoneType[source]

Bases: AttType[None]

from_dict(obj: Any) → None[source]
pretty(value: None) → None[source]
to_dict(value: None) → Any[source]
class OptionalType(value_type: AttType[T])[source]

Bases: Generic[T], AttType[Optional[T]]

from_dict(obj: Any) → T | None[source]
pretty(value: T | None) → str | None[source]
to_dict(value: T | None) → Any[source]
class PathType[source]

Bases: AttType[Path]

from_dict(obj: Any) → Path[source]
pretty(value: Path) → str[source]
to_dict(value: Path) → Any[source]
class StrType[source]

Bases: AttType[str]

from_dict(obj: Any) → str[source]
pretty(value: str) → str[source]
to_dict(value: str) → Any[source]
class WithKAtt[source]

Bases: ABC

att: KAtt
abstract let_att(att: KAtt) → W[source]
map_att(f: Callable[[KAtt], KAtt]) → W[source]
update_atts(entries: Iterable[AttEntry]) → W[source]