Decorator to register Python methods in PyCLIPS

Question

I make use of PyCLIPS to integrate CLIPS into Python. Python methods are registered in CLIPS using clips.RegisterPythonFunction(method, optional-name). Since I have to register several functions and want to keep the code clear, I am looking for a decorator to do the registration.

This is how it is done now:

class CLIPS(object):
...
    def __init__(self, data):
        self.data = data
        clips.RegisterPythonFunction(self.pyprint, "pyprint")
    def pyprint(self, value):
        print self.data, "".join(map(str, value))

and this is how I would like to do it:

class CLIPS(object):
...
    def __init__(self, data):
        self.data = data
        #clips.RegisterPythonFunction(self.pyprint, "pyprint")
    @clips_callable
    def pyprint(self, value):
        print self.data, "".join(map(str, value))

It keeps the coding of the methods and registering them in one place.

NB: I use this in a multiprocessor set-up in which the CLIPS process runs in a separate process like this:

import clips
import multiprocessing

class CLIPS(object):
    def __init__(self, data):
        self.environment = clips.Environment()
        self.data = data
        clips.RegisterPythonFunction(self.pyprint, "pyprint")
        self.environment.Load("test.clp")
    def Run(self, cycles=None):
        self.environment.Reset()
        self.environment.Run()
    def pyprint(self, value):
        print self.data, "".join(map(str, value))

class CLIPSProcess(multiprocessing.Process):
    def run(self):
        p = multiprocessing.current_process()
        self.c = CLIPS("%s %s" % (p.name, p.pid))
        self.c.Run()

if __name__ == "__main__":
    p = multiprocessing.current_process()
    c = CLIPS("%s %s" % (p.name, p.pid))
    c.Run()
    # Now run CLIPS from another process
    cp = CLIPSProcess()
    cp.start()

I don't know about Python, I have environment which integrates CLIPS with C#, and registers methods in a loop. But from the name of your method "pyprint" maybe you should use CLIPS routers for routing CLIPS output to Python? — Amittai Shapira, May 16 '12 at 12:54
pyprint is a simple test. I would use Python functions to assert facts and call COOL stuff. — Lemoi, May 16 '12 at 13:11

mata · Answer 1 · 2012-05-16T13:28:10.137

1

it should be fairly simple to do like this:

# mock clips for testing
class clips:
    @staticmethod
    def RegisterPythonFunction(func, name):
        print "register: ", func, name

def clips_callable(fnc):
    clips.RegisterPythonFunction(fnc, fnc.__name__)
    return fnc

@clips_callable
def test(self):
    print "test"

test()

edit: if used on a class method it will register the unbound method only. So it won't work if the function will be called without an instance of the class as the first argument. Therefore this would be usable to register module level functions, but not class methods. To do that, you'll have to register them in __init__.

edited May 16 '12 at 13:28

answered May 16 '12 at 12:57

mata

67,110
10
163
162

Well, it does not work and has the following error: [PYTHONXC1] Call to function pyprint failed. [PRCCODE4] Execution halted during the actions of defrule start-me-up. I think this has to do with the method being unbound as it is registered. The function is registered before the class is instanciated. I need access to data of the instance. – Lemoi May 16 '12 at 13:06
i don't know anything about clips itself, but the decorator works. the problem is probably that the decorator is only executed once when creating the class. the registration has do be done for each instance, then you have to do it within `__init__`. – mata May 16 '12 at 13:15
But how? Somebody suggested a list within the class which is filled using some kind of decorator or recognize the methods on their name and register them in a loop during __init__. I am not very good with stuff like this. – Lemoi May 16 '12 at 14:07
i don't think that would be that easy to do, and probably more work the just register the methods during `__init__` like you're currently doing. – mata May 16 '12 at 14:55

score 0 · Answer 2 · edited May 23 '17 at 10:30

It seems that the elegant solution proposed by mata wouldn't work because the CLIPS environment should be initialized before registering methods to it.
I'm not a Python expert, but from some searching it seems that combination of inspect.getmembers() and hasattr() will do the trick for you - you could loop all members of your class, and register the ones that have the @clips_callable attribute to CLIPS.

score 0 · Accepted Answer · answered May 17 '12 at 09:48

Got it working now by using a decorator to set an attribute on the method to be registered in CLIPS and using inspect in init to fetch the methods and register them. Could have used some naming strategy as well, but I prefer using a decorator to make the registering more explicit. Python functions can be registered before initializing a CLIPS environment. This is what I have done.

import inspect

def clips_callable(func):
    from functools import wraps
    @wraps(func)
    def wrapper(*__args,**__kw):
        return func(*__args,**__kw)
    setattr(wrapper, "clips_callable", True)
    return wrapper

class CLIPS(object):
    def __init__(self, data):
        members = inspect.getmembers(self, inspect.ismethod)
        for name, method in members:
            try:
                if method.clips_callable:
                    clips.RegisterPythonFunction(method, name)
            except:
                pass
...
    @clips_callable
    def pyprint(self, value):
        print self.data, "".join(map(str, value))

For completeness, the CLIPS code in test.clp is included below.

(defrule MAIN::start-me-up
    =>
    (python-call pyprint "Hello world")
)

If somebody knows a more elegant approach, please let me know.

Decorator to register Python methods in PyCLIPS

3 Answers3