typing tweaks (cb1746ce) · Commits · fja / eval

evalweb/evalweb.py

+2 −2

Original line number	Original line	Diff line number	Diff line
	@@ -58,7 +58,7 @@ def compare():
	student_string=student_string, student_type=tasks[student_type],		student_string=student_string, student_type=tasks[student_type],
	teacher_string=teacher_string, teacher_type=types[teacher_type],		teacher_string=teacher_string, teacher_type=types[teacher_type],
	extra_word_ce=extra_word_ce, missing_word_ce=missing_word_ce)		extra_word_ce=extra_word_ce, missing_word_ce=missing_word_ce)
	flash(error)		#flash(error)

	student_example = ""		student_example = ""
	teacher_example = ""		teacher_example = ""
	@@ -88,7 +88,7 @@ def convert():

	return render_template('result.html', compare=False, student_string=student_string,		return render_template('result.html', compare=False, student_string=student_string,
	student_type=types[student_type], task=tasks[task], output=output)		student_type=types[student_type], task=tasks[task], output=output)
	flash(error)		#flash(error)

	example = ""		example = ""
	# if request.method == 'POST' and 'example_button' in request.form:		# if request.method == 'POST' and 'example_button' in request.form:

evalweb/web_checker.py

+13 −10

Original line number	Original line	Diff line number	Diff line
	@@ -20,7 +20,10 @@ class WebChecker():
	except ParsingError as ex:		except ParsingError as ex:
	return("Chyba při parsování.")		return("Chyba při parsování.")

			task_solved = ""
			if isinstance(student_solution, reg.DFA) or isinstance(student_solution, reg.NFA):
	task_solved = check_task(student_solution, task)		task_solved = check_task(student_solution, task)

	check_empty(student_solution=student_dfa,		check_empty(student_solution=student_dfa,
	teacher_solution=teacher_dfa)		teacher_solution=teacher_dfa)

	@@ -51,27 +54,27 @@ class WebChecker():
	parser = Parser()		parser = Parser()

	if self.task in {"DFA", "TOT", "MIN"}:		if self.task in {"DFA", "TOT", "MIN"}:
	automaton = dfa_transform(self.student_string, student_type)		dfa = dfa_transform(self.student_string, student_type)

	if self.task == "DFA":		if self.task == "DFA":
	return parser.dfa_to_str(automaton)		return parser.dfa_to_str(dfa)
	if self.task == "TOT":		if self.task == "TOT":
	return parser.dfa_to_str(automaton.total())		return parser.dfa_to_str(dfa.total())
	if self.task == "MIN":		if self.task == "MIN":
	return parser.dfa_to_str(automaton.minimize())		return parser.dfa_to_str(dfa.minimize())
	#if canonize: TODO checkbox		#if canonize: TODO checkbox
	# return parser.dfa_to_str(automaton.canonize())		# return parser.dfa_to_str(automaton.canonize())

	automaton = nfa_transform(self.student_string, student_type)		nfa = nfa_transform(self.student_string, student_type)
	if self.task == "EFA":		if self.task == "EFA":
	return parser.nfa_to_str(automaton)		return parser.nfa_to_str(nfa)

	automaton = automaton.eliminate_epsilon()		nfa = nfa.eliminate_epsilon()
	if self.task == "NFA":		if self.task == "NFA":
	return parser.nfa_to_str(automaton)		return parser.nfa_to_str(nfa)

	if self.task == "GRA":		if self.task == "GRA":
	return parser.reggrammar_to_str(automaton.nfa_to_reggrammar().eliminate_useless())		return parser.reggrammar_to_str(nfa.nfa_to_reggrammar().eliminate_useless())

	if self.task == "REG":		if self.task == "REG":
	return self.student_string if student_type == "REG" else \		return self.student_string if student_type == "REG" else \

lib/checker.py

+5 −5

Original line number	Original line	Diff line number	Diff line
	@@ -44,7 +44,7 @@ def nfa_transform(string: str, automaton_type: str) -> reg.NFA:
	except ParsingError as ex:		except ParsingError as ex:
	raise ParsingError(ex.args)		raise ParsingError(ex.args)

	def transform(string: str, automaton_type: str):		def transform(string: str, automaton_type: str) -> Union[reg.DFA, reg.NFA, reg.RegGrammar, reg.RegEx]:
	try:		try:
	parser = Parser()		parser = Parser()

	@@ -63,14 +63,14 @@ def transform(string: str, automaton_type: str):
	raise ParsingError(ex.args)		raise ParsingError(ex.args)




	def check_task(automaton: Union[reg.DFA, reg.NFA], task: str) -> str:		def check_task(automaton: Union[reg.DFA, reg.NFA], task: str) -> str:
	parser = Parser()		parser = Parser()
	output = ""		output = ""

	if task == "NFA" and isinstance(automaton, reg.NFA) and automaton.has_epsilon():		if isinstance(automaton, reg.NFA):
	return "NFA obsahuje ε-kroky."		if task == "NFA" and automaton.has_epsilon():
			output = "NFA obsahuje ε-kroky."
			return output

	if task not in {"TOT", "MIN", "TOC", "MIC"}:		if task not in {"TOT", "MIN", "TOC", "MIC"}:
	return output		return output

lib/dfa.py

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -349,7 +349,7 @@ class DFA:
	if (state, character) in self.transition and \		if (state, character) in self.transition and \
	self.transition[state, character] == dest_state:		self.transition[state, character] == dest_state:
	return character		return character
	# else should not happen really		return Character("")

	@staticmethod		@staticmethod
	def one_of(collection: Set[type_var]) -> type_var:		def one_of(collection: Set[type_var]) -> type_var:
	@@ -397,8 +397,8 @@ class DFA:
	return IsEmptyResult()		return IsEmptyResult()

	terminable = self.terminating_states(completed, pred)		terminable = self.terminating_states(completed, pred)
	for state in succ:		for sstate in succ:
	succ[state] = succ[state].intersection(terminable)		succ[sstate] = succ[sstate].intersection(terminable)

	if self.init in self.final:		if self.init in self.final:
	return IsEmptyResult('ε', len(on_cycle.intersection(terminable)) > 0)		return IsEmptyResult('ε', len(on_cycle.intersection(terminable)) > 0)

lib/grammars.py

+12 −14

Original line number	Original line	Diff line number	Diff line
	@@ -25,18 +25,17 @@ class RegGrammar:

	@staticmethod		@staticmethod
	def from_cfg(cfg: CFG) -> RegGrammar:		def from_cfg(cfg: CFG) -> RegGrammar:
	if cfg.is_regular():		assert cfg.is_regular()
	reg_rules : RegGrammar.Rules = {}		reg_rules : RegGrammar.Rules = {}
	for nonterminal in cfg.rules:		for nonterminal in cfg.rules:
	for rule in cfg.rules[nonterminal]:		for rule in cfg.rules[nonterminal]:
	new_rule = rule		new_rule: Union[Terminal, Tuple[Terminal, Nonterminal]] = rule
	# rule of type Tuple[Terminal] becomes of type Terminal, others are OK		# rule of type Tuple[Terminal] becomes of type Terminal, others are OK
	if isinstance(rule, tuple) and len(rule) == 1:		if isinstance(rule, tuple) and isinstance(rule[0], Terminal) and len(rule) == 1:
	new_rule = rule[0]		new_rule = rule[0]
	reg_rules.setdefault(nonterminal, set()).add(new_rule)		reg_rules.setdefault(nonterminal, set()).add(new_rule)

	return RegGrammar(cfg.nonterminals, cfg.terminals, reg_rules, cfg.init)		return RegGrammar(cfg.nonterminals, cfg.terminals, reg_rules, cfg.init)

	# exception		# exception


	@@ -71,7 +70,7 @@ class RegGrammar:
	for terminal in self.terminals:		for terminal in self.terminals:
	characters.add(Character(terminal.name))		characters.add(Character(terminal.name))

	transition: Dict[Tuple[State, Character], Set[State]] = dict()		transition: NFA.Transition = dict()
	for nonterminal in self.rules:		for nonterminal in self.rules:
	state = State(nonterminal.name)		state = State(nonterminal.name)
	for rule in self.rules[nonterminal]:		for rule in self.rules[nonterminal]:
	@@ -109,7 +108,6 @@ class RegGrammar:
	if isinstance(rule, Terminal) or isinstance(rule, Eps):		if isinstance(rule, Terminal) or isinstance(rule, Eps):
	actual.add(nonterminal)		actual.add(nonterminal)
	elif rule[1] in previous:		elif rule[1] in previous:
	print("tuple", nonterminal.name, rule[1].name)
	actual.add(nonterminal)		actual.add(nonterminal)

	actual.remove(helper)		actual.remove(helper)