def METHOD_NAME(
    self, query: str, generic_cover: str = "", locale: str = "en"
) -> Optional[List[MetaRecord]]:
    #timer=time()
    def inner(link, index) -> [dict, int]:
        with self.session as session:
            try:
                r = session.get(f"https://www.amazon.com/{link}")
                r.raise_for_status()
            except Exception as ex:
                log.warning(ex)
                return None
            long_soup = BS(r.text, "lxml")  #~4sec :/
            soup2 = long_soup.find("div", attrs={"cel_widget_id": "dpx-books-ppd_csm_instrumentation_wrapper"})
            if soup2 is None:
                return None
            try:
                match = MetaRecord(
                    title = "",
                    authors = "",
                    source=MetaSourceInfo(
                        id=self.__id__,
                        description="Amazon Books",
                        link="https://amazon.com/"
                    ),
                    url = f"https://www.amazon.com{link}",
                    #the more searches the slower, these are too hard to find in reasonable time or might not even exist
                    publisher= "",  # very unreliable
                    publishedDate= "",  # very unreliable
                    id = None,  # ?
                    tags = []  # dont exist on amazon
                )
                try:
                    match.description = "\n".join(
                        soup2.find("div", attrs={"data-feature-name": "bookDescription"}).stripped_strings)\
                                            .replace("\xa0"," ")[:-9].strip().strip("\n")
                except (AttributeError, TypeError):
                    return None  # if there is no description it is not a book and therefore should be ignored
                try:
                    match.title = soup2.find("span", attrs={"id": "productTitle"}).text
                except (AttributeError, TypeError):
                    match.title = ""
                try:
                    match.authors = [next(
                        filter(lambda i: i != " " and i != "\n" and not i.startswith("{"),
                               x.findAll(string=True))).strip()
                                    for x in soup2.findAll("span", attrs={"class": "author"})]
                except (AttributeError, TypeError, StopIteration):
                    match.authors = ""
                try:
                    match.rating = int(
                        soup2.find("span", class_="a-icon-alt").text.split(" ")[0].split(".")[
                            0])  # first number in string
                except (AttributeError, ValueError):
                    match.rating = 0
                try:
                    match.cover = soup2.find("img", attrs={"class": "a-dynamic-image frontImage"})["src"]
                except (AttributeError, TypeError):
                    match.cover = ""
                return match, index
            except Exception as e:
                log.error_or_exception(e)
                return None
    val = list()
    if self.active:
        try:
            results = self.session.get(
                f"https://www.amazon.com/s?k={query.replace(' ', '+')}&i=digital-text&sprefix={query.replace(' ', '+')}"
                f"%2Cdigital-text&ref=nb_sb_noss",
                headers=self.headers)
            results.raise_for_status()
        except requests.exceptions.HTTPError as e:
            log.error_or_exception(e)
            return []
        except Exception as e:
            log.warning(e)
            return []
        soup = BS(results.text, 'html.parser')
        links_list = [next(filter(lambda i: "digital-text" in i["href"], x.findAll("a")))["href"] for x in
                      soup.findAll("div", attrs={"data-component-type": "s-search-result"})]
        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
            fut = {executor.submit(inner, link, index) for index, link in enumerate(links_list[:5])}
            val = list(map(lambda x : x.result() ,concurrent.futures.as_completed(fut)))
    result = list(filter(lambda x: x, val))
    return [x[0] for x in sorted(result, key=itemgetter(1))] #sort by amazons listing order for best relevance