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()
