Support schema 300 (settings)

pyproject.toml

@@ -19,7 +19,7 @@ dependencies = [
     "Click",
     "GeoAlchemy2>=0.9,!=0.11.*",
     "SQLAlchemy>=1.4",
-    "threedi-schema==0.220.*"
+    "threedi-schema@https://github.com/nens/threedi-schema/archive/refs/heads/margriet_46_schema_300.zip"
 ]
 
 [project.optional-dependencies]

threedi_modelchecker/checks/geo_query.py

@@ -8,7 +8,7 @@
 
 
 def epsg_code_query():
-    epsg_code = Query(models.GlobalSetting.epsg_code).limit(1).scalar_subquery()
+    epsg_code = Query(models.ModelSettings.epsg_code).limit(1).scalar_subquery()
     return func.coalesce(epsg_code, literal(DEFAULT_EPSG)).label("epsg_code")
 
 

threedi_modelchecker/checks/other.py

@@ -10,15 +10,6 @@
 from .cross_section_definitions import cross_section_configuration
 from .geo_query import distance, length, transform
 
-# Use these to make checks only work on the first global settings entry:
-first_setting = (
-    Query(models.GlobalSetting.id)
-    .order_by(models.GlobalSetting.id)
-    .limit(1)
-    .scalar_subquery()
-)
-first_setting_filter = models.GlobalSetting.id == first_setting
-
 
 class CorrectAggregationSettingsExist(BaseCheck):
     """Check if aggregation settings are correctly filled with aggregation_method and flow_variable as required"""
@@ -30,25 +21,19 @@ def __init__(
         *args,
         **kwargs,
     ):
-        super().__init__(column=models.GlobalSetting.id, *args, **kwargs)
+        super().__init__(column=models.ModelSettings.id, *args, **kwargs)
         self.aggregation_method = aggregation_method.value
         self.flow_variable = flow_variable.value
 
     def get_invalid(self, session: Session) -> List[NamedTuple]:
-        global_settings = self.to_check(session).filter(first_setting_filter)
+        global_settings = self.to_check(session)
         correctly_defined = session.execute(
-            select(models.AggregationSettings)
-            .filter(
+            select(models.AggregationSettings).filter(
                 models.AggregationSettings.aggregation_method
                 == self.aggregation_method,
                 models.AggregationSettings.flow_variable == self.flow_variable,
             )
-            .filter(
-                models.AggregationSettings.global_settings_id
-                == global_settings.subquery().c.id
-            )
         ).all()
-
         return global_settings.all() if len(correctly_defined) == 0 else []
 
     def description(self) -> str:
@@ -244,12 +229,14 @@ class Use0DFlowCheck(BaseCheck):
     """
 
     def __init__(self, *args, **kwargs):
-        super().__init__(column=models.GlobalSetting.use_0d_inflow, *args, **kwargs)
+        super().__init__(
+            column=models.SimulationTemplateSettings.use_0d_inflow, *args, **kwargs
+        )
 
     def to_check(self, session):
         """Return a Query object on which this check is applied"""
-        return session.query(models.GlobalSetting).filter(
-            models.GlobalSetting.use_0d_inflow != 0
+        return session.query(models.SimulationTemplateSettings).filter(
+            models.SimulationTemplateSettings.use_0d_inflow != 0
         )
 
     def get_invalid(self, session):
@@ -301,7 +288,7 @@ def get_invalid(self, session):
 class ConnectionNodesLength(BaseCheck):
     """Check that the distance between `start_node` and `end_node` is at least
     `min_distance`. The coords will be transformed into (the first entry) of
-    GlobalSettings.epsg_code.
+    ModelSettingss.epsg_code.
     """
 
     def __init__(
@@ -469,7 +456,7 @@ def description(self) -> str:
 
 class OpenChannelsWithNestedNewton(BaseCheck):
     """Checks whether the model has any closed cross-section in use when the
-    NumericalSettings.use_of_nested_newton is turned off.
+    NumericalSettings.use_nested_newton is turned off.
 
     See https://github.com/nens/threeditoolbox/issues/522
     """
@@ -479,7 +466,7 @@ def __init__(self, level=CheckLevel.WARNING, *args, **kwargs):
             column=models.CrossSectionDefinition.id,
             level=level,
             filters=Query(models.NumericalSettings)
-            .filter(models.NumericalSettings.use_of_nested_newton == 0)
+            .filter(models.NumericalSettings.use_nested_newton == 0)
             .exists(),
             *args,
             **kwargs,
@@ -532,8 +519,8 @@ def get_invalid(self, session: Session) -> List[NamedTuple]:
     def description(self) -> str:
         return (
             f"{self.column_name} has a closed cross section definition while "
-            f"NumericalSettings.use_of_nested_newton is switched off. "
-            f"This gives convergence issues. We recommend setting use_of_nested_newton = 1."
+            f"NumericalSettings.use_nested_newton is switched off. "
+            f"This gives convergence issues. We recommend setting use_nested_newton = 1."
         )
 
 
@@ -731,7 +718,8 @@ def get_invalid(self, session: Session) -> List[NamedTuple]:
             .filter(
                 (models.ConnectionNode.storage_area != None)
                 & (
-                    (  # calculate how many seconds the pumpstation takes to empty its storage: (storage * height)/pump capacity
+                    (
+                        # calculate how many seconds the pumpstation takes to empty its storage: (storage * height)/pump capacity
                         (
                             # Arithmetic operations on None return None, so without this
                             # conditional type cast, no invalid results would be returned
@@ -744,9 +732,7 @@ def get_invalid(self, session: Session) -> List[NamedTuple]:
                         )
                     )
                     / (models.Pumpstation.capacity / 1000)
-                    < Query(models.GlobalSetting.sim_time_step)
-                    .filter(first_setting_filter)
-                    .scalar_subquery()
+                    < Query(models.TimeStepSettings.time_step).scalar_subquery()
                 )
             )
             .all()
@@ -819,7 +805,7 @@ class InflowNoFeaturesCheck(BaseCheck):
     """Check that the surface table in the global use_0d_inflow setting contains at least 1 feature."""
 
     def __init__(self, *args, surface_table, condition=True, **kwargs):
-        super().__init__(*args, column=models.GlobalSetting.id, **kwargs)
+        super().__init__(*args, column=models.ModelSettings.id, **kwargs)
         self.surface_table = surface_table
         self.condition = condition
 
@@ -828,13 +814,13 @@ def get_invalid(self, session: Session):
             select(func.count(self.surface_table.id))
         ).scalar()
         return (
-            session.query(models.GlobalSetting)
+            session.query(models.ModelSettings)
             .filter(self.condition, surface_table_length == 0)
             .all()
         )
 
     def description(self) -> str:
-        return f"v2_global_settings.use_0d_inflow is set to use {self.surface_table.__tablename__}, but {self.surface_table.__tablename__} does not contain any features."
+        return f"model_settings.use_0d_inflow is set to use {self.surface_table.__tablename__}, but {self.surface_table.__tablename__} does not contain any features."
 
 
 class NodeSurfaceConnectionsCheck(BaseCheck):
@@ -1082,3 +1068,76 @@ def _get_records(self, session):
                 )
             )
         )
+
+
+class UsedSettingsPresentCheck(BaseCheck):
+    def __init__(
+        self,
+        column,
+        settings_table,
+        filters=None,
+        level=CheckLevel.ERROR,
+        error_code=0,
+    ):
+        super().__init__(column, filters, level, error_code)
+        self.settings_table = settings_table
+
+    def get_invalid(self, session: Session) -> List[NamedTuple]:
+        # more than 1 row should be caught by another check
+        all_results = self.to_check(session).filter(self.column == True).all()
+        use_cols = len(all_results) > 0
+        if use_cols and session.query(self.settings_table).count() == 0:
+            return all_results
+        return []
+
+    def description(self) -> str:
+        return f"{self.column_name} in {self.table.name} is set to True but {self.settings_table.name} is empty"
+
+
+class SettingsLengthCheck(BaseCheck):
+    def __init__(
+        self,
+        column,
+        filters=None,
+        level=CheckLevel.ERROR,
+        error_code=0,
+        min_length=0,
+        max_length=1,
+    ):
+        super().__init__(column, filters, level, error_code)
+        self.min_length = min_length
+        self.max_length = max_length
+        self.observed_length = 0
+
+    def get_invalid(self, session: Session) -> List[NamedTuple]:
+        # return mock list in case the table is empty when it shouldn't be
+        all_results = self.to_check(session).all()
+        self.observed_length = len(all_results)
+        if (self.observed_length > self.max_length) or (
+            self.observed_length < self.min_length
+        ):
+            return all_results if self.observed_length > 0 else ["foo"]
+        else:
+            return []
+
+    def description(self) -> str:
+        return (
+            f"{self.table.name} has {self.observed_length} rows, "
+            f"but should have at least {self.min_length} rows and "
+            f"at most {self.max_length} rows."
+        )
+
+
+class AggregationSettingsInvervalCheck(BaseCheck):
+    def get_invalid(self, session: Session) -> List[NamedTuple]:
+        return (
+            session.query(models.AggregationSettings, models.TimeStepSettings)
+            .filter(
+                models.AggregationSettings.interval
+                < models.TimeStepSettings.output_time_step
+            )
+            .all()
+        )
+
+    def description(self) -> str:
+        return "aggregation_settings.interval should be smaller than time_step_settings.output_time_step"

threedi_modelchecker/checks/raster.py

@@ -159,7 +159,7 @@ class RasterHasMatchingEPSGCheck(BaseRasterCheck):
     """Check whether a raster's EPSG code matches the EPSG code in the global settings for the SQLite."""
 
     def get_invalid(self, session):
-        epsg_code_query = session.query(models.GlobalSetting.epsg_code).first()
+        epsg_code_query = session.query(models.ModelSettings.epsg_code).first()
         if epsg_code_query is not None:
             self.epsg_code = epsg_code_query[0]
         else:
@@ -175,7 +175,7 @@ def is_valid(self, path: str, interface_cls: Type[RasterInterface]):
             return raster.epsg_code == self.epsg_code
 
     def description(self):
-        return f"The file in {self.column_name} has no EPSG code or the EPSG code does not match does not match v2_global_settings.epsg_code"
+        return f"The file in {self.column_name} has no EPSG code or the EPSG code does not match does not match model_settings.epsg_code"
 
 
 class RasterSquareCellsCheck(BaseRasterCheck):
@@ -202,9 +202,11 @@ class RasterGridSizeCheck(BaseRasterCheck):
     """Check whether the global settings' grid size is an even multiple of a raster's cell size (at least 2x)."""
 
     def get_invalid(self, session):
-        grid_space_query = session.query(models.GlobalSetting.grid_space).first()
-        if grid_space_query is not None:
-            self.grid_space = grid_space_query[0]
+        minimum_cell_size_query = session.query(
+            models.ModelSettings.minimum_cell_size
+        ).first()
+        if minimum_cell_size_query is not None:
+            self.minimum_cell_size = minimum_cell_size_query[0]
         else:
             return []
         return super().get_invalid(session)
@@ -217,17 +219,17 @@ def is_valid(self, path: str, interface_cls: Type[RasterInterface]):
             try:
                 return (
                     isclose(
-                        a=((self.grid_space / raster.pixel_size[0]) % 2),
+                        a=((self.minimum_cell_size / raster.pixel_size[0]) % 2),
                         b=0,
                         rel_tol=1e-09,
                     )
-                ) and (self.grid_space >= (2 * raster.pixel_size[0]))
+                ) and (self.minimum_cell_size >= (2 * raster.pixel_size[0]))
             # if one of the fields is a NoneType it will be caught elsewhere
             except TypeError:
                 return True
 
     def description(self):
-        return "v2_global_settings.grid_space is not a positive even multiple of the raster cell size."
+        return "model_settings.minimum_cell_size is not a positive even multiple of the raster cell size."
 
 
 class RasterPixelCountCheck(BaseRasterCheck):