def search_method():
"""Match for applicable methods and their arguments."""
data = json.loads(request.get_data().decode("utf-8"))
if data:
cell = cells[data['id']]
thy = cell.thy
fact_ids = data['fact_ids']
goal_id = data['goal_id']
search_res = cell.search_method(goal_id, fact_ids)
for res in search_res:
if '_goal' in res:
res['_goal'] = [
printer.print_term(thy, t, unicode=True)
for t in res['_goal']
]
if '_fact' in res:
res['_fact'] = [
printer.print_term(thy, t, unicode=True)
for t in res['_fact']
]
ctxt = cell.get_ctxt(goal_id)
print_ctxt = dict((k, printer.print_type(thy, v, highlight=True))
for k, v in ctxt.items())
return jsonify({'search_res': search_res, 'ctxt': print_ctxt})
return jsonify({})
return jsonify({})
def testParseUnicodeType(self):
test_data = ["'a ⇒ 'b"]
for s in test_data:
T = parser.parse_type(thy, s)
self.assertIsInstance(T, HOLType)
self.assertEqual(print_type(thy, T, unicode=True), s)
def get_display(self):
Targs = [TVar(arg) for arg in self.args]
T = TConst(self.name, *Targs)
constrs = []
for constr in self.constrs:
argsT, _ = constr['type'].strip_type()
res = pprint.N(constr['name'])
for i, arg in enumerate(constr['args']):
res += pprint.N(' (' + arg + ' :: ') + printer.print_type(
argsT[i]) + pprint.N(')')
constrs.append(res)
return {
'ty': 'type.ind',
'type': printer.print_type(T),
'constrs': constrs if settings.highlight else '\n'.join(constrs)
}
def search_method():
"""Match for applicable methods and their arguments.
Input:
* username: username.
* theory_name: name of the theory.
* thm_name: name of the theorem.
Returns:
* search_res: list of search results.
* ctxt: current proof context.
"""
data = json.loads(request.get_data().decode("utf-8"))
if data['profile']:
pr = cProfile.Profile()
pr.enable()
if not proof_cache.check_cache(data):
start_time = time.perf_counter()
proof_cache.create_cache(data)
print("Load: %f" % (time.perf_counter() - start_time))
if data['thm_name'] != '':
limit = ('thm', data['thm_name'])
else:
limit = None
basic.load_theory(data['theory_name'],
limit=limit,
username=data['username'])
start_time = time.perf_counter()
state = proof_cache.states[data['index']]
fact_ids = data['step']['fact_ids']
goal_id = data['step']['goal_id']
search_res = state.search_method(goal_id, fact_ids)
with settings.global_setting(unicode=True):
for res in search_res:
if '_goal' in res:
res['_goal'] = [printer.print_term(t) for t in res['_goal']]
if '_fact' in res:
res['_fact'] = [printer.print_term(t) for t in res['_fact']]
vars = state.get_vars(goal_id)
with settings.global_setting(unicode=True, highlight=True):
print_vars = dict((k, printer.print_type(v)) for k, v in vars.items())
print("Response:", time.perf_counter() - start_time)
if data['profile']:
p = Stats(pr)
p.strip_dirs()
p.sort_stats('cumtime')
p.print_stats()
return jsonify({'search_res': search_res, 'ctxt': print_vars})
def testParseUnicodeType(self):
test_data = ["'a ⇒ 'b"]
basic.load_theory('list')
for s in test_data:
T = parser.parse_type(s)
self.assertIsInstance(T, Type)
with global_setting(unicode=True):
self.assertEqual(print_type(T), s)
def print_extension(thy, ext):
"""Print given extension."""
if isinstance(ext, AxType):
return "Type " + ext.name
elif isinstance(ext, AxConstant):
return "Constant " + ext.name + " :: " + printer.print_type(
thy, ext.T, unicode=True)
elif isinstance(ext, Theorem):
return "Theorem " + ext.name + ": " + printer.print_term(
thy, ext.th.prop, unicode=True)
def export_json(self):
with global_setting(unicode=True):
res = {
'ty': 'def.ax',
'name': self.name,
'type':
self.type if self.error else printer.print_type(self.type)
}
if self.overloaded:
res['overloaded'] = True
return res
def get_display(self):
return {
'ty':
'def.ax',
'name':
self.name,
'type':
display_raw(self.type)
if self.error else printer.print_type(self.type),
'overloaded':
self.overloaded
}
def export_json(self):
with global_setting(unicode=True):
res = {
'ty': 'def',
'name': self.name,
'type':
self.type if self.error else printer.print_type(self.type),
'prop': self.prop if self.error else export_term(self.prop)
}
if self.attributes:
res['attributes'] = self.attributes
return res
def export_json(self):
with global_setting(unicode=True):
res = {
'ty': 'thm.ax',
'name': self.name,
'vars': self.vars if self.error else \
dict((nm, printer.print_type(T)) for nm, T in self.vars.items()),
'prop': self.prop if self.error else export_term(self.prop)
}
if self.attributes:
res['attributes'] = self.attributes
return res
def json_data(self):
"""Export proof in json format."""
with global_setting(unicode=True):
vars = {v.name: printer.print_type(v.T) for v in self.vars}
with global_setting(unicode=True, highlight=True):
res = {
"vars": vars,
"proof": self.export_proof(),
"num_gaps": len(self.rpt.gaps),
"method_sig": method.get_method_sig(),
}
return res
def export_json(self):
with global_setting(unicode=True):
return {
'ty':
'def.ind',
'name':
self.name,
'type':
self.type if self.error else printer.print_type(self.type),
'rules': [{
'prop':
rule['prop'] if self.error else export_term(rule['prop'])
} for rule in self.rules]
}
def get_display(self):
if self.error:
disp_type = display_raw(self.type)
disp_prop = display_raw(self.prop)
else:
disp_type = printer.print_type(self.type)
disp_prop = display_term(self.prop)
return {
'ty': 'def',
'name': self.name,
'type': disp_type,
'prop': disp_prop,
'attributes': self.attributes
}
def export_json(self):
constrs = []
for constr in self.constrs:
constrs.append({
'name':
constr['name'],
'args':
constr['args'],
'type':
constr['type']
if self.error else printer.print_type(constr['type'])
})
return {
'ty': 'type.ind',
'name': self.name,
'args': self.args,
'constrs': constrs
}
def get_display(self):
if self.error:
disp_type = display_raw(self.type)
disp_rules = [rule['prop'] for rule in self.rules]
else:
disp_type = printer.print_type(self.type)
with global_setting(line_length=None):
disp_rules = [
printer.print_term(rule['prop']) for rule in self.rules
]
return {
'ty': 'def.ind',
'name': self.name,
'type': disp_type,
'rules':
disp_rules if settings.highlight else '\n'.join(disp_rules)
}
def get_display(self):
if self.error:
disp_vars = [
pprint.N(nm + ' :: ' + T) for nm, T in self.vars.items()
]
disp_prop = display_raw(self.prop)
else:
disp_vars = [
pprint.N(nm + ' :: ') + printer.print_type(T)
for nm, T in self.vars.items()
]
disp_prop = display_term(self.prop)
return {
'ty': 'thm.ax',
'name': self.name,
'vars': disp_vars if settings.highlight else '\n'.join(disp_vars),
'prop': disp_prop,
'attributes': self.attributes
}
def file_data_to_output(thy, data):
"""Convert items in the theory from json format for the file to
json format for the web client. Modifies data in-place.
Also modifies argument thy in parsing the item.
"""
parser.parse_extension(thy, data)
if data['ty'] == 'def.ax':
T = parser.parse_type(thy, data['type'])
data['type_hl'] = printer.print_type(thy,
T,
unicode=True,
highlight=True)
elif data['ty'] == 'thm' or data['ty'] == 'thm.ax':
temp_list = []
for k, v in data['vars'].items():
temp_list.append(k + ' :: ' + v)
ctxt = parser.parse_vars(thy, data['vars'])
prop = parser.parse_term(thy, ctxt, data['prop'])
data['prop_hl'] = printer.print_term(thy,
prop,
unicode=True,
highlight=True)
data['vars_lines'] = temp_list
elif data['ty'] == 'type.ind':
constrs = []
data_content = ''
for constr in data['constrs']:
T = parser.parse_type(thy, constr['type'])
constrs.append((constr['name'], T, constr['args']))
exts = induct.add_induct_type(data['name'], data['args'], constrs)
# Obtain items added by the extension
ext_output = []
for ext in exts.data:
s = print_extension(thy, ext)
if s:
ext_output.append(s)
data['ext'] = ext_output
# Obtain type to be defined
T = Type(data['name'], *(TVar(nm) for nm in data['args']))
data['type_hl'] = printer.print_type(thy,
T,
unicode=True,
highlight=True)
# Obtain types of arguments for each constructor
data['argsT'] = dict()
for i, constr in enumerate(data['constrs']):
str_temp_var = ''
T = parser.parse_type(thy, constr['type'])
argsT, _ = HOLType.strip_type(T)
argsT = [
printer.print_type(thy, argT, unicode=True, highlight=True)
for argT in argsT
]
data['argsT'][str(i)] = argsT
for j, a in enumerate(constr['args']):
str_temp_term = ''
for m, t in enumerate(data['argsT'][str(i)][j]):
str_temp_term += t[0]
str_temp_var += ' (' + a + ' :: ' + str_temp_term + ')'
data_content += '\n' + constr['name'] + str_temp_var
data['type_content'] = data_content
elif data['ty'] == 'def.ind' or data['ty'] == 'def.pred':
container = [[], [], [], '', '', '']
data_content_list, data_rule_names, data_vars_list, data_new_content, data_rule_name, data_vars_str = container
T = parser.parse_type(thy, data['type'])
data['type_hl'] = printer.print_type(thy,
T,
unicode=True,
highlight=True)
rules = []
for rule in data['rules']:
ctxt = parser.parse_vars(thy, rule['vars'])
prop = parser.parse_term(thy, ctxt, rule['prop'])
rule['prop_hl'] = printer.print_term(thy,
prop,
unicode=True,
highlight=True)
rules.append(prop)
exts = induct.add_induct_def(data['name'], T, rules)
# Obtain items added by the extension
ext_output = []
for ext in exts.data:
s = print_extension(thy, ext)
if s:
ext_output.append(s)
data['ext'] = ext_output
if data['ty'] == 'def.ind':
type_name = 'fun'
if data['ty'] == 'def.pred':
type_name = 'inductive'
data['ext_output'] = '\n'.join(ext_output)
data['type_name'] = type_name
for k, r in enumerate(data['rules']):
vars_str = ''
data_con = ''
for m, v in enumerate(r['vars']):
vars_str += str(m) + '::' + v + ' '
data_vars_list.append(vars_str)
for p in r['prop_hl']:
data_con += p[0]
data_content_list.append(data_con)
if 'name' in r:
data_rule_names.append(r['name'])
for n, dv in enumerate(data_vars_list):
data_vars_str += str(n) + ': ' + dv + '\n'
for j, dc in enumerate(data_content_list):
data_new_content += str(j) + ': ' + dc + '\n'
data_rule_name += str(j) + ': ' + dc + '\n'
data['data_new_content'] = data_new_content
data['data_rule_name'] = data_rule_name
data['data_vars_str'] = data_vars_str
elif data['ty'] == 'def':
i = 0
vars = ''
data_new_content = ''
data_content_list = []
data_content_list.append(data['prop'])
for j, dc in enumerate(data_content_list):
data_new_content += str(j) + ': ' + dc + '\n'
for j, v in enumerate(data['vars']):
vars += str(i) + ': ' + str(j) + '::' + v + '\n'
i += 1
data['item_vars'] = vars
T = parser.parse_type(thy, data['type'])
data['type_name'] = 'definition'
data['data_new_content'] = data_new_content
data['type_hl'] = printer.print_type(thy,
T,
unicode=True,
highlight=True)
ctxt = parser.parse_vars(thy, data['vars'])
prop = parser.parse_term(thy, ctxt, data['prop'])
data['prop_hl'] = printer.print_term(thy,
prop,
unicode=True,
highlight=True)
# Ignore other types of information.
else:
pass
def display_step(self, state, data):
T = parser.parse_type(data['type'])
return pprint.N("Variable " + data['name'] +
" :: ") + printer.print_type(T)
def get_display(self):
Targs = [TVar(arg) for arg in self.args]
T = TConst(self.name, *Targs)
return {'ty': 'type.ax', 'type': printer.print_type(T)}