docs: def proc_val(key, val):
          """
          Static helper method to convert Feff parameters to proper types, e.g.
          integers, floats, lists, etc.
  
          Args:
              key: Feff parameter key
              val: Actual value of Feff parameter.
          """
  
          list_type_keys = list(VALID_FEFF_TAGS)
          del list_type_keys[list_type_keys.index("ELNES")]
          del list_type_keys[list_type_keys.index("EXELFS")]
          boolean_type_keys = ()
          float_type_keys = ("S02", "EXAFS", "RPATH")
  
          def smart_int_or_float(numstr):
              if numstr.find(".") != -1 or numstr.lower().find("e") != -1:
                  return float(numstr)
              else:
                  return int(numstr)
  
          try:
              if key.lower() == 'cif':
                  m = re.search(r"\w+.cif", val)
                  return m.group(0)
  
              if key in list_type_keys:
                  output = list()
                  toks = re.split(r"\s+", val)
  
                  for tok in toks:
                      m = re.match(r"(\d+)\*([\d\.\-\+]+)", tok)
                      if m:
                          output.extend([smart_int_or_float(m.group(2))] *
                                        int(m.group(1)))
                      else:
                          output.append(smart_int_or_float(tok))
                  return output
              if key in boolean_type_keys:
                  m = re.search(r"^\W+([TtFf])", val)
                  if m:
                      if m.group(1) == "T" or m.group(1) == "t":
                          return True
                      else:
                          return False
                  raise ValueError(key + " should be a boolean type!")
  
              if key in float_type_keys:
                  return float(val)
  
          except ValueError:
              return val.capitalize()
  
          return val.capitalize()