Exemple #1
0
    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())
Exemple #2
0
    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)
Exemple #3
0
    def test_instance(self):
        """Instance test."""
        defclass = self.env.find_class('ConcreteClass')

        instance_name = self.env.eval(
            '(make-instance test-eval-instance of ConcreteClass)')
        self.assertEqual(instance_name, 'test-eval-instance')
        self.assertTrue(isinstance(instance_name, InstanceName))

        instance = self.env.make_instance(
            '(test-make-instance of ConcreteClass (Slot value))')
        self.assertEqual(instance.name, 'test-make-instance')
        self.assertEqual(instance['Slot'], Symbol('value'))

        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_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)
Exemple #5
0
    def test_eval_python_function(self):
        """Python function is evaluated correctly."""
        expected = [0, 1.1, "2", Symbol('three')]
        ret = self.env.eval('(python_function 0 1.1 "2" three)')
        self.assertEqual(ret, expected)

        expected = [Symbol('nil'), Symbol('TRUE'), Symbol('FALSE')]
        ret = self.env.eval('(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_method 0 1.1 "2" three)')

        print(self.values)

        self.assertEqual(ret, Symbol('nil'))
        self.assertEqual(self.values, expected)
Exemple #7
0
    def test_modify_instance(self):
        """Instance slot modification test."""
        defclass = self.env.find_class('ConcreteClass')

        defclass.make_instance('some-instance')
        instance = defclass.make_instance('test-instance',
                                          Slot=Symbol('value'))
        instance.modify_slots(Slot=Symbol('another-value'))

        self.assertEqual(instance['Slot'], Symbol('another-value'))

        instance.delete()
Exemple #8
0
    def test_eval_python_function(self):
        """Python function is evaluated correctly."""
        expected = (0, 1.1, "2", Symbol('three'), InstanceName('four'))
        ret = self.env.eval('(python_function 0 1.1 "2" three [four])')
        self.assertEqual(ret, expected)

        expected = (0, 1.1, "2", Symbol('three'))
        ret = self.env.eval('(python-function-renamed 0 1.1 "2" three)')
        self.assertEqual(ret, expected)

        expected = (Symbol('nil'), Symbol('TRUE'), Symbol('FALSE'))
        ret = self.env.eval('(python_types)')
        self.assertEqual(ret, expected)
Exemple #9
0
    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 add_emergency():
    global emergency_count
    emergency = EMERGENCY_TEMPLATE.new_fact()
    emergency["id"] = emergency_count
    emergency["type"] = Symbol(request.form.get("emergencytype"))
    emergency["location"] = [
        float(request.form.get("locx")),
        float(request.form.get("locy"))
    ]
    emergency["n_affected_people"] = int(request.form.get("affected"))
    emergency.assertit()

    if emergency.asserted:
        emergency_count += 1
        env.run()
        data = {"id": emergency['id'], "type": emergency['type']}
        logs = get_current_responses()
        response = Success(callback=data,
                           logs=logs,
                           message="Emergency added successfully")
        json_data = json.dumps(response.__dict__,
                               default=lambda o: o.__dict__,
                               indent=4)
        return json_data

    response = Error(None, None,
                     "Emergency could not be added. Try again later.")
    json_data = json.dumps(response.__dict__,
                           default=lambda o: o.__dict__,
                           indent=4)
    return json_data
def add_service():
    global service_count
    service = SERVICE_TEMPLATE.new_fact()
    service["id"] = service_count
    service["name"] = Symbol(request.form.get("servicename"))
    service["location"] = [
        float(request.form.get("locx")),
        float(request.form.get("locy"))
    ]
    service["n_members"] = int(request.form.get("members"))
    service["movement_speed"] = float(request.form.get("speed"))
    service["prep_time"] = float(request.form.get("preptime"))
    service.assertit()

    if service.asserted:
        service_count += 1
        env.run()
        data = {"id": service['id'], "name": service['name']}
        logs = get_current_responses()
        response = Success(callback=data,
                           logs=logs,
                           message="Emergency added successfully")
        json_data = json.dumps(response.__dict__,
                               default=lambda o: o.__dict__,
                               indent=4)
        return json_data

    response = Error(None, None,
                     "Service could not be added. Try again later.")
    json_data = json.dumps(response.__dict__,
                           default=lambda o: o.__dict__,
                           indent=4)
    return json_data
Exemple #12
0
    def test_make_instance_errors(self):
        """Instance errors."""
        defclass = self.env.find_class('ConcreteClass')

        with self.assertRaises(KeyError):
            defclass.make_instance('some-instance', NonExistingSlot=1)
        with self.assertRaises(TypeError):
            defclass.make_instance('some-instance', Slot="wrong type")
        with self.assertRaises(ValueError):
            defclass.make_instance('some-instance', Slot=Symbol('wrong-value'))
Exemple #13
0
    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, ('SYMBOL', ))
        self.assertEqual(slot.sources, (defclass.name, ))
        self.assertEqual(slot.range, Symbol('FALSE'))
        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('value'))
        self.assertEqual(slot.allowed_values, ('value', 'another-value'))
        self.assertEqual(tuple(slot.allowed_classes()), ())
Exemple #14
0
    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()))
Exemple #15
0
    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)
Exemple #16
0
    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)

        self.assertEqual(self.env.call('function-sum', 1, 2), 3)
        self.assertEqual(self.env.call('generic-sum', 1, 2), 3)

        self.assertEqual(
            self.env.call('create$', 1, 2.0, "three", Symbol('four')),
            (1, 2.0, 'three', 'four'))
Exemple #17
0
    def test_instance(self):
        """Instance test."""
        defclass = self.env.classes.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)')

        instance.delete()

        instance = defclass.new_instance('test-instance')

        instance.unmake()
Exemple #18
0
    def test_template_fact_already_asserted(self):
        """Asserted TemplateFacts cannot be modified or re-asserted."""
        template = self.env.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()
Exemple #19
0
    def test_make_instance(self):
        """Instance test."""
        defclass = self.env.find_class('ConcreteClass')

        instance_name = self.env.eval(
            '(make-instance test-name-instance of ConcreteClass)')
        self.assertEqual(instance_name, 'test-name-instance')
        self.assertTrue(isinstance(instance_name, InstanceName))

        instance = defclass.make_instance()
        self.assertEqual(instance.name, 'gen1')

        instance = defclass.make_instance('test-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()

        with self.assertRaises(LookupError):
            self.env.find_instance('test-instance')

        instance = defclass.make_instance('test-instance')

        instance.unmake()

        with self.assertRaises(LookupError):
            self.env.find_instance('test-instance')
Exemple #20
0
    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()
Exemple #21
0
    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()))
Exemple #22
0
    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()))
Exemple #23
0
    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()), ())