Merge pull request #47 from sanders41/decorator

Added decorator to check for errors in status

Author: sanders41

README.md

@@ -291,6 +291,25 @@ SearchResults(
   response = await index.update_documents_from_file_auto_batch("/path/to/file.json")
   ```
 
+* status_check decorator:
+
+  ```py
+  from meilisearch import Client
+  from meilisearch_status_check_decorator import status_check
+
+  index = Client("http://localhost:7700", "masterKey").index("test")
+
+  @status_check(index=index)
+  async def bad_insert():
+      await index.add_documents(documents)
+  ```
+
+  If the adding of documents fails something similar to the folling will be printed:
+
+  ```sh
+  FAILED: [UpdateStatus(status='failed', update_id=0, update_type={'name': 'DocumentsAddition'}, enqueued_at=datetime.datetime(2021, 9, 2, 22, 47, 42, 234902, tzinfo=datetime.timezone.utc), duration=0.0, processed_at=datetime.datetime(2021, 9, 2, 22, 47, 42, 236647, tzinfo=datetime.timezone.utc), error=None)]
+  ```
+
 ## Compatibility with MeiliSearch
 
 This package only guarantees the compatibility with [version v0.21.0 of MeiliSearch](https://github.com/meilisearch/MeiliSearch/releases/tag/v0.21.0).

meilisearch_python_async/decorators.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from asyncio import sleep
+from functools import wraps
+from typing import Any, Callable
+
+from meilisearch_python_async.index import Index
+
+
+def status_check(index: Index) -> Callable:
+    def decorator_status_check(func: Callable) -> Callable:
+        @wraps(func)
+        async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            initial_stats = await index.get_all_update_status()
+            initial_status_count = 0 if not initial_stats else len(initial_stats)
+
+            result = await func(*args, **kwargs)
+
+            errors = False
+            all_status = await index.get_all_update_status()
+
+            while True:
+                if not all_status or not [
+                    x.status for x in all_status if x.status not in ["processed", "failed"]
+                ]:
+                    break
+
+                await sleep(1)
+                all_status = await index.get_all_update_status()
+
+            if all_status:
+                if len(all_status) == initial_status_count + 1:
+                    status = all_status[-1:]
+                    if status[0].status == "failed":
+                        errors = True
+                else:
+                    status = all_status[initial_status_count:]
+                    for s in status:
+                        if s.status == "failed":
+                            errors = True
+
+            if errors:
+                print(f"FAILED: {status}")  # noqa: T001
+
+            return result
+
+        return wrapper
+
+    return decorator_status_check

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "meilisearch-python-async"
-version = "0.13.1"
+version = "0.14.0"
 description = "A Python async client for the MeiliSearch API"
 authors = ["Paul Sanders <[email protected]>"]
 license = "MIT"

tests/integration/test_documents.py

@@ -3,6 +3,7 @@
 
 import pytest
 
+from meilisearch_python_async.decorators import status_check
 from meilisearch_python_async.errors import MeiliSearchApiError, MeiliSearchError, PayloadTooLarge
 
 
@@ -24,6 +25,18 @@ def generate_test_movies(num_movies=50):
     return movies
 
 
+@pytest.fixture
+def add_document():
+    return {
+        "id": "1",
+        "title": f"{'a' * 999999}",
+        "poster": f"{'a' * 999999}",
+        "overview": f"{'a' * 999999}",
+        "release_date": 1551830399,
+        "genre": f"{'a' * 999999}",
+    }
+
+
 @pytest.mark.asyncio
 async def test_get_documents_default(empty_index):
     index = await empty_index()
@@ -43,16 +56,114 @@ async def test_add_documents(primary_key, expected_primary_key, empty_index, sma
     assert update.status == "processed"
 
 
-@pytest.fixture
-def add_document():
-    return {
-        "id": "1",
-        "title": f"{'a' * 999999}",
-        "poster": f"{'a' * 999999}",
-        "overview": f"{'a' * 999999}",
-        "release_date": 1551830399,
-        "genre": f"{'a' * 999999}",
-    }
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "docs, expected_fail, expected_indexed",
+    [
+        (
+            [
+                {
+                    "id": 1,
+                    "name": "test 1",
+                },
+                {
+                    "id": 2,
+                    "name": "test 2",
+                },
+            ],
+            False,
+            2,
+        ),
+        (
+            [
+                {
+                    "name": "test 1",
+                },
+                {
+                    "name": "test 2",
+                },
+            ],
+            True,
+            0,
+        ),
+    ],
+)
+async def test_status_check_decorator(docs, expected_fail, expected_indexed, empty_index, capfd):
+    index = await empty_index()
+
+    @status_check(index=index)
+    async def fn():
+        await index.add_documents(docs)
+
+    await fn()
+    stats = await index.get_stats()
+    assert stats.number_of_documents == expected_indexed
+
+    out, _ = capfd.readouterr()
+
+    fail_text = "status='failed'"
+
+    if expected_fail:
+        assert fail_text in out
+    else:
+        assert fail_text not in out
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "docs, expected_fail, expected_indexed, expected_messages",
+    [
+        (
+            [
+                {
+                    "id": 1,
+                    "name": "test 1",
+                },
+                {
+                    "id": 2,
+                    "name": "test 2",
+                },
+            ],
+            False,
+            2,
+            0,
+        ),
+        (
+            [
+                {
+                    "name": "test 1",
+                },
+                {
+                    "name": "test 2",
+                },
+            ],
+            True,
+            0,
+            2,
+        ),
+    ],
+)
+async def test_status_check_decorator_batch(
+    docs, expected_fail, expected_indexed, expected_messages, empty_index, capfd
+):
+    index = await empty_index()
+
+    @status_check(index=index)
+    async def fn():
+        await index.add_documents_in_batches(docs, batch_size=1)
+
+    await fn()
+    stats = await index.get_stats()
+    assert stats.number_of_documents == expected_indexed
+
+    out, _ = capfd.readouterr()
+
+    fail_text = "status='failed'"
+
+    if expected_fail:
+        assert out.count(fail_text) == expected_messages
+    else:
+        assert fail_text not in out
 
 
 @pytest.mark.asyncio