def __init__(self, rules_files: List[Text], functions_package_name: Text = None): """ :param rules_files: List of files containing the Clips definition of the rules. Files are provided following their intended loading order. For instance, if file_2 uses constructs defined in file_1 then the following list must be provided [file_1, file_2]. :param functions_package_name: The name of the package containing the functions that will be used in the rules. """ super().__init__() self._tic("__init__") self.rules_files = rules_files self.env = Environment() if functions_package_name is not None: self.functions_package_name = functions_package_name for f in get_functions_from_module_name(functions_package_name): logger.info("Defining function {}".format(f.__name__)) self.env.define_function(f) for rf in rules_files: self.env.load(rf) # This is the total number of rules fired during the execution of the reason() method. self.num_fires = 0 self._toc("__init__") logger.info("Rules engine created in {0:.3f} ms".format( self._tictoc("__init__") * 1000))
def setUp(self): self.env = Environment() self.env.build(DEFMETHOD) self.env.build(DEFGENERIC1) self.env.build(DEFGENERIC2) self.env.build(DEFFUNCTION1) self.env.build(DEFFUNCTION2)
def __init__(self, config: Dict) -> None: self.config = config self.is_shape_init = False self.static_env = Environment() self.env = [] self.shape_fact = '' self.run_result = [] logging.getLogger('clips/load').info('Loading clips file {}'.format(config['kbs_file'])) self.static_env.load(config['kbs_file'])
def run(clp_file: str, facts, board_size): env = Environment() env.batch_star(clp_file) for fact in facts: env.assert_string(fact) env.run() print("Run clips done") history = [generate_init_state(board_size)] logs = [] log = [] state = generate_init_state(board_size) for fact in env.facts(): log.append(str(fact)) if "bomb" in str(fact) and check(fact, BOMBPATTERN): row, col = parse(fact, BOMBPATTERN) state = generate_history_state(state, row, col, 1) logs.append(log) history.append(state) log = [] if "not_bomb" in str(fact) and check(fact, NOTBOMBPATTERN): row, col = parse(fact, NOTBOMBPATTERN) state = generate_history_state(state, row, col, 0) return history, logs
def setUp(self): self.value = None self.env = Environment() router = LoggingRouter() router.add_to_environment(self.env) self.env.build(DEFCLASS) self.env.build(DEFFUNCTION) self.env.build(DEFRULE_FACT) self.env.build(DEFRULE_INSTANCE) self.env.define_function(python_function) self.env.define_function(self.python_method) self.env.define_function(self.python_fact_method)
class TestRules(unittest.TestCase): def setUp(self): self.env = Environment() self.env.build(DEFTEMPLATE) self.env.build(DEFTEMPLATERULE) def test_rule_build(self): """Simple Rule build.""" rule = self.env.agenda.find_rule('rule-name') self.assertTrue(rule in self.env.agenda.rules()) self.assertEqual(rule.module.name, 'MAIN') self.assertTrue(rule.deletable) self.assertEqual(str(rule), DEFTEMPLATERULE) self.assertEqual(repr(rule), "Rule: %s" % DEFTEMPLATERULE) self.assertFalse(rule.watch_firings) rule.watch_firings = True self.assertTrue(rule.watch_firings) self.assertFalse(rule.watch_activations) rule.watch_activations = True self.assertTrue(rule.watch_activations) rule.undefine() with self.assertRaises(LookupError): self.env.agenda.find_rule('rule-name') with self.assertRaises(TypeError): rule.name def test_rule_matches(self): """Partial rule matches.""" rule = self.env.agenda.find_rule('rule-name') self.env.facts.assert_string('(implied-fact implied-value)') self.assertEqual(rule.matches(), (1, 0, 0)) rule.undefine() def test_rule_activation(self): """Rule activation.""" rule = self.env.agenda.find_rule('rule-name') self.env.facts.assert_string('(implied-fact implied-value)') self.env.facts.assert_string( '(template-fact (template-slot template-value))') self.assertEqual(rule.matches(), (2, 1, 1)) self.env.agenda.run() rule.refresh() fact_names = (f.template.name for f in self.env.facts.facts()) self.assertTrue('rule-fired' in fact_names)
def callCLIPS(list_facts): env = Environment() #rule env.define_function(callRule) env.define_function(callFact) env.load('rule.txt') print(list_facts) #fact for fact in list_facts : env.assert_string(fact) env.run()
def setUp(self): self.values = [] self.env = Environment() self.router = LoggingRouter() self.router.add_to_environment(self.env) self.env.define_function(python_function) self.env.define_function(python_function, name='python-function-renamed') self.env.define_function(python_types) self.env.define_function(self.python_method) self.env.define_function(self.python_fact_method) self.env.build(DEFCLASS) self.env.build(DEFFUNCTION) self.env.build(DEFRULE_FACT) self.env.build(DEFRULE_INSTANCE)
def setShape(self, shape_list: List[ShapeData]) -> None: self.is_shape_init = False self.shape_list = shape_list self.env = [Environment() for _ in range(len(shape_list))] for idx, shape in enumerate(shape_list): logging.getLogger('clips/load').debug('Init new shape') self.env[idx].load(self.config['kbs_file']) self.env[idx].reset() self.initShapeFact(shape, self.env[idx]) self.is_shape_init = True self.shape_fact = self.genFacts()
def home(): res = {} if 'file' not in request.files: res['status'] = 'ERROR' res['msg'] = 'No file submitted' return cors((jsonify(res))) file = request.files['file'] # if user does not select file, browser also # submit an empty part without filename if not allowed_file(file.filename): res['status'] = 'ERROR' res['msg'] = 'Only png, jpg, and jpeg format allowed' return cors(jsonify(res)) else: filename = secure_filename(file.filename) file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) results = detection.detectImage('uploads/' + filename) env = Environment() env.load('backend/shape.clp') shape.insert_angle(env, results) res['activations'] = shape.get_activations(env) env.run() res['rules'] = shape.get_rules(env) res['facts'] = shape.get_facts(env) return cors(jsonify(res))
def initShapeFact(self, shape: ShapeData, env: Environment) -> None: logger = logging.getLogger('clips/fact-assert') env.assert_string('(objek (sisi {}))'.format(len(shape.side))) for side in shape.side: side_fact = '(sisi (from {}) (to {}) (length {}))'.format(*side) logger.debug('Asserting {}'.format(side_fact)) env.assert_string(side_fact) for point in shape.degree: degree_fact = '(sudut (id {}) (degree {}))'.format(*point) logger.debug('Asserting {}'.format(degree_fact)) env.assert_string(degree_fact) parallel_set = self.processParallel(shape) parallel_count = len(parallel_set) parallel_fact = '(paralel (jumlah {}))'.format(parallel_count) logger.debug('Asserting {}'.format(parallel_fact)) env.assert_string(parallel_fact)
class Engine: def __init__(self, configuration): self.environment = Environment() self.configuration = configuration def __enter__(self): self.environment.load(self.configuration['constructs']) self.environment.load(self.configuration['ioc_rules']) return self def __exit__(self, *_): self.environment.clear() def process_event(self, event_xml: str) -> bool: """Process the event XML. Return True if the event was processed, False if discarded. """ event = etree.fromstring(event_xml) try: instance = self.event_instance(event) except LookupError as error: return False initialize_instance(instance, event) self.environment.agenda.run() return True def event_instance(self, event: etree.Element): """Create a new instance from the given event. The instance name will be the record ID of the event. """ evtid = event.find('{*}System/{*}EventID').text evtprov = event.find('{*}System/{*}Provider').attrib['Name'] cls = self.environment.classes.find_class("%s-%s" % (evtprov, evtid)) evtrecord = event.find('{*}System/{*}EventRecordID').text return cls.new_instance(evtrecord)
from clips import Environment, Symbol environment = Environment() # assert a fact as string environment.assert_string('(a-fact)') # retrieve a fact template template = environment.find_template('a-fact') # create a new fact from the template fact = template.new_fact() # implied (ordered) facts are accessed as lists fact.extend((7, 2)) # assert the fact within the environment fact.assertit() # execute the activations in the agenda environment.run() for fact in environment.facts(): print(fact)
def setUp(self): self.env = Environment() self.env.build(DEFTEMPLATE)
class TestFacts(unittest.TestCase): def setUp(self): self.env = Environment() self.env.build(DEFTEMPLATE) def test_facts(self): """Facts wrapper test.""" template = self.env.facts.find_template('template-fact') self.assertTrue(template in self.env.facts.templates()) fact = self.env.facts.assert_string('(implied-fact)') self.assertTrue(fact in self.env.facts.facts()) self.env.facts.load_facts('(one-fact) (two-facts)') self.assertTrue('(two-facts)' in (str(f) for f in self.env.facts.facts())) with NamedTemporaryFile() as tmp: saved = self.env.facts.save_facts(tmp.name) self.env.reset() loaded = self.env.facts.load_facts(tmp.name) self.assertEqual(saved, loaded) def test_implied_fact(self): """ImpliedFacts are asserted.""" self.env.facts.assert_string('(implied-fact)') expected = [Symbol('implied-fact'), 1, 2.3, '4', Symbol('five')] template = self.env.facts.find_template('implied-fact') fact = template.new_fact() fact.append(1) fact.extend((2.3, '4', Symbol('five'))) fact.assertit() for asserted_fact in self.env.facts.facts(): if asserted_fact == fact: break self.assertEqual(asserted_fact[1], 1) self.assertEqual(len(asserted_fact), 5) self.assertEqual(asserted_fact.index, 2) self.assertEqual(list(asserted_fact), expected) self.assertEqual(str(asserted_fact), IMPL_STR) self.assertEqual(repr(asserted_fact), IMPL_RPR) def test_template_fact(self): """TemplateFacts are asserted.""" expected = { '': 'template-fact', 'int': 1, 'float': 2.2, 'str': '4', 'symbol': Symbol('five'), 'multifield': [1, 2] } template = self.env.facts.find_template('template-fact') fact = template.new_fact() fact['int'] = 1 fact.update({'float': 2.2, 'str': '4'}) fact.update((('symbol', Symbol('five')), ('multifield', [1, 2]))) fact.assertit() self.assertEqual(fact.index, 1) for asserted_fact in self.env.facts.facts(): if asserted_fact == fact: break self.assertEqual(len(asserted_fact), 6) self.assertEqual(asserted_fact.index, 1) self.assertEqual(asserted_fact['int'], 1) self.assertEqual(dict(asserted_fact), expected) self.assertEqual(str(asserted_fact), TMPL_STR) self.assertEqual(repr(asserted_fact), TMPL_RPR) def test_implied_fact_already_asserted(self): """Asserted ImpliedFacts cannot be modified or re-asserted.""" self.env.facts.assert_string('(implied-fact)') template = self.env.facts.find_template('implied-fact') fact = template.new_fact() fact.extend((1, 2.3, '4', Symbol('five'))) fact.assertit() self.assertTrue(fact.asserted) with self.assertRaises(RuntimeError): fact.append(42) with self.assertRaises(RuntimeError): fact.assertit() def test_template_fact_already_asserted(self): """Asserted TemplateFacts cannot be modified or re-asserted.""" template = self.env.facts.find_template('template-fact') fact = template.new_fact() fact.update({ 'int': 1, 'float': 2.2, 'str': '4', 'symbol': Symbol('five'), 'multifield': [1, 2] }) fact.assertit() self.assertTrue(fact.asserted) with self.assertRaises(RuntimeError): fact['int'] = 42 with self.assertRaises(RuntimeError): fact.assertit() def test_retract_fact(self): """Retracted fact is not anymore in the fact list.""" self.env.facts.assert_string('(implied-fact)') template = self.env.facts.find_template('implied-fact') fact = template.new_fact() fact.extend((1, 2.3, '4', Symbol('five'))) fact.assertit() self.assertTrue(fact.asserted) self.assertTrue(fact in list(self.env.facts.facts())) fact.retract() self.assertFalse(fact.asserted) self.assertFalse(fact in list(self.env.facts.facts())) def test_implied_fact_template(self): """ImpliedFact template properties.""" fact = self.env.facts.assert_string('(implied-fact 1 2.3 "4" five)') template = fact.template self.assertTrue(template.implied) self.assertEqual(template.name, 'implied-fact') self.assertEqual(template.module.name, 'MAIN') self.assertEqual(template.slots(), ()) self.assertEqual(str(template), 'implied-fact') self.assertEqual(repr(template), 'Template: implied-fact') self.assertFalse(template.deletable) with self.assertRaises(CLIPSError): template.undefine() def test_template_fact_template(self): """TemplateFact template properties.""" template = self.env.facts.find_template('template-fact') self.assertEqual(template.name, 'template-fact') self.assertEqual(template.module.name, 'MAIN') self.assertEqual(len(tuple(template.slots())), 5) self.assertEqual(str(template), DEFTEMPLATE) self.assertEqual(repr(template), 'Template: ' + DEFTEMPLATE) self.assertTrue(template.deletable) template.undefine() def test_template_fact_slot(self): """TemplateFact template Slot.""" template = self.env.facts.find_template('template-fact') slots = {s.name: s for s in template.slots()} self.assertEqual(slots['int'].name, 'int') self.assertFalse(slots['int'].multifield) self.assertTrue(slots['multifield'].multifield) self.assertEqual(slots['int'].types, ('INTEGER', )) self.assertEqual(slots['float'].types, ('FLOAT', )) self.assertEqual(slots['str'].types, ('STRING', )) self.assertEqual(slots['symbol'].types, ('SYMBOL', )) self.assertEqual(slots['int'].range, ('-oo', '+oo')) self.assertEqual(slots['float'].cardinality, ()) self.assertEqual(slots['str'].default_type, TemplateSlotDefaultType.STATIC_DEFAULT) self.assertEqual(slots['str'].default_value, '') self.assertEqual(slots['int'].allowed_values, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9))
def __init__(self, clp_file_name): self.environment = Environment() self.get_result = [] self.facts = [] #ini array2D of string self.environment.load(clp_file_name) self.environment.reset()
class Analysis: def __init__(self, clp_file_name): self.environment = Environment() self.get_result = [] self.facts = [] #ini array2D of string self.environment.load(clp_file_name) self.environment.reset() def create_facts(self, i, j, value): facts = ['namatemplate', i, j, value] self.environment.assert_string(self.list_to_fact(facts)) return def assertFacts(self, facts): for fact in facts: self.environment.assert_string(self.list_to_fact(fact)) def list_to_fact(self, facts): res = '(' for idx, element in enumerate(facts): res += str(element) if (idx != len(facts) - 1): res += " " res += ')' return res def show_facts(self): res = "" for fact in self.facts: res += (self.list_to_fact(fact)) res += "\n" print(res) return res def show_rules(self): res = "" for rule in self.environment.rules(): res += rule.name res += "\n" print("Rule list:") print(res) def print_rule(self, iteration, rule): res = (' ' * iteration + rule) res += '\n' self.done[rule] = True for rule in self.rule_list[rule]: if not (self.done[rule]): res += self.print_rule(iteration + 1, rule) return res def hit_rules(self): self.done = dict.fromkeys(self.rule_list, False) res = "" for rule in self.rule_list: if not (self.done[rule]): res += self.print_rule(0, rule) print("Hit rules:") print(res) return res def matched_facts(self): facts = [] res = "" for fact in self.environment.facts( ): # fact -> (down (value val) (x x) (y y)) res += "f-" + str(fact.index) + " " + str(fact) res += '\n' listattr = fact.split("(") if (listattr[1] == "choose-cell "): action = listattr[2].split(" ")[1].replace(")", "").replace( " ", "") x = int(listattr[3].split(" ")[1].replace(")", "")) y = int(listattr[4].split(" ")[1].replace(")", "")) facts.append([action, x, y]) # print("Matched facts:") # print(res) return fact def get_name(self, rule): return rule.name + ' ' + rule.__repr__().split(':')[2] def run(self): self.rule_list = dict.fromkeys( [self.get_name(rule) for rule in self.environment.activations()], []) while (len([rule for rule in self.environment.activations()])): activations = self.environment.activations() current_rule = next(activations) rule_name = self.get_name(current_rule) self.environment.run(1) self.update_rule_matched(rule_name) def update_rule_matched(self, rule_name): if (not (rule_name in self.rule_list.keys())): self.rule_list[rule_name] = [] for activation in self.environment.activations(): if (not (self.get_name(activation) in self.rule_list.keys())): self.rule_list[self.get_name(activation)] = [] self.rule_list[rule_name].append(self.get_name(activation))
def setUp(self): self.env = Environment() router = LoggingRouter() router.add_to_environment(self.env) for defclass in DEFCLASSES: self.env.build(defclass)
def initialize_env(self, clp_file_name): self.environment = Environment() self.environment.load(clp_file_name)
class TestFacts(unittest.TestCase): def setUp(self): self.env = Environment() self.env.build(DEFTEMPLATE) def test_facts(self): """Facts wrapper test.""" template = self.env.find_template('template-fact') self.assertTrue(template in self.env.templates()) fact = self.env.assert_string('(implied-fact)') self.assertTrue(fact in self.env.facts()) self.env.load_facts('(one-fact) (two-facts)') self.assertTrue('(two-facts)' in (str(f) for f in self.env.facts())) with TempFile() as tmp: saved = self.env.save_facts(tmp.name) self.env.reset() loaded = self.env.load_facts(tmp.name) self.assertEqual(saved, loaded) def test_implied_fact(self): """ImpliedFacts are asserted.""" expected = (1, 2.3, '4', Symbol('five')) fact = self.env.assert_string('(implied-fact 1 2.3 "4" five)') self.assertEqual(fact[0], 1) self.assertEqual(len(fact), 4) self.assertEqual(fact.index, 1) self.assertEqual(tuple(fact), expected) self.assertEqual(str(fact), IMPL_STR) self.assertEqual(repr(fact), IMPL_RPR) self.assertTrue(fact in tuple(self.env.facts())) def test_template_fact(self): """TemplateFacts are asserted.""" expected = { 'int': 1, 'float': 2.2, 'str': '4', 'symbol': Symbol('five'), 'multifield': (1, 2) } template = self.env.find_template('template-fact') fact = template.assert_fact(**expected) self.assertEqual(len(fact), 5) self.assertEqual(fact.index, 1) self.assertEqual(fact['int'], 1) self.assertEqual(dict(fact), expected) self.assertEqual(str(fact), TMPL_STR) self.assertEqual(repr(fact), TMPL_RPR) self.assertTrue(fact in tuple(self.env.facts())) def test_template_fact_errors(self): """TemplateFacts errors.""" with self.assertRaises(LookupError): self.env.find_template('non-existing-template') template = self.env.find_template('template-fact') with self.assertRaises(KeyError): template.assert_fact(non_existing_slot=1) with self.assertRaises(TypeError): template.assert_fact(int=1.0) with self.assertRaises(ValueError): template.assert_fact(int=10) def test_fact_duplication(self): """Test fact duplication.""" fact = self.env.assert_string('(implied-fact)') new_fact = self.env.assert_string('(implied-fact)') self.assertEqual(fact, new_fact) self.assertEqual(len(tuple(self.env.facts())), 1) self.env.fact_duplication = True new_fact = self.env.assert_string('(implied-fact)') self.assertNotEqual(fact, new_fact) self.assertEqual(len(tuple(self.env.facts())), 2) def test_modify_fact(self): """Asserted TemplateFacts can be modified.""" template = self.env.find_template('template-fact') fact = template.assert_fact( **{ 'int': 1, 'float': 2.2, 'str': '4', 'symbol': Symbol('five'), 'multifield': (1, 2) }) fact.modify_slots(symbol=Symbol('six')) self.assertEqual(fact['symbol'], Symbol('six')) def test_retract_fact(self): """Retracted fact is not anymore in the fact list.""" fact = self.env.assert_string('(implied-fact)') self.assertTrue(fact in list(self.env.facts())) fact.retract() self.assertFalse(fact in list(self.env.facts())) def test_implied_fact_template(self): """ImpliedFact template properties.""" fact = self.env.assert_string('(implied-fact 1 2.3 "4" five)') template = fact.template self.assertTrue(template.implied) self.assertEqual(template.name, 'implied-fact') self.assertEqual(template.module.name, 'MAIN') self.assertEqual(template.slots, ()) self.assertEqual(str(template), '') self.assertEqual(repr(template), 'Template: ') self.assertFalse(template.deletable) with self.assertRaises(CLIPSError): template.undefine() def test_template_fact_template(self): """TemplateFact template properties.""" template = self.env.find_template('template-fact') self.assertEqual(template.name, 'template-fact') self.assertEqual(template.module.name, 'MAIN') self.assertEqual(len(tuple(template.slots)), 5) self.assertEqual(str(template), ' '.join(DEFTEMPLATE.split())) self.assertEqual(repr(template), 'Template: ' + ' '.join(DEFTEMPLATE.split())) self.assertTrue(template.deletable) template.undefine() with self.assertRaises(LookupError): self.env.find_template('template-fact') with self.assertRaises(CLIPSError): print(template) def test_template_fact_slot(self): """TemplateFact template Slot.""" template = self.env.find_template('template-fact') slots = {s.name: s for s in template.slots} self.assertEqual(slots['int'].name, 'int') self.assertFalse(slots['int'].multifield) self.assertTrue(slots['multifield'].multifield) self.assertEqual(slots['int'].types, ('INTEGER', )) self.assertEqual(slots['float'].types, ('FLOAT', )) self.assertEqual(slots['str'].types, ('STRING', )) self.assertEqual(slots['symbol'].types, ('SYMBOL', )) self.assertEqual(slots['int'].range, ('-oo', '+oo')) self.assertEqual(slots['float'].cardinality, ()) self.assertEqual(slots['str'].default_type, TemplateSlotDefaultType.STATIC_DEFAULT) self.assertEqual(slots['str'].default_value, '') self.assertEqual(slots['int'].allowed_values, (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)) def test_defined_facts(self): """DefinedFacts tests.""" self.env.build(DEFFACTS) deffacts = self.env.find_defined_facts('defined-facts') listed = list(self.env.defined_facts()) self.assertEqual(deffacts, listed[0]) self.assertEqual(deffacts.name, 'defined-facts') self.assertEqual( str(deffacts), '(deffacts MAIN::defined-facts (template-fact (int 1) (str "a-string")))' ) self.assertEqual(deffacts.module.name, 'MAIN') self.assertTrue(deffacts.deletable) deffacts.undefine() with self.assertRaises(LookupError): self.env.find_defined_facts('defined-facts') with self.assertRaises(CLIPSError): print(deffacts)
class TestAgenda(unittest.TestCase): def setUp(self): self.env = Environment() self.env.build(DEFTEMPLATE) self.env.build(DEFRULE) def test_agenda_strategy(self): """Agenda strategy getting/setting.""" for strategy in Strategy: self.env.strategy = strategy self.assertEqual(self.env.strategy, strategy) def test_agenda_salience_evaluation(self): """Agenda salience_evaluation getting/setting.""" for salience_evaluation in SalienceEvaluation: self.env.salience_evaluation = salience_evaluation self.assertEqual(self.env.salience_evaluation, salience_evaluation) def test_agenda_activation(self): """Agenda activation test.""" self.env.assert_string('(implied-fact implied-value)') self.assertTrue(self.env.agenda_changed) activation = tuple(self.env.activations())[0] self.assertEqual(activation.name, 'rule-name') self.assertEqual(activation.salience, 10) self.assertEqual(str(activation), '10 rule-name: f-1') self.assertEqual(repr(activation), 'Activation: 10 rule-name: f-1') activation.delete() self.assertFalse(activation in self.env.activations()) def test_agenda_run(self): """Agenda rules are fired on run.""" self.env.assert_string('(implied-fact implied-value)') self.env.run() fact_names = (f.template.name for f in self.env.facts()) self.assertTrue('rule-fired' in fact_names) def test_agenda_activation_order(self): """Agenda activations order change if salience or strategy change.""" self.env.build(DEFOTHERRULE) self.env.assert_string('(implied-fact implied-value)') self.assertTrue(self.env.agenda_changed) activations = tuple(self.env.activations()) self.assertEqual(tuple(a.name for a in activations), (u'other-rule-name', u'rule-name')) activations[1].salience = 30 self.assertFalse(self.env.agenda_changed) self.env.reorder() self.assertTrue(self.env.agenda_changed) activations = tuple(self.env.activations()) self.assertEqual(tuple(a.name for a in activations), (u'rule-name', u'other-rule-name')) self.env.refresh() self.assertTrue(self.env.agenda_changed) self.env.clear() activations = tuple(self.env.activations()) self.assertEqual(len(activations), 0)
from flask import Flask, render_template, jsonify, url_for, request from clips import Environment # Define the clips environment clips = Environment() # Load the Project Expert System clips.load("project.clp") # Define the app of web server app = Flask(__name__) boolAnswer = False def changeUIState(): # Get the state-list. factlist = clips.eval("(find-all-facts ((?f state-list)) TRUE)") if len(factlist) == 0: return jsonify(question="Error in the website and we don't know why") currentID = factlist[0]["current"] print("currentID1 :", currentID) # Get the current UI state. factlist = clips.eval("(find-all-facts ((?f UI-state)) (eq ?f:id %s))" % currentID) if len(factlist) == 0: return jsonify(question="Error in the website and we don't know why") # Determine the Next/Prev button states. state = factlist[0]["state"] if state == "final":
def detection(file_name): e = Environment() # Pilih rule e.load('geometri.clp') # Load image img = cv2.imread(file_name, cv2.IMREAD_GRAYSCALE) _, threshold = cv2.threshold(img, 240, 255, cv2.THRESH_BINARY) # Buat contours contours, _ = cv2.findContours(threshold, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) # Pilih font font = cv2.FONT_HERSHEY_COMPLEX for cnt in contours[1:]: # Aproksimasi sisi polygon approx = cv2.approxPolyDP(cnt, 0.01 * cv2.arcLength(cnt, True), True) # Gambar contour cv2.drawContours(img, [approx], 0, (0), 5) #cv2.imshow("contours", img) cv2.imwrite("result.jpg", img) # Get x, y untuk text x = approx.ravel()[0] y = approx.ravel()[1] # print(cv2.arcLength(cnt, True)) for a in approx: print("(titik " + str(a[0][0]) + " " + str(a[0][1]) + ")") for i in getSisi(approx): print(i) for i in getSudut(approx): print(i) # Klasifikasi berdasarkan jumlah sisi print(len(approx)) if len(approx) == 3: # Assert fakta berupa titik shape e.assert_string(getEdgeFact(getSisi(approx))) e.assert_string(getAngleFact(getSudut(approx))) e.assert_string('(titik 3)') cv2.putText(img, "Segitiga", (x, y), font, 1, (0)) elif len(approx) == 4: e.assert_string(getEdgeFact(getSisi(approx))) e.assert_string(getAngleFact(getSudut(approx))) e.assert_string('(titik 4)') cv2.putText(img, "Persegi", (x, y), font, 1, (0)) elif len(approx) == 5: e.assert_string(getEdgeFact(getSisi(approx))) e.assert_string('(titik 5)') cv2.putText(img, "Segi Lima", (x, y), font, 1, (0)) elif len(approx) == 6: e.assert_string(getEdgeFact(getSisi(approx))) e.assert_string('(titik 6)') cv2.putText(img, "Segi Enam", (x, y), font, 1, (0)) # Print initial facts print("\nInitial Facts :") list_fact = '' for fact in e.facts(): list_fact += str(fact) + '\n' print(fact) outputFile = open("fakta.txt", "w") outputFile.write(list_fact) outputFile.close() print("\nAgenda :") list_agenda = '' for agenda in e.activations(): list_agenda += str(agenda) + '\n' print(agenda) outputFile = open("hit_rules.txt", "w") outputFile.write(list_agenda) outputFile.close() # Kalo mau run sekali, pake e.run(1) # Kalo mau run sampai habis, pake e.run() e.run() # Print all facts at the end print("\n\nFinal Facts :") list_fact = '' for fact in e.facts(): list_fact += str(fact) + '\n' print(fact) outputFile = open("matched_facts.txt", "w") outputFile.write(list_fact) outputFile.close()
from flask import Flask, render_template, jsonify, url_for, request from clips import Environment # Define the clips environment clips = Environment() # Load the Network Expert System clips.load("newNetwork.clp") # Define the app of web server app = Flask(__name__) boolAnswer = False def changeUIState(): # Get the state-list. factlist = clips.eval("(find-all-facts ((?f state-list)) TRUE)") if len(factlist) == 0: return jsonify(question="Error in the server, ask support to fix") currentID = factlist[0]["current"] print("currentID1 :", currentID) # Get the current UI state. factlist = clips.eval("(find-all-facts ((?f UI-state)) (eq ?f:id %s))" % currentID) if len(factlist) == 0: return jsonify(question="Error in the server, ask support to fix") # Determine the Next/Prev button states. state = factlist[0]["state"] if state == "final": buttonLabel = "Restart"
class TestFunctions(unittest.TestCase): def setUp(self): self.env = Environment() self.env.build(DEFMETHOD) self.env.build(DEFGENERIC1) self.env.build(DEFGENERIC2) self.env.build(DEFFUNCTION1) self.env.build(DEFFUNCTION2) def test_function_call(self): """Test function call.""" function = self.env.find_function('function-sum') self.assertEqual(function('1 2'), 3) function = self.env.find_generic('generic-sum') self.assertEqual(function('1 2'), 3) def test_function(self): """Deffunction object test.""" func = self.env.find_function("function-sub") self.assertTrue(func in self.env.functions()) self.assertEqual(func.name, "function-sub") self.assertEqual(func.module.name, "MAIN") self.assertTrue('deffunction' in str(func)) self.assertTrue('deffunction' in repr(func)) self.assertTrue(func.deletable) self.assertFalse(func.watch) func.watch = True self.assertTrue(func.watch) func.undefine() self.assertTrue(func not in self.env.functions()) with self.assertRaises(LookupError): self.env.find_function("function-sub") def test_generic(self): """Defgeneric object test.""" func = self.env.find_generic("generic-sum") self.assertTrue(func in self.env.generics()) self.assertEqual(func.name, "generic-sum") self.assertEqual(func.module.name, "MAIN") self.assertTrue('defgeneric' in str(func)) self.assertTrue('defgeneric' in repr(func)) self.assertTrue(func.deletable) self.assertFalse(func.watch) func.watch = True self.assertTrue(func.watch) func.undefine() self.assertTrue(func not in self.env.generics()) with self.assertRaises(LookupError): self.env.find_function("generic-sum") def test_method(self): """Defgeneric object test.""" restr = [ 2, 2, 2, 6, 9, Symbol('FALSE'), 1, Symbol('INTEGER'), Symbol('FALSE'), 1, Symbol('INTEGER') ] func = self.env.find_generic("generic-sum") method = tuple(func.methods())[0] self.assertTrue('defmethod' in str(method)) self.assertTrue('defmethod' in repr(method)) self.assertTrue(method.deletable) self.assertFalse(method.watch) self.assertEqual(method.description, "1 (INTEGER) (INTEGER)") self.assertEqual(method.restrictions, restr) method.watch = True self.assertTrue(method.watch) method.undefine() self.assertTrue(method not in func.methods())
class TestClasses(unittest.TestCase): def setUp(self): self.env = Environment() router = LoggingRouter() router.add_to_environment(self.env) for defclass in DEFCLASSES: self.env.build(defclass) def test_classes(self): """Classes wrapper test.""" self.assertEqual( self.env.default_mode, ClassDefaultMode.CONVENIENCE_MODE) self.env.default_mode = ClassDefaultMode.CONSERVATION_MODE self.assertEqual( self.env.default_mode, ClassDefaultMode.CONSERVATION_MODE) defclass = self.env.find_class('USER') self.assertTrue(defclass in self.env.classes()) with self.assertRaises(LookupError): self.env.find_class('NonExisting') defclass = self.env.find_class('ConcreteClass') defclass.new_instance('some-instance') defclass.new_instance('test-instance') instance = self.env.find_instance('test-instance') self.assertTrue(instance in self.env.instances()) with self.assertRaises(LookupError): self.env.find_instance('NonExisting') self.assertTrue(self.env.instances_changed) self.assertFalse(self.env.instances_changed) # See: https://sourceforge.net/p/clipsrules/tickets/33/ # with TempFile() as tmp: # saved = self.env.save_instances(tmp.name) # self.env.reset() # loaded = self.env.load_instances(tmp.name) # self.assertEqual(saved, loaded) with TempFile() as tmp: saved = self.env.save_instances(tmp.name) self.env.reset() loaded = self.env.restore_instances(tmp.name) self.assertEqual(saved, loaded) with TempFile() as tmp: saved = self.env.save_instances(tmp.name, binary=True) self.env.reset() loaded = self.env.load_instances(tmp.name) self.assertEqual(saved, loaded) def test_abstract_class(self): """Abstract class test.""" superclass = self.env.find_class('USER') subclass = self.env.find_class('InheritClass') defclass = self.env.find_class('AbstractClass') self.assertTrue(defclass.abstract) self.assertFalse(defclass.reactive) self.assertEqual(defclass.name, 'AbstractClass') self.assertEqual(defclass.module.name, 'MAIN') self.assertTrue(defclass.deletable) self.assertTrue(defclass.subclass(superclass)) self.assertTrue(defclass.superclass(subclass)) self.assertEqual(tuple(defclass.subclasses()), (subclass, )) self.assertEqual(tuple(defclass.superclasses()), (superclass, )) with self.assertRaises(CLIPSError): defclass.new_instance('foobar') defclass.undefine() def test_concrete_class(self): """Concrete class test.""" defclass = self.env.find_class('ConcreteClass') self.assertFalse(defclass.abstract) self.assertTrue(defclass.reactive) self.assertEqual(defclass.name, 'ConcreteClass') self.assertEqual(defclass.module.name, 'MAIN') self.assertTrue(defclass.deletable) self.assertFalse(defclass.watch_instances) defclass.watch_instances = True self.assertTrue(defclass.watch_instances) self.assertFalse(defclass.watch_slots) defclass.watch_slots = True self.assertTrue(defclass.watch_slots) defclass.undefine() def test_slot(self): """Slot test.""" defclass = self.env.find_class('ConcreteClass') slot = tuple(defclass.slots())[0] self.assertFalse(slot.public) self.assertTrue(slot.writable) self.assertTrue(slot.accessible) self.assertTrue(slot.initializable) self.assertEqual(slot.name, 'Slot') self.assertEqual(slot.types, ('FLOAT', 'INTEGER', 'SYMBOL', 'STRING', 'EXTERNAL-ADDRESS', 'FACT-ADDRESS', 'INSTANCE-ADDRESS', 'INSTANCE-NAME')) self.assertEqual(slot.sources, (defclass.name, )) self.assertEqual(slot.range, ('-oo', '+oo')) self.assertEqual(slot.facets, ('SGL', 'STC', 'INH', 'RW', 'LCL', 'RCT', 'EXC', 'PRV', 'RW', 'put-Slot')) self.assertEqual(slot.cardinality, ()) self.assertEqual(slot.default_value, Symbol('nil')) self.assertEqual(slot.allowed_values, ()) self.assertEqual(tuple(slot.allowed_classes()), ()) def test_instance(self): """Instance test.""" defclass = self.env.find_class('ConcreteClass') defclass.new_instance('some-instance') instance = defclass.new_instance('test-instance') instance['Slot'] = Symbol('value') self.assertTrue(instance in defclass.instances()) self.assertEqual(instance.name, 'test-instance') self.assertEqual(instance.instance_class, defclass) self.assertEqual(instance['Slot'], Symbol('value')) self.assertEqual( str(instance), '[test-instance] of ConcreteClass (Slot value)') self.assertEqual( repr(instance), 'Instance: [test-instance] of ConcreteClass (Slot value)') self.assertEqual(dict(instance), {'Slot': Symbol('value')}) instance.delete() instance = defclass.new_instance('test-instance') instance.unmake() def test_message_handler(self): """MessageHandler test.""" defclass = self.env.find_class('MessageHandlerClass') handler = defclass.find_message_handler('test-handler') expected_str = """(defmessage-handler MAIN::MessageHandlerClass test-handler () (+ ?self:One ?self:Two))""" self.assertTrue(handler.deletable) self.assertEqual(handler.type, 'primary') self.assertEqual(handler.name, 'test-handler') self.assertTrue(handler in defclass.message_handlers()) self.assertEqual(str(handler), expected_str) self.assertEqual(repr(handler), 'MessageHandler: ' + expected_str) self.assertFalse(handler.watch) handler.watch = True self.assertTrue(handler.watch) handler.undefine() def test_message_handler_instance(self): """MessageHandler instance test.""" defclass = self.env.find_class('MessageHandlerClass') instance = defclass.new_instance('test-instance') instance['One'] = 1 instance['Two'] = 2 self.assertEqual(instance.send('test-handler'), 3)
class ClipsMinesweeper(): def __init__(self): self.environment = Environment() # load constructs into the environment self.environment.load('minesweeper.clp') self.environment.reset() def load_board(self, size, num_bombs): template_board = self.environment.find_template('board') new_board = template_board.new_fact() new_board['size'] = size new_board['remaining-bomb'] = num_bombs new_board.assertit() def load_square(self, board_state): template_square = self.environment.find_template('square') for col in range(len(board_state)): for row in range(len(board_state[col])): new_square = template_square.new_fact() closed_square_around = 8 if col == 0 or col == len(board_state) - 1: closed_square_around -= 3 if row == 0 or row == len(board_state) - 1: closed_square_around -= 3 if col == 0 or col == len(board_state) - 1: closed_square_around += 1 new_square['x'] = row new_square['y'] = col new_square['value'] = board_state[col][row] new_square['closed-square-around'] = closed_square_around # if col == 0 and row == 0: # new_square['is-open'] new_square.assertit() def print_facts(self): print('ke sini') template_square = self.environment.find_template('square') template_board = self.environment.find_template('board') for fact in self.environment.facts(): if fact.template == template_square: print(fact['x'], fact['y']) elif fact.template == template_board: print(fact['remaining-bomb']) def run_one_step(self): self.environment.run(limit=1) template_square = self.environment.find_template('square') template_board = self.environment.find_template('board') square_fact = [] board_fact = template_board.new_fact() return self.environment.facts()
class Analysis: def __init__(self, clp_file_name): self.initialize_env(clp_file_name) self.get_result = [] def initialize_env(self, clp_file_name): self.environment = Environment() self.environment.load(clp_file_name) def load_image(self, file_name): self.environment.reset() self.get_result = [] self.facts = create_facts(file_name) for fact in self.facts: self.environment.assert_string(list_to_fact(fact)) def print_rule(self, iteration, rule): res = (' ' * iteration + rule) res += '\n' self.done[rule] = True for rule in self.rule_list[rule]: if not (self.done[rule]): res += self.print_rule(iteration + 1, rule) return res def hit_rules(self): self.done = dict.fromkeys(self.rule_list, False) res = "" for rule in self.rule_list: if not (self.done[rule]): res += self.print_rule(0, rule) print("Hit rules:") print(res) return res def matched_facts(self): res = "" for fact in self.environment.facts(): print(fact) res += "f-" + str(fact.index) + " " + str(fact) self.insert_fact(str(fact)) res += '\n' print("Matched facts:") print(res) return res def insert_fact(self, fact): parsed_fact = fact.split(' ') self.get_result.append(convert(parsed_fact[0][1:])) def detection_results(self, source_image_result): print("Hasil: ", source_image_result) print(self.get_result) return "True" if (source_image_result in self.get_result) else "False" def show_facts(self): res = "" for fact in self.facts: res += (list_to_fact(fact)) res += "\n" print(res) return res def show_rules(self): res = "" for rule in self.environment.rules(): res += rule.name res += "\n" print("Rule list:") print(res) def open_image(self, filename): load_image(filename) return cv2.imread(filename) def run(self): self.rule_list = dict.fromkeys( [self.get_name(rule) for rule in self.environment.activations()], []) while (len([rule for rule in self.environment.activations()])): activations = self.environment.activations() current_rule = next(activations) rule_name = self.get_name(current_rule) self.environment.run(1) self.update_rule_matched(rule_name) def get_name(self, rule): return rule.name + ' ' + rule.__repr__().split(':')[2] def update_rule_matched(self, rule_name): if (not (rule_name in self.rule_list.keys())): self.rule_list[rule_name] = [] for activation in self.environment.activations(): if (not (self.get_name(activation) in self.rule_list.keys())): self.rule_list[self.get_name(activation)] = [] self.rule_list[rule_name].append(self.get_name(activation))
class TestEnvironment(unittest.TestCase): def setUp(self): self.value = None self.env = Environment() router = LoggingRouter() router.add_to_environment(self.env) self.env.build(DEFCLASS) self.env.build(DEFFUNCTION) self.env.build(DEFRULE_FACT) self.env.build(DEFRULE_INSTANCE) self.env.define_function(python_function) self.env.define_function(python_types) self.env.define_function(self.python_method) self.env.define_function(self.python_fact_method) def python_method(self, *value): self.value = value def python_fact_method(self): """Returns a list with one fact.""" template = self.env.find_template('test-fact') fact = template.new_fact() fact.append(5) return [fact] def test_eval_python_function(self): """Python function is evaluated correctly.""" expected = [0, 1.1, "2", Symbol('three')] ret = self.env.eval( '(python-function python_function 0 1.1 "2" three)') self.assertEqual(ret, expected) expected = [Symbol('nil'), Symbol('TRUE'), Symbol('FALSE')] ret = self.env.eval('(python-function python_types)') self.assertEqual(ret, expected) def test_eval_python_method(self): """Python method is evaluated correctly.""" expected = 0, 1.1, "2", Symbol('three') ret = self.env.eval('(python-function python_method 0 1.1 "2" three)') self.assertEqual(ret, Symbol('nil')) self.assertEqual(self.value, expected) def test_rule_python_fact(self): """Facts are forwarded to Python """ fact = self.env.assert_string('(test-fact)') self.env.run() self.assertEqual(self.value[0], fact) def test_rule_python_instance(self): """Instances are forwarded to Python """ cl = self.env.find_class('TEST') inst = cl.new_instance('test') self.env.run() self.assertEqual(self.value[0], inst) def test_facts_function(self): """Python functions can return list of """ function = self.env.find_function('test-fact-function') function() self.assertTrue(isinstance(self.value[0][0], ImpliedFact)) def test_batch_star(self): """Commands are evaluated from file.""" with NamedTemporaryFile() as tmp: tmp.write(b"(assert (test-fact))\n") tmp.flush() self.env.batch_star(tmp.name) self.assertTrue('test-fact' in (f.template.name for f in self.env.facts())) def test_save_load(self): """Constructs are saved and loaded.""" with NamedTemporaryFile() as tmp: self.env.save(tmp.name) self.env.clear() self.env.load(tmp.name) self.assertTrue('fact-rule' in (r.name for r in self.env.rules())) with NamedTemporaryFile() as tmp: self.env.save(tmp.name, binary=True) self.env.clear() self.env.load(tmp.name) self.assertTrue('fact-rule' in (r.name for r in self.env.rules()))
def __init__(self): self.environment = Environment() # load constructs into the environment self.environment.load('minesweeper.clp') self.environment.reset()