text: # -*- coding: utf-8 -*-
  
  """Compute the lintscore on the corpus."""
  
  from __future__ import print_function
  from builtins import input
  from builtins import int
  
  import os
  import subprocess
  import re
  
  proselint_path = os.path.dirname(os.path.realpath(__file__))
  
  
  def score(check=None):
      """Compute the linter's score on the corpus.
  
      Proselint's score reflects the desire to have a linter that catches many
      errors, but which takes false alarms seriously. It is better not to say
      something than to say the wrong thing, and the harm from saying the wrong
      thing is greater than the benefit of saying the right thing. Thus our score
      metric is defined as:
  
          TP * (TP / (FP + TP)) ^ k,
  
      where TP is the number of true positives (hits), FP is the number of
      false positives (false alarms), and k > 0 is a temperature parameter that
      determines the penalty for imprecision. In general, we should choose a
      large value of k, one that strongly discourages the creation of rules that
      can't be trusted. Suppose that k = 2. Then if the linter detects 100
      errors, of which 10 are false positives, the score is 81.
      """
      tp = 0
      fp = 0
  
      parent_directory = os.path.dirname(proselint_path)
      path_to_corpus = os.path.join(parent_directory, "corpora", "0.1.0")
      for root, _, files in os.walk(path_to_corpus):
          files = [f for f in files if f.endswith(".md")]
          for f in files:
              fullpath = os.path.join(root, f)
  
              # Run the linter.
              print("Linting {}".format(f))
              out = subprocess.check_output(["proselint", fullpath])
  
              # Determine the number of errors.
              regex = r".+?:(?P<line>\d+):(?P<col>\d+): (?P<message>.+)"
              num_errors = len(tuple(re.finditer(regex, out)))
              print("Found {} errors.".format(num_errors))
  
              # Open the document.
              subprocess.call(["open", fullpath])
  
              # Ask the scorer how many of the errors were false alarms?
              input_val = None
              while not isinstance(input_val, int):
                  try:
                      input_val = input("# of false alarms? ")
                      if input_val == "exit":
                          return
                      else:
                          input_val = int(input_val)
                          fp += input_val
                          tp += (num_errors - input_val)
                  except ValueError:
                      pass
  
              print("Currently {} hits and {} false alarms\n---".format(tp, fp))
  
      if (tp + fp) > 0:
          return tp * (1.0 * tp / (tp + fp)) ** 2
      else:
          return 0
  