示例#1
0
    def test_formula_parser_method_call_with_args_and_kwargs(self):
        assert formula_parser.parse('A.some_method("string", some_setting=True)') == (
            'MethodCall',
             'A',
             'some_method',
             (('Str', 'string'),),
             (('some_setting', ('Bool', 'True')),))

        assert formula_parser.parse('A.some_method(some_setting=True)') == (
            'MethodCall',
             'A',
             'some_method',
             (),
             (('some_setting', ('Bool', 'True')),))
示例#2
0
    def test_formula_parser_method_call_with_args_and_kwargs_expr(self):
        to_e = lambda f:formula_parser.tree_to_expr(formula_parser.parse(f))
        assert to_e('A.some_method("string", some_setting=True)') == \
                "some_method(A,'string',some_setting=True)"

        assert to_e('A.some_method(some_setting=True)') == \
                "some_method(A,some_setting=True)"
示例#3
0
    def test_formula_parser_method_call_with_dict(self):

        assert formula_parser.parse('A.some_method({\'some dimension\':\'XYZ\'})') == (
            'MethodCall',
            'A',
            'some_method',
            (('Dict', ((('Str', 'some dimension'), ('Str', 'XYZ')),)),),
            ()
        )
示例#4
0
 def test_formula_parser_method_call_with_args(self):
     assert formula_parser.parse('A.some_method("string", B, 1, 2.3, (1, 2, 3))') == (
         'MethodCall',
              'A',
              'some_method',
              (
                 ('Str', 'string'),
                 ('Name', 'B'),
                 ('Num', 1),
                 ('Num', 2.3),
                 ('Tuple', (('Num', 1), ('Num', 2), ('Num', 3)))
             ),
             ()
     )
示例#5
0
 def getMeasureData(self, measure_ids, company_id, start_date, end_date):
     self.cursor.execute("use precompute")
     sql_version = "select max(big_table_version_id) from ks_fact where company_id = %s"%(company_id)
     self.cursor.execute(sql_version)
     rows = self.cursor.fetchall()
     row = rows[0]
     version = row[0]
     data = {}
     for measure_id in measure_ids:
         ks_fh = filehandler(self.db)
         measure_data = ks_fh.getMeasureDataByID(measure_id)
         if len(measure_data["formula"])>0:
             formula_data = {}
             formula_tree = parse(measure_data["formula"])
             facts = tree_names(formula_tree)
             formula_data["op"] = formula_tree[0]
             formula_data["rhs"] = ks_fh.getMeasureID(list(facts)[0])
             formula_data["lhs"] = ks_fh.getMeasureID(list(facts)[1])
             formula_data["agg_type"] = measure_data["agg_type"]
             data[measure_id] = self.getRawDataFormula(formula_data,version,  measure_id, start_date, end_date)
             
         else:
             data[measure_id] = self.getRawData(version, measure_id, start_date, end_date)
     return data
示例#6
0
 def test_tree_names_for_simple_arithmetic(self):
     tree = formula_parser.parse('(A+B)/(C-D)*X')
     self.assertEqual(
         'ABCDX',
         ''.join(sorted(list(formula_parser.tree_names(tree)))))
示例#7
0
 def test_formula_parser_method_call_with_dict_expr(self):
     to_e = lambda f:formula_parser.tree_to_expr(formula_parser.parse(f))
     assert to_e('A.some_method({\'some dimension\':\'XYZ\'})') == \
             "some_method(A,{'some dimension':'XYZ'})"
示例#8
0
 def test_formula_parser_method_call_with_args_expr(self):
     to_e = lambda f:formula_parser.tree_to_expr(formula_parser.parse(f))
     assert to_e('A.some_method("string", B, 1, 2.3, (1, 2, 3))') == \
             "some_method(A,'string',B,1,2.3,(1,2,3))"
示例#9
0
 def test_tree_names_for_method_call_with_tuple(self):
     tree = formula_parser.parse('A.some_method((X, Y, 7))/A')
     assert 'AXY' == ''.join(sorted(list(formula_parser.tree_names(tree))))
示例#10
0
 def test_formula_parser_basic_method_call_expr(self):
     to_e = lambda f:formula_parser.tree_to_expr(formula_parser.parse(f))
     assert 'prev_period(A)' == to_e('A.prev_period()')
示例#11
0
 def test_formula_parser_basic_method_call(self):
     assert ('MethodCall', 'A', 'prev_period', (), ()) == formula_parser.parse('A.prev_period()')
示例#12
0
 def test_formula_parser_nested_parens_expr(self):
     to_e = lambda f:formula_parser.tree_to_expr(formula_parser.parse(f))
     assert to_e('A*B/(A+B)') == 'div(mult(A,B),add(A,B))'
示例#13
0
 def test_formula_parser_nested_parens(self):
     assert formula_parser.parse('A*B/(A+B)') == (
         'Div',
          ('Mult', ('Name', 'A'), ('Name', 'B')),
          ('Add', ('Name', 'A'), ('Name', 'B'))
     )
示例#14
0
 def test_tree_names_for_method_call_with_dict(self):
     tree = formula_parser.parse('A.some_method({"X":X, "Y":7})/A')
     assert 'AX' == ''.join(sorted(list(formula_parser.tree_names(tree))))
示例#15
0
 def test_formula_parser_simple_arithmetic_to_expr(self):
     to_e = lambda f:formula_parser.tree_to_expr(formula_parser.parse(f))
     assert 'add(A,B)' == to_e('A+B')
     assert 'mult(A,B)' == to_e('A*B')
     assert 'div(A,B)' == to_e('A/B')
     assert 'sub(A,B)' == to_e('A-B')
示例#16
0
 def test_formula_parser_simple_arithmetic(self):
     assert  ('Add', ('Name', 'A'), ('Name', 'B')) == formula_parser.parse('A+B')
     assert  ('Mult', ('Name', 'A'), ('Name', 'B')) == formula_parser.parse('A*B')
     assert  ('Div', ('Name', 'A'), ('Name', 'B')) == formula_parser.parse('A/B')
     assert  ('Sub', ('Name', 'A'), ('Name', 'B')) == formula_parser.parse('A-B')
示例#17
0
            linebreaks = set(int(w) for w in linebreaks_str.split())

        if len(stmt) > 0 and stmt[0] == "assert":
            formula = stmt[1]

            if clause_number > 1:
                if args.conjunction:
                    print("%\n\\land\n%")
                else:
                    print("~\\\\~")

            if clause_number == 1 and args.conjunction:
                print("& %")

            print(f"% {formula}")
            latex = formula_parser.parse(formula)[0]

            if args.conjunction:
                if formula[0] == 'or':
                    print(f"({latex})")
                else:
                    print(latex)

                if clause_number in linebreaks:
                    print("~\\\\~\n& %")
                    # print("~\\land \\\\~")
            else:
                print(f"& {latex}")

            clause_number += 1
示例#18
0
 def test_tree_names_for_method_call_args_and_kwargs(self):
     tree = formula_parser.parse('A.some_method(X, Y, some_arg=Z)/A')
     assert 'AXYZ' == ''.join(sorted(list(formula_parser.tree_names(tree))))