ckanext-search-tweaks 0.5.0__tar.gz → 0.6.0__tar.gz

{ckanext-search-tweaks-0.5.0/ckanext_search_tweaks.egg-info → ckanext-search-tweaks-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ckanext-search-tweaks
-Version: 0.5.0
+Version: 0.6.0
 Home-page: https://github.com/DataShades/ckanext-search-tweaks
 Author: Sergey Motornyuk
 Author-email: sergey.motornyuk@linkdigital.com.au
@@ -8,11 +8,14 @@ License: AGPL
 Keywords: CKAN
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
-Classifier: Programming Language :: Python :: 2.7
-Requires-Python: >=3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
 Description-Content-Type: text/markdown
-Provides-Extra: advanced-search
 License-File: LICENSE
+Requires-Dist: freezegun
+Requires-Dist: typing_extensions>=4.0.0
+Provides-Extra: advanced-search
 
 [![Tests](https://github.com/DataShades/ckanext-search-tweaks/actions/workflows/test.yml/badge.svg?branch=master)](https://github.com/DataShades/ckanext-search-tweaks/actions)
 

{ckanext-search-tweaks-0.5.0 → ckanext-search-tweaks-0.6.0}/ckanext/__init__.py

@@ -1,4 +1,3 @@
-# encoding: utf-8
 
 # this is a namespace package
 try:

ckanext-search-tweaks-0.6.0/ckanext/search_tweaks/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from .shared import feature_disabled

{ckanext-search-tweaks-0.5.0 → ckanext-search-tweaks-0.6.0}/ckanext/search_tweaks/advanced_search/plugin.py

@@ -37,14 +37,14 @@ DEFAULT_FORM_DEFINITION = json.dumps(
                 {"value": "private", "label": "Private"},
             ],
         },
-    }
+    },
 )
 DEFAULT_FIELD_ORDER = None
 
 
 def form_config():
     definition = json.loads(
-        tk.config.get(CONFIG_FORM_DEFINITION, DEFAULT_FORM_DEFINITION)
+        tk.config.get(CONFIG_FORM_DEFINITION, DEFAULT_FORM_DEFINITION),
     )
     order = tk.aslist(tk.config.get(CONFIG_FIELD_ORDER, DEFAULT_FIELD_ORDER))
     if not order:
@@ -74,7 +74,7 @@ class AdvancedSearchPlugin(p.SingletonPlugin):
             from ckanext.composite_search.interfaces import ICompositeSearch
         except ImportError:
             raise CkanConfigurationException(
-                "ckanext-composite-search is not installed"
+                "ckanext-composite-search is not installed",
             )
         if not p.plugin_loaded("composite_search"):
             msg = "Advanced search requires `composite_search` plugin"

{ckanext-search-tweaks-0.5.0 → ckanext-search-tweaks-0.6.0}/ckanext/search_tweaks/cli.py

@@ -1,8 +1,8 @@
 import click
 
-
-def get_commands():
-    return [search_tweaks]
+__all__ = [
+    "search_tweaks",
+]
 
 
 @click.group(short_help="Search tweaks")

ckanext-search-tweaks-0.6.0/ckanext/search_tweaks/config.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+import ckan.plugins.toolkit as tk
+from ckan.lib.search.query import QUERY_FIELDS
+
+CONFIG_QF = "ckanext.search_tweaks.common.qf"
+DEFAULT_QF = QUERY_FIELDS
+
+CONFIG_FUZZY = "ckanext.search_tweaks.common.fuzzy_search.enabled"
+CONFIG_FUZZY_DISTANCE = "ckanext.search_tweaks.common.fuzzy_search.distance"
+CONFIG_MM = "ckanext.search_tweaks.common.mm"
+CONFIG_FUZZY_KEEP_ORIGINAL = "ckanext.search_tweaks.common.fuzzy_search.keep_original"
+CONFIG_PREFER_BOOST = "ckanext.search_tweaks.common.prefer_boost"
+
+
+def qf() -> str:
+    return tk.config[CONFIG_QF] or DEFAULT_QF
+
+
+def fuzzy() -> bool:
+    return tk.config[CONFIG_FUZZY]
+
+
+def fuzzy_distance() -> int:
+    return tk.config[CONFIG_FUZZY_DISTANCE]
+
+
+def mm() -> str:
+    return tk.config[CONFIG_MM]
+
+
+def fuzzy_with_original() -> bool:
+    return tk.config[CONFIG_FUZZY_KEEP_ORIGINAL]
+
+
+def prefer_boost() -> bool:
+    return tk.config[CONFIG_PREFER_BOOST]

{ckanext-search-tweaks-0.5.0 → ckanext-search-tweaks-0.6.0}/ckanext/search_tweaks/field_relevance/plugin.py

@@ -5,8 +5,8 @@ from typing import Any
 import ckan.plugins as p
 import ckan.plugins.toolkit as tk
 
-from .. import feature_disabled
-from ..interfaces import ISearchTweaks
+from ckanext.search_tweaks import feature_disabled
+from ckanext.search_tweaks.interfaces import ISearchTweaks
 from . import views
 
 CONFIG_BOOST_FN = "ckanext.search_tweaks.field_relevance.boost_function"
@@ -23,7 +23,7 @@ class FieldRelevancePlugin(p.SingletonPlugin):
     # ISearchTweaks
     def get_search_boost_fn(self, search_params: dict[str, Any]) -> str | None:
         if feature_disabled("field_boost", search_params):
-            return
+            return None
 
         return tk.config.get(CONFIG_BOOST_FN, DEFAULT_BOOST_FN)
 

{ckanext-search-tweaks-0.5.0 → ckanext-search-tweaks-0.6.0}/ckanext/search_tweaks/field_relevance/views.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Optional
+from typing import Any
 
 from flask import Blueprint
 from flask.views import MethodView
@@ -29,7 +29,7 @@ field_relevance = Blueprint("search_tweaks_field_relevance", __name__)
 
 def get_blueprints():
     if tk.asbool(
-        tk.config.get(CONFIG_ENABLE_PROMOTION_ROUTE, DEFAULT_ENABLE_PROMOTION_ROUTE)
+        tk.config.get(CONFIG_ENABLE_PROMOTION_ROUTE, DEFAULT_ENABLE_PROMOTION_ROUTE),
     ):
         path = tk.config.get(CONFIG_PROMOTION_PATH, DEFAULT_PROMOTION_PATH)
         field_relevance.add_url_rule(path, view_func=PromoteView.as_view("promote"))
@@ -52,9 +52,9 @@ class PromoteView(MethodView):
                 tk.get_validator("convert_int"),
                 tk.get_validator("natural_number_validator"),
                 tk.get_validator("limit_to_configured_maximum")(
-                    CONFIG_MAX_PROMOTION, DEFAULT_MAX_PROMOTION
+                    CONFIG_MAX_PROMOTION, DEFAULT_MAX_PROMOTION,
                 ),
-            ]
+            ],
         }
 
         data, errors = tk.navl_validate(
@@ -67,7 +67,7 @@ class PromoteView(MethodView):
             return self.get(id, data, errors)
         try:
             pkg_dict = tk.get_action("package_patch")(
-                {}, {"id": id, field: data[field]}
+                {}, {"id": id, field: data[field]},
             )
         except tk.ValidationError as e:
             for k, v in e.error_summary.items():
@@ -79,8 +79,8 @@ class PromoteView(MethodView):
     def get(
         self,
         id,
-        data: Optional[dict[str, Any]] = None,
-        errors: Optional[dict[str, Any]] = None,
+        data: dict[str, Any] | None = None,
+        errors: dict[str, Any] | None = None,
     ):
         self._check_access(id)
         field = tk.config.get(CONFIG_PROMOTION_FIELD, DEFAULT_PROMOTION_FIELD)
@@ -90,7 +90,7 @@ class PromoteView(MethodView):
             "errors": errors or {},
             "data": data or pkg_dict,
             "max_promotion": tk.asint(
-                tk.config.get(CONFIG_MAX_PROMOTION, DEFAULT_MAX_PROMOTION)
+                tk.config.get(CONFIG_MAX_PROMOTION, DEFAULT_MAX_PROMOTION),
             ),
             "field_name": field,
         }

ckanext-search-tweaks-0.6.0/ckanext/search_tweaks/interfaces.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import Any
+
+from ckan.plugins.interfaces import Interface
+
+
+class ISearchTweaks(Interface):
+    def get_search_boost_fn(self, search_params: dict[str, Any]) -> str | None:
+        """Return Solr's boost function applicable to the current search.
+
+        Note: it will be applied as `boost` when
+        `ckanext.search_tweaks.common.prefer_boost` enabled and as `bf`
+        otherwise.
+
+        """
+        return None
+
+    def get_extra_qf(self, search_params: dict[str, Any]) -> str | None:
+        """Return an additional fragment of the Solr's qf.
+
+        This fragment will be appended to the current qf
+        """
+        return None
+
+
+
+class IQueryPopularity(Interface):
+    def skip_query_popularity(self, params: dict[str, Any]) -> bool:
+        """Do not index search query.
+        """
+        return False

{ckanext-search-tweaks-0.5.0 → ckanext-search-tweaks-0.6.0}/ckanext/search_tweaks/plugin.py

@@ -1,54 +1,37 @@
 from __future__ import annotations
 
 import logging
-from typing import Any, Dict
+from typing import Any
 
 import ckan.plugins as plugins
 import ckan.plugins.toolkit as tk
-from ckan.lib.search.query import QUERY_FIELDS
-
-from . import boost_preffered, cli, feature_disabled
+from . import feature_disabled, config
 from .interfaces import ISearchTweaks
 
 log = logging.getLogger(__name__)
-
-SearchParams = Dict[str, Any]
-
-CONFIG_QF = "ckanext.search_tweaks.common.qf"
-CONFIG_FUZZY = "ckanext.search_tweaks.common.fuzzy_search.enabled"
-CONFIG_FUZZY_DISTANCE = "ckanext.search_tweaks.common.fuzzy_search.distance"
-CONFIG_MM = "ckanext.search_tweaks.common.mm"
-CONFIG_FUZZY_KEEP_ORIGINAL = "ckanext.search_tweaks.common.fuzzy_search.keep_original"
-
-DEFAULT_QF = QUERY_FIELDS
-DEFAULT_FUZZY = False
-DEFAULT_FUZZY_DISTANCE = 1
-DEFAULT_MM = "1"
-DEFAULT_FUZZY_KEEP_ORIGINAL = True
+CONFIG_PREFER_BOOST = "ckanext.search_tweaks.common.prefer_boost"
+DEFAULT_PREFER_BOOST = True
 
 
+@tk.blanket.cli
+@tk.blanket.config_declarations
 class SearchTweaksPlugin(plugins.SingletonPlugin):
-    plugins.implements(plugins.IClick)
     plugins.implements(plugins.IPackageController, inherit=True)
 
-    # IClick
-
-    def get_commands(self):
-        return cli.get_commands()
-
     # IPackageController
 
-    def before_dataset_search(self, search_params: SearchParams):
+    def before_dataset_search(self, search_params: dict[str, Any]):
         if feature_disabled("everything", search_params):
             return search_params
 
-        search_params.setdefault("mm", tk.config.get(CONFIG_MM, DEFAULT_MM))
+        search_params.setdefault("mm", config.mm())
 
         if "defType" not in search_params:
             search_params["defType"] = "edismax"
 
-        if boost_preffered() and search_params["defType"] == "edismax":
+        if config.prefer_boost() and search_params["defType"] == "edismax":
             _set_boost(search_params)
+
         else:
             _set_bf(search_params)
 
@@ -58,7 +41,7 @@ class SearchTweaksPlugin(plugins.SingletonPlugin):
         return search_params
 
 
-def _set_boost(search_params: SearchParams) -> None:
+def _set_boost(search_params: dict[str, Any]) -> None:
     boost: list[str] = search_params.setdefault("boost", [])
     for plugin in plugins.PluginImplementations(ISearchTweaks):
         extra = plugin.get_search_boost_fn(search_params)
@@ -67,7 +50,7 @@ def _set_boost(search_params: SearchParams) -> None:
         boost.append(extra)
 
 
-def _set_bf(search_params: SearchParams) -> None:
+def _set_bf(search_params: dict[str, Any]) -> None:
     default_bf: str = search_params.get("bf") or "0"
     search_params.setdefault("bf", default_bf)
     for plugin in plugins.PluginImplementations(ISearchTweaks):
@@ -77,11 +60,11 @@ def _set_bf(search_params: SearchParams) -> None:
         search_params["bf"] = f"sum({search_params['bf']},{extra_bf})"
 
 
-def _set_qf(search_params: SearchParams) -> None:
+def _set_qf(search_params: dict[str, Any]) -> None:
     if feature_disabled("qf", search_params):
         return
 
-    default_qf: str = search_params.get("qf") or tk.config.get(CONFIG_QF, DEFAULT_QF)
+    default_qf: str = search_params.get("qf") or config.qf()
     search_params.setdefault("qf", default_qf)
     for plugin in plugins.PluginImplementations(ISearchTweaks):
         extra_qf = plugin.get_extra_qf(search_params)
@@ -90,8 +73,8 @@ def _set_qf(search_params: SearchParams) -> None:
         search_params["qf"] += " " + extra_qf
 
 
-def _set_fuzzy(search_params: SearchParams) -> None:
-    if not tk.asbool(tk.config.get(CONFIG_FUZZY, DEFAULT_FUZZY)):
+def _set_fuzzy(search_params: dict[str, Any]) -> None:
+    if not config.fuzzy():
         return
 
     if feature_disabled("fuzzy", search_params):
@@ -114,18 +97,16 @@ def _set_fuzzy(search_params: SearchParams) -> None:
             if s.isalpha() and s not in ("AND", "OR", "TO")
             else s,
             q.split(),
-        )
+        ),
     )
-    if tk.asbool(
-        tk.config.get(CONFIG_FUZZY_KEEP_ORIGINAL, DEFAULT_FUZZY_KEEP_ORIGINAL)
-    ):
+    if config.fuzzy_with_original():
         search_params["q"] = f"({fuzzy_q}) OR ({q})"
     else:
         search_params["q"] = fuzzy_q
 
 
 def _get_fuzzy_distance() -> int:
-    distance = tk.asint(tk.config.get(CONFIG_FUZZY_DISTANCE, DEFAULT_FUZZY_DISTANCE))
+    distance = config.fuzzy_distance()
     if distance < 0:
         log.warning("Cannot use negative fuzzy distance: %s.", distance)
         distance = 0

ckanext-search-tweaks-0.6.0/ckanext/search_tweaks/query_popularity/config.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+import ckan.plugins.toolkit as tk
+
+
+def skip_irrefutable() -> bool:
+    return tk.config["ckanext.search_tweaks.query_popularity.skip_irrefutable_search"]
+
+
+def ignored_symbols() -> set[str]:
+    return set(tk.config["ckanext.search_tweaks.query_popularity.ignored_symbols"])
+
+
+def ignored_terms() -> list[str]:
+    return tk.config["ckanext.search_tweaks.query_popularity.ignored_terms"]
+
+
+def throttle() -> int:
+    return tk.config["ckanext.search_tweaks.query_popularity.query_throttle"]
+
+
+def max_age() -> int:
+    return tk.config["ckanext.search_tweaks.query_popularity.max_age"]
+
+
+def obsoletion_period() -> int:
+    return tk.config["ckanext.search_tweaks.query_popularity.obsoletion_period"]
+
+
+def tracked_endpoints() -> list[str]:
+    return tk.config["ckanext.search_tweaks.query_popularity.tracked_endpoints"]

ckanext-search-tweaks-0.6.0/ckanext/search_tweaks/query_popularity/logic/action.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from typing import Any
+from ckan import types
+import ckan.plugins.toolkit as tk
+
+from ckanext.search_tweaks.query_popularity.score import Score
+
+
+@tk.side_effect_free
+def search_tweaks_query_popularity_list(
+    context: types.Context, data_dict: dict[str, Any]
+) -> list[dict[str, Any]]:
+    score = Score()
+
+    if tk.asbool(data_dict.get("refresh")):
+        score.refresh()
+
+    limit = tk.asint(data_dict.get("limit", 10))
+
+    return list(score.stats(limit))
+
+
+@tk.side_effect_free
+def search_tweaks_query_popularity_export(
+    context: types.Context, data_dict: dict[str, Any]
+) -> dict[str, Any]:
+    score = Score()
+
+    results = score.export()
+    return {"results": results, "count": len(results)}
+
+
+@tk.side_effect_free
+def search_tweaks_query_popularity_ignore(
+    context: types.Context, data_dict: dict[str, Any]
+):
+    q = tk.get_or_bust(data_dict, "q")
+    score = Score()
+    result = score.ignore(q)
+    if tk.asbool(data_dict.get("remove")):
+        score.drop(q)
+
+    return result

ckanext-search-tweaks-0.6.0/ckanext/search_tweaks/query_popularity/logic/auth.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+from typing import Any
+from ckan import types
+
+from ckan.authz import is_authorized
+
+
+def search_tweaks_query_popularity_list(
+    context: types.Context, data_dict: dict[str, Any]
+) -> types.AuthResult:
+    return is_authorized("sysadmin", context, data_dict)
+
+
+def search_tweaks_query_popularity_export(
+    context: types.Context, data_dict: dict[str, Any]
+) -> types.AuthResult:
+    return is_authorized("sysadmin", context, data_dict)
+
+
+def search_tweaks_query_popularity_ignore(
+    context: types.Context, data_dict: dict[str, Any]
+) -> types.AuthResult:
+    return is_authorized("sysadmin", context, data_dict)

ckanext-search-tweaks-0.6.0/ckanext/search_tweaks/query_popularity/plugin.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from typing import Any
+import ckan.plugins as p
+import ckan.plugins.toolkit as tk
+from ckanext.search_tweaks.interfaces import IQueryPopularity
+from . import config, score
+
+
+@tk.blanket.actions
+@tk.blanket.auth_functions
+@tk.blanket.config_declarations
+class QueryPopularityPlugin(p.SingletonPlugin):
+    p.implements(p.IConfigurable)
+    p.implements(p.IPackageController, inherit=True)
+    p.implements(IQueryPopularity, inherit=True)
+
+    def after_dataset_search(self, results: dict[str, Any], params: dict[str, Any]):
+        bp, view = tk.get_endpoint()
+        if bp and view and f"{bp}.{view}" in config.tracked_endpoints():
+            if not any(
+                plugin.skip_query_popularity(params)
+                for plugin in p.PluginImplementations(IQueryPopularity)
+            ):
+                self.score.save(params["q"])
+
+        return results
+
+    def configure(self, config: Any):
+        self.score = score.Score()
+
+    def skip_query_popularity(self, params: dict[str, Any]) -> bool:
+        q = params["q"]
+
+        if q == "*:*":
+            return config.skip_irrefutable()
+
+        symbols = config.ignored_symbols()
+        if symbols and set(q) & symbols:
+            return True
+
+        terms = config.ignored_terms()
+
+        for term in terms:
+            if term in q:
+                return True
+
+        return False

ckanext-search-tweaks-0.6.0/ckanext/search_tweaks/query_popularity/score.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+from collections import defaultdict
+from datetime import datetime, timedelta
+import logging
+from hashlib import md5
+from typing import Any, Iterable, cast
+from operator import itemgetter
+from ckan.lib.redis import connect_to_redis
+import ckan.plugins.toolkit as tk
+from redis import Redis
+from . import config
+
+log = logging.getLogger(__name__)
+connect_to_redis: Any
+
+
+class Score:
+    redis: Redis[bytes]
+    date_format = "%Y-%m-%d %H-%M"
+
+    def __init__(self):
+        self.redis = connect_to_redis()
+
+        site = tk.config["ckan.site_id"]
+        self.prefix = f"{site}:search_tweaks:qp"
+
+    def export(self):
+        data: dict[bytes, dict[str, Any]] = {
+            hash: {"query": query, "records": []}
+            for hash, query in self.redis.hgetall(self.trans_key()).items()
+        }
+        for k, v in self.redis.hscan_iter(self.distribution_key()):
+            date_str, q_hash = k.split(b"/", 1)
+            try:
+                date = datetime.strptime(date_str.decode(), self.date_format)
+            except ValueError:
+                continue
+
+            data[q_hash]["records"].append({"date": date, "count": int(v)})
+
+        return list(data.values())
+
+    def save(self, q: str):
+        q = q.strip()
+        q_hash = self.hash(q)
+
+        if self.is_ignored(q_hash):
+            return
+
+        if self.is_throttling(q_hash):
+            return
+
+        self.redis.hset(self.trans_key(), q_hash, q)
+
+        date_stem = self.format_date_stem(self.now())
+
+        self.redis.hincrby(self.distribution_key(), f"{date_stem}/{q_hash}", 1)
+
+    def drop(self, q: str):
+        q_hash = self.hash(q)
+        dk = self.distribution_key()
+
+        series = self.redis.hscan_iter(dk, f"*/{q_hash}")
+        keys = list(map(itemgetter(0), series))
+        if keys:
+            self.redis.hdel(dk, *keys)
+
+        self.redis.hdel(self.trans_key(), q_hash)
+        self.redis.zrem(self.score_key(), q_hash)
+
+    def is_throttling(self, q_hash: str):
+        user = tk.current_user.name
+
+        throttle_key = f"{self.prefix}:throttle:{user}:{q_hash}"
+        if self.redis.exists(throttle_key):
+            return True
+
+        self.redis.set(throttle_key, 1, ex=config.throttle())
+        return False
+
+    def reset(self):
+        keys = self.redis.keys(f"{self.prefix}:*")
+        if keys:
+            self.redis.delete(*keys)
+
+    def refresh(self):
+        max_age = timedelta(seconds=config.max_age())
+        dk = self.distribution_key()
+        sk = self.score_key()
+
+        expired_dist: set[bytes] = set()
+        distribution = cast(
+            "Iterable[tuple[bytes, bytes]]",
+            self.redis.hscan_iter(dk),
+        )
+
+        scores: dict[bytes, float] = defaultdict(float)
+
+        for k, v in distribution:
+            date_str, q_hash = k.split(b"/", 1)
+            try:
+                date = datetime.strptime(date_str.decode(), self.date_format)
+            except ValueError:
+                log.error("Remove invalid key %s", k)
+                expired_dist.add(k)
+                continue
+
+            age = self.now() - date
+
+            if age > max_age:
+                expired_dist.add(k)
+                continue
+
+            scores[q_hash] += int(v) / (age.seconds // config.obsoletion_period() + 1)
+
+        if expired_dist:
+            self.redis.hdel(dk, *expired_dist)
+
+        expired_scores: set[bytes] = set()
+        for k, v in self.redis.zscan_iter(sk):
+            if k not in scores:
+                expired_scores.add(k)
+                continue
+        if scores:
+            self.redis.zadd(sk, cast(Any, scores))
+
+        if expired_scores:
+            self.redis.zrem(sk, *expired_scores)
+            self.redis.hdel(self.trans_key(), *expired_scores)
+
+    def hash(self, q: str):
+        return md5(q.encode()).hexdigest()
+
+    def is_ignored(self, q_hash: str):
+        return self.redis.sismember(self.ignore_key(), q_hash)
+
+    def ignore(self, q: str):
+        return self.redis.sadd(self.ignore_key(), self.hash(q))
+
+    def now(self):
+        return datetime.utcnow()
+
+    def score_key(self):
+        return f"{self.prefix}:score"
+
+    def trans_key(self):
+        return f"{self.prefix}:trans"
+
+    def ignore_key(self):
+        return f"{self.prefix}:ignore"
+
+    def distribution_key(self):
+        return f"{self.prefix}:distribution"
+
+    def format_date_stem(self, date: datetime):
+        return date.strftime(self.date_format)
+
+    def stats(self, num: int) -> Iterable[dict[str, Any]]:
+        scores: list[tuple[bytes, float]] = self.redis.zrange(
+            self.score_key(), 0, num - 1, desc=True, withscores=True
+        )
+        trans_key = self.trans_key()
+
+        for k, v in scores:
+            yield {"query": self.redis.hget(trans_key, k), "score": v}

{ckanext-search-tweaks-0.5.0 → ckanext-search-tweaks-0.6.0}/ckanext/search_tweaks/query_relevance/__init__.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 import contextlib
-from typing import Optional
 
 from urllib.parse import urlparse, parse_qs
 
@@ -14,7 +13,7 @@ from .score import QueryScore, normalize_query
 __all__ = ["QueryScore", "normalize_query", "update_score_by_url"]
 
 
-def update_score_by_url(pkg: model.Package, ref: Optional[str] = None) -> bool:
+def update_score_by_url(pkg: model.Package, ref: str | None = None) -> bool:
     """Make given package more relevant for the current search query."""
     if tk.request:
         ref = ref or tk.request.referrer