def serve(self):
left_part = self.left_part.serve()
right_part = self.right_part.serve()
if type(left_part) != type(right_part):
print(
f"Operator values types missmatch {type_to_string(left_part)}, {type_to_string(right_part)}."
)
return None
both_type = determine_type(left_part)
if self.operator == "+":
return left_part + right_part
if both_type == "str":
print(f"{self.operator} is not available for {both_type}")
return None
if self.operator == "-":
return left_part - right_part
elif self.operator == "*":
return left_part * right_part
elif self.operator == "/":
return left_part / right_part
elif self.operator == "^":
return convert_to(math.pow(left_part, right_part), both_type)
else:
print(f"Unsupported operator {self.operator}.")
return None
def extract_data(self, data, current_column):
temp_data = utils.remove_whitespace(data)
data_type = utils.determine_type(temp_data)
if data_type == self.schema[current_column]:
return temp_data
else:
return ''
def assign(self, v_name, v_value):
if v_name not in self.names:
return False
if self.names[v_name].type != determine_type(v_value):
raise VariableTypeError(
f"value {v_value} and type {self.names[v_name][0]} missmatch")
self.names[v_name] = Variable(self.names[v_name].type, v_value)
return True
def add_key_value(self):
if not(self.textEditHome.toPlainText() == "" or self.textEditKey.toPlainText() == ""):
if(not(self.textEditDFA.toPlainText() == "")):
tmp_sch = Schema([utils.schema_from_list(eval(self.textEditDFA.toPlainText()))], 1, len(eval(self.textEditDFA.toPlainText())))
tmp_data = Dataframe([eval(self.textEditDFA.toPlainText())], tmp_sch)
tmp_key = Key(str(self.textEditKey.toPlainText()), int(self.textEditHome.toPlainText()))
self.app.add_value(tmp_key, tmp_data)
elif(not(self.textEditDFS.toPlainText() == "")):
tmp_sch = Schema([utils.determine_type(self.textEditDFS.toPlainText())], 1, 1)
tmp_data = Dataframe([[eval(self.textEditDFS.toPlainText())]], tmp_sch)
tmp_key = Key(str(self.textEditKey.toPlainText()), int(self.textEditHome.toPlainText()))
self.app.add_value(tmp_key, tmp_data)
def define(self, v_name, v_value):
v_type = determine_type(v_value)
if not not_keyword_or_type(v_name):
raise KeywordName()
if v_name in self.names:
raise AlreadyExist(f"{v_name} already exists.")
if not valid_type(v_type):
raise VariableTypeError(f"{v_type} is not valid type.")
self.names[v_name] = Variable(v_type, v_value)
def serve(self):
name = self.name.serve()
if name not in functions:
print(f"Function {name} not defined!")
return None
else:
function = functions[name]
args_val = self.args.serve() if self.args is not None else None
if function["args"] is None:
if args_val is not None:
print(f"Arguments count missmatch in function {name}.")
return None
else:
scopes.add_scope()
res = function["block"].serve()
scopes.remove_scope()
return res
else:
if args_val is not None and function["args"] is None:
print(f"Too many arguments in function {name}.")
return None
if len(args_val) != len(function["args"]):
print(f"Arguments count missmatch in function {name}.")
return None
else:
scopes.add_scope()
valid_args = True
res = None
for i in range(len(args_val)):
arg_name = function["args"][i][0]
arg_type = function["args"][i][1]
arg_value = args_val[i]
given_arg_type = determine_type(arg_value)
arg_value = convert_to(arg_value, arg_type)
scopes.define(arg_name, arg_value)
if valid_args:
res = function["block"].serve()
scopes.remove_scope()
return res