text: def parse(f, comment="#"):
      """
      Parse a file in ``.fasta`` format.
  
      :param f: Input file object
      :type f: _io.TextIOWrapper
      :param comment: Character used for comments
      :type comment: str
  
      :return: names, sequence
      :rtype: list[str], list[str]
      """
      starter = ">"
      empty = ""
      if "b" in f.mode:
          comment = b"#"
          starter = b">"
          empty = b""
      names = []
      sequences = []
      name = None
      sequence = []
      for line in f:
          if line.startswith(comment):
              continue
          line = line.strip()
          if line.startswith(starter):
              if name is not None:
                  names.append(name)
                  sequences.append(empty.join(sequence))
              name = line[1:]
              sequence = []
          else:
              sequence.append(line.upper())
      if name is not None:
          names.append(name)
          sequences.append(empty.join(sequence))
  
      return names, sequences
  
  
  def parse_directory(directory, extension=".seq"):
      """
      Parse all files in a directory ending with ``extension``.
  
      :param directory: Input directory
      :type directory: str
      :param extension: Extension of all files to read in
      :type extension: str
  
      :return: names, sequence
      :rtype: list[str], list[str]
      """
      names = []
      sequences = []
  
      for seqPath in os.listdir(directory):
          if seqPath.endswith(extension):
              n, s = parse(open(f"{directory}/{seqPath}", "rb"))
              names.append(n[0].decode("utf-8").strip())
              sequences.append(s[0].decode("utf-8").strip())
      return names, sequences
  
  
  def write(nam, seq, f):
      """
      Write a file in ``.fasta`` format.
  
      :param nam: List of names
      :type nam: list[str]
      :param seq: List of sequences
      :type seq: list[str]
      :param f: Output file object
      :type f: _io.TextIOWrapper
      """
      for n, s in zip(nam, seq):
          f.write(">{}\n".format(n))
          f.write("{}\n".format(s))
  