Merge branch 'master' into flow_api-to-flow

Author: cibere

docs/whats_new.rst

@@ -14,6 +14,8 @@ Breaking Changes
     - Remove ``flogin.errors.SettingNotFound``
 - Rewrite the CLI commands
 - Remove ``flogin.conditions.MultiCondition`` in favor of :class:`flogin.conditions.AnyCondition` and :class:`flogin.conditions.AllCondition`
+- Remove `Query.from_json`
+- For :func:`flogin.testing.plugin_tester.PluginTester.test_query`, switch from receiving a query object to taking kwargs that will be used to make a query object
 - Rename the ``flogin.flow_api`` directory to ``flogin.flow``
     - Rename ``flogin.flow_api.client.py`` to ``flogin.flow.api.py``
 
@@ -33,6 +35,8 @@ New Features
 - Make :attr:`flogin.jsonrpc.results.Result.title` optional
 - Add :class:`flogin.conditions.AnyCondition`
 - Add :class:`flogin.conditions.AllCondition`
+- Add :func:`flogin.query.Query.update_results`
+- Add :func:`flogin.query.Query.update`
 - Add ``flogin.flow.settings.py``
     - Add :class:`flogin.flow.settings.CustomFileManager`
     - Add :class:`flogin.flow.settings.CustomBrowser`

flogin/default_events.py

@@ -26,7 +26,7 @@ async def on_error(
 
 def get_default_events(plugin: Plugin[Any]) -> dict[str, Callable[..., Awaitable[Any]]]:
     def on_query(data: dict[str, Any], raw_settings: dict[str, Any]):
-        query = Query.from_json(data)
+        query = Query(data, plugin)
         if plugin._settings_are_populated is False:
             LOG.info(f"Settings have not been populated yet, creating a new instance")
             plugin._settings_are_populated = True

flogin/query.py

@@ -1,12 +1,25 @@
 from __future__ import annotations
 
-from typing import Any, Generic, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, TypedDict, TypeVar
+
+from ._types import PluginT
+from .utils import MISSING
+
+if TYPE_CHECKING:
+    from .jsonrpc.results import Result
 
 T = TypeVar("T")
 
 __all__ = ("Query",)
 
 
+class RawQuery(TypedDict):
+    search: str
+    rawQuery: str
+    isReQuery: bool
+    actionKeyword: str
+
+
 class Query(Generic[T]):
     r"""This class represents the query data sent from flow launcher
 
@@ -34,24 +47,10 @@ class Query(Generic[T]):
         The keyword used to initiate the query
     """
 
-    def __init__(
-        self, *, raw_text: str, is_requery: bool = False, text: str, keyword: str
-    ) -> None:
+    def __init__(self, data: RawQuery, plugin: PluginT) -> None:
         self.__search_condition_data: T | None = None
-
-        self.raw_text = raw_text
-        self.is_requery = is_requery
-        self.text = text
-        self.keyword = keyword
-
-    @classmethod
-    def from_json(cls: type[Query], data: dict[str, Any]) -> Query:
-        return cls(
-            raw_text=data["rawQuery"],
-            is_requery=data["isReQuery"],
-            text=data["search"],
-            keyword=data["actionKeyword"],
-        )
+        self._data = data
+        self.plugin = plugin
 
     @property
     def condition_data(self) -> T | None:
@@ -62,6 +61,22 @@ def condition_data(self) -> T | None:
     def condition_data(self, value: T) -> None:
         self.__search_condition_data = value
 
+    @property
+    def is_requery(self) -> bool:
+        return self._data["isReQuery"]
+
+    @property
+    def keyword(self) -> str:
+        return self._data["actionKeyword"]
+
+    @property
+    def raw_text(self) -> str:
+        return self._data["rawQuery"]
+
+    @property
+    def text(self) -> str:
+        return self._data["search"]
+
     def __eq__(self, other: Any) -> bool:
         return (
             isinstance(other, Query)
@@ -74,3 +89,61 @@ def __hash__(self) -> int:
 
     def __repr__(self) -> str:
         return f"<Query {self.raw_text=} {self.text=} {self.keyword=} {self.is_requery=} {self.condition_data=}>"
+
+    async def update_results(self, results: list[Result]) -> None:
+        r"""|coro|
+
+        Tells flow to change the results shown to the user, using the query from this query object.
+
+        This method provides quick acess to :func:`flogin.flow_api.client.FlowLauncherAPI.update_results`. Because of that, this method will only take affect if the user has not changed the query.
+
+        Parameters
+        ----------
+        results: list[:class:`~flogin.jsonrpc.results.Result`]
+            The new results
+
+        Returns
+        -------
+        None
+        """
+
+        return await self.plugin.api.update_results(self.raw_text, results)
+
+    async def update(
+        self, *, text: str, keyword: str | None = MISSING, requery: bool = False
+    ) -> None:
+        r"""|coro|
+
+        Applies updates to the query with flow, and to this object.
+
+        This method provides quick acess to :func:`flogin.flow_api.client.FlowLauncherAPI.change_query`
+
+        Parameters
+        ----------
+        text: :class:`str`
+            The text that will be used with the query.
+        keyword: :class:`str`
+            The keyword that will be used with the query. Defaults to the pre-existing value of :attr:`Query.keyword`. Set this to ``None`` or `"*"` for no keyword to be used.
+        requery: :class:`bool`
+            Whether or not to re-send a query request in the event that the new query is the same as the current query
+
+        Returns
+        --------
+        None
+        """
+
+        if keyword is MISSING:
+            keyword = self.keyword
+
+        if keyword is None or keyword == "*":
+            raw_text = text
+            self._data["actionKeyword"] = "*"
+        else:
+            raw_text = f"{keyword} {text}"
+            self._data["actionKeyword"] = keyword
+
+        self._data["rawQuery"] = raw_text
+        self._data["search"] = text
+        self._data["isReQuery"] = requery
+
+        return await self.plugin.api.change_query(raw_text, requery=requery)

flogin/testing/plugin_tester.py

@@ -9,14 +9,14 @@
 
 from .._types import PluginT, RawSettings
 from ..flow.plugin_metadata import PluginMetadata
+from ..query import Query
 from ..settings import Settings
 from ..utils import MISSING
 from .filler import FillerObject
 
 if TYPE_CHECKING:
     from ..jsonrpc.responses import QueryResponse
     from ..jsonrpc.results import Result
-    from ..query import Query
 
 API_FILLER_TEXT = "FlowLauncherAPI is unavailable during testing. Consider passing the 'flow_api_client' arg into PluginTester to impliment your own flow api client."
 CHARACTERS = "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLLZXCVBNM1234567890"
@@ -88,7 +88,12 @@ def set_flow_api_client(self, flow_api_client: Any = MISSING) -> None:
         self.plugin.metadata._flow_api = flow_api_client
 
     async def test_query(
-        self, query: Query, *, settings: Settings | RawSettings | None = MISSING
+        self,
+        text: str,
+        *,
+        keyword: str = "*",
+        is_requery: bool = False,
+        settings: Settings | RawSettings | None = MISSING,
     ) -> QueryResponse:
         r"""|coro|
 
@@ -116,6 +121,16 @@ async def test_query(
             self.plugin.settings = settings
             self.plugin._settings_are_populated = True
 
+        query = Query(
+            {
+                "rawQuery": f"{keyword} {text}",
+                "search": text,
+                "actionKeyword": keyword,
+                "isReQuery": is_requery,
+            },
+            self.plugin,
+        )
+
         coro = self.plugin.process_search_handlers(query)
 
         if coro is None:

tests/test_conditions.py

@@ -10,16 +10,33 @@
     Query,
     RegexCondition,
 )
+from flogin.testing.filler import FillerObject
+
+
+def _create_query(text: str, plugin, keyword: str = "*", is_requery: bool = False):
+    return Query(
+        {
+            "rawQuery": f"{keyword} {text}",
+            "search": text,
+            "actionKeyword": keyword,
+        },
+        plugin,
+    )
+
+
+@pytest.fixture
+def plugin():
+    return FillerObject(f"Fake plugin object provided")
 
 
 @pytest.fixture
-def yes_query():
-    return Query(raw_text="bar foo", text="foo", keyword="bar")
+def yes_query(plugin):
+    return _create_query(text="foo", keyword="bar", plugin=plugin)
 
 
 @pytest.fixture
-def no_query():
-    return Query(raw_text="car foo", text="apple", keyword="car")
+def no_query(plugin):
+    return _create_query(text="apple", keyword="car", plugin=plugin)
 
 
 @pytest.fixture(params=[0, 1])

tests/test_search_handlers.py

@@ -19,14 +19,6 @@ def tester(plugin, metadata):
     return PluginTester(plugin, metadata=metadata)
 
 
-@pytest.fixture
-def query():
-    txt = "bar"
-    keyword = "foo"
-
-    return Query(raw_text=f"{txt} {keyword}", text=txt, keyword=keyword)
-
-
 class ReturnSingleResultHandler(SearchHandler):
     async def callback(self, query: Query):
         return Result("Title")
@@ -75,7 +67,7 @@ def handler(plugin: Plugin, request: pytest.FixtureRequest):
 
 
 @pytest.mark.asyncio
-async def test_handler_result(tester: PluginTester, query: Query):
-    response = await tester.test_query(query)
+async def test_handler_result(tester: PluginTester):
+    response = await tester.test_query("bar", keyword="foo")
     result = response.results[0]
     assert result.title == "Title"