replace library.use_cache with library.cache_results

Author: cibere

plugin/handlers/lookup_handler.py

@@ -22,31 +22,28 @@ async def callback(self, query: Query):
         try:
             library = self.plugin.libraries[keyword]
         except KeyError:
-            yield Result(
+            return Result(
                 f"Library '{keyword}' not found in settings", icon="Images/error.png"
             )
-            return
 
-        if not library.use_cache:
-            log.debug(
-                "Library %r not set to use cache, rebuilding for request", library.name
-            )
-            msg = await self.plugin.refresh_library_cache(
-                library, send_noti=False, txt=query.text, wait=True
-            )
-            if msg is not None:
-                yield Result(msg, icon=library.icon)
-                return
+        if library.cache_results and (
+            cached_results := library.result_cache.get(query.text)
+        ):
+            log.debug("Returning results from result cache")
+
+            return cached_results
 
         if library.cache is None:
-            log.debug("Cache is `None`, refreshing")
+            log.debug("Refreshing cache for %r, cache or `None`", library.name)
             await self.plugin.refresh_library_cache(library)
             if library.cache is None:
-                yield Result(
+                return Result(
                     f"Library '{library.name}' not found in cache, and I was unable to build the cache.",
                     icon="Images/error.png",
                 )
-                return
+
+        if library.is_api:
+            await library.make_request(self.plugin.session, query.text)
 
         cache = list(library.cache.items())
         if library.is_api:
@@ -55,11 +52,18 @@ async def callback(self, query: Query):
             matches = fuzzy_finder(text, cache, key=lambda t: t[0])
 
         if len(matches) == 0:
-            yield Result("Could not find anything. Sorry.", icon=library.icon)
-            return
+            return Result("Could not find anything. Sorry.", icon=library.icon)
+
+        results = [
+            OpenRtfmResult(
+                library=library,
+                entry=(entry if isinstance(entry, Entry) else Entry(name, entry)),
+                score=idx,
+            )
+            for idx, (name, entry) in enumerate(reversed(matches))
+        ]
 
-        for idx, (name, entry) in enumerate(reversed(matches)):
-            if isinstance(entry, str):
-                entry = Entry(name, entry)
+        if library.cache_results:
+            library.result_cache[query.text] = results
 
-            yield OpenRtfmResult(library=library, entry=entry, score=idx)
+        return results

plugin/libraries/doctypes/cidex.py

@@ -20,9 +20,7 @@
 CidexResponse = CacheIndex | VariantManifest | ApiIndex
 msgpack = msgspec.msgpack.Decoder(type=CidexResponse)
 api_decoder = msgspec.json.Decoder(type=Cache)
-INDEX_URL = (
-    "https://github.com/cibere/Rtfm-Indexes/raw/refs/heads/indexes-v2/indexes_v2/{}.cidex"
-)
+INDEX_URL = "https://github.com/cibere/Rtfm-Indexes/raw/refs/heads/indexes-v2/indexes_v2/{}.cidex"
 
 
 class CidexBase(Library):
@@ -79,6 +77,7 @@ async def build_cache(self, session: ClientSession, webserver_port: int) -> None
         if isinstance(index, ApiIndex):
             self.is_api = True
             self._api_info = index
+            self.cache = {}
         else:
             self.cache = index.cache
 

plugin/libraries/library.py

@@ -10,9 +10,10 @@
 from ..icons import get_icon as _get_icon
 
 if TYPE_CHECKING:
-    from collections.abc import Mapping
+    from collections.abc import Iterable, Mapping
 
     from aiohttp import ClientSession
+    from flogin import Result
 
     from .entry import Entry
 
@@ -23,15 +24,15 @@ class PartialLibrary(msgspec.Struct):
     name: str
     type: str
     loc: str
-    use_cache: bool = False
+    cache_results: bool = False
     is_api: bool = False
 
     def to_dict(self):
         return {
             "name": self.name,
             "type": self.type,
             "loc": self.loc,
-            "use_cache": self.use_cache,
+            "cache_results": self.cache_results,
             "is_api": self.is_api,
         }
 
@@ -53,13 +54,15 @@ class Library:
     is_api: bool = False
     cache: Mapping[str, Entry | str] | None
     supports_local: ClassVar[bool] = False
+    result_cache: dict[str, Iterable[Result]]
 
-    def __init__(self, name: str, loc: URL | Path, *, use_cache: bool) -> None:
+    def __init__(self, name: str, loc: URL | Path, *, cache_results: bool) -> None:
         self.name = name
         self.loc = loc
         self.icon: str | None = None
         self.cache = None
-        self.use_cache = use_cache
+        self.cache_results = cache_results
+        self.result_cache = {}
 
     @property
     def url(self) -> URL | None:
@@ -70,7 +73,7 @@ def path(self) -> Path | None:
         return self.loc if isinstance(self.loc, Path) else None
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__} {self.name=} {self.url=} {self.icon=} {self.use_cache=} {self.typename=} {self.is_api=}>"
+        return f"<{self.__class__.__name__} {self.name=} {self.url=} {self.icon=} {self.cache_results=} {self.typename=} {self.is_api=}>"
 
     async def fetch_icon(self) -> str | None:
         if self.favicon_url is None:
@@ -104,7 +107,7 @@ def _build_url(self, piece: str, port: int) -> str:
 
     @classmethod
     def from_partial(cls: type[Self], data: PartialLibrary) -> Self:
-        kwargs = {"name": data.name, "use_cache": data.use_cache}
+        kwargs = {"name": data.name, "cache_results": data.cache_results}
 
         loc: str = data.loc
 
@@ -124,6 +127,6 @@ def to_partial(self) -> PartialLibrary:
             self.name,
             type=self.typename,
             loc=str(self.loc),
-            use_cache=self.use_cache,
+            cache_results=self.cache_results,
             is_api=self.is_api,
         )

plugin/plugin.py

@@ -162,26 +162,18 @@ async def refresh_library_cache(
         library: Library,
         *,
         send_noti: bool = True,
-        txt: str | None = None,
         wait: bool = False,
     ) -> str | None:
         log.debug("Building cache for %r", library)
+        library.result_cache = {}
 
         async def run(coro: Coroutine[Any, Any, Any]):
             if wait:
                 return await coro
             asyncio.create_task(coro)
 
-        if library.is_api is True:
-            if txt is None:
-                await run(library.fetch_icon())
-                return
-            coro = library.make_request(self.session, txt)
-        else:
-            coro = library.build_cache(self.session, self.webserver_port)
-
         try:
-            await coro
+            await library.build_cache(self.session, self.webserver_port)
         except Exception as e:
             log.exception(
                 "Sending could not be parsed notification for %r", library, exc_info=e
@@ -256,12 +248,12 @@ async def get_library_from_url(self, name: str, raw_url: str) -> Library | None:
         log.debug("Getting library from url: %r", loc)
         is_path: bool = isinstance(loc, Path)
 
-        for doctype in doc_types:
-            if is_path is True and doctype.supports_local is False:
+        for Doctype in doc_types:
+            if is_path is True and Doctype.supports_local is False:
                 continue
-            lib = doctype(name, loc, use_cache=True)
+            lib = Doctype(name, loc, cache_results=True)
             try:
-                log.debug("Trying doctype: %r", doctype)
+                log.debug("Trying doctype: %r", Doctype)
                 await lib.build_cache(self.session, self.webserver_port)
             except Exception as e:
                 log.exception("Failed to build cache for library: %r", name, exc_info=e)

plugin/server/index.html

@@ -9,7 +9,7 @@
 </head>
 <body>
 <template id="docs-template">
-    {{ doc(location="{{LOCATION}}", index="{{INDEX}}", type="{{TYPE}}", name="{{NAME}}", use_cache=False, is_api=False) }}
+    {{ doc(location="{{LOCATION}}", index="{{INDEX}}", type="{{TYPE}}", name="{{NAME}}", cache_results=False, is_api=False) }}
 </template>
 <main>
     {% call card("Rtfm Plugin") %}
@@ -67,7 +67,7 @@
         </div>
 
         {% for lib in libs %}
-            {{ doc(location=lib.loc, index=loop.index, type=lib.typename, name=lib.name, use_cache=lib.use_cache, is_api=lib.is_api) }}
+            {{ doc(location=lib.loc, index=loop.index, type=lib.typename, name=lib.name, cache_results=lib.cache_results, is_api=lib.is_api) }}
         {% endfor %}
     </form>
 </main>

plugin/server/macros.html

@@ -5,7 +5,7 @@
     </div>
 {% endmacro %}
 
-{% macro doc(location, index, type, name, use_cache, is_api) %}
+{% macro doc(location, index, type, name, cache_results, is_api) %}
     <div class="card" data-index="{{ index }}">
         <input type="hidden" name="doc.{{ index }}.loc" value="{{ location }}">
         <input type="hidden" name="doc.{{ index }}.type" value="{{ type }}">
@@ -29,17 +29,16 @@
                 >
             {% endcall %}
 
-            {% call checkbox(label="Use Cache", id="lib-cache-input-" ~ index, description="If checked, the plugin will cache the index. If not checked, the plugin will rebuild the index for each query.") %}
+            {% call checkbox(label="Cache Results", id="lib-cache-input-" ~ index, description="If checked, the plugin will cache the results that you get for each query, for faster lookup times on duplicate queries.") %}
                 <input
                         id="lib-cache-input-{{ index }}"
                         type="checkbox"
-                        name="doc.{{ index }}.use_cache"
-                        {% if use_cache %}checked{% endif %}
-                        {% if is_api %}disabled{% endif %}
+                        name="doc.{{ index }}.cache_results"
+                        {% if cache_results %}checked{% endif %}
                 >
             {% endcall %}
 
-            {% call checkbox(label="Is API", id="lib-api-input-" ~ index, description="If checked, this means that the plugin must make a web request for each query, and that caching is not supported.") %}
+            {% call checkbox(label="Is API", id="lib-api-input-" ~ index, description="If checked, this means that the plugin must make a web request for each query, and the API determines the ordering of the results, and which results get shown.") %}
                 <input type="checkbox" id="lib-api-input-{{ index }}" name="doc.{{ index }}.is_api" disabled {% if is_api %}checked{% endif %}>
             {% endcall %}
         </div>

plugin/server/payloads/settings.py

@@ -39,7 +39,7 @@ def parse_form_data(cls, data: dict[str, str]) -> PluginSettings:
                 case "doc":
                     idx = int(parts[1])
                     match parts[2]:
-                        case "use_cache":
+                        case "cache_results":
                             value = True
                         case "keyword":
                             parts[2] = "name"

plugin/server/script.js

@@ -21,7 +21,7 @@
  * @property {string} name
  * @property {string} type
  * @property {string} loc
- * @property {boolean} use_cache
+ * @property {boolean} cache_results
  * @property {boolean} is_api
  */
 
@@ -65,9 +65,8 @@ function addNewDoc(data) {
         .replaceAll("{{NAME}}", data.name)
         .replaceAll("{{TYPE}}", data.type);
 
-    const useCacheInput = card.querySelector('input[name$="use_cache"]');
-    useCacheInput.checked = data.use_cache;
-    useCacheInput.disabled = data.is_api;
+    const useCacheInput = card.querySelector('input[name$="cache_results"]');
+    useCacheInput.checked = data.cache_results;
 
     const isApiInput = card.querySelector('input[name$="is_api"]');
     isApiInput.checked = data.is_api;