docs: def _update_triplestore(self, es_result, action_list, **kwargs):
          """
          updates the triplestore with success of saves and failues of indexing
  
          Args:
          -----
              es_result: the elasticsearch result list
              action_list: list of elasticsearch action items that were indexed
          """
          idx_time = XsdDatetime(datetime.datetime.utcnow())
          uri_keys = {}
          bnode_keys = {}
          for item in action_list:
              try:
                  uri_keys[item['_id']] = item['_source']["uri"]
              except KeyError:
                  bnode_keys[item['_id']] = item['_id']
          error_dict = {}
          error_bnodes = {}
          if es_result[1]:
              for result in es_result[1]:
                  err_item = list(result.values())[0]
                  try:
                      error_dict[uri_keys.pop(err_item['_id'])] = \
                              XsdString(err_item['error']['reason'])
                  except KeyError:
                      error_bnodes[bnode_keys.pop(err_item['_id'])] = \
                              XsdString(err_item['error']['reason'])
          if uri_keys:
              sparql_good = """
                  DELETE
                  {{
                      ?s kds:esIndexTime ?esTime .
                      ?s kds:esIndexError ?esError .
                  }}
                  INSERT
                  {{
                      GRAPH ?g {{ ?s kds:esIndexTime {idx_time} }}.
                  }}
                  WHERE
                  {{
                      VALUES ?s {{ {subj_list} }} .
                      {{
                          SELECT DISTINCT ?g ?s ?esTime ?esError
                          {{
                              GRAPH ?g {{ ?s ?p ?o }} .
                              OPTIONAL {{
                                  ?s kds:esIndexTime ?esTime
                              }}
                              OPTIONAL {{
                                  ?s kds:esIndexError ?esError
                              }}
                          }}
                      }}
                  }}
                  """.format(idx_time=idx_time.sparql,
                             subj_list="<%s>" % ">\n<".join(uri_keys.values()))
              self.tstore_conn.update_query(sparql_good)
          # Process any errors that were found.
          if not error_dict:
              return
          # Delete all indexing triples related to the error subjects
          sparql_error = """
              DELETE
              {{
                  ?s kds:esIndexTime ?esTime .
                  ?s kds:esIndexError ?esError .
              }}
              WHERE
              {{
                  VALUES ?s {{ {subj_list} }} .
                  OPTIONAL {{
                      ?s kds:esIndexTime ?esTime
                  }}
                  OPTIONAL {{
                      ?s kds:esIndexError ?esError
                  }}
              }}
              """.format(subj_list="<%s>" % ">\n<".join(error_dict.keys()))
          self.tstore_conn.update_query(sparql_error)
          del sparql_error
          sparql_update = """
              INSERT
              {{
                  GRAPH ?g {{
                      ?s kds:esIndexTime {idx_time} .
                      ?s kds:esIndexError ?esError .
                  }}
              }}
              WHERE
              {{
                  VALUES (?s ?esError) {{ {error_list} }} .
                  {{
                      SELECT DISTINCT ?g ?s
                      {{
                          graph ?g {{?s ?p ?o}}
                      }}
                  }}
              }}""".format(
                      idx_time=idx_time.sparql,
                      error_list="\n".join(["(<%s> %s)" % (key, val.sparql)
                                            for key, val in error_dict.items()]))
  
          # Create a turtle data stream of the new errors to upload into the
          # triplestore
          self.tstore_conn.update_query(sparql_update)
          del sparql_update