code: def get(self, query_path=None, return_type=list, preceding_depth=None, throw_null_return_error=False):
          
          function_type_lookup = {str: self._get_path_entry_from_string,
                                  list: self._get_path_entry_from_list}
  
          if query_path is None:
              return self._default_config(return_type)
  
          try:
              config_entry = function_type_lookup.get(type(query_path), str)(query_path)
              query_result = self.config_entry_handler.format_query_result(config_entry,
                                                                           query_path,
                                                                           return_type=return_type,
                                                                           preceding_depth=preceding_depth)
  
              return query_result
          except IndexError:
              return return_type()
docs: Traverses the list of query paths to find the data requested
  
          :param query_path: (list(str), str), list of query path branches or query string
                                               Default behavior: returns list(str) of possible config headers
          :param return_type: (list, str, dict, OrderedDict), desired return type for the data
          :param preceding_depth: int, returns a dictionary containing the data that traces back up the path for x depth
                                       -1: for the full traversal back up the path
                                       None: is default for no traversal
          :param throw_null_return_error: bool, whether or not to throw an error if we get an empty result but no error
          :return: (list, str, dict, OrderedDict), the type specified from return_type
          :raises: exceptions.ResourceNotFoundError: if the query path is invalid