pybotx 0.77.1__tar.gz → 0.77.2__tar.gz

pybotx-0.77.2/.gitlab-ci.yml

@@ -0,0 +1,56 @@
+workflow:
+  rules:
+    - if: '$CI_PIPELINE_SOURCE == "merge_request_event"'
+    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH && $CI_OPEN_MERGE_REQUESTS'
+      when: never
+    - if: '$CI_PIPELINE_SOURCE == "push" && $CI_COMMIT_BRANCH'
+
+stages:
+  - check
+  - package
+
+variables:
+  PYTHON_VERSION: "3.13"
+
+default:
+  image: "python:${PYTHON_VERSION}-bookworm"
+  tags:
+    - docker
+  before_script:
+    - python -m pip install uv
+    - uv sync --locked --dev
+
+test:
+  stage: check
+  parallel:
+    matrix:
+      - PYTHON_VERSION: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+  script:
+    - >-
+      uv run --no-sync ./scripts/test -n 4 --cov-report=xml
+      --junitxml=junit.xml --junit-prefix="py${PYTHON_VERSION}"
+  coverage: '/^TOTAL\s+.*\s+([0-9]+(?:\.[0-9]+)?%)\s*$/'
+  artifacts:
+    reports:
+      junit: junit.xml
+      coverage_report:
+        coverage_format: cobertura
+        path: coverage.xml
+
+lint:
+  stage: check
+  script:
+    - uv run --no-sync ./scripts/lint
+
+docs-lint:
+  stage: check
+  script:
+    - uv run --no-sync bash ./scripts/docs-lint
+
+package:
+  stage: package
+  script:
+    - uv build
+  artifacts:
+    paths:
+      - dist/

{pybotx-0.77.1 → pybotx-0.77.2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.5
 Name: pybotx
-Version: 0.77.1
+Version: 0.77.2
 Summary: A python library for interacting with eXpress BotX API
 Project-URL: Repository, https://github.com/ExpressApp/pybotx
-Author-email: Sidnev Nikolay <nsidnev@ccsteam.ru>, Maxim Gorbachev <mgorbachev@ccsteam.ru>, Alexander Samoylenko <alexandr.samojlenko@ccsteam.ru>, Arseniy Zhiltsov <arseniy.zhiltsov@ccsteam.ru>
+Author: Sidnev Nikolay, Maxim Gorbachev, Alexander Samoylenko, Arseniy Zhiltsov, Aleksandr Osovskii
 License-File: LICENSE
 Requires-Python: <4.0,>=3.10
 Requires-Dist: aiocsv<2,>=1.4.0

{pybotx-0.77.1 → pybotx-0.77.2}/pybotx/bot/bot.py

@@ -4,7 +4,7 @@ from contextlib import AsyncExitStack, asynccontextmanager, contextmanager
 from contextvars import ContextVar, Token
 from datetime import datetime
 from types import SimpleNamespace
-from typing import Any, TypeAlias
+from typing import Any, Literal, TypeAlias
 from uuid import UUID
 
 import aiofiles
@@ -38,6 +38,7 @@ from pybotx.bot.contextvars import (
     trace_id_var,
 )
 from pybotx.bot.exceptions import (
+    AmbiguousBotAccountError,
     AnswerDestinationLookupError,
     RequestHeadersNotProvidedError,
     UnknownBotAccountError,
@@ -409,22 +410,51 @@ class Bot:
             if logging_command:
                 log_incoming_request(raw_bot_command, message="Got command: ")
 
+            account_key = None
             if verify_request:
-                self._verify_request(request_headers, trusted_issuers=trusted_issuers)
+                account_key = self._verify_request(
+                    request_headers,
+                    trusted_issuers=trusted_issuers,
+                )
 
-            try:
-                command_type = raw_bot_command.get("command", {}).get("command_type")
-                if command_type == BotAPICommandTypes.USER:
-                    bot_api_command = BotAPIIncomingMessage.model_validate(raw_bot_command)
-                else:
-                    bot_api_command = TypeAdapter(BotAPISystemEvent).validate_python(
-                        raw_bot_command
+            with self._verified_account_scope(account_key):
+                try:
+                    command_type = raw_bot_command.get("command", {}).get(
+                        "command_type"
+                    )
+                    if command_type == BotAPICommandTypes.USER:
+                        bot_api_command = BotAPIIncomingMessage.model_validate(
+                            raw_bot_command
+                        )
+                    else:
+                        bot_api_command = TypeAdapter(
+                            BotAPISystemEvent
+                        ).validate_python(raw_bot_command)
+                except ValidationError as validation_exc:
+                    raise ValueError("Bot command validation error") from validation_exc
+
+                bot_command = bot_api_command.to_domain(raw_bot_command)
+                if account_key is None:
+                    return self.async_execute_bot_command(bot_command)
+
+                if bot_command.bot.id != account_key.bot_id:
+                    raise UnverifiedRequestError(
+                        "Command bot_id does not match the verified bot account",
+                    )
+
+                verified_account = self._bot_accounts_storage.get_bot_account_by_key(
+                    account_key,
+                )
+                if bot_command.bot.host != verified_account.host:
+                    raise UnverifiedRequestError(
+                        "Command host does not match the verified CTS",
                     )
-            except ValidationError as validation_exc:
-                raise ValueError("Bot command validation error") from validation_exc
 
-            bot_command = bot_api_command.to_domain(raw_bot_command)
-            return self.async_execute_bot_command(bot_command)
+                return self._handler_collector.async_handle_bot_command(
+                    self,
+                    bot_command,
+                    account_key=account_key,
+                )
         finally:
             self._reset_contextvars(context_tokens)
 
@@ -482,20 +512,25 @@ class Bot:
                     message="Got sync smartapp event: ",
                 )
 
+            account_key = None
             if verify_request:
-                self._verify_request(request_headers, trusted_issuers=trusted_issuers)
-
-            try:
-                bot_api_smartapp_event = BotAPISyncSmartAppEvent.model_validate(
-                    raw_smartapp_event
+                account_key = self._verify_request(
+                    request_headers,
+                    trusted_issuers=trusted_issuers,
                 )
-            except ValidationError as validation_exc:
-                raise ValueError(
-                    "Sync smartapp event validation error",
-                ) from validation_exc
 
-            smartapp_event = bot_api_smartapp_event.to_domain(raw_smartapp_event)
-            return await self.sync_execute_smartapp_event(smartapp_event)
+            with self._verified_account_scope(account_key):
+                try:
+                    bot_api_smartapp_event = BotAPISyncSmartAppEvent.model_validate(
+                        raw_smartapp_event
+                    )
+                except ValidationError as validation_exc:
+                    raise ValueError(
+                        "Sync smartapp event validation error",
+                    ) from validation_exc
+
+                smartapp_event = bot_api_smartapp_event.to_domain(raw_smartapp_event)
+                return await self.sync_execute_smartapp_event(smartapp_event)
         finally:
             self._reset_contextvars(context_tokens)
 
@@ -533,20 +568,25 @@ class Bot:
                 status=lambda: pformat_jsonable_obj(query_params),
             )
 
+            account_key = None
             if verify_request:
-                self._verify_request(request_headers, trusted_issuers=trusted_issuers)
-
-            try:
-                bot_api_status_recipient = BotAPIStatusRecipient.model_validate(
-                    query_params
+                account_key = self._verify_request(
+                    request_headers,
+                    trusted_issuers=trusted_issuers,
                 )
-            except ValidationError as exc:
-                raise ValueError("Status request validation error") from exc
 
-            status_recipient = bot_api_status_recipient.to_domain()
+            with self._verified_account_scope(account_key):
+                try:
+                    bot_api_status_recipient = BotAPIStatusRecipient.model_validate(
+                        query_params
+                    )
+                except ValidationError as exc:
+                    raise ValueError("Status request validation error") from exc
+
+                status_recipient = bot_api_status_recipient.to_domain()
 
-            bot_menu = await self.get_status(status_recipient)
-            return build_bot_status_response(bot_menu)
+                bot_menu = await self.get_status(status_recipient)
+                return build_bot_status_response(bot_menu)
         finally:
             self._reset_contextvars(context_tokens)
 
@@ -570,16 +610,20 @@ class Bot:
         try:
             logger.debug("Got callback: {callback}", callback=raw_botx_method_result)
 
+            account_key = None
             if verify_request:
-                self._verify_request(request_headers, trusted_issuers=trusted_issuers)
-
-            callback: BotXMethodCallback = TypeAdapter(
-                BotXMethodCallback
-            ).validate_python(
-                raw_botx_method_result,
-            )
+                account_key = self._verify_request(
+                    request_headers,
+                    trusted_issuers=trusted_issuers,
+                )
+            with self._verified_account_scope(account_key):
+                callback: BotXMethodCallback = TypeAdapter(
+                    BotXMethodCallback
+                ).validate_python(
+                    raw_botx_method_result,
+                )
 
-            await self._callbacks_manager.set_botx_method_callback_result(callback)
+                await self._callbacks_manager.set_botx_method_callback_result(callback)
         finally:
             self._reset_contextvars(context_tokens)
 
@@ -622,6 +666,20 @@ class Bot:
         finally:
             bot_account_key_var.reset(account_key_token)
 
+    @contextmanager
+    def _verified_account_scope(
+        self, account_key: BotAccountKey | None
+    ) -> Iterator[None]:
+        if account_key is None:
+            yield
+            return
+
+        account_key_token = bot_account_key_var.set(account_key)
+        try:
+            yield
+        finally:
+            bot_account_key_var.reset(account_key_token)
+
     def invalidate_account(self, account_key: BotAccountKey) -> None:
         """Discard cached legacy JWTs after registration lifecycle changes."""
         self._bot_accounts_storage.invalidate(account_key)
@@ -1057,13 +1115,16 @@ class Bot:
         self,
         *,
         message: ReplyMessage,
-    ) -> None:
-        """Reply message.
+        api_version: Literal[3, 4] = 4,
+    ) -> UUID | None:
+        """Reply to a message.
 
         :param message: Built outgoing reply message.
+        :param api_version: Use v4 (BotX >= 3.79) by default or deprecated v3.
+        :return: Sync ID of the sent reply for v4, or `None` for v3.
         """
 
-        await self.reply_message(
+        return await self.reply_message(
             bot_id=message.bot_id,
             sync_id=message.sync_id,
             body=message.body,
@@ -1076,6 +1137,7 @@ class Bot:
             stealth_mode=message.stealth_mode,
             send_push=message.send_push,
             ignore_mute=message.ignore_mute,
+            api_version=api_version,
         )
 
     async def reply_message(
@@ -1093,8 +1155,9 @@ class Bot:
         stealth_mode: Missing[bool] = Undefined,
         send_push: Missing[bool] = Undefined,
         ignore_mute: Missing[bool] = Undefined,
-    ) -> None:
-        """Reply on message by `sync_id`.
+        api_version: Literal[3, 4] = 4,
+    ) -> UUID | None:
+        """Reply to a message by `sync_id`.
 
         :param bot_id: Bot which should perform the request.
         :param sync_id: `sync_id` of message to reply on.
@@ -1112,6 +1175,8 @@ class Bot:
             devices.
         :param ignore_mute: (BotX default: False) Ignore mute or dnd (do not
             disturb).
+        :param api_version: Use v4 (BotX >= 3.79) by default or deprecated v3.
+        :return: Sync ID of the sent reply for v4, or `None` for v3.
         """
 
         payload = BotXAPIReplyEventRequestPayload.from_domain(
@@ -1132,7 +1197,7 @@ class Bot:
             self._httpx_client,
             self._bot_accounts_storage,
         )
-        await method.execute(payload)
+        return await method.execute(payload, api_version=api_version)
 
     async def get_message_status(self, *, bot_id: UUID, sync_id: UUID) -> MessageStatus:
         """
@@ -2611,7 +2676,9 @@ class Bot:
             parts = traceparent.split("-")
             if len(parts) >= 4:
                 trace_id = parts[1].lower()
-                if len(trace_id) == 32 and all(char in "0123456789abcdef" for char in trace_id):
+                if len(trace_id) == 32 and all(
+                    char in "0123456789abcdef" for char in trace_id
+                ):
                     return trace_id
 
         b3 = self._get_header_value(request_headers, "b3")
@@ -2678,7 +2745,7 @@ class Bot:
         headers: Mapping[str, str] | None,
         *,
         trusted_issuers: set[str] | None = None,
-    ) -> None:
+    ) -> BotAccountKey:
         if headers is None:
             raise RequestHeadersNotProvidedError
 
@@ -2700,14 +2767,13 @@ class Bot:
         except jwt.DecodeError as decode_exc:
             raise UnverifiedRequestError(decode_exc.args[0]) from decode_exc
         if self._is_v2_payload(token_payload):
-            self._verify_request_v2(token, token_payload, decode_algorithms)
-        else:
-            self._verify_request_v1(
-                token,
-                token_payload,
-                decode_algorithms,
-                trusted_issuers,
-            )
+            return self._verify_request_v2(token, token_payload, decode_algorithms)
+        return self._verify_request_v1(
+            token,
+            token_payload,
+            decode_algorithms,
+            trusted_issuers,
+        )
 
     @staticmethod
     def _is_v2_payload(token_payload: Mapping[str, Any]) -> bool:
@@ -2731,7 +2797,7 @@ class Bot:
         token: str,
         token_payload: Mapping[str, Any],
         decode_algorithms: list[str],
-    ) -> None:
+    ) -> BotAccountKey:
         issuer = token_payload.get("iss")
         if issuer is None:
             raise UnverifiedRequestError('Token is missing the "iss" claim')
@@ -2743,16 +2809,23 @@ class Bot:
         except (TypeError, ValueError) as exc:
             raise UnverifiedRequestError("Invalid issuer") from exc
 
-        try:
-            bot_account = self._bot_accounts_storage.get_bot_account(bot_id)
-        except UnknownBotAccountError as unknown_bot_exc:
-            raise UnverifiedRequestError(unknown_bot_exc.args[0]) from unknown_bot_exc
-
         audience = token_payload.get("aud")
         if not audience or not isinstance(audience, str):
             raise UnverifiedRequestError("Invalid audience parameter was provided.")
+
+        try:
+            account_key = self._bot_accounts_storage.resolve_incoming_account_key(
+                bot_id=bot_id,
+                host=audience,
+            )
+            bot_account = self._bot_accounts_storage.get_bot_account_by_key(account_key)
+        except (AmbiguousBotAccountError, UnknownBotAccountError) as exp:
+            raise UnverifiedRequestError(str(exp)) from exp
+
         if audience != bot_account.host:
-            raise UnverifiedRequestError("Invalid audience parameter was provided.")
+            raise UnverifiedRequestError(
+                "Invalid audience parameter was provided.",
+            )
 
         try:
             jwt.decode(
@@ -2766,13 +2839,15 @@ class Bot:
         except jwt.InvalidTokenError as exc:
             raise UnverifiedRequestError(exc.args[0]) from exc
 
+        return account_key
+
     def _verify_request_v1(
         self,
         token: str,
         token_payload: Mapping[str, Any],
         decode_algorithms: list[str],
         trusted_issuers: set[str] | None,
-    ) -> None:
+    ) -> BotAccountKey:
         audience = token_payload.get("aud")
         if (
             not audience
@@ -2783,9 +2858,55 @@ class Bot:
             raise UnverifiedRequestError("Invalid audience parameter was provided.")
 
         try:
-            bot_account = self._bot_accounts_storage.get_bot_account(UUID(audience[-1]))
-        except UnknownBotAccountError as unknown_bot_exc:
-            raise UnverifiedRequestError(unknown_bot_exc.args[0]) from unknown_bot_exc
+            bot_id = UUID(audience[-1])
+        except (TypeError, ValueError) as exc:
+            raise UnverifiedRequestError(
+                "Invalid audience parameter was provided.",
+            ) from exc
+
+        issuer = token_payload.get("iss")
+        if issuer is None:
+            raise UnverifiedRequestError('Token is missing the "iss" claim')
+
+        if not isinstance(issuer, str):
+            raise UnverifiedRequestError("Invalid issuer")
+
+        try:
+            account_key = self._bot_accounts_storage.resolve_incoming_account_key(
+                bot_id=bot_id,
+                host=issuer,
+            )
+            bot_account = self._bot_accounts_storage.get_bot_account_by_key(
+                account_key,
+            )
+        except (UnknownBotAccountError, AmbiguousBotAccountError) as exc:
+            if not trusted_issuers or issuer not in trusted_issuers:
+                raise UnverifiedRequestError(str(exc)) from exc
+
+            try:
+                bot_account = self._bot_accounts_storage.get_bot_account(bot_id)
+            except (UnknownBotAccountError, AmbiguousBotAccountError) as fallback_exc:
+                raise UnverifiedRequestError(str(fallback_exc)) from fallback_exc
+
+            fallback_account_key = bot_account.account_key
+            if fallback_account_key is not None:
+                account_key = fallback_account_key
+            else:
+                try:
+                    account_key = (
+                        self._bot_accounts_storage.resolve_incoming_account_key(
+                            bot_id=bot_id,
+                            host=bot_account.host,
+                        )
+                    )
+                    bot_account = self._bot_accounts_storage.get_bot_account_by_key(
+                        account_key,
+                    )
+                except (UnknownBotAccountError, AmbiguousBotAccountError):
+                    account_key = BotAccountKey(
+                        server_id=bot_account.host,
+                        bot_id=bot_id,
+                    )
 
         try:
             jwt.decode(
@@ -2802,14 +2923,12 @@ class Bot:
         except jwt.InvalidTokenError as exc:
             raise UnverifiedRequestError(exc.args[0]) from exc
 
-        issuer = token_payload.get("iss")
-        if issuer is None:
-            raise UnverifiedRequestError('Token is missing the "iss" claim')
-
         if issuer != bot_account.host:
             if not trusted_issuers or issuer not in trusted_issuers:
                 raise UnverifiedRequestError("Invalid issuer")
 
+        return account_key
+
     @staticmethod
     def _build_main_collector(
         collectors: Sequence[HandlerCollector],

{pybotx-0.77.1 → pybotx-0.77.2}/pybotx/bot/bot_account_provider.py

@@ -58,7 +58,7 @@ class StaticBotAccountProvider:
         host: str | None,
     ) -> BotAccountKey:
         account = self.get_account_by_bot_id(bot_id)
-        return BotAccountKey(server_id=host or account.host, bot_id=bot_id)
+        return BotAccountKey(server_id=account.host, bot_id=bot_id)
 
     def iter_bot_accounts(self) -> Iterator[BotAccountWithSecret]:
         yield from self._bot_accounts

{pybotx-0.77.1 → pybotx-0.77.2}/pybotx/bot/bot_accounts_storage.py

@@ -60,12 +60,23 @@ class BotAccountsStorage:
             return self._account_provider.get_account(account_key)
         return self._account_provider.get_account_by_bot_id(bot_id)
 
+    def get_bot_account_by_key(
+        self,
+        account_key: BotAccountKey,
+    ) -> BotAccountWithSecret:
+        return self._account_provider.get_account(account_key)
+
     def resolve_incoming_account_key(
         self,
         *,
         bot_id: UUID,
         host: str | None,
     ) -> BotAccountKey:
+        if host is None:
+            current_account_key = self._get_current_account_key(bot_id)
+            if current_account_key is not None:
+                return current_account_key
+
         return self._account_provider.resolve_incoming_account_key(
             bot_id=bot_id,
             host=host,

{pybotx-0.77.1 → pybotx-0.77.2}/pybotx/client/events_api/reply_event.py

@@ -100,13 +100,30 @@ class BotXAPIReplyEventRequestPayload(UnverifiedPayloadBaseModel):
         )
 
 
+class BotXAPIReplyEventV3ResponsePayload(VerifiedPayloadBaseModel):
+    status: Literal["ok"]
+
+
+class BotXAPIReplyEventResult(VerifiedPayloadBaseModel):
+    sync_id: UUID
+
+
 class BotXAPIReplyEventResponsePayload(VerifiedPayloadBaseModel):
     status: Literal["ok"]
+    result: BotXAPIReplyEventResult
 
 
 class ReplyEventMethod(AuthorizedBotXMethod):
-    async def execute(self, payload: BotXAPIReplyEventRequestPayload) -> None:
-        path = "/api/v3/botx/events/reply_event"
+    async def execute(
+        self,
+        payload: BotXAPIReplyEventRequestPayload,
+        *,
+        api_version: Literal[3, 4] = 4,
+    ) -> UUID | None:
+        if not isinstance(api_version, int) or api_version not in (3, 4):
+            raise ValueError(f"Unsupported reply event API version: {api_version}")
+
+        path = f"/api/v{api_version}/botx/events/reply_event"
 
         response = await self._botx_method_call(
             "POST",
@@ -114,7 +131,15 @@ class ReplyEventMethod(AuthorizedBotXMethod):
             json=payload.jsonable_dict(),
         )
 
-        self._verify_and_extract_api_model(
+        if api_version == 3:
+            self._verify_and_extract_api_model(
+                BotXAPIReplyEventV3ResponsePayload,
+                response,
+            )
+            return None
+
+        api_model = self._verify_and_extract_api_model(
             BotXAPIReplyEventResponsePayload,
             response,
         )
+        return api_model.result.sync_id

{pybotx-0.77.1 → pybotx-0.77.2}/pyproject.toml

@@ -1,12 +1,13 @@
 [project]
 name = "pybotx"
-version = "0.77.1"
+version = "0.77.2"
 description = "A python library for interacting with eXpress BotX API"
 authors = [
-    { name = "Sidnev Nikolay", email = "nsidnev@ccsteam.ru" },
-    { name = "Maxim Gorbachev", email = "mgorbachev@ccsteam.ru" },
-    { name = "Alexander Samoylenko", email = "alexandr.samojlenko@ccsteam.ru" },
-    { name = "Arseniy Zhiltsov", email = "arseniy.zhiltsov@ccsteam.ru" },
+    { name = "Sidnev Nikolay" },
+    { name = "Maxim Gorbachev" },
+    { name = "Alexander Samoylenko" },
+    { name = "Arseniy Zhiltsov" },
+    { name = "Aleksandr Osovskii" },
 ]
 readme = "README.md"
 requires-python = ">=3.10,<4.0"