kobil-chat 3.0.0__tar.gz

kobil_chat-3.0.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: kobil-chat
+Version: 3.0.0
+Summary: KOBIL Chat (Mercury) client for Python with automatic OAuth token management.
+License: MIT
+Project-URL: Repository, https://github.com/uveysservetoglu/kobil-sdks
+Keywords: kobil,chat,mercury,messaging
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: kobil-core>=1.0
+
+# kobil-chat
+
+KOBIL Chat (Mercury) client for Python, with automatic OAuth token management.
+
+```bash
+pip install kobil-chat
+```
+
+```python
+from kobil.chat import ChatClient
+
+chat = ChatClient(
+    chat_base_url="https://idp.cloud.kobil.com/auth/realms/{TENANT}/mpower/v1/users/{USER_ID}",
+    tenant_name="acme",
+    token_auth_mode="basic",  # chat token endpoint may require Basic auth
+    media_download_url="https://idp.cloud.kobil.com/v1/mpower/tenants/{TENANT}/media/{MEDIA_ID}/download",
+    # credentials optional if KOBIL_* env vars are set
+)
+
+chat.send_text(user_id, "Hi!", title="Update")
+chat.send_choice(user_id, "Continue?", ["Yes", "No"])
+chat.send_smart_screen(user_id, "Opening…", "service_client_id")
+chat.send_attachment(user_id, open("a.pdf", "rb").read(), file_name="a.pdf", text="Please review")
+data = chat.get_attachment_file(media_id)  # bytes
+```
+
+`{TENANT}` is filled from `tenant_name`, `{USER_ID}` from the call, `{MEDIA_ID}` from
+`get_attachment_file`. Send operations return `{"messageId": ..., "instanceId": ...}`.
+Failures raise `kobil.chat.KobilChatError`.
+
+## License
+
+MIT

kobil_chat-3.0.0/README.md

@@ -0,0 +1,33 @@
+# kobil-chat
+
+KOBIL Chat (Mercury) client for Python, with automatic OAuth token management.
+
+```bash
+pip install kobil-chat
+```
+
+```python
+from kobil.chat import ChatClient
+
+chat = ChatClient(
+    chat_base_url="https://idp.cloud.kobil.com/auth/realms/{TENANT}/mpower/v1/users/{USER_ID}",
+    tenant_name="acme",
+    token_auth_mode="basic",  # chat token endpoint may require Basic auth
+    media_download_url="https://idp.cloud.kobil.com/v1/mpower/tenants/{TENANT}/media/{MEDIA_ID}/download",
+    # credentials optional if KOBIL_* env vars are set
+)
+
+chat.send_text(user_id, "Hi!", title="Update")
+chat.send_choice(user_id, "Continue?", ["Yes", "No"])
+chat.send_smart_screen(user_id, "Opening…", "service_client_id")
+chat.send_attachment(user_id, open("a.pdf", "rb").read(), file_name="a.pdf", text="Please review")
+data = chat.get_attachment_file(media_id)  # bytes
+```
+
+`{TENANT}` is filled from `tenant_name`, `{USER_ID}` from the call, `{MEDIA_ID}` from
+`get_attachment_file`. Send operations return `{"messageId": ..., "instanceId": ...}`.
+Failures raise `kobil.chat.KobilChatError`.
+
+## License
+
+MIT

kobil_chat-3.0.0/kobil/chat/__init__.py

@@ -0,0 +1,197 @@
+"""kobil.chat — KOBIL Chat (Mercury) client."""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.parse
+from typing import Any, Dict, List, Optional, Sequence
+
+from kobil.core import (
+    DefaultTokenProvider,
+    KobilError,
+    ServiceClient,
+    TokenProvider,
+    credentials_from_env,
+    new_uuid,
+)
+
+__all__ = ["ChatClient", "KobilChatError"]
+
+_MIME_BY_EXT = {
+    ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif",
+    ".bmp": "image/bmp", ".webp": "image/webp", ".svg": "image/svg+xml", ".pdf": "application/pdf",
+    ".doc": "application/msword",
+    ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ".xls": "application/vnd.ms-excel",
+    ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ".ppt": "application/vnd.ms-powerpoint",
+    ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ".txt": "text/plain", ".csv": "text/csv", ".json": "application/json", ".xml": "application/xml",
+    ".zip": "application/zip", ".rar": "application/vnd.rar", ".7z": "application/x-7z-compressed",
+    ".mp3": "audio/mpeg", ".mp4": "video/mp4", ".avi": "video/x-msvideo", ".mov": "video/quicktime",
+}
+
+
+class KobilChatError(KobilError):
+    """Thrown when a chat operation fails."""
+
+
+class ChatClient(ServiceClient):
+    def __init__(
+        self,
+        *,
+        chat_base_url: str,
+        token_endpoint: Optional[str] = None,
+        client_id: Optional[str] = None,
+        client_secret: Optional[str] = None,
+        token_auth_mode: Optional[str] = None,
+        media_download_url: Optional[str] = None,
+        tenant_name: Optional[str] = None,
+        service_uuid: Optional[str] = None,
+        version: int = 3,
+        escape_attachment_unicode: bool = True,
+        token_provider: Optional[TokenProvider] = None,
+    ) -> None:
+        credentials = credentials_from_env(
+            token_endpoint=token_endpoint,
+            client_id=client_id,
+            client_secret=client_secret,
+            token_auth_mode=token_auth_mode,
+        )
+        super().__init__(token_provider or DefaultTokenProvider(credentials))
+        if not chat_base_url:
+            raise KobilChatError("chat_base_url is required.")
+        self._chat_base_url = chat_base_url
+        self._media_download_url = media_download_url
+        self._tenant_name = tenant_name
+        self._client_id = credentials.client_id
+        self._service_uuid = service_uuid
+        self._version = version
+        self._escape_unicode = escape_attachment_unicode
+
+    def _make_error(self, message, status_code=None, response_body=None, cause=None) -> KobilError:
+        return KobilChatError(message, status_code, response_body, cause)
+
+    def send_text(self, user_id: str, text: str, title: Optional[str] = None) -> Dict[str, Any]:
+        self._require_user(user_id)
+        return self.send_json("POST", self._message_url(user_id), {
+            "serviceUuid": self._resolve_service_uuid(),
+            "messageType": "processChatMessage",
+            "version": self._version,
+            "messageContent": {"messageText": self._compose_text(title, text)},
+        })
+
+    def send_choice(self, user_id: str, text: str, choices: Sequence[str]) -> Dict[str, Any]:
+        self._require_user(user_id)
+        if not choices:
+            raise KobilChatError("At least one choice is required.")
+        return self.send_json("POST", self._message_url(user_id), {
+            "serviceUuid": self._resolve_service_uuid(),
+            "messageType": "choiceRequest",
+            "version": self._version,
+            "messageContent": {"messageText": text, "choices": [{"text": c} for c in choices]},
+        })
+
+    def send_smart_screen(self, user_id: str, text: str, smart_screen_service_uuid: str) -> Dict[str, Any]:
+        self._require_user(user_id)
+        if not smart_screen_service_uuid:
+            raise KobilChatError("smart_screen_service_uuid cannot be empty.")
+        return self.send_json("POST", self._message_url(user_id), {
+            "serviceUuid": self._resolve_service_uuid(),
+            "messageType": "smartScreenService",
+            "version": self._version,
+            "messageContent": {"messageText": text, "smartScreenServiceUuid": smart_screen_service_uuid},
+        })
+
+    def send_attachment(self, user_id: str, file: bytes, file_name: Optional[str] = None,
+                        content_type: Optional[str] = None, file_extension: Optional[str] = None,
+                        title: Optional[str] = None, text: Optional[str] = None) -> Dict[str, Any]:
+        self._require_user(user_id)
+        if not file:
+            raise KobilChatError("file cannot be empty.")
+        message = {
+            "serviceUuid": self._resolve_service_uuid(),
+            "messageType": "attachmentMessage",
+            "version": self._version,
+            "messageContent": {"messageText": self._compose_attachment_text(title, text)},
+        }
+        message_json = json.dumps(message, ensure_ascii=False)
+        if self._escape_unicode:
+            message_json = _escape_non_ascii(message_json)
+        files = {
+            "attachment": {
+                "content": file,
+                "filename": _file_name(file_name, file_extension),
+                "content_type": _content_type(content_type, file_name, file_extension),
+            }
+        }
+        return self.send_multipart("POST", self._media_url(user_id), {"message": message_json}, files)
+
+    def get_attachment_file(self, media_id: str) -> bytes:
+        if not media_id:
+            raise KobilChatError("media_id cannot be empty.")
+        if not self._media_download_url:
+            raise KobilChatError("media_download_url is required to download attachments.")
+        url = self._replace_tokens(self._media_download_url, {"{TENANT}": self._tenant_name, "{MEDIA_ID}": media_id})
+        return self.send_for_bytes("POST", url)
+
+    def _message_url(self, user_id: str) -> str:
+        return self._user_base_url(user_id) + "/message"
+
+    def _media_url(self, user_id: str) -> str:
+        return self._user_base_url(user_id) + "/media"
+
+    def _user_base_url(self, user_id: str) -> str:
+        return self._replace_tokens(self._chat_base_url, {"{TENANT}": self._tenant_name, "{USER_ID}": user_id}).rstrip("/")
+
+    def _resolve_service_uuid(self) -> str:
+        return self._service_uuid or self._client_id
+
+    @staticmethod
+    def _compose_text(title: Optional[str], text: str) -> str:
+        return f"{title}\n\n{text}" if title else text
+
+    @staticmethod
+    def _compose_attachment_text(title: Optional[str], text: Optional[str]) -> str:
+        out = ""
+        if title:
+            out += f"*{title}*"
+        if title and text:
+            out += f"\n\n{text}"
+        elif not title and text:
+            out += text
+        return out
+
+    @staticmethod
+    def _replace_tokens(template: str, tokens: Dict[str, Optional[str]]) -> str:
+        for token, value in tokens.items():
+            template = template.replace(token, urllib.parse.quote(value or "", safe=""))
+        return template
+
+    @staticmethod
+    def _require_user(user_id: str) -> None:
+        if not user_id:
+            raise KobilChatError("user_id cannot be empty.")
+
+
+def _content_type(content_type: Optional[str], file_name: Optional[str], file_extension: Optional[str]) -> str:
+    if content_type:
+        return content_type
+    ext = (file_extension or "").lower()
+    if not ext and file_name:
+        ext = os.path.splitext(file_name)[1].lower()
+    return _MIME_BY_EXT.get(ext, "application/octet-stream")
+
+
+def _file_name(file_name: Optional[str], file_extension: Optional[str]) -> str:
+    if file_name:
+        return file_name
+    ext = (file_extension or ".bin").lower()
+    if not ext.startswith("."):
+        ext = "." + ext
+    return f"{new_uuid()}{ext}"
+
+
+def _escape_non_ascii(text: str) -> str:
+    return "".join(c if ord(c) < 128 else "\\u%04x" % ord(c) for c in text)

kobil_chat-3.0.0/kobil_chat.egg-info/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: kobil-chat
+Version: 3.0.0
+Summary: KOBIL Chat (Mercury) client for Python with automatic OAuth token management.
+License: MIT
+Project-URL: Repository, https://github.com/uveysservetoglu/kobil-sdks
+Keywords: kobil,chat,mercury,messaging
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: kobil-core>=1.0
+
+# kobil-chat
+
+KOBIL Chat (Mercury) client for Python, with automatic OAuth token management.
+
+```bash
+pip install kobil-chat
+```
+
+```python
+from kobil.chat import ChatClient
+
+chat = ChatClient(
+    chat_base_url="https://idp.cloud.kobil.com/auth/realms/{TENANT}/mpower/v1/users/{USER_ID}",
+    tenant_name="acme",
+    token_auth_mode="basic",  # chat token endpoint may require Basic auth
+    media_download_url="https://idp.cloud.kobil.com/v1/mpower/tenants/{TENANT}/media/{MEDIA_ID}/download",
+    # credentials optional if KOBIL_* env vars are set
+)
+
+chat.send_text(user_id, "Hi!", title="Update")
+chat.send_choice(user_id, "Continue?", ["Yes", "No"])
+chat.send_smart_screen(user_id, "Opening…", "service_client_id")
+chat.send_attachment(user_id, open("a.pdf", "rb").read(), file_name="a.pdf", text="Please review")
+data = chat.get_attachment_file(media_id)  # bytes
+```
+
+`{TENANT}` is filled from `tenant_name`, `{USER_ID}` from the call, `{MEDIA_ID}` from
+`get_attachment_file`. Send operations return `{"messageId": ..., "instanceId": ...}`.
+Failures raise `kobil.chat.KobilChatError`.
+
+## License
+
+MIT

kobil_chat-3.0.0/kobil_chat.egg-info/SOURCES.txt

@@ -0,0 +1,8 @@
+README.md
+pyproject.toml
+kobil/chat/__init__.py
+kobil_chat.egg-info/PKG-INFO
+kobil_chat.egg-info/SOURCES.txt
+kobil_chat.egg-info/dependency_links.txt
+kobil_chat.egg-info/requires.txt
+kobil_chat.egg-info/top_level.txt

kobil_chat-3.0.0/kobil_chat.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kobil_chat-3.0.0/kobil_chat.egg-info/requires.txt

@@ -0,0 +1 @@
+kobil-core>=1.0

kobil_chat-3.0.0/kobil_chat.egg-info/top_level.txt

@@ -0,0 +1 @@
+kobil

kobil_chat-3.0.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kobil-chat"
+version = "3.0.0"
+description = "KOBIL Chat (Mercury) client for Python with automatic OAuth token management."
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = ["kobil", "chat", "mercury", "messaging"]
+dependencies = ["kobil-core>=1.0"]
+
+[project.urls]
+Repository = "https://github.com/uveysservetoglu/kobil-sdks"
+
+[tool.setuptools.packages.find]
+include = ["kobil*"]
+namespaces = true

kobil_chat-3.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+