Add Snapshot entity (#96)

Guys, I wrote some stuff that I think mostly makes sense but I can't get
tests to pass if I add my snapshot fixture to the manifest i.e.. Also, I
am not understanding how to try to run this code locally, and some other
issues. Would much appreciate some feedback on this

```
    "snapshot.package.snapshot1": {
      "resource_type": "snapshot",
      "package_name": "package",
      "unique_id": "snapshot.package.snapshot1",
      "name": "snapshot1",
      "description": "A great snapshot.",
      "original_file_path": "/path/to/snapshot1.sql",
      "config": {},
      "meta": {},
      "columns": {
        "a": {
          "name": "column_a",
          "description": "Column A.",
          "data_type": "string",
          "meta": {},
          "constraints": [],
          "tags": []
        }
      },
      "constraints": [],
      "database": "db",
      "schema": "schema",
      "raw_code": "SELECT x FROM y",
      "alias": "snapshot1_alias",
      "patch_path": "/path/to/snapshot1.yml",
      "tags": [],
      "depends_on": {},
      "language": "sql",
      "access": "protected",
      "strategy": "timestamp",
      "unique_key": ["a"]
    },
```

---------

Co-authored-by: Alin Cristian Preda <[email protected]>
Co-authored-by: Jochem van Dooren <[email protected]>

Author: 3 people

CHANGELOG.md

@@ -11,6 +11,7 @@ and this project adheres to
 - Improve documentation on rule filters. (#93)
 - Add `group` to model definition. (#99)
 - Add rule: prevent use of is_incremental() in non-incremental models. (#103)
+- Support linting of snapshots. (#96)
 
 ## [0.10.0] - 2025-01-27
 

docs/configuration.md

@@ -51,8 +51,8 @@ The following options can be set in the `pyproject.toml` file:
 - `disabled_rules`: A list of rules to disable.
 - `fail_project_under` (default: `5.0`): If the project score is below this
   value the command will fail with return code 1.
-- `fail_any_item_under` (default: `5.0`): If any model or source scores below
-  this value the command will fail with return code 1.
+- `fail_any_item_under` (default: `5.0`): If any entity scores below this value
+  the command will fail with return code 1.
 
 #### Badges configuration
 

docs/create_rules.md

@@ -1,9 +1,9 @@
 # Create rules
 
-In order to lint and score models or sources, `dbt-score` uses a set of rules
-that are applied to each item. A rule can pass or fail when it is run. Based on
-the severity of the rule, items are scored with the weighted average of the
-rules results. Note that `dbt-score` comes bundled with a
+In order to lint and score dbt entities, `dbt-score` uses a set of rules that
+are applied to each item. A rule can pass or fail when it is run. Based on the
+severity of the rule, items are scored with the weighted average of the rules
+results. Note that `dbt-score` comes bundled with a
 [set of default rules](rules/generic.md).
 
 On top of the generic rules, it's possible to add your own rules. Two ways exist
@@ -32,7 +32,7 @@ function is its description. Therefore, it is important to use a
 self-explanatory name for the function and document it well.
 
 The type annotation for the rule's argument dictates whether the rule should be
-applied to dbt models or sources.
+applied to dbt models, sources or snapshots.
 
 Here is the same example rule, applied to sources:
 
@@ -116,9 +116,9 @@ def sql_has_reasonable_number_of_lines(model: Model, max_lines: int = 200) -> Ru
 
 ### Filtering rules
 
-Custom and standard rules can be configured to have filters. Filters allow
-models or sources to be ignored by one or multiple rules if the item doesn't
-satisfy the filter criteria.
+Custom and standard rules can be configured to have filters. Filters allow a dbt
+entity to be ignored by one or multiple rules if the item doesn't satisfy the
+filter criteria.
 
 Filters are created using the same discovery mechanism and interface as custom
 rules, except they do not accept parameters. Similar to Python's built-in
@@ -139,8 +139,8 @@ class SkipSchemaY(RuleFilter):
       return model.schema.lower() != 'y'
 ```
 
-Filters also rely on type-annotations to dictate whether they apply to models or
-sources:
+Filters also rely on type-annotations to dictate whether they apply to models
+sources or snapshots:
 
 ```python
 from dbt_score import RuleFilter, rule_filter, Source

docs/get_started.md

@@ -40,8 +40,8 @@ It's also possible to automatically run `dbt parse`, to generate the
 dbt-score lint --run-dbt-parse
 ```
 
-To lint only a selection of models or sources, the argument `--select` can be
-used. It accepts any
+To lint only a selection of dbt entities, the argument `--select` can be used.
+It accepts any
 [dbt node selection syntax](https://docs.getdbt.com/reference/node-selection/syntax):
 
 ```shell

docs/index.md

@@ -2,12 +2,18 @@
 
 `dbt-score` is a linter for [dbt](https://www.getdbt.com/) metadata.
 
-dbt allows data practitioners to organize their data in to _models_ and
+dbt allows data practitioners to organize their data into _models_ and
 _sources_. Those models and sources have metadata associated with them:
-documentation, tests, types, etc.
+documentation, tests, types, etc. dbt supports more types of entities, e.g.
+snapshots, analysis, seeds and more.
 
 `dbt-score` allows to lint and score this metadata, in order to enforce (or
-encourage) good practices.
+encourage) good practices. The dbt entities that `dbt-score` is able to lint
+(currently) are:
+
+- Models
+- Sources
+- Snapshots
 
 ## Example
 
@@ -22,20 +28,20 @@ Score: 10.0 🥇
 
 In this example, the model `customers` scores the maximum value of `10.0` as it
 passes all the rules. It also is awarded a golden medal because of the perfect
-score. By default a passing model or source with or without rule violations will
-not be shown, unless we pass the `--show-all` flag.
+score. By default a passing dbt entity with or without rule violations will not
+be shown, unless we pass the `--show-all` flag.
 
 ## Philosophy
 
-dbt models/sources are often used as metadata containers: either in YAML files
-or through the use of `{{ config() }}` blocks, they are associated with a lot of
+dbt entities are often used as metadata containers: either in YAML files or
+through the use of `{{ config() }}` blocks, they are associated with a lot of
 information. At scale, it becomes tedious to enforce good practices in large
-data teams dealing with many models/sources.
+data teams dealing with many dbt entities.
 
 To that end, `dbt-score` has 2 main features:
 
-- It runs rules on dbt models and sources, and displays any rule violations.
-  These can be used in interactive environments or in CI.
+- It runs rules on dbt entities, and displays any rule violations. These can be
+  used in interactive environments or in CI.
 - Using those run results, it scores items, to ascribe them a measure of their
   maturity. This score can help gamify metadata improvements/coverage, and be
   reflected in data catalogs.

docs/programmatic_invocations.md

@@ -61,9 +61,9 @@ When `dbt-score` terminates, it exists with one of the following exit codes:
   project being linted either doesn't raise any warning, or the warnings are
   small enough to be above the thresholds. This generally means "successful
   linting".
-- `1` in case of linting errors. This is the unhappy case: some models or
-  sources in the project raise enough warnings to have a score below the defined
-  thresholds. This generally means "linting doesn't pass".
+- `1` in case of linting errors. This is the unhappy case: some entities in the
+  project raise enough warnings to have a score below the defined thresholds.
+  This generally means "linting doesn't pass".
 - `2` in case of an unexpected error. This happens for example if something is
   misconfigured (for example a faulty dbt project), or the wrong parameters are
   given to the CLI. This generally means "setup needs to be fixed".

src/dbt_score/__init__.py

@@ -1,12 +1,13 @@
 """Init dbt_score package."""
 
-from dbt_score.models import Model, Source
+from dbt_score.models import Model, Snapshot, Source
 from dbt_score.rule import Rule, RuleViolation, Severity, rule
 from dbt_score.rule_filter import RuleFilter, rule_filter
 
 __all__ = [
     "Model",
     "Source",
+    "Snapshot",
     "RuleFilter",
     "Rule",
     "RuleViolation",

src/dbt_score/dbt_utils.py

@@ -69,7 +69,7 @@ def dbt_parse() -> "dbtRunnerResult":
 @dbt_required
 def dbt_ls(select: Iterable[str] | None) -> Iterable[str]:
     """Run dbt ls."""
-    cmd = ["ls", "--resource-types", "model", "source", "--output", "name"]
+    cmd = ["ls", "--resource-types", "model", "source", "snapshot", "--output", "name"]
     if select:
         cmd += ["--select", *select]
 

src/dbt_score/evaluation.py

@@ -61,7 +61,9 @@ def evaluate(self) -> None:
         rules = self._rule_registry.rules.values()
 
         for evaluable in chain(
-            self._manifest_loader.models, self._manifest_loader.sources
+            self._manifest_loader.models,
+            self._manifest_loader.sources,
+            self._manifest_loader.snapshots,
         ):
             # type inference on elements from `chain` is wonky
             # and resolves to superclass HasColumnsMixin
@@ -91,5 +93,9 @@ def evaluate(self) -> None:
         )
 
         # Add null check before calling project_evaluated
-        if self._manifest_loader.models or self._manifest_loader.sources:
+        if (
+            self._manifest_loader.models
+            or self._manifest_loader.sources
+            or self._manifest_loader.snapshots
+        ):
             self._formatter.project_evaluated(self.project_score)

src/dbt_score/formatters/human_readable_formatter.py

@@ -4,7 +4,7 @@
 
 from dbt_score.evaluation import EvaluableResultsType
 from dbt_score.formatters import Formatter
-from dbt_score.models import Evaluable, Model, Source
+from dbt_score.models import Evaluable, Model, Snapshot, Source
 from dbt_score.rule import RuleViolation
 from dbt_score.scoring import Score
 
@@ -35,6 +35,8 @@ def pretty_name(evaluable: Evaluable) -> str:
                 return evaluable.name
             case Source():
                 return evaluable.selector_name
+            case Snapshot():
+                return evaluable.name
             case _:
                 raise NotImplementedError
 
@@ -53,7 +55,7 @@ def evaluable_evaluated(
             )
         ):
             resource_type = type(evaluable).__name__
-            name_formatted = f"{resource_type[0]}: {self.pretty_name(evaluable)}"
+            name_formatted = f"{resource_type}: {self.pretty_name(evaluable)}"
             header = (
                 f"{score.badge} "
                 f"{self.bold(name_formatted)} (score: {score.rounded_value!s})"
@@ -72,8 +74,7 @@ def evaluable_evaluated(
                     )
                 else:
                     print(
-                        f"{self.indent}{self.label_error} {rule.source()}: "
-                        f"{result!s}"
+                        f"{self.indent}{self.label_error} {rule.source()}: {result!s}"
                     )
             print()