def dfa_dot_importer(input_file: str) -> dict:
    """ Imports a DFA from a DOT file.

    Of DOT files are recognized the following attributes:

      • nodeX   shape=doublecircle -> accepting node;
      • nodeX   root=true -> initial node;
      • edgeX   label="a" -> action in alphabet;
      • fake    [style=invisible] -> dummy invisible node pointing
                to initial state (they will be skipped);
      • fake-> S [style=bold] -> dummy transition to draw the arrow
                pointing to initial state (it will be skipped).

    Forbidden names:

      • 'fake'  used for graphical purpose to drawn the arrow of
        the initial state;
      • 'sink'  used as additional state when completing a DFA;
      • 'None'  used when no initial state is present.

    Forbidden characters:
      • "
      • '
      • (
      • )
      • spaces

    :param str input_file: path to the DOT file;
    :return: *(dict)* representing a DFA.
    """

    # pyDot Object
    g = pydot.graph_from_dot_file(input_file)[0]

    states = set()
    initial_state = None
    accepting_states = set()

    replacements = {'"': '', "'": '', '(': '', ')': '', ' ': ''}
    for node in g.get_nodes():
        if node.get_name() == 'fake' \
                or node.get_name() == 'None' \
                or node.get_name() == 'graph' \
                or node.get_name() == 'node':
            continue
        if 'style' in node.get_attributes() \
                and node.get_attributes()['style'] == 'invisible':
            continue
        node_reference = __replace_all(replacements,
                                       node.get_name()).split(',')
        if len(node_reference) > 1:
            node_reference = tuple(node_reference)
        else:
            node_reference = node_reference[0]
        states.add(node_reference)
        for attribute in node.get_attributes():
            if attribute == 'root':
                initial_state = node_reference
            if attribute == 'shape' and node.get_attributes()[
                'shape'] == 'doublecircle':
                accepting_states.add(node_reference)

    alphabet = set()
    transitions = {}
    for edge in g.get_edges():
        if edge.get_source() == 'fake':
            continue
        label = __replace_all(replacements, edge.get_label())
        alphabet.add(label)
        source = __replace_all(replacements,
                               edge.get_source()).split(',')
        if len(source) > 1:
            source = tuple(source)
        else:
            source = source[0]
        destination = __replace_all(replacements,
                                    edge.get_destination()).split(',')
        if len(destination) > 1:
            destination = tuple(destination)
        else:
            destination = destination[0]
        transitions[source, label] = destination

    dfa = {
        'alphabet': alphabet,
        'states': states,
        'initial_state': initial_state,
        'accepting_states': accepting_states,
        'transitions': transitions}
    return dfa