Beispiel #1
0
 def test_global_names(self):
     """When an operand is bound, its global name must be set accordingly."""
     operand = String("hey there")
     bind1 = Bind("da_global_name", operand)
     bind2 = Bind("Da_Global_Name", operand)
     eq_(bind1.global_name, "da_global_name")
     eq_(bind1.global_name, bind2.global_name)
Beispiel #2
0
 def test_constructor_with_objects(self):
     objects = [
         Bind("greeting", String("hey")),
         Bind("traffic", TrafficLightVar())
     ]
     st = SymbolTable("global", objects)
     eq_(st.objects, set(objects))
Beispiel #3
0
    def test_retrieving_namespace_with_partially_untrastlated_contents(self):
        """
        When a namespace is requested in a locale in which not all items are
        available, the namespace with global names should be returned instead.

        """
        bool_var = BoolVar()
        traffic = TrafficLightVar()
        st = SymbolTable(
            "global",
            (Bind("bool", BoolVar(), es="booleano", fr=u"booléen"),
             Bind("traffic", TrafficLightVar(), es=u"tráfico")),
            SymbolTable(
                "foo",
                (
                    Bind("bar", bool_var, es="fulano"),
                    Bind("baz", traffic, es="mengano", fr="bonjour"),
                ),
            ),
        )

        # Checking the namespace:
        namespace = st.get_namespace("fr")
        eq_(len(namespace.subnamespaces), 1)
        subnamespace = namespace.subnamespaces["foo"]
        subnamespace_objects = {
            'bar': bool_var,
            'bonjour': traffic,
        }
        eq_(subnamespace.objects, subnamespace_objects)
        expected_unbound_objects_global = {
            u'booléen': BoolVar(),
            'traffic': TrafficLightVar(),
        }
        eq_(namespace.objects, expected_unbound_objects_global)
Beispiel #4
0
    def _solve_rules(self, rules, metrics):
        """
        solve the rules using the given metrics.
        metrics must contains all needed metrics.
        :param list[Rule] rules: the
        :param metrics:
        :return:
        :raises:
            pyparsing.ParseException
        """
        results = {}

        root_table = SymbolTable('root', ())

        for metric_name, values in metrics.items():
            # bind to allow "rmq & rmq:xxx"
            root_table.add_object(Bind(metric_name, Constant(bool(values))))
            # bind to allow "rmq:latency" etc
            root_table.add_subtable(
                SymbolTable(
                    metric_name,
                    tuple(Bind(k, Constant(v)) for k, v in values.items())))
        # build the symbol table for all rules (as boolean)
        rules_symbols = SymbolTable('rules', ())

        root_table.add_subtable(rules_symbols)
        for rule in rules:
            rule_name_ = rule['name']

            rules_symbols.add_object(
                Bind(
                    rule_name_,
                    BooleanVariable(
                        partial(get_rule_result,
                                rule_name=rule_name_,
                                rule=rule))))
            rules_symbols.add_subtable(
                SymbolTable(rule_name_, (Bind(
                    'since',
                    DurationVariable(
                        partial(get_since, rule_name=rule_name_,
                                rule=rule))), )))

        parse_manager = EvaluableParseManager(root_table, grammar)

        for rule in rules:

            expression_ = rule['expression']
            try:
                results[rule['name']] = parse_manager.parse(expression_)(
                    results)
            except pyparsing.ParseException as e:
                logger.debug("error while parsing %r: %s", expression_, e)
                raise
        return results
Beispiel #5
0
 def test_string_without_symbol_table(self):
     # With ASCII characters:
     bind1 = Bind("pi", Number(3.1416))
     bind1_as_unicode = six.text_type(bind1)
     eq_(bind1_as_unicode, 'Operand 3.1416 bound as "pi"')
     eq_(bind1_as_unicode, six.text_type(bind1))
     # With non-ASCII characters:
     bind2 = Bind(u"pí", Number(3.1416))
     bind2_as_unicode = six.text_type(bind2)
     eq_(bind2_as_unicode, u'Operand 3.1416 bound as "pí"')
     eq_(six.text_type(bind2), 'Operand 3.1416 bound as "pí"')
Beispiel #6
0
    def test_checking_duplicate_object_global_names(self):
        """
        Two objects cannot have the same global names in the same table.

        """
        st = SymbolTable(
            "global",
            (
                Bind("e", Number(2.7183), es_VE=u"número e"),
                Bind("pi", Number(3.1416)),
                Bind("e", Number(2.71828), es_ES=u"número e"),
            ),
        )
        assert_raises(ScopeError, st.validate_scope)
Beispiel #7
0
 def test_retrieving_non_existing_localized_names(self):
     """
     When a non-existing localized name is requested, a warning must be 
     issued and the global name returned.
     
     """
     bind = Bind("foo", String("hey"), es="fulano")
     logging_fixture = LoggingHandlerFixture()
     eq_(bind.get_localized_name("fr"), "foo")
     # Checking for the the warning:
     eq_(len(logging_fixture.handler.messages["warning"]), 1)
     warning = logging_fixture.handler.messages["warning"][0]
     eq_(warning, 'Operand "hey" bound as "foo" doesn\'t have a name in fr; '
                  'using the global one')
     # Undoing it:
     logging_fixture.undo()
Beispiel #8
0
 def test_string_with_symbol_table(self):
     # With ASCII characters:
     bind1 = Bind("pi", Number(3.1416))
     SymbolTable("global", [bind1])
     bind1_as_unicode = six.text_type(bind1)
     eq_('Operand 3.1416 bound as "pi" (in Symbol table global)',
         bind1_as_unicode)
     eq_(six.text_type(bind1), bind1_as_unicode)
     # With non-ASCII characters:
     bind2 = Bind(u"pí", Number(3.1416))
     SymbolTable("global", [bind2])
     bind2_as_unicode = six.text_type(bind2)
     eq_(u'Operand 3.1416 bound as "pí" (in Symbol table global)',
         bind2_as_unicode)
     eq_('Operand 3.1416 bound as "pí" (in Symbol table global)',
         six.text_type(bind2))
Beispiel #9
0
    def test_names(self):
        """
        When an operand is bound, its multiple names must be set accordingly.

        """
        operand = String("Vive la france !")
        # No localized names:
        bind1 = Bind("foo", operand)
        eq_(bind1.names, {})
        # Lower-case names:
        names0 = {'es_VE': "cartuchera", 'es_ES': "estuche"}
        bind2 = Bind("bar", operand, **names0)
        eq_(bind2.names, names0)
        # Mixed-case names -- must be converted to lower-case:
        names1 = {'es_VE': "Cartuchera", 'es_ES': "estuche"}
        bind2 = Bind("bar", operand, **names1)
        eq_(bind2.names, names0)
Beispiel #10
0
    def test_name_clash_in_grand_children(self):
        """
        The scope must be validated even inside the sub-tables.

        """
        sciences_st1 = SymbolTable(
            "sciences",
            (),
            SymbolTable("maths", (), es=u"matemática"),
            SymbolTable("computing", ()),
            SymbolTable("maths", ()),
        )
        sciences_st2 = SymbolTable(
            "sciences",
            (),
            SymbolTable("maths", (), es=u"matemática"),
            SymbolTable("computing", ()),
            SymbolTable("mathematics", (), es=u"matemática"),
        )
        sciences_st3 = SymbolTable(
            "sciences",
            (),
            SymbolTable("maths", (), es=u"matemática"),
            SymbolTable("computing", ()),
            # This sub-table will be called "matemática" in Spanish too:
            SymbolTable(u"matemática", ()),
        )
        # Now a name clash at the objects level:
        sciences_st4 = SymbolTable("global", (
            Bind("foo", BoolVar()),
            Bind("foo", TrafficLightVar(), es="bar"),
        ))

        st1 = SymbolTable("global", (), sciences_st1,
                          SymbolTable("society", ()))
        st2 = SymbolTable("global", (), sciences_st2,
                          SymbolTable("society", ()))
        st3 = SymbolTable("global", (), sciences_st3,
                          SymbolTable("society", ()))
        st4 = SymbolTable("global", (), sciences_st4)

        assert_raises(ScopeError, st1.validate_scope)
        assert_raises(ScopeError, st2.validate_scope)
        assert_raises(ScopeError, st3.validate_scope)
        assert_raises(ScopeError, st4.validate_scope)
Beispiel #11
0
 def test_checking_valid_table(self):
     st = SymbolTable(
         "global",
         # Bindings/global objects:
         (
             Bind("bool", BoolVar(), es="booleano"),
             Bind("traffic", TrafficLightVar(), es=u"tráfico"),
         ),
         # Sub-tables:
         SymbolTable(
             "maths",
             (
                 Bind("pi", Number(3.1416)),
                 Bind("e", Number(2.7183)),
             ),
         ),
     )
     eq_(st.validate_scope(), None)
Beispiel #12
0
    def test_checking_object_and_subtable_sharing_localized_name(self):
        """
        It's valid for an object and a sub-table to share the localized name.

        """
        st1 = SymbolTable(
            "global",
            (Bind("current_day", BoolVar(), es="hoy"), ),
            SymbolTable("today", (), es="hoy"),
        )
        st2 = SymbolTable(
            "global",
            (Bind("current_day", BoolVar(), es="hoy"), ),
            # This sub-name will be called "hoy" in Spanish too:
            SymbolTable("hoy", ()),
        )
        eq_(st1.validate_scope(), None)
        eq_(st2.validate_scope(), None)
Beispiel #13
0
    def test_retrieving_non_existing_localized_names(self):
        """
        When a non-existing localized name is requested, a warning must be
        issued and the global name returned.

        """
        bind = Bind("foo", String("hey"), es="fulano")
        logging_fixture = LoggingHandlerFixture()
        eq_(bind.get_localized_name("fr"), "foo")
        # Checking for the the warning:
        eq_(len(logging_fixture.handler.messages["warning"]), 1)
        warning = logging_fixture.handler.messages["warning"][0]
        eq_(
            warning,
            'Operand "hey" bound as "foo" doesn\'t have a name in fr; '
            'using the global one')
        # Undoing it:
        logging_fixture.undo()
Beispiel #14
0
    def test_checking_object_and_subtable_sharing_global_name(self):
        """
        It's valid for an object and a sub-table to share the global name.

        """
        st = SymbolTable(
            "global",
            (Bind("today", BoolVar()), ),
            SymbolTable("today", ()),
        )
        eq_(st.validate_scope(), None)
Beispiel #15
0
    def test_retrieving_namespace_without_children(self):
        """
        A namespace shouldn't have sub-namespaces if the original symbol table
        doesn't have sub-tables.

        """
        bool_var = BoolVar()
        traffic = TrafficLightVar()
        st = SymbolTable(
            "global",
            (Bind("bool", bool_var,
                  es="booleano"), Bind("traffic", traffic, es=u"tráfico")),
        )

        # Checking the namespace:
        global_namespace = st.get_namespace()
        eq_(len(global_namespace.subnamespaces), 0)

        # Checking the namespace in Castilian:
        castilian_namespace = st.get_namespace("es")
        eq_(len(castilian_namespace.subnamespaces), 0)
Beispiel #16
0
    def test_retrieving_namespace_with_children(self):
        """
        A namespace should have sub-namespaces for the sub-tables of the
        original symbol table.

        """
        bool_var = BoolVar()
        traffic = TrafficLightVar()
        st = SymbolTable(
            "global",
            (Bind("bool", bool_var,
                  es="booleano"), Bind("traffic", traffic, es=u"tráfico")),
            SymbolTable(
                "foo",
                (
                    Bind("bar", bool_var, es="fulano"),
                    Bind("baz", traffic, es="mengano"),
                ),
            ),
        )

        # Checking the namespace:
        global_namespace = st.get_namespace()
        eq_(len(global_namespace.subnamespaces), 1)
        global_subnamespace = global_namespace.subnamespaces["foo"]
        global_subnamespace_objects = {
            'bar': bool_var,
            'baz': traffic,
        }
        eq_(global_subnamespace.objects, global_subnamespace_objects)

        # Checking the namespace in Castilian:
        castilian_namespace = st.get_namespace("es")
        eq_(len(castilian_namespace.subnamespaces), 1)
        castilian_subnamespace = castilian_namespace.subnamespaces["foo"]
        castilian_subnamespace_objects = {
            'fulano': bool_var,
            'mengano': traffic,
        }
        eq_(castilian_subnamespace.objects, castilian_subnamespace_objects)
Beispiel #17
0
    def test_unreusable_bindings(self):
        """
        Operand bindings and symbol tables can only be bound to a single parent
        symbol table.

        """
        # An operand binding:
        bind = Bind("traffic-light", TrafficLightVar())
        SymbolTable("traffic", [bind])
        assert_raises(ScopeError, SymbolTable, "baz", [bind])
        # A symbol table:
        st0 = SymbolTable("foo", [])
        SymbolTable("global", [], st0)
        assert_raises(ScopeError, SymbolTable, "bar", [], st0)
    def create_grammar(self):
        root_table = SymbolTable(
            "root",
            map(lambda f: Bind(f['name'], GeometryProperty(f['name'])),
                self.fields))

        tokens = {
            'not': 'not',
            'eq': '==',
            'ne': '!=',
            'belongs_to': 'in',
            'is_subset': 'are included in',
            'or': "or",
            'and': 'and'
        }
        grammar = Grammar(**tokens)
        self.parse_manager = EvaluableParseManager(root_table, grammar)
Beispiel #19
0
 def test_duplicate_objects(self):
     """There must be no duplicate object."""
     # In the constructor:
     objects1 = [
         Bind("salutation", String("hey")),
         Bind("traffic", TrafficLightVar()),
         Bind("salutation", String("hey"))
     ]
     assert_raises(ScopeError, SymbolTable, "global", objects1)
     # Post-instantiation:
     objects2 = [
         Bind("salutation", String("hey")),
         Bind("traffic", TrafficLightVar())
     ]
     st = SymbolTable("global", objects2)
     assert_raises(ScopeError, st.add_object,
                   Bind("salutation", String("hey")))
Beispiel #20
0
    def test_checking_duplicate_object_localized_names(self):
        """
        Two objects cannot have the same localized names in the same table.

        """
        st1 = SymbolTable(
            "global",
            (
                Bind("e", Number(2.7183), es_VE=u"número e"),
                Bind("pi", Number(3.1416)),
                Bind("eulers-number", Number(2.71828), es_VE=u"número e"),
            ),
        )
        st2 = SymbolTable(
            "global",
            (
                Bind("e", Number(2.7183), es_VE=u"número e"),
                Bind("pi", Number(3.1416)),
                # These object will be called "número e" in Spanish too:
                Bind(u"número e", Number(2.71828)),
            ),
        )
        assert_raises(ScopeError, st1.validate_scope)
        assert_raises(ScopeError, st2.validate_scope)
Beispiel #21
0
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import datetime

from booleano.operations.operands.constants import Number
from booleano.parser.core import EvaluableParseManager
from booleano.parser.grammar import Grammar

from booleano.operations.variables import NumberVariable, StringVariable, DurationVariable, SetVariable
from booleano.parser.scope import SymbolTable, Bind

name = StringVariable("name")

symbols = SymbolTable(
    'my_table', [
        Bind('character', name),
    ],
    SymbolTable('character', [
        Bind('age', NumberVariable('age')),
        Bind('name', name),
        Bind('training', DurationVariable('training')),
        Bind('bending', SetVariable('bending')),
    ]), SymbolTable('consts', [
        Bind('majority', Number(18)),
    ]))

grammar = Grammar(**{'and': 'and', 'or': 'or', 'belongs_to': 'in'})

# 2: create the parser with se symbol table and the grammar (customized)
parse_manager = EvaluableParseManager(symbols, grammar)
# 3: compile a expression
Beispiel #22
0
 def test_no_default_symbol_table(self):
     """Operand bindings must not be in a symbol table by default."""
     bind = Bind("foo", String("whatever"))
     eq_(bind.symbol_table, None)
Beispiel #23
0
 def test_retrieving_existing_localized_names(self):
     bind = Bind("foo", String("hey"), es="fulano")
     eq_(bind.get_localized_name("es"), "fulano")
Beispiel #24
0
 def test_contents_retrieval(self):
     """Bindings must return bound operand as its contents."""
     op = BoolVar()
     bind = Bind("bool", op)
     eq_(op, bind._get_contents(None))
Beispiel #25
0
 def test_constant(self):
     """Constants can be bound."""
     constant = String("I'm a string!")
     bound_constant = Bind("da_string", constant)
     eq_(bound_constant.operand, constant)
Beispiel #26
0
 def test_retrieving_existing_localized_names(self):
     bind = Bind("foo", String("hey"), es="fulano")
     eq_(bind.get_localized_name("es"), "fulano")
Beispiel #27
0
    def test_equivalence(self):
        objects1 = lambda: [
            Bind("dish", String("cachapa")),
            Bind("drink", String("empanada"))
        ]
        objects2 = lambda: [
            Bind("drink", String("empanada")),
            Bind("dish", String("cachapa"))
        ]
        objects3 = lambda: [Bind("pi", Number(3.1416))]

        st1 = SymbolTable("foo", objects1())
        st2 = SymbolTable("foo", objects1())
        st3 = SymbolTable("foo", objects1(), es="fulano")
        st4 = SymbolTable("foo", objects1(), es="fulano")
        st5 = SymbolTable("foo", objects2())
        st6 = SymbolTable("foo", objects3())
        st7 = SymbolTable("foo", objects2(), es="fulano")
        st8 = SymbolTable("foo", objects3(), es_VE="fulano")
        st9 = SymbolTable("bar", objects1())
        st10 = SymbolTable("foo", objects1())
        st11 = SymbolTable("foo", objects1(), SymbolTable("bar", []),
                           SymbolTable("baz", []))
        st12 = SymbolTable("foo", objects1(), SymbolTable("baz", []),
                           SymbolTable("bar", []))

        # Moving st10 into the "baz" symbol table:
        SymbolTable("baz", [], st10)

        ok_(st1 == st2)
        ok_(st1 == st5)
        ok_(st1 == st10)
        ok_(st2 == st1)
        ok_(st2 == st5)
        ok_(st2 == st10)
        ok_(st3 == st4)
        ok_(st3 == st7)
        ok_(st4 == st3)
        ok_(st4 == st7)
        ok_(st5 == st1)
        ok_(st5 == st2)
        ok_(st5 == st10)
        ok_(st7 == st3)
        ok_(st7 == st4)
        ok_(st10 == st1)
        ok_(st10 == st2)
        ok_(st10 == st5)
        ok_(st11 == st12)
        ok_(st12 == st11)

        ok_(st1 != None)
        ok_(st1 != Bind("foo", String("cachapa")))

        ok_(st1 != st3)
        ok_(st1 != st4)
        ok_(st1 != st6)
        ok_(st1 != st7)
        ok_(st1 != st8)
        ok_(st1 != st9)
        ok_(st1 != st11)
        ok_(st1 != st12)
        ok_(st2 != st3)
        ok_(st2 != st4)
        ok_(st2 != st6)
        ok_(st2 != st7)
        ok_(st2 != st8)
        ok_(st2 != st9)
        ok_(st2 != st11)
        ok_(st2 != st12)
        ok_(st3 != st1)
        ok_(st3 != st2)
        ok_(st3 != st5)
        ok_(st3 != st6)
        ok_(st3 != st8)
        ok_(st3 != st9)
        ok_(st3 != st10)
        ok_(st3 != st11)
        ok_(st3 != st12)
        ok_(st4 != st1)
        ok_(st4 != st2)
        ok_(st4 != st5)
        ok_(st4 != st6)
        ok_(st4 != st8)
        ok_(st4 != st9)
        ok_(st4 != st10)
        ok_(st4 != st11)
        ok_(st4 != st12)
        ok_(st5 != st3)
        ok_(st5 != st4)
        ok_(st5 != st6)
        ok_(st5 != st7)
        ok_(st5 != st8)
        ok_(st5 != st9)
        ok_(st5 != st11)
        ok_(st5 != st12)
        ok_(st6 != st1)
        ok_(st6 != st2)
        ok_(st6 != st3)
        ok_(st6 != st4)
        ok_(st6 != st5)
        ok_(st6 != st7)
        ok_(st6 != st8)
        ok_(st6 != st9)
        ok_(st6 != st10)
        ok_(st6 != st11)
        ok_(st6 != st12)
        ok_(st7 != st1)
        ok_(st7 != st2)
        ok_(st7 != st5)
        ok_(st7 != st6)
        ok_(st7 != st8)
        ok_(st7 != st9)
        ok_(st7 != st10)
        ok_(st7 != st11)
        ok_(st7 != st12)
        ok_(st8 != st1)
        ok_(st8 != st2)
        ok_(st8 != st3)
        ok_(st8 != st4)
        ok_(st8 != st5)
        ok_(st8 != st6)
        ok_(st8 != st7)
        ok_(st8 != st9)
        ok_(st8 != st10)
        ok_(st8 != st11)
        ok_(st8 != st12)
        ok_(st9 != st1)
        ok_(st9 != st2)
        ok_(st9 != st3)
        ok_(st9 != st4)
        ok_(st9 != st5)
        ok_(st9 != st6)
        ok_(st9 != st7)
        ok_(st9 != st8)
        ok_(st9 != st10)
        ok_(st9 != st11)
        ok_(st9 != st12)
        ok_(st10 != st3)
        ok_(st10 != st4)
        ok_(st10 != st6)
        ok_(st10 != st7)
        ok_(st10 != st8)
        ok_(st10 != st9)
        ok_(st11 != st1)
        ok_(st11 != st2)
        ok_(st11 != st3)
        ok_(st11 != st4)
        ok_(st11 != st5)
        ok_(st11 != st6)
        ok_(st11 != st7)
        ok_(st11 != st8)
        ok_(st11 != st9)
        ok_(st11 != st10)
        ok_(st12 != st1)
        ok_(st12 != st2)
        ok_(st12 != st3)
        ok_(st12 != st4)
        ok_(st12 != st5)
        ok_(st12 != st6)
        ok_(st12 != st7)
        ok_(st12 != st8)
        ok_(st12 != st9)
        ok_(st12 != st10)
Beispiel #28
0
 def test_instance(self):
     """Class instances can be bound."""
     instance = TrafficLightVar()
     bound_instance = Bind("da_variable", instance)
     eq_(bound_instance.operand, instance)
Beispiel #29
0
 def test_contents_retrieval(self):
     """Bindings must return bound operand as its contents."""
     op = BoolVar()
     bind = Bind("bool", op)
     eq_(op, bind._get_contents(None))
Beispiel #30
0
    def test_equality(self):
        """Two bindings are equivalent if they have the same names."""
        op1 = TrafficLightVar()
        op2 = String("hey, where's my car?")
        bind1 = Bind("name1", op1)
        bind2 = Bind("name2", op2)
        bind3 = Bind("name2", op1)
        bind4 = Bind("name1", op2)
        bind5 = Bind("name1", op1)
        bind6 = Bind("name2", op2)
        bind7 = Bind("name1", op1, es="nombre1")
        bind8 = Bind("name1", op1, es_VE="nombre1", es="nombre1")
        bind9 = Bind("name1", op1, es="nombre1")

        ok_(bind1 == bind4)
        ok_(bind1 == bind5)
        ok_(bind2 == bind3)
        ok_(bind2 == bind6)
        ok_(bind3 == bind2)
        ok_(bind3 == bind6)
        ok_(bind4 == bind1)
        ok_(bind4 == bind5)
        ok_(bind5 == bind5)
        ok_(bind5 == bind1)
        ok_(bind5 == bind4)
        ok_(bind6 == bind2)
        ok_(bind6 == bind3)
        ok_(bind7 == bind9)
        ok_(bind9 == bind7)

        ok_(bind1 != None)
        ok_(bind1 != SymbolTable("name1", []))

        ok_(bind1 != bind2)
        ok_(bind1 != bind3)
        ok_(bind1 != bind6)
        ok_(bind1 != bind7)
        ok_(bind1 != bind8)
        ok_(bind1 != bind9)
        ok_(bind2 != bind1)
        ok_(bind2 != bind4)
        ok_(bind2 != bind5)
        ok_(bind2 != bind7)
        ok_(bind2 != bind8)
        ok_(bind2 != bind9)
        ok_(bind3 != bind1)
        ok_(bind3 != bind4)
        ok_(bind3 != bind5)
        ok_(bind3 != bind7)
        ok_(bind3 != bind8)
        ok_(bind3 != bind9)
        ok_(bind4 != bind2)
        ok_(bind4 != bind3)
        ok_(bind4 != bind6)
        ok_(bind4 != bind7)
        ok_(bind4 != bind8)
        ok_(bind4 != bind9)
        ok_(bind5 != bind2)
        ok_(bind5 != bind3)
        ok_(bind5 != bind6)
        ok_(bind5 != bind7)
        ok_(bind5 != bind8)
        ok_(bind5 != bind9)
        ok_(bind6 != bind1)
        ok_(bind6 != bind4)
        ok_(bind6 != bind5)
        ok_(bind6 != bind7)
        ok_(bind6 != bind8)
        ok_(bind6 != bind9)
        ok_(bind7 != bind1)
        ok_(bind7 != bind2)
        ok_(bind7 != bind3)
        ok_(bind7 != bind4)
        ok_(bind7 != bind5)
        ok_(bind7 != bind6)
        ok_(bind7 != bind8)
        ok_(bind8 != bind1)
        ok_(bind8 != bind2)
        ok_(bind8 != bind3)
        ok_(bind8 != bind4)
        ok_(bind8 != bind5)
        ok_(bind8 != bind6)
        ok_(bind8 != bind7)
        ok_(bind8 != bind9)
        ok_(bind9 != bind1)
        ok_(bind9 != bind2)
        ok_(bind9 != bind3)
        ok_(bind9 != bind4)
        ok_(bind9 != bind5)
        ok_(bind9 != bind6)
        ok_(bind9 != bind8)
Beispiel #31
0
 def test_repr(self):
     bind = Bind("pi", Number(3.1416))
     eq_(repr(bind), u'<Operand 3.1416 bound as "pi">')
Beispiel #32
0
        "age": 16,
        "birthdate": datetime.date(1983, 1, 1)
    },
    {
        "name": "sokka",
        "age": 15,
        "birthdate": datetime.date(1984, 1, 1)
    },
]

# 1: create a static Symbol Table
root_table = SymbolTable(
    "root",
    (
        # variablet taken from context
        Bind("age", NumberVariable('age')),
        Bind("name", StringVariable('name')),
        Bind("birthdate", DateVariable("birthdate")),
        Bind("tags", SetVariable("tags")),
        # constants
        Bind("majority", Number(18)),
    ))

# 2: create the parser with se symbol table and the grammar (customized)

grammar = Grammar(belongs_to='in')
parse_manager = EvaluableParseManager(root_table, grammar)
# 3: compile a expression
# compiled_expression = parse_manager.parse('age < majority & "o" in name & birthdate > "1983-02-02"')

# check the command line args