docs: def get_json_qry_item(dataset, param, no_key=False):
      """ 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()):
          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)
                  try:
                      return list(set(rtn_list))
                  except TypeError:
                      return 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):
              rtn_list = ds
              if key:
                  rtn_list = merge_list([reduce_list(reduce_list(elem)[key]) \
                                     for elem in ds
                                     if isinstance(reduce_list(elem), dict)
                                     and reduce_list(elem).get(key)])
              if filter_tup:
                  return [elem for elem in rtn_list \
                          if test_elem(elem, filter_tup)]
              return rtn_list
  
          if isinstance(ds, list):
              return filter_list(ds, key, filter_tup)
          elif isinstance(ds, dict):
              search_dict = ds
              if key:
                  search_dict = ds.get(key,[])
              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 [elem for elem in ds[key] \
                  #         if filter_tup[1] in elem.get(filter_tup[0], []) \
                  #         and elem]
              return merge_list(search_dict)
      if param == "*":
          return dataset
      try:
          if param.startswith("="):
              # if the dataset length is '0' consider it a false match
              if dataset:
                  return [pyrdf(param[1:])]
              return []
      except AttributeError:
          pass
      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'):
              if key:
                  rtn_obj = get_dataset_vals(dataset,
                                             key,
                                             ('rdf_type',
                                              param.ident, "="))
              elif param.ident in dataset.get('rdf_type', []):
                  rtn_obj = dataset
              else:
                  rtn_obj = [value for value in dataset.values()
                             if param.ident in value.get('rdf_type', [])]
              # pdb.set_trace()
          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
          if key:
              return dataset[key]
          else:
              return dataset
      elif hasattr(param, 'element'):
          key = param.element
          return get_dataset_vals(dataset, key)