Input Validation

[matekelemen]

I like how the Parameters class validates the keys and value types of the input, but most of the time the values themselves have to go through a second round of validation on-site, where the Parameters instance is used (eg.: restricting buffer_size to positive integers).

A friend of mine started working on a project that validates configuration files against a "schema", essentially restricting values with regular expressions. This allows constraining not only the types of the parameters, but also their values (eg.: ranges of values, specific strings, a certain set of characters, etc.). I think this is a neat idea that we could use too.

I know that Parameters are heavily used in Kratos and there's no way to retroactively adapt every use case, but an extension to Parameters could be implemented with this functionality that could be used later on. Any thoughts on this?

Example:

Current example:

class DemoProcess(KratosMultiphysics.Process):
    def __init__(self, model_part, parameters):
        KratosMultiphysics.Process.__init__(self)

        # --- Validate input types ---
        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters())

        # --- Validate input values ---
        # model_part_name: non-empty string
        if not parameters["model_part_name"].GetString():
            raise ValueError("'model_part_name' must not be empty!")

        # buffer_size: positive integer
        if not parameters["buffer_size"].GetInt() > 0:
            raise ValueError("'buffer_size' must be a positive integer!")

        # scheme: "explicit" or "implicit"
        if not parameters["scheme"].GetString() in ("explicit", "implicit"):
            raise ValueError("Invalid 'scheme'. Options are: 'explicit', 'implicit'!")
        
        # Do other stuff the process was actually created for
        # ...

    @staticmethod
    def GetDefaultParameters():
        return KratosMultiphysics.Parameters("""{
            "model_part_name" : "",
            "buffer_size"     : 1,
            "scheme"          : "explicit",
        }""")

Same example with suggested features:

class DemoProcess(KratosMultiphysics.Process):
    def __init__(self, model_part, parameters):
        KratosMultiphysics.Process.__init__(self)

        # --- Validate input types and values ---
        parameters.ValidateAndAssignDefaults(self.GetDefaultParameters(), self.GetParametersPattern())
        
        # Do other stuff the process was actually created for
        # ...

    @staticmethod
    def GetDefaultParameters():
        return KratosMultiphysics.Parameters("""{
            "model_part_name" : "",
            "buffer_size"     : 1,
            "scheme"          : "explicit",
        }""")

    @staticmethod
    def GetParametersPattern():
        # model_part_name can be anything, so it's not included in the regex
        return KratosMultiphysics.Parameters("""{
            "buffer_size"     : "^[1-9]\d*$",
            "scheme"          : "(?=(explicit|implicit))",
        }""")

[loumalouomega]

@KratosMultiphysics/technical-committee has the JSON schema in mind for this pourpose

[matekelemen]

Ah I haven't heard about that, thanks! Can you point me to where it's being tracked?

[loumalouomega]

https://json-schema.org/

[loumalouomega]

https://github.com/pboettch/json-schema-validator

[matekelemen]

that's very nice! Any plans on when it will be adopted by Kratos?

[loumalouomega]

If I had time...

[matekelemen]

Let me know if you have an idea on how it should look like, I might be able to help you with implementing it.

[rubenzorrilla]

I remember discussing about this in #653.

[matekelemen]

I see it was expanded on in #5106, and I agree that we should use the standard if it already exists for this purpose. If there's a general idea on how and where it should be adopted in Kratos, I can help with implementing it.