gammasimtools 0.23.0__py3-none-any.whl → 0.24.0__py3-none-any.whl

simtools/data_model/model_data_writer.py

@@ -186,7 +186,7 @@ class ModelDataWriter:
         ValueError
             If parameter with the same version exists in the database.
         """
-        db = db_handler.DatabaseHandler(mongo_db_config=db_config)
+        db = db_handler.DatabaseHandler(db_config=db_config)
         try:
             db.get_model_parameter(
                 parameter=parameter_name,

simtools/data_model/schema.py

@@ -4,12 +4,9 @@ import logging
 from pathlib import Path
 
 import jsonschema
-from packaging.specifiers import SpecifierSet
-from packaging.version import Version
 from referencing import Registry, Resource
 
 import simtools.utils.general as gen
-from simtools import version
 from simtools.constants import (
     METADATA_JSON_SCHEMA,
     MODEL_PARAMETER_METASCHEMA,
@@ -17,8 +14,10 @@ from simtools.constants import (
     SCHEMA_PATH,
 )
 from simtools.data_model import format_checkers
+from simtools.dependencies import get_software_version
 from simtools.io import ascii_handler
 from simtools.utils import names
+from simtools.version import check_version_constraint
 
 _logger = logging.getLogger(__name__)
 
@@ -96,7 +95,7 @@ def get_model_parameter_schema_version(schema_version=None):
 
 
 def validate_dict_using_schema(
-    data, schema_file=None, json_schema=None, ignore_software_version=False
+    data, schema_file=None, json_schema=None, ignore_software_version=False, offline=False
 ):
     """
     Validate a data dictionary against a schema.
@@ -124,7 +123,7 @@ def validate_dict_using_schema(
     if json_schema is None:
         json_schema = load_schema(schema_file, get_schema_version_from_data(data))
 
-    _validate_deprecation_and_version(data, ignore_software_version)
+    validate_deprecation_and_version(data, ignore_software_version=ignore_software_version)
 
     validator = jsonschema.Draft6Validator(
         schema=json_schema,
@@ -137,6 +136,16 @@ def validate_dict_using_schema(
     except jsonschema.exceptions.ValidationError as exc:
         _logger.error(f"Validation failed using schema: {json_schema} for data: {data}")
         raise exc
+
+    if not offline:
+        _validate_meta_schema_url(data)
+
+    _logger.debug(f"Successful validation of data using schema ({json_schema.get('name')})")
+    return data
+
+
+def _validate_meta_schema_url(data):
+    """Validate meta_schema_url if present in data."""
     if (
         isinstance(data, dict)
         and data.get("meta_schema_url")
@@ -144,9 +153,6 @@ def validate_dict_using_schema(
     ):
         raise FileNotFoundError(f"Meta schema URL does not exist: {data['meta_schema_url']}")
 
-    _logger.debug(f"Successful validation of data using schema ({json_schema.get('name')})")
-    return data
-
 
 def _retrieve_yaml_schema_from_uri(uri):
     """Load schema from a file URI."""
@@ -307,9 +313,7 @@ def _add_array_elements(key, schema):
     return schema
 
 
-def _validate_deprecation_and_version(
-    data, software_name="simtools", ignore_software_version=False
-):
+def validate_deprecation_and_version(data, software_name=None, ignore_software_version=False):
     """
     Check if data contains deprecated parameters or version mismatches.
 
@@ -317,39 +321,37 @@ def _validate_deprecation_and_version(
     ----------
     data: dict
         Data dictionary to check.
-    software_name: str
-        Name of the software to check version against.
+    software_name: str or None
+        Name of the software to check version against. If None, use complete list
     ignore_software_version: bool
         If True, ignore software version check.
     """
     if not isinstance(data, dict):
         return
 
+    data_name = data.get("name", "<unknown>")
+
     if data.get("deprecated", False):
         note = data.get("deprecation_note", "(no deprecation note provided)")
-        _logger.warning(f"Data is deprecated. Note: {note}")
+        _logger.warning(f"Data for {data_name} is deprecated. Note: {note}")
 
-    def check_version(sw):
-        constraint = sw.get("version")
-        if constraint is None:
-            return
-        constraint = constraint.strip()
-        spec = SpecifierSet(constraint, prereleases=True)
-        if Version(version.__version__) in spec:
+    for sw in data.get("simulation_software", []):
+        name, constraint = sw.get("name"), sw.get("version")
+        if not name or not constraint:
+            continue
+        if software_name is not None and name.lower() != software_name.lower():
+            continue
+
+        software_version = get_software_version(name)
+        if check_version_constraint(software_version, constraint):
             _logger.debug(
-                f"Version {version.__version__} of {software_name} matches constraint {constraint}."
+                f"{data_name}: version {software_version} of {name} matches "
+                f"constraint {constraint}."
             )
+            continue
+
+        msg = f"{data_name}: version {software_version} of {name} does not match {constraint}."
+        if ignore_software_version:
+            _logger.warning(f"{msg}, but version check is ignored.")
         else:
-            msg = (
-                f"Version {version.__version__} of {software_name} "
-                f"does not match constraint {constraint}."
-            )
-            if ignore_software_version:
-                _logger.warning(f"{msg}, but version check is ignored.")
-                return
             raise ValueError(msg)
-
-    for sw in data.get("simulation_software", []):
-        if sw.get("name") == software_name:
-            check_version(sw)
-            break