commit 23a3b2966206b5722910c2c3436cd03e60a8f92e · zenfyr.dev/xpost

+17

bluesky.py

···

       293
       293
        
               LOGGER.info("Listening to %s...", streaming + '/com.atproto.sync.subscribeRepos')

     

       294
       294
        
               await client.start(on_message)

     

       295
       295
        
       

     

       296
       296
       +
       ALLOWED_GATES = ['mentioned', 'following', 'followers', 'everybody']

     

       297
       297
       +
       

     

       298
       298
       +
       class BlueskyOutputOptions:

     

       299
       299
       +
           def __init__(self, o: dict) -> None:

     

       300
       300
       +
               self.quote_gate = False

     

       301
       301
       +
               self.thread_gate = ['everybody']

     

       302
       302
       +
               

     

       303
       303
       +
               quote_gate = o.get('quote_gate')

     

       304
       304
       +
               if quote_gate is not None:

     

       305
       305
       +
                   self.quote_gate = bool(quote_gate)

     

       306
       306
       +
               

     

       307
       307
       +
               thread_gate = o.get('thread_gate')

     

       308
       308
       +
               if thread_gate is not None:

     

       309
       309
       +
                   if any([v not in ALLOWED_GATES for v in ALLOWED_GATES]):

     

       310
       310
       +
                       raise ValueError(f"'thread_gate' only accepts {', '.join(ALLOWED_GATES)} or [], got: {thread_gate}")

     

       311
       311
       +
                   self.thread_gate = thread_gate

     

       312
       312
       +
       

     

       296
       313
        
       class BlueskyOutput(cross.Output):

     

       297
       314
        
           def __init__(self, input: cross.Input, settings: dict, db: DataBaseWorker) -> None:

     

       298
       315
        
               super().__init__(input, settings, db)

+1 -1

cross.py

···

       1
       1
        
       from typing import Callable, Any

     

       2
       2
        
       from database import DataBaseWorker

     

       3
       3
        
       from datetime import datetime, timezone

     

       4
       4
       -
       from media_util import MediaInfo, get_media_meta

     

       4
       4
       +
       from media_util import MediaInfo

     

       5
       5
        
       import util

     

       6
       6
        
       import re

     

       7
       7

+4 -13

main.py

···

       4
       4
        
       import database

     

       5
       5
        
       import mastodon, misskey, bluesky, cross

     

       6
       6
        
       import asyncio, threading, queue, traceback

     

       7
       7
       +
       import util

     

       7
       8
        
       

     

       8
       9
        
       DEFAULT_SETTINGS: dict = {

     

       9
       10
        
           'input': {

     

       10
       11
        
               'type': 'mastodon-wss',

     

       11
       12
        
               'instance': 'env:MASTODON_INSTANCE',

     

       12
       13
        
               'token': 'env:MASTODON_TOKEN',

     

       13
       13
       -
               "options": {

     

       14
       14
       -
                   "allowed_visibility": [

     

       15
       15
       -
                       "public",

     

       16
       16
       -
                       "unlisted"

     

       17
       17
       -
                   ]

     

       18
       18
       -
               }

     

       14
       14
       +
               "options": mastodon.MastodonInputOptions({})

     

       19
       15
        
           },

     

       20
       16
        
           'outputs': [

     

       21
       17
        
               {

     

       22
       18
        
                   'type': 'bluesky',

     

       23
       19
        
                   'handle': 'env:BLUESKY_HANDLE',

     

       24
       20
        
                   'app-password': 'env:BLUESKY_APP_PASSWORD',

     

       25
       25
       -
                   'options': {

     

       26
       26
       -
                       'quote_gate': False,

     

       27
       27
       -
                       'thread_gate': [

     

       28
       28
       -
                           'everybody'

     

       29
       29
       -
                       ]

     

       30
       30
       -
                   }

     

       21
       21
       +
                   'options': bluesky.BlueskyOutputOptions({})

     

       31
       22
        
               }

     

       32
       23
        
           ]

     

       33
       24
        
       }

     
···

       54
       45
        
               LOGGER.info("First launch detected! Creating %s and exiting!", settings_path)

     

       55
       46
        
               

     

       56
       47
        
               with open(settings_path, 'w') as f:

     

       57
       57
       -
                   json.dump(DEFAULT_SETTINGS, f, indent=2)

     

       48
       48
       +
                   f.write(util.as_json(DEFAULT_SETTINGS, indent=2))

     

       58
       49
        
               return 0

     

       59
       50
        
       

     

       60
       51
        
           LOGGER.info('Loading settings...')

+26 -9

mastodon.py

···

       10
       10
        
       from bs4.element import NavigableString

     

       11
       11
        
       from html_to_markdown import markdownify as md

     

       12
       12
        
       

     

       13
       13
       -
       FORMATS = {

     

       14
       14
       -
           'video': 'video',

     

       15
       15
       -
           'image': 'image',

     

       16
       16
       -
           'gifv': 'gif',

     

       17
       17
       -
           'audio': 'audio',

     

       18
       18
       -
           'unknown': 'other'

     

       19
       19
       -
       }

     

       20
       13
        
       POSSIBLE_MIMES = [

     

       21
       14
        
           'audio/ogg',

     

       22
       15
        
           'audio/mp3',

     
···

       120
       113
        
           def get_attachments(self) -> list[media_util.MediaInfo]:

     

       121
       114
        
               return self.media_attachments

     

       122
       115
        
       

     

       116
       116
       +
       ALLOWED_VISIBILITY = ['public', 'unlisted']

     

       117
       117
       +
           

     

       118
       118
       +
       class MastodonInputOptions():

     

       119
       119
       +
           def __init__(self, o: dict) -> None:

     

       120
       120
       +
               self.allowed_visibility = ALLOWED_VISIBILITY

     

       121
       121
       +
               

     

       122
       122
       +
               allowed_visibility = o.get('allowed_visibility')

     

       123
       123
       +
               if allowed_visibility is not None:

     

       124
       124
       +
                   if any([v not in ALLOWED_VISIBILITY for v in allowed_visibility]):

     

       125
       125
       +
                       raise ValueError(f"'allowed_visibility' only accepts {', '.join(ALLOWED_VISIBILITY)}, got: {allowed_visibility}")

     

       126
       126
       +
                   self.allowed_visibility = allowed_visibility

     

       127
       127
       +
       

     

       123
       128
        
       class MastodonInput(cross.Input):

     

       124
       129
        
           def __init__(self, settings: dict, db: DataBaseWorker) -> None:

     

       125
       125
       -
               self.options = settings.get('options', {})

     

       130
       130
       +
               self.options = MastodonInputOptions(settings.get('options', {}))

     

       126
       131
        
               self.token = util.as_envvar(settings.get('token')) or (_ for _ in ()).throw(ValueError("'token' is required"))

     

       127
       132
        
               instance: str = util.as_envvar(settings.get('instance')) or (_ for _ in ()).throw(ValueError("'instance' is required"))

     

       128
       133
        
               

     
···

       167
       172
        
                   LOGGER.info("Skipping '%s'! Reply to other user..", status['id'])

     

       168
       173
        
                   return

     

       169
       174
        
               

     

       170
       170
       -
               if status.get('visibility') not in self.options.get('allowed_visibility', []):

     

       175
       175
       +
               if status.get('visibility') not in self.options.allowed_visibility:

     

       171
       176
        
                   # Skip f/o and direct posts

     

       172
       177
        
                   LOGGER.info("Skipping '%s'! '%s' visibility..", status['id'], status.get('visibility'))

     

       173
       178
        
                   return

     
···

       230
       235
        
                       LOGGER.error(e, stack_info=True, exc_info=True)

     

       231
       236
        
                       LOGGER.info("Reconnecting to %s...", self.streaming)

     

       232
       237
        
                       continue

     

       238
       238
       +
       

     

       239
       239
       +
       ALLOWED_POSTING_VISIBILITY = ['public', 'unlisted', 'private']

     

       240
       240
       +
       

     

       241
       241
       +
       class MastodonOutputOptions():

     

       242
       242
       +
           def __init__(self, o: dict) -> None:

     

       243
       243
       +
               self.visibility = 'public'

     

       244
       244
       +
               

     

       245
       245
       +
               visibility = o.get('visibility')

     

       246
       246
       +
               if visibility is not None:

     

       247
       247
       +
                   if visibility not in ALLOWED_POSTING_VISIBILITY:

     

       248
       248
       +
                       raise ValueError(f"'visibility' only accepts {', '.join(ALLOWED_POSTING_VISIBILITY)}, got: {visibility}")

     

       249
       249
       +
                   self.visibility = visibility

     

       233
       250
        
       

     

       234
       251
        
       class MastodonOutput(cross.Output):

     

       235
       252
        
           def __init__(self, input: cross.Input, settings: dict, db: DataBaseWorker) -> None:

+14 -14

misskey.py

···

       11
       11
        
       MD_AUTOLINK = re.compile(r"<((?:https?://[^\s>]+|mailto:[^\s>]+))>")

     

       12
       12
        
       HASHTAG = re.compile(r'(?<!\w)\#([\w]+)')

     

       13
       13
        
       FEDIVERSE_HANDLE = re.compile(r'(?<![\w@])@([\w-]+)(?:@([\w\.-]+\.[\w\.-]+))?')

     

       14
       14
       -
       

     

       15
       15
       -
       def get_image_common(mime: str):

     

       16
       16
       -
           if mime.startswith('image/'):

     

       17
       17
       -
               if mime == 'image/gif':

     

       18
       18
       -
                   return 'gif'

     

       19
       19
       -
               return 'image'

     

       20
       20
       -
           elif mime.startswith('video/'):

     

       21
       21
       -
               return 'video'

     

       22
       22
       -
           elif mime.startswith('audio/'):

     

       23
       23
       -
               return 'audio'

     

       24
       24
       -
           else:

     

       25
       25
       -
               return 'other'

     

       26
       14
        
           

     

       27
       15
        
       def tokenize_note(note: dict) -> list[cross.Token]:

     

       28
       16
        
           text: str = note.get('text', '')

     
···

       134
       122
        
           

     

       135
       123
        
           def is_sensitive(self) -> bool:

     

       136
       124
        
               return self.sensitive

     

       125
       125
       +
           

     

       126
       126
       +
       ALLOWED_VISIBILITY = ['public', 'home']

     

       127
       127
       +
           

     

       128
       128
       +
       class MisskeyInputOptions():

     

       129
       129
       +
           def __init__(self, o: dict) -> None:

     

       130
       130
       +
               self.allowed_visibility = ALLOWED_VISIBILITY

     

       131
       131
       +
               

     

       132
       132
       +
               allowed_visibility = o.get('allowed_visibility')

     

       133
       133
       +
               if allowed_visibility is not None:

     

       134
       134
       +
                   if any([v not in ALLOWED_VISIBILITY for v in allowed_visibility]):

     

       135
       135
       +
                       raise ValueError(f"'allowed_visibility' only accepts {', '.join(ALLOWED_VISIBILITY)}, got: {allowed_visibility}")

     

       136
       136
       +
                   self.allowed_visibility = allowed_visibility

     

       137
       137
        
       

     

       138
       138
        
       class MisskeyInput(cross.Input):

     

       139
       139
        
           def __init__(self, settings: dict, db: cross.DataBaseWorker) -> None:

     

       140
       140
       -
               self.options = settings.get('options', {})

     

       140
       140
       +
               self.options = MisskeyInputOptions(settings.get('options', {}))

     

       141
       141
        
               self.token = util.as_envvar(settings.get('token')) or (_ for _ in ()).throw(ValueError("'token' is required"))

     

       142
       142
        
               instance: str = util.as_envvar(settings.get('instance')) or (_ for _ in ()).throw(ValueError("'instance' is required"))

     

       143
       143
        
               

     
···

       170
       170
        
                       LOGGER.info("Skipping '%s'! Reply to other user..", note['id'])

     

       171
       171
        
                       return

     

       172
       172
        
               

     

       173
       173
       -
               if note.get('visibility') not in self.options.get('allowed_visibility', []):

     

       173
       173
       +
               if note.get('visibility') not in self.options.allowed_visibility:

     

       174
       174
        
                   LOGGER.info("Skipping '%s'! '%s' visibility..", note['id'], note.get('visibility'))

     

       175
       175
        
                   return

     

       176
       176

+10

util.py

···

       1
       1
        
       import logging, sys, os

     

       2
       2
       +
       import json

     

       2
       3
        
       

     

       3
       4
        
       logging.basicConfig(stream=sys.stdout, level=logging.INFO)

     

       4
       5
        
       LOGGER = logging.getLogger("XPost")

     

       6
       6
       +
       

     

       7
       7
       +
       import json

     

       8
       8
       +
       

     

       9
       9
       +
       def as_json(obj, indent=None,sort_keys=False) -> str:

     

       10
       10
       +
           return json.dumps(

     

       11
       11
       +
               obj.__dict__ if not isinstance(obj, dict) else obj, 

     

       12
       12
       +
               default=lambda o: o.__json__() if hasattr(o, '__json__') else o.__dict__,

     

       13
       13
       +
               indent=indent,

     

       14
       14
       +
               sort_keys=sort_keys)

     

       5
       15
        
       

     

       6
       16
        
       def canonical_label(label: str | None, href: str):

     

       7
       17
        
           if not label or label == href: