Create a tuple of TemplateElement from a tuple of LexedElement. This adds slices in the templated file to the original lexed elements

Match delimited sequences. To achieve this we flip flop between looking for content and looking for delimiters. Individual elements o

Match when the position is preceded by the configured keywords. Scans backward from ``idx`` through non-code and meta segments, check

Match a list of segments against this segment. Note: Match for segments is done in the ABSTRACT. When dealing with concrete then we'r

Return a truthy match result if the file is ignored.

Perform a lookup in a nested dict object. Lookups are performed by iterating keys. >>> nested_dict_get( ... {"a": {"b": "c"}}, ("a",

Set a value in a nested dict object. Lookups are performed by iterating keys. >>> d = {"a": {"b": "c"}} >>> nested_dict_set(d, ("a", "b")

Count the number of violations. Optionally now with filters.

Parse command line arguments.

Parse the INSTRUCTIONS block. Returns a list of instruction dictionaries. Extracts variant, child indices, counts, flags, parse mode, and com

Parse a Rust array of numbers.

Parse a Rust array of strings.

Parse SQL with Python parser and collect metrics.

Parse SQL with Rust parser and collect metrics.

Parse with Rust, returning None if not available.

Parse a SQL file using sqlfluff and measure timing. Args: sql_file: Path to SQL file use_rust: Whether to use Rust parser

Print side-by-side comparison of metrics.

Output the residual error totals for the file. Args: total_errors (int): The total number of templating & parsing errors.

Used by human formatting during the `sqlfluff parse` command.

Print table statistics.

Print Rust parser statistics.

Given the existing spacing, extract information and do basic pruning.

Extended version of `process` which returns multiple variants. Unless explicitly defined, this simply yields the result of .process().

Process a string and return one or more variant renderings. Note that the arguments are enforced as keywords because Templaters can h

Set up the progress bar (if it's not already set up). Args: last_char (:obj:`int`): The templated character position of the

Store a match in the cache for later retrieval.

Iterate raw segments, return normalized value.

Returns a function that determines if segment matches one of the raw inputs.

Reflow line breaks within a sequence. Initially this only _moves_ existing segments around line breaks (e.g. for operators and commas), b

Reflow line breaks within a sequence. Initially this only _moves_ existing segments around line breaks (e.g. for operators and commas), b

Filter a list of lint errors, removing those from the templated slices.

Convert RST code-block directive to Markdown code fence. Args: rst_text: Text potentially containing RST code-block directives Retur

Convert RST docstring to Markdown. Args: rst_text: RST-formatted text Returns: Markdown-formatted text

Convert RST docstring to Markdown. Args: rst_text: RST-formatted text Returns: Markdown-formatted text

Fetch the code of the rule which cause this error.

Fetch the name of the rule which cause this error.

Generate a rule reference map for looking up rules. Generate the master reference map. The priority order is: codes > names > groups

Test that a rule passes/fails on a set of test_cases. Optionally, also test the fixed string if provided in the test case.

Run linting on the specified list of files.

Convert a segment class name to a token name.

Reorder fnames to process dependent files first. This avoids errors when an ephemeral model is processed before use.

Heuristic for legit values containing comma.

Check if the matcher supports uppercase hash matching route. The TypedParser segment does not support matching against raw strings, b

Return simple options for this matcher. Because string matchers are not case sensitive we can just return the template here.

Return simple options for this matcher. Because string matchers are not case sensitive we can just return the templates here.

Does this matcher support a uppercase hash matching route? Regex segment does NOT for now. We might need to later for efficiency.

Does this matcher support a uppercase hash matching route? Sequence does provide this, as long as the *first* non-optional element do

Slice the file to determine regions where we can fix.

Return hashable source signature for deduplication.

r"""Converts a colon separated string. The final value in the string is handled separately the other others. >>> split_colon_separated_string

Split a string into lines based on whitespace. For short strings the functionality is trivial. >>> split_string_on_spaces("abc") ['abc']

Pretty print a match for debugging.

Generate a summary for display.

Time Python parser.

Time Rust parser.

Time Rust parser including lexing.

Convert a linting result to a :exc:`SQLLintError` if appropriate.

Make a formatted string of this position.

Convert a slice into a tuple of (start, stop).

Return a tuple structure from this segment. Unlike most segments, we return the _source_ content for placeholders if viewing metas is

On ending a 'for' or 'if' block, set up tracking. Args: block_type (str): The type of block ('block_start', 'block_mid',

Set up tracking for "{% call ... %}". Args: m_open (regex.Match): A regex match object representing the opening tag.

Set up tracking for a Jinja literal.

Compute tracking info for Jinja templated region, e.g. {{ foo }}. Args: m_open (regex.Match): A regex match object representing t

Return a DepthInfo object with some amount trimmed.

Attempt to silence dbt logs. During normal operation dbt is likely to log output such as: .. code-block:: 14:13:10 Regi

Based on block tag, update whether in a set/call/macro/block section.

Based on block, update conditional jump info.

Insert or update a manifest entry for the published channel.

Run sanity checks on generated tables.

Return a dictionary of Violations recorded in `src_paths`.

Generate any lexing errors for any unlexables.

Copy this position and replace the working position.

A MatchResult is truthy if it has length or inserts.

A LexMatch is truthy if it contains a non-zero number of matched elements.

Don't fail when called unlike parent class.

When the wrapper is called, call the internal function.

When relation(*) is called return self as another relation.

Wraps jinja macro calls to handle dbt's `return` jinja function.

Errors compare equal if they are the same type and same content.

Return true if `other` is of the same class as this one. NB: This is useful in comparing configs.

Compare equality with another fix. A fix is equal to another if is in the same place (position), with the same type and (if appropria

Don't fail when called, remember instead.

Intercept any calls to undefined attributes. Args: item (str): The name of the attribute. Returns: object: A

When relation.attribute is called return self as another relation. NOTE: If the attribute begins with `is_`, then return a boolean True.

When var.attribute is called return self as another placeholder.

Individual "getting" returns a single segment. NOTE: Using `SupportsIndex` rather than `int` is to ensure type compatibility with the