migrate languages.json to fastapi

Author: RayBB

openlibrary/asgi_app.py

@@ -159,8 +159,10 @@ def create_app() -> FastAPI:
     def health() -> dict[str, str]:
         return {"status": "ok"}
 
+    from openlibrary.fastapi.languages import router as languages_router  # type: ignore
     from openlibrary.fastapi.search import router as search_router  # type: ignore
 
+    app.include_router(languages_router)
     app.include_router(search_router)
 
     return app

openlibrary/core/cache.py

@@ -2,6 +2,7 @@
 
 import functools
 import hashlib
+import inspect
 import json
 import random
 import string
@@ -497,21 +498,40 @@ def __init__(
     def __call__(self, f):
         """Returns the memoized version of f."""
 
-        @functools.wraps(f)
-        def func(*args, **kwargs):
-            """The memoized function.
-
-            If this is the first call with these arguments, function :attr:`f` is called and the return value is cached.
-            Otherwise, value from the cache is returned.
-            """
-            key = self.keyfunc(*args, **kwargs)
-            value = self.cache_get(key)
-            if value is None:
-                value = f(*args, **kwargs)
-                self.cache_set(key, value)
-            return value
-
-        return func
+        if inspect.iscoroutinefunction(f):
+            # Async function - return async wrapper
+            @functools.wraps(f)
+            async def async_func(*args, **kwargs):
+                """The memoized async function.
+
+                If this is the first call with these arguments, function :attr:`f` is called and the return value is cached.
+                Otherwise, value from the cache is returned.
+                """
+                key = self.keyfunc(*args, **kwargs)
+                value = self.cache_get(key)
+                if value is None:
+                    value = await f(*args, **kwargs)
+                    self.cache_set(key, value)
+                return value
+
+            return async_func
+        else:
+            # Sync function - return sync wrapper (existing behavior)
+            @functools.wraps(f)
+            def func(*args, **kwargs):
+                """The memoized function.
+
+                If this is the first call with these arguments, function :attr:`f` is called and the return value is cached.
+                Otherwise, value from the cache is returned.
+                """
+                key = self.keyfunc(*args, **kwargs)
+                value = self.cache_get(key)
+                if value is None:
+                    value = f(*args, **kwargs)
+                    self.cache_set(key, value)
+                return value
+
+            return func
 
     def cache_get(self, key: str | tuple):
         """Reads value of a key from the cache.

openlibrary/fastapi/languages.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from fastapi import APIRouter, Query, Request
+from fastapi.responses import JSONResponse
+
+from openlibrary.plugins.worksearch.languages import get_top_languages
+
+router = APIRouter()
+
+
+@router.get("/languages.json", response_class=JSONResponse)
+async def list_languages(
+    request: Request,
+    sort: Literal["count", "name", "ebook_edition_count"] = Query(
+        "count", description="The field to sort by."
+    ),
+    limit: int = Query(15, gt=0, description="The number of results to return."),
+):
+    """
+    Get a list of the top languages, sorted by the specified criteria.
+    """
+    return await get_top_languages(limit=limit, user_lang=request.state.lang, sort=sort)

openlibrary/plugins/upstream/utils.py

@@ -722,6 +722,12 @@ def strip_accents(s: str) -> str:
 
 @functools.cache
 def get_languages(limit: int = 1000) -> dict:
+    # TODO: fix this hack. Should be higher up like in other PR.
+    if not hasattr(web.ctx, 'site'):
+        from infogami.utils.delegate import create_site
+
+        web.ctx.site = create_site()
+
     keys = web.ctx.site.things({"type": "/type/language", "limit": limit})
     return {
         lang.key: lang for lang in web.ctx.site.get_many(keys) if not lang.deprecated
@@ -1170,15 +1176,16 @@ def get_marc21_language(language: str) -> str | None:
 
 
 @public
-def get_language_name(lang_or_key: "Nothing | str | Thing") -> Nothing | str:
+def get_language_name(
+    lang_or_key: "Nothing | str | Thing", user_lang: str = 'en'
+) -> Nothing | str:
     if isinstance(lang_or_key, str):
         lang = get_language(lang_or_key)
         if not lang:
             return lang_or_key
     else:
         lang = lang_or_key
 
-    user_lang = web.ctx.lang or 'en'
     return safeget(lambda: lang['name_translated'][user_lang][0]) or lang.name  # type: ignore[index]
 
 

openlibrary/plugins/worksearch/code.py

@@ -135,7 +135,11 @@ def process_facet(
                 key, name = read_author_facet(val)
                 yield (key, name, count)
             elif field == 'language':
-                yield (val, get_language_name(f'/languages/{val}'), count)
+                yield (
+                    val,
+                    get_language_name(f'/languages/{val}', web.ctx.lang or 'en'),
+                    count,
+                )
             else:
                 yield (val, val, count)
 

openlibrary/plugins/worksearch/languages.py

@@ -6,12 +6,14 @@
 from typing import Literal, override
 
 import web
+from typing_extensions import deprecated
 
 from infogami.plugins.api.code import jsonapi
 from infogami.utils import delegate
 from infogami.utils.view import render_template, safeint
 from openlibrary.core import cache
 from openlibrary.plugins.upstream.utils import get_language_name
+from openlibrary.utils.async_utils import async_bridge
 
 from . import search, subjects
 
@@ -39,22 +41,23 @@ def process_key(self, key):
         return key.replace("_", " ")
 
 
-def get_top_languages(
+async def get_top_languages(
     limit: int,
+    user_lang: str,
     sort: Literal["count", "name", "ebook_edition_count"] = "count",
 ) -> list[web.storage]:
     available_edition_counts = dict(
-        get_all_language_counts('edition', ebook_access="borrowable")
+        await get_all_language_counts('edition', ebook_access="borrowable")
     )
     results = [
         web.storage(
-            name=get_language_name(lang_key),
+            name=get_language_name(lang_key, user_lang),
             key=lang_key,
             marc_code=lang_key.split('/')[-1],
             count=count,
             ebook_edition_count=available_edition_counts.get(lang_key, 0),
         )
-        for (lang_key, count) in get_all_language_counts('work')
+        for (lang_key, count) in await get_all_language_counts('work')
     ]
     results.sort(
         key=lambda x: x[sort], reverse=sort in ("count", "ebook_edition_count")
@@ -63,7 +66,7 @@ def get_top_languages(
 
 
 @cache.memoize("memcache", key='get_all_language_counts', expires=60 * 60)
-def get_all_language_counts(
+async def get_all_language_counts(
     solr_type: Literal['work', 'edition'],
     ebook_access: str | None = None,
 ) -> list[tuple[str, int]]:
@@ -73,7 +76,7 @@ def get_all_language_counts(
     if ebook_access:
         ebook_access_query = f' AND ebook_access:[{ebook_access} TO *]'
 
-    result = search.get_solr().select(
+    result = await search.get_solr().select_async(
         f'type:{solr_type} {ebook_access_query}',
         rows=0,
         facets=['language'],
@@ -96,12 +99,16 @@ def GET(self):
         if sort not in ("count", "name", "ebook_edition_count"):
             raise web.badrequest("Invalid sort parameter")
 
-        return render_template("languages/index", get_top_languages(500, sort=sort))
+        return render_template(
+            "languages/index",
+            async_bridge.run(get_top_languages(500, user_lang=web.ctx.lang, sort=sort)),
+        )
 
     def is_enabled(self):
         return True
 
 
+@deprecated("migrated to fastapi")
 class index_json(delegate.page):
     path = "/languages"
     encoding = "json"
@@ -112,7 +119,11 @@ def GET(self):
         limit = safeint(i.limit, 15)
         if i.sort not in ("count", "name", "ebook_edition_count"):
             raise web.badrequest("Invalid sort parameter")
-        return json.dumps(get_top_languages(limit, sort=i.sort))
+        return json.dumps(
+            async_bridge.run(
+                get_top_languages(limit, user_lang=web.ctx.lang, sort=i.sort)
+            )
+        )
 
 
 class language_search(delegate.page):

openlibrary/utils/solr.py

@@ -1,5 +1,6 @@
 """Python library for accessing Solr"""
 
+import functools
 import logging
 import re
 from collections.abc import Callable, Iterable
@@ -117,7 +118,7 @@ def update_in_place(self, request, commit: bool = False):
         ).json()
         return resp
 
-    def select(
+    async def select_async(
         self,
         query,
         fields=None,
@@ -130,7 +131,7 @@ def select(
         _pass_time_allowed=DEFAULT_PASS_TIME_ALLOWED,
         **kw,
     ):
-        """Execute a solr query.
+        """Asynchronously execute a solr query.
 
         query can be a string or a dictionary. If query is a dictionary, query
         is constructed by concatenating all the key-value pairs with AND condition.
@@ -163,8 +164,8 @@ def select(
                     name = f
                 params['facet.field'].append(name)
 
-        json_data = async_bridge.run(
-            self.raw_request(
+        json_data = (
+            await self.raw_request(
                 'select',
                 urlencode(params, doseq=True),
                 _timeout=_timeout,
@@ -176,6 +177,16 @@ def select(
             json_data, doc_wrapper=doc_wrapper, facet_wrapper=facet_wrapper
         )
 
+    @functools.wraps(select_async)
+    def select(self, *args, **kwargs):
+        """
+        Synchronously execute a solr query.
+
+        This is a wrapper around the async `select_async` method.
+        All parameters are passed directly to the async version.
+        """
+        return async_bridge.run(self.select_async(*args, **kwargs))
+
     async def raw_request(
         self,
         path_or_url: str,