docs: def _get_calculatable_methods_dict(inputs, methods):
      '''
      Given an iterable of input variable names and a methods dictionary,
      returns the subset of that methods dictionary that can be calculated and
      which doesn't calculate something we already have. Additionally it may
      only contain one method for any given output variable, which is the one
      with the fewest possible arguments.
      '''
      # Initialize a return dictionary
      calculatable_methods = {}
      # Iterate through each potential method output
      for var in methods.keys():
          # See if we already have this output
          if var in inputs:
              continue  # if we have it, we don't need to calculate it!
          else:
              # Initialize a dict for this output variable
              var_dict = {}
              for args, func in methods[var].items():
                  # See if we have what we need to solve this equation
                  if all([arg in inputs for arg in args]):
                      # If we do, add it to the var_dict
                      var_dict[args] = func
              if len(var_dict) == 0:
                  # No methods for this variable, keep going
                  continue
              elif len(var_dict) == 1:
                  # Exactly one method, perfect.
                  calculatable_methods[var] = var_dict
              else:
                  # More than one method, find the one with the least arguments
                  min_args = min(var_dict.keys(), key=lambda x: len(x))
                  calculatable_methods[var] = {min_args: var_dict[min_args]}
      return calculatable_methods