docs: 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