code: def typevalue(self, key, value):
          
  
          def listconvert(value):
              # this function might be called with both string
              # represenations of entire lists and simple (unquoted)
              # strings. String representations come in two flavours,
              # the (legacy/deprecated) python literal (eg "['foo',
              # 'bar']") and the simple (eg "foo, bar") The
              # ast.literal_eval handles the first case, and if the
              # value can't be parsed as a python expression, the second
              # way is attempted. If both fail, it is returned verbatim
              # (not wrapped in a list, for reasons)
              try:
                  return ast.literal_eval(value)
              except (SyntaxError, ValueError):
                  if "," in value:
                      return [x.strip() for x in value.split(",")]
                  else:
                      return value
  
          # self.get(key) should never fail
          default = self.get(key)
          # if type(default) == type:
          if inspect.isclass(default):
              # print("Using class for %s" % key)
              t = default
          else:
              # print("Using instance for %s" % key)
              t = type(default)
  
          if t == bool:
              t = LayeredConfig.boolconvert
          elif t == list:
              t = listconvert
          elif t == date:
              t = LayeredConfig.dateconvert
          elif t == datetime:
              t = LayeredConfig.datetimeconvert
          # print("Converting %r to %r" % (value,t(value)))
          return t(value)
docs: Given a parameter identified by ``key`` and an untyped string,
          convert that string to the type that our version of key has.