def __init__(self, comp_type, init):
self.indent_modifier = [0, 0]
name = init.get('name')
block_type = 'class_methods'
lines = init.get('_lines')
statements = list()
if init.get('import'):
statements.append(init.get('import'))
statements.append(
Statement('definition',
block_type,
init={
'keyword': 'def',
'name': name,
'arguments': lines[0],
}))
for line in lines[1:]:
statements.append(
Statement('line', block_type,
line='${indent}' + line.rstrip()))
super(ClassMethodComponent,
self).__init__(comp_type,
statements=statements,
outline_str='cls.' + name + ',')
def create_outline(self):
"""Create the outline of the WorkChain."""
block = Block('define_outline', 2)
indent = 1
block.add_statement(
Statement('comment',
'define_outline',
init={'comment': 'spec.outline('}))
for component in self._components:
if component.type not in OUTLINE_COMPONENTS:
# Component, that does not contribute to the outline.
continue
indent += component.indent_modifier[0]
# Add the components outline string to the outline.
block.add_statement(
Statement('comment',
'define_outline',
indent=indent,
init={'comment': component.outline_str}))
indent += component.indent_modifier[1]
block.add_statement(
Statement('comment', 'define_outline', init={'comment': ')'}))
self.blocks['define_outline'] = block
def p_return(p):
'''
return_statement : RETURN
| RETURN expression
'''
if len(p) == 2:
p[0] = Statement(StatementType.RETURN, p.lineno(1),
{'return_value': None})
else:
p[0] = Statement(StatementType.RETURN, p.lineno(1),
{'return_value': p[2]})
def p_class_instanciation(p):
'''
expression : NEW IDENT LP RP
| NEW IDENT LP args RP
'''
if len(p) == 5:
p[0] = Statement(StatementType.NEW_CLASS, p.lineno(1), {
'class_name': p[2],
'class_args': {}
})
else:
p[0] = Statement(StatementType.NEW_CLASS, p.lineno(1), {
'class_name': p[2],
'class_args': p[4]
})
def p_call_func(p):
'''
call_func : IDENT LP args RP
| IDENT LP RP
'''
if len(p) == 5:
p[0] = Statement(StatementType.FUNCTION_CALL, p.lineno(1), {
'function_name': p[1],
'args': p[3]
})
else:
p[0] = Statement(StatementType.FUNCTION_CALL, p.lineno(1), {
'function_name': p[1],
'args': []
})
def p_if_statement(p):
'''
if_statement : IF LP condition_statement RP block
| IF LP condition_statement RP block ELSE statement
'''
if len(p) == 6:
p[0] = Statement(StatementType.IF, p.lineno(1), {
'condition': p[3],
'statementlist': p[5]
})
else:
p[0] = Statement(StatementType.IF, p.lineno(1), {
'condition': p[3],
'statementlist': p[5],
'else_statementlist': [p[7]]
})
def create_statement(self):
"""
@rtype: Statement
"""
self._putMessageId(protocol.CREATE)
self._exchangeMessages()
return Statement(self.getInt())
def main():
while (True):
line = input("db > ")
if (line[0] == "."):
command_value = do_meta_command(line)
if (command_value == MetaCommands.META_COMMAND_SUCCESS):
continue
elif (command_value ==
MetaCommands.META_COMMAND_UNRECOGNIZED_COMMAND):
print("Unrecognized command {0} .\n".format(line))
continue
elif (command_value == MetaCommands.META_COMMAND_EXIT):
print("~Goodbye")
sys.exit()
statement = Statement()
statement_value = prepare_statement(line, statement)
if (statement_value == PreparedStatements.PREPARE_SUCCESS):
break
elif (statement_value ==
PreparedStatements.PREPARE_UNRECOGNIZED_STATEMENT):
print("Unrecognized keyword at start of {0} .\n".format(line))
continue
execute_statement(statement)
print("Executed")
def __init__(self, ast_node, prog):
self.ast_node = ast_node
# Reference to the program
self.prog = prog
# Get the function properties
name, params, localvars, statements = ast_node.children
# The name of the function
self.name = name.text
# Dictionaries for variables and parameters
self.params = {
p.text: VecParam(p.text, i)
for i, p in enumerate(params.children)
}
self.localvars = {
v.text: LocalVar(v.text, i)
for i, v in enumerate(localvars.children)
}
# Run statements
self.statements = [Statement(s, self) for s in statements.children]
self.before = FUNC_START_ASM
self.after = FUNC_END_ASM
def p_loop_statement(p):
'''
loop_statement : LOOP LP condition_statement RP block
| LOOP LP IDENT COLON expression RP block
'''
if len(p) == 6:
p[0] = Statement(StatementType.LOOP, p.lineno(1), {
'condition': p[3],
'statementlist': p[5]
})
else:
p[0] = Statement(StatementType.LOOP, p.lineno(1), {
'ident': p[3],
'loop_count': p[5],
'statementlist': p[7]
})
def get_clean_statement(self, worksheet):
if self.statement_dirty:
self.statement = Statement(self.tokenized.get_text(), worksheet)
self.statement.chunk = self
self.statement_dirty = False
return self.statement
def Replace(self):
# Get the rule
value = self.value_edit.currentText().strip()
# Add it to the logs
self.valueLog.AddRule(self.question, value)
# Propagate rule
self.ruleHeap.Propagate(self.question, value)
# If solutions are found, add them to logs and propagate them
solutions = self.ruleHeap.GetSolutions()
for sol in solutions:
sol_st = Statement(sol)
if (sol_st.root.sign):
val = "T"
else:
val = "F"
if (sol_st.root.symbol.mask not in ["T", "F"]):
self.valueLog.AddRule(sol_st.root.symbol.mask, val)
self.ruleHeap.Propagate(sol_st.root.symbol.mask, val)
self.reasoned.append(sol_st.root.symbol.mask)
self.UpdateValueLog()
self.UpdateRuleHeap()
if (self.ruleHeap.IsSolved()):
# Enter finished state
if (self.valueLog.RuleExists(self.objective)):
self.Explain()
else:
self.Fail()
else:
try:
self.SetNextQuestion()
except:
self.Fail()
def p_define_class(p):
'''
define_class : CLASS IDENT LC newline define_class_properties newline define_methods newline RC
| CLASS IDENT LC newline define_methods newline RC
'''
if len(p) == 8:
p[0] = Statement(StatementType.CLASS_DEFINE, p.lineno(1), {
'class_name': p[2],
'properties': [],
'methods': p[5]
})
else:
p[0] = Statement(StatementType.CLASS_DEFINE, p.lineno(1), {
'class_name': p[2],
'properties': p[5],
'methods': p[7]
})
def p_decrement(p):
'''
assign_statement : IDENT DECREMENT
'''
p[0] = Statement(StatementType.ASSIGN, p.lineno(1), {
'variable_name': p[1],
'type': 'decrement'
})
def p_define_func(p):
'''
define_function : FUNCTION IDENT LP RP block
| FUNCTION IDENT LP define_function_args RP block
'''
if len(p) == 6:
p[0] = Statement(StatementType.FUNCTION_DEFINE, p.lineno(1), {
'function_name': p[2],
'function_args': [],
'statementlist': p[5]
})
else:
p[0] = Statement(StatementType.FUNCTION_DEFINE, p.lineno(1), {
'function_name': p[2],
'function_args': p[4],
'statementlist': p[6]
})
def IsSolved(self):
regex = "^[\w]+$"
undef = []
for rule in self.rules:
rule_st = Statement(rule)
if(rule_st.root.symbol.mask in ["T", "F"]):
undef.append(rule)
return len(undef) == len(self.rules)
def p_instance_method(p):
'''
call_func : IDENT DOT IDENT LP RP
| IDENT DOT IDENT LP args RP
'''
if len(p) == 6:
p[0] = Statement(StatementType.CALL_METHOD, p.lineno(1), {
'variable_name': p[1],
'method_name': p[3],
'method_args': {}
})
else:
p[0] = Statement(StatementType.CALL_METHOD, p.lineno(1), {
'variable_name': p[1],
'method_name': p[3],
'method_args': p[5]
})
def p_if_statement_else(p):
'''
if_statement : IF LP condition_statement RP block ELSE block
'''
p[0] = Statement(StatementType.IF, p.lineno(1), {
'condition': p[3],
'statementlist': p[5],
'else_statementlist': p[7]
})
def p_assign_statement(p):
'''
assign_statement : IDENT ASSIGN expression
'''
# variables[p[1]] = p[3]
p[0] = Statement(StatementType.ASSIGN, p.lineno(1), {
'variable_name': p[1],
'expression': p[3]
})
def update_expression(self, cell_pos, attrib, expression, save=False):
#cell = self.cell_dict[cell_pos]
new_json = self.files[attrib].apply_statements(self.config, self.cell_dict, [Statement(attrib, [CellRange((cell_pos[0], cell_pos[0] + 1), (cell_pos[1], cell_pos[1] + 1))], Expression(expression))])
#new_json = cell.update_expression(attrib, Expression(expression), self.config, self.cell_dict)
new_json = {str(key)[1:-1]: value for key, value in new_json.items()}
if save: self.files[attrib].write_to_file()
self.data["cells"].update(new_json)
return json.dumps(self.data)
def build_statements(fiscal_periods):
statements = []
for fiscal_period in fiscal_periods:
for financial_statement in fiscal_period.Statement:
header = financial_statement.FPHeader
periodTypeCode = None
periodTypeValue = None
periodLength = None
auditorNameCode = None
auditorNameValue = None
auditorOpinionCode = None
auditorOpinionValue = None
sourceDate = None
if hasattr(header, 'periodType'):
periodTypeCode = header.periodType.Code
periodTypeValue = header.periodType.Value
periodLength = header.PeriodLength
if hasattr(header, 'AuditorName'):
auditorNameCode = header.AuditorName.Code
auditorNameValue = header.AuditorName.Value
if hasattr(header, 'AuditorOpinion'):
auditorOpinionCode = header.AuditorOpinion.Code
auditorOpinionValue = header.AuditorOpinion.Value
if hasattr(header.Source, 'Date'):
sourceDate = header.Source.Date
statement = Statement(fiscal_period.EndDate, fiscal_period.Type,
fiscal_period.FiscalYear,
financial_statement.Type,
periodTypeCode, periodTypeValue, periodLength,
auditorNameCode,
auditorNameValue,
header.Source.Value, sourceDate,
header.StatementDate,
header.UpdateType.Code, header.UpdateType.Value,
auditorOpinionCode, auditorOpinionValue,
financial_statement.lineItem)
statements.append(statement)
return statements
def GetSolutions(self):
"""Check for a ruleset that became a solution through Modus Tollens"""
#
# A rule is a solution if there is only one variable left in the rule
#
regex = "^[\w]+$"
solutions = []
for rule in self.rules:
rule_st = Statement(rule)
if(rule_st.root.symbol.code == "IDENTIFIER"):
if(rule_st.root.symbol.mask not in ["T", "F"]):
solutions.append(rule)
return solutions
def __init__(self, block_type, indent_level, init=None):
self._type = block_type
self._indent_level = indent_level
self._statements = []
# Add all the statements already contained in init.
if init is None:
init = []
for statement_type, value in init:
statement = Statement(statement_type, block_type, init=value)
self.add_statement(statement)
def p_expression(p):
'''
expression : term
| expression ADD term
| expression SUB term
'''
if len(p) == 4:
p[0] = Statement(StatementType.EXPRESSION, p.lineno(2), {
'left': p[1],
'right': p[3],
'op': p[2]
})
else:
p[0] = p[1]
def p_term(p):
'''
term : primary_expression
| term MUL primary_expression
| term DIV primary_expression
'''
if len(p) == 4:
p[0] = Statement(StatementType.EXPRESSION, p.linno(2), {
'left': p[1],
'right': p[3],
'op': p[2]
})
else:
p[0] = p[1]
def parse(self):
with open(self.path, 'r') as file:
text = file.read()
statements = []
matches = re.findall(
r"^([^(\|=)]*)=((\s*\|((\s\s*..*(\n|))*))|([^\n\|]*))", text,
re.MULTILINE)
for match in matches:
statements.append(
Statement(self.attrib, File.parse_cell_ranges(match[0]),
Expression(match[3].strip() or match[1].strip())))
self.statements = statements
def _find_control_flow(self, cursor, arg_parser):
if not isinstance(cursor, clang.cindex.Cursor):
return []
# find first compound of function and get child control flow
start_stmt_cursor = [
c for c in cursor.get_children()
if c.kind in util.dct_alias_compound_stmt
]
if len(start_stmt_cursor) != 1:
print("Error, cannot find stmt child into function %s" % self)
return None
return Statement(start_stmt_cursor[0],
arg_parser=arg_parser,
count_stmt=self.lst_cfg,
method_obj=self,
param_decl=[a for a in cursor.get_children()][:-1])
def read_statement_csv(path: str) -> Statement:
"""
Get Statement object from Revolut statement path
:param path: path of Revolut statement
:type path: str
:return: statement object
:rtype: Statement
"""
transactions = []
tr_dict = csv.DictReader(io.StringIO(get_csv_normalized(path)),
delimiter=',')
for el in tr_dict:
transaction = Transaction(el)
transactions.append(transaction)
transactions.reverse()
statement = Statement(transactions[0].currency, transactions)
return statement
def __init__(self, comp_type, init):
arguments = []
# Assemble the string, that will be passed as an argument
# in spec.item(...).
for item in ['name', 'valid_type']:
if item in init:
arguments.append('{0}={1}'.format(item, init.get(item)))
inputs = {'item_type': comp_type, 'arguments': ', '.join(arguments)}
block_type = 'define_' + comp_type + 's'
statements = []
if init.get('import'):
statements.append(inputs.get('import'))
statements.append(Statement('spec_item', block_type, init=inputs))
super(IOComponent, self).__init__(comp_type, statements=statements)
def __init__(self):
self.app = QtWidgets.QApplication(sys.argv)
self.main_window = QtWidgets.QWidget()
self.ui = Ui_MainWindow()
self.ui.setupUi(self.main_window)
self.main_window.setWindowIcon(QIcon('./system_files/图标.png'))
self.main_window.setFont(QFont("Microsoft YaHei", 9))
self.set_bace_url()
self.connect()
self.ui.pushButton.setEnabled(False)
# 创建声明
self.statement = Statement('news_output_word')
if not self.statement.check_pd:
exit()
if self.statement.accept:
self.main_window.show()
else:
self.statement.ui.pushButton.clicked.connect(self.main_window.show)
sys.exit(self.app.exec_())
