refactor: ruff checks

Author: noclone

geos-trame/geos_trame/app/__main__.py

@@ -2,13 +2,16 @@
 # SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies.
 # SPDX-FileContributor: Lionel Untereiner
 from pathlib import Path
+from typing import Any
 
 from trame.app import get_server
+from trame_server import Server
 
 from geos_trame.app.core import GeosTrame
 
 
-def main( server=None, **kwargs ):
+def main( server: Server = None, **kwargs: Any ) -> None:
+    """Main function."""
     # Get or create server
     if server is None:
         server = get_server()

geos-trame/geos_trame/app/components/alertHandler.py

@@ -7,14 +7,14 @@
 
 
 class AlertHandler( vuetify3.VContainer ):
-    """
-    Vuetify component used to display an alert status.
+    """Vuetify component used to display an alert status.
 
     This alert will be displayed in the bottom right corner of the screen.
     It will be displayed until closed by the user or after 10 seconds if it is a success or warning.
     """
 
-    def __init__( self ):
+    def __init__( self ) -> None:
+        """Constructor."""
         super().__init__(
             fluid=True,
             classes="pa-0 ma-0",
@@ -31,31 +31,32 @@ def __init__( self ):
 
         self.generate_alert_ui()
 
-    def generate_alert_ui( self ):
-        """
-        Generate the alert UI.
+    def generate_alert_ui( self ) -> None:
+        """Generate the alert UI.
 
         The alert will be displayed in the bottom right corner of the screen.
 
         Use an abritary z-index value to put the alert on top of the other components.
         """
-        with self:
-            with vuetify3.VCol( style="width: 40%; position: fixed; right: 50px; bottom: 50px; z-index: 100;", ):
-                vuetify3.VAlert(
-                    style="max-height: 20vh; overflow-y: auto",
-                    classes="ma-2",
-                    v_for=( "(status, index) in alerts", ),
-                    key="status",
-                    type=( "status.type", "info" ),
-                    text=( "status.message", "" ),
-                    title=( "status.title", "" ),
-                    closable=True,
-                    click_close=( self.on_close, f"[status.id]" ),
-                )
-
-    def add_alert( self, type: str, title: str, message: str ):
-        """
-        Add a status to the stack with a unique id.
+        with (
+                self,
+                vuetify3.VCol( style="width: 40%; position: fixed; right: 50px; bottom: 50px; z-index: 100;", ),
+        ):
+            vuetify3.VAlert(
+                style="max-height: 20vh; overflow-y: auto",
+                classes="ma-2",
+                v_for=( "(status, index) in alerts", ),
+                key="status",
+                type=( "status.type", "info" ),
+                text=( "status.message", "" ),
+                title=( "status.title", "" ),
+                closable=True,
+                click_close=( self.on_close, "[status.id]" ),
+            )
+
+    def add_alert( self, type: str, title: str, message: str ) -> None:
+        """Add a status to the stack with a unique id.
+
         If there are more than 5 alerts displayed, remove the oldest.
         A warning will be automatically closed after 10 seconds.
         """
@@ -77,21 +78,15 @@ def add_alert( self, type: str, title: str, message: str ):
         if type == "warning":
             asyncio.get_event_loop().call_later( self.__lifetime_of_alert, self.on_close, alert_id )
 
-    async def add_warning( self, title: str, message: str ):
-        """
-        Add an alert of type "warning"
-        """
+    async def add_warning( self, title: str, message: str ) -> None:
+        """Add an alert of type 'warning'."""
         self.add_alert( "warning", title, message )
 
-    async def add_error( self, title: str, message: str ):
-        """
-        Add an alert of type "error"
-        """
+    async def add_error( self, title: str, message: str ) -> None:
+        """Add an alert of type 'error'."""
         self.add_alert( "error", title, message )
 
-    def on_close( self, alert_id ):
-        """
-        Remove in the state the alert associated to the given id.
-        """
+    def on_close( self, alert_id: int ) -> None:
+        """Remove in the state the alert associated to the given id."""
         self.state.alerts = list( filter( lambda i: i[ "id" ] != alert_id, self.state.alerts ) )
         self.state.flush()

geos-trame/geos_trame/app/utils/properties_checker.py renamed to geos-trame/geos_trame/app/components/properties_checker.py

@@ -1,55 +1,69 @@
 # SPDX-License-Identifier: Apache-2.0
 # SPDX-FileCopyrightText: Copyright 2023-2024 TotalEnergies.
 # SPDX-FileContributor: Kitware
+from typing import Any
 
 from trame_client.widgets.core import AbstractElement
 from trame_simput import get_simput_manager
 
 from geos_trame.app.data_types.field_status import FieldStatus
 from geos_trame.app.deck.tree import DeckTree
 from geos_trame.app.ui.viewer.regionViewer import RegionViewer
+from geos_trame.app.utils.geos_utils import group_name_ref_array_to_list
 
-attributes_to_check = [ "region_attribute", "fields_to_import", "surfacicFieldsToImport" ]
+# Doc reference: https://geosx-geosx.readthedocs-hosted.com/en/latest/docs/sphinx/datastructure/CompleteXMLSchema.html
+attributes_to_check = [ ( "region_attribute", str ), ( "fields_to_import", list ), ( "surfacicFieldsToImport", list ) ]
 
 
 class PropertiesChecker( AbstractElement ):
-    """
-    Class to check the validity of properties within a deck tree.
-    """
+    """Validity checker of properties within a deck tree."""
 
-    def __init__( self, tree: DeckTree, region_viewer: RegionViewer, **kwargs ):
+    def __init__( self, tree: DeckTree, region_viewer: RegionViewer, **kwargs: Any ) -> None:
+        """Constructor."""
         super().__init__( "div", **kwargs )
 
         self.tree = tree
         self.region_viewer = region_viewer
         self.simput_manager = get_simput_manager( id=self.state.sm_id )
 
-    def check_fields( self ):
-        """
-        Get the names of all the cell data arrays from the input of the region viewer, then check that all the attributes
-        in `attributes_to_check` have a value corresponding to one of the array names.
+    def check_fields( self ) -> None:
+        """Check all the fields in the deck_tree.
+
+        Get the names of all the cell data arrays from the input of the region viewer, then check that
+        all the attributes in `attributes_to_check` have a value corresponding to one of the array names.
         """
         cellData = self.region_viewer.input.GetCellData()
         arrayNames = [ cellData.GetArrayName( i ) for i in range( cellData.GetNumberOfArrays() ) ]
-        arrayNames.extend( [ "", "{}" ] )  # default values
         for field in self.state.deck_tree:
             self.check_field( field, arrayNames )
         self.state.dirty( "deck_tree" )
         self.state.flush()
 
-    def check_field( self, field, array_names: list[ str ] ):
-        """
-        Check that all the attributes in `attributes_to_check` have a value corresponding to one of the array names.
+    def check_field( self, field: dict, array_names: list[ str ] ) -> None:
+        """Check that all the attributes in `attributes_to_check` have a value corresponding to one of the array names.
+
         Set the `valid` property to the result of this check, and if necessary, indicate which properties are invalid.
         """
         field[ "valid" ] = FieldStatus.VALID.value
         field[ "invalid_properties" ] = []
 
         proxy = self.simput_manager.proxymanager.get( field[ "id" ] )
         if proxy is not None:
-            for attr in attributes_to_check:
-                if attr in proxy.definition and proxy[ attr ] not in array_names:
-                    field[ "invalid_properties" ].append( attr )
+            for attr, expected_type in attributes_to_check:
+                if attr in proxy.definition:
+                    if ( expected_type is str and proxy[ attr ]  # value is not empty (valid)
+                         and proxy[ attr ] not in array_names  # value is not in the expected names
+                        ):
+                        field[ "invalid_properties" ].append( attr )
+                    elif expected_type is list:
+                        arrays: list[ str ] | None = group_name_ref_array_to_list( proxy[ attr ] )
+                        if arrays is None:
+                            field[ "invalid_properties" ].append( attr )
+                            continue
+                        for array_name in arrays:
+                            if array_name not in array_names:
+                                field[ "invalid_properties" ].append( attr )
+                                break
 
         if len( field[ "invalid_properties" ] ) != 0:
             field[ "valid" ] = FieldStatus.INVALID.value

geos-trame/geos_trame/app/core.py

@@ -6,14 +6,17 @@
 from trame.decorators import TrameApp
 from trame.widgets import html, simput
 from trame.widgets import vuetify3 as vuetify
+from trame_server import Server
+from trame_server.controller import Controller
+from trame_server.state import State
 from trame_simput import get_simput_manager
 
 from geos_trame import module
 from geos_trame.app.deck.tree import DeckTree
 from geos_trame.app.io.data_loader import DataLoader
 from geos_trame.app.ui.viewer.regionViewer import RegionViewer
 from geos_trame.app.ui.viewer.wellViewer import WellViewer
-from geos_trame.app.utils.properties_checker import PropertiesChecker
+from geos_trame.app.components.properties_checker import PropertiesChecker
 from geos_trame.app.ui.editor import DeckEditor
 from geos_trame.app.ui.inspector import DeckInspector
 from geos_trame.app.ui.plotting import DeckPlotting
@@ -27,8 +30,8 @@
 @TrameApp()
 class GeosTrame:
 
-    def __init__( self, server, file_name: str ):
-
+    def __init__( self, server: Server, file_name: str ) -> None:
+        """Constructor."""
         self.alertHandler: AlertHandler | None = None
         self.deckPlotting: DeckPlotting | None = None
         self.deckViewer: DeckViewer | None = None
@@ -77,26 +80,32 @@ def __init__( self, server, file_name: str ):
         self.build_ui()
 
     @property
-    def state( self ):
+    def state( self ) -> State:
+        """Getter for the state."""
         return self.server.state
 
     @property
-    def ctrl( self ):
+    def ctrl( self ) -> Controller:
+        """Getter for the controller."""
         return self.server.controller
 
-    def set_input_file( self, file_name ):
-        """sets the input file of the InputTree object and populates simput/ui"""
+    def set_input_file( self, file_name: str ) -> None:
+        """Sets the input file of the InputTree object and populates simput/ui."""
         self.tree.set_input_file( file_name )
 
-    def deck_ui( self ):
-        """Generates the UI for the deck edition / visualization tab"""
+    def deck_ui( self ) -> None:
+        """Generates the UI for the deck edition / visualization tab."""
         with vuetify.VRow( classes="mb-6 fill-height" ):
             with vuetify.VCol(
                     cols=2,
                     order=1,
             ):
                 self.deckInspector = DeckInspector( source=self.tree, classes="fit-content" )
-                vuetify.VBtn( text="Check fields", classes="ma-4", click=( self.properties_checker.check_fields, ) )
+                vuetify.VBtn(
+                    text="Check fields",
+                    classes="ma-4",
+                    click=( self.properties_checker.check_fields, ),
+                )
 
             with vuetify.VCol(
                     cols=10,
@@ -133,9 +142,8 @@ def deck_ui( self ):
                             style="flex: 1; height: 40%; width: 100%;",
                         )
 
-    def build_ui( self ):
-        """Generates the full UI for the GEOS Trame Application"""
-
+    def build_ui( self ) -> None:
+        """Generates the full UI for the GEOS Trame Application."""
         with VAppLayout( self.server ) as layout:
             self.simput_widget.register_layout( layout )
 
@@ -154,18 +162,20 @@ def build_ui( self ):
                         style=
                         "position: absolute; top: 0; left: 0; height: 100%; width: 100%; display: flex; align-items: center; justify-content: center;",
                 ):
-                    with html.Div(
-                            v_if=( "tab_idx == 0", ),
-                            style=
-                            "height: 100%; width: 100%; display: flex; align-items: center; justify-content: flex-end;",
-                    ):
-                        with vuetify.VBtn(
+                    with (
+                            html.Div(
+                                v_if=( "tab_idx == 0", ),
+                                style=
+                                "height: 100%; width: 100%; display: flex; align-items: center; justify-content: flex-end;",
+                            ),
+                            vuetify.VBtn(
                                 click=self.tree.write_files,
                                 icon=True,
                                 style="z-index: 1;",
                                 id="save-button",
-                        ):
-                            vuetify.VIcon( "mdi-content-save-outline" )
+                            ),
+                    ):
+                        vuetify.VIcon( "mdi-content-save-outline" )
 
                     with html.Div(
                             style=

geos-trame/geos_trame/app/data_types/renderable.py

@@ -5,6 +5,7 @@
 
 
 class Renderable( Enum ):
+    """Enum class for renderable types and their ids."""
     VTKMESH = "VTKMesh"
     INTERNALMESH = "InternalMesh"
     INTERNALWELL = "InternalWell"

geos-trame/geos_trame/app/data_types/tree_node.py

@@ -3,14 +3,17 @@
 # SPDX-FileContributor: Kitware
 from dataclasses import dataclass
 
-from geos_trame.app.data_types.field_status import FieldStatus
-
 
 @dataclass
 class TreeNode:
+    """Single element of the tree, used by `DeckTree`.
+
+    `valid` has to be an int for serialization purposes, but is actually a FieldStatus so only possibles values are:
+        - 0 (UNCHECKED): Validity check has not been performed.
+        - 1 (VALID): TreeNode is checked and valid.
+        - 2 (INVALID): TreeNode is checked and invalid.
     """
-    Single element of the tree, used by `DeckTree`.
-    """
+
     id: str
     title: str
     children: list
@@ -21,22 +24,13 @@ class TreeNode:
 
     @property
     def json( self ) -> dict:
-        if self.children:
-            return dict(
-                id=self.id,
-                title=self.title,
-                is_drawable=self.is_drawable,
-                drawn=self.drawn,
-                valid=self.valid,
-                children=[ c.json for c in self.children ],
-                hidden_children=[ c.json for c in self.hidden_children ],
-            )
-        return dict(
-            id=self.id,
-            title=self.title,
-            is_drawable=self.is_drawable,
-            drawn=self.drawn,
-            valid=self.valid,
-            children=None,
-            hidden_children=[],
-        )
+        """Get the tree node as json."""
+        return {
+            "id": self.id,
+            "title": self.title,
+            "is_drawable": self.is_drawable,
+            "drawn": self.drawn,
+            "valid": self.valid,
+            "children": [ c.json for c in self.children ] if self.children else None,
+            "hidden_children": ( [ c.json for c in self.hidden_children ] if self.hidden_children else [] ),
+        }