bobo decider run development - need tests for decider material...

.github/workflows/cicd.yml

@@ -57,3 +57,11 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.COVERALLS_TOKEN }}
         run: |
           coveralls
+
+      - name: Delete old workflow runs
+        uses: Mattraks/delete-workflow-runs@v2
+        with:
+          token: ${{ github.token }}
+          repository: ${{ github.repository }}
+          retain_days: 1
+          keep_minimum_runs: 10

.github/workflows/security.yml

@@ -32,3 +32,11 @@ jobs:
 
     - name: CodeQL analysis
       uses: github/codeql-action/analyze@v1
+
+    - name: Delete old workflow runs
+      uses: Mattraks/delete-workflow-runs@v2
+      with:
+        token: ${{ github.token }}
+        repository: ${{ github.repository }}
+        retain_days: 1
+        keep_minimum_runs: 10

bobocep/engine/decider/bobo_decider_run.py

@@ -42,23 +42,54 @@ def process(self, event: BoboEvent) -> bool:
                 return False
 
             block: BoboPatternBlock = self.pattern.blocks[self._block_index]
-            # match = self._is_match(event, block.predicates)
 
             if block.loop:
-                self._process_loop()
+                self._process_loop(event, block)
             else:
-                self._process_not_loop()
+                self._process_not_loop(event, block)
 
-    def _process_loop(self) -> None:
-        # a looping block cannot be negated or optional
-        # i.e. negated and optional are False if loop is True
-        pass
+    def _process_loop(self,
+                      event: BoboEvent,
+                      block: BoboPatternBlock) -> None:
+        # a looping block can neither be negated nor optional
+        match = self._is_match(event, block.predicates)
 
-    def _process_not_loop(self) -> None:
+        if not match:
+            if block.strict:
+                self._halted = True
+
+            elif self._block_index + 1 < len(self.pattern.blocks):
+                block = self.pattern.blocks[self._block_index + 1]
+                if block.loop:
+                    self._process_loop(event, block)
+                else:
+                    self._process_not_loop(event, block)
+
+    def _process_not_loop(self,
+                          event: BoboEvent,
+                          block: BoboPatternBlock) -> None:
         # a non-looping block cannot be both negated and optional
-        # i.e. negated and optional are not both True if loop is False
-        pass
+        # a strict block cannot be optional
+        match = self._is_match(event, block.predicates)
+
+        if block.negated:
+            if match and block.strict:
+                self._halted = True
+
+        elif block.optional:
+            if not match and self._block_index + 1 < len(self.pattern.blocks):
+                block = self.pattern.blocks[self._block_index + 1]
+                if block.loop:
+                    self._process_loop(event, block)
+                else:
+                    self._process_not_loop(event, block)
+
+        else:
+            if (not match) and block.strict:
+                self._halted = True
 
-    def _is_match(self, event: BoboEvent, predicates: List[BoboPredicate]):
+    def _is_match(self,
+                  event: BoboEvent,
+                  predicates: List[BoboPredicate]) -> bool:
         return any(predicate.evaluate(event=event, history=self.history)
                    for predicate in predicates)

bobocep/pattern/bobo_pattern_block.py

@@ -31,6 +31,8 @@ class BoboPatternBlock:
     :type optional: bool
     """
 
+    # todo cannot be strict and optional?
+
     @require("'group' must be of type str",
              lambda args: isinstance(args.group, str))
     @require("'group' must have a length greater than 0",
@@ -50,6 +52,8 @@ class BoboPatternBlock:
              lambda args: isinstance(args.negated, bool))
     @require("'optional' must be of type bool",
              lambda args: isinstance(args.optional, bool))
+    @require("'strict' and 'optional' must not both be True",
+             lambda args: not (args.strict and args.optional))
     @require("'negated' and 'optional' must both be False if 'loop' is True",
              lambda args: (not args.negated and
                            not args.optional) if args.loop else True)

bobocep/pattern/bobo_pattern_builder.py

@@ -31,8 +31,7 @@ def next(self,
              group: str,
              predicate: BoboPredicate,
              times: int = 1,
-             loop: bool = False,
-             optional: bool = False) -> 'BoboPatternBuilder':
+             loop: bool = False) -> 'BoboPatternBuilder':
 
         for _ in range(max(times, 1)):
             self._blocks.append(BoboPatternBlock(
@@ -41,7 +40,7 @@ def next(self,
                 strict=True,
                 loop=loop,
                 negated=False,
-                optional=optional))
+                optional=False))
         return self
 
     def not_next(self,

tests/test_pattern/test_bobo_pattern_builder.py

@@ -17,8 +17,7 @@ def test_1_block_1_pre_1_halt():
         .next(group=group_a,
               predicate=predicate_block_a,
               times=1,
-              loop=False,
-              optional=False) \
+              loop=False) \
         .precondition(predicate=predicate_pre_a) \
         .haltcondition(predicate=predicate_halt_a)
 
@@ -64,18 +63,15 @@ def test_3_blocks_3_pres_3_halts():
         .next(group=group_a,
               predicate=predicate_block_a,
               times=1,
-              loop=False,
-              optional=False) \
+              loop=False) \
         .next(group=group_b,
               predicate=predicate_block_b,
               times=1,
-              loop=False,
-              optional=False) \
+              loop=False) \
         .next(group=group_c,
               predicate=predicate_block_c,
               times=1,
-              loop=False,
-              optional=False) \
+              loop=False) \
         .precondition(predicate=predicate_pre_a) \
         .precondition(predicate=predicate_pre_b) \
         .precondition(predicate=predicate_pre_c) \