class_docstr: This class extract relations, objects or triplets from Wikidata HDT file.
class_docstr_tok: ["This","class","extract","relations",",","objects","or","triplets","from","Wikidata","HDT","file","."]
code: def execute_queries_list(
      self, parser_info_list: List[str], queries_list: List[Any]
  ):
      wiki_parser_output = []
      query_answer_types = []
      for parser_info, query in zip(parser_info_list, queries_list):
          if parser_info == "query_execute":
              answers, found_rels, found_combs = [], [], []
              try:
                  (
                      what_return,
                      rels_from_query,
                      query_seq,
                      filter_info,
                      order_info,
                      answer_types,
                      rel_types,
                      return_if_found,
                  ) = query
                  if answer_types:
                      query_answer_types = answer_types
                  answers, found_rels, found_combs = self.execute(
                      what_return,
                      rels_from_query,
                      query_seq,
                      filter_info,
                      order_info,
                      query_answer_types,
                      rel_types,
                  )
              except ValueError:
                  log.warning(
                      "Wrong arguments are passed to wiki_parser"
                  )
              wiki_parser_output.append(
                  [answers, found_rels, found_combs]
              )
          elif parser_info == "find_rels":
              rels = []
              try:
                  rels = self.find_rels(*query)
              except:
                  log.warning(
                      "Wrong arguments are passed to wiki_parser"
                  )
              wiki_parser_output.append(rels)
          elif parser_info == "find_rels_2hop":
              rels = []
              try:
                  rels = self.find_rels_2hop(*query)
              except ValueError:
                  log.warning(
                      "Wrong arguments are passed to wiki_parser"
                  )
              wiki_parser_output += rels
          elif parser_info == "find_object":
              objects = []
              try:
                  objects = self.find_object(*query)
              except:
                  log.warning(
                      "Wrong arguments are passed to wiki_parser"
                  )
              wiki_parser_output.append(objects)
          elif parser_info == "check_triplet":
              check_res = False
              try:
                  check_res = self.check_triplet(*query)
              except:
                  log.warning(
                      "Wrong arguments are passed to wiki_parser"
                  )
              wiki_parser_output.append(check_res)
          elif parser_info == "find_label":
              label = ""
              try:
                  label = self.find_label(*query)
              except:
                  log.warning(
                      "Wrong arguments are passed to wiki_parser"
                  )
              wiki_parser_output.append(label)
          elif parser_info == "find_types":
              types = []
              try:
                  types = self.find_types(query)
              except:
                  log.warning(
                      "Wrong arguments are passed to wiki_parser"
                  )
              wiki_parser_output.append(types)
          elif parser_info == "fill_triplets":
              filled_triplets = []
              try:
                  filled_triplets = self.fill_triplets(*query)
              except ValueError:
                  log.warning(
                      "Wrong arguments are passed to wiki_parser"
                  )
              wiki_parser_output.append(filled_triplets)
          elif parser_info == "find_triplets":
              if self.file_format == "hdt":
                  triplets = []
                  try:
                      triplets_forw, c = self.document.search_triples(
                          f"{self.prefixes['entity']}/{query}", "", ""
                      )
                      triplets.extend(
                          [
                              triplet
                              for triplet in triplets_forw
                              if not triplet[2].startswith(
                                  self.prefixes["statement"]
                              )
                          ]
                      )
                      triplets_backw, c = self.document.search_triples(
                          "", "", f"{self.prefixes['entity']}/{query}"
                      )
                      triplets.extend(
                          [
                              triplet
                              for triplet in triplets_backw
                              if not triplet[0].startswith(
                                  self.prefixes["statement"]
                              )
                          ]
                      )
                  except:
                      log.warning(
                          "Wrong arguments are passed to wiki_parser"
                      )
                  wiki_parser_output.append(list(triplets))
              else:
                  triplets = {}
                  try:
                      triplets = self.document.get(query, {})
                  except:
                      log.warning(
                          "Wrong arguments are passed to wiki_parser"
                      )
                  uncompressed_triplets = {}
                  if triplets:
                      if "forw" in triplets:
                          uncompressed_triplets[
                              "forw"
                          ] = self.uncompress(triplets["forw"])
                      if "backw" in triplets:
                          uncompressed_triplets[
                              "backw"
                          ] = self.uncompress(triplets["backw"])
                  wiki_parser_output.append(uncompressed_triplets)
          elif parser_info == "find_triplets_for_rel":
              found_triplets = []
              try:
                  found_triplets, c = self.document.search_triples(
                      "",
                      f"{self.prefixes['rels']['direct']}/{query}",
                      "",
                  )
              except:
                  log.warning(
                      "Wrong arguments are passed to wiki_parser"
                  )
              wiki_parser_output.append(list(found_triplets))
          elif (
              parser_info == "parse_triplets"
              and self.file_format == "pickle"
          ):
              for entity in query:
                  self.parse_triplets(entity)
              wiki_parser_output.append("ok")
          else:
              raise ValueError("Unsupported query type")
  
      return wiki_parser_output
  
imports: import datetime
  import re
  from collections import namedtuple
  from logging import getLogger
  from typing import List, Tuple, Dict, Any, Union
  from hdt import HDTDocument
  from deeppavlov.core.commands.utils import expand_path
  from deeppavlov.core.common.file import load_pickle, read_json
  from deeppavlov.core.common.registry import register
label_desc: Use image node_id 3 for calling the WikiParser obj's underlying member method code with example usage: obj.execute_queries_list(parser_info_list, queries_list) and returns: wiki_parser_output