mmar-mcli 1.0.6__tar.gz

mmar_mcli-1.0.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AIRI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mmar_mcli-1.0.6/PKG-INFO

@@ -0,0 +1,29 @@
+Metadata-Version: 2.4
+Name: mmar-mcli
+Version: 1.0.6
+Summary: Client to Maestro
+Keywords: 
+Author: tagin
+Author-email: tagin <tagin@airi.net>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Documentation
+Classifier: Topic :: Software Development
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
+Requires-Dist: aiohttp==3.12.15
+Requires-Dist: loguru==0.7.3
+Requires-Dist: mmar-mapi~=1.2.5
+Requires-Dist: mmar-utils~=1.1.3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# MMAR Maestro Client

mmar_mcli-1.0.6/README.md

@@ -0,0 +1 @@
+# MMAR Maestro Client

mmar_mcli-1.0.6/pyproject.toml

@@ -0,0 +1,69 @@
+[project]
+name = "mmar-mcli"
+# dynamic version is not supported yet on uv_build
+version = "1.0.6"
+description = "Client to Maestro"
+authors = [{name = "tagin", email = "tagin@airi.net"}]
+license = "MIT"
+license-files = ["LICENSE"]
+readme = "README.md"
+requires-python = ">=3.12"
+keywords = []
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Documentation",
+    "Topic :: Software Development",
+    "Topic :: Utilities",
+    "Typing :: Typed",
+]
+dependencies = [
+    "aiohttp==3.12.15",
+    "loguru==0.7.3",
+
+    "mmar_mapi~=1.2.5",
+    "mmar_utils~=1.1.3",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.14,<0.9.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "mmar_mcli"
+source-exclude = [".ruff_cache"]
+
+[dependency-groups]
+ci = [
+    "ruff>=0.4",
+    "pytest>=8.2",
+    "pytest-asyncio>=1.0.0",
+]
+
+[tool.uv]
+default-groups = ["ci"]
+
+[tool.ruff]
+line-length = 120
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[pytest]
+python_files = [ "test_*.py" ]
+testpaths = [ "tests" ]
+
+# action:message_regex:warning_class:module_regex:line
+filterwarnings = [ "error" ]
+
+[mypy]
+ignore_missing_imports = true
+exclude = "tests/fixtures/"
+warn_unused_ignores = true
+show_error_codes = true

mmar_mcli-1.0.6/src/mmar_mcli/__init__.py

@@ -0,0 +1,5 @@
+from mmar_mcli.maestro_client import MaestroClient, MESSAGE_START
+from mmar_mcli.maestro_client_dummy import MaestroClientDummy
+from mmar_mcli.models import FileData, FileName, MessageData
+
+__all__ = [MaestroClient, MaestroClientDummy, FileName, FileData, MessageData, MESSAGE_START]

mmar_mcli-1.0.6/src/mmar_mcli/io_aiohttp.py

@@ -0,0 +1,55 @@
+import asyncio
+from mimetypes import guess_type
+
+from aiohttp import ClientConnectionError, ClientError, ClientResponseError, ClientSession, ClientTimeout, FormData
+from loguru import logger
+from mmar_utils import on_error_log_and_none, retry_on_ex
+
+from mmar_mcli.models import FileData
+
+POST_ERRORS = (asyncio.TimeoutError, ClientConnectionError, ClientResponseError)
+
+
+def make_file_form_data(file_data: FileData) -> FormData:
+    fd = FormData()
+    fname, fbytes = file_data
+    content_type = guess_type(fname)[0] or "application/octet-stream"
+    fd.add_field(name="file", filename=fname, content_type=content_type, value=fbytes)
+    return fd
+
+
+@on_error_log_and_none(logger.exception)
+@retry_on_ex(attempts=3, wait_seconds=1, catch=POST_ERRORS, logger=logger.warning)
+async def request_with_session(
+    *,
+    method: str,
+    url: str,
+    json: dict | None = None,
+    headers: dict[str, str] | None = None,
+    params: dict[str, str] | None = None,
+    timeout: int | None = None,
+    data: FormData | None = None,
+    headers_extra: dict[str, str] | None = None,
+) -> bytes | dict:
+    headers_all = headers | (headers_extra or {})
+    async with ClientSession(headers={}) as session:
+        timeout_ = ClientTimeout(timeout) if isinstance(timeout, int) else None
+        async with session.request(
+            method=method,
+            url=url,
+            json=json,
+            headers=headers_all,
+            params=params,
+            timeout=timeout_,
+            data=data,
+        ) as resp:
+            content_type = resp.headers.get("Content-Type", "").lower()
+            if "application/json" in content_type:
+                body: dict = await resp.json()
+                try:
+                    resp.raise_for_status()
+                except Exception as ex:
+                    raise ClientError(f"{ex}\nResponse body: {body}") from ex
+                return body
+            else:
+                return await resp.read()

mmar_mcli-1.0.6/src/mmar_mcli/maestro_client.py

@@ -0,0 +1,150 @@
+import time
+from functools import cache, partial
+from types import SimpleNamespace
+
+from aiohttp import FormData
+from loguru import logger
+from mmar_mapi import AIMessage, Context, FileStorage, HumanMessage, ResourceId, make_content
+from mmar_utils import remove_prefix_if_present
+
+from mmar_mcli.io_aiohttp import make_file_form_data, request_with_session
+from mmar_mcli.models import FileData, MaestroConfig, MessageData, RequestCall
+
+ROUTES = SimpleNamespace(
+    send="api/v0/send",
+    download="api/v2/files/download_bytes",
+    upload="api/v2/files/upload",
+)
+
+
+MESSAGE_START: MessageData = make_content(text="/start"), None
+
+
+def fix_maestro_address(maestro_address: str) -> str:
+    if not maestro_address.startswith("https:"):
+        if maestro_address.startswith(":"):
+            maestro_address = f"localhost{maestro_address}"
+        maestro_address = "http://" + remove_prefix_if_present(maestro_address, "http://")
+    return maestro_address
+
+
+class RemoteStorager:
+    def __init__(self, request: RequestCall, url_base: str, client_id: str):
+        self.request = request
+        self.url_download = url_base.replace(ROUTES.send, ROUTES.download)
+        self.url_upload = url_base.replace(ROUTES.send, ROUTES.upload)
+        self.client_id = client_id
+        self.headers = {"client-id": client_id}
+
+    async def upload_async(self, content: bytes | str, fname: str) -> ResourceId:
+        content = content if isinstance(content, bytes) else content.encode()
+        data: FormData = make_file_form_data((fname, content))
+        response_data = await self.request(method="post", url=self.url_upload, headers=self.headers, data=data)
+        if not isinstance(response_data, dict):
+            raise ValueError(f"POST {self.url_upload}: expected json, found {type(response_data)}")
+        resource_id: str = response_data["ResourceId"]
+        return resource_id
+
+    async def download_async(self, resource_id: str) -> bytes:
+        params = dict(resource_id=resource_id)
+        resource_bytes = await self.request(method="get", url=self.url_download, params=params, headers=self.headers)
+        if not isinstance(resource_bytes, bytes):
+            raise ValueError(f"GET {self.url_download}: expected bytes, found {type(resource_bytes)}")
+        return resource_bytes
+
+
+class MaestroClientI:
+    async def send(self, context: Context, msg_data: MessageData | str) -> list[MessageData]:
+        pass
+
+    async def upload_resource(self, file_data: FileData, client_id: str) -> str | None:
+        pass
+
+    async def download_resource(self, resource_id: str, client_id: str) -> bytes:
+        pass
+
+
+class MaestroClient(MaestroClientI):
+    def __init__(self, config: MaestroConfig):
+        addresses__maestro: str = getattr(config, "addresses__maestro", "https://maestro.airi.net")
+        error: str = getattr(getattr(config, "res", SimpleNamespace()), "error", "Server is not available")
+        headers_extra: dict[str, str] | None = getattr(config, "headers_extra", "")
+        files_dir: str | None = getattr(config, "files_dir", None)
+        timeout: int = getattr(config, "timeout", 120)
+
+        self.url = fix_maestro_address(addresses__maestro) + "/" + ROUTES.send
+        logger.info(f"Creating client, maestro url: {self.url}")
+        self.request = partial(request_with_session, timeout=timeout, headers_extra=headers_extra)
+        self.msg_data_response_error: MessageData = make_content(text=error), None
+
+        self.file_storage: FileStorage | None = files_dir and FileStorage(files_dir)
+
+    @cache
+    def get_file_storage(self, client_id: str) -> FileStorage:
+        return self.file_storage or RemoteStorager(self.request, self.url, client_id)
+
+    async def send(self, context: Context, msg_data: MessageData | str) -> list[MessageData]:
+        start = time.time()
+        msg_datas_response = await self._send(context, msg_data)
+        elapsed = time.time() - start
+
+        entrypoint_key = (context.extra or {}).get("entrypoint_key", "")
+        cd = f"{context.track_id}.{context.session_id}.{entrypoint_key}"
+        log_suffix = " (NULL!)" if not msg_datas_response else ""
+        logger.info(f"BotResponse processing time for {cd}: {elapsed:.2f} s{log_suffix}")
+
+        msg_datas_response = msg_datas_response or [self.msg_data_response_error]
+        return msg_datas_response
+
+    async def upload_resource(self, file_data: FileData, client_id: str) -> str | None:
+        file_name, file_bytes = file_data
+        resourse_id: str = await self.get_file_storage(client_id).upload_async(file_bytes, file_name)
+        return resourse_id
+
+    async def download_resource(self, resource_id: str, client_id: str) -> bytes:
+        res: bytes = await self.get_file_storage(client_id).download_async(resource_id)
+        return res
+
+    async def _download_file_data_maybe(self, msg: HumanMessage, client_id: str) -> FileData | None:
+        resource_id = msg.resource_id
+        if not resource_id:
+            return None
+        logger.info(f"Downloading resource: {resource_id}")
+        resource_name = msg.resource_name
+        if not resource_name:
+            resource_ext = resource_id.split(".")[-1]
+            resource_name = f"result.{resource_ext}"
+        resource_bytes = await self.download_resource(resource_id, client_id)
+        return resource_name, resource_bytes
+
+    async def _send(self, context: Context, msg_data: MessageData | str) -> list[MessageData] | None:
+        if isinstance(msg_data, str):
+            msg_data = msg_data, None
+        content, file_data = msg_data
+
+        resource_id = file_data and await self.upload_resource(file_data, context.client_id)
+        content = make_content(content=content, resource_id=resource_id)
+        msg = HumanMessage(content=content)
+        ai_messages = await self._send_raw(context, msg)
+        if not ai_messages:
+            return None
+        download = partial(self._download_file_data_maybe, client_id=context.client_id)
+        res = [(ai_msg.content, await download(ai_msg)) for ai_msg in ai_messages]
+        return res
+
+    async def _send_raw(self, context: Context, msg: HumanMessage) -> list[AIMessage] | None:
+        dict_user_message = msg.model_dump()
+        dict_ctx = context.model_dump()
+        data_json = {"context": dict_ctx, "messages": [dict_user_message]}
+        headers = {"client-id": context.client_id}
+        try:
+            response_data = await self.request(method="post", url=self.url, json=data_json, headers=headers)
+        except Exception:
+            logger.exception(f"Failed to send request {msg}")
+            return None
+        if response_data is None:
+            return None
+        logger.trace(f"Response data: {response_data}")
+        response_messages_raw = response_data["response_messages"]
+        ai_messages = list(map(AIMessage.model_validate, response_messages_raw))
+        return ai_messages

mmar_mcli-1.0.6/src/mmar_mcli/maestro_client_dummy.py

@@ -0,0 +1,38 @@
+import asyncio
+
+from loguru import logger
+from mmar_mapi import Context
+from mmar_mapi.models.chat import _get_command, _get_text
+from mmar_utils import try_parse_int
+
+from mmar_mcli.maestro_client import MaestroClientI
+from mmar_mcli.models import MessageData
+
+
+class MaestroClientDummy(MaestroClientI):
+    def __init__(self, config):
+        pass
+
+    async def send(self, context: Context, msg_data: MessageData | str) -> list[MessageData]:
+        if isinstance(msg_data, str):
+            msg_data = msg_data, None
+        content, file_data = msg_data
+
+        text = _get_text(content)
+        command = _get_command(content)
+
+        if text.lower().startswith("wait"):
+            seconds = try_parse_int(text[len("wait") :].strip())
+            logger.info(f"Going to wait {seconds} seconds")
+            if seconds:
+                await asyncio.sleep(seconds)
+            return [(f"After waiting {seconds} seconds", None)]
+
+        text_response_lines = [
+            f"Your context: {context}",
+            f"Your text: {text}",
+            f"Your command: {command}",
+            f"Your file_data: {file_data and (file_data[0], len(file_data[1]))}",
+        ]
+        text_response = "\n".join(text_response_lines)
+        return [(text_response, None)]

mmar_mcli-1.0.6/src/mmar_mcli/models.py

@@ -0,0 +1,20 @@
+from collections.abc import Callable
+from typing import Awaitable, NamedTuple, Protocol
+
+from mmar_mapi import Content
+
+FileName = str
+FileData = tuple[FileName, bytes]
+MessageData = tuple[Content | None, FileData | None]
+
+RequestCall = Callable[..., Awaitable[bytes | dict]]
+BotConfig = NamedTuple("BotConfig", [("timeout", int)])
+ResourcesConfig = NamedTuple("ResourcesConfig", [("error", str)])
+
+
+class MaestroConfig(Protocol):
+    addresses__maestro: str
+    res: ResourcesConfig
+    headers_extra: dict[str, str] | None
+    files_dir: str | None
+    timeout: int