From b0a8d1b98426c42ac9672d8cb9374e3a4be1c7af Mon Sep 17 00:00:00 2001 From: Tulir Asokan Date: Sat, 10 Feb 2018 16:45:43 +0200 Subject: [PATCH] Remove matrix-client dependency --- mautrix_appservice/__init__.py | 1 + mautrix_appservice/errors.py | 38 ++++ mautrix_appservice/intent_api.py | 321 +++++++++++++++++---------- mautrix_appservice/temp_async_api.py | 72 ------ mautrix_telegram/commands.py | 2 +- mautrix_telegram/formatter.py | 2 +- mautrix_telegram/matrix.py | 2 +- requirements.txt | 1 - setup.py | 1 - 9 files changed, 250 insertions(+), 190 deletions(-) create mode 100644 mautrix_appservice/errors.py delete mode 100644 mautrix_appservice/temp_async_api.py diff --git a/mautrix_appservice/__init__.py b/mautrix_appservice/__init__.py index 3d104ad9..7a5ef73c 100644 --- a/mautrix_appservice/__init__.py +++ b/mautrix_appservice/__init__.py @@ -1,4 +1,5 @@ from .appservice import AppService +from .errors import MatrixError, MatrixRequestError, IntentError __version__ = "0.1.0" __author__ = "Tulir Asokan " diff --git a/mautrix_appservice/errors.py b/mautrix_appservice/errors.py new file mode 100644 index 00000000..8c09936f --- /dev/null +++ b/mautrix_appservice/errors.py @@ -0,0 +1,38 @@ +# -*- coding: future_fstrings -*- +# mautrix-telegram - A Matrix-Telegram puppeting bridge +# Copyright (C) 2018 Tulir Asokan +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see . + + +class MatrixError(Exception): + """A generic Matrix error. Specific errors will subclass this.""" + pass + + +class IntentError(MatrixError): + def __init__(self, message, source): + super().__init__(message) + self.source = source + + +class MatrixRequestError(MatrixError): + """ The home server returned an error response. """ + + def __init__(self, code=0, text="", errcode=None, message=None): + super().__init__("%d: %s" % (code, text)) + self.code = code + self.text = text + self.errcode = errcode + self.message = message diff --git a/mautrix_appservice/intent_api.py b/mautrix_appservice/intent_api.py index 15035188..2bd2bade 100644 --- a/mautrix_appservice/intent_api.py +++ b/mautrix_appservice/intent_api.py @@ -14,26 +14,36 @@ # # You should have received a copy of the GNU General Public License # along with this program. If not, see . +from urllib.parse import quote +from time import time import re import json import magic +import asyncio -from matrix_client.errors import MatrixRequestError - -from .temp_async_api import AsyncHTTPAPI +from .errors import MatrixError, MatrixRequestError, IntentError -class HTTPAPI(AsyncHTTPAPI): +class HTTPAPI: def __init__(self, base_url, domain=None, bot_mxid=None, token=None, identity=None, log=None, - state_store=None, client_session=None): - super().__init__(base_url, client_session, token, identity) + state_store=None, client_session=None, child=False): + self.base_url = base_url + self.token = token + self.identity = identity + self.validate_cert = True + self.session = client_session + self.domain = domain self.bot_mxid = bot_mxid - self.intent_log = log.getChild("intent") - self.log = log.getChild("api") - self.validate_cert = True self.state_store = state_store - self.children = {} + + if child: + self.log = log + else: + self.intent_log = log.getChild("intent") + self.log = log.getChild("api") + self.txn_id = 0 + self.children = {} def user(self, user): try: @@ -49,43 +59,74 @@ class HTTPAPI(AsyncHTTPAPI): def intent(self, user): return IntentAPI(user, self.user(user), self, self.state_store, self.intent_log) - def _send(self, method, path, content=None, query_params=None, headers=None, - api_path="/_matrix/client/r0"): - if not query_params: - query_params = {} - if self.identity: - query_params["user_id"] = self.identity + async def _send(self, method, endpoint, content, query_params, headers): + while True: + query_params["access_token"] = self.token + request = self.session.request(method, endpoint, params=query_params, + data=content, headers=headers) + async with request as response: + if response.status < 200 or response.status >= 300: + errcode = message = None + try: + response_data = await response.json() + errcode = response_data["errcode"] + message = response_data["error"] + except (json.decoder.JSONDecodeError, KeyError): + pass + raise MatrixRequestError(code=response.status, text=await response.text(), + errcode=errcode, message=message) + + if response.status == 429: + await asyncio.sleep(response.json()["retry_after_ms"] / 1000) + else: + return await response.json() + + def _log_request(self, method, path, content, query_params): log_content = content if not isinstance(content, bytes) else f"<{len(content)} bytes>" log_content = log_content or "(No content)" query_identity = query_params["user_id"] if "user_id" in query_params else "No identity" self.log.debug("%s %s %s as user %s", method, path, log_content, query_identity) - return super()._send(method, path, content, query_params, headers or {}, api_path=api_path) - def create_room(self, alias=None, is_public=False, name=None, topic=None, is_direct=False, - invitees=(), initial_state=None): - content = { - "visibility": "public" if is_public else "private" - } - if alias: - content["room_alias_name"] = alias - if invitees: - content["invite"] = invitees - if name: - content["name"] = name - if topic: - content["topic"] = topic - if initial_state: - content["initial_state"] = initial_state - content["is_direct"] = is_direct + def request(self, method, path, content=None, query_params=None, headers=None, + api_path="/_matrix/client/r0"): + content = content or {} + query_params = query_params or {} + headers = headers or {} - return self._send("POST", "/createRoom", content) + method = method.upper() + if method not in ["GET", "PUT", "DELETE", "POST"]: + raise MatrixError("Unsupported HTTP method: %s" % method) - def set_presence(self, status="online", user=None): - content = { - "presence": status - } - user = user or self.identity - return self._send("PUT", f"/presence/{user}/status", content) + if "Content-Type" not in headers: + headers["Content-Type"] = "application/json" + if headers["Content-Type"] == "application/json": + content = json.dumps(content) + + if self.identity: + query_params["user_id"] = self.identity + + self._log_request(method, path, content, query_params) + + endpoint = self.base_url + api_path + path + return self._send(method, endpoint, content, query_params, headers or {}) + + def get_download_url(self, mxcurl): + if mxcurl.startswith('mxc://'): + return f"{self.base_url}/_matrix/media/r0/download/{mxcurl[6:]}" + else: + raise ValueError("MXC URL did not begin with 'mxc://'") + + async def get_display_name(self, user_id): + content = await self.request("GET", f"/profile/{user_id}/displayname") + return content.get('displayname', None) + + async def get_avatar_url(self, user_id): + content = await self.request("GET", f"/profile/{user_id}/avatar_url") + return content.get('avatar_url', None) + + async def get_room_id(self, room_alias): + content = await self.request("GET", f"/directory/room/{quote(room_alias)}") + return content.get("room_id", None) def set_typing(self, room_id, is_typing=True, timeout=5000, user=None): content = { @@ -94,20 +135,14 @@ class HTTPAPI(AsyncHTTPAPI): if is_typing: content["timeout"] = timeout user = user or self.identity - return self._send("PUT", f"/rooms/{room_id}/typing/{user}", content) + return self.request("PUT", f"/rooms/{room_id}/typing/{user}", content) class ChildHTTPAPI(HTTPAPI): def __init__(self, user, parent): - self.base_url = parent.base_url - self.token = parent.token - self.identity = user - self.validate_cert = True - self.validate_cert = parent.validate_cert - self.log = parent.log - self.domain = parent.domain + super().__init__(parent.base_url, parent.domain, parent.bot_mxid, parent.token, user, + parent.log, parent.state_store, parent.session, child=True) self.parent = parent - self.client_session = parent.client_session @property def txn_id(self): @@ -118,28 +153,6 @@ class ChildHTTPAPI(HTTPAPI): self.parent.txn_id = value -class IntentError(Exception): - def __init__(self, message, source): - super().__init__(message) - self.source = source - - -def matrix_error_code(err): - try: - data = json.loads(err.content) - return data["errcode"] - except Exception: - return err.content - - -def matrix_error_data(err): - try: - data = json.loads(err.content) - return data["errcode"], data["error"] - except Exception: - return err.content - - class IntentAPI: mxid_regex = re.compile("@(.+):(.+)") @@ -167,40 +180,65 @@ class IntentAPI: async def get_joined_rooms(self): await self.ensure_registered() - response = await self.client._send("GET", "/joined_rooms") + response = await self.client.request("GET", "/joined_rooms") return response["joined_rooms"] async def set_display_name(self, name): await self.ensure_registered() - return await self.client.set_display_name(self.mxid, name) + content = {"displayname": name} + return await self.client.request("PUT", f"/profile/{self.mxid}/displayname", content) async def set_presence(self, status="online"): await self.ensure_registered() - return await self.client.set_presence(status) + content = { + "presence": status + } + return await self.client.request("PUT", f"/presence/{self.mxid}/status", content) async def set_avatar(self, url): await self.ensure_registered() - return await self.client.set_avatar_url(self.mxid, url) + content = {"avatar_url": url} + return await self.client.request("PUT", f"/profile/{self.mxid}/avatar_url", content) async def upload_file(self, data, mime_type=None): await self.ensure_registered() mime_type = mime_type or magic.from_buffer(data, mime=True) - return await self.client.media_upload(data, mime_type) + return await self.client.request("POST", "", content=data, + headers={"Content-Type": mime_type}, + api_path="/matrix/media/r0/upload") async def download_file(self, url): await self.ensure_registered() url = self.client.get_download_url(url) - async with self.client.client_session.get(url) as response: + async with self.client.session.get(url) as response: return await response.read() # endregion # region Room actions - async def create_room(self, alias=None, is_public=False, name=None, topic=None, is_direct=False, - invitees=(), initial_state=None): + async def create_room(self, alias=None, is_public=False, name=None, topic=None, + is_direct=False, invitees=None, initial_state=None): await self.ensure_registered() - return await self.client.create_room(alias, is_public, name, topic, is_direct, invitees, - initial_state or {}) + content = { + "visibility": "public" if is_public else "private", + "is_direct": is_direct, + } + if alias: + content["room_alias_name"] = alias + if invitees: + content["invite"] = invitees + if name: + content["name"] = name + if topic: + content["topic"] = topic + if initial_state: + content["initial_state"] = initial_state + + return await self.client.request("POST", "/createRoom", content) + + def _invite_direct(self, room_id, user_id): + content = {"user_id": user_id} + return self.client.request("POST", "/rooms/" + room_id + "/invite", content) async def invite(self, room_id, user_id, check_cache=False): await self.ensure_joined(room_id) @@ -209,14 +247,13 @@ class IntentAPI: do_invite = (not check_cache or self.state_store.get_membership(room_id, user_id) not in ok_states) if do_invite: - response = await self.client.invite_user(room_id, user_id) + response = await self._invite_direct(room_id, user_id) self.state_store.invited(room_id, user_id) return response except MatrixRequestError as e: - code, message = matrix_error_data(e) - if code != "M_FORBIDDEN": + if e.errcode != "M_FORBIDDEN": raise IntentError(f"Failed to invite {user_id} to {room_id}", e) - if "is already in the room" in message: + if "is already in the room" in e.message: self.state_store.joined(room_id, user_id) def set_room_avatar(self, room_id, avatar_url, info=None): @@ -227,18 +264,20 @@ class IntentAPI: content["info"] = info return self.send_state_event(room_id, "m.room.avatar", content) - async def add_room_alias(self, room_id, alias): + async def add_room_alias(self, room_id, localpart): await self.ensure_registered() - return await self.client.set_room_alias(room_id, f"#{alias}:{self.client.domain}") + content = {"room_id": room_id} + alias = f"#{localpart}:{self.client.domain}" + return await self.client.request("PUT", f"/directory/room/{quote(alias)}", content) - async def remove_room_alias(self, alias): + async def remove_room_alias(self, localpart): await self.ensure_registered() - return await self.client.remove_room_alias(f"#{alias}:{self.client.domain}") + alias = f"#{localpart}:{self.client.domain}" + return await self.client.request("DELETE", f"/directory/room/{quote(alias)}") - async def set_room_name(self, room_id, name): - await self.ensure_joined(room_id) - await self._ensure_has_power_level_for(room_id, "m.room.name") - return await self.client.set_room_name(room_id, name) + def set_room_name(self, room_id, name): + body = {"name": name} + return self.send_state_event(room_id, "m.room.name", body) async def get_power_levels(self, room_id, ignore_cache=False): await self.ensure_joined(room_id) @@ -247,18 +286,21 @@ class IntentAPI: return self.state_store.get_power_levels(room_id) except KeyError: pass - levels = await self.client.get_power_levels(room_id) + levels = await self.client.request("GET", + f"/rooms/{quote(room_id)}/state/m.room.power_levels") self.state_store.set_power_levels(room_id, levels) return levels async def set_power_levels(self, room_id, content): + if "events" not in content: + content["events"] = {} response = await self.send_state_event(room_id, "m.room.power_levels", content) self.state_store.set_power_levels(room_id, content) return response async def get_pinned_messages(self, room_id): await self.ensure_joined(room_id) - response = await self.client._send("GET", f"/rooms/{room_id}/state/m.room.pinned_events") + response = await self.client.request("GET", f"/rooms/{room_id}/state/m.room.pinned_events") return response["content"]["pinned"] def set_pinned_messages(self, room_id, events): @@ -280,15 +322,21 @@ class IntentAPI: async def get_event(self, room_id, event_id): await self.ensure_joined(room_id) - return await self.client._send("GET", f"/rooms/{room_id}/event/{event_id}") + return await self.client.request("GET", f"/rooms/{room_id}/event/{event_id}") async def set_typing(self, room_id, is_typing=True, timeout=5000): await self.ensure_joined(room_id) - return await self.client.set_typing(room_id, is_typing, timeout) + content = { + "typing": is_typing + } + if is_typing: + content["timeout"] = timeout + return await self.client.request("PUT", f"/rooms/{room_id}/typing/{self.mxid}", content) async def mark_read(self, room_id, event_id): await self.ensure_joined(room_id) - return await self.client._send("POST", f"/rooms/{room_id}/receipt/m.read/{event_id}", content={}) + return await self.client.request("POST", f"/rooms/{room_id}/receipt/m.read/{event_id}", + content={}) def send_notice(self, room_id, text, html=None): return self.send_text(room_id, text, html, "m.notice") @@ -331,29 +379,70 @@ class IntentAPI: await self.send_notice(room_id, text, html=html) await self.leave_room(room_id) - async def kick(self, room_id, user_id, message): - await self.ensure_joined(room_id) - return await self.client.kick_user(room_id, user_id, message) + def kick(self, room_id, user_id, message): + return self.set_membership(room_id, user_id, "leave", message) - async def send_event(self, room_id, event_type, body, txn_id=None): + def get_membership(self, room_id, user_id): + return self.get_state_event(room_id, "m.room.member", state_key=user_id) + + def set_membership(self, room_id, user_id, membership, reason="", profile=None): + body = { + "membership": membership, + "reason": reason + } + profile = profile or {} + if "displayname" in profile: + body["displayname"] = profile["displayname"] + if "avatar_url" in profile: + body["avatar_url"] = profile["avatar_url"] + + return self.send_state_event(room_id, "m.room.member", body, state_key=user_id) + + @staticmethod + def _get_event_url(room_id, event_type, txn_id): + return f"/rooms/{quote(room_id)}/send/{quote(event_type)}/{quote(txn_id)}" + + async def send_event(self, room_id, event_type, content, txn_id=None): await self.ensure_joined(room_id) await self._ensure_has_power_level_for(room_id, event_type) - return await self.client.send_message_event(room_id, event_type, body, txn_id) - async def send_state_event(self, room_id, event_type, body, state_key=""): + txn_id = txn_id or str(self.client.txn_id) + str(int(time() * 1000)) + self.client.txn_id += 1 + + url = self._get_event_url(room_id, event_type, txn_id) + + return await self.client.request("PUT", url, content) + + @staticmethod + def _get_state_url(room_id, event_type, state_key=""): + url = f"/rooms/{quote(room_id)}/state/{quote(event_type)}" + if state_key: + url += f"/{quote(state_key)}" + return url + + async def send_state_event(self, room_id, event_type, content, state_key=""): await self.ensure_joined(room_id) await self._ensure_has_power_level_for(room_id, event_type) - return await self.client.send_state_event(room_id, event_type, body, state_key) + url = self._get_state_url(room_id, event_type, state_key) + return await self.client.request("PUT", url, content) + + async def get_state_event(self, room_id, event_type, state_key=""): + await self.ensure_joined(room_id) + url = self._get_state_url(room_id, event_type, state_key) + return await self.client.request("GET", url) def join_room(self, room_id): return self.ensure_joined(room_id, ignore_cache=True) + def _join_room_direct(self, room): + return self.client.request("POST", f"/join/{quote(room)}") + def leave_room(self, room_id): self.state_store.left(room_id, self.mxid) - return self.client.leave_room(room_id) + return self.client.request("POST", f"/rooms/{quote(room_id)}/leave") def get_room_memberships(self, room_id): - return self.client.get_room_members(room_id) + return self.client.request("GET", f"/rooms/{quote(room_id)}/members") async def get_room_members(self, room_id, allowed_memberships=("join",)): memberships = await self.get_room_memberships(room_id) @@ -362,7 +451,8 @@ class IntentAPI: async def get_room_state(self, room_id): await self.ensure_joined(room_id) - state = await self.client.get_room_state(room_id) + state = await self.client.request("GET", f"/rooms/{quote(room_id)}/state") + # TODO update values based on state? return state # endregion @@ -373,25 +463,30 @@ class IntentAPI: return await self.ensure_registered() try: - await self.client.join_room(room_id) + await self._join_room_direct(room_id) self.state_store.joined(room_id, self.mxid) except MatrixRequestError as e: - if matrix_error_code(e) != "M_FORBIDDEN" or not self.bot: + if e.errcode != "M_FORBIDDEN" or not self.bot: raise IntentError(f"Failed to join room {room_id} as {self.mxid}", e) try: await self.bot.invite_user(room_id, self.mxid) - await self.client.join_room(room_id) + await self._join_room_direct(room_id) self.state_store.joined(room_id, self.mxid) except MatrixRequestError as e2: raise IntentError(f"Failed to join room {room_id} as {self.mxid}", e2) + def _register(self): + content = {"username": self.localpart} + query_params = {"kind": "user"} + return self.client.request("POST", "/register", content, query_params) + async def ensure_registered(self): if self.state_store.is_registered(self.mxid): return try: - await self.client.register({"username": self.localpart}) + await self._register() except MatrixRequestError as e: - if matrix_error_code(e) != "M_USER_IN_USE": + if e.errcode != "M_USER_IN_USE": self.log.exception(f"Failed to register {self.mxid}!") # raise IntentError(f"Failed to register {self.mxid}", e) return diff --git a/mautrix_appservice/temp_async_api.py b/mautrix_appservice/temp_async_api.py deleted file mode 100644 index ab321914..00000000 --- a/mautrix_appservice/temp_async_api.py +++ /dev/null @@ -1,72 +0,0 @@ -import json -from asyncio import sleep -from urllib.parse import quote - -from matrix_client.api import MatrixHttpApi -from matrix_client.errors import MatrixError, MatrixRequestError - - -class AsyncHTTPAPI(MatrixHttpApi): - def __init__(self, base_url, client_session, token=None, identity=None): - self.base_url = base_url - self.token = token - self.identity = identity - self.txn_id = 0 - self.validate_cert = True - self.client_session = client_session - - async def _send(self, - method, - path, - content=None, - query_params={}, - headers={}, - api_path="/_matrix/client/r0"): - if not content: - content = {} - - method = method.upper() - if method not in ["GET", "PUT", "DELETE", "POST"]: - raise MatrixError("Unsupported HTTP method: %s" % method) - - if "Content-Type" not in headers: - headers["Content-Type"] = "application/json" - - if self.token: - query_params["access_token"] = self.token - endpoint = self.base_url + api_path + path - - if headers["Content-Type"] == "application/json": - content = json.dumps(content) - - while True: - request = self.client_session.request( - method, - endpoint, - params=query_params, - data=content, - headers=headers) - async with request as response: - if response.status < 200 or response.status >= 300: - raise MatrixRequestError( - code=response.status, content=await response.text()) - - if response.status == 429: - await sleep(response.json()['retry_after_ms'] / 1000) - else: - return await response.json() - - async def get_display_name(self, user_id): - content = await self._send("GET", "/profile/%s/displayname" % user_id) - return content.get('displayname', None) - - async def get_avatar_url(self, user_id): - content = await self._send("GET", "/profile/%s/avatar_url" % user_id) - return content.get('avatar_url', None) - - async def get_room_id(self, room_alias): - content = await self._send( - "GET", - "/directory/room/{}".format(quote(room_alias)), - api_path="/_matrix/client/r0") - return content.get("room_id", None) diff --git a/mautrix_telegram/commands.py b/mautrix_telegram/commands.py index 1480224c..e299ff5a 100644 --- a/mautrix_telegram/commands.py +++ b/mautrix_telegram/commands.py @@ -18,7 +18,7 @@ import markdown import logging import asyncio -from matrix_client.errors import MatrixRequestError +from mautrix_appservice import MatrixRequestError from telethon.errors import * from telethon.tl.types import * diff --git a/mautrix_telegram/formatter.py b/mautrix_telegram/formatter.py index 13c3ce89..cb920284 100644 --- a/mautrix_telegram/formatter.py +++ b/mautrix_telegram/formatter.py @@ -20,7 +20,7 @@ from collections import deque import re import logging -from matrix_client.errors import MatrixRequestError +from mautrix_appservice import MatrixRequestError from telethon.tl.types import * diff --git a/mautrix_telegram/matrix.py b/mautrix_telegram/matrix.py index 1b13ea3e..ccc5d651 100644 --- a/mautrix_telegram/matrix.py +++ b/mautrix_telegram/matrix.py @@ -16,7 +16,7 @@ # along with this program. If not, see . import logging -from matrix_client.errors import MatrixRequestError +from mautrix_appservice import MatrixRequestError from .user import User from .portal import Portal diff --git a/requirements.txt b/requirements.txt index 4d15e4c1..3c33c25b 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,5 +1,4 @@ aiohttp --e git+git://github.com/Cadair/matrix-python-sdk#egg=matrix_client ruamel.yaml python-magic SQLAlchemy diff --git a/setup.py b/setup.py index 9a503413..59fbefea 100644 --- a/setup.py +++ b/setup.py @@ -24,7 +24,6 @@ setuptools.setup( "python-magic>=0.4.15,<0.5", ], dependency_links=[ - "https://github.com/Cadair/matrix-python-sdk/tarball/1fab9821d98d15769e44e66f714d00a32a48d692#egg=matrix_client", "https://github.com/LonamiWebs/Telethon/tarball/7da092894b306d720cc60c04daa2bfba58f81946#egg=Telethon" ],