phound 0.1.3__py3-none-win_amd64.whl

phound/__init__.py

@@ -0,0 +1,7 @@
+from phound.main import Phound
+
+from phound.logging import setup_logging as _setup_logging
+
+_setup_logging()
+
+__all__ = ["Phound"]

phound/chats/text_helpers.py

@@ -0,0 +1,36 @@
+from enum import Enum, IntEnum
+
+
+MENTION_FORMAT = "<mention:persona_uid=\"{}\":label=\"{}\">"
+
+
+class MessageTextFormat(IntEnum):
+    PLAIN = 1
+    HTML = 2
+    GPTMARKDOWN = 3
+
+
+class Tag(str, Enum):
+    BOLD = "b"
+    ITALIC = "i"
+    UNDERLINE = "u"
+
+
+def mention(persona_uid: str, label: str = "") -> str:
+    return MENTION_FORMAT.format(persona_uid, label)
+
+
+def bold(text: str) -> str:
+    return _wrap(text, Tag.BOLD)
+
+
+def italic(text: str) -> str:
+    return _wrap(text, Tag.ITALIC)
+
+
+def underline(text: str) -> str:
+    return _wrap(text, Tag.UNDERLINE)
+
+
+def _wrap(text: str, tag: Tag) -> str:
+    return f"<{tag}>{text}</{tag}>"

phound/chats/utils.py

@@ -0,0 +1,63 @@
+from typing import List, Dict, Any, Tuple
+import re
+import mimetypes
+from enum import IntEnum
+
+from PIL import Image
+
+from phound.chats.text_helpers import Tag, MessageTextFormat, MENTION_FORMAT
+
+
+def parse_attachments(attachments: List[str]) -> List[Dict[str, Any]]:
+    parsed_attachments = []
+    for path in attachments:
+        attachment = {"path": path, "type": _AttachmentType.FILE}
+        mime_type, _ = mimetypes.guess_type(path)
+        if mime_type:
+            if mime_type.startswith("audio/"):
+                attachment["type"] = _AttachmentType.SOUND
+            elif mime_type.startswith("image/"):
+                attachment["type"] = _AttachmentType.IMAGE
+                with Image.open(path) as img:
+                    attachment["dimentions"] = img.size
+        parsed_attachments.append(attachment)
+    return parsed_attachments
+
+
+def extract_mentions(raw_text: str, text_format: MessageTextFormat) -> Tuple[str, List[Dict[str, int]]]:
+    mentions = []
+    text = raw_text
+    for match in re.findall(MENTION_FORMAT.format(r"\d+", r".*?"), raw_text):
+        persona_uid, label = re.findall(MENTION_FORMAT.format(r"(\d+)", r"(.*?)"), match)[0]
+        if not label:
+            label = persona_uid
+        mentions.append({
+            "uid": int(persona_uid),
+            "offset": (text.find(match)
+                       if text_format != MessageTextFormat.HTML
+                       else _remove_html_tags(text).find(match)),
+            "length": len(label)}
+        )
+        text = text.replace(match, label, 1)
+    return text, mentions
+
+
+def get_chat_id(from_uid: str, to_uid: str) -> str:
+    return "".join([_uid_to_hex(i) for i in sorted([from_uid, to_uid])])
+
+
+def _uid_to_hex(uid: str) -> str:
+    hex_size = 16
+    direct = hex(int(uid))[2:].upper().zfill(hex_size)
+    chunk_size = 2
+    return "".join(reversed([direct[i:i + chunk_size] for i in range(0, hex_size, chunk_size)]))
+
+
+def _remove_html_tags(text: str) -> str:
+    return re.sub(fr"<({'|'.join(list(Tag))})>(.*?)</\1>", r"\2", text)
+
+
+class _AttachmentType(IntEnum):
+    FILE = 1
+    IMAGE = 2
+    SOUND = 3

phound/client.py

@@ -0,0 +1,173 @@
+from typing import Any, Dict, Optional, List
+import os
+import subprocess
+import json
+import threading
+from pathlib import Path
+
+from phound.events import EventType, Message, Event
+from phound.event_listener import EventListener
+from phound.logging import logger, get_logging_parameters
+from phound.config import settings
+
+_DEFAULT_CHANNEL_ID = "0"
+_HEALTH_CHECK_INTERVAL_SECONDS = 5
+lock = threading.Lock()
+
+
+class Client:
+    def __init__(self) -> None:
+        self._process = self._create_process()
+        self._event_listener = EventListener(self._process.stdout)
+        self._connect()
+
+        self._health_check_thread = _HealthCheckThread(target=self._restart_not_running_process)
+        self._health_check_thread.start()
+
+        self._channels_enabled = False
+        self._channels_port = 0
+
+    def stop(self) -> None:
+        self._health_check_thread.stop()
+        self._health_check_thread.join()
+        self._destroy_process()
+
+    def send_message(self,
+                     persona_uid: str,
+                     chat_id: str,
+                     text: str,
+                     text_format: int,
+                     attachments: Optional[List[Dict[str, Any]]] = None,
+                     mentions: Optional[List[Dict[str, int]]] = None,
+                     app_meta: Optional[Dict[str, Any]] = None,
+                     channel_id: str = _DEFAULT_CHANNEL_ID,
+                     wait_sent: bool = True) -> Optional[Message]:
+        message_json = {
+            "text": text,
+            "chan": channel_id,
+            "wait": wait_sent,
+            "format": text_format,
+        }
+        if attachments:
+            message_json["attachments"] = json.dumps(attachments)
+        if mentions:
+            message_json["mentions"] = json.dumps(mentions)
+        if app_meta:
+            message_json["app_meta"] = json.dumps(app_meta)
+        self._write(f"send-message {persona_uid} {chat_id} {channel_id} <<JSON\n{json.dumps(message_json)}")
+
+    def answer_call(self, call_id: str) -> None:
+        self._write(f"answer {call_id}")
+
+    def delay_call(self, call_id: str, milliseconds: int) -> None:
+        self._write(f"delay {call_id} {milliseconds}")
+
+    def record_call(
+        self,
+        call_id: str,
+        file_path: str,
+        min_smg_len: int = 3,
+        max_sgm_len: int = 5,
+        sgm_overlap: int = 1
+    ) -> None:
+        self._write(f"record {call_id} {file_path} sgm:{min_smg_len}:{max_sgm_len}:{sgm_overlap}")
+
+    def play_file(self, call_id: str, file_path: str) -> None:
+        self._write(f"play {call_id} {file_path}")
+
+    def hangup(self, call_id: str) -> None:
+        self._write(f"hangup {call_id}")
+
+    def show_typing(
+        self, persona_uid: str, chat_id: str, timeout: int = 10, channel_id: str = _DEFAULT_CHANNEL_ID
+    ) -> None:
+        self._write(f"typing-indicator {persona_uid} {chat_id} {timeout} {channel_id}")
+
+    def request_chat_history(
+        self,
+        persona_uid: str,
+        chat_id: str,
+        start_message_id: str,
+        channel_id: str = _DEFAULT_CHANNEL_ID,
+        depth: int = 10
+    ) -> None:
+        self._write(f"get-history-bulk {persona_uid} {chat_id} {start_message_id} {channel_id} {depth}")
+
+    def lookup_phone_number(self, phone_number: str, channel_id: str = _DEFAULT_CHANNEL_ID) -> None:
+        self._write(f"lookup-phone-number {phone_number} {channel_id}")
+
+    def request_next_event(self, channel_id: str) -> None:
+        self._write(f"pump-queue {channel_id}")
+
+    def wait_event(self, *event_types: EventType) -> Event:
+        return self._event_listener.wait_event(*event_types)
+
+    def shutdown(self) -> None:
+        self._write("shutdown")
+
+    def enable_channels(self, port: int) -> None:
+        self._channels_enabled = True
+        self._channels_port = port
+        self._write(f"set-handler channel 127.0.0.1:{port}")
+
+    def _connect(self) -> None:
+        uid, api_key = settings.token.split(".")
+        self._write(f"connect {settings.sbc} {uid} {api_key} {settings.personas}", log=False)
+        self._event_listener.wait_event(EventType.CONNECTED)
+
+    def _create_process(self) -> subprocess.Popen:
+        cmd = [f"{Path(__file__).parent.resolve()}/bin/uccrobot", "-e", "-q"]
+
+        _, log_file_dir = get_logging_parameters()
+        if log_file_dir:
+            cmd.extend(["-l", log_file_dir])
+        cmd.append("-")
+
+        # pylint: disable=W1509
+        return subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            # this is required in order not to receive parent's signals eg SIGINT
+            creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
+            encoding="utf-8",
+            bufsize=0
+        )
+
+    def _destroy_process(self) -> None:
+        self._process.stdin.close()
+        self._process.stdout.close()
+        self._process.wait()
+        logger.info("UCC client process destroyed")
+
+    def _write(self, cmd: str, log: bool = True) -> None:
+        if log:
+            logger.info(f"Sending cmd '{cmd}' to ucc")
+        with lock:
+            self._process.stdin.write(cmd + os.linesep)
+
+    def _restart_not_running_process(self) -> None:
+        while not self._health_check_thread.stopped():
+            if self._process.poll() is not None:
+                logger.error("Found UCC client process died, restarting")
+                self._process = self._create_process()
+                self._event_listener = EventListener(self._process.stdout)
+                self._connect()
+                if self._channels_enabled and self._channels_port:
+                    self.enable_channels(self._channels_port)
+            self._health_check_thread.wait(_HEALTH_CHECK_INTERVAL_SECONDS)
+
+
+class _HealthCheckThread(threading.Thread):
+    def __init__(self,  *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._event = threading.Event()
+
+    def stop(self) -> None:
+        self._event.set()
+
+    def wait(self, timeout: int) -> None:
+        self._event.wait(timeout)
+
+    def stopped(self) -> bool:
+        return self._event.is_set()

phound/config.py

@@ -0,0 +1,30 @@
+import os
+from dataclasses import dataclass
+
+from dotenv import load_dotenv as _load_dotenv
+
+_load_dotenv()
+
+_DEFAULT_SBC = "wss://ow-sbc.phound.app/ucp"
+
+
+@dataclass(frozen=True)
+class Settings:
+    sbc: str
+    token: str
+    personas: str
+    phound_log: bool
+    phound_log_dir: str
+
+    def __post_init__(self) -> None:
+        if not self.token or len(self.token.split(".")) != 2:
+            raise ValueError("Token is invalid, must be in format <uid>.<api_key>")
+
+
+settings = Settings(
+    sbc=os.environ.get("SBC", _DEFAULT_SBC),
+    token=os.environ.get("TOKEN", ""),
+    personas=os.environ.get("PERSONAS", ""),
+    phound_log=os.environ.get("PHOUND_LOG", "False").lower() == "true",
+    phound_log_dir=os.environ.get("PHOUND_LOG_DIR", ""),
+)

phound/event_listener.py

@@ -0,0 +1,34 @@
+from typing import TextIO
+
+from phound import events
+from phound.events import EventType, Event
+from phound import exceptions
+
+
+class EventListener:
+    def __init__(self, source: TextIO) -> None:
+        self._source = source
+
+    def wait_event(self, *event_types: EventType) -> Event:
+        event = self._get_next_event()
+        self._raise_for_error(event)
+        if event_types and event.type not in event_types:
+            raise exceptions.UnexpectedEventError(
+                f"Unexpected event: {event.type}, expected: {', '.join(event_types)}")
+        return event
+
+    def _get_next_event(self) -> Event:
+        while True:
+            data = self._source.readline()
+            if not data:
+                raise exceptions.InputError
+            event = events.parse(data)
+            if event:
+                return event
+
+    @staticmethod
+    def _raise_for_error(event: Event) -> None:
+        if event.type == EventType.ERROR:
+            raise exceptions.PhoundError(event.body)
+        if event.type == EventType.CHAT_ERROR:
+            raise exceptions.ChatError(event.body)