API Reference¶

This reference is generated automatically from docstrings via mkdocstrings. See the Quickstart for a narrative walkthrough.

Functions¶

Public Python API: sample -> template, records, ast, canonical/readable DSL.

`DSLResult(ast=TemplateAST(), canonical='', readable='', recognizers=list(), reason='', ready=False)` `dataclass` ¶

Bases: Serializable

Result of compiling a template into ast/canonical/readable/recognizers.

Attributes:

Name	Type	Description
`ast`	`TemplateAST`	The parsed template AST (an empty `TemplateAST()` on failure).
`canonical`	`str`	The canonical (regex-expanded) TextFSM template.
`readable`	`str`	The human-readable DSL form of the template.
`recognizers`	`List[str]`	Regex patterns that detect this block of text.
`reason`	`str`	Failure reason if `ready` is False; "" on success.
`ready`	`bool`	True if compiling succeeded.

`LLMResult(template='', records=list(), variables=dict(), handling=list(), reason='', ready=False)` `dataclass` ¶

Bases: Serializable

Result of asking an LLM to turn a sample into a template.

Attributes:

Name	Type	Description
`template`	`str`	The LLM-authored TextFSM template ("" if generation failed).
`records`	`List[Dict[str, str]]`	Records the LLM claims to have parsed from the sample.
`variables`	`Dict[str, str]`	Per-variable explanations the LLM provided.
`handling`	`List[str]`	Notes on how the LLM handled ambiguous or edge-case lines.
`reason`	`str`	Failure reason if `ready` is False; "" on success.
`ready`	`bool`	True if generation succeeded.

`ValidationResult(data=None, args=None, kwargs=None, reason='', ready=False)` `dataclass` ¶

Bases: Serializable

Generic pass/fail validation outcome.

Attributes:

Name	Type	Description
`data`	`Optional[Any]`	The value that was validated (e.g. the template string, for `validate_template()`).
`args`	`Optional[list]`	Reserved for callers that validate against positional inputs; unused by `validate_template()`.
`kwargs`	`Optional[dict]`	Reserved for callers that validate against keyword inputs; unused by `validate_template()`.
`reason`	`str`	Failure reason if `ready` is False; "" on success.
`ready`	`bool`	True if validation succeeded.

`DeliveryOutput(mode, output='', passed=False, error='')` `dataclass` ¶

Formatted result of running the full generate + compile pipeline.

Attributes:

Name	Type	Description
`mode`	`DeliveryMode`	The verbosity mode `output` was formatted for.
`output`	`str`	The formatted text (or JSON, if `as_json=True` was passed).
`passed`	`bool`	True if the pipeline succeeded.
`error`	`str`	Failure detail if `passed` is False; "" on success.

`TemplateAST(values=list(), states=list())` `dataclass` ¶

Parsed representation of a TextFSM/DSL template.

Attributes:

Name	Type	Description
`values`	`List[ValueNode]`	The `Value` declarations parsed from the template.
`states`	`List[StateNode]`	The states (each with its rules) parsed from the template.

`parse_to_dicts(template, sample)` ¶

Parse sample with a TextFSM template, returning rows as dicts.

Source code in textfsm_ai/core/utils/template.py

def parse_to_dicts(template: str, sample: str) -> List[Dict[str, str]]:
    """Parse `sample` with a TextFSM `template`, returning rows as dicts."""
    parser = _create_parser(template)
    return parser.ParseTextToDicts(sample)

`parse_to_lists(template, sample)` ¶

Parse sample with a TextFSM template, returning rows of raw values.

Source code in textfsm_ai/core/utils/template.py

def parse_to_lists(template: str, sample: str) -> List[List[str]]:
    """Parse `sample` with a TextFSM `template`, returning rows of raw values."""
    parser = _create_parser(template)
    return parser.ParseText(sample)

`validate_template(template)` ¶

Validate that a TextFSM template is non-empty and syntactically valid.

Source code in textfsm_ai/core/utils/template.py

def validate_template(template: str) -> ValidationResult:
    """Validate that a TextFSM template is non-empty and syntactically valid."""

    text = template.strip()
    if not text:
        return ValidationResult(
            data=template,
            reason="template_empty",
            ready=False,
        )

    try:
        _create_parser(text)
        return ValidationResult(data=template, ready=True)
    except Exception as ex:
        return ValidationResult(
            data=template,
            reason=f"template_syntax_error: {type(ex).__name__}: {ex}",
            ready=False,
        )

`generate(sample, provider, api_key, model, *, endpoint='', api_version='', region='', project='', compartment_id='', max_retries=1, **kwargs)` ¶

Ask an LLM to turn a sample into a template, parsed records, variable explanations, and handling notes. Never raises.