commit 33d25a2a1da04999f9590ff412ad4ec4e4c33423 · zenfyr.dev/xpost

+5 -10

cross/service.py

···

       34
       34
        
               self.conn.close()

     

       35
       35
        
       

     

       36
       36
        
       class OutputService(Service):

     

       37
       37
       -
           def __init__(self, url: str, db: Path) -> None:

     

       38
       38
       -
               super().__init__(url, db)

     

       39
       39
       -
       

     

       40
       37
        
           def accept_post(self, post: Post):

     

       41
       41
       -
               LOGGER.warning("NOT IMPLEMENTED, accept_post %s", post.id)

     

       38
       38
       +
               LOGGER.warning("NOT IMPLEMENTED (%s), accept_post %s", self.url, post.id)

     

       42
       39
        
       

     

       43
       40
        
           def delete_post(self, post_id: str):

     

       44
       44
       -
               LOGGER.warning("NOT IMPLEMENTED, delete_post %s", post_id)

     

       41
       41
       +
               LOGGER.warning("NOT IMPLEMENTED (%s), delete_post %s", self.url, post_id)

     

       45
       42
        
       

     

       46
       43
        
           def accept_repost(self, repost_id: str, reposted_id: str):

     

       47
       47
       -
               LOGGER.warning("NOT IMPLEMENTED, accept_repost %s", repost_id)

     

       44
       44
       +
               LOGGER.warning("NOT IMPLEMENTED (%s), accept_repost %s of %s", self.url, repost_id, reposted_id)

     

       48
       45
        
       

     

       49
       46
        
           def delete_repost(self, repost_id: str):

     

       50
       50
       -
               LOGGER.warning("NOT IMPLEMENTED, delete_repost %s", repost_id)

     

       47
       47
       +
               LOGGER.warning("NOT IMPLEMENTED (%s), delete_repost %s", self.url, repost_id)

     

       51
       48
        
       

     

       52
       49
        
       class InputService(Service):

     

       53
       53
       -
           def __init__(self, url: str, db: Path) -> None:

     

       54
       54
       -
               super().__init__(url, db)

     

       55
       50
        
       

     

       56
       56
       -
           async def listen(self, outputs: list[OutputService], submitter: Callable[[Callable[[], None]], None]):

     

       51
       51
       +
           async def listen(self, outputs: list[OutputService], submitter: Callable[[Callable[[], None]], None]):  # pyright: ignore[reportUnusedParameter]

     

       57
       52
        
               pass

+79

mastodon/info.py

···

       1
       1
       +
       from abc import ABC, abstractmethod

     

       2
       2
       +
       from dataclasses import dataclass

     

       3
       3
       +
       from typing import Any

     

       4
       4
       +
       

     

       5
       5
       +
       import requests

     

       6
       6
       +
       

     

       7
       7
       +
       from cross.service import Service

     

       8
       8
       +
       from util.util import LOGGER

     

       9
       9
       +
       

     

       10
       10
       +
       

     

       11
       11
       +
       @dataclass(kw_only=True)

     

       12
       12
       +
       class InstanceInfo:

     

       13
       13
       +
           max_characters: int = 500

     

       14
       14
       +
           max_media_attachments: int = 4

     

       15
       15
       +
           characters_reserved_per_url: int = 23

     

       16
       16
       +
       

     

       17
       17
       +
           image_size_limit: int = 16777216

     

       18
       18
       +
           video_size_limit: int = 103809024

     

       19
       19
       +
       

     

       20
       20
       +
           @classmethod

     

       21
       21
       +
           def from_api(cls, data: dict[str, Any]) -> "InstanceInfo":

     

       22
       22
       +
               config: dict[str, Any] = {}

     

       23
       23
       +
       

     

       24
       24
       +
               if "statuses" in data:

     

       25
       25
       +
                   statuses_config: dict[str, Any] = data.get("statuses", {})

     

       26
       26
       +
                   if "max_characters" in statuses_config:

     

       27
       27
       +
                       config["max_characters"] = statuses_config["max_characters"]

     

       28
       28
       +
                   if "max_media_attachments" in statuses_config:

     

       29
       29
       +
                       config["max_media_attachments"] = statuses_config[

     

       30
       30
       +
                           "max_media_attachments"

     

       31
       31
       +
                       ]

     

       32
       32
       +
                   if "characters_reserved_per_url" in statuses_config:

     

       33
       33
       +
                       config["characters_reserved_per_url"] = statuses_config[

     

       34
       34
       +
                           "characters_reserved_per_url"

     

       35
       35
       +
                       ]

     

       36
       36
       +
       

     

       37
       37
       +
               if "media_attachments" in data:

     

       38
       38
       +
                   media_config: dict[str, Any] = data.get("media_attachments", {})

     

       39
       39
       +
                   if "image_size_limit" in media_config:

     

       40
       40
       +
                       config["image_size_limit"] = media_config["image_size_limit"]

     

       41
       41
       +
                   if "video_size_limit" in media_config:

     

       42
       42
       +
                       config["video_size_limit"] = media_config["video_size_limit"]

     

       43
       43
       +
       

     

       44
       44
       +
               # *oma extensions

     

       45
       45
       +
               if "max_toot_chars" in data:

     

       46
       46
       +
                   config["max_characters"] = data["max_toot_chars"]

     

       47
       47
       +
               if "upload_limit" in data:

     

       48
       48
       +
                   config["image_size_limit"] = data["upload_limit"]

     

       49
       49
       +
                   config["video_size_limit"] = data["upload_limit"]

     

       50
       50
       +
       

     

       51
       51
       +
               return InstanceInfo(**config)

     

       52
       52
       +
       

     

       53
       53
       +
       

     

       54
       54
       +
       class MastodonService(ABC, Service):

     

       55
       55
       +
           def verify_credentials(self):

     

       56
       56
       +
               token = self._get_token()

     

       57
       57
       +
               responce = requests.get(

     

       58
       58
       +
                   f"{self.url}/api/v1/accounts/verify_credentials",

     

       59
       59
       +
                   headers={"Authorization": f"Bearer {token}"},

     

       60
       60
       +
               )

     

       61
       61
       +
               if responce.status_code != 200:

     

       62
       62
       +
                   LOGGER.error("Failed to validate user credentials!")

     

       63
       63
       +
                   responce.raise_for_status()

     

       64
       64
       +
               return dict(responce.json())

     

       65
       65
       +
       

     

       66
       66
       +
           def fetch_instance_info(self):

     

       67
       67
       +
               token = self._get_token()

     

       68
       68
       +
               responce = requests.get(

     

       69
       69
       +
                   f"{self.url}/api/v1/instance",

     

       70
       70
       +
                   headers={"Authorization": f"Bearer {token}"},

     

       71
       71
       +
               )

     

       72
       72
       +
               if responce.status_code != 200:

     

       73
       73
       +
                   LOGGER.error("Failed to get instance info!")

     

       74
       74
       +
                   responce.raise_for_status()

     

       75
       75
       +
               return dict(responce.json())

     

       76
       76
       +
       

     

       77
       77
       +
           @abstractmethod

     

       78
       78
       +
           def _get_token(self) -> str:

     

       79
       79
       +
               pass

+55 -10

mastodon/input.py

···

       1
       1
       +
       import asyncio

     

       1
       2
        
       import re

     

       2
       3
        
       from dataclasses import dataclass, field

     

       3
       4
        
       from pathlib import Path

     

       4
       5
        
       from typing import Any, Callable, override

     

       6
       6
       +
       

     

       7
       7
       +
       import websockets

     

       5
       8
        
       

     

       6
       9
        
       from cross.service import InputService, OutputService

     

       10
       10
       +
       from mastodon.info import MastodonService

     

       7
       11
        
       from util.util import LOGGER

     

       8
       12
        
       

     

       9
       13
        
       ALLOWED_VISIBILITY: list[str] = ["public", "unlisted"]

     

       14
       14
       +
       

     

       10
       15
        
       

     

       11
       16
        
       @dataclass(kw_only=True)

     

       12
       17
        
       class MastodonInputOptions:

     

       13
       18
        
           token: str

     

       14
       19
        
           instance: str

     

       15
       15
       -
           allowed_visibility: list[str] = field(default_factory=lambda: ALLOWED_VISIBILITY.copy())

     

       20
       20
       +
           allowed_visibility: list[str] = field(

     

       21
       21
       +
               default_factory=lambda: ALLOWED_VISIBILITY.copy()

     

       22
       22
       +
           )

     

       16
       23
        
           regex_filters: list[re.Pattern[str]] = field(default_factory=lambda: [])

     

       17
       24
        
       

     

       18
       25
        
           @classmethod

     

       19
       19
       -
           def from_dict(cls, data: dict[str, Any]) -> 'MastodonInputOptions':

     

       20
       20
       -
               data['instance'] = data['instance'][:-1] if data['instance'].endswith("/") else data['instance']

     

       26
       26
       +
           def from_dict(cls, data: dict[str, Any]) -> "MastodonInputOptions":

     

       27
       27
       +
               data["instance"] = (

     

       28
       28
       +
                   data["instance"][:-1]

     

       29
       29
       +
                   if data["instance"].endswith("/")

     

       30
       30
       +
                   else data["instance"]

     

       31
       31
       +
               )

     

       21
       32
        
       

     

       22
       22
       -
               if 'allowed_visibility' in data:

     

       23
       23
       -
                   for vis in data.get('allowed_visibility', []):

     

       33
       33
       +
               if "allowed_visibility" in data:

     

       34
       34
       +
                   for vis in data.get("allowed_visibility", []):

     

       24
       35
        
                       if vis not in ALLOWED_VISIBILITY:

     

       25
       36
        
                           raise ValueError(f"Invalid visibility option {vis}!")

     

       26
       37
        
       

     

       27
       27
       -
               if 'regex_filters' in data:

     

       28
       28
       -
                   data['regex_filters'] = [re.compile(r) for r in data['regex_filters']]

     

       38
       38
       +
               if "regex_filters" in data:

     

       39
       39
       +
                   data["regex_filters"] = [re.compile(r) for r in data["regex_filters"]]

     

       29
       40
        
       

     

       30
       41
        
               return MastodonInputOptions(**data)

     

       31
       42
        
       

     

       32
       32
       -
       class MastodonInputService(InputService):

     

       43
       43
       +
       

     

       44
       44
       +
       class MastodonInputService(MastodonService, InputService):

     

       33
       45
        
           def __init__(self, db: Path, options: MastodonInputOptions) -> None:

     

       34
       46
        
               super().__init__(options.instance, db)

     

       47
       47
       +
               self.options: MastodonInputOptions = options

     

       35
       48
        
       

     

       36
       49
        
               LOGGER.info("Verifying %s credentails...", self.url)

     

       50
       50
       +
               responce = self.verify_credentials()

     

       51
       51
       +
               self.user_id: str = responce["id"]

     

       52
       52
       +
       

     

       53
       53
       +
               LOGGER.info("Getting %s configuration...", self.url)

     

       54
       54
       +
               responce = self.fetch_instance_info()

     

       55
       55
       +
               self.streaming_url: str = responce["urls"]["streaming_api"]

     

       37
       56
        
       

     

       38
       57
        
           @override

     

       39
       39
       -
           async def listen(self, outputs: list[OutputService], submitter: Callable[[Callable[[], None]], None]):

     

       40
       40
       -
               return await super().listen(outputs, submitter) # TODO

     

       58
       58
       +
           def _get_token(self) -> str:

     

       59
       59
       +
               return self.options.token

     

       60
       60
       +
       

     

       61
       61
       +
           @override

     

       62
       62
       +
           async def listen(

     

       63
       63
       +
               self,

     

       64
       64
       +
               outputs: list[OutputService],

     

       65
       65
       +
               submitter: Callable[[Callable[[], None]], None],

     

       66
       66
       +
           ):

     

       67
       67
       +
               uri = f"{self.streaming_url}/api/v1/streaming?stream=user"

     

       68
       68
       +
       

     

       69
       69
       +
               async for ws in websockets.connect(

     

       70
       70
       +
                   uri, additional_headers={"Authorization": f"Bearer {self.options.token}"}

     

       71
       71
       +
               ):

     

       72
       72
       +
                   try:

     

       73
       73
       +
                       LOGGER.info("Listening to %s...", self.streaming_url)

     

       74
       74
       +
       

     

       75
       75
       +
                       async def listen_for_messages():

     

       76
       76
       +
                           async for msg in ws:

     

       77
       77
       +
                               LOGGER.info(msg)  # TODO

     

       78
       78
       +
       

     

       79
       79
       +
                       listen = asyncio.create_task(listen_for_messages())

     

       80
       80
       +
       

     

       81
       81
       +
                       _ = await asyncio.gather(listen)

     

       82
       82
       +
                   except websockets.ConnectionClosedError as e:

     

       83
       83
       +
                       LOGGER.error(e, stack_info=True, exc_info=True)

     

       84
       84
       +
                       LOGGER.info("Reconnecting to %s...", self.streaming_url)

     

       85
       85
       +
                       continue

+28 -6

mastodon/output.py

···

       1
       1
        
       from dataclasses import dataclass

     

       2
       2
        
       from pathlib import Path

     

       3
       3
       -
       from typing import Any

     

       3
       3
       +
       from typing import Any, override

     

       4
       4
       +
       

     

       4
       5
        
       from cross.service import OutputService

     

       6
       6
       +
       from mastodon.info import InstanceInfo, MastodonService

     

       7
       7
       +
       from util.util import LOGGER

     

       5
       8
        
       

     

       6
       9
        
       ALLOWED_POSTING_VISIBILITY: list[str] = ["public", "unlisted", "private"]

     

       7
       10
        
       

     

       11
       11
       +
       

     

       8
       12
        
       @dataclass(kw_only=True)

     

       9
       13
        
       class MastodonOutputOptions:

     

       10
       14
        
           token: str

     
···

       12
       16
        
           visibility: str = "public"

     

       13
       17
        
       

     

       14
       18
        
           @classmethod

     

       15
       15
       -
           def from_dict(cls, data: dict[str, Any]) -> 'MastodonOutputOptions':

     

       16
       16
       -
               data['instance'] = data['instance'][:-1] if data['instance'].endswith("/") else data['instance']

     

       19
       19
       +
           def from_dict(cls, data: dict[str, Any]) -> "MastodonOutputOptions":

     

       20
       20
       +
               data["instance"] = (

     

       21
       21
       +
                   data["instance"][:-1]

     

       22
       22
       +
                   if data["instance"].endswith("/")

     

       23
       23
       +
                   else data["instance"]

     

       24
       24
       +
               )

     

       17
       25
        
       

     

       18
       18
       -
               if 'visibility' in data:

     

       19
       19
       -
                   if data['visibility'] not in ALLOWED_POSTING_VISIBILITY:

     

       26
       26
       +
               if "visibility" in data:

     

       27
       27
       +
                   if data["visibility"] not in ALLOWED_POSTING_VISIBILITY:

     

       20
       28
        
                       raise ValueError(f"Invalid visibility option {data['visibility']}!")

     

       21
       29
        
       

     

       22
       30
        
               return MastodonOutputOptions(**data)

     

       23
       31
        
       

     

       32
       32
       +
       

     

       24
       33
        
       # TODO

     

       25
       25
       -
       class MastodonOutputService(OutputService):

     

       34
       34
       +
       class MastodonOutputService(MastodonService, OutputService):

     

       26
       35
        
           def __init__(self, db: Path, options: MastodonOutputOptions) -> None:

     

       27
       36
        
               super().__init__(options.instance, db)

     

       37
       37
       +
               self.options: MastodonOutputOptions = options

     

       38
       38
       +
       

     

       39
       39
       +
               LOGGER.info("Verifying %s credentails...", self.url)

     

       40
       40
       +
               responce = self.verify_credentials()

     

       41
       41
       +
               self.user_id: str = responce["id"]

     

       42
       42
       +
       

     

       43
       43
       +
               LOGGER.info("Getting %s configuration...", self.url)

     

       44
       44
       +
               responce = self.fetch_instance_info()

     

       45
       45
       +
               self.instance_info = InstanceInfo.from_api(responce)

     

       46
       46
       +
       

     

       47
       47
       +
           @override

     

       48
       48
       +
           def _get_token(self) -> str:

     

       49
       49
       +
               return self.options.token