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

slidge/plugins/telegram/client.py

@@ -1,325 +0,0 @@
-import asyncio
-import functools
-from datetime import datetime
-from typing import TYPE_CHECKING, Union
-
-import aiotdlib
-from aiotdlib import api as tgapi
-
-from . import config
-from .util import get_best_file
-
-if TYPE_CHECKING:
-    from .contact import Contact
-    from .group import MUC, Participant
-    from .session import Session
-
-
-def get_base_kwargs(user_reg_form: dict):
-    return dict(
-        phone_number=user_reg_form["phone"],
-        api_id=user_reg_form.get("api_id") or config.API_ID,
-        api_hash=user_reg_form.get("api_hash") or config.API_HASH,
-        database_encryption_key=config.TDLIB_KEY,
-        files_directory=config.TDLIB_PATH,
-    )
-
-
-class CredentialsValidation(aiotdlib.Client):
-    def __init__(self, registration_form: dict):
-        super().__init__(**get_base_kwargs(registration_form))
-        self.code_future: asyncio.Future[
-            str
-        ] = asyncio.get_running_loop().create_future()
-        self._auth_get_code = self._get_code
-        self._auth_get_password = self._get_code
-
-    async def _get_code(self):
-        return await self.code_future
-
-
-class TelegramClient(aiotdlib.Client):
-    def __init__(self, session: "Session"):
-        super().__init__(
-            parse_mode=aiotdlib.ClientParseMode.MARKDOWN,
-            **get_base_kwargs(session.user.registration_form),
-        )
-        self.session = session
-        self.contacts = session.contacts
-        self.bookmarks = session.bookmarks
-        self.log = self.session.log
-
-        async def input_(prompt):
-            self.session.send_gateway_status(f"Action required: {prompt}")
-            return await session.input(prompt)
-
-        self.input = input_
-        self._auth_get_code = functools.partial(input_, "Enter code")
-        self._auth_get_password = functools.partial(input_, "Enter 2FA password:")
-        self._auth_get_first_name = functools.partial(input_, "Enter first name:")
-        self._auth_get_last_name = functools.partial(input_, "Enter last name:")
-
-        self.add_event_handler(self.dispatch_update, tgapi.API.Types.ANY)
-
-    async def dispatch_update(self, _self, update: tgapi.Update):
-        try:
-            handler = getattr(self, "handle_" + update.ID[6:])
-        except AttributeError:
-            self.session.log.debug("No handler for %s, ignoring", update.ID)
-        except IndexError:
-            self.session.log.debug("Ignoring weird event: %s", update.ID)
-        else:
-            await handler(update)
-
-    async def handle_NewMessage(self, update: tgapi.UpdateNewMessage):
-        if (msg := update.message).is_channel_post:
-            self.log.debug("Ignoring channel post")
-            return
-
-        if not await self.is_private_chat(msg.chat_id):
-            return await self.handle_group_message(msg)
-
-        session = self.session
-        if msg.is_outgoing:
-            # This means slidge is responsible for this message, so no carbon is needed;
-            # but maybe this does not handle all possible cases gracefully?
-            if msg.sending_state is not None or msg.id in session.sent:
-                return
-            content = msg.content
-            contact = await session.contacts.by_legacy_id(msg.chat_id)
-            if isinstance(content, tgapi.MessageText):
-                contact.send_text(
-                    content.text.text,
-                    legacy_msg_id=msg.id,
-                    when=datetime.fromtimestamp(msg.date),
-                    carbon=True,
-                )
-            elif best_file := get_best_file(content):
-                file = await self.api.download_file(
-                    file_id=best_file.id,
-                    synchronous=True,
-                    priority=1,
-                    offset=0,
-                    limit=0,
-                )
-                has_caption = (caption := content.caption) and (text := caption.text)
-                await contact.send_file(
-                    filename=file.local.path,
-                    legacy_msg_id=None if has_caption else msg.id,
-                    carbon=True,
-                )
-                if has_caption:
-                    contact.send_text(text, legacy_msg_id=msg.id, carbon=True)
-            return
-
-        sender = msg.sender_id
-        if not isinstance(sender, tgapi.MessageSenderUser):
-            # Does this happen?
-            self.log.warning("Ignoring chat sender in direct message: %s", msg)
-            return
-
-        await (await session.contacts.by_legacy_id(sender.user_id)).send_tg_message(msg)
-
-    async def handle_group_message(self, msg: tgapi.Message):
-        self.log.debug("MUC message: %s", msg)
-        if msg.is_outgoing:
-            if msg.sending_state is not None or msg.id in self.session.sent:
-                return
-
-        muc = await self.bookmarks.by_legacy_id(msg.chat_id)
-        sender = msg.sender_id
-        if isinstance(sender, tgapi.MessageSenderUser):
-            participant = await muc.participant_by_tg_user(
-                await self.api.get_user(sender.user_id)
-            )
-        else:
-            participant = await muc.participant_system()
-        await participant.send_tg_message(msg)
-
-    async def handle_UserStatus(self, update: tgapi.UpdateUserStatus):
-        if update.user_id == await self.get_my_id():
-            return
-        contact = await self.contacts.by_legacy_id(update.user_id)
-        if not contact.added_to_roster:
-            self.log.debug("Ignoring presence of contact not in the roster")
-            return
-        contact.update_status(update.status)
-
-    async def handle_ChatReadOutbox(self, update: tgapi.UpdateChatReadOutbox):
-        if await self.is_private_chat(update.chat_id):
-            contact = await self.contacts.by_legacy_id(update.chat_id)
-            contact.displayed(update.last_read_outbox_message_id)
-        else:
-            muc = await self.bookmarks.by_legacy_id(update.chat_id)
-            async for p in muc.get_participants():
-                p.displayed(update.last_read_outbox_message_id)
-
-    async def handle_ChatAction(self, action: tgapi.UpdateChatAction):
-        sender = action.sender_id
-        if not isinstance(sender, tgapi.MessageSenderUser):
-            self.log.debug("Ignoring action: %s", action)
-            return
-
-        chat_id = action.chat_id
-        user_id = sender.user_id
-        if chat_id == user_id:
-            composer: Union[
-                "Contact", "Participant"
-            ] = await self.contacts.by_legacy_id(chat_id)
-        else:
-            muc: MUC = await self.bookmarks.by_legacy_id(chat_id)
-            composer = await muc.participant_by_tg_user(
-                await self.api.get_user(user_id)
-            )
-
-        composer.composing()
-
-    async def handle_ChatReadInbox(self, action: tgapi.UpdateChatReadInbox):
-        if not await self.is_private_chat(action.chat_id):
-            return
-
-        session = self.session
-        msg_id = action.last_read_inbox_message_id
-        self.log.debug(
-            "Self read mark for %s and we sent %s", msg_id, session.sent_read_marks
-        )
-        try:
-            session.sent_read_marks.remove(msg_id)
-        except KeyError:
-            # slidge didn't send this read mark, so it comes from the official tg client
-            contact = await session.contacts.by_legacy_id(action.chat_id)
-            contact.displayed(msg_id, carbon=True)
-
-    async def handle_MessageContent(self, action: tgapi.UpdateMessageContent):
-        new = action.new_content
-        if isinstance(new, tgapi.MessagePhoto):
-            # Happens when the user send a picture, looks safe to ignore
-            self.log.debug("Ignoring message photo update: %s", new)
-            return
-        if not isinstance(new, tgapi.MessageText):
-            self.log.warning("Ignoring message update: %s", new)
-            return
-        session = self.session
-        corrected_msg_id = action.message_id
-        chat_id = action.chat_id
-        try:
-            fut = session.user_correction_futures.pop(action.message_id)
-        except KeyError:
-            if await self.is_private_chat(chat_id):
-                contact = await session.contacts.by_legacy_id(chat_id)
-                if action.message_id in self.session.sent:
-                    contact.correct(corrected_msg_id, new.text.text, carbon=True)
-                else:
-                    contact.correct(corrected_msg_id, new.text.text)
-            else:
-                if action.message_id not in self.session.muc_sent_msg_ids:
-                    muc = await session.bookmarks.by_legacy_id(chat_id)
-                    msg = await self.api.get_message(chat_id, corrected_msg_id)
-                    participant = await muc.participant_by_tg_user(
-                        await self.api.get_user(msg.sender_id.user_id)
-                    )
-                    participant.correct(action.message_id, new.text.text)
-        else:
-            self.log.debug("User correction confirmation received")
-            fut.set_result(None)
-
-    async def handle_User(self, action: tgapi.UpdateUser):
-        u = action.user
-        if u.id == await self.get_my_id():
-            return
-        contact = await self.session.contacts.by_legacy_id(u.id)
-        await contact.update_info_from_user(u)
-        if u.is_contact:
-            await contact.add_to_roster()
-
-    async def handle_MessageInteractionInfo(
-        self, update: tgapi.UpdateMessageInteractionInfo
-    ):
-        if not await self.is_private_chat(update.chat_id):
-            return
-
-        contact = await self.session.contacts.by_legacy_id(update.chat_id)
-        me = await self.get_my_id()
-        if update.interaction_info is None:
-            contact.react(update.message_id, [])
-            contact.react(update.message_id, [], carbon=True)
-        else:
-            user_reactions = list[str]()
-            contact_reactions = list[str]()
-            # these sanity checks might not be necessary, but in doubt…
-            for reaction in update.interaction_info.reactions:
-                if reaction.total_count == 1:
-                    if len(reaction.recent_sender_ids) != 1:
-                        self.log.warning(
-                            "Weird reactions (wrong count): %s",
-                            update.interaction_info.reactions,
-                        )
-                        continue
-                    sender = reaction.recent_sender_ids[0]
-                    if isinstance(sender, tgapi.MessageSenderUser):
-                        if sender.user_id == me:
-                            user_reactions.append(reaction.reaction)
-                        elif sender.user_id == contact.legacy_id:
-                            contact_reactions.append(reaction.reaction)
-                    else:
-                        self.log.warning(
-                            "Weird reactions (neither me nor them): %s",
-                            update.interaction_info.reactions,
-                        )
-                elif reaction.total_count == 2:
-                    user_reactions.append(reaction.reaction)
-                    contact_reactions.append(reaction.reaction)
-                else:
-                    self.log.warning(
-                        "Weird reactions (empty): %s", update.interaction_info.reactions
-                    )
-
-            contact.react(update.message_id, contact_reactions)
-            contact.react(update.message_id, user_reactions, carbon=True)
-
-    async def handle_DeleteMessages(self, update: tgapi.UpdateDeleteMessages):
-        if not update.is_permanent:  # tdlib send 'delete from cache' updates apparently
-            self.log.debug("Ignoring non permanent delete")
-            return
-        for legacy_msg_id in update.message_ids:
-            try:
-                future = self.session.delete_futures.pop(legacy_msg_id)
-            except KeyError:
-                if await self.is_private_chat(update.chat_id):
-                    contact = await self.session.contacts.by_legacy_id(update.chat_id)
-                    if legacy_msg_id in self.session.sent:
-                        contact.retract(legacy_msg_id, carbon=True)
-                    else:
-                        contact.retract(legacy_msg_id)
-                else:
-                    return
-                    # FIXME: does not work because we need to fetch the participant,
-                    #        the DeleteMessage payload has not author info,
-                    #        and we cannot get_message() anymore
-                    # We should probably use MUC moderation tools here
-                    # muc = await self.session.bookmarks.by_legacy_id(update.chat_id)
-                    # msg = await self.api.get_message(update.chat_id, legacy_msg_id)
-                    # participant = await muc.participant_by_tg_user_id(
-                    #     msg.sender_id.user_id
-                    # )
-                    # participant.retract(legacy_msg_id)
-            else:
-                future.set_result(update)
-
-    async def handle_MessageSendSucceeded(
-        self, update: tgapi.UpdateMessageSendSucceeded
-    ):
-        self.session.sent_read_marks.add(update.message.id)
-        for _ in range(10):
-            try:
-                future = self.session.ack_futures.pop(update.message.id)
-            except KeyError:
-                await asyncio.sleep(0.5)
-            else:
-                future.set_result(update.message.id)
-                return
-        self.log.warning("Ignoring Send success for %s", update.message.id)
-
-    async def is_private_chat(self, chat_id: int):
-        chat = await self.get_chat(chat_id)
-        return isinstance(chat.type_, tgapi.ChatTypePrivate)

slidge/plugins/telegram/config.py

@@ -1,21 +0,0 @@
-from pathlib import Path
-from typing import Optional
-
-TDLIB_PATH: Path
-TDLIB_PATH__DOC = "Defaults to ${SLIDGE_HOME_DIR}/tdlib"
-TDLIB_PATH__DYNAMIC_DEFAULT = True
-
-TDLIB_KEY: str = "NOT_SECURE"
-TDLIB_KEY__DOC = "Key used to encrypt tdlib persistent DB"
-
-API_ID: Optional[int] = None
-API_ID__DOC = "Telegram app api_id, obtained at https://my.telegram.org/apps"
-
-API_HASH: Optional[str] = None
-API_HASH__DOC = "Telegram app api_hash, obtained at https://my.telegram.org/apps"
-
-REGISTRATION_AUTH_CODE_TIMEOUT: int = 60
-REGISTRATION_AUTH_CODE_TIMEOUT__DOC = (
-    "On registration, users will be prompted for a 2FA code they receive "
-    "on other telegram clients."
-)

slidge/plugins/telegram/contact.py

@@ -1,154 +0,0 @@
-import asyncio
-import logging
-import time
-from datetime import datetime, timedelta
-from typing import TYPE_CHECKING, Optional, Union
-
-import aiotdlib.api as tgapi
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-from .util import AvailableEmojisMixin, TelegramToXMPPMixin
-
-if TYPE_CHECKING:
-    from .session import Session
-
-
-async def noop():
-    return
-
-
-class Contact(AvailableEmojisMixin, LegacyContact["Session", int], TelegramToXMPPMixin):
-    CLIENT_TYPE = "phone"
-    session: "Session"  # type:ignore
-
-    def __init__(self, *a, **k):
-        super().__init__(*a, **k)
-        self.chat_id = self.legacy_id
-        self._online_expire_task = self.xmpp.loop.create_task(noop())
-
-    async def _expire_online(self, timestamp: Union[int, float]):
-        now = time.time()
-        how_long = timestamp - now
-        log.debug("Online status expires in %s seconds", how_long)
-        await asyncio.sleep(how_long)
-        self.away(last_seen=datetime.fromtimestamp(timestamp))
-
-    def update_status(self, status: tgapi.UserStatus):
-        if isinstance(status, tgapi.UserStatusEmpty):
-            self.inactive()
-            self.offline()
-        elif isinstance(status, tgapi.UserStatusLastMonth):
-            self.inactive()
-            self.extended_away(
-                "Offline since last month"
-                if global_config.LAST_SEEN_FALLBACK
-                else None,
-                last_seen=datetime.now() - timedelta(days=31),
-            )
-        elif isinstance(status, tgapi.UserStatusLastWeek):
-            self.inactive()
-            self.extended_away(
-                "Offline since last week" if global_config.LAST_SEEN_FALLBACK else None,
-                last_seen=datetime.now() - timedelta(days=7),
-            )
-        elif isinstance(status, tgapi.UserStatusOffline):
-            self.inactive()
-            if self._online_expire_task.done():
-                # we've never seen the contact online, so we use the was_online timestamp
-                self.away(last_seen=datetime.fromtimestamp(status.was_online))
-        elif isinstance(status, tgapi.UserStatusOnline):
-            self.online()
-            self.active()
-            self._online_expire_task.cancel()
-            self._online_expire_task = self.xmpp.loop.create_task(
-                self._expire_online(status.expires)
-            )
-        elif isinstance(status, tgapi.UserStatusRecently):
-            self.inactive()
-            self.away(
-                "Last seen recently" if global_config.LAST_SEEN_FALLBACK else None,
-                last_seen=datetime.now(),
-            )
-
-    async def update_info_from_user(self, user: Optional[tgapi.User] = None):
-        if user is None:
-            user = await self.session.tg.api.get_user(self.legacy_id)
-        if username := user.username:
-            name = username
-        else:
-            name = user.first_name
-            if last := user.last_name:
-                name += " " + last
-        self.name = name
-
-        if photo := user.profile_photo:
-            if (local := photo.small.local) and (path := local.path):
-                with open(path, "rb") as f:
-                    self.avatar = f.read()
-            else:
-                response = await self.session.tg.api.download_file(
-                    file_id=photo.small.id,
-                    synchronous=True,
-                    priority=1,
-                    offset=0,
-                    limit=0,
-                )
-                with open(response.local.path, "rb") as f:
-                    self.avatar = f.read()
-
-        if isinstance(user.type_, tgapi.UserTypeBot) or user.id == 777000:
-            # 777000 is not marked as bot, it's the "Telegram" contact, which gives
-            # confirmation codes and announces telegram-related stuff
-            self.CLIENT_TYPE = "bot"
-
-        else:
-            if user.is_contact:
-                self._subscribe_to = True
-                self._subscribe_from = user.is_mutual_contact
-            else:
-                self._subscribe_to = self._subscribe_from = False
-
-        self.update_status(user.status)
-
-        if p := user.phone_number:
-            phone = "+" + p
-        else:
-            phone = None
-        self.set_vcard(
-            given=user.first_name, surname=user.last_name, phone=phone, full_name=name
-        )
-
-    async def update_info_from_chat(self, chat: tgapi.Chat):
-        self.name = chat.title
-        if isinstance(chat.photo, tgapi.ChatPhotoInfo):
-            if (local := chat.photo.small.local) and (path := local.path):
-                with open(path, "rb") as f:
-                    self.avatar = f.read()
-            else:
-                response = await self.session.tg.api.download_file(
-                    file_id=chat.photo.small.id,
-                    synchronous=True,
-                    priority=1,
-                    offset=0,
-                    limit=0,
-                )
-                with open(response.local.path, "rb") as f:
-                    self.avatar = f.read()
-
-
-class Roster(LegacyRoster["Session", "Contact", int]):
-    async def jid_username_to_legacy_id(self, jid_username: str) -> int:
-        try:
-            tg_id = int(jid_username)
-        except ValueError:
-            raise XMPPError("bad-request", "This is not a telegram user ID")
-        else:
-            if tg_id > 0:
-                return tg_id
-            else:
-                raise XMPPError("bad-request", "This looks like a telegram group ID")
-
-
-log = logging.getLogger(__name__)

slidge/plugins/telegram/gateway.py

@@ -1,182 +0,0 @@
-import asyncio
-import logging
-import typing
-from datetime import datetime
-
-import aiotdlib.api as tgapi
-from slixmpp import JID, Iq
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-from slidge.core.adhoc import RegistrationType
-
-from ...util import is_valid_phone_number
-from . import config
-from .client import CredentialsValidation
-
-if typing.TYPE_CHECKING:
-    from .session import Session
-
-REGISTRATION_INSTRUCTIONS = (
-    "You need to create a telegram account in an official telegram client.\n\n"
-    "Then you can enter your phone number here, and you will receive a confirmation code "
-    "in the official telegram client. "
-    "You can uninstall the telegram client after this if you want."
-)
-
-
-class Gateway(BaseGateway["Session"]):
-    REGISTRATION_INSTRUCTIONS = REGISTRATION_INSTRUCTIONS
-    REGISTRATION_FIELDS = [FormField(var="phone", label="Phone number", required=True)]
-    REGISTRATION_TYPE = RegistrationType.TWO_FACTOR_CODE
-    ROSTER_GROUP = "Telegram"
-    COMPONENT_NAME = "Telegram (slidge)"
-    COMPONENT_TYPE = "telegram"
-    COMPONENT_AVATAR = "https://web.telegram.org/img/logo_share.png"
-
-    SEARCH_FIELDS = [
-        FormField(var="phone", label="Phone number", required=True),
-        FormField(var="first", label="First name", required=True),
-        FormField(var="last", label="Last name", required=False),
-    ]
-
-    GROUPS = True
-
-    def __init__(self):
-        super().__init__()
-        if config.TDLIB_PATH is None:
-            config.TDLIB_PATH = global_config.HOME_DIR / "tdlib"
-        self._pending_registrations = dict[
-            str, tuple[asyncio.Task[CredentialsValidation], CredentialsValidation]
-        ]()
-        if not config.API_ID:
-            self.REGISTRATION_FIELDS.extend(
-                [
-                    FormField(
-                        var="info",
-                        type="fixed",
-                        label="Get API id and hash on https://my.telegram.org/apps",
-                    ),
-                    FormField(var="api_id", label="API ID", required=True),
-                    FormField(var="api_hash", label="API Hash", required=True),
-                ]
-            )
-        log.debug("CONFIG %s", vars(config))
-
-    async def validate(
-        self, user_jid: JID, registration_form: dict[str, typing.Optional[str]]
-    ):
-        phone = registration_form.get("phone")
-        if not is_valid_phone_number(phone):
-            raise ValueError("Not a valid phone number")
-        tg_client = CredentialsValidation(registration_form)  # type: ignore
-        auth_task = self.loop.create_task(tg_client.start())
-        self._pending_registrations[user_jid.bare] = auth_task, tg_client
-
-    async def validate_two_factor_code(self, user: GatewayUser, code: str):
-        auth_task, tg_client = self._pending_registrations.pop(user.bare_jid)
-        tg_client.code_future.set_result(code)
-        try:
-            await asyncio.wait_for(auth_task, config.REGISTRATION_AUTH_CODE_TIMEOUT)
-        except asyncio.TimeoutError:
-            raise XMPPError(
-                "not-authorized",
-                text="Something went wrong when trying to authenticate you on the "
-                "telegram network. Please retry and/or contact your slidge admin.",
-            )
-        await tg_client.stop()
-
-    async def unregister(self, user: GatewayUser):
-        session = self.session_cls.from_user(user)
-        # FIXME: this effectively removes user data from disk, but crashes slidge.
-        await session.tg.start()
-        await session.tg.api.log_out()
-
-    def add_adhoc_commands(self):
-        self.adhoc.add_command(
-            node="get_sessions",
-            name="List active sessions",
-            handler=self.adhoc_active_sessions1,
-            only_users=True,
-        )
-
-    async def adhoc_active_sessions1(
-        self, iq: Iq, adhoc_session: dict[str, typing.Any]
-    ):
-        user = user_store.get_by_stanza(iq)
-        if user is None:
-            raise XMPPError("subscription-required")
-        session = self.session_cls.from_stanza(iq)
-
-        form = self["xep_0004"].make_form("form", "Active telegram sessions")
-        tg_sessions = (await session.tg.api.get_active_sessions()).sessions
-        form.add_field(
-            "tg_session_id",
-            ftype="list-single",
-            label="Sessions",
-            options=[{"label": f"{s.country}", "value": s.id} for s in tg_sessions],
-        )
-
-        adhoc_session["payload"] = form
-        adhoc_session["next"] = self.adhoc_active_sessions2
-        adhoc_session["has_next"] = True
-        adhoc_session["tg_sessions"] = {s.id: s for s in tg_sessions}
-        adhoc_session["slidge_session"] = session
-
-        return adhoc_session
-
-    async def adhoc_active_sessions2(self, form, adhoc_session: dict[str, typing.Any]):
-        tg_session_id = int(form.get_values()["tg_session_id"])
-
-        form = self["xep_0004"].make_form("form", "Telegram session info")
-        tg_session: tgapi.Session = adhoc_session["tg_sessions"][str(tg_session_id)]
-        for x in fmt_tg_session(tg_session):
-            form.add_field(
-                ftype="fixed",
-                value=x,
-            )
-        if tg_session.is_current:
-            adhoc_session["has_next"] = False
-        else:
-            form.add_field(
-                "terminate", ftype="boolean", label="Terminate session", value="0"
-            )
-            form.add_field("tg_session_id", ftype="hidden", value=tg_session.id)
-            adhoc_session["has_next"] = True
-            adhoc_session["next"] = self.adhoc_active_sessions3
-
-        adhoc_session["payload"] = form
-
-        return adhoc_session
-
-    async def adhoc_active_sessions3(self, form, adhoc_session: dict[str, typing.Any]):
-        form_values = form.get_values()
-        terminate = bool(int(form_values["terminate"]))
-
-        if terminate:
-            session: Session = adhoc_session["slidge_session"]
-            await session.tg.api.terminate_session(int(form_values["tg_session_id"]))
-            info = "Session terminated."
-        else:
-            info = "Session not terminated."
-
-        adhoc_session["notes"] = [("info", info)]
-        adhoc_session["has_next"] = False
-
-        return adhoc_session
-
-
-def fmt_tg_session(s: tgapi.Session):
-    return [
-        f"Country: {s.country}",
-        f"Region: {s.region}",
-        f"Ip: {s.ip}",
-        f"App: {s.application_name}",
-        f"Device: {s.device_model}",
-        f"Platform: {s.platform}",
-        f"Since: {datetime.fromtimestamp(s.log_in_date).isoformat()}",
-        f"Last seen: {datetime.fromtimestamp(s.last_active_date).isoformat()}",
-    ]
-
-
-log = logging.getLogger(__name__)