Edit on GitHub

sqlmesh.core.config.linter

 1from __future__ import annotations
 2
 3import typing as t
 4
 5from sqlglot import exp
 6from sqlglot.helper import ensure_collection
 7
 8from sqlmesh.core.config.base import BaseConfig
 9
10from sqlmesh.utils.pydantic import field_validator
11
12
13class LinterConfig(BaseConfig):
14    """Configuration for model linting
15
16    Args:
17        enabled: Flag indicating whether the linter should run
18
19        use_project_index: Whether to use the persistent project index when linting.
20
21        rules: A list of error rules to be applied on model
22        warn_rules: A list of rules to be applied on models but produce warnings instead of raising errors.
23        ignored_rules: A list of rules to be excluded/ignored
24
25    """
26
27    enabled: bool = False
28    use_project_index: bool = False
29
30    rules: t.Set[str] = set()
31    warn_rules: t.Set[str] = set()
32    ignored_rules: t.Set[str] = set()
33
34    @classmethod
35    def _validate_rules(cls, v: t.Any) -> t.Set[str]:
36        if isinstance(v, exp.Paren):
37            v = v.unnest().name
38        elif isinstance(v, (exp.Tuple, exp.Array)):
39            v = [e.name for e in v.expressions]
40        elif isinstance(v, exp.Expr):
41            v = v.name
42
43        return {name.lower() for name in ensure_collection(v)}
44
45    @field_validator("rules", "warn_rules", "ignored_rules", mode="before")
46    def rules_validator(cls, vs: t.Any) -> t.Set[str]:
47        return cls._validate_rules(vs)
class LinterConfig(sqlmesh.core.config.base.BaseConfig):
14class LinterConfig(BaseConfig):
15    """Configuration for model linting
16
17    Args:
18        enabled: Flag indicating whether the linter should run
19
20        use_project_index: Whether to use the persistent project index when linting.
21
22        rules: A list of error rules to be applied on model
23        warn_rules: A list of rules to be applied on models but produce warnings instead of raising errors.
24        ignored_rules: A list of rules to be excluded/ignored
25
26    """
27
28    enabled: bool = False
29    use_project_index: bool = False
30
31    rules: t.Set[str] = set()
32    warn_rules: t.Set[str] = set()
33    ignored_rules: t.Set[str] = set()
34
35    @classmethod
36    def _validate_rules(cls, v: t.Any) -> t.Set[str]:
37        if isinstance(v, exp.Paren):
38            v = v.unnest().name
39        elif isinstance(v, (exp.Tuple, exp.Array)):
40            v = [e.name for e in v.expressions]
41        elif isinstance(v, exp.Expr):
42            v = v.name
43
44        return {name.lower() for name in ensure_collection(v)}
45
46    @field_validator("rules", "warn_rules", "ignored_rules", mode="before")
47    def rules_validator(cls, vs: t.Any) -> t.Set[str]:
48        return cls._validate_rules(vs)

Configuration for model linting

Arguments:
  • enabled: Flag indicating whether the linter should run
  • use_project_index: Whether to use the persistent project index when linting.
  • rules: A list of error rules to be applied on model
  • warn_rules: A list of rules to be applied on models but produce warnings instead of raising errors.
  • ignored_rules: A list of rules to be excluded/ignored
enabled: bool
use_project_index: bool
rules: Set[str]
warn_rules: Set[str]
ignored_rules: Set[str]
@field_validator('rules', 'warn_rules', 'ignored_rules', mode='before')
def rules_validator(cls, vs: Any) -> Set[str]:
46    @field_validator("rules", "warn_rules", "ignored_rules", mode="before")
47    def rules_validator(cls, vs: t.Any) -> t.Set[str]:
48        return cls._validate_rules(vs)
model_config = {'json_encoders': {<class 'sqlglot.expressions.core.Expr'>: <function _expression_encoder>, <class 'sqlglot.expressions.datatypes.DataType'>: <function _expression_encoder>, <class 'sqlglot.expressions.query.Tuple'>: <function _expression_encoder>, typing.Union[sqlglot.expressions.query.Query, sqlmesh.core.dialect.JinjaQuery]: <function _expression_encoder>, typing.Union[sqlglot.expressions.query.Query, sqlmesh.core.dialect.JinjaQuery, sqlmesh.core.dialect.MacroFunc]: <function _expression_encoder>, <class 'datetime.tzinfo'>: <function PydanticModel.<lambda>>}, 'arbitrary_types_allowed': True, 'extra': 'forbid', 'protected_namespaces': ()}

Configuration for the model, should be a dictionary conforming to [ConfigDict][pydantic.config.ConfigDict].

Inherited Members
pydantic.main.BaseModel
BaseModel
model_fields
model_computed_fields
model_extra
model_fields_set
model_construct
model_copy
model_dump
model_dump_json
model_json_schema
model_parametrized_name
model_post_init
model_rebuild
model_validate
model_validate_json
model_validate_strings
parse_file
from_orm
construct
schema
schema_json
validate
update_forward_refs
sqlmesh.core.config.base.BaseConfig
update_with
sqlmesh.utils.pydantic.PydanticModel
dict
json
copy
fields_set
parse_obj
parse_raw
missing_required_fields
extra_fields
all_fields
all_field_infos
required_fields