Cdstp 113 data loss in subgraph creation (#97)

* CDSTP-113 Created functions to get a map of overlapping out events from a DiGraph of Event

* CDSTP-113 update calculate loop components to always consider any nodes that break the loop as break points (unless they have a path to an in node to exit point) or unless they are part of an eventset from a break out node that contains an event in the loop

* CDSTP-113 Adds functionality to filter and replace break nodes with a connection to end events of a loop with a dummy break event type.

* CDSTP-113 Added updated functionality into detect loops

* CDSTP-113 Updated functionality to remove dummy break events and restructure nested PUML Graphs so that PUML can be ingested by plu2json

* CDSTP-113 Updated pv_to_puml_file function to use v2 with revised loop detection and use removal of dummy break events

* CDSTP-113 updated tests to account for updated methodology for break events

* CDSTP-113 updated mypy errors file

* CDSTP-113 Added extra tests and docs

* CDSTP-113 Updated test outcomes graphs

* CDSTP-113 Fixed docstrings

* CDSTP-113 test for pm4py

* CDSTP-113 try fixing setuptools to olde version

* CDSTP-113 attempt to fix workflow

* CDSTP-113 update github actions yaml

* CDSTP-113 update env

* CDSTP-113 update workflow

* CDSTP-113 update linting workflow

Author: FreddieMatherSmartDCSIT

.github/workflows/PythonLinting.yml

@@ -0,0 +1,63 @@
+name: run-tests
+on: [workflow_call]
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup Actions
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install Python Dependencies
+        run: |
+          export PIP_CONSTRAINT='pip_constraint.txt'
+          pip install --upgrade pip
+
+          pip install flake8
+          flake8 --version
+          pip install pylint
+          pylint --version
+          pip install mypy
+          mypy --version
+
+          pip install -r requirements.txt
+
+      - name: Flake8
+        if: '!cancelled()'
+        run: |
+          PY_FILES=$(git ls-files '*.py')
+
+          if [ -z "$PY_FILES" ]
+          then
+            echo "No files to check!"
+          else
+            flake8 $PY_FILES
+          fi
+
+      - name: Pylint
+        if: '!cancelled()'
+        run: |
+          PY_FILES=$(git ls-files '*.py')
+
+          if [ -z "$PY_FILES" ]
+          then
+            echo "No files to check!"
+          else
+            pylint $PY_FILES
+          fi
+
+      - name: MyPy
+        if: '!cancelled()'
+        run: |
+          PY_FILES=$(git ls-files '*.py')
+
+          if [ -z "$PY_FILES" ]
+          then
+            echo "No files to check!"
+          else
+            mypy --strict --explicit-package-bases --namespace-packages .
+          fi

.github/workflows/test-workflow.yml

@@ -9,13 +9,15 @@ on:
   push:
     branches:
       main
+
+
 jobs:
   sast:
     uses: SmartDCSITlimited/actions-store/.github/workflows/SAST.yml@main
   secret-detection:
     uses: SmartDCSITlimited/actions-store/.github/workflows/SecretDetection.yml@main
   python-linting:
-    uses: SmartDCSITlimited/actions-store/.github/workflows/PythonLinting.yml@main
+    uses: ./.github/workflows/PythonLinting.yml
 
   run-tests:
     runs-on: ubuntu-latest
@@ -49,15 +51,6 @@ jobs:
           conda install -y -c conda-forge cvxopt
           conda install -y -c conda-forge pygraphviz
 
-      - name: Install Requirements
-        run: |
-          pip install --upgrade pip
-
-          pip install pytest
-          pytest --version
-
-          pip install -r requirements.txt
-
       - name: Install Requirements (test-event-generator)
         run: |
           cd test-event-generator
@@ -77,6 +70,16 @@ jobs:
           pip install .
           cd ..
           rm -rf test-harness
+      
+      - name: Install Requirements
+        run: |
+          export PIP_CONSTRAINT='pip_constraint.txt'
+          pip install --upgrade pip
+
+          pip install pytest
+          pytest --version
+
+          pip install -r requirements.txt
 
       - name: Run Tests
         run: |

mypy_errors.txt

@@ -0,0 +1 @@
+setuptools<72

pip_constraint.txt

@@ -9,7 +9,7 @@
 from pm4py import (  # type: ignore[import-untyped]
     ProcessTree,
 )
-from networkx import DiGraph
+from networkx import DiGraph, Graph, connected_components
 from test_event_generator.solutions.graph_solution import (  # type: ignore[import-untyped] # noqa: E501
     GraphSolution,
 )
@@ -455,7 +455,7 @@ def get_reduced_event_set(event_sets: set[EventSet]) -> set[frozenset[str]]:
     """This function reduces a set of event sets to a set of unique events.
 
     :return: The reduced event set.
-    :rtype: `set`[:class:`frozenset`[`str`]]
+    :rtype: `set`[`frozenset`[`str`]]
     """
     return {event_set.to_frozenset() for event_set in event_sets}
 
@@ -474,3 +474,89 @@ def get_event_set_counts(event_sets: set[EventSet]) -> dict[str, set[int]]:
             else:
                 event_set_counts[event] = {count}
     return event_set_counts
+
+
+def get_overlapping_event_types(
+    event_sets: set[EventSet],
+) -> set[frozenset[str]]:
+    """This function gets the overlapping events from a set of event sets.
+
+    :param event_sets: The event sets.
+    :type event_sets: `set`[:class:`EventSet`]
+    :return: The overlapping events.
+    :rtype: `set`[`frozenset`[`str`]]
+    """
+    graph: "Graph[str]" = Graph()
+    for event_set in event_sets:
+        if len(event_set) > 1:
+            graph.add_edges_from(
+                {
+                    (event1, event2)
+                    for event1 in event_set
+                    for event2 in event_set
+                }
+            )
+    return {frozenset(component) for component in connected_components(graph)}
+
+
+def get_overlapping_events_from_event_sets_and_connected_events(
+    event_sets: set[EventSet], connected_events: set[Event]
+) -> list[set[Event]]:
+    """This function gets the overlapping events from a set of event sets.
+
+    :param event_sets: The event sets.
+    :type event_sets: `set`[:class:`EventSet`]
+    :param connected_events: The connected events.
+    :type connected_events: `set`[:class:`Event`]
+    :return: The overlapping events.
+    :rtype: `set`[`frozenset`[:class:`str`]]
+    """
+    overlapping_event_types = get_overlapping_event_types(event_sets)
+    return [
+        {
+            event
+            for event in connected_events
+            if event.event_type in over_lapping_event_types_set
+        }
+        for over_lapping_event_types_set in overlapping_event_types
+    ]
+
+
+def get_overlapping_events_from_event_and_graph(
+    event: Event, graph: "DiGraph[Event]"
+) -> list[set[Event]]:
+    """This function gets the overlapping events from a set of event sets.
+
+    :param event: The event.
+    :type event: :class:`Event`
+    :param graph: The graph.
+    :type graph: :class:`DiGraph`[:class:`Event`]
+    :return: The overlapping events.
+    :rtype: `set`[`frozenset`[`str`]]
+    """
+    return get_overlapping_events_from_event_sets_and_connected_events(
+        event.event_sets, set(
+            edge[1] for edge in graph.out_edges(event)
+        )
+    )
+
+
+def get_event_to_over_lapping_events_map(
+    graph: "DiGraph[Event]",
+) -> dict[Event, list[set[Event]]]:
+    """This function gets the event to overlapping events mapping from the
+    graph.
+
+    :param graph: The graph.
+    :type graph: :class:`DiGraph`[:class:`Event`]
+    :return: The event to overlapping events mapping.
+    :rtype: `dict`[:class:`Event`, `list`[`set`[:class:`Event`]]]
+    """
+    event_to_overlapping_events_map: dict[Event, list[set[Event]]] = {}
+    for event in graph.nodes:
+        over_lapping_events = get_overlapping_events_from_event_and_graph(
+            event, graph
+        )
+        if over_lapping_events:
+            event_to_overlapping_events_map[event] = over_lapping_events
+    return event_to_overlapping_events_map