mmar-mapi 1.0.7__py3-none-any.whl → 1.1.1__py3-none-any.whl

mmar_mapi/__init__.py

@@ -11,19 +11,19 @@ from .models.chat import (
     Content,
     BaseMessage,
 )
-from .models.chat_item import ChatItem, OuterContextItem, InnerContextItem, ReplicaItem
 from .models.enums import MTRSLabelEnum, DiagnosticsXMLTagEnum, MTRSXMLTagEnum, DoctorChoiceXMLTagEnum
 from .models.tracks import TrackInfo, DomainInfo
 from .models.widget import Widget
-from .utils import make_session_id
+from .utils import make_session_id, chunked
 from .xml_parser import XMLParser
+from .utils_import import load_main_objects
+from .decorators_maybe_lru_cache import maybe_lru_cache
 
 __all__ = [
     "AIMessage",
     "Base",
     "BaseMessage",
     "Chat",
-    "ChatItem",
     "ChatMessage",
     "Content",
     "Context",
@@ -32,16 +32,16 @@ __all__ = [
     "DomainInfo",
     "FileStorage",
     "HumanMessage",
-    "InnerContextItem",
     "MTRSLabelEnum",
     "MTRSXMLTagEnum",
     "MiscMessage",
-    "OuterContextItem",
-    "ReplicaItem",
     "ResourceId",
     "TrackInfo",
     "Widget",
     "XMLParser",
+    "chunked",
+    "load_main_objects",
     "make_content",
     "make_session_id",
+    "maybe_lru_cache",
 ]

mmar_mapi/api.py

@@ -1,11 +1,14 @@
+from enum import StrEnum
+from typing import Annotated, Any
+
+from pydantic import AfterValidator, BaseModel
+
+from mmar_mapi.file_storage import ResourceId
 from mmar_mapi.models.chat import Chat, ChatMessage
 from mmar_mapi.models.tracks import DomainInfo, TrackInfo
-from pydantic import BaseModel
-
 
 Value = str
 Interpretation = str
-ResourceId = str
 
 
 class ChatManagerAPI:
@@ -37,16 +40,59 @@ class ContentInterpreterRemoteAPI:
         raise NotImplementedError
 
 
-class ClassifierAPI:
-    def get_values(self) -> list[Value]:
+class BinaryClassifiersAPI:
+    def get_classifiers(self) -> list[str]:
         raise NotImplementedError
 
-    def evaluate(self, *, chat: Chat) -> Value:
+    def evaluate(self, *, classifier: str | None = None, text: str) -> bool:
+        raise NotImplementedError
+
+
+class LLMAccessorAPI:
+    def get_entrypoint_keys(self) -> list[str]:
+        raise NotImplementedError
+
+    def get_response(
+        self,
+        *,
+        prompt: str,
+        resource_id: ResourceId | None = None,
+        entrypoint_key: str | None = None,
+        max_retries: int = 1,
+    ) -> str:
+        raise NotImplementedError
+
+    def get_response_by_payload(
+        self,
+        *,
+        payload: dict[str, Any],
+        resource_id: ResourceId | None = None,
+        entrypoint_key: str | None = None,
+        max_retries: int = 1,
+    ) -> str:
+        raise NotImplementedError
+
+    def get_embedding(
+        self,
+        *,
+        prompt: str,
+        resource_id: ResourceId | None = None,
+        entrypoint_key: str | None = None,
+        max_retries: int = 1,
+    ) -> list[float]:
+        raise NotImplementedError
+
+
+class TranslatorAPI:
+    def get_lang_codes(self) -> list[str]:
+        raise NotImplementedError
+
+    def translate(self, *, text: str, lang_code_from: str | None = None, lang_code_to: str) -> str:
         raise NotImplementedError
 
 
 class CriticAPI:
-    def evaluate(self, *, text: str, chat: Chat | None = None) -> float:
+    def evaluate(self, *, text: str, chat: Chat | None = None) -> float:  # TODO replace float with bool
         raise NotImplementedError
 
 
@@ -60,3 +106,99 @@ class ContentInterpreterAPI:
 class TextProcessorAPI:
     def process(self, *, text: str, chat: Chat | None = None) -> str:
         raise NotImplementedError
+
+
+class TextExtractorAPI:
+    def extract(self, *, resource_id: ResourceId) -> ResourceId:
+        """returns file with text"""
+        raise NotImplementedError
+
+
+def _validate_page_range(v: tuple[int, int]) -> tuple[int, int]:
+    if v[0] < 1 or v[1] < v[0]:
+        raise ValueError("Invalid page range: start must be ≥ 1 and end must be ≥ start.")
+    return v
+
+
+PageRange = Annotated[tuple[int, int], AfterValidator(_validate_page_range)]
+ForceOCR = StrEnum("ForceOCR", ["ENABLED", "DISABLED", "AUTO"])
+OutputType = StrEnum("OutputType", ["RAW", "PLAIN", "MARKDOWN"])
+
+
+class ExtractionEngineSpec(BaseModel, frozen=True):
+    output_type: OutputType = OutputType.MARKDOWN
+    force_ocr: ForceOCR = ForceOCR.AUTO
+    do_ocr: bool = False
+    do_table_structure: bool = False
+    do_cell_matching: bool = False
+    do_annotations: bool = False
+    do_image_extraction: bool = False
+    generate_page_images: bool = False
+    images_scale: float = 2.0
+
+
+class DocExtractionSpec(BaseModel, frozen=True):
+    page_range: PageRange | None = None
+    engine: ExtractionEngineSpec = ExtractionEngineSpec()
+
+    def _update(self, **update):
+        return self.model_copy(update=update)
+
+    def _update_engine(self, **engine_update):
+        return self._update(engine=self.engine.model_copy(update=engine_update))
+
+    # fmt: off
+    def with_output_type_raw(self): return self._update_engine(output_type=OutputType.RAW)
+    def with_output_type_plain(self): return self._update_engine(output_type=OutputType.PLAIN)
+    def with_ocr(self): return self._update_engine(do_ocr=True)
+    def with_tables(self): return self._update_engine(do_table_structure=True, do_cell_matching=True)
+    def with_images(self): return self._update_engine(do_image_extraction=True)
+    def with_annotations(self): return self._update_engine(do_annotations=True)
+    def with_force_ocr_enabled(self): return self._update_engine(force_ocr=ForceOCR.ENABLED)
+    def with_force_ocr_disabled(self): return self._update_engine(force_ocr=ForceOCR.DISABLED)
+    def with_page_images(self): return self._update_engine(generate_page_images=True)
+
+    def with_page_range(self, page_range: PageRange): return self._update(page_range=page_range)
+    # fmt: on
+
+
+class ExtractedImage(BaseModel):
+    page: int
+    image_resource_id: ResourceId | None = None
+
+
+class ExtractedImageMetadata(BaseModel):
+    annotation: str = ""
+    caption: str = ""
+    width: int | None = None
+    height: int | None = None
+
+
+class ExtractedPicture(ExtractedImage, ExtractedImageMetadata):
+    "Image of part of page"
+
+    pass
+
+
+class ExtractedTable(ExtractedImage, ExtractedImageMetadata):
+    formatted_str: str
+
+
+class ExtractedPageImage(ExtractedImage):
+    "Image of all page"
+
+    pass
+
+
+class DocExtractionOutput(BaseModel):
+    spec: DocExtractionSpec
+    text: str = ""
+    tables: list[ExtractedTable] = []
+    pictures: list[ExtractedPicture] = []
+    page_images: list[ExtractedPageImage] = []
+
+
+class DocumentExtractorAPI:
+    def extract(self, *, resource_id: ResourceId, spec: DocExtractionSpec) -> ResourceId | None:
+        """returns file with DocExtractionOutput"""
+        raise NotImplementedError

mmar_mapi/decorators_maybe_lru_cache.py

@@ -0,0 +1,14 @@
+from collections.abc import Callable
+from functools import lru_cache
+
+from loguru import logger
+
+
+def maybe_lru_cache(maxsize: int, func: Callable) -> tuple[str, Callable]:
+    if maxsize >= 0:
+        maxsize = maxsize or None
+        logger.info(f"Caching for {func.__name__}: enabled: maxsize={maxsize}")
+        func = lru_cache(maxsize=maxsize)(func)
+    else:
+        logger.info(f"Caching for {func.__name__}: disabled")
+    return func

mmar_mapi/file_storage.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from zipfile import ZipFile, is_zipfile
 
 ResourceId = str
-ASCII_DIGITS = set(string.ascii_lowercase + string.digits)
+ASCII_DIGITS_SPECIAL = set(string.ascii_lowercase + string.digits + "-")
 SUFFIX_DIR = ".dir"
 SUFFIX_METADATA = ".metadata"
 
@@ -18,7 +18,7 @@ def _validate_exist(files_dir):
 
 
 def _validate_dtype(dtype: str):
-    if all(map(ASCII_DIGITS.__contains__, dtype)):
+    if all(map(ASCII_DIGITS_SPECIAL.__contains__, dtype)):
         return
     raise ValueError(f"Bad dtype: {dtype}")
 
@@ -45,7 +45,7 @@ class FileStorage:
         resource_id = self.upload(content, fname)
         return resource_id
 
-    def upload(self, content: bytes | str, fname: str) -> ResourceId:
+    def upload(self, content: bytes | str, fname: str, origin: str | None = None) -> ResourceId:
         if isinstance(content, str):
             content = content.encode()
 
@@ -56,17 +56,29 @@ class FileStorage:
 
         fpath_md = fpath.with_suffix(SUFFIX_METADATA)
         update_date = f"{datetime.now():%Y-%m-%d--%H-%M-%S}"
-        metadata = {"fname": fname, "update_date": update_date, "size": len(content)}
+        metadata = {"fname": fname, "update_date": update_date, "size": len(content), "origin": origin}
         fpath_md.write_text(json.dumps(metadata, ensure_ascii=False))
 
         return str(fpath)
 
+    def get_metadata(self, resource_id: ResourceId) -> dict | None:
+        metadata_path = Path(resource_id).with_suffix(SUFFIX_METADATA)
+        if not metadata_path.exists():
+            return None
+        return json.loads(metadata_path.read_text())
+
+    def get_fname(self, resource_id: ResourceId) -> str | None:
+        metadata = self.get_metadata(resource_id)
+        if metadata is None:
+            return None
+        return metadata.get("fname")
+
     async def upload_async(self, content: bytes | str, fname: str) -> ResourceId:
         return self.upload(content, fname)
 
     def upload_dir(self, resource_ids: list[ResourceId]) -> ResourceId:
         content = "\n".join(resource_ids)
-        res = self.upload(content, "dir")
+        res = self.upload(content=content, fname=".dir")
         return res
 
     def download(self, resource_id: ResourceId) -> bytes:
@@ -84,6 +96,9 @@ class FileStorage:
         res = self.download_text(resource_id).split("\n")
         return res
 
+    def get_path(self, resource_id: ResourceId | None) -> Path | None:
+        return self._get_path(resource_id)
+
     def _get_path(self, resource_id: ResourceId | None) -> Path | None:
         if not resource_id:
             return None
@@ -103,7 +118,7 @@ class FileStorage:
         return path and path.suffix == SUFFIX_DIR
 
     def get_dtype(self, resource_id: ResourceId | None) -> str | None:
-        return resource_id and resource_id.rsplit(".")[-1]
+        return resource_id and resource_id.rsplit(".")[-1].lower()
 
     def unzip_file(self, resource_id: str) -> ResourceId:
         """takes resource_id which refer to zip-archive, unpacks it and returns directory ResourceId with content of zip-archive"""

mmar_mapi/models/chat.py

@@ -1,21 +1,37 @@
 import warnings
 from collections.abc import Callable
-from copy import deepcopy
 from datetime import datetime
-from typing import Any, Literal, TypeVar
+from typing import Any, Literal, NotRequired, TypedDict, TypeVar
+
+from pydantic import Field
 
-from mmar_mapi.models.chat_item import ChatItem, ReplicaItem, OuterContextItem
 from mmar_mapi.models.widget import Widget
 from mmar_mapi.type_union import TypeUnion
-from pydantic import Field, ValidationError
 
 from .base import Base
 
-
 _DT_FORMAT: str = "%Y-%m-%d-%H-%M-%S"
 _EXAMPLE_DT: str = datetime(year=1970, month=1, day=1).strftime(_DT_FORMAT)
 StrDict = dict[str, Any]
-ContentBase = str | Widget | StrDict
+
+
+class ResourceDict(TypedDict):
+    type: Literal["resource_id"]
+    resource_id: str
+    resource_name: NotRequired[str]
+
+
+class TextDict(TypedDict):
+    type: Literal["text"]
+    text: str
+
+
+class CommandDict(TypedDict):
+    type: Literal["command"]
+    command: StrDict
+
+
+ContentBase = str | Widget | ResourceDict | CommandDict | TextDict | StrDict
 Content = ContentBase | list[ContentBase]
 T = TypeVar("T")
 
@@ -33,10 +49,12 @@ class Context(Base):
 
     def create_id(self, short: bool = False) -> str:
         uid, sid, cid = self.user_id, self.session_id, self.client_id
-        if short:
-            return f"{cid}_{uid}_{sid}"
         return f"client_{cid}_user_{uid}_session_{sid}"
 
+    def create_trace_id(self) -> str:
+        uid, sid, cid = self.user_id, self.session_id, self.client_id
+        return f"{cid}_{uid}_{sid}"
+
     def _get_deprecated_extra(self, field, default):
         # legacy: eliminate after migration
         res = (self.extra or {}).get(field, default)
@@ -96,6 +114,22 @@ def _get_resource_id(obj: Content) -> str | None:
     return None
 
 
+def _get_resource_name(obj: Content) -> str | None:
+    if isinstance(obj, list):
+        return next((el for el in map(_get_resource_name, obj) if el), None)
+    if isinstance(obj, dict) and obj.get("type") == "resource_id":
+        return _get_field(obj, "resource_name", str)
+    return None
+
+
+def _get_resource(obj: Content) -> str | None:
+    if isinstance(obj, list):
+        return next((el for el in map(_get_resource_id, obj) if el), None)
+    if isinstance(obj, dict) and obj.get("type") == "resource_id":
+        return obj
+    return None
+
+
 def _get_command(obj: Content) -> dict | None:
     if isinstance(obj, list):
         return next((el for el in map(_get_command, obj) if el), None)
@@ -127,7 +161,10 @@ class BaseMessage(Base):
 
     def modify_text(self, callback: Callable[[str], str]) -> "BaseMessage":
         content_upd = _modify_text(self.content, callback)
-        return self.model_copy(update=dict(content=content_upd))
+        return self.with_content(content_upd)
+
+    def with_content(self, content: Content) -> "BaseMessage":
+        return self.model_copy(update=dict(content=content))
 
     @property
     def body(self) -> str:
@@ -138,6 +175,15 @@ class BaseMessage(Base):
     def resource_id(self) -> str | None:
         return _get_resource_id(self.content)
 
+    @property
+    def resource_name(self) -> str | None:
+        res = _get_resource_name(self.content)
+        return res
+
+    @property
+    def resource(self) -> dict | None:
+        return _get_resource(self.content)
+
     @property
     def command(self) -> dict | None:
         return _get_command(self.content)
@@ -162,7 +208,7 @@ class BaseMessage(Base):
         return _DT_FORMAT
 
     @staticmethod
-    def find_resource_id(msg: "BaseMessage", ext: str | None = None, type: str=None) -> str | None:
+    def find_resource_id(msg: "BaseMessage", ext: str | None = None, type: str = None) -> str | None:
         resource_id = msg.resource_id
         if type and type != msg.type:
             return None
@@ -185,6 +231,9 @@ class AIMessage(BaseMessage):
     def action(self) -> str:
         return (self.extra or {}).get("action", "")
 
+    def with_state(self, state: str) -> "AIMessage":
+        return self.model_copy(update=dict(state=state))
+
 
 class MiscMessage(BaseMessage):
     type: Literal["misc"] = "misc"
@@ -213,11 +262,8 @@ class Chat(Base):
         return self.context.create_id(short)
 
     @staticmethod
-    def parse(chat_obj: str | dict | ChatItem) -> "Chat":
-        return _parse_chat_compat(chat_obj)
-
-    def to_chat_item(self) -> ChatItem:
-        return convert_chat_to_chat_item(self)
+    def parse(chat_obj: str | dict) -> "Chat":
+        return _parse_chat(chat_obj)
 
     def add_message(self, message: ChatMessage):
         self.messages.append(message)
@@ -242,180 +288,63 @@ class Chat(Base):
     def rfind_in_messages(self, func: Callable[[ChatMessage], T | None]) -> T | None:
         return find_in_messages(self.messages[::-1], func)
 
+    def get_last_user_message(self) -> HumanMessage | None:
+        messages = self.messages
+        if not messages:
+            return []
+        message = messages[-1]
+        return message if isinstance(message, HumanMessage) else None
+
+    def count_messages(self, func: Callable[[ChatMessage], bool] | type) -> int:
+        if isinstance(func, type):
+            msg_type = func
+            func = lambda msg: isinstance(msg, msg_type)
+        return sum(map(func, self.messages))
+
 
 def make_content(
     text: str | None = None,
     *,
     resource_id: str | None = None,
+    resource: dict | None = None,
     command: dict | None = None,
     widget: Widget | None = None,
     content: Content | None = None,
 ) -> Content:
-    resource_id = (resource_id or None) and {"type": "resource_id", "resource_id": resource_id}
+    if resource and resource_id:
+        raise ValueError("Cannot pass both 'resource' and 'resource_id'")
+
+    if resource_id:
+        resource = {"type": "resource_id", "resource_id": resource_id}
+    elif resource:
+        if not isinstance(resource, dict):
+            raise TypeError("'resource' must be a dict")
+        resource_id = resource.get("resource_id")
+        if not resource_id:
+            raise ValueError("'resource' must contain 'resource_id'")
+        resource_name = resource.get("resource_name")
+        resource = {"type": "resource_id", "resource_id": resource_id}
+        if resource_name:
+            resource["resource_name"] = resource_name
+    else:
+        resource = None
+
     command = (command or None) and {"type": "command", "command": command}
 
     content = content if isinstance(content, list) else [content] if content else []
-    content += list(filter(None, [text, resource_id, command, widget]))
+    content += list(filter(None, [text, resource, command, widget]))
     if len(content) == 0:
         content = ""
     elif len(content) == 1:
         content = content[0]
-
     return content
 
 
-def convert_replica_item_to_message(replica: ReplicaItem) -> ChatMessage:
-    date_time = replica.date_time
-    content = make_content(
-        text=replica.body,
-        resource_id=replica.resource_id,
-        command=replica.command,
-        widget=replica.widget,
-    )
-    # legacy: eliminate after migration
-    resource_id = (replica.resource_id or None) and {"type": "resource_id", "resource_id": replica.resource_id}
-    body = replica.body
-    command = (replica.command or None) and {"type": "command", "command": replica.command}
-    widget = replica.widget
-    date_time = replica.date_time
-
-    content = list(filter(None, [body, resource_id, command, widget]))
-    if len(content) == 0:
-        content = ""
-    elif len(content) == 1:
-        content = content[0]
-
-    is_bot_message = replica.role
-
-    if is_bot_message:
-        kwargs = dict(
-            content=content,
-            date_time=date_time,
-            state=replica.state,
-            extra=dict(
-                **(replica.extra or {}),
-                action=replica.action,
-                moderation=replica.moderation,
-            ),
-        )
-        res = AIMessage(**kwargs)
-    else:
-        kwargs = dict(content=content, date_time=date_time)
-        res = HumanMessage(**kwargs)
-    return res
-
-
-def convert_outer_context_to_context(octx: OuterContextItem) -> Context:
-    # legacy: eliminate after migration
-    context = Context(
-        client_id=octx.client_id,
-        user_id=octx.user_id,
-        session_id=octx.session_id,
-        track_id=octx.track_id,
-        extra=dict(
-            sex=octx.sex,
-            age=octx.age,
-            parent_session_id=octx.parent_session_id,
-            entrypoint_key=octx.entrypoint_key,
-            language_code=octx.language_code,
-        ),
-    )
-    return context
-
-
-def convert_chat_item_to_chat(chat_item: ChatItem) -> Chat:
-    # legacy: eliminate after migration
-    context = convert_outer_context_to_context(chat_item.outer_context)
-    messages = list(map(convert_replica_item_to_message, chat_item.inner_context.replicas))
-    res = Chat(context=context, messages=messages)
-    return res
-
-
-def convert_context_to_outer_context(context: Context) -> OuterContextItem:
-    # legacy: eliminate after migration
-    extra = context.extra or {}
-    return OuterContextItem(
-        client_id=context.client_id,
-        user_id=context.user_id,
-        session_id=context.session_id,
-        track_id=context.track_id,
-        sex=extra.get("sex"),
-        age=extra.get("age"),
-        parent_session_id=extra.get("parent_session_id"),
-        entrypoint_key=extra.get("entrypoint_key"),
-        language_code=extra.get("language_code"),
-    )
-
-
-def convert_message_to_replica_item(message: ChatMessage) -> ReplicaItem | None:
-    # legacy: eliminate after migration
-    m_type = message.type
-    if m_type in {"ai", "human"}:
-        role = m_type == "ai"
-    else:
-        return None
-
-    extra = deepcopy(message.extra) if message.extra else {}
-    action = extra.pop("action", "")
-    moderation = extra.pop("moderation", "OK")
-
-    kwargs = dict(
-        role=role,
-        body=message.text,
-        resource_id=message.resource_id,
-        command=message.command,
-        widget=message.widget,
-        date_time=message.date_time,
-        extra=extra or None,
-        state=getattr(message, "state", ""),
-        action=action,
-        moderation=moderation,
-    )
-    return ReplicaItem(**kwargs)
-
-
-def convert_chat_to_chat_item(chat: Chat) -> ChatItem:
-    # legacy: eliminate after migration
-    return ChatItem(
-        outer_context=convert_context_to_outer_context(chat.context),
-        inner_context=dict(replicas=list(map(convert_message_to_replica_item, chat.messages))),
-    )
-
-
-def parse_chat_item_as_chat(chat_obj: str | dict | ChatItem) -> Chat:
-    # legacy: eliminate after migration
-    if isinstance(chat_obj, ChatItem):
-        chat_item = chat_obj
-    else:
-        chat_item = ChatItem.parse(chat_obj)
-    res = convert_chat_item_to_chat(chat_item)
-    return res
-
-
-def _parse_chat(chat_obj: str | dict) -> Chat:
+def _parse_chat(chat_obj: str | dict | Chat) -> Chat:
+    if isinstance(chat_obj, Chat):
+        return chat_obj
     if isinstance(chat_obj, dict):
         return Chat.model_validate(chat_obj)
-
-    return Chat.model_validate_json(chat_obj)
-
-
-def is_chat_item(chat_obj: str | dict | ChatItem) -> bool:
-    if isinstance(chat_obj, ChatItem):
-        return True
-    if isinstance(chat_obj, dict):
-        return "OuterContext" in chat_obj
     if isinstance(chat_obj, str):
-        return "OuterContext" in chat_obj
-    warnings.warn(f"Unexpected chat object: {chat_obj} :: {type(chat_obj)}")
-    return False
-
-
-def _parse_chat_compat(chat_obj: str | dict | ChatItem) -> Chat:
-    # legacy: eliminate after migration
-    if is_chat_item(chat_obj):
-        return parse_chat_item_as_chat(chat_obj)
-    try:
-        return _parse_chat(chat_obj)
-    except ValidationError as ex:
-        warnings.warn(f"Failed to parse chat: {ex}")
-        return parse_chat_item_as_chat(chat_obj)
+        return Chat.model_validate_json(chat_obj)
+    raise ValueError(f"Bad chat_obj {type(chat_obj)}: {chat_obj}")

mmar_mapi/models/widget.py

@@ -1,6 +1,6 @@
 from typing import Self, Literal
 
-from more_itertools import chunked
+from mmar_mapi.utils import chunked
 from pydantic import BaseModel, model_validator
 
 
@@ -26,9 +26,17 @@ class Widget(BaseModel):
     def make_inline_buttons(ibuttons: dict[str, str], by=1) -> "Widget":
         return _make_inline_buttons(ibuttons=ibuttons, by=by)
 
+    @staticmethod
+    def make_buttons(buttons: list[str], by=1) -> "Widget":
+        return _make_buttons(buttons=buttons, by=1)
+
 
 def _make_inline_buttons(ibuttons: dict[str, str], by=1) -> "Widget":
     ibs0 = [f"{key}:{val}" for key, val in ibuttons.items()]
-    ibs = list(chunked(ibs0, n=by))
-    res = Widget(ibuttons=ibs)
+    res = Widget(ibuttons=list(chunked(ibs0, n=by)))
+    return res
+
+
+def _make_buttons(buttons: list[str], by=1) -> "Widget":
+    res = Widget(buttons=list(chunked(buttons, n=by)))
     return res

mmar_mapi/utils.py

@@ -1,5 +1,18 @@
+from itertools import islice
+from collections.abc import Iterable
 from datetime import datetime
 
 
-def make_session_id() -> str:
-    return f"{datetime.now():%Y-%m-%d--%H-%M-%S}"
+def make_session_id(with_millis=False) -> str:
+    dt = datetime.now()
+    fmt = "%Y-%m-%d--%H-%M-%S-%f" if with_millis else "%Y-%m-%d--%H-%M-%S"
+    return dt.strftime(fmt)
+
+
+def chunked(items: Iterable, n) -> list:
+    "behavior like in more_itertools.chunked"
+    iterator = iter(items)
+    res = []
+    while chunk := list(islice(iterator, n)):
+        res.append(chunk)
+    return res

mmar_mapi/utils_import.py

@@ -0,0 +1,47 @@
+from pkgutil import iter_modules
+from importlib import import_module
+from types import ModuleType
+
+from loguru import logger
+
+
+def convert_snake_to_pascal(name: str) -> str:
+    """snake_to_pascal -> SnakeToPascal"""
+    return "".join(map(str.capitalize, name.split("_")))
+
+
+def get_main_object_name(module: type[ModuleType]) -> str:
+    module_name = module.__name__.rsplit(".", 1)[-1]
+    main_object_name = convert_snake_to_pascal(module_name)
+    return main_object_name
+
+
+def get_main_object(module: type[ModuleType], obj_type):
+    """tries to find SomeObject in object src.some_object"""
+    main_object_name = get_main_object_name(module)
+    try:
+        res = getattr(module, main_object_name)
+        if not isinstance(res, obj_type) and not issubclass(res, obj_type):
+            logger.error(f"Failed to load {module}.{main_object_name}: expected {obj_type} but found {type(res)}")
+            return None
+        return res
+    except AttributeError as ex:
+        logger.error(f"Failed to load {module}.{main_object_name}: {ex}")
+        return None
+
+
+def load_modules(package_name: str) -> list[type[ModuleType]]:
+    try:
+        package = import_module(package_name)
+    except ModuleNotFoundError:
+        logger.error(f"Not found module: {package_name}")
+        return []
+    res = [import_module(module_name) for _, module_name, _ in iter_modules(package.__path__, package_name + ".")]
+    return res
+
+
+def load_main_objects(package_name: str, obj_type: type) -> dict[str, object]:
+    modules = load_modules(package_name)
+    main_objects = [get_main_object(m, obj_type) for m in modules]
+    res = {obj.__name__: obj for obj in main_objects}
+    return res

{mmar_mapi-1.0.7.dist-info → mmar_mapi-1.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmar-mapi
-Version: 1.0.7
+Version: 1.1.1
 Summary: Common pure/IO utilities for multi-modal architectures team
 Keywords: 
 Author: Eugene Tagin
@@ -20,7 +20,8 @@ Classifier: Topic :: Software Development
 Classifier: Topic :: Utilities
 Classifier: Typing :: Typed
 Requires-Dist: pydantic~=2.11.7
-Requires-Python: >=3.12
+Requires-Dist: loguru~=0.7.3
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 
 # mmar-mapi

mmar_mapi-1.1.1.dist-info/RECORD

@@ -0,0 +1,18 @@
+mmar_mapi/__init__.py,sha256=Wq3MAvrtONYfUY63ShtqzbO-05uhxPzKU5I6p27aZc0,1085
+mmar_mapi/api.py,sha256=VGoZ2nYIvm35U4FO4yhFG9nYSaK-gjOUC3pNyfBrq3o,6109
+mmar_mapi/decorators_maybe_lru_cache.py,sha256=eO2I6t1fHLUNRABClK1c8EZzHAmCeSK6O-hbJGb2c9E,444
+mmar_mapi/file_storage.py,sha256=gSz2lM5UIQtjK8f-PatGe3br_UOSVJwgbTMi1sDjXC8,5075
+mmar_mapi/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mmar_mapi/models/base.py,sha256=mKtXV2x51XVj7W-et9tjGcPMDUUUMelW-BywMgFc2p0,411
+mmar_mapi/models/chat.py,sha256=6qVuiOCQ0J5CbmGtVfuytAcpWklBCYjhAn0FkonSBqo,10999
+mmar_mapi/models/enums.py,sha256=J-GNpql9MCnKnWiV9aJRQGI-pAybvV86923RZs99grA,1006
+mmar_mapi/models/tracks.py,sha256=HKDp-BX1p7AlDfSEKfOKCu0TRSK9cD4Dmq1vJt8oRjw,307
+mmar_mapi/models/widget.py,sha256=ue5o4AkN8SG09aA8eQLOOxbwah-mkZir0ZGL6OA8S9Q,1355
+mmar_mapi/type_union.py,sha256=diwmzcnbqkpGFckPHNw9o8zyQ955mOGNvhTlcBJ0RMI,1905
+mmar_mapi/utils.py,sha256=FlW9n-84xz2zSHsahHzJ3Y4Wu5mjpFer6t9z6PF6lS0,488
+mmar_mapi/utils_import.py,sha256=pUyMFd8SItTxBKI-GO9JhRmy43jG_OQlUPr8QCBOSwg,1682
+mmar_mapi/xml_parser.py,sha256=VvLIX_XCZao9i0qqpTVx8nx0vbFXSe8pEbdJdXnj97g,568
+mmar_mapi-1.1.1.dist-info/licenses/LICENSE,sha256=2A90w8WjhOgQXnFuUijKJYazaqZ4_NTokYb9Po4y-9k,1061
+mmar_mapi-1.1.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+mmar_mapi-1.1.1.dist-info/METADATA,sha256=cc6x65HLcK7oHBNEC92IjB_ZWh9OF4qw9VfwM-3UO3Q,943
+mmar_mapi-1.1.1.dist-info/RECORD,,

{mmar_mapi-1.0.7.dist-info → mmar_mapi-1.1.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.17
+Generator: uv 0.8.24
 Root-Is-Purelib: true
 Tag: py3-none-any

mmar_mapi/models/chat_item.py

@@ -1,157 +0,0 @@
-from datetime import datetime
-from typing import Annotated, Any
-from collections.abc import Callable
-
-from mmar_mapi.models.widget import Widget
-from pydantic import Field, ConfigDict, BeforeValidator, AfterValidator
-
-from .base import Base
-
-
-_DT_FORMAT: str = "%Y-%m-%d-%H-%M-%S"
-_EXAMPLE_DT_0 = datetime(1970, 1, 1, 0, 0, 0)
-_EXAMPLE_DT: str = _EXAMPLE_DT_0.strftime(_DT_FORMAT)
-
-
-def now_pretty() -> str:
-    return datetime.now().strftime(ReplicaItem.DATETIME_FORMAT())
-
-
-class OuterContextItem(Base):
-    # remove annoying warning for protected `model_` namespace
-    model_config = ConfigDict(protected_namespaces=())
-
-    sex: bool = Field(False, alias="Sex", description="True = male, False = female", examples=[True])
-    age: int = Field(0, alias="Age", examples=[20])
-    user_id: str = Field("", alias="UserId", examples=["123456789"])
-    parent_session_id: str | None = Field(None, alias="ParentSessionId", examples=["987654320"])
-    session_id: str = Field("", alias="SessionId", examples=["987654321"])
-    client_id: str = Field("", alias="ClientId", examples=["543216789"])
-    track_id: str = Field(default="Consultation", alias="TrackId")
-    entrypoint_key: str = Field("", alias="EntrypointKey", examples=["giga"])
-    language_code: str = Field("ru", alias="LanguageCode", examples=["ru"])
-
-    def create_id(self, short: bool = False) -> str:
-        uid, sid, cid = self.user_id, self.session_id, self.client_id
-        if short:
-            return f"{uid}_{sid}_{cid}"
-        return f"user_{uid}_session_{sid}_client_{cid}"
-
-    def to_dict(self) -> dict[str, Any]:
-        return self.model_dump(by_alias=True)
-
-
-LABELS = {
-    0: "OK",
-    1: "NON_MED",
-    2: "CHILD",
-    3: "ABSURD",
-    4: "GREETING",
-    5: "RECEIPT",
-}
-
-
-def fix_deprecated_moderation(moderation):
-    if isinstance(moderation, int):
-        return LABELS.get(moderation, "OK")
-    elif isinstance(moderation, str):
-        return moderation
-    else:
-        raise ValueError(f"Unsupported moderation: {moderation} :: {type(moderation)}")
-
-
-def nullify_empty(text: str) -> str | None:
-    return text or None
-
-
-class ReplicaItem(Base):
-    body: str = Field("", alias="Body", examples=["Привет"])
-    resource_id: Annotated[str | None, AfterValidator(nullify_empty)] = Field(
-        None, alias="ResourceId", examples=["<link-id>"]
-    )
-    widget: Widget | None = Field(None, alias="Widget", examples=[None])
-    command: dict | None = Field(None, alias="Command", examples=[None])
-    role: bool = Field(False, alias="Role", description="True = ai, False = client", examples=[False])
-    date_time: str = Field(
-        default_factory=now_pretty, alias="DateTime", examples=[_EXAMPLE_DT], description=f"Format: {_DT_FORMAT}"
-    )
-    state: str = Field("", alias="State", description="chat manager fsm state", examples=["COLLECTION"])
-    action: str = Field("", alias="Action", description="chat manager fsm action", examples=["DIAGNOSIS"])
-    # todo fix: support loading from `moderation: int`
-    moderation: Annotated[str, BeforeValidator(str)] = Field(
-        "OK", alias="Moderation", description="moderation outcome", examples=["OK"]
-    )
-    extra: dict | None = Field(None, alias="Extra", examples=[None])
-
-    def to_dict(self) -> dict[str, Any]:
-        return self.model_dump(by_alias=True)
-
-    @staticmethod
-    def DATETIME_FORMAT() -> str:
-        return _DT_FORMAT
-
-    def with_now_datetime(self):
-        return self.model_copy(update=dict(date_time=now_pretty()))
-
-    @property
-    def is_ai(self):
-        return self.role
-
-    @property
-    def is_human(self):
-        return not self.role
-
-    def modify_text(self, callback: Callable[[str], str]) -> "ReplicaItem":
-        body_upd = callback(self.body)
-        return self.model_copy(update=dict(body=body_upd))
-
-
-class InnerContextItem(Base):
-    replicas: list[ReplicaItem] = Field(alias="Replicas")
-    attrs: dict[str, str | int] | None = Field(default={}, alias="Attrs")
-
-    def to_dict(self) -> dict[str, list]:
-        return self.model_dump(by_alias=True)
-
-
-class ChatItem(Base):
-    outer_context: OuterContextItem = Field(alias="OuterContext")
-    inner_context: InnerContextItem = Field(alias="InnerContext")
-
-    def create_id(self, short: bool = False) -> str:
-        return self.outer_context.create_id(short)
-
-    def to_dict(self) -> dict[str, Any]:
-        return self.model_dump(by_alias=True)
-
-    def add_replica(self, replica: ReplicaItem):
-        self.inner_context.replicas.append(replica)
-
-    def add_replicas(self, replicas: list[ReplicaItem]):
-        for replica in replicas:
-            self.inner_context.replicas.append(replica)
-
-    def replace_replicas(self, replicas: list[ReplicaItem]):
-        return self.model_copy(update=dict(inner_context=InnerContextItem(replicas=replicas)))
-
-    def get_last_state(self, default: str = "empty") -> str:
-        replicas = self.inner_context.replicas
-        for ii in range(len(replicas) - 1, -1, -1):
-            replica = replicas[ii]
-            if replica.role:
-                return replica.state
-        return default
-
-    def zip_history(self, field: str) -> list[Any]:
-        return [replica.to_dict().get(field, None) for replica in self.inner_context.replicas]
-
-    @classmethod
-    def parse(cls, chat_obj: str | dict) -> "ChatItem":
-        return _parse_chat_item(chat_obj)
-
-
-def _parse_chat_item(chat_obj: str | dict) -> ChatItem:
-    if isinstance(chat_obj, dict):
-        return ChatItem.model_validate(chat_obj)
-
-    return ChatItem.model_validate_json(chat_obj)

mmar_mapi-1.0.7.dist-info/RECORD

@@ -1,17 +0,0 @@
-mmar_mapi/__init__.py,sha256=hhLEK5u9NL1Du3X1M0SzmMPYYq5FIUcbiVNL2_jCZYc,1084
-mmar_mapi/api.py,sha256=C9Sr8dISvf51xfEznPjccI_odaG4coQE3HI_0jVpjMQ,1677
-mmar_mapi/file_storage.py,sha256=GbahBabBdAKjlAnv1MszERUxxZyA9HGMiR9tz2a9dgY,4409
-mmar_mapi/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mmar_mapi/models/base.py,sha256=mKtXV2x51XVj7W-et9tjGcPMDUUUMelW-BywMgFc2p0,411
-mmar_mapi/models/chat.py,sha256=IsIYoHY3Taxnfn-Audeml-WLGIbJgKr_-Arg-ZA8FIE,13293
-mmar_mapi/models/chat_item.py,sha256=ZfCKvTqr7gpuJSAuHVxWRnlTefRwki_IVNA2N_CXGdg,5557
-mmar_mapi/models/enums.py,sha256=J-GNpql9MCnKnWiV9aJRQGI-pAybvV86923RZs99grA,1006
-mmar_mapi/models/tracks.py,sha256=HKDp-BX1p7AlDfSEKfOKCu0TRSK9cD4Dmq1vJt8oRjw,307
-mmar_mapi/models/widget.py,sha256=pQHiOukNLzsrz5lr5ptMeARPxSzJhJnijA0rVpVSIhk,1108
-mmar_mapi/type_union.py,sha256=diwmzcnbqkpGFckPHNw9o8zyQ955mOGNvhTlcBJ0RMI,1905
-mmar_mapi/utils.py,sha256=hcKJVslvTBLw2vjZ9zcKZxh_tqk48obHcVs_i3Rxn3M,112
-mmar_mapi/xml_parser.py,sha256=VvLIX_XCZao9i0qqpTVx8nx0vbFXSe8pEbdJdXnj97g,568
-mmar_mapi-1.0.7.dist-info/licenses/LICENSE,sha256=2A90w8WjhOgQXnFuUijKJYazaqZ4_NTokYb9Po4y-9k,1061
-mmar_mapi-1.0.7.dist-info/WHEEL,sha256=Pi5uDq5Fdo_Rr-HD5h9BiPn9Et29Y9Sh8NhcJNnFU1c,79
-mmar_mapi-1.0.7.dist-info/METADATA,sha256=GnTR9S4PdQJak3j-3tIJ61xrA7bU1AjubCe-vRWkL3I,914
-mmar_mapi-1.0.7.dist-info/RECORD,,