A kind of meta-grammar that references other grammars by name at runtime.

Match a specific sequence of elements.

Match any of the elements given once. If it matches multiple, it returns the longest, and if any are the same length it returns the first (un

Match an arbitrary number of elements separated by a delimiter. Note that if there are multiple elements passed in that they will be treated

Match if a bracketed sequence, with content that matches one of the elements. Note that the contents of the Bracketed Expression are treated as a

A more configurable version of OneOf.

An object which matches and returns raw segments based on strings.

The persistent object for internal methods to access configuration. This class is designed to be instantiated once for each file and then be

The interface class to interact with the linter.

A class to hold the results of a rule evaluation. Args: anchor (:obj:`BaseSegment`, optional): A segment which represents the

Hybrid of Bracketed and Sequence: allows brackets but they aren't required. NOTE: This class is greedy on brackets so if they *can* be claimed, t

This RegexLexer matches based on regular expressions.

An object which matches and returns raw segments based on types.

Match any number of the elements but each element can only be matched once.

An object which matches and returns raw segments based on a regex.

Matches nothing. Useful for placeholders which might be overwritten by other dialects.

This singleton matcher matches strings exactly. This is the simplest usable matcher, but it also defines some of the mechanisms for more comp

A crawler that efficiently searches for specific segment types. The segment type(s) are specified on creation.

Matches anything.

Segment containing whitespace.

An object which matches and returns raw segments on a collection of strings.

A grammar which is conditional on the parse context. | NOTE: The Conditional grammar is assumed to be operating | within a Sequence grammar,

This should be the default response from any `match` method. All references and indices are in reference to a single root tuple of segments.

Object to handle the context at hand during parsing. Holds two tiers of references. 1. Persistent config, like references to the dialect or

Encapsulates a sequence of one or more BaseSegments. The segments may or may not be contiguous in a parse tree. Provides useful operations on

Defines a late-bound dialect object. It returns a single dialect object on expansion. These are defined using a callable, which is only call

A segment used for matching single entities which aren't keywords. We rename the segment class here so that descendants of _ProtoKeywordSegme

A reference to a position in a file. Things to note: - This combines the previous functionality of FilePositionMarker and Enric

RuleContext written in a "functional" style; simplifies writing rules.

An error which should be fed back to the user.

Provides information about a Jinja tag and how it affects JinjaAnalyzer behavior. Attributes: block_type (str): The block type that the J

A slice referring to a raw file.

A segment used for matching single words. We rename the segment class here so that descendants of _ProtoKeywordSegment can use the same funct

A slice referring to a templated file.

Data for a single GrammarInst (before serialization to Rust).

A templater using the jinja2 library. See: https://jinja.palletsprojects.com/

An error which occurred during parsing. Args: segment (:obj:`BaseSegment`, optional): The segment which is relevant for the f

Segment containing a newline. NOTE: NewlineSegment does not inherit from WhitespaceSegment. Therefore NewlineSegment.is_type('whitespace') re

Class for keeping track of editable elements in reflow. This class, and its sibling :obj:`ReflowBlock`, should not normally be manipulated di

This is a segment without any subsegments.

An error which occurred during templating. Args: pos (:obj:`PosMarker`, optional): The position which the error occurred at.

A templated SQL file. This is the response of a templaters .process() method and contains both references to the original file and also t

A crawler that doesn't crawl. This just yields one context on the root-level (topmost) segment of the file.

Class for keeping track of elements in a reflow operation. This acts as the primary route into using the reflow routines. It acts in a way th

An element of the response to BaseSegment.path_to(). Attributes: segment (:obj:`BaseSegment`): The segment in the chain. idx (int

An edit patch for a source file.

Class to wrap a callable, for better error handling. When called, it just delegates to the provided callable, but if it is rendered as a stri

Parser wrapper that uses Rust implementation but returns BaseSegment. This is designed to be a drop-in replacement for the Python Parser clas

Match a number of elements optionally separated by a delimiter. Note that if there are multiple elements passed in that they will be treated

Instantiates parsed queries from a sequence of lexed raw segments.

A templater for generic placeholders. Different libraries and tools use different styles of placeholders in order to escape them when running

A templater using python format strings. See: https://docs.python.org/3/library/string.html#format-string-syntax For the python templater we

An error returned from a templater to skip a file.

An identifier segment. Defined here for type inheritance.

An intermediate representation of a partially sliced File.

An element matched during lexing.

A class to hold a potential fix to a linting violation. Args: edit_type (:obj:`str`): One of `create_before`, `create_after`,

Outputs to a specified file.

Formatter which writes to an OutputStream. On instantiation, this formatter accepts a function to dispatch messages. Each public method accep

Make an API call but with error handling for the CLI.

Similar to jinja2.StrictUndefined, but remembers, not fails.

A generic (likely letters only) segment. Defined here for type inheritance. This is the base segment for things like keywords and naked

A segment which is empty but indicates where an indent should be. This segment is always empty, i.e. its raw format is '', but it indicates t

Details about a table alias.

The base segment element. This defines the base element which drives both Lexing, Parsing and Linting. A large chunk of the logic which defin

A segment which is empty but indicates where an dedent should be. This segment is always empty, i.e. its raw format is '', but it indicates t

A class to hold matches from the Lexer.

A class which emulates the `this` class from dbt.

An error which occurred during linting. In particular we reference the rule here to do extended logging based on the rule in question which c

A stored reference to a fix in the non-templated file.

This is a segment which can't be parsed. It indicates a error during parsing.

A minimal task packet sent to workers when templating is deferred. Instead of templating in the main process and shipping the full RenderedFi

Serves as the basis for runtime resolution of Grammar. Args: name (:obj:`str`): The name of the dialect, used for lookup. lexer_m

Acts as a dummy value to try and avoid template failures. Inherits from jinja2.Undefined so Jinja's default() filter will treat it as a missi

Dataclass to hold summary of indents in a point. Attributes: impulse (int): The net change when summing the impulses of all t

A literal segment. Defined here for type inheritance.

An object which behaves like a matcher to match non-code.

Matches when the current position is preceded by a keyword sequence. This is used as an ``exclude`` pattern on keyword matchers to prevent th

A wrapper around the sqlfluffrs lexer.

Encapsulates a sequence of one or more RawFileSlice. The slices may or may not be contiguous in a file. Provides useful operations on a seque

Exception class for reporting lint failure inside deeply nested code.

Used like a dataclass by rule tests.

Rule Tuple object for describing rules.

An error which occurred during lexing. Args: pos (:obj:`PosMarker`, optional): The position which the error occurred at.

A "SELECT" query segment.

A segment which is empty but indicates where something should be. This segment is always empty, i.e. its raw format is '', but it indicates t

Temporary structure for holding metadata about an indented ReflowPoint. We only evaluate point which either *are* line breaks or contain Inde

A location within a sequence to consider rebreaking.

A binary operator segment. Defined here for type inheritance. Inherits from RawSegment.

Arguments to load dbt runtime config.

Minimal config stub exposing a ``get`` method.

Fake lint error used by tests, similar to SQLLintError.

A meta segment to indicate the end of the file.

A Sequence which only populates on the first access. This is useful for being able to define sequences within the click cli decorators, but t

A class to store the idea of a collection of linted files at a single start path. A LintedDir may contain files in subdirectories, but they all s

A class to represent the result of a linting operation. Notably this might be a collection of paths, all with multiple potential files within

Parsed version of a 'noqa' comment.

For AM03, segment that ends an ORDER BY column and any order provided.

Container for parser metrics.