Exemplo n.º 1
0
def loadCLIPS():
    clips.Load(os.path.join('src', 'clips', 'peces.pont'))
    clips.Load(os.path.join('src', 'clips', 'peces.clp'))
    clips.Load(os.path.join('src', 'clips', 'peces.pins'))
    clips.Reset()
    clips.SendCommand('(set-salience-evaluation when-activated)')
    clips.SendCommand('(set-strategy depth)')
    printCLIPS()
    loadFishFromCLIPS(True)
Exemplo n.º 2
0
 def set_value(self, value):
     self._value = value
     if (self._fact):
         sstr = '(bind ?*ans* (modify %d (name %s)) )' % (self._fact,
                                                          self.value)
         clips.SendCommand(sstr)
         self._fact = clips.Eval('?*ans*').Index
Exemplo n.º 3
0
 def set_flag(self, flag, value):
     self.flags[flag] = value
     if (self._fact):
         sstr = '(bind ?*ans* (modify %d (%s %s)) )' % (self._fact, flag,
                                                        value)
         clips.SendCommand(sstr)
         self._fact = clips.Eval('?*ans*').Index
Exemplo n.º 4
0
 def __setitem__(self, name, value):
     'sets the slot by name'
     self._slots[name] = value
     if (self.clips_id != None):
         #notification to clips engine
         clips.SendCommand('(modify %s (%s %s) )' %
                           (self.clips_id, name, value))
Exemplo n.º 5
0
 def set_children(self, children):
     self._children=children
     if(self._fact):
         child_ids=[str(child._id) for child in self.children]
         sstr='(bind ?*ans* (modify %d (children %s)) )' % (self._fact, ' '.join(self.child_ids))
         clips.SendCommand(sstr)
         self._fact=clips.Eval('?*ans*').Index
Exemplo n.º 6
0
 def set_number(self, number):
     self._number=number
     if(number in [MatlabParser.INT,  MatlabParser.FLOAT,  MatlabParser.NUMBER]):
         self.set_flag('is_scalar', True)
     if(self._fact):
         sstr='(bind ?*ans* (modify %d (name %s)) )' % (self._fact, self.name)
         clips.SendCommand(sstr)
         self._fact=clips.Eval('?*ans*').Index
Exemplo n.º 7
0
    def run(self):
        """
        Start or resume an interactive CLIPS shell
        """

        exit_flag = False
        while not exit_flag:
            self.__lineno = 1
            s = ""
            dic = {'cmdno': self.__cmdno, 'lineno': self.__lineno}
            prompt = self.__ps1 % dic
            try:
                while not self.cmd_complete(s):
                    if s:
                        s += " "
                    s += raw_input(prompt).strip()
                    self.__lineno += 1
                    dic = {'cmdno': self.__cmdno, 'lineno': self.__lineno}
                    prompt = self.__ps2 % dic
            except ValueError as e:
                _sys.stderr.write("[SHELL] %s\n" % str(e))
            except EOFError:
                _clips.ErrorStream.Read()
                exit_flag = True
            try:
                if not exit_flag:
                    _clips.SendCommand(s, True)
            except _clips.ClipsError as e:
                _sys.stderr.write("[PYCLIPS] %s\n" % str(e))
            self.__cmdno += 1
            r0 = _clips.StdoutStream.Read()
            r1 = _clips.DisplayStream.Read()
            tx = _clips.TraceStream.Read()
            r = ""
            if r0:
                r += r0
            if r1:
                r += r1
            t = _clips.ErrorStream.Read()
            if r:
                r = "%s\n" % r.rstrip()
            if t:
                t = "%s\n" % t.rstrip()
            if tx:
                t = "%s\n" % tx.rstrip() + t
            if t:
                _sys.stderr.write(t)
            if r:
                _sys.stdout.write(r)
Exemplo n.º 8
0
def add_wrong_rules():
    #reads in from wrong-rule.txt
    file = open("wrong-rule.txt", "r")
    header = file.readline().split()
    ngram, no_of_root_rules = int(header[0]), int(header[1])

    for i in xrange(no_of_root_rules):
        header = file.readline().split()
        root, no_of_subrules = header[0], int(header[1])
        for j in xrange(no_of_subrules):
            root, leaf = file.readline().split("-")
            leaf = leaf.rstrip()
            command = "(assert (wrong-bigram-rule (root %s)(wrong-rule %s %s)))" % (
                root, root, leaf)  #flag for scaling
            clips.SendCommand(command)

    file.close()
Exemplo n.º 9
0
class GrapherClipsShell(object):
    """an interactive CLIPS shell"""
    def __init__(self):
        self.__ps1 = "GRAPHER[%(cmdno)s/%(lineno)s]> "
        self.__ps2 = "GRAPHER[%(cmdno)s/%(lineno)s]: "
        self.__cmdno = 1
        self.__lineno = 1

    def __cmdcomplete(self, cms):
        """check if CLIPS command is complete (stolen from 'commline.c')"""
        def eat_ws(s, i):
            """eat up whitespace"""
            while i < len(s) and s[i] in _string.whitespace:
                i += 1
            return i

        def eat_string(s, i):
            """eat up strings"""
            if s[i] != '"' or i >= len(s): return i
            i += 1
            while i < len(s):
                if s[i] == '"': return i + 1
                else:
                    if s[i] == '\\': i += 1
                    i += 1
            if i > len(s): raise ValueError, "non-terminated string"
            return i

        def eat_comment(s, i):
            """eat up comments"""
            if s[i] != ';' or i >= len(s): return i
            while i < len(s) and s[i] not in '\n\r':
                i += 1
            return i + 1

        s = cms.strip()
        if len(s) == 0: return False
        depth = 0
        i = 0
        while i < len(s):
            c = s[i]
            if c in '\n\r' and depth == 0: return True
            elif c == '"': i = eat_string(s, i)
            elif c == ';': i = eat_comment(s, i)
            elif c == '(':
                depth += 1
                i += 1
            elif c == ')':
                depth -= 1
                i += 1
            elif c in _string.whitespace:
                i = eat_ws(s, i)
            else:
                i += 1
            if depth < 0: raise ValueError, "invalid command"
        if depth == 0: return True
        else: return False

    def InteractiveShellRun(self):
        """start or resume an interactive CLIPS shell"""
        exitflag = False
        while not exitflag:
            self.__lineno = 1
            s = ""
            dic = {'cmdno': self.__cmdno, 'lineno': self.__lineno}
            prompt = self.__ps1 % dic
            try:
                while not self.__cmdcomplete(s):
                    if s: s += " "
                    s += raw_input(prompt).strip()
                    self.__lineno += 1
                    dic = {'cmdno': self.__cmdno, 'lineno': self.__lineno}
                    prompt = self.__ps2 % dic
            except ValueError, e:
                _sys.stderr.write("[SHELL] %s\n" % str(e))
            except EOFError:
                _cm.ErrorStream.Read()
                exitflag = True
            try:
                if not exitflag:
                    _cm.SendCommand(s, True)
            except _cm.ClipsError, e:
                _sys.stderr.write("[PYCLIPS] %s\n" % str(e))
Exemplo n.º 10
0
def add_bigram_as_fact(t1, t2):
    command = "(assert (bigram (tags %s %s) (words \"%s\" \"%s\")))" % (
        t1[1], t2[1], t1[0], t2[0])
    clips.SendCommand(command)  # print command
Exemplo n.º 11
0
def stepCLIPS():
    global PASO
    clips.SendCommand('(run 1)')
    PASO += 1
    loadFishFromCLIPS(False)
    printCLIPS()
Exemplo n.º 12
0
def Run(times=''):
    _clipsLock.acquire()
    clips.SendCommand('(run ' + str(times) + ')')
    _clipsLock.release()
Exemplo n.º 13
0
#with CaptureOutput() as capturer:
#	clips.PrintFacts()
#	print  capturer.get_lines()
#print h
#clips.PrintRules()
#clips.Matches()
clips.Save("rulez.clp")

#clips.Ppdefrule()
#subprocess.call(["ls", "-l"])
#print subprocess.check_output(['ls','-l'])

#clips.FindRule("""ClutchNoise""")
#clips.SendCommand("""(rules)""")
#clips.StdinStream.Write("""(rules)""")
#clips.Build("""rules""")
#t = clips.RuleList()
#clips.Run()
#clips.StdoutStream.Read()
#clips.Call("""ppdefrule""","""EngineStart""")
#print t

clips.SendCommand("(assert (Engine fails to start))")
clips.SendCommand("(assert (Spark is good))")
#clips.SendCommand("(ppdefrule "+"EngineStart"+")")
#clips.Run()
#clips.PrintFacts()
#sys.stdout = open("/dev/stdout", "w")

clips.PrintRules()
Exemplo n.º 14
0
def system_run(input_ set):
    if 'hazard' in input_set:
        clips.Clear()
        clips.Reset()

        eng_var[:]=[]

        eng_var.append(input_set['lat'])

        eng_var.append(input_set['long'])

        eng_var.append(clips.BuildTemplate("entity", """
        (slot aid (type STRING))
        (slot latitude (type NUMBER))
        (slot longitude (type NUMBER))
        (slot quantity (type NUMBER))
        """, "template for a entity"))

        eng_var.append(clips.BuildTemplate("allies", """
        (slot username (type STRING))
        (slot foraid (type STRING))
        (slot action (type STRING))
        (slot quantity (type NUMBER))
        """, "template for a allies"))

        eng_var.append(input_set['control'])

        eng_var.append(clips.BuildTemplate("disaster", """
        (slot hazard (type STRING))
        (slot latitude (type NUMBER))
        (slot longitude (type NUMBER))
        (slot span (type NUMBER))
        """, "template for a disaster"))

        d=clips.Fact(eng_var[5])
        d.Slots['hazard'] = input_set['hazard']
        d.Slots['latitude'] = input_set['lat']
        d.Slots['longitude'] = input_set['long']
        d.Slots['span'] = input_set['span']
        d.Assert()

        facts[:] = []
        fields[:] = []
        list_map[:] = []

        clips.RegisterPythonFunction(invoke_pronearea)
        clips.RegisterPythonFunction(display_disaster)
        clips.RegisterPythonFunction(invoke_entity)
        clips.RegisterPythonFunction(invoke_useralert)
        clips.RegisterPythonFunction(invoke_user_allocate )
        clips.RegisterPythonFunction(invoke_user_deallocate)
        clips.RegisterPythonFunction(invoke_message)
        clips.RegisterPythonFunction(invoke_alert_area)

        clips.BatchStar("/home/jishnu/PycharmProjects/dmis/controlunit/expertsystem/inference.clp")
        clips.Run()

    if 'refresh' in input_set:
        if len(eng_var)==0:
            return {'fact': facts, 'field': fields,'map_data':list_map}
        message_dealer(input_set['control'],eng_var[0],eng_var[1],eng_var[2])
        user_status_checking()
        clips.Run()

    if 'send' in input_set:
        if len(eng_var)==0:
            return {'fact': facts, 'field': fields,'map_data':list_map}
        message_handler(input_set['control'],input_set['selectaid'],input_set['parameter'])

    if 'deallocate' in input_set:
        try:
            clips.Assert("(DeallocateAll)")
        except clips.ClipsError:
            print("Error in Deallocation")
        clips.Run()
        facts[:] = []
        fields[:] = []
        list_map[:] = []

    clips.SendCommand("run")
    print (clips.PrintFacts())
    list_temp=list(facts)
    list_temp.reverse()
    return {'fact':list_temp,'field':list(set(fields)),'map_data':list_map}