What about to compare a value (or regex) against a string or list of string

[nicolas-rdgs]

import rule_engine

samples = [
    {"key": "myvalue"},
    {"key": ["myvalue", "some other string"]}
]

rules = [
	rule_engine.Rule('key == "myvalue"'),
	rule_engine.Rule('key =~ "myvalue"')
]

for sample in samples:
    for rule in rules:
        try:
            print(rule.text, rule.matches(sample))
        except Exception as error:
            print(rule.text, error)

Output:

key == "myvalue" True
key =~ "myvalue" True
key == "myvalue" False
key =~ "myvalue" data type mismatch

In our case, we cannot predict if the value of key could be a string or list of string in advance and we get data type mismatch error despite we combine with array comprehension in the rule.

If we want to manage both cases, string and a list of strings, what's the best approach or what do you think?

[zeroSteiner]

In our case, we cannot predict if the value of key could be a string or list of string in advance

I would recommend normalizing the data and addressing this problem directly. Otherwise you'd need some way to do type checks (which I don't think I support now) and then use some complex list comprehension with conditionals in it.

[nicolas-rdgs]

We are trying to figure out how to normalize the input data (with some difficulties), but if we were to do it with a rule_engine, how would you go about checking the type?

[zeroSteiner]

You don't. There is no #type attribute or isinstance equivalent. I don't think you can access the type through introspection because not knowing it ahead of time kinda breaks one of the core assumptions.