+ [ 2 files changed ] - Added support for currency converter to gsearch

Author: null2264

exts/api/google.py

@@ -5,11 +5,13 @@
 
 import aiohttp
 import bs4
+import re
 
 
+from contextlib import suppress
+from core.decorators import in_executor  # type: ignore
 from typing import Any, Optional, List
 from urllib.parse import quote_plus
-from core.decorators import in_executor  # type: ignore
 
 
 class SearchResult:
@@ -22,7 +24,16 @@ def __repr__(self) -> str:
         return f"<{self.__class__.__name__} link={self.link} title={self.title} contents={self.contents}>"
 
     def __eq__(self, other: Any) -> bool:
-        return isinstance(other, SearchResult) and (self.title == other.title and self.contents == other.contents)
+        return isinstance(other, SearchResult) and (
+            self.title == other.title and self.contents == other.contents
+        )
+
+
+class SpecialResult:
+    def __init__(self, type: str, content: Any) -> None:
+        self.type: str = type
+        self.content: Any = content
+        pass
 
 
 class ComplementaryResult:
@@ -61,37 +72,59 @@ def parseResults(self, page: str) -> Optional[dict]:
         # normal results
         results = soup.find("div", {"id": "search"}).find_all("div", {"class": "g"})  # type: ignore
         webRes: Optional[List[SearchResult]] = None
+        specialRes: Optional[SpecialResult] = None
+        # parse both webRes and specialRes (if there is)
         if results:
             webRes = []
             for result in results:
                 try:
                     link = result.find("a", href=True)["href"]  # type: ignore
                 except (KeyError, TypeError):
                     continue
-                title = result.find("h3").text  # type: ignore
-                summary = result.find("div").select("div > span")  # type: ignore
-                if summary and title and link:
-                    res = SearchResult(link, title, [s.text for s in summary[1:]])
-                    if res not in webRes:
-                        webRes.append(res)
+                try:
+                    title = result.find("h3").text  # type: ignore
+                except AttributeError:
+                    # Special result such as Currency converter, Maps, etc
+                    type = result.find("h2").text  # type: ignore
+
+                    if type == "Currency converter":
+                        contents = result.find(  # type: ignore
+                            "div", id=re.compile("knowledge-currency")
+                        ).contents
+                        formattedContent = []
+
+                        # Currency stuff
+                        convertion = contents[0].find_all("div")
+                        target = f"`{convertion[0].text}`"
+                        dest = convertion[1].find_all("span")
+                        dest = f"**`{dest[0].text}` {dest[1].text}**"
+                        formattedContent.extend([target, dest])
+
+                        # Last updated
+                        formattedContent.append(contents[1].text)
+                        specialRes = SpecialResult(type, formattedContent)
+
+                        continue
+                else:
+                    summary = result.find("div").select("div > span")  # type: ignore
+                    if summary and title and link:
+                        res = SearchResult(link, title, [s.text for s in summary[1:]])
+                        if res not in webRes:
+                            webRes.append(res)
 
         # Complementary results
         complementaryRes = soup.find("div", {"id": "rhs", "data-hveid": True})
         if complementaryRes:
-            try:
-                title = complementaryRes.find("h2", {"data-attrid": "title"}).span.text  # type: ignore
-            except AttributeError:
-                title = None
+            title: Optional[str] = None
+            subtitle: Optional[str] = None
+            desc: Optional[str] = None
 
-            try:
+            with suppress(AttributeError):
+                title = complementaryRes.find("h2", {"data-attrid": "title"}).span.text  # type: ignore
                 subtitle = complementaryRes.find("div", {"data-attrid": "subtitle"}).span.text  # type: ignore
-            except AttributeError:
-                subtitle = None
 
-            try:
+            with suppress(AttributeError):
                 desc = complementaryRes.find("div", {"class": "kno-rdesc"}).span.text  # type: ignore
-            except AttributeError:
-                desc = None
 
             infoList = complementaryRes.find_all("div", {"data-attrid": True, "lang": True})  # type: ignore
             formattedInfo = []
@@ -110,12 +143,20 @@ def parseResults(self, page: str) -> Optional[dict]:
                 if infoTitle and infoContent:
                     formattedInfo.append((infoTitle, infoContent))
 
+            # A complementary result always have title and subtitle
             if subtitle and title:
-                complementaryRes = ComplementaryResult(title, subtitle, desc, formattedInfo)
+                complementaryRes = ComplementaryResult(
+                    title, subtitle, desc, formattedInfo
+                )
             else:
                 complementaryRes = None
 
-        return {"stats": searchStats, "web": webRes, "complementary": complementaryRes}
+        return {
+            "stats": searchStats,
+            "web": webRes,
+            "complementary": complementaryRes,
+            "special": specialRes,
+        }
 
     async def search(
         self,

exts/utilities.py

@@ -182,13 +182,14 @@ async def google(self, ctx, *, query: str):
         e.set_footer(text=results["stats"])
 
         complementary = results["complementary"]
+        special = results["special"]
         limit = 3
 
         if complementary is not None:
-            limit = 2
-            e.description = (
-                f"**{complementary.title or 'Unknown'}**\n"
-                + (
+            limit -= 1
+            e.add_field(
+                name=f"{complementary.title or 'Unknown'}",
+                value=(
                     f"`{complementary.subtitle or 'Unknown'}`\n"
                     if complementary.subtitle
                     else ""
@@ -201,6 +202,13 @@ async def google(self, ctx, *, query: str):
                 + "\n".join([f"**{i}**`{j}`" for i, j in complementary.info])
             )
 
+        if special:
+            limit -= 1
+            e.add_field(
+                name=str(special.type).title(),
+                value="\n".join(special.content),
+            )
+
         for res in results["web"][:limit]:
             try:
                 content = res.contents[0]