feat: Asset agnostic rule configs

.gitignore

@@ -18,3 +18,5 @@ python/protos/**/*
 python/build
 python/docs/sift_py
 *.egg-info/
+
+.vscode/*

python/examples/ingestion_with_python_config/rule_modules/velocity.yml

@@ -0,0 +1,12 @@
+namespace: velocity
+
+rules:
+  - name: vehicle_stuck
+    description: Triggers if the vehicle velocity is not 0 for 5s after entering accelerating state
+    expression: $1 == "Accelerating" && persistence($2 == 0, 5)
+    type: review
+
+  - name: vehicle_not_stopped
+    description: Triggers if the vehicle velocity does not remain 0 while stopped
+    expression: $1 == "Stopped" && $2 > 0
+    type: review

python/examples/ingestion_with_python_config/rule_modules/voltage.yml

@@ -0,0 +1,12 @@
+namespace: voltage
+
+rules:
+  - name: overvoltage
+    description: Checks for overvoltage while accelerating
+    expression: $1 == "Accelerating" && $2 > 80
+    type: review
+
+  - name: undervoltage
+    description: Checks for undervoltage while accelerating
+    expression: $1 == "Accelerating" && $2 < 40
+    type: review

python/examples/ingestion_with_python_config/telemetry_config.py

@@ -7,13 +7,14 @@
     ChannelEnumType,
 )
 from sift_py.ingestion.config.telemetry import FlowConfig, TelemetryConfig
-from sift_py.ingestion.config.yaml.load import load_named_expression_modules
+from sift_py.ingestion.config.yaml.load import load_named_expression_modules, load_rule_namespaces
 from sift_py.ingestion.rule.config import (
     RuleActionCreateDataReviewAnnotation,
     RuleConfig,
 )
 
 EXPRESSION_MODULES_DIR = Path().joinpath("expression_modules")
+RULE_NAMESPACES_DIR = Path().joinpath("rule_modules")
 
 
 def nostromos_lv_426() -> TelemetryConfig:
@@ -24,6 +25,12 @@ def nostromos_lv_426() -> TelemetryConfig:
         ]
     )
 
+    rule_namespaces = load_rule_namespaces(
+        [
+            RULE_NAMESPACES_DIR,
+        ]
+    )
+
     log_channel = ChannelConfig(
         name="log",
         data_type=ChannelDataType.STRING,
@@ -124,6 +131,70 @@ def nostromos_lv_426() -> TelemetryConfig:
                     tags=["nostromo", "failure"],
                 ),
             ),
+            RuleConfig(
+                name="overvoltage",
+                namespace="voltage",
+                namespace_rules=rule_namespaces,
+                channel_references=[
+                    # INFO: Can use either "channel_identifier" or "channel_config"
+                    {
+                        "channel_reference": "$1",
+                        "channel_identifier": vehicle_state_channel.fqn(),
+                    },
+                    {
+                        "channel_reference": "$2",
+                        "channel_config": voltage_channel,
+                    },
+                ],
+            ),
+            RuleConfig(
+                name="undervoltage",
+                namespace="voltage",
+                namespace_rules=rule_namespaces,
+                channel_references=[
+                    # INFO: Can use either "channel_identifier" or "channel_config"
+                    {
+                        "channel_reference": "$1",
+                        "channel_identifier": vehicle_state_channel.fqn(),
+                    },
+                    {
+                        "channel_reference": "$2",
+                        "channel_config": voltage_channel,
+                    },
+                ],
+            ),
+            RuleConfig(
+                name="vehicle_stuck",
+                namespace="velocity",
+                namespace_rules=rule_namespaces,
+                channel_references=[
+                    # INFO: Can use either "channel_identifier" or "channel_config"
+                    {
+                        "channel_reference": "$1",
+                        "channel_identifier": vehicle_state_channel.fqn(),
+                    },
+                    {
+                        "channel_reference": "$2",
+                        "channel_config": velocity_channel,
+                    },
+                ],
+            ),
+            RuleConfig(
+                name="vehicle_not_stopped",
+                namespace="velocity",
+                namespace_rules=rule_namespaces,
+                channel_references=[
+                    # INFO: Can use either "channel_identifier" or "channel_config"
+                    {
+                        "channel_reference": "$1",
+                        "channel_identifier": vehicle_state_channel.fqn(),
+                    },
+                    {
+                        "channel_reference": "$2",
+                        "channel_config": velocity_channel,
+                    },
+                ],
+            ),
         ],
         flows=[
             FlowConfig(

python/examples/ingestion_with_yaml_config/rule_modules/velocity.yml

@@ -0,0 +1,12 @@
+namespace: velocity
+
+rules:
+  - name: vehicle_stuck
+    description: Triggers if the vehicle velocity is not 0 for 5s after entering accelerating state
+    expression: $1 == "Accelerating" && persistence($2 == 0, 5)
+    type: review
+
+  - name: vehicle_not_stopped
+    description: Triggers if the vehicle velocity does not remain 0 while stopped
+    expression: $1 == "Stopped" && $2 > 0
+    type: review

python/examples/ingestion_with_yaml_config/rule_modules/voltage.yml

@@ -0,0 +1,12 @@
+namespace: voltage
+
+rules:
+  - name: overvoltage
+    description: Checks for overvoltage while accelerating
+    expression: $1 == "Accelerating" && $2 > 80
+    type: review
+
+  - name: undervoltage
+    description: Checks for undervoltage while accelerating
+    expression: $1 == "Accelerating" && $2 < 40
+    type: review

python/examples/ingestion_with_yaml_config/telemetry_config.py

@@ -5,6 +5,7 @@
 
 TELEMETRY_CONFIGS_DIR = Path().joinpath("telemetry_configs")
 EXPRESSION_MODULES_DIR = Path().joinpath("expression_modules")
+RULE_MODULES_DIR = Path().joinpath("rule_modules")
 
 
 def nostromos_lv_426() -> TelemetryConfig:
@@ -15,11 +16,12 @@ def nostromos_lv_426() -> TelemetryConfig:
 
     telemetry_config_path = TELEMETRY_CONFIGS_DIR.joinpath(telemetry_config_name)
 
-    # Load your telemetry config with your reusable expressions modules
+    # Load your telemetry config with your reusable expressions modules and rule modules
     return TelemetryConfig.try_from_yaml(
         telemetry_config_path,
         [
             EXPRESSION_MODULES_DIR.joinpath("kinematics.yml"),
             EXPRESSION_MODULES_DIR.joinpath("string.yml"),
         ],
+        [RULE_MODULES_DIR],
     )

python/examples/ingestion_with_yaml_config/telemetry_configs/nostromo_lv_426.yml

@@ -88,6 +88,30 @@ rules:
         - failure
         - nostromo
 
+  - namespace: voltage
+    name: overvoltage
+    channel_references:
+      - $1: *vehicle_state_channel
+      - $2: *voltage_channel
+
+  - namespace: voltage
+    name: undervoltage
+    channel_references:
+      - $1: *vehicle_state_channel
+      - $2: *voltage_channel
+
+  - namespace: velocity
+    name: vehicle_stuck
+    channel_references:
+      - $1: *vehicle_state_channel
+      - $2: *velocity_channel
+
+  - namespace: velocity
+    name: vehicle_not_stopped
+    channel_references:
+      - $1: *vehicle_state_channel
+      - $2: *velocity_channel
+
 flows:
   - name: readings
     channels:
@@ -103,7 +127,7 @@ flows:
   - name: gpio_channel
     channels:
       - <<: *gpio_channel
-      
+
   - name: logs
     channels:
       - <<: *log_channel

python/lib/sift_py/ingestion/config/telemetry.py

@@ -12,7 +12,11 @@
     ChannelEnumType,
     _channel_fqn,
 )
-from sift_py.ingestion.config.yaml.load import load_named_expression_modules, read_and_validate
+from sift_py.ingestion.config.yaml.load import (
+    load_named_expression_modules,
+    load_rule_namespaces,
+    read_and_validate,
+)
 from sift_py.ingestion.config.yaml.spec import TelemetryConfigYamlSpec
 from sift_py.ingestion.flow import FlowConfig
 from sift_py.ingestion.rule.config import (
@@ -111,6 +115,7 @@ def try_from_yaml(
         cls,
         path: Path,
         named_expression_modules: Optional[List[Path]] = None,
+        named_rule_modules: Optional[List[Path]] = None,
     ) -> Self:
         """
         Initializes a telemetry config from a YAML file found at the provided `path` as well as optional
@@ -119,17 +124,21 @@ def try_from_yaml(
 
         config_as_yaml = read_and_validate(path)
 
+        named_expressions = {}
+        rule_namespaces = {}
         if named_expression_modules is not None:
             named_expressions = load_named_expression_modules(named_expression_modules)
-            return cls._from_yaml(config_as_yaml, named_expressions)
-        else:
-            return cls._from_yaml(config_as_yaml)
+        if named_rule_modules is not None:
+            rule_namespaces = load_rule_namespaces(named_rule_modules)
+
+        return cls._from_yaml(config_as_yaml, named_expressions, rule_namespaces)
 
     @classmethod
     def _from_yaml(
         cls,
         config_as_yaml: TelemetryConfigYamlSpec,
         named_expressions: Dict[str, str] = {},
+        rule_namespaces: Dict[str, List] = {},
     ) -> Self:
         rules = []
         flows = []
@@ -179,16 +188,21 @@ def _from_yaml(
             )
 
         for rule in config_as_yaml.get("rules", []):
-            annotation_type = RuleActionAnnotationKind.from_str(rule["type"])
-
-            tags = rule.get("tags")
-
-            action: RuleAction = RuleActionCreatePhaseAnnotation(tags)
-            if annotation_type == RuleActionAnnotationKind.REVIEW:
-                action = RuleActionCreateDataReviewAnnotation(
-                    assignee=rule.get("assignee"),
-                    tags=tags,
-                )
+            namespace = rule.get("namespace", "")
+
+            action: Optional[RuleAction] = None
+            description: str = ""
+            if not namespace:
+                annotation_type = RuleActionAnnotationKind.from_str(rule["type"])
+                tags = rule.get("tags")
+                description = rule.get("description", "")
+
+                action = RuleActionCreatePhaseAnnotation(tags)
+                if annotation_type == RuleActionAnnotationKind.REVIEW:
+                    action = RuleActionCreateDataReviewAnnotation(
+                        assignee=rule.get("assignee"),
+                        tags=tags,
+                    )
 
             channel_references: List[
                 ExpressionChannelReference | ExpressionChannelReferenceChannelConfig
@@ -206,15 +220,17 @@ def _from_yaml(
                         }
                     )
 
-            expression = rule["expression"]
+            expression = rule.get("expression", "")
             if isinstance(expression, str):
                 rules.append(
                     RuleConfig(
                         name=rule["name"],
-                        description=rule.get("description", ""),
+                        description=description,
                         expression=expression,
                         action=action,
                         channel_references=channel_references,
+                        namespace=namespace,
+                        namespace_rules=rule_namespaces,
                     )
                 )
             else:
@@ -237,11 +253,13 @@ def _from_yaml(
                 rules.append(
                     RuleConfig(
                         name=rule["name"],
-                        description=rule.get("description", ""),
+                        description=description,
                         expression=expr,
                         action=action,
                         channel_references=channel_references,
                         sub_expressions=sub_exprs,
+                        namespace=namespace,
+                        namespace_rules=rule_namespaces,
                     )
                 )