slidge 0.1.0b2__py3-none-any.whl → 0.1.1__py3-none-any.whl

slidge/plugins/skype.py

@@ -1,325 +0,0 @@
-import asyncio
-import concurrent.futures
-import io
-import logging
-import pprint
-import threading
-from pathlib import Path
-from threading import Lock, Thread
-from typing import Any, Optional
-
-import aiohttp
-import skpy
-from slixmpp import JID
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-
-class Gateway(BaseGateway["Session"]):
-    REGISTRATION_INSTRUCTIONS = "Enter skype credentials"
-    REGISTRATION_FIELDS = [
-        FormField(var="username", label="Username", required=True),
-        FormField(var="password", label="Password", required=True, private=True),
-    ]
-
-    ROSTER_GROUP = "Skype"
-
-    COMPONENT_NAME = "Skype (slidge)"
-    COMPONENT_TYPE = "skype"
-
-    COMPONENT_AVATAR = "https://logodownload.org/wp-content/uploads/2017/05/skype-logo-1-1-2048x2048.png"
-
-    async def validate(
-        self, user_jid: JID, registration_form: dict[str, Optional[str]]
-    ):
-        pass
-
-    def __init__(self, args):
-        super().__init__(args)
-        self.executor = concurrent.futures.ThreadPoolExecutor()
-
-    def shutdown(self):
-        super().shutdown()
-        log.debug("Shutting down thread pool")
-        self.executor.shutdown(wait=False, cancel_futures=True)
-        log.debug("Shutting down user threads")
-        for user in user_store.get_all():
-            session = self._session_cls.from_jid(user.jid)
-            if thread := session.thread:
-                thread.stop()
-
-
-class Roster(LegacyRoster):
-    # ':' is forbidden in the username part of a JID
-
-    @staticmethod
-    def legacy_id_to_jid_username(legacy_id: str) -> str:
-        if legacy_id.startswith("live:"):
-            return legacy_id.replace("live:", "__live__")
-        else:
-            return legacy_id
-
-    @staticmethod
-    def jid_username_to_legacy_id(jid_username: str) -> str:
-        if jid_username.startswith("__live__"):
-            return jid_username.replace("__live__", "live:")
-        else:
-            return jid_username
-
-
-class Contact(LegacyContact):
-    def update_presence(self, status: skpy.SkypeUtils.Status):
-        if status == skpy.SkypeUtils.Status.Offline:
-            self.offline()
-        elif status == skpy.SkypeUtils.Status.Busy:
-            self.busy()
-        elif status == skpy.SkypeUtils.Status.Away:
-            self.away("Away")
-        elif status == skpy.SkypeUtils.Status.Idle:
-            self.away("Idle")
-        elif status == skpy.SkypeUtils.Status.Online:
-            self.online()
-        else:
-            log.warning("Unknown contact status: %s", status)
-
-
-class ListenThread(Thread):
-    def __init__(self, session: "Session", *a, **kw):
-        super().__init__(*a, **kw, daemon=True)
-        self.name = f"listen-{session.user.bare_jid}"
-        self.session = session
-        self._target = self.skype_blocking
-        self.stop_event = threading.Event()
-
-    def skype_blocking(self):
-        session = self.session
-        sk = session.sk
-        loop = session.xmpp.loop
-        while True:
-            if self.stop_event.is_set():
-                break
-            for event in sk.getEvents():
-                # no need to sleep since getEvents blocks for 30 seconds already
-                asyncio.run_coroutine_threadsafe(session.on_skype_event(event), loop)
-
-    def stop(self):
-        self.stop_event.set()
-
-
-class Session(BaseSession[Contact, Roster, Gateway]):
-    skype_token_path: Path
-    sk: skpy.Skype
-    thread: Optional[ListenThread]
-    sent_by_user_to_ack: dict[int, asyncio.Future]
-    unread_by_user: dict[int, skpy.SkypeMsg]
-    send_lock: Lock
-
-    def post_init(self):
-        self.skype_token_path = self.xmpp.home_dir / self.user.bare_jid
-        self.thread = None
-        self.sent_by_user_to_ack = {}
-        self.unread_by_user = {}
-        self.send_lock = Lock()
-
-    async def async_wrap(self, func, *args):
-        return await self.xmpp.loop.run_in_executor(self.xmpp.executor, func, *args)
-
-    async def login(self):
-        f = self.user.registration_form
-        self.sk = await self.async_wrap(
-            skpy.Skype,
-            f["username"],
-            f["password"],
-            str(self.skype_token_path),
-        )
-
-        self.sk.subscribePresence()
-        for contact in self.sk.contacts:
-            c = self.contacts.by_legacy_id(contact.id)
-            first = contact.name.first
-            last = contact.name.last
-            if first is not None and last is not None:
-                c.name = f"{first} {last}"
-            elif first is not None:
-                c.name = first
-            elif last is not None:
-                c.name = last
-            if contact.avatar is not None:
-                c.avatar = contact.avatar
-            await c.add_to_roster()
-        # TODO: Creating 1 thread per user is probably very not optimal.
-        #       We should contribute to skpy to make it aiohttp compatible…
-        self.thread = thread = ListenThread(self)
-        thread.start()
-        return f"Connected as '{self.sk.userId}'"
-
-    async def on_skype_event(self, event: skpy.SkypeEvent):
-        log.debug("Skype event: %s", event)
-        if isinstance(event, skpy.SkypeNewMessageEvent):
-            while self.send_lock.locked():
-                await asyncio.sleep(0.1)
-            msg = event.msg
-            chat = event.msg.chat
-            if isinstance(chat, skpy.SkypeSingleChat):
-                log.debug("this is a single chat with user: %s", chat.userIds[0])
-                contact = self.contacts.by_legacy_id(chat.userIds[0])
-                if msg.userId == self.sk.userId:
-                    try:
-                        fut = self.sent_by_user_to_ack.pop(msg.clientId)
-                    except KeyError:
-                        if log.isEnabledFor(logging.DEBUG):
-                            log.debug(
-                                "Slidge did not send this message: %s",
-                                pprint.pformat(vars(event)),
-                            )
-                        contact.carbon(msg.plain)
-                    else:
-                        fut.set_result(msg)
-                else:
-                    if isinstance(msg, skpy.SkypeTextMsg):
-                        contact.send_text(msg.plain, legacy_msg_id=msg.clientId)
-                        self.unread_by_user[msg.clientId] = msg
-                    elif isinstance(msg, skpy.SkypeFileMsg):
-                        file = io.BytesIO(
-                            await self.async_wrap(lambda: msg.fileContent)
-                        )  # non-blocking download / lambda because fileContent = property
-                        await contact.send_file(filename=msg.file.name, input_file=file)
-        elif isinstance(event, skpy.SkypeTypingEvent):
-            contact = self.contacts.by_legacy_id(event.userId)
-            if event.active:
-                contact.composing()
-            else:
-                contact.paused()
-        elif isinstance(event, skpy.SkypeEditMessageEvent):
-            msg = event.msg
-            chat = event.msg.chat
-            if isinstance(chat, skpy.SkypeSingleChat):
-                if (user_id := msg.userId) != self.sk.userId:
-                    if log.isEnabledFor(logging.DEBUG):
-                        log.debug("edit msg event: %s", pprint.pformat(vars(event)))
-                    contact = self.contacts.by_legacy_id(user_id)
-                    msg_id = msg.clientId
-                    log.debug("edited msg id: %s", msg_id)
-                    if text := msg.plain:
-                        contact.correct(msg_id, text)
-                    else:
-                        if msg_id:
-                            contact.retract(msg_id)
-                        else:
-                            contact.send_text(
-                                "/me tried to remove a message, but slidge got in trouble"
-                            )
-        elif isinstance(event, skpy.SkypeChatUpdateEvent):
-            if log.isEnabledFor(logging.DEBUG):
-                log.debug("chat update: %s", pprint.pformat(vars(event)))
-        elif isinstance(event, skpy.SkypePresenceEvent):
-            if event.userId != self.sk.userId:
-                self.contacts.by_legacy_id(event.userId).update_presence(event.status)
-
-        # No 'contact has read' event :( https://github.com/Terrance/SkPy/issues/206
-        await self.async_wrap(event.ack)
-
-    async def send_text(self, t: str, c: LegacyContact, *, reply_to_msg_id=None):
-        chat = self.sk.contacts[c.legacy_id].chat
-        self.send_lock.acquire()
-        msg = await self.async_wrap(chat.sendMsg, t)
-        if log.isEnabledFor(logging.DEBUG):
-            log.debug("Sent msg: %s", pprint.pformat(vars(msg)))
-        future = asyncio.Future[skpy.SkypeMsg]()
-        self.sent_by_user_to_ack[msg.clientId] = future
-        self.send_lock.release()
-        skype_msg = await future
-        return skype_msg.clientId
-
-    async def logout(self):
-        if self.thread is not None:
-            self.thread.stop()
-            self.thread.join()
-
-    async def send_file(self, u: str, c: LegacyContact, *, reply_to_msg_id=None):
-        async with aiohttp.ClientSession() as session:
-            async with session.get(u) as response:
-                file_bytes = await response.read()
-        fname = u.split("/")[-1]
-        fname_lower = fname.lower()
-        await self.async_wrap(
-            self.sk.contacts[c.legacy_id].chat.sendFile,
-            io.BytesIO(file_bytes),
-            fname,
-            any(fname_lower.endswith(x) for x in (".png", ".jpg", ".gif", ".jpeg")),
-        )
-
-    async def active(self, c: LegacyContact):
-        pass
-
-    async def inactive(self, c: LegacyContact):
-        pass
-
-    async def composing(self, c: LegacyContact):
-        self.xmpp.executor.submit(self.sk.contacts[c.legacy_id].chat.setTyping, True)
-
-    async def paused(self, c: LegacyContact):
-        self.xmpp.executor.submit(self.sk.contacts[c.legacy_id].chat.setTyping, False)
-
-    async def displayed(self, legacy_msg_id: int, c: LegacyContact):
-        try:
-            skype_msg = self.unread_by_user.pop(legacy_msg_id)
-        except KeyError:
-            log.debug(
-                "We did not transmit: %s (%s)", legacy_msg_id, self.unread_by_user
-            )
-        else:
-            log.debug("Calling read on %s", skype_msg)
-            try:
-                await self.async_wrap(skype_msg.read)
-            except skpy.SkypeApiException as e:
-                # FIXME: this raises HTTP 400 and does not mark the message as read
-                # https://github.com/Terrance/SkPy/issues/207
-                self.log.debug("Skype read marker failed: %r", e)
-
-    async def correct(self, text: str, legacy_msg_id: Any, c: Contact):
-        try:
-            m = self.get_msg(legacy_msg_id, c)
-        except RuntimeError:
-            raise XMPPError("not-found")
-        else:
-            self.xmpp.executor.submit(m.edit, text)
-
-    async def retract(self, legacy_msg_id: Any, c: Contact):
-        try:
-            m = self.get_msg(legacy_msg_id, c)
-        except RuntimeError:
-            raise XMPPError("not-found")
-        else:
-            log.debug("Deleting %s", m)
-            self.xmpp.executor.submit(m.delete)
-
-    async def search(self, form_values: dict[str, str]):
-        pass
-
-    def get_msg(self, legacy_msg_id: int, contact: Contact) -> skpy.SkypeTextMsg:
-        for m in self.sk.contacts[contact.legacy_id].chat.getMsgs():
-            log.debug("Message %r vs %r : %s", legacy_msg_id, m.clientId, m)
-            if m.clientId == legacy_msg_id:
-                return m
-        else:
-            raise RuntimeError("Could not find message ID")
-
-
-def handle_thread_exception(args):
-    # TODO: establish what exceptions are OK (eg temporary network failures)
-    #       and which one should trigger killing the session and/or exiting slidge
-    #       and/or relogging in
-    log.error("Exception in thread: %s", args)
-    if (thread := getattr(args, "thread")) is not None:
-        if isinstance(thread, ListenThread):
-            session = thread.session
-            log.warning("Attempting re-login for %s", session.user)
-            thread.stop()
-            session.re_login()
-
-
-threading.excepthook = handle_thread_exception
-
-log = logging.getLogger(__name__)

slidge/plugins/steam.py

@@ -1,310 +0,0 @@
-"""
-Just a stab at steam chat.
-
-Unfortunately the library underneath uses gevent and there is probably some work to do
-to make it play nice with asyncio.
-
-Right now, listing friends + send them messages works BUT in a blocking way.
-
-Asyncsteampy https://github.com/somespecialone/asyncsteampy
-might be interesting as it uses python's asyncio BUT the
-login process seem a little too exotic for my taste.
-"""
-import asyncio
-from collections import defaultdict
-from typing import Any
-
-import steam.enums
-from steam.client import SteamClient
-from steam.client.user import SteamUser
-from steam.core.msg import MsgProto
-from steam.enums.common import EPersonaState, EResult
-from steam.enums.emsg import EMsg
-from steam.protobufs.steammessages_friendmessages_pb2 import (
-    k_EMessageReactionType_Emoticon,
-)
-from steam.steamid import SteamID
-
-from slidge import *
-from slidge.util import BiDict
-
-
-class Gateway(BaseGateway["Session"]):
-    REGISTRATION_INSTRUCTIONS = "Enter steam credentials"
-    REGISTRATION_FIELDS = [
-        FormField(var="username", label="Steam username", required=True),
-        FormField(var="password", label="Password", private=True, required=True),
-    ]
-
-    ROSTER_GROUP = "Steam"
-
-    COMPONENT_NAME = "Steam (slidge)"
-    COMPONENT_TYPE = "steam"
-
-    COMPONENT_AVATAR = "https://logos-download.com/wp-content/uploads/2016/05/Steam_icon_logo_logotype.png"
-
-
-class Contact(LegacyContact["Session"]):
-    MARKS = False
-    CORRECTION = False
-    RETRACTION = False
-
-    def __init__(self, *a, **k):
-        super().__init__(*a, **k)
-        # keys = msg timestamp; vals = list of single character emoji
-        self.user_reactions = defaultdict[int, set[str]](set)
-        self.contact_reactions = defaultdict[int, set[str]](set)
-
-    def update_status(self, persona_state: EPersonaState):
-        if persona_state == EPersonaState.Offline:
-            self.offline()
-        elif persona_state == EPersonaState.Online:
-            self.online()
-        elif persona_state == EPersonaState.Busy:
-            self.busy()
-        elif persona_state == EPersonaState.Away:
-            self.away()
-
-    def update_reactions(self, timestamp: int):
-        self.react(timestamp, self.contact_reactions[timestamp])
-
-
-class Roster(LegacyRoster[Contact, "Session"]):
-    @staticmethod
-    def jid_username_to_legacy_id(jid_username: str) -> int:
-        return int(jid_username)
-
-
-class Session(BaseSession[Contact, Roster, Gateway]):
-    steam: SteamClient
-    job_futures: dict[str, asyncio.Future[Any]]
-
-    def post_init(self):
-        store_dir = self.xmpp.home_dir / self.user.bare_jid
-        store_dir.mkdir(exist_ok=True)
-
-        self.job_futures = {}
-
-        self.steam = SteamClient()
-        self.steam.set_credential_location(store_dir)
-        self.steam.username = self.user.registration_form["username"]
-
-    @staticmethod
-    def xmpp_msg_id_to_legacy_msg_id(legacy_msg_id: Any) -> int:
-        return int(legacy_msg_id)
-
-    async def login(self):
-        username = self.user.registration_form["username"]
-        password = self.user.registration_form["password"]
-
-        # self.steam.on(SteamClient.EVENT_CHAT_MESSAGE, self.on_steam_msg)
-        self.steam.on(EMsg.ClientPersonaState, self.on_persona_state)
-        self.steam.on("FriendMessagesClient.IncomingMessage#1", self.on_friend_message)
-        self.steam.on("FriendMessagesClient.MessageReaction#1", self.on_friend_reaction)
-        self.steam.on(EMsg.ServiceMethodResponse, self.on_service_method_response)
-
-        login_result = self.steam.relogin()
-
-        if login_result != EResult.OK:
-            login_result = self.steam.login(username, password)
-
-            if login_result == EResult.AccountLogonDenied:  # 2FA
-                code = await self.input("Enter the code you received by email")
-                login_result = self.steam.login(
-                    self.user.registration_form["username"],
-                    self.user.registration_form["password"],
-                    auth_code=code,
-                )
-
-        self.log.debug("Login result: %s", login_result)
-        if login_result == EResult.OK:
-            self.log.debug("Login success")
-        else:
-            raise RuntimeError("Could not connect to steam")
-
-        for f in self.steam.friends:
-            f: SteamUser
-            self.log.debug("Friend: %s - %s - %s", f, f.name, f.steam_id.id)
-            c = self.contacts.by_legacy_id(f.steam_id.id)
-            c.name = f.name
-            c.avatar = f.get_avatar_url()
-            await c.add_to_roster()
-            c.update_status(f.state)
-
-        asyncio.create_task(self.idle())
-
-    async def idle(self):
-        while True:
-            self.steam.idle()
-            await asyncio.sleep(0.1)
-
-    def on_service_method_response(self, msg):
-        self.log.debug("New service method response : %s", msg)
-        try:
-            fut = self.job_futures.pop(f"job_{msg.header.jobid_target}")
-        except KeyError:
-            self.log.debug(
-                "Ignoring: %s vs %s", msg.header.jobid_target, self.job_futures
-            )
-        else:
-            fut.set_result(msg.body)
-
-    def on_friend_message(self, msg):
-        self.log.debug("New friend message : %s", msg)
-        if (type_ := msg.body.chat_entry_type) == steam.enums.EChatEntryType.Typing:
-            user = self.steam.get_user(msg.body.steamid_friend)
-            self.contacts.by_legacy_id(user.steam_id.id).composing()
-        elif type_ == steam.enums.EChatEntryType.ChatMsg:
-            user = self.steam.get_user(msg.body.steamid_friend)
-            self.contacts.by_legacy_id(user.steam_id.id).send_text(
-                msg.body.message, legacy_msg_id=msg.body.rtime32_server_timestamp
-            )
-
-    def on_friend_reaction(self, msg):
-        self.log.debug("New friend reaction : %s", msg)
-        body = msg.body
-        timestamp = body.server_timestamp
-        if body.reactor == self.steam.steam_id:
-            if body.reaction_type == k_EMessageReactionType_Emoticon:
-                contact = self.contacts.by_legacy_id(
-                    SteamID(msg.body.steamid_friend).id
-                )
-                emoji = emoji_translate.get(body.reaction)
-                if emoji is None:
-                    return
-                if body.is_add:
-                    contact.user_reactions[timestamp].add(emoji)
-                else:
-                    try:
-                        contact.user_reactions[timestamp].remove(emoji)
-                    except KeyError:
-                        self.log.warning("User removed a reaction we didn't know about")
-                contact.carbon_react(timestamp, contact.user_reactions[timestamp])
-        else:
-            if body.reaction_type == k_EMessageReactionType_Emoticon:
-                contact = self.contacts.by_legacy_id(SteamID(msg.body.reactor).id)
-                emoji = emoji_translate.get(body.reaction, "❓")
-                if body.is_add:
-                    contact.contact_reactions[timestamp].add(emoji)
-                else:
-                    try:
-                        contact.contact_reactions[timestamp].remove(emoji)
-                    except KeyError:
-                        self.log.warning(
-                            "Contact removed a reaction we didn't know about"
-                        )
-                contact.update_reactions(timestamp)
-
-    def on_persona_state(self, msg: MsgProto):
-        persona_state = msg.body
-        self.log.debug("New state event: %s", persona_state)
-        for f in persona_state.friends:
-            if f.friendid == self.steam.steam_id:
-                self.log.debug("This is me %s", self.steam.steam_id)
-                return
-            self.contacts.by_legacy_id(SteamID(f.friendid).id).update_status(
-                f.persona_state
-            )
-
-    async def logout(self):
-        pass
-
-    async def send_text(self, t: str, c: Contact, *, reply_to_msg_id=None):
-        if not t:
-            return
-        job_id = self.steam.send_um(
-            "FriendMessages.SendMessage#1",
-            {
-                "steamid": SteamID(c.legacy_id),
-                "chat_entry_type": steam.enums.EChatEntryType.ChatMsg,
-                "message": t,
-            },
-        )
-        f = self.job_futures[job_id] = self.xmpp.loop.create_future()
-        return (await f).server_timestamp
-
-    async def send_file(self, u: str, c: Contact, *, reply_to_msg_id=None):
-        return await self.send_text(u, c)
-
-    async def active(self, c: Contact):
-        pass
-
-    async def inactive(self, c: Contact):
-        pass
-
-    async def composing(self, c: Contact):
-        self.steam.send_um(
-            "FriendMessages.SendMessage#1",
-            {
-                "steamid": SteamID(c.legacy_id),
-                "chat_entry_type": steam.enums.EChatEntryType.Typing,
-            },
-        )
-
-    async def paused(self, c: Contact):
-        pass
-
-    async def displayed(self, legacy_msg_id: Any, c: Contact):
-        pass
-
-    async def correct(self, text: str, legacy_msg_id: Any, c: Contact):
-        pass
-
-    async def search(self, form_values: dict[str, str]):
-        pass
-
-    async def react(self, legacy_msg_id: Any, emojis: list[str], c: Contact):
-        old = c.user_reactions[legacy_msg_id]
-        new = set[str]()
-        for emoji in emojis:
-            if emoji_translate.inverse.get(emoji) is None:
-                self.send_gateway_message(
-                    f"On steam, you can only react with {' '.join(emoji_translate.values())}"
-                )
-            else:
-                new.add(emoji)
-
-        for emoji_char in old - new:
-            self.steam.send_um(
-                "FriendMessages.UpdateMessageReaction#1",
-                {
-                    "steamid": SteamID(c.legacy_id).as_64,
-                    "server_timestamp": legacy_msg_id,
-                    "reaction_type": k_EMessageReactionType_Emoticon,
-                    "reaction": emoji_translate.inverse.get(emoji_char),
-                    "is_add": False,
-                },
-            )
-
-        for emoji_char in new - old:
-            self.steam.send_um(
-                "FriendMessages.UpdateMessageReaction#1",
-                {
-                    "steamid": SteamID(c.legacy_id).as_64,
-                    "server_timestamp": legacy_msg_id,
-                    "reaction_type": k_EMessageReactionType_Emoticon,
-                    "reaction": emoji_translate.inverse.get(emoji_char),
-                    "is_add": True,
-                },
-            )
-
-        c.user_reactions[legacy_msg_id] = new
-        c.carbon_react(legacy_msg_id, new)
-
-    async def retract(self, legacy_msg_id: Any, c: Contact):
-        pass
-
-
-emoji_translate = BiDict[str, str](
-    [
-        (":steamthumbsup:", "👍"),
-        (":steamthumbsdown:", "👎"),
-        (":steambored:", "🥱"),
-        (":steamfacepalm:", "🤦"),
-        (":steamhappy:", "😄"),
-        (":steammocking:", "😝"),
-        (":steamsalty:", "🧂"),
-        (":steamsad:", "😔"),
-        (":steamthis:", "⬆"),
-    ]
-)

slidge/plugins/telegram/__init__.py

@@ -1,5 +0,0 @@
-from .client import TelegramClient
-from .config import get_parser
-from .contact import Contact, Roster
-from .gateway import Gateway
-from .session import Session