docs: def get_reverse_json_qry_item(dataset, param, no_key=False, initial_val=None):
      """ reads the paramater and returns the selected element
  
      args:
          dataset: the dataset to search
          param: the paramater to search by
          no_key: wheather to use the 'param' 'element' to filter the list.
                  This is passed True after the first run during recurssive call
                  when the key has already been used to select subset of the
                  dataset
      """
  
      def get_dataset_vals(ds, key, filter_tup=tuple(), initial_val=None):
          def reduce_list(value):
              if isinstance(value, list):
                  if len(value) == 1:
                      return value[0]
              return value
  
          def merge_list(value):
              if isinstance(value, list):
                  rtn_list = []
                  for item in value:
                      if isinstance(item, list):
                          rtn_list += item
                      else:
                          rtn_list.append(item)
                  return list(set(rtn_list))
              return value
  
          def test_elem(elem, filter_tup):
              search_lst = elem
              if isinstance(elem, dict):
                  search_lst = elem.get(filter_tup[0], [])
              if filter_tup[2] == '=':
                  try:
                      if elem.subject == filter_tup[1]:
                          return True
                  except AttributeError:
                      pass
                  test_lst = [item for item in search_lst \
                              if (isinstance(item, dict) \
                                  and item.subject == filter_tup[1]) \
                              or item == filter_tup[1]]
                  if test_lst:
                      return True
                  return False
  
          def filter_list(ds, key, filter_tup, initial_val=None):
              rtn_list = ds
              if key:
                  rtn_list = merge_list([reduce_list(reduce_list(elem)[key]) \
                                     for elem in ds if reduce_list(elem).get(key)])
              if filter_tup:
                  return [elem for elem in rtn_list \
                          if test_elem(elem, filter_tup)]
              return rtn_list
  
          def reverse_filter_list(ds, key, filter_tup, initial_val=None):
  
              def get_reverse_ds_dict(ds, key, filter_tup, initial_val=None):
                  if hasattr(ds, 'rmap') and initial_val:
                      # pdb.set_trace()
                      if key:
                          try:
                              return ds.rmap[initial_val][key]
                          except KeyError:
                              return []
                      else:
                          return ds.rmap[initial_val]
                  data_list = UniqueList()
                  if not key and not initial_val:
                      return data_list
                  for sub, ds_rdf_class in ds.items():
                      for pred, obj in ds_rdf_class.items():
                          if key and pred == key:
                              if initial_val:
                                  if initial_val in obj:
                                      data_list.append(ds_rdf_class)
                              else:
                                  data_list.append(ds_rdf_class)
                          if not key and initial_val:
                              if initial_val in obj:
                                  data_list.append(ds_rdf_class)
                  # pdb.set_trace()
                  return data_list
  
              if isinstance(ds, dict):
                  return get_reverse_ds_dict(ds, key, filter_tup, initial_val)
              elif isinstance(ds, list):
                  rtn_list = UniqueList()
                  for item in ds:
                      rtn_list += get_reverse_ds_dict(ds,
                                                      key,
                                                      filter_tup,
                                                      initial_val)
                  return rtn_list
  
  
          if isinstance(ds, list):
              return reverse_filter_list(ds, key, filter_tup, initial_val)
          elif isinstance(ds, dict):
              search_dict = ds
              if key:
                  search_dict = reverse_filter_list(ds,
                                                    key,
                                                    filter_tup,
                                                    initial_val)
              # pdb.set_trace()
              if filter_tup:
                  datalist = []
                  for elem in search_dict:
                      if filter_tup[2] == "=":
                          # pdb.set_trace()
                          if filter_tup[1] in elem.get(filter_tup[0], []):
                              if isinstance(elem, list):
                                  datalist += elem
                              else:
                                  datalist.append(elem)
                      elif filter_tup[2] == "!=":
                          if filter_tup[1] not in elem.get(filter_tup[0], []):
                              datalist.append(elem)
                  return datalist
              return merge_list(search_dict)
  
  
  
      if param == "*":
          pass
      # pdb.set_trace()
      if hasattr(param, 'parsed_tree'):
          param = param.parsed_tree
  
      if hasattr(param, 'selector'):
  
          if no_key:
              key = None
          else:
              key = get_element(param.selector)
          rtn_obj = None
          if hasattr(param, 'ident'):
              rtn_obj = get_dataset_vals(dataset,
                                         key,
                                         ('rdf_type',
                                          param.ident, "="))
          elif hasattr(param, 'attrib'):
              # if param.parsed_tree.attrib == 'bf_role':
              #     pdb.set_trace()
              rtn_obj = get_dataset_vals(dataset,
                                         key,
                                         (param.attrib,
                                          param.value,
                                          param.operator))
          if rtn_obj is not None:
              if hasattr(param, 'selector') \
                      and hasattr(param.selector, 'selector') \
                      and rtn_obj:
                  rtn_obj = get_json_qry_item(rtn_obj, param.selector, True)
              return rtn_obj
          return dataset.get(key, [])
      elif hasattr(param, 'element'):
          key = param.element
          return get_dataset_vals(dataset, key, initial_val=initial_val)