feat(analytics): add async support for analytics operations

- add async tests for analytics functionality
- remove future annotations imports from test files

Author: tharropoulos

src/typesense/async_analytics.py

@@ -0,0 +1,14 @@
+"""Client for Typesense Analytics module (async)."""
+
+from typesense.async_analytics_events import AsyncAnalyticsEvents
+from typesense.async_analytics_rules import AsyncAnalyticsRules
+from typesense.async_api_call import AsyncApiCall
+
+
+class AsyncAnalytics:
+    """Client for v30 Analytics endpoints (async)."""
+
+    def __init__(self, api_call: AsyncApiCall) -> None:
+        self.api_call = api_call
+        self.rules = AsyncAnalyticsRules(api_call)
+        self.events = AsyncAnalyticsEvents(api_call)

src/typesense/async_analytics_events.py

@@ -0,0 +1,71 @@
+"""Client for Analytics events and status operations (async)."""
+
+import sys
+
+if sys.version_info >= (3, 11):
+    import typing
+else:
+    import typing_extensions as typing
+
+from typesense.async_api_call import AsyncApiCall
+from typesense.types.analytics import (
+    AnalyticsEvent as AnalyticsEventSchema,
+    AnalyticsEventCreateResponse,
+    AnalyticsEventsResponse,
+    AnalyticsStatus,
+)
+
+
+class AsyncAnalyticsEvents:
+    events_path: typing.Final[str] = "/analytics/events"
+    flush_path: typing.Final[str] = "/analytics/flush"
+    status_path: typing.Final[str] = "/analytics/status"
+
+    def __init__(self, api_call: AsyncApiCall) -> None:
+        self.api_call = api_call
+
+    async def create(self, event: AnalyticsEventSchema) -> AnalyticsEventCreateResponse:
+        response: AnalyticsEventCreateResponse = await self.api_call.post(
+            AsyncAnalyticsEvents.events_path,
+            body=event,
+            as_json=True,
+            entity_type=AnalyticsEventCreateResponse,
+        )
+        return response
+
+    async def retrieve(
+        self,
+        *,
+        user_id: str,
+        name: str,
+        n: int,
+    ) -> AnalyticsEventsResponse:
+        params: typing.Dict[str, typing.Union[str, int]] = {
+            "user_id": user_id,
+            "name": name,
+            "n": n,
+        }
+        response: AnalyticsEventsResponse = await self.api_call.get(
+            AsyncAnalyticsEvents.events_path,
+            params=params,
+            as_json=True,
+            entity_type=AnalyticsEventsResponse,
+        )
+        return response
+
+    async def flush(self) -> AnalyticsEventCreateResponse:
+        response: AnalyticsEventCreateResponse = await self.api_call.post(
+            AsyncAnalyticsEvents.flush_path,
+            body={},
+            as_json=True,
+            entity_type=AnalyticsEventCreateResponse,
+        )
+        return response
+
+    async def status(self) -> AnalyticsStatus:
+        response: AnalyticsStatus = await self.api_call.get(
+            AsyncAnalyticsEvents.status_path,
+            as_json=True,
+            entity_type=AnalyticsStatus,
+        )
+        return response

src/typesense/async_analytics_rule.py

@@ -0,0 +1,31 @@
+"""Per-rule client for Analytics rules operations (async)."""
+
+from typesense.async_api_call import AsyncApiCall
+from typesense.types.analytics import AnalyticsRuleSchema
+
+
+class AsyncAnalyticsRule:
+    def __init__(self, api_call: AsyncApiCall, rule_name: str) -> None:
+        self.api_call = api_call
+        self.rule_name = rule_name
+
+    @property
+    def _endpoint_path(self) -> str:
+        from typesense.async_analytics_rules import AsyncAnalyticsRules
+
+        return "/".join([AsyncAnalyticsRules.resource_path, self.rule_name])
+
+    async def retrieve(self) -> AnalyticsRuleSchema:
+        response: AnalyticsRuleSchema = await self.api_call.get(
+            self._endpoint_path,
+            as_json=True,
+            entity_type=AnalyticsRuleSchema,
+        )
+        return response
+
+    async def delete(self) -> AnalyticsRuleSchema:
+        response: AnalyticsRuleSchema = await self.api_call.delete(
+            self._endpoint_path,
+            entity_type=AnalyticsRuleSchema,
+        )
+        return response

src/typesense/async_analytics_rules.py

@@ -0,0 +1,62 @@
+"""Client for Analytics rules collection operations (async)."""
+
+import sys
+
+if sys.version_info >= (3, 11):
+    import typing
+else:
+    import typing_extensions as typing
+
+from typesense.async_analytics_rule import AsyncAnalyticsRule
+from typesense.async_api_call import AsyncApiCall
+from typesense.types.analytics import (
+    AnalyticsRuleCreate,
+    AnalyticsRuleSchema,
+    AnalyticsRuleUpdate,
+)
+
+
+class AsyncAnalyticsRules(object):
+    resource_path: typing.Final[str] = "/analytics/rules"
+
+    def __init__(self, api_call: AsyncApiCall) -> None:
+        self.api_call = api_call
+        self.rules: typing.Dict[str, AsyncAnalyticsRule] = {}
+
+    def __getitem__(self, rule_name: str) -> AsyncAnalyticsRule:
+        if rule_name not in self.rules:
+            self.rules[rule_name] = AsyncAnalyticsRule(self.api_call, rule_name)
+        return self.rules[rule_name]
+
+    async def create(self, rule: AnalyticsRuleCreate) -> AnalyticsRuleSchema:
+        response: AnalyticsRuleSchema = await self.api_call.post(
+            AsyncAnalyticsRules.resource_path,
+            body=rule,
+            as_json=True,
+            entity_type=AnalyticsRuleSchema,
+        )
+        return response
+
+    async def retrieve(
+        self, *, rule_tag: typing.Union[str, None] = None
+    ) -> typing.List[AnalyticsRuleSchema]:
+        params: typing.Dict[str, str] = {}
+        if rule_tag:
+            params["rule_tag"] = rule_tag
+        response: typing.List[AnalyticsRuleSchema] = await self.api_call.get(
+            AsyncAnalyticsRules.resource_path,
+            params=params if params else None,
+            as_json=True,
+            entity_type=typing.List[AnalyticsRuleSchema],
+        )
+        return response
+
+    async def upsert(
+        self, rule_name: str, update: AnalyticsRuleUpdate
+    ) -> AnalyticsRuleSchema:
+        response: AnalyticsRuleSchema = await self.api_call.put(
+            "/".join([AsyncAnalyticsRules.resource_path, rule_name]),
+            body=update,
+            entity_type=AnalyticsRuleSchema,
+        )
+        return response

tests/analytics_events_test.py

@@ -1,10 +1,10 @@
 """Tests for Analytics events endpoints (client.analytics.events)."""
 
-from __future__ import annotations
-
 import pytest
 
 from tests.utils.version import is_v30_or_above
+from typesense.async_analytics_events import AsyncAnalyticsEvents
+from typesense.async_analytics_rules import AsyncAnalyticsRules
 from typesense.client import Client
 from typesense.types.analytics import AnalyticsEvent
 
@@ -127,3 +127,82 @@ def test_acutal_retrieve_events(
 def test_acutal_flush(actual_client: Client, delete_all: None) -> None:
     resp = actual_client.analytics.events.flush()
     assert resp["ok"] in [True, False]
+
+
+async def test_actual_create_event_async(
+    actual_async_analytics_rules: AsyncAnalyticsRules,
+    actual_async_analytics_events: AsyncAnalyticsEvents,
+    delete_all: None,
+    create_collection: None,
+    delete_all_analytics_rules: None,
+) -> None:
+    await actual_async_analytics_rules.create(
+        {
+            "name": "company_analytics_rule",
+            "type": "log",
+            "collection": "companies",
+            "event_type": "click",
+            "params": {},
+        }
+    )
+    event: AnalyticsEvent = {
+        "name": "company_analytics_rule",
+        "event_type": "query",
+        "data": {
+            "user_id": "user-1",
+            "doc_id": "apple",
+        },
+    }
+    resp = await actual_async_analytics_events.create(event)
+    assert resp["ok"] is True
+    await actual_async_analytics_rules["company_analytics_rule"].delete()
+
+
+async def test_status_async(
+    actual_async_analytics_events: AsyncAnalyticsEvents,
+    delete_all: None,
+) -> None:
+    status = await actual_async_analytics_events.status()
+    assert isinstance(status, dict)
+
+
+async def test_retrieve_events_async(
+    actual_async_analytics_rules: AsyncAnalyticsRules,
+    actual_async_analytics_events: AsyncAnalyticsEvents,
+    delete_all: None,
+    create_collection: None,
+    delete_all_analytics_rules: None,
+) -> None:
+    await actual_async_analytics_rules.create(
+        {
+            "name": "company_analytics_rule",
+            "type": "log",
+            "collection": "companies",
+            "event_type": "click",
+            "params": {},
+        }
+    )
+    event: AnalyticsEvent = {
+        "name": "company_analytics_rule",
+        "event_type": "query",
+        "data": {
+            "user_id": "user-1",
+            "doc_id": "apple",
+        },
+    }
+    resp = await actual_async_analytics_events.create(event)
+    assert resp["ok"] is True
+    result = await actual_async_analytics_events.retrieve(
+        user_id="user-1",
+        name="company_analytics_rule",
+        n=10,
+    )
+    assert "events" in result
+
+
+async def test_actual_flush_async(
+    actual_async_analytics_events: AsyncAnalyticsEvents,
+    delete_all: None,
+) -> None:
+    resp = await actual_async_analytics_events.flush()
+    assert resp["ok"] in [True, False]

tests/analytics_rule_test.py

@@ -1,13 +1,12 @@
 """Unit tests for per-rule AnalyticsRule operations."""
 
-from __future__ import annotations
-
 import pytest
 
 from tests.utils.version import is_v30_or_above
 from typesense.client import Client
 from typesense.analytics_rule import AnalyticsRule
 from typesense.analytics_rules import AnalyticsRules
+from typesense.async_analytics_rules import AsyncAnalyticsRules
 
 
 pytestmark = pytest.mark.skipif(
@@ -41,3 +40,23 @@ def test_actual_rule_delete(
 ) -> None:
     resp = actual_analytics_rules["company_analytics_rule"].delete()
     assert resp["name"] == "company_analytics_rule"
+
+
+async def test_actual_rule_retrieve_async(
+    actual_async_analytics_rules: AsyncAnalyticsRules,
+    delete_all: None,
+    delete_all_analytics_rules: None,
+    create_analytics_rule: None,
+) -> None:
+    resp = await actual_async_analytics_rules["company_analytics_rule"].retrieve()
+    assert resp["name"] == "company_analytics_rule"
+
+
+async def test_actual_rule_delete_async(
+    actual_async_analytics_rules: AsyncAnalyticsRules,
+    delete_all: None,
+    delete_all_analytics_rules: None,
+    create_analytics_rule: None,
+) -> None:
+    resp = await actual_async_analytics_rules["company_analytics_rule"].delete()
+    assert resp["name"] == "company_analytics_rule"

tests/analytics_rules_test.py

@@ -8,6 +8,8 @@
 from typesense.client import Client
 from typesense.analytics_rules import AnalyticsRules
 from typesense.analytics_rule import AnalyticsRule
+from typesense.async_api_call import AsyncApiCall
+from typesense.async_analytics_rules import AsyncAnalyticsRules
 from typesense.types.analytics import AnalyticsRuleCreate
 
 
@@ -82,3 +84,68 @@ def test_actual_retrieve(
     rules = actual_analytics_rules.retrieve()
     assert isinstance(rules, list)
     assert any(r.get("name") == "company_analytics_rule" for r in rules)
+
+
+def test_rules_init_async(fake_async_api_call: AsyncApiCall) -> None:
+    from typesense.async_analytics_rules import AsyncAnalyticsRules
+
+    rules = AsyncAnalyticsRules(fake_async_api_call)
+    assert rules.rules == {}
+
+
+def test_rule_getitem_async(fake_async_api_call: AsyncApiCall) -> None:
+    from typesense.async_analytics_rules import AsyncAnalyticsRules
+    from typesense.async_analytics_rule import AsyncAnalyticsRule
+
+    rules = AsyncAnalyticsRules(fake_async_api_call)
+    rule = rules["company_analytics_rule"]
+    assert isinstance(rule, AsyncAnalyticsRule)
+    assert rule._endpoint_path == "/analytics/rules/company_analytics_rule"
+
+
+async def test_actual_create_async(
+    actual_async_analytics_rules: AsyncAnalyticsRules,
+    delete_all: None,
+    delete_all_analytics_rules: None,
+    create_collection: None,
+    create_query_collection: None,
+) -> None:
+    body: AnalyticsRuleCreate = {
+        "name": "company_analytics_rule",
+        "type": "nohits_queries",
+        "collection": "companies",
+        "event_type": "search",
+        "params": {"destination_collection": "companies_queries", "limit": 1000},
+    }
+    resp = await actual_async_analytics_rules.create(rule=body)
+    assert resp["name"] == "company_analytics_rule"
+    assert resp["params"]["destination_collection"] == "companies_queries"
+
+
+async def test_actual_update_async(
+    actual_async_analytics_rules: AsyncAnalyticsRules,
+    delete_all: None,
+    delete_all_analytics_rules: None,
+    create_analytics_rule: None,
+) -> None:
+    resp = await actual_async_analytics_rules.upsert(
+        "company_analytics_rule",
+        {
+            "params": {
+                "destination_collection": "companies_queries",
+                "limit": 500,
+            },
+        },
+    )
+    assert resp["name"] == "company_analytics_rule"
+
+
+async def test_actual_retrieve_async(
+    actual_async_analytics_rules: AsyncAnalyticsRules,
+    delete_all: None,
+    delete_all_analytics_rules: None,
+    create_analytics_rule: None,
+) -> None:
+    rules = await actual_async_analytics_rules.retrieve()
+    assert isinstance(rules, list)
+    assert any(r.get("name") == "company_analytics_rule" for r in rules)