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

slidge/plugins/hackernews.py

@@ -1,209 +0,0 @@
-"""
-Hackernews slidge plugin
-
-Will poll replies to items you've posted.
-For every reply, the chat window '<REPLY_ITEM_ID>@<BRIDGE_JID>' should open.
-It will contain your original post (as a carbon) and its reply as a normal chat message.
-You can re-reply by replying in your XMPP client directly.
-"""
-
-import asyncio
-import logging
-import re
-from datetime import datetime
-from typing import Any, Optional
-
-import aiohttp
-from slixmpp import JID
-from slixmpp.exceptions import XMPPError
-
-from slidge import *
-
-
-class Gateway(BaseGateway):
-    # FIXME: implement proper login process, but we might have to do something to handle captcha
-    REGISTRATION_INSTRUCTIONS = (
-        "Enter the hackernews cookie from your browser's dev console "
-        "(something like your-user-name ampersand XXXXXXXXXXXXXXXXXXXXXXXXX)"
-    )
-    REGISTRATION_FIELDS = [
-        FormField(var="cookie", label="'user' cookie", required=True),
-    ]
-
-    ROSTER_GROUP = "HN"  # Not used, we don't add anything to the roster
-
-    COMPONENT_NAME = "Hackernews (slidge)"
-    COMPONENT_TYPE = "hackernews"
-
-    COMPONENT_AVATAR = "https://news.ycombinator.com/favicon.ico"
-
-    async def validate(
-        self, user_jid: JID, registration_form: dict[str, Optional[str]]
-    ):
-        if registration_form["cookie"] is None:
-            raise ValueError("A cookie is required")
-        async with aiohttp.ClientSession(
-            cookies={"user": registration_form["cookie"]}
-        ) as session:
-            async with session.get(LOGIN_URL, allow_redirects=False) as r:
-                log.debug("Login response: %s - %s", r.status, await r.text())
-                if r.status != 302:
-                    raise ValueError("Cookie does not seem valid")
-
-
-class Session(BaseSession):
-    def __init__(self, user):
-        super().__init__(user)
-        self.http_session = aiohttp.ClientSession(
-            cookies={"user": self.user.registration_form["cookie"]}  # type: ignore
-        )
-        self.highest_handled_submission_id = 0
-        self.hn_username = self.user.registration_form["cookie"].split("&")[0]  # type: ignore
-
-    async def login(self):
-        kid_ids: list[int] = []
-        for submission_id in await self.get_user_submissions():
-            user_submission = await self.get_item(submission_id)
-            for kid_id in user_submission.get("kids", []):
-                kid_ids.append(kid_id)
-
-        if kid_ids:
-            self.highest_handled_submission_id = max(kid_ids)
-
-        self.xmpp.loop.create_task(self.main_loop())
-        return f"Logged as {self.hn_username}"
-
-    async def main_loop(self):
-        kid_ids: list[int] = []
-        while True:
-            kid_ids.clear()
-            for submission_id in await self.get_user_submissions():
-                try:
-                    user_submission = await self.get_item(submission_id)
-                except aiohttp.ContentTypeError as e:
-                    log.warning("Hackernews API problem: %s")
-                    log.exception(e)
-                    continue
-                for kid_id in user_submission.get("kids", []):
-                    if kid_id <= self.highest_handled_submission_id:
-                        continue
-                    await self.send_own_and_reply(user_submission, kid_id)
-                    kid_ids.append(kid_id)
-            if kid_ids:
-                self.highest_handled_submission_id = max(kid_ids)
-            await asyncio.sleep(POLL_INTERVAL)
-
-    async def get_user_submissions(self) -> list[int]:
-        log.debug("Getting user subs: %s", self.hn_username)
-        async with self.http_session.get(
-            f"{API_URL}/user/{self.hn_username}.json"
-        ) as r:
-            if r.status != 200:
-                log.warning("Bad response from API: %s", r)
-                raise RuntimeError
-            return (await r.json())["submitted"]
-
-    async def send_own_and_reply(self, user_submission, reply_id):
-        contact: LegacyContact = await self.contacts.by_legacy_id(reply_id)
-        date = datetime.fromtimestamp(user_submission["time"])
-        contact.send_text(
-            parse_comment_text(user_submission["text"]), when=date, carbon=True
-        )
-        kid = await self.get_item(reply_id)
-        contact.send_text(parse_comment_text(kid["text"]))
-
-    async def get_item(self, item_id):
-        async with self.http_session.get(f"{API_URL}/item/{item_id}.json") as r:
-            return await r.json()
-
-    async def logout(self):
-        pass
-
-    async def send_text(self, text: str, chat: LegacyContact, **k):
-        goto = f"threads?id={self.hn_username}#{chat.legacy_id}"
-        url = f"{REPLY_URL}?id={chat.legacy_id}&goto={goto}"
-        async with self.http_session.get(url) as r:
-            if r.status != 200:
-                raise XMPPError(text="Couldn't get the post reply web page from HN")
-            form_page_content = await r.text()
-        match = re.search(HMAC_RE, form_page_content)
-
-        if match is None:
-            raise XMPPError(
-                text="Couldn't find the HMAC hidden input on the comment reply thread"
-            )
-
-        await asyncio.sleep(SLEEP_BEFORE_POST)
-
-        form_dict = {
-            "hmac": match.group(1),
-            "parent": chat.legacy_id,
-            "text": text,
-            "goto": goto,
-        }
-
-        form = aiohttp.FormData(form_dict)
-        async with self.http_session.post(REPLY_POST_URL, data=form) as r:
-            first_attempt_html_content = await r.text()
-
-        log.debug("Reply response #1: %s", r)
-        if r.status != 200:
-            raise XMPPError(text=f"Problem replying: {r}")
-
-        if REPOST_TEXT in first_attempt_html_content:
-            match = re.search(HMAC_RE, first_attempt_html_content)
-            if match is None:
-                raise XMPPError(
-                    text="We should repost but haven't found any hmac field on the repost page"
-                )
-
-            await asyncio.sleep(SLEEP_BEFORE_POST2)
-            form = aiohttp.FormData(form_dict | {"hmac": match.group(1)})
-            async with self.http_session.post(REPLY_POST_URL, data=form) as r:
-                log.debug("Reply response #2: %s", r)
-                if r.status != 200:
-                    raise XMPPError(text=f"Problem replying: {r}")
-
-    # none of the following make sense in a HN context,
-    # this is just to avoid raising NotImplementedErrors
-    async def send_file(self, *a, **k):
-        pass
-
-    async def active(self, c: LegacyContact):
-        pass
-
-    async def inactive(self, c: LegacyContact):
-        pass
-
-    async def composing(self, c: LegacyContact):
-        pass
-
-    async def paused(self, c: LegacyContact):
-        pass
-
-    async def displayed(self, legacy_msg_id: Any, c: LegacyContact):
-        pass
-
-    async def correct(self, text: str, legacy_msg_id: Any, c: LegacyContact):
-        pass
-
-    async def search(self, form_values: dict[str, str]):
-        pass
-
-
-def parse_comment_text(text: str):
-    # TODO: use regex or something more efficient here
-    return text.replace("<p>", "\n").replace("&#x27;", "'").replace("&#x2F;", "/")
-
-
-LOGIN_URL = "https://news.ycombinator.com/login"
-REPLY_URL = "https://news.ycombinator.com/reply"
-REPLY_POST_URL = "https://news.ycombinator.com/comment"
-API_URL = "https://hacker-news.firebaseio.com/v0"
-POLL_INTERVAL = 30  # seconds
-SLEEP_BEFORE_POST = 30  # seconds
-SLEEP_BEFORE_POST2 = 5  # seconds
-REPOST_TEXT = "<tr><td>Please confirm that this is your comment by submitting it one"
-HMAC_RE = re.compile(r'name="hmac" value="([a-zA-Z\d]*)"')
-
-log = logging.getLogger(__name__)

slidge/plugins/mattermost/__init__.py

@@ -1 +0,0 @@
-from .gateway import Gateway, Session

slidge/plugins/mattermost/api.py

@@ -1,288 +0,0 @@
-import asyncio
-import io
-import logging
-
-import aiohttp
-import emoji
-from mattermost_api_reference_client.api.channels import (
-    create_direct_channel,
-    get_channel_members,
-    get_channels_for_team_for_user,
-    view_channel,
-)
-from mattermost_api_reference_client.api.files import get_file, upload_file
-from mattermost_api_reference_client.api.posts import (
-    create_post,
-    delete_post,
-    get_posts_for_channel,
-    update_post,
-)
-from mattermost_api_reference_client.api.reactions import (
-    delete_reaction,
-    get_reactions,
-    save_reaction,
-)
-from mattermost_api_reference_client.api.status import get_users_statuses_by_ids
-from mattermost_api_reference_client.api.teams import get_teams_for_user
-from mattermost_api_reference_client.api.users import (
-    get_profile_image,
-    get_user,
-    get_user_by_username,
-    get_users_by_ids,
-)
-from mattermost_api_reference_client.client import AuthenticatedClient
-from mattermost_api_reference_client.models import (
-    Reaction,
-    Status,
-    User,
-    ViewChannelJsonBody,
-)
-from mattermost_api_reference_client.models.create_post_json_body import (
-    CreatePostJsonBody,
-)
-from mattermost_api_reference_client.models.update_post_json_body import (
-    UpdatePostJsonBody,
-)
-from mattermost_api_reference_client.models.upload_file_multipart_data import (
-    UploadFileMultipartData,
-)
-from mattermost_api_reference_client.types import File, Unset
-
-
-class MattermostException(Exception):
-    pass
-
-
-class ContactNotFound(MattermostException):
-    pass
-
-
-class MattermostClient:
-    # TODO: this should be autogenerated using a template in mattermost_api_reference_client
-
-    def __init__(self, *args, **kwargs):
-        self.http = AuthenticatedClient(*args, **kwargs)
-        self.mm_id: asyncio.Future[str] = asyncio.get_running_loop().create_future()
-        self.me: asyncio.Future[User] = asyncio.get_running_loop().create_future()
-
-    async def login(self):
-        log.debug("Login")
-        me = await get_user.asyncio("me", client=self.http)
-        if me is None:
-            raise RuntimeError("Could not login")
-        self.me.set_result(me)
-        my_id = me.id
-        if isinstance(my_id, Unset):
-            raise RuntimeError("Could not login")
-        self.mm_id.set_result(my_id)
-        log.debug("Me: %s", me)
-
-    async def get_contacts(self) -> list[str]:
-        mm = self.http
-        my_id = await self.mm_id
-
-        contact_mm_ids: list[str] = []
-
-        teams = await get_teams_for_user.asyncio("me", client=mm)
-
-        if teams is None:
-            raise RuntimeError
-
-        for team in teams:
-            if isinstance(team.id, Unset):
-                log.warning("Team without ID")
-                continue
-            channels = await get_channels_for_team_for_user.asyncio(
-                "me", team.id, client=mm
-            )
-
-            if channels is None:
-                log.warning("Team without channels")
-                continue
-
-            for channel in channels:
-                if isinstance(channel.id, Unset):
-                    log.warning("Channel without ID")
-                    continue
-                members = await self.get_channel_members(channel.id, per_page=4)
-                if len(members) == 2:
-                    user_ids = {m.user_id for m in members}
-                    try:
-                        user_ids.remove(my_id)
-                    except KeyError:
-                        log.warning("Weird 2 person channel: %s", members)
-                    else:
-                        contact_id = user_ids.pop()
-                        if not isinstance(contact_id, str):
-                            log.warning("Weird contact: %s", members)
-                            continue
-                        contact_mm_ids.append(contact_id)
-
-        return contact_mm_ids
-
-    async def get_channel_members(
-        self, channel_id: str, *, page: int = 0, per_page: int = 10
-    ):
-        members = await get_channel_members.asyncio(
-            channel_id, client=self.http, per_page=per_page, page=page
-        )
-        if members is None:
-            raise RuntimeError
-        return members
-
-    async def get_users_by_ids(self, user_ids: list[str]) -> list[User]:
-        r = await get_users_by_ids.asyncio(json_body=user_ids, client=self.http)
-        if r is None:
-            raise RuntimeError
-        return r
-
-    async def get_user(self, user_id: str):
-        r = await get_user.asyncio(user_id, client=self.http)
-        if r is None:
-            raise RuntimeError
-        if isinstance(r.username, Unset):
-            raise RuntimeError
-        return r
-
-    async def get_users_statuses_by_ids(self, user_ids: list[str]) -> list[Status]:
-        r = await get_users_statuses_by_ids.asyncio(
-            json_body=user_ids, client=self.http
-        )
-        if r is None:
-            raise RuntimeError
-        return r
-
-    async def send_message_to_user(self, user_id: str, text: str) -> str:
-        await self.mm_id
-        mm = self.http
-
-        other = await self.get_user_by_username(user_id)
-
-        direct_channel = await self.get_direct_channel(other.id)
-
-        msg = await create_post.asyncio(
-            json_body=CreatePostJsonBody(channel_id=direct_channel.id, message=text),
-            client=mm,
-        )
-        if msg is None:
-            raise RuntimeError
-
-        if isinstance(msg.id, Unset):
-            raise RuntimeError
-
-        return msg.id
-
-    async def send_message_with_file(self, channel_id: str, file_id: str):
-        r = await create_post.asyncio(
-            json_body=CreatePostJsonBody(
-                channel_id=channel_id, file_ids=[file_id], message=""
-            ),
-            client=self.http,
-        )
-        if r is None or isinstance(r.id, Unset):
-            raise RuntimeError(r)
-        return r.id
-
-    async def get_user_by_username(self, username: str) -> User:
-        user = await get_user_by_username.asyncio(username, client=self.http)
-        if user is None or isinstance(user.id, Unset):
-            raise ContactNotFound("Contact not found")
-        return user
-
-    async def get_direct_channel(self, user_id):
-        direct_channel = await create_direct_channel.asyncio(
-            json_body=[await self.mm_id, user_id], client=self.http
-        )
-        if direct_channel is None or isinstance(direct_channel.id, Unset):
-            raise RuntimeError("Could not create direct channel")
-        return direct_channel
-
-    async def get_profile_image(self, user_id: str) -> bytes:
-        resp = await get_profile_image.asyncio_detailed(user_id, client=self.http)
-        return resp.content
-
-    async def get_file(self, file_id: str):
-        resp = await get_file.asyncio_detailed(file_id, client=self.http)
-        return resp.content
-
-    async def delete_post(self, post_id: str):
-        r = await delete_post.asyncio(post_id, client=self.http)
-        if r is not None and not isinstance(r, Unset) and r.status != "ok":
-            raise RuntimeError("Could not delete post %s", post_id)
-
-    async def update_post(self, post_id: str, body: str):
-        r = await update_post.asyncio(
-            post_id,
-            client=self.http,
-            json_body=UpdatePostJsonBody(id=post_id, message=body),
-        )
-        if r is None or isinstance(r, Unset):
-            raise RuntimeError(r)
-        return r.id
-
-    async def get_posts_for_channel(self, channel_id: str):
-        r = await get_posts_for_channel.asyncio(
-            channel_id, client=self.http, per_page=2
-        )
-        if r is None or isinstance(r, Unset):
-            raise RuntimeError(r)
-        return r
-
-    async def upload_file(self, channel_id: str, url: str):
-        async with aiohttp.ClientSession() as s:
-            async with s.get(url) as get_response:
-                data = await get_response.read()
-        req = UploadFileMultipartData(
-            files=File(file_name=url.split("/")[-1], payload=io.BytesIO(data)),
-            channel_id=channel_id,
-        )
-        r = await upload_file.asyncio(client=self.http, multipart_data=req)
-        if (
-            r is None
-            or isinstance(r, Unset)
-            or r.file_infos is None
-            or isinstance(r.file_infos, Unset)
-            or len(r.file_infos) != 1
-        ):
-            raise RuntimeError(r)
-        return r.file_infos[0].id
-
-    async def react(self, post_id: str, emoji_char: str):
-        return await save_reaction.asyncio(
-            client=self.http,
-            json_body=Reaction(
-                user_id=await self.mm_id,
-                post_id=post_id,
-                emoji_name=demojize(emoji_char),
-            ),
-        )
-
-    async def get_reactions(self, post_id: str):
-        try:
-            return await get_reactions.asyncio(post_id, client=self.http)
-        except TypeError:
-            return []
-
-    async def delete_reaction(self, post_id: str, emoji_name: str):
-        await delete_reaction.asyncio(
-            await self.mm_id, post_id, emoji_name=emoji_name, client=self.http
-        )
-
-    async def view_channel(self, channel_id: str):
-        await view_channel.asyncio(
-            await self.mm_id,
-            client=self.http,
-            json_body=ViewChannelJsonBody(channel_id=channel_id),
-        )
-
-
-def demojize(emoji_char: str):
-    # TODO: find a better when than these non standard emoji aliases replace
-    return (
-        emoji.demojize(emoji_char, delimiters=("", ""), language="alias")
-        .replace("_three_", "_3_")
-        .replace("thumbsup", "+1")
-    )
-
-
-log = logging.getLogger(__name__)