ironic.common.kernel_parameter_parser.kernel_parameter_parser module

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.AbstractBasicLexer(conf: LexerConf, comparator=None)

Bases: Lexer

lex(state: LexerState, parser_state: Any) → Iterator[Token]

abstractmethod next_token(lex_state: LexerState, parser_state: Any = None) → Token

terminals_by_name: Dict[str, TerminalDef]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Action(name)

Bases: object

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.AmbiguousExpander(to_expand, tree_class, node_builder)

Bases: object

__call__(children)

Call self as a function.

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.AmbiguousIntermediateExpander(tree_class, node_builder)

Bases: object

__call__(children)

Call self as a function.

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.BasicLexer(conf: LexerConf, comparator=None)

Bases: AbstractBasicLexer

callback: Dict[str, Callable[[Token], Token]]

ignore_types: FrozenSet[str]

match(text, pos)

newline_types: FrozenSet[str]

next_token(lex_state: LexerState, parser_state: Any = None) → Token

re: ModuleType

property scanner: Scanner

terminals: Collection[TerminalDef]

user_callbacks: Dict[str, Callable[[Token], Token]]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.CallChain(callback1, callback2, cond)

Bases: object

__call__(t)

Call self as a function.

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ChildFilter(to_include, append_none, node_builder)

Bases: object

__call__(children)

Call self as a function.

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ChildFilterLALR(to_include, append_none, node_builder)

Bases: ChildFilter

__call__(children)

Call self as a function.

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ChildFilterLALR_NoPlaceholders(to_include, node_builder)

Bases: ChildFilter

__call__(children)

Call self as a function.

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.ConfigurationError

Bases: LarkError, ValueError

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ContextualLexer(conf: LexerConf, states: Dict[int, Collection[str]], always_accept: Collection[str] = ())

Bases: Lexer

class BasicLexer(conf: LexerConf, comparator=None)

Bases: AbstractBasicLexer

callback: Dict[str, Callable[[Token], Token]]

ignore_types: FrozenSet[str]

match(text, pos)

newline_types: FrozenSet[str]

next_token(lex_state: LexerState, parser_state: Any = None) → Token

re: ModuleType

property scanner: Scanner

terminals: Collection[TerminalDef]

terminals_by_name: Dict[str, TerminalDef]

user_callbacks: Dict[str, Callable[[Token], Token]]

lex(lexer_state: LexerState, parser_state: ParserState) → Iterator[Token]

lexers: Dict[int, AbstractBasicLexer]

root_lexer: AbstractBasicLexer

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.DedentError

Bases: LarkError

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ExpandSingleChild(node_builder)

Bases: object

__call__(children)

Call self as a function.

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.GrammarError

Bases: LarkError

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ImmutableInteractiveParser(parser, parser_state: ParserState, lexer_thread: LexerThread)

Bases: InteractiveParser

as_mutable()

exhaust_lexer()

feed_token(token)

result = None

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Indenter

Bases: PostLex, ABC

abstract property CLOSE_PAREN_types: List[str]

abstract property DEDENT_type: str

abstract property INDENT_type: str

abstract property NL_type: str

abstract property OPEN_PAREN_types: List[str]

property always_accept

Built-in immutable sequence.

If no argument is given, the constructor returns an empty tuple. If iterable is specified the tuple is initialized from iterable’s items.

If the argument is a tuple, the return value is the same object.

handle_NL(token: Token) → Iterator[Token]

indent_level: List[int]

paren_level: int

process(stream)

abstract property tab_len: int

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.InlineTransformer(visit_tokens: bool = True)

Bases: Transformer

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.IntParseTable(states, start_states, end_states)

Bases: ParseTableBase[int]

classmethod from_ParseTable(parse_table: ParseTable)

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.InteractiveParser(parser, parser_state: ParserState, lexer_thread: LexerThread)

Bases: object

accepts()

as_immutable()

choices()

copy(deepcopy_values=True)

exhaust_lexer() → List[Token]

feed_eof(last_token=None)

feed_token(token: Token)

iter_parse() → Iterator[Token]

property lexer_state: LexerThread

pretty()

resume_parse()

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Interpreter

Bases: _Decoratable, ABC, Generic[_Leaf_T, _Return_T]

visit(tree: Tree[_Leaf_T]) → _Return_T

visit_children(tree: Tree[_Leaf_T]) → List

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.LALR_Parser(parser_conf: ParserConf, debug: bool = False, strict: bool = False)

Bases: Serialize

classmethod deserialize(data, memo, callbacks, debug=False)

parse(lexer, start, on_error=None)

parse_interactive(lexer: LexerThread, start: str)

serialize(memo: Any = None) → Dict[str, Any]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Lark(grammar: Grammar | str | IO[str], **options)

Bases: Serialize

get_terminal(name: str) → TerminalDef

grammar: Grammar

lex(text: AnyStr | TextSlice, dont_ignore: bool = False) → Iterator[Token]

lexer: Lexer

classmethod load(f) → _T

classmethod open(grammar_filename: str, rel_to: str | None = None, **options) → _T

classmethod open_from_package(package: str, grammar_path: str, search_paths: Sequence[str] = [''], **options) → _T

options: LarkOptions

parse(text: AnyStr | TextSlice | Any, start: str | None = None, on_error: Callable[[UnexpectedInput], bool] | None = None) → ParseTree

parse_interactive(text: AnyStr | TextSlice | Any | None = None, start: str | None = None) → InteractiveParser

parser: ParsingFrontend

save(f, exclude_options: Collection[str] = ()) → None

source_grammar: str

source_path: str

terminals: Collection[TerminalDef]

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.LarkError

Bases: Exception

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.LarkOptions(options_dict: Dict[str, Any])

Bases: Serialize

OPTIONS_DOC = '\n    **===  General Options  ===**\n\n    start\n            The start symbol. Either a string, or a list of strings for multiple possible starts (Default: "start")\n    debug\n            Display debug information and extra warnings. Use only when debugging (Default: ``False``)\n            When used with Earley, it generates a forest graph as "sppf.png", if \'dot\' is installed.\n    strict\n            Throw an exception on any potential ambiguity, including shift/reduce conflicts, and regex collisions.\n    transformer\n            Applies the transformer to every parse tree (equivalent to applying it after the parse, but faster)\n    propagate_positions\n            Propagates positional attributes into the \'meta\' attribute of all tree branches.\n            Sets attributes: (line, column, end_line, end_column, start_pos, end_pos,\n                              container_line, container_column, container_end_line, container_end_column)\n            Accepts ``False``, ``True``, or a callable, which will filter which nodes to ignore when propagating.\n    maybe_placeholders\n            When ``True``, the ``[]`` operator returns ``None`` when not matched.\n            When ``False``,  ``[]`` behaves like the ``?`` operator, and returns no value at all.\n            (default= ``True``)\n    cache\n            Cache the results of the Lark grammar analysis, for x2 to x3 faster loading. LALR only for now.\n\n            - When ``False``, does nothing (default)\n            - When ``True``, caches to a temporary file in the local directory\n            - When given a string, caches to the path pointed by the string\n    cache_grammar\n            For use with ``cache`` option. When ``True``, the unanalyzed grammar is also included in the cache.\n            Useful for classes that require the ``Lark.grammar`` to be present (e.g. Reconstructor).\n            (default= ``False``)\n    regex\n            When True, uses the ``regex`` module instead of the stdlib ``re``.\n    g_regex_flags\n            Flags that are applied to all terminals (both regex and strings)\n    keep_all_tokens\n            Prevent the tree builder from automagically removing "punctuation" tokens (Default: ``False``)\n    tree_class\n            Lark will produce trees comprised of instances of this class instead of the default ``lark.Tree``.\n\n    **=== Algorithm Options ===**\n\n    parser\n            Decides which parser engine to use. Accepts "earley" or "lalr". (Default: "earley").\n            (there is also a "cyk" option for legacy)\n    lexer\n            Decides whether or not to use a lexer stage\n\n            - "auto" (default): Choose for me based on the parser\n            - "basic": Use a basic lexer\n            - "contextual": Stronger lexer (only works with parser="lalr")\n            - "dynamic": Flexible and powerful (only with parser="earley")\n            - "dynamic_complete": Same as dynamic, but tries *every* variation of tokenizing possible.\n    ambiguity\n            Decides how to handle ambiguity in the parse. Only relevant if parser="earley"\n\n            - "resolve": The parser will automatically choose the simplest derivation\n              (it chooses consistently: greedy for tokens, non-greedy for rules)\n            - "explicit": The parser will return all derivations wrapped in "_ambig" tree nodes (i.e. a forest).\n            - "forest": The parser will return the root of the shared packed parse forest.\n\n    **=== Misc. / Domain Specific Options ===**\n\n    postlex\n            Lexer post-processing (Default: ``None``) Only works with the basic and contextual lexers.\n    priority\n            How priorities should be evaluated - "auto", ``None``, "normal", "invert" (Default: "auto")\n    lexer_callbacks\n            Dictionary of callbacks for the lexer. May alter tokens during lexing. Use with caution.\n    use_bytes\n            Accept an input of type ``bytes`` instead of ``str``.\n    ordered_sets\n            Should Earley use ordered-sets to achieve stable output (~10% slower than regular sets. Default: True)\n    edit_terminals\n            A callback for editing the terminals before parse.\n    import_paths\n            A List of either paths or loader functions to specify from where grammars are imported\n    source_path\n            Override the source of from where the grammar was loaded. Useful for relative imports and unconventional grammar loading\n    **=== End of Options ===**\n    '

ambiguity: Literal['auto', 'resolve', 'explicit', 'forest']

cache: bool | str

cache_grammar: bool

debug: bool

classmethod deserialize(data: Dict[str, Any], memo: Dict[int, TerminalDef | Rule]) → LarkOptions

edit_terminals: Callable[[TerminalDef], TerminalDef] | None

g_regex_flags: int

import_paths: List[str | Callable[[None | str | PackageResource, str], Tuple[str, str]]]

keep_all_tokens: bool

lexer: Literal['auto', 'basic', 'contextual', 'dynamic', 'dynamic_complete'] | Type[Lexer]

lexer_callbacks: Dict[str, Callable[[Token], Token]]

maybe_placeholders: bool

ordered_sets: bool

parser: Literal['earley', 'lalr', 'cyk', 'auto']

postlex: PostLex | None

priority: Literal['auto', 'normal', 'invert'] | None

propagate_positions: bool | str

regex: bool

serialize(memo=None) → Dict[str, Any]

source_path: str | None

start: List[str]

strict: bool

transformer: Transformer | None

tree_class: Callable[[str, List], Any] | None

use_bytes: bool

ironic.common.kernel_parameter_parser.kernel_parameter_parser.Lark_StandAlone(**kwargs)

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.LexError

Bases: LarkError

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Lexer

Bases: ABC

abstractmethod lex(lexer_state: LexerState, parser_state: Any) → Iterator[Token]

make_lexer_state(text: str)

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.LexerConf(terminals: Collection[TerminalDef], re_module: ModuleType, ignore: Collection[str] = (), postlex: PostLex | None = None, callbacks: Dict[str, Callable[[Token], Token]] | None = None, g_regex_flags: int = 0, skip_validation: bool = False, use_bytes: bool = False, strict: bool = False)

Bases: Serialize

callbacks: Dict[str, Callable[[Token], Token]]

g_regex_flags: int

ignore: Collection[str]

lexer_type: Literal['auto', 'basic', 'contextual', 'dynamic', 'dynamic_complete'] | Type[Lexer] | None

postlex: PostLex | None

re_module: ModuleType

skip_validation: bool

strict: bool

terminals: Collection[TerminalDef]

use_bytes: bool

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.LexerState(text: TextSlice, line_ctr: LineCounter | None = None, last_token: Token | None = None)

Bases: object

last_token: Token | None

line_ctr: LineCounter

text: TextSlice

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.LexerThread(lexer: Lexer, lexer_state: LexerState | None)

Bases: object

classmethod from_custom_input(lexer: Lexer, text: Any) → LexerThread

classmethod from_text(lexer: Lexer, text_or_slice: AnyStr | TextSlice) → LexerThread

lex(parser_state)

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.LineCounter(newline_char)

Bases: object

char_pos

column

feed(token: AnyStr | TextSlice, test_newline=True)

line

line_start_pos

newline_char

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Meta

Bases: object

column: int

empty: bool

end_column: int

end_line: int

end_pos: int

line: int

match_tree: bool

orig_expansion: List[TerminalDef]

start_pos: int

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.MissingVariableError

Bases: LarkError

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.NonTerminal(name: str)

Bases: Symbol

is_term: ClassVar[bool] = False

name: str

serialize(memo=None) → Dict[str, Any]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ParseConf(parse_table: ParseTableBase[StateT], callbacks: Dict[str, Callable], start: str)

Bases: Generic[StateT]

callbacks: Dict[str, Callable]

end_state: StateT

parse_table: ParseTableBase[StateT]

start: str

start_state: StateT

states: Dict[StateT, Dict[str, tuple]]

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.ParseError

Bases: LarkError

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ParseTable(states, start_states, end_states)

Bases: ParseTableBase[State]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ParseTableBase(states, start_states, end_states)

Bases: Generic[StateT]

classmethod deserialize(data, memo)

end_states: Dict[str, StateT]

serialize(memo)

start_states: Dict[str, StateT]

states: Dict[StateT, Dict[str, Tuple]]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ParseTreeBuilder(rules, tree_class, propagate_positions=False, ambiguous=False, maybe_placeholders=False)

Bases: object

create_callback(transformer=None)

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ParserConf(rules: List[Rule], callbacks: Dict[str, Callable], start: List[str])

Bases: Serialize

callbacks: Dict[str, Callable]

parser_type: Literal['earley', 'lalr', 'cyk', 'auto']

rules: List[Rule]

start: List[str]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ParserState(parse_conf: ParseConf[StateT], lexer: LexerThread, state_stack=None, value_stack=None)

Bases: Generic[StateT]

copy(deepcopy_values=True) → ParserState[StateT]

feed_token(token: Token, is_end=False) → Any

lexer: LexerThread

parse_conf: ParseConf[StateT]

property position: StateT

state_stack: List[StateT]

value_stack: list

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.ParsingFrontend(lexer_conf: LexerConf, parser_conf: ParserConf, options, parser=None)

Bases: Serialize

lexer_conf: LexerConf

options: Any

parse(text: AnyStr | TextSlice | Any | None, start=None, on_error=None)

parse_interactive(text: AnyStr | TextSlice | None = None, start=None)

parser_conf: ParserConf

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Pattern(value: str, flags: Collection[str] = (), raw: str | None = None)

Bases: Serialize, ABC

flags: Collection[str]

abstract property max_width: int

abstract property min_width: int

raw: str | None

abstractmethod to_regexp() → str

type: ClassVar[str]

value: str

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.PatternRE(value: str, flags: Collection[str] = (), raw: str | None = None)

Bases: Pattern

property max_width: int

property min_width: int

to_regexp() → str

type: ClassVar[str] = 're'

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.PatternStr(value: str, flags: Collection[str] = (), raw: str | None = None)

Bases: Pattern

property max_width: int

property min_width: int

to_regexp() → str

type: ClassVar[str] = 'str'

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.PostLex

Bases: ABC

always_accept: Iterable[str] = ()

abstractmethod process(stream: Iterator[Token]) → Iterator[Token]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.PostLexConnector(lexer, postlexer)

Bases: object

lex(lexer_state, parser_state)

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.PropagatePositions(node_builder, node_filter=None)

Bases: object

__call__(children)

Call self as a function.

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.PythonIndenter

Bases: Indenter

CLOSE_PAREN_types = ['RPAR', 'RSQB', 'RBRACE']

DEDENT_type = '_DEDENT'

INDENT_type = '_INDENT'

NL_type = '_NEWLINE'

OPEN_PAREN_types = ['LPAR', 'LSQB', 'LBRACE']

tab_len = 8

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Rule(origin: NonTerminal, expansion: Sequence[Symbol], order: int = 0, alias: str | None = None, options: RuleOptions | None = None)

Bases: Serialize

alias: str | None

expansion: Sequence[Symbol]

options: RuleOptions

order: int

origin: NonTerminal

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.RuleOptions(keep_all_tokens: bool = False, expand1: bool = False, priority: int | None = None, template_source: str | None = None, empty_indices: Tuple[bool, ...] = ())

Bases: Serialize

empty_indices: Tuple[bool, ...]

expand1: bool

keep_all_tokens: bool

priority: int | None

template_source: str | None

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Scanner(terminals, g_regex_flags, re_, use_bytes)

Bases: object

fullmatch(text: str) → str | None

match(text: TextSlice, pos)

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Serialize

Bases: object

classmethod deserialize(data: Dict[str, Any], memo: Dict[int, Any]) → _T

memo_serialize(types_to_memoize: List) → Any

serialize(memo=None) → Dict[str, Any]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.SerializeMemoizer(types_to_memoize: List)

Bases: Serialize

classmethod deserialize(data: Dict[int, Any], namespace: Dict[str, Any], memo: Dict[Any, Any]) → Dict[int, Any]

in_types(value: Serialize) → bool

serialize() → Dict[int, Any]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Symbol(name: str)

Bases: Serialize

property fullrepr

is_term: ClassVar[bool] = NotImplemented

name: str

renamed(f)

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Terminal(name: str, filter_out: bool = False)

Bases: Symbol

property fullrepr

is_term: ClassVar[bool] = True

name: str

renamed(f)

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.TerminalDef(name: str, pattern: Pattern, priority: int = 0)

Bases: Serialize

name: str

pattern: Pattern

priority: int

user_repr() → str

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.TextSlice(text: AnyStr, start: int, end: int)

Bases: Generic

classmethod cast_from(text: AnyStr | TextSlice) → TextSlice

count(substr: AnyStr)

end: int

is_complete_text()

rindex(substr: AnyStr)

start: int

text: AnyStr

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Token(type: str, value: Any, start_pos: int | None = None, line: int | None = None, column: int | None = None, end_line: int | None = None, end_column: int | None = None, end_pos: int | None = None)

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Token(type_: str, value: Any, start_pos: int | None = None, line: int | None = None, column: int | None = None, end_line: int | None = None, end_column: int | None = None, end_pos: int | None = None)

Bases: str

column: int | None

end_column: int | None

end_line: int | None

end_pos: int | None

line: int | None

classmethod new_borrow_pos(type_: str, value: Any, borrow_t: Token) → _T

start_pos: int | None

type: str

update(type: str | None = None, value: Any | None = None) → Token

update(type_: str | None = None, value: Any | None = None) → Token

value: Any

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Transformer(visit_tokens: bool = True)

Bases: _Decoratable, ABC, Generic[_Leaf_T, _Return_T]

transform(tree: Tree[_Leaf_T]) → _Return_T

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.TransformerChain(*transformers: Transformer | TransformerChain)

Bases: Generic[_Leaf_T, _Return_T]

transform(tree: Tree[_Leaf_T]) → _Return_T

transformers: Tuple[Transformer | TransformerChain, ...]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Transformer_InPlace(visit_tokens: bool = True)

Bases: Transformer

transform(tree: Tree[_Leaf_T]) → _Return_T

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Transformer_InPlaceRecursive(visit_tokens: bool = True)

Bases: Transformer

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Transformer_NonRecursive(visit_tokens: bool = True)

Bases: Transformer

transform(tree: Tree[_Leaf_T]) → _Return_T

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Tree(data: str, children: List[_Leaf_T | Tree[_Leaf_T]], meta: Meta | None = None)

Bases: Generic[_Leaf_T]

children: List[_Leaf_T | Tree[_Leaf_T]]

data: str

find_data(data: str) → Iterator[Tree[_Leaf_T]]

find_pred(pred: Callable[[Tree[_Leaf_T]], bool]) → Iterator[Tree[_Leaf_T]]

iter_subtrees() → Iterator[Tree[_Leaf_T]]

iter_subtrees_topdown()

property meta: Meta

pretty(indent_str: str = '  ') → str

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.UnexpectedCharacters(seq, lex_pos, line, column, allowed=None, considered_tokens=None, state=None, token_history=None, terminals_by_name=None, considered_rules=None)

Bases: LexError, UnexpectedInput

allowed: Set[str]

considered_tokens: Set[Any]

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.UnexpectedEOF(expected, state=None, terminals_by_name=None)

Bases: ParseError, UnexpectedInput

expected: List[Token]

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.UnexpectedInput

Bases: LarkError

column: int

get_context(text: str, span: int = 40) → str

interactive_parser: InteractiveParser

line: int

match_examples(parse_fn: Callable[[str], Tree], examples: Mapping[T, Iterable[str]] | Iterable[Tuple[T, Iterable[str]]], token_type_match_fallback: bool = False, use_accepts: bool = True) → T | None

pos_in_stream = None

state: Any

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.UnexpectedToken(token, expected, considered_rules=None, state=None, interactive_parser=None, terminals_by_name=None, token_history=None)

Bases: ParseError, UnexpectedInput

property accepts: Set[str]

considered_rules: Set[str]

expected: Set[str]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.UnlessCallback(scanner: Scanner)

Bases: object

__call__(t: Token)

Call self as a function.

exception ironic.common.kernel_parameter_parser.kernel_parameter_parser.VisitError(rule, obj, orig_exc)

Bases: LarkError

obj: Tree | Token

orig_exc: Exception

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Visitor

Bases: VisitorBase, ABC, Generic[_Leaf_T]

visit(tree: Tree[_Leaf_T]) → Tree[_Leaf_T]

visit_topdown(tree: Tree[_Leaf_T]) → Tree[_Leaf_T]

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.VisitorBase

Bases: object

class ironic.common.kernel_parameter_parser.kernel_parameter_parser.Visitor_Recursive

Bases: VisitorBase, Generic[_Leaf_T]

visit(tree: Tree[_Leaf_T]) → Tree[_Leaf_T]

visit_topdown(tree: Tree[_Leaf_T]) → Tree[_Leaf_T]

ironic.common.kernel_parameter_parser.kernel_parameter_parser.apply_visit_wrapper(func, name, wrapper)

ironic.common.kernel_parameter_parser.kernel_parameter_parser.assert_config(value, options: Collection, msg='Got %r, expected one of %s')

ironic.common.kernel_parameter_parser.kernel_parameter_parser.classify(seq: Iterable, key: Callable | None = None, value: Callable | None = None) → Dict

ironic.common.kernel_parameter_parser.kernel_parameter_parser.create_basic_lexer(lexer_conf, parser, postlex, options) → BasicLexer

ironic.common.kernel_parameter_parser.kernel_parameter_parser.create_contextual_lexer(lexer_conf: LexerConf, parser, postlex, options) → ContextualLexer

ironic.common.kernel_parameter_parser.kernel_parameter_parser.create_lalr_parser(lexer_conf: LexerConf, parser_conf: ParserConf, options=None) → LALR_Parser

ironic.common.kernel_parameter_parser.kernel_parameter_parser.get_regexp_width(expr: str) → Tuple[int, int] | List[int]

ironic.common.kernel_parameter_parser.kernel_parameter_parser.inplace_transformer(func)

ironic.common.kernel_parameter_parser.kernel_parameter_parser.make_propagate_positions(option)

ironic.common.kernel_parameter_parser.kernel_parameter_parser.maybe_create_ambiguous_expander(tree_class, expansion, keep_all_tokens)

ironic.common.kernel_parameter_parser.kernel_parameter_parser.maybe_create_child_filter(expansion, keep_all_tokens, ambiguous, _empty_indices: List[bool])

ironic.common.kernel_parameter_parser.kernel_parameter_parser.merge_transformers(base_transformer=None, **transformers_to_merge)

ironic.common.kernel_parameter_parser.kernel_parameter_parser.v_args(inline: bool = False, meta: bool = False, tree: bool = False, wrapper: Callable | None = None) → Callable[[Callable[[...], _Return_T] | type], Callable[[...], _Return_T] | type]

ironic.common.kernel_parameter_parser.kernel_parameter_parser.visit_children_decor(func: Callable[[Type[Interpreter], _Return_T], _R]) → Callable[[Type[Interpreter], _Return_T], _R]