irispy-client 0.0.9__py3-none-any.whl

iris/__init__.py

@@ -0,0 +1,6 @@
+__version__ = "0.0.9"
+
+from iris.bot import Bot
+from iris.bot.models import ChatContext, Message, Room, User
+from iris.kakaolink import IrisLink
+from iris.util import PyKV

iris/bot/__init__.py

@@ -0,0 +1,115 @@
+import json
+import time
+from dataclasses import dataclass
+import typing as t
+
+from websockets.sync.client import connect
+from iris.bot._internal.emitter import EventEmitter
+from iris.bot._internal.iris import IrisAPI, IrisRequest
+from iris.bot.models import ChatContext, Message, Room, User
+
+class Bot:
+    def __init__(self, iris_url: str, *, max_workers=None):
+        self.emitter = EventEmitter(max_workers=max_workers)
+
+        self.iris_url = iris_url.replace(
+                "http://",
+                "",
+            ).replace(
+                "https://",
+                "",
+            ).replace(
+                "ws://",
+                "",
+            ).replace(
+                "wss://",
+                "",
+            )
+        if self.iris_url.endswith("/"):
+            self.iris_url = self.iris_url[:-1]
+            
+        self.iris_ws_endpoint = f"ws://{self.iris_url}/ws"
+        self.api = IrisAPI(f"http://{iris_url}")
+
+    def __process_chat(self, chat: ChatContext):
+        self.emitter.emit("chat", [chat])
+
+        origin = chat.message.v.get("origin")
+        if origin == "MSG":
+            self.emitter.emit("message", [chat])
+        elif origin == "NEWMEM":
+            self.emitter.emit("new_member", [chat])
+        elif origin == "DELMEM":
+            self.emitter.emit("del_member", [chat])
+
+    def __process_iris_request(self, req: IrisRequest):
+        v = {}
+        try:
+            v = json.loads(req.raw["v"])
+        except Exception:
+            pass
+
+        room = Room(
+            id=int(req.raw["chat_id"]),
+            name=req.room,
+            api=self.api,
+        )
+        sender = User(
+            id=int(req.raw["user_id"]),
+            chat_id=room.id,
+            api=self.api,
+            name=req.sender,
+            bot_id=self.bot_id,
+        )
+        message = Message(
+            id=int(req.raw["id"]),
+            type=int(req.raw["type"]),
+            msg=req.raw["message"],
+            attachment=req.raw["attachment"],
+            v=v,
+        )
+
+        chat = ChatContext(
+            room=room, sender=sender, message=message, raw=req.raw, api=self.api, _bot_id=self.bot_id
+        )
+        self.__process_chat(chat)
+
+    def run(self):
+        while True:
+            try:
+                with connect(self.iris_ws_endpoint, close_timeout=0) as ws:
+                    print("웹소켓에 연결되었습니다")
+                    self.bot_id = self.api.get_info()["bot_id"]
+                    while True:
+                        recv = ws.recv()
+                        try:
+                            data: dict = json.loads(recv)
+                            data["raw"] = data.get("json")
+                            del data["json"]
+
+                            self.__process_iris_request(IrisRequest(**data))
+                        except Exception as e:
+                            print(
+                                "Iris 이벤트를 처리 중 오류가 발생했습니다: {}", e
+                            )
+            except KeyboardInterrupt:
+                print("웹소켓 연결을 종료합니다")
+                break
+            
+            except Exception as e:
+                print("웹소켓 연결 오류: {}", e)
+                print("3초 후 재연결합니다")
+
+            time.sleep(3)
+
+    def on_event(self, name: str):
+        def decorator(func: t.Callable):
+            self.emitter.register(name, func)
+
+            def wrapper(*args, **kwargs):
+                return func(*args, **kwargs)
+
+            return wrapper
+
+        return decorator
+

iris/bot/_internal/emitter.py

@@ -0,0 +1,46 @@
+import concurrent.futures
+import traceback
+import typing as t
+from iris.bot.models import ErrorContext
+from iris.util.pykv import PyKV
+import sys
+
+
+class EventEmitter:
+    def __init__(self, max_workers=None):
+        self.ev: dict[str, list[t.Callable]] = {}
+        self.pool = concurrent.futures.ThreadPoolExecutor(max_workers=max_workers)
+
+    def register(self, name: str, func: t.Callable):
+        name = name.lower()
+
+        if name not in self.ev:
+            self.ev[name] = []
+
+        self.ev[name].append(func)
+
+    def emit(self, name: str, args: list[t.Any]):
+        name = name.lower()
+
+        for func in self.ev.get(name, []):
+            self.pool.submit(self._handle_event, func, name, args)
+
+    def _handle_event(self, func, name, args):
+        try:
+            kv = PyKV()
+            func(*args)
+        except Exception as e:
+            if name == "error":
+                print(f"error handler에서 오류가 발생했습니다 ({e})")
+                traceback.print_exc()
+                return
+            else:
+                print(f"오류가 발생했습니다 ({e})")
+                traceback.print_exc()
+
+            self.emit(
+                "error", [ErrorContext(event=name, func=func, exception=e, args=args)]
+            )
+        finally:
+            kv.close()
+            sys.stdout.flush()

iris/bot/_internal/iris.py

@@ -0,0 +1,113 @@
+from dataclasses import dataclass
+import requests
+import typing as t
+import base64
+from io import BufferedIOBase, BytesIO, BufferedReader
+from PIL import Image
+
+@dataclass
+class IrisRequest:
+    msg: str
+    room: str
+    sender: str
+    raw: dict
+    
+class IrisAPI:
+    def __init__(self, iris_endpoint: str):
+        self.iris_endpoint = iris_endpoint
+
+    def __parse(self, res: requests.Response) -> dict:
+        try:
+            data: dict = res.json()
+        except Exception:
+            raise Exception(f"Iris 응답 JSON 파싱 오류: {res.text}")
+
+        if not 200 <= res.status_code <= 299:
+            print(f"Iris 오류: {res}")
+            raise Exception(f"Iris 오류: {data.get('message', '알 수 없는 오류')}")
+
+        return data
+
+    def reply(self, room_id: int, msg: str):
+        res = requests.post(
+            f"{self.iris_endpoint}/reply",
+            json={"type": "text", "room": str(room_id), "data": str(msg)},
+        )
+        return self.__parse(res)
+
+    def reply_media(
+        self,
+        room_id: int,
+        files: t.List[BufferedIOBase | bytes | Image.Image | str],
+    ):
+        if type(files) is not list:
+            files = [files]
+        data = []
+        for file in files:
+            try:
+                if isinstance(file, BufferedIOBase):
+                    data.append(base64.b64encode(file.read()).decode())
+                elif isinstance(file, bytes):
+                    data.append(base64.b64encode(file).decode())
+                elif isinstance(file, Image.Image):
+                    image_bytes_io = BytesIO()
+                    img = file.convert("RGBA")
+                    img.save(image_bytes_io, format="PNG")
+                    image_bytes_io.seek(0)
+                    buffered_reader = BufferedReader(image_bytes_io)
+                    data.append(base64.b64encode(buffered_reader.read()).decode())
+                elif isinstance(file, str):
+                    try:
+                        if file.startswith("http"):
+                            res = requests.get(file)
+                            if res.status_code == 200:
+                                file = res.content
+                            else:
+                                print(f"이미지 다운로드 실패: {res.status_code}")
+                        else:
+                            with open(file, "rb") as f:
+                                file = f.read()
+                        data.append(base64.b64encode(file).decode())
+                    except Exception as e:
+                        print(f"이미지 처리 중 오류 발생: {e}")
+                else:
+                    print(f"지원하지 않는 형식입니다: {type(file)}")
+            except TypeError as e:
+                print(f"이미지 처리 중 오류 발생: {e}")
+                continue
+        if len(data) > 0:
+            res = requests.post(
+                f"{self.iris_endpoint}/reply",
+                json={
+                    "type": "image_multiple",
+                    "room": str(room_id),
+                    "data": data,
+                },
+            )
+            return self.__parse(res)
+        else:
+            print("이미지 전송이 모두 실패하였습니다. 이미지 전송 요청 부분을 확인해주세요.")
+
+    def decrypt(self, enc: int, b64_ciphertext: str, user_id: int) -> str | None:
+        res = requests.post(
+            f"{self.iris_endpoint}/decrypt",
+            json={"enc": enc, "b64_ciphertext": b64_ciphertext, "user_id": user_id},
+        )
+
+        res = self.__parse(res)
+        return res.get("plain_text")
+
+    def query(self, query: str, bind: list[t.Any] | None = None) -> list[dict]:
+        res = requests.post(
+            f"{self.iris_endpoint}/query", json={"query": query, "bind": bind or []}
+        )
+        res = self.__parse(res)
+        return res.get("data", [])
+
+    def get_info(self):
+        res = requests.get(f"{self.iris_endpoint}/config")
+        return self.__parse(res)
+
+    def get_aot(self):
+        res = requests.get(f"{self.iris_endpoint}/aot")
+        return self.__parse(res)

iris/bot/models.py

@@ -0,0 +1,382 @@
+from dataclasses import dataclass
+import typing as t
+from iris.bot._internal.iris import IrisAPI
+import json
+from functools import cached_property
+from PIL import Image
+from io import BytesIO, BufferedIOBase
+import requests
+
+@dataclass
+class Message:
+    id: int
+    type: int
+    msg: str
+    attachment: str
+    v: dict
+
+    def __post_init__(self):
+        self.command, *param = self.msg.split(" ", 1)
+        self.has_param = len(param) > 0
+        self.param = param[0] if self.has_param else None
+        try:
+            self.attachment = json.loads(self.attachment)
+        except Exception:
+            pass
+        if self.type in [71,27,2,71+16384,27+16384,2+16384]:
+            self.image = ChatImage(self)
+        else:
+            self.image = None
+    
+    def __repr__(self) -> str:
+        return f"Message(id={self.id}, type={self.type}, msg={self.msg})"
+
+class Room:
+    def __init__(self, id: int, name: str, api: IrisAPI):
+        self.id = id
+        self.name = name
+        self._api = api
+
+    @cached_property
+    def type(self) -> t.Optional[str]:
+        try:
+            results = self._api.query(
+                'select type from chat_rooms where id = ?',
+                [self.id]
+            )
+            if results and results[0]:
+                fetched_type = results[0].get("type")
+                return fetched_type
+            else:
+                return None
+
+        except Exception as e:
+            return None
+
+    def __repr__(self) -> str:
+        return f"Room(id={self.id}, name={self.name})"
+
+
+class User:
+    def __init__(self, id: int, chat_id: int, api: IrisAPI, name: str = None, bot_id: int = None):
+        self.id = id
+        self._chat_id = chat_id
+        self._api = api
+        self._name = name
+        self._bot_id = bot_id
+        self.avatar = Avatar(id, chat_id, api)
+    
+    @cached_property
+    def name(self) -> t.Optional[str]:
+        try:
+            if not self._name:
+                if self.id == self._bot_id:
+                    query = "SELECT T2.nickname FROM chat_rooms AS T1 JOIN db2.open_profile AS T2 ON T1.link_id = T2.link_id WHERE T1.id = ?"
+                    results = self._api.query(query, [self._chat_id])
+                    name = results[0].get("nickname")
+                elif self.id < 10000000000:
+                    query = "SELECT name, enc FROM db2.friends WHERE id = ?"
+                    results = self._api.query(query, [self.id])
+                    name = results[0].get("name")
+                else:
+                    query = "SELECT nickname,enc FROM db2.open_chat_member WHERE user_id = ?"
+                    results = self._api.query(query, [self.id])
+                    name = results[0].get("original_profile_image_url")
+                return name
+            
+            else:
+                return self._name
+            
+        except Exception as e:
+            return None
+    
+    @cached_property
+    def type(self) -> t.Optional[str]:
+        try:
+            if self.id == self._bot_id:
+                query = "SELECT T2.link_member_type FROM chat_rooms AS T1 INNER JOIN open_profile AS T2 ON T1.link_id = T2.link_id WHERE T1.id = ?"
+                results = self._api.query(query, [self._chat_id])
+                
+            else:
+                query = "SELECT link_member_type FROM db2.open_chat_member WHERE user_id = ?"
+                results = self._api.query(query, [self.id])
+            
+            member_type = int(results[0].get("link_member_type"))
+            match member_type:
+                case 1:
+                    return "HOST"
+                case 2:
+                    return "NORMAL"
+                case 4:
+                    return "MANAGER"
+                case 8:
+                    return "BOT"
+                case _:
+                    return "UNKNOWN"
+            
+        except Exception as e:
+            return "REAL_PROFILE"
+    
+    def __repr__(self) -> str:
+        return f"User(name={self.name})"
+
+class Avatar:
+    def __init__(self, id: int, chat_id: int, api: IrisAPI):
+        self._id = id
+        self._api = api
+        self._chat_id = chat_id
+
+    @cached_property
+    def url(self) -> t.Optional[str]:
+        try:
+            if self._id < 10000000000:
+                query = "SELECT T2.o_profile_image_url FROM chat_rooms AS T1 JOIN db2.open_profile AS T2 ON T1.link_id = T2.link_id WHERE T1.id = ?"
+                results = self._api.query(query, [self._chat_id])
+                fetched_url = results[0].get("o_profile_image_url")
+            else:
+                query = "SELECT original_profile_image_url,enc FROM db2.open_chat_member WHERE user_id = ?"
+                results = self._api.query(query, [self._id])
+                fetched_url = results[0].get("original_profile_image_url")
+            return fetched_url
+            
+        except Exception as e:
+            return None
+
+    @cached_property
+    def img(self) -> t.Optional[bytes]:
+        avatar_url = self.url
+
+        if not avatar_url:
+            return None
+
+        try:
+            image_data = self.__get_image_from_url(avatar_url)
+            return image_data
+        except Exception as e:
+            print(f"아바타 이미지 로딩 실패: {e}")
+            return None
+    
+    def __get_image_from_url(self, url: str) -> Image:
+        try:
+            img = Image.open(BytesIO(requests.get(url).content))
+            img = img.convert("RGBA")
+            return img
+        except Exception as e:
+            print(f"아바타 이미지 로딩 실패: {e}")
+            return None
+
+    def __repr__(self) -> str:
+        return f"Avatar(url={self.url})"
+
+class ChatImage:
+    def __init__(self, message: Message):
+        self.url = self.__get_photo_url(message)
+        
+    @cached_property
+    def img(self):
+        if not self.url:
+            return None
+
+        try:
+            imgs = []
+            for url in self.url:
+                imgs.append(self.__get_image_from_url(url))
+            return imgs
+        except Exception as e:
+            return None
+    
+    def __get_photo_url(self, message) -> list:        
+        try:
+            urls = []
+            if message.type == 71:
+                for item in message.attachment["C"]["THL"]:
+                    urls.append(item["TH"]["THU"])
+            elif message.type == 27:
+                for item in message.attachment["imageUrls"]:
+                    urls.append(item)
+            else:
+                urls.append(message.attachment["url"])
+            return urls
+        except Exception as e:
+            return None
+    
+    def __get_image_from_url(self, url: str) -> Image:
+        try:
+            img = Image.open(BytesIO(requests.get(url).content))
+            img = img.convert("RGBA")
+            return img
+        except Exception as e:
+            print(f"이미지 로딩 실패: {e}")
+            return None
+
+    def __repr__(self) -> str:
+        return f"ChatImage(url={self.url})"
+
+@dataclass
+class ChatContext:
+    room: Room
+    sender: User
+    message: Message
+    raw: dict
+    api: IrisAPI
+    _bot_id: int = None
+
+    def __post_init__(self):
+        pass
+
+    def reply(self, message: str, room_id: int = None):
+        if room_id is None:
+            room_id = self.room.id
+
+        try:
+            self.api.reply(room_id, message)
+        except Exception as e:
+            print(f"reply 오류: {e}")
+
+    def reply_media(
+        self,
+        files: t.List[BufferedIOBase | bytes | Image.Image | str],
+        room_id: int = None,
+    ):
+        if room_id is None:
+            room_id = self.room.id
+        
+        self.api.reply_media(room_id, files)
+    
+    def get_source(self):
+        source_record = self.__get_reply_chat(self.message)
+        if source_record:
+            source_chat = self.__make_chat(self, source_record)
+            return source_chat
+        else:
+            return None
+
+    def get_next_chat(self, n: int = 1):
+        next_record = self.__get_next_record(self.message.id, n)
+        if next_record:
+            next_chat = self.__make_chat(self, next_record)
+            return next_chat
+        else:
+            return None
+
+    def get_previous_chat(self, n: int = 1):
+        previous_record = self.__get_previous_record(self.message.id, n)
+        if previous_record:
+            previous_chat = self.__make_chat(self, previous_record)
+            return previous_chat
+        else:
+            return None
+        
+    def __get_reply_chat(self, message: Message):
+        try:
+            src_log_id = message.attachment['src_logId']
+            query = "select * from chat_logs where id = ?"    
+            src_record = self.api.query(query,[src_log_id])
+            return src_record[0]
+        except Exception as e:
+            print(e)
+            return None
+    
+    def __get_previous_record(self, log_id, n: int = 1):
+        if n < 0:
+            raise ValueError("n must be greater than 0")
+        
+        query = """
+            WITH RECURSIVE ChatHistory AS (
+                SELECT *
+                FROM chat_logs
+                WHERE id = ?
+                UNION ALL
+                SELECT c.*
+                FROM chat_logs c
+                JOIN ChatHistory h ON c.id = h.prev_id
+            )
+            SELECT *
+            FROM ChatHistory
+            LIMIT 1 OFFSET ?;
+            """
+        record = self.api.query(query, [log_id, n])
+        return record[0] if record else None
+
+    def __get_next_record(self, log_id, n: int = 1):
+        n = n - 1
+        if n < -1:
+            raise ValueError("n must be greater than 0")
+        query = """
+            WITH RECURSIVE ChatHistory AS (
+                SELECT
+                    *,
+                    0 AS depth
+                FROM
+                    chat_logs
+                WHERE
+                    id = ?
+
+                UNION ALL
+
+                SELECT
+                    c.*,
+                    h.depth + 1
+                FROM
+                    chat_logs c
+                JOIN ChatHistory h ON c.prev_id = h.id
+                WHERE
+                    h.depth < 100
+                    AND c.prev_id IS NOT NULL
+                    AND h.id IS NOT NULL
+                    AND c.id IS NOT NULL
+            )
+            SELECT *
+            FROM ChatHistory
+            WHERE depth = ? + 1
+            LIMIT 1; 
+            """
+        record = self.api.query(query, [log_id, n])
+        return record[0] if record else None
+    
+    def __make_chat(self, chat, record):
+        v = {}
+        try:
+            v = json.loads(record["v"])
+        except Exception:
+            pass
+
+        room = Room(
+            id=int(record["chat_id"]),
+            name=chat.room.name,
+            api=self.api,
+        )
+        sender = User(
+            id=int(record["user_id"]),
+            chat_id=chat.room.id,
+            api=self.api,
+            name=self.__get_name_of_user_id(int(record["user_id"])),
+            bot_id=self._bot_id,
+        )
+        message = Message(
+            id=int(record["id"]),
+            type=int(record["type"]),
+            msg=record["message"],
+            attachment=record["attachment"],
+            v=v,
+        )
+        new_chat = ChatContext(
+            room=room, sender=sender, message=message, raw=record, api=self.api, _bot_id=self._bot_id
+        )
+        
+        return new_chat
+    
+    def __get_name_of_user_id(self, user_id: int):
+        query = "WITH info AS (SELECT ? AS user_id) SELECT COALESCE(open_chat_member.nickname, friends.name) AS name, COALESCE(open_chat_member.enc, friends.enc) AS enc FROM info LEFT JOIN db2.open_chat_member ON open_chat_member.user_id = info.user_id LEFT JOIN db2.friends ON friends.id = info.user_id;"
+        result = self.api.query(query,[user_id])
+        if len(result) == 0:
+            return None
+        return result[0]['name']
+
+@dataclass
+class ErrorContext:
+    event: str
+    func: t.Callable
+    exception: Exception
+    args: list[t.Any]
+