evalweb: Add a bunch of type annotations & fix some types

# taken from tutorial on flask.palletsprojects.com/en/1.1.x/tutorial

def create_app(test_config=None):

def create_app(test_config=None) -> Flask:

    # create and configure the app

    app = Flask(__name__, instance_relative_config=True)

    app.config.from_mapping(SECRET_KEY='dev')

from flask import Blueprint, render_template, request

from flask_wtf import FlaskForm

from wtforms import RadioField

from flask_wtf import FlaskForm  # type: ignore

from wtforms import RadioField   # type: ignore

from lib.parsing.parser import ParsingError

from evalweb.web_checker import WebChecker, Language

from evalweb.examples import examples, convert_examples

@bp.route('/compare', methods=('GET', 'POST'))

def compare():

def compare() -> str:

    student_form = TaskForm(prefix='student_form')

    teacher_form = TypeForm(prefix='teacher_form')

    student_area = ""  # areas remembers user input or replace it with examples

            missing_word_ce = checker.eq.right_counterexample

            inf = checker.eq.inf

        assert checker.teacher is not None

        assert checker.student is not None

        return render_template('result_compare.html', compare=True, ok=result,

                               inf=inf, task_solved=checker.task_solved,

                               alphabets=checker.alphabets,

# analogical to compare, only with just one input formalism

@bp.route('/convert', methods=('GET', 'POST'))

def convert():

def convert() -> str:

    student_form = TypeForm(prefix='student_form')

    task_form = ConvertForm(prefix='task_form')

    student_area = ""

@bp.route('/userref')

def userref():

def userref() -> str:

    return render_template('userref.html')

@bp.route('/about')

def about():

def about() -> str:

    return render_template('about.html')

teacher_efa = r"(A,a)={B} (A,\e)={D} (B,b)={A} final={A,D}"

student_nfa = parser.nfa_to_str(parser.str_to_nfa(teacher_efa)

                                      .eliminate_epsilon())

student_gra = r"S -> aS' | \e\nS' -> bA | b\nA -> aS'"

student_gra = "S -> aS' | \\e\nS' -> bA | b\nA -> aS'"

student_reg = "(ab)^*"

student_efa = r"(A,a)={B} (A,\e)={D} (B,b)={C} (C,a)={B} final={C,D}"

from lib.parsing.parser import Parser, ParsingError

from lib.checker import transform, dfa_transform, nfa_transform, check_task, \

                        check_alphabets

from typing import List, Tuple

from typing import List, Optional

from enum import Enum

import enum

    def __init__(self, string: str, task: str = "DFA") -> None:

        self.string = string

        self.task = task

        self.dfa = None

        self.minimal = None

        self.size = None

        self.sizename = None

        self.example = None

        self.gen_lang_html()

    def gen_lang_html(self) -> None:

        parser = Parser()

        dfa = dfa_transform(self.string, self.task)

        self.minimal = parser.dfa_to_str(dfa.minimize().canonize())

    def gen_is_task(self, task: str) -> str:

        teacher = "NFA" if self.task == "EFA" else self.task

        parser = Parser()

        assert self.dfa is not None

        dfa = parser.dfa_to_str(self.dfa.canonize())

        return f"{teacher}-{task}:{dfa}"

class WebChecker:

    def __init__(self, student_string: str, task: str):

    def __init__(self, student_string: str, task: str) -> None:

        self.student_string = student_string

        self.task = task

        self.task_solved = ""

        self.alphabets = ""

        self.eq = None

        self.teacher = None

        self.student = None

        self.is_task = None

        self.img_src = None

        self.languages = [None, None, None, None]

        self.eq: Optional[reg.IsEquivalentResult] = None

        self.teacher: Optional[Language] = None

        self.student: Optional[Language] = None

        self.is_task: Optional[str] = None

        self.img_src: Optional[str] = None

        self.languages: List[Optional[Language]] = [None, None, None, None]

    # nearly equivalent to dfa_task in fja_checker (for IS ROPOTs)

    def dfa_task(self, teacher_type, teacher_string, task, student_string):

    def dfa_task(self, teacher_type: str, teacher_string: str,

                 task: str, student_string: str) -> bool:

        try:

            teacher = Language(string=teacher_string, task=teacher_type)

            student = Language(string=student_string, task=self.task)

            return False

        self.eq = reg.DFA.is_equivalent(student.dfa, teacher.dfa)

        assert self.eq is not None

        self.img_src = self.relation(self.eq.left_counterexample is None

                                     and self.eq.right_counterexample is None)

            return True

        return False

    def compare(self, teacher_string: str, teacher_type: str):

    def compare(self, teacher_string: str, teacher_type: str) -> bool:

        # signal.alarm(50)  # from fja_checker: here would kill the web

        try:

            return self.dfa_task(teacher_type=teacher_type,

            return ex.args

            # raise ParsingError(ex.args)

    def convert(self, student_type):

    def convert(self, student_type: str) -> str:

        try:

            parser = Parser()

            if self.task in {"DFA", "TOT", "MIN"}:

            print("Error inside of web checker:", ex.args)

    def relation(self, eq: bool) -> str:

        assert self.teacher is not None

        assert self.student is not None

        student = self.student.dfa

        teacher = self.teacher.dfa

        assert student is not None

        assert teacher is not None

        # language 0 on picture: complement of both

        self.languages[0] = self.language(

                              (reg.DFA.union(teacher, student)).complement())

        if not eq:

            assert self.eq is not None

            if self.eq.left_counterexample is not None:  # extra word

                if self.eq.right_counterexample is not None:  # missing word

                    intersection = reg.DFA.intersection(student, teacher)