start report refactoring #219

Author: JavierCladellas

src/feelpp/benchmarking/dashboardRenderer/__init__.py

@@ -0,0 +1,12 @@
+from feelpp.benchmarking.dashboardRenderer.schemas.dashboardSchema import ComponentMetadata
+
+class Component:
+    def __init__(self, id, component_metadata: ComponentMetadata):
+        self.id = id
+        self.display_name = component_metadata.display_name
+        self.description = component_metadata.description
+
+        self.views = {}
+
+    def __repr__(self):
+        return f"<{self.id}>"

src/feelpp/benchmarking/dashboardRenderer/component.py

@@ -0,0 +1,26 @@
+from feelpp.benchmarking.report.renderer import Renderer
+from repository import ComponentRepository
+from feelpp.benchmarking.dashboardRenderer.utils import TreeUtils
+
+
+class DashboardRenderer:
+    """ Serves as a repository orchestrator"""
+    def __init__(self,components_config,export_base_path):
+
+        self.component_repositories = [
+            ComponentRepository(repository_id, components)
+            for repository_id, components in components_config.components.items()
+        ]
+
+        self.initRepositoryViews(components_config.views,components_config.component_map)
+
+    def initRepositoryViews(self,views,component_map):
+        tree_order = component_map.component_order
+        mapping = component_map.mapping
+        for component_repository in self.component_repositories:
+            component_views = views[component_repository.id]
+            view_orders = TreeUtils.treeToLists({component_repository.id:component_views})
+            for view_order in view_orders:
+                view_perm = [tree_order.index(v) for v in view_order]
+                permuted_tree = TreeUtils.permuteTreeLevels(mapping,view_perm)
+                component_repository.initViews(view_order,permuted_tree,self.component_repositories)

src/feelpp/benchmarking/dashboardRenderer/dashboardRenderer.py

@@ -0,0 +1,99 @@
+import os
+from feelpp.benchmarking.dashboardRenderer.component import Component
+
+class Repository:
+    """ Base class for repositories.
+    Designed for containing and manipulating a unique list of items
+    """
+    def __init__(self,id):
+        self.data = []
+        self.id = id
+
+    def __iter__(self):
+        """ Iterator for the repository """
+        return iter(self.data)
+
+    def __repr__(self):
+        return f"< {self.id} : [{', '.join([str(d) for d in self.data])}] >"
+
+    def add(self, item):
+        """ Add an item to the repository, ensuring it is unique
+        Args:
+            item (object): The item to add
+        """
+        if item not in self.data and item.id not in [x.id for x in self.data]:
+            self.data.append(item)
+
+    def get(self, id):
+        """ Get an item by its id """
+        return next(filter(lambda x: x.id == id, self.data))
+
+    def __getitem__(self,index):
+        return self.data[index]
+
+
+class ComponentRepository(Repository):
+    """Class representing a collection of components (machines, applications, useCases) """
+    def __init__(self, id, components):
+        super().__init__(id)
+        for component_id, component_metadata in components.items():
+            self.add(Component(component_id, component_metadata))
+
+    def initViews(self,view_order,tree, other_repositories):
+        repo_lookup = {rep.id : rep for rep in other_repositories}
+
+        def processViewTree(subtree, level_index):
+            if level_index >= len(view_order) or not subtree:
+                return {}
+
+            current_repo = repo_lookup[view_order[level_index]]
+            view_structure = {}
+
+            for view_component_id, sub_tree in subtree.items():
+                view_component = current_repo.get(view_component_id)
+                view_structure[view_component] = processViewTree(sub_tree, level_index + 1)
+
+            return view_structure
+
+        for component in self.data:
+            component_subtree = tree.get(component.id, {})
+            component.views[view_order[1]] = processViewTree(component_subtree, 1)
+
+    # def renderSelf(self, base_dir, renderer, self_tag_id, parent_id = "catalog-index"):
+    #     """ Initialize the module for repository.
+    #     Creates the directory for the repository and renders the index.adoc file
+    #     Args:
+    #         base_dir (str): The base directory for the modules
+    #         renderer (Renderer): The renderer to use
+    #         self_tag_id (str): The catalog id of the current reposirory, to be used by their children as parent
+    #         parent_id (str): The catalog id of the parent component
+    #     """
+    #     module_path = os.path.join(base_dir, self.id)
+
+    #     if not os.path.exists(module_path):
+    #         os.mkdir(module_path)
+
+    #     renderer.render(
+    #         os.path.join(module_path,"index.adoc"),
+    #         self.indexData(parent_id,self_tag_id)
+    #     )
+
+    # def renderChildren(self, base_dir, renderer):
+    #     """ Inits the repository module and calls the initModules method of each item in the repository.
+    #     Args:
+    #         base_dir (str): The base directory for the modules
+    #         renderer (Renderer): The renderer to use
+    #         parent_id (str,optional): The catalog id of the parent component. Defaults to "supercomputers".
+    #     """
+    #     for item in self.data:
+    #         item.render(os.path.join(base_dir,self.id), renderer, self.id)
+
+    # def render(self, base_dir, renderer, parent_id = "catalog-index"):
+    #     """ Inits the repository module and calls the initModules method of each item in the repository.
+    #     Args:
+    #         base_dir (str): The base directory for the modules
+    #         renderer (Renderer): The renderer to use
+    #         parent_id (str,optional): The catalog id of the parent component. Defaults to "supercomputers".
+    #     """
+    #     self.renderSelf(base_dir,renderer,self_tag_id=self.id, parent_id=parent_id)
+    #     self.renderChildren(base_dir, renderer)

src/feelpp/benchmarking/dashboardRenderer/repository.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel
+from typing import List, Dict, Optional
+
+class ComponentMap(BaseModel):
+    component_order: List[str]
+    mapping: Dict[str,Dict]
+
+class ComponentMetadata(BaseModel):
+    display_name: str
+    description: Optional[str] = ""
+
+class DashboardSchema(BaseModel):
+    component_map: ComponentMap
+    components: Dict[str,Dict[str, ComponentMetadata]]
+    views : Dict[str,Dict]

src/feelpp/benchmarking/dashboardRenderer/schemas/__init__.py

@@ -0,0 +1,112 @@
+import pytest
+from feelpp.benchmarking.dashboardRenderer.schemas.dashboardSchema import ComponentMetadata
+from feelpp.benchmarking.dashboardRenderer.repository import ComponentRepository
+from feelpp.benchmarking.dashboardRenderer.component import Component
+from feelpp.benchmarking.dashboardRenderer.utils import TreeUtils
+
+class TestComponentRepository:
+
+    @staticmethod
+    def checkForDuplicates(list):
+        assert len(list) == len(set(list)), "list has duplicate values"
+
+    def test_uniqueness(self):
+        components_config = {
+            "a": ComponentMetadata(display_name = "A"),
+            "b": ComponentMetadata(display_name = "B"),
+            "c": ComponentMetadata(display_name = "C"),
+            "a": ComponentMetadata(display_name = "A"),
+        }
+        component_repository = ComponentRepository("test",components_config)
+        self.checkForDuplicates(component_repository.data)
+        assert len([c for c in component_repository.data if c.id == "a"]) == 1
+
+        component_repository.add(Component(id = "b",component_metadata=ComponentMetadata(display_name="Other")))
+        self.checkForDuplicates(component_repository.data)
+        assert len([c for c in component_repository.data if c.id == "b"]) == 1
+
+
+    def test_initViews(self):
+        """Test the initViews method with different view order permutations."""
+
+        # --- Create Components in each repository ---
+        components_config_1 = {"A1": ComponentMetadata(display_name="A1"), "A2": ComponentMetadata(display_name="A2")}
+        components_config_2 = {"B1": ComponentMetadata(display_name="B1"), "B2": ComponentMetadata(display_name="B2")}
+        components_config_3 = {"C1": ComponentMetadata(display_name="C1"), "C2": ComponentMetadata(display_name="C2")}
+        components_config_4 = {"D1": ComponentMetadata(display_name="D1"), "D2": ComponentMetadata(display_name="D2")}
+
+        # --- Create Repositories ---
+        repo1 = ComponentRepository("Repo1", components_config_1)
+        repo2 = ComponentRepository("Repo2", components_config_2)
+        repo3 = ComponentRepository("Repo3", components_config_3)
+        repo4 = ComponentRepository("Repo4", components_config_4)
+
+        # Get the actual components from repositories
+        component_A1 = repo1.get("A1")
+        component_A2 = repo1.get("A2")
+        component_B1 = repo2.get("B1")
+        component_B2 = repo2.get("B2")
+        component_C1 = repo3.get("C1")
+        component_C2 = repo3.get("C2")
+        component_D1 = repo4.get("D1")
+        component_D2 = repo4.get("D2")
+
+        repositories = [repo1, repo2, repo3, repo4]
+        view_order = ["Repo1", "Repo2", "Repo3", "Repo4"]
+        # --- Define a Hierarchical Tree ---
+        tree = {
+            "A1": {
+                "B1": {
+                    "C1": {
+                        "D1": {}
+                    },
+                    "C2": {
+                        "D2": {}
+                    }
+                },
+                "B2": {
+                    "C1": {
+                        "D2": {}
+                    }
+                }
+            },
+            "A2": {
+                "B1": {
+                    "C2": {
+                        "D1": {}
+                    }
+                }
+            }
+        }
+
+        # --- Run initViews on repo1 ---
+        repo1.initViews(view_order, tree, repositories)
+
+        # Ensure view key exists in components
+        assert view_order[1] in component_A1.views
+        assert view_order[1] in component_A2.views
+
+        # Expected structure after `initViews`
+        expected_structure_A1 = {
+            component_B1: {
+                component_C1: {component_D1: {}},
+                component_C2: {component_D2: {}}
+            },
+            component_B2: {
+                component_C1: {component_D2: {}}
+            }
+        }
+
+        expected_structure_A2 = {
+            component_B1: {
+                component_C2: {component_D1: {}}
+            }
+        }
+
+        assert component_A1.views[view_order[1]] == expected_structure_A1, (
+            f"Expected {expected_structure_A1}, but got {component_A1.views[view_order[1]]}"
+        )
+
+        assert component_A2.views[view_order[1]] == expected_structure_A2, (
+            f"Expected {expected_structure_A2}, but got {component_A2.views[view_order[1]]}"
+        )

src/feelpp/benchmarking/dashboardRenderer/schemas/dashboardSchema.py

@@ -0,0 +1,48 @@
+from feelpp.benchmarking.dashboardRenderer.utils import TreeUtils
+import pytest
+
+@pytest.mark.parametrize("tree, expected", [
+    ({}, []),  # Empty tree case
+    ({"A": "B"}, [["A", "B"]]),  # Single key-value pair
+    ({"A": {"B": "C"}}, [["A", "B", "C"]]),  # Simple nested case
+    ({"A": {"B": "C", "D": "E"}}, [["A", "B", "C"], ["A", "D", "E"]]),  # Two branches at second level
+    ({"A": {"B": {"C": "D"}}}, [["A", "B", "C", "D"]]),  # Deeply nested single path
+    ({"A": {"B": "C"}, "D": {"E": "F"}}, [["A", "B", "C"], ["D", "E", "F"]]),  # Multiple top-level keys
+    ({"A": {"B": {"C": "D", "E": "F"}, "G": "H"}},
+     [["A", "B", "C", "D"], ["A", "B", "E", "F"], ["A", "G", "H"]])  # Complex case with mixed depths
+])
+def test_treeToList(tree,expected):
+    tree_list = TreeUtils.treeToLists(tree)
+    assert tree_list == expected
+
+
+
+@pytest.mark.parametrize("tree, permutation, expected", [
+    ({"A": {"B": "C"}}, [0, 1], {"A": {"B": "C"}}), # Basic case: No permutation (identity)
+    ({"A": {"B": "C"}}, [1, 0], {"B": {"A": "C"}}), # Swap two levels
+    ({"A": {"B": {"C": "D"}}}, [1, 0, 2], {"B": {"A": {"C": "D"}}}), # Three levels, swapping first and second
+    ({"A": {"B": {"C": "D", "E": "F"}}}, [1, 0, 2], {"B": {"A": {"C": "D", "E": "F"}}}), # More complex tree with swaps
+    ({"A": {"B": {"C": "D"}}}, [2, 1, 0], {"C": {"B": {"A": "D"}}}), # Three levels, swapping first and third
+    ({
+        "A": {"B": {"C": "D", "E": "F"}},
+        "X": {"Y": {"Z": "W"}}
+    }, [1, 0, 2],
+    {
+        "B": {"A": {"C": "D", "E": "F"}},
+        "Y": {"X": {"Z": "W"}}
+    })  # Multiple branches, swapping levels
+])
+def test_permuteTreeLevels(tree, permutation, expected):
+    """Test that permuteTreeLevels correctly rearranges tree levels."""
+    result = TreeUtils.permuteTreeLevels(tree, permutation)
+    assert result == expected
+
+@pytest.mark.parametrize(("tree","permutation", "error"), [
+    ({"A": {"B": "C"}}, [0], ValueError),  # Invalid permutation length
+    ({"A": {"B": {"C": "D"}}}, [0, 1], ValueError),  # Missing level in permutation
+    ({"A": {"B": "C"}}, [2, 1], IndexError),  # Out of range permutation
+])
+def test_permuteTreeLevels_errors(tree, permutation, error):
+    """Test that permuteTreeLevels raises error on incorrect permutations."""
+    with pytest.raises(error):
+        TreeUtils.permuteTreeLevels(tree, permutation)

src/feelpp/benchmarking/dashboardRenderer/tests/test_repository.py

@@ -0,0 +1,55 @@
+class TreeUtils:
+
+    @staticmethod
+    def treeToLists(tree, prefix=[]):
+        tree_list = []
+        for k, v in tree.items():
+            new_prefix = prefix + [k]
+            if isinstance(v, dict):
+                tree_list.extend(TreeUtils.treeToLists(v, new_prefix))
+            else:
+                tree_list.append(new_prefix + [v])
+        return tree_list
+
+
+    @staticmethod
+    def permuteTreeLevels(tree, permutation):
+        """Permute the levels of an N-level nested dictionary tree."""
+        branches = []
+
+        def traverse(subtree, path):
+            if isinstance(subtree, dict) and subtree:
+                for key, child in subtree.items():
+                    traverse(child, path + [key])
+            else:
+                branches.append((path, subtree))
+
+        traverse(tree, [])
+
+        N = len(permutation)
+
+        for path, leaf in branches:
+            if len(path) != N:
+                raise ValueError(f"Branch {path} has {len(path)} levels but expected {N}.")
+
+        new_branches = []
+        for path, leaf in branches:
+            new_path = [None] * N
+            for new_level, old_level in enumerate(permutation):
+                new_path[new_level] = path[old_level]
+            new_branches.append((new_path, leaf))
+
+        new_tree = {}
+        for path, leaf in new_branches:
+            current = new_tree
+            for key in path[:-1]:
+                if key not in current:
+                    current[key] = {}
+
+                elif not isinstance(current[key], dict):
+                    raise ValueError(f"Conflict encountered at key '{key}' while rebuilding the tree.")
+                current = current[key]
+
+            current[path[-1]] = leaf
+
+        return new_tree