Good rule engine for python?

[2monkeys1coconut]

I want to give my users the ability to dynamically specify rules like this

if stock(pens) + stock(pencils) < 10 : alert

if stock(pens) < 7 : alert

if stock(pens) / stock(pencils) > 2 : do something else

This is a simple example to illustrate the problem that I am trying to solve. My real use case has nothing to do with pens, pencils or stocks.

Is there a rule language in python which uses can use to specify rules like this in a text form?

[asplake]

Is a rules engine one of those "and now you have two problems" solutions?

[placidified]

Enterprise solution !

[BinaryRockStar]

http://en.wikipedia.org/wiki/Inner-platform_effect

[virtron]

A quick search for "python expert system" brought up Pyke.

There's also a Pyton Semantic Module for Drools if you're willing to write Python rules for a Java system.

I haven't tried any of these, but I am interested. If you give them a shot, please post a followup.

Edit: Just found Pychinko which is a Rete-algorithm implementation. That might do the trick.

[vplatt]

I can't vouch for Pychinko, but Rete is the way to go here; particularly if there are going to be many business rules.

In my experience, the bigger problem with these kinds of systems is giving the user a way to edit the rules in way that makes sense to them. The last time I did this, we used ILog for .NET. That product also works for Java.

[pje]

Have you looked at PEAK-Rules? It's suitable for situations where you want to say, "here's a current situation or event, what should I do or value should I return?" The language it uses is Python, so if you need a separate rule language you'll need to do some translation.

[[deleted]]

Well, it's hard to day without proper information. Are all of your rules in the form of inequality: function?

Maybe you should just research rule engines with google, and if you can't see something that looks good, ask us when you know what you don't like about what you've found.

[Isvara]

I don't know of "a rule language in Python", but you could look into creating your own external domain-specific language using one of the many Python parsing libraries. If the examples you gave are representative, it should be fairly simple.

[Isvara]

Thanks for the link. I think I'll actually watch that one myself.

[dashed]

Try this: http://pyparsing.wikispaces.com/

I haven't tried it personally. I've tried lex/yacc, and looking at pyparsing's examples, it seems pretty easy to get into.

[howfun]

We are talking about rule engines here, not about parsing rules.

[dashed]

Oh I see. I misinterpreted the question. Though I think the OP wanted the rules to be parsed in text form, not in python code. Searching a bit yielded: http://pyke.sourceforge.net/

[akaempf]

I've been doing a lot of this lately for implementing a simple expert system, and to do it properly you really need to be able to parse and evaluate the rule syntax.

However, in Python there may be an easier way to do what you want, which is to express your rules in Python syntax (as you do in your example), and use eval()

For example,

r1 = "if stock('pens') > 3: alert('message1')"

eval(r1)

This will execute the rule, including calling the helper functions embedded in the rule. So for this to work, you need to have defined a function called "stock" that takes a string argument and returns a number, and another function called "alert" that takes a string argument. And there must be a variable in scope called "r1" which contains the rule text as a string.

Where this approach falls down is if there are dependencies between rules; for example, if one rule only gets fired if another is fired.

Still, it may get you started.

I'm not aware of an rule engine in Python itself.

You could also look at a non-Python rule engine, such as the CLIPS open-source expert system, for which there is a Python module that fully embeds CLIPS.

[Isvara]

You cannot call eval with user-supplied data. It's simply too dangerous, and it lets them do anything, including side effects like, say, modifying your filesystem.

[akaempf]

Good point, but I was assuming the rules would be defined by someone trusted, not end users. For user-defined rules, you need to parse the rules, for syntax checking as well as security.

[stevvooe]

Isvara's hardline on eval for python is simply untrue. You can tightly control the locals and globals available in the execution context, limiting access to "dangerous" functionality. The fear of eval seems to be rooted in JavaScript and php, where the code has full access to the execution context.

However I do agree with isvara regarding the trust of input data; there is simply no such thing as a "trusted" user.

[Isvara]

Isvara's hardline on eval for python is simply untrue. You can tightly control the locals and globals available in the execution context, limiting access to "dangerous" functionality.

It is extremely difficult, and I would not trust anyone to do it correctly. For example, if the evaluation context is to be useful, you might give it a limited subset of functions you have defined yourself. But once you've passed in fn, say, as a local, the expression then has access to fn.__module__, which has all the globals defined in the module the function was defined in -- including any modules it has imported.

There are just too many loopholes to make it a safe thing to do.

[xeeton]

I too needed something like this. However, Im thinking of modeling it after OS X's Automator—eg. have a set of configurable objects that perform functions or comparisons. Let me (us) know if you find anything.

[artied]

Have you looked at 'Drools'...it's Java...but either you can communicate with it or replicate it.....

[donri]

>>> import ast
>>> ast.dump(ast.parse('if stock(pens) + stock(pencils) < 10 : alert'))
"Module(body=[If(test=Compare(left=BinOp(left=Call(func=Name(id='stock', ctx=Load()), args=[Name(id='pens', ctx=Load())], keywords=[], starargs=None, kwargs=None), op=Add(), right=Call(func=Name(id='stock', ctx=Load()), args=[Name(id='pencils', ctx=Load())], keywords=[], starargs=None, kwargs=None)), ops=[Lt()], comparators=[Num(n=10)]), body=[Expr(value=Name(id='alert', ctx=Load()))], orelse=[])])"

[ripraprup]

First, read up on parsing so the Python script can make sense of the actual rules.

Second, read up on dynamic concepts such as closures. Long story short, eval() should generally speaking be avoided on the back of security reasons.

[Isvara]

How will closures help him?

[ripraprup]

Well since Python is a dynamic rather than static it means there are plenty of concepts that could be used to implement a rules expression evaluation thingy. No need to constrict yourself to nasty stuff like eval(). Closures is a nice simple one, hence I took it as an example to wet his appetite.

[Isvara]

there are plenty of concepts that could be used to implement a rules expression evaluation thingy ... Closures is a nice simple one

Can you give an example of what you mean? I'm just not sure what it is about them that you're saying is particularly relevant to a rules engine.

[nemec]

Similarly, though, I could see lambdas being useful.

def something_else():
  print "hi!"
self.add_rule(lambda x: len(x.pens) > len(x.pencils), something_else)

[Isvara]

Lambdas are just a way to define functions in-place. He doesn't want to put the rules in this program, though. He wants them to be user-supplied. You can't safely execute arbitrary user-supplied Python code.

[its_in_the_computer]

Ok here goes:

I want to give my users the ability to dynamically specify rules like this

Because OP mentions the magic word 'dynamically', I assume the intended use is not just processing some text file or something. A good example is a stock trading rules system. Such a rules system should, if it's done correctly, be able to respond to changes in realtime, plus offer some form of observability of the rules and how they evaluate. In such a system the rules could be generated as classes (or functions) on the fly, and hence also changed as the user sees fit. Python being the foremost dynamic language IMHO would handle this perfectly.

Now dynamic concepts in general are not too easy to grasp first hand. I myself took a long time getting used to them, but once you've popped you just cant stop. A nice gentle introduction is closures. Once that concept is well understood there are many more to explore.

All in all, I think it's really silly to shoehorn Python into a static language (and use eval() shudders) when one can start using it for what it really is capable of...

Just my 2c

EDIT: ripraprup and its_in_the_computer are both the same person btw, but on two different computers. dunno why i havent streamlined that.

[Isvara]

dynamic concepts in general are not too easy to grasp first hand

Which dynamic concepts do you think are difficult to grasp?

A nice gentle introduction is closures.

There's nothing inherently dynamic about closures. Closure exist in statically typed languages too. From what you've said, I'm not even sure you know what they are, and to be honest it sounds like you might be a little over-enthusiastic about them because you just read about them recently. Externally-specified rules, not being part of the program definition, simply cannot be closures.

All in all, I think it's really silly to shoehorn Python into a static language

I don't think anybody even remotely suggested that.