commit 2867f353cd549505a4eadeaf5d8b51848661dc9c · zenfyr.dev/xpost

+5 -2

cross.py

···

       69
       69
        
           def get_tokens(self) -> list[Token]:

     

       70
       70
        
               return []

     

       71
       71
        
           

     

       72
       72
       -
           def get_parent_id(self) -> str:

     

       73
       73
       -
               return ''

     

       72
       72
       +
           def get_parent_id(self) -> str | None:

     

       73
       73
       +
               return None

     

       74
       74
        
           

     

       75
       75
        
           def get_attachments(self) -> list[MediaAttachment]:

     

       76
       76
        
               return []

     
···

       80
       80
        
           

     

       81
       81
        
           def get_cw(self) -> str:

     

       82
       82
        
               return ''

     

       83
       83
       +
           

     

       84
       84
       +
           def get_languages(self) -> list[str]:

     

       85
       85
       +
               return []

     

       83
       86
        
           

     

       84
       87
        
           def is_sensitive(self) -> bool:

     

       85
       88
        
               return False

+21 -12

mastodon.py

···

       79
       79
        
               self.status = status

     

       80
       80
        
               media_attachments: list[cross.MediaAttachment] = []

     

       81
       81
        
               

     

       82
       82
       -
               for attachment in status['media_attachments']:

     

       82
       82
       +
               for attachment in status.get('media_attachments', []):

     

       83
       83
        
                   media_attachments.append(MastodonAttachment(attachment))

     

       84
       84
        
                   

     

       85
       85
        
               self.media_attachments = media_attachments

     

       86
       86
        
               

     

       87
       87
       -
               self.tokens = util.tokenize_html(status['content'])

     

       87
       87
       +
               self.tokens = util.tokenize_html(status.get('content', ''))

     

       88
       88
        
           

     

       89
       89
        
           def get_tokens(self) -> list[cross.Token]:

     

       90
       90
        
               return self.tokens

     

       91
       91
        
           

     

       92
       92
       -
           def get_parent_id(self) -> str:

     

       93
       93
       -
               return self.status['in_reply_to_id']

     

       92
       92
       +
           def get_parent_id(self) -> str | None:

     

       93
       93
       +
               return self.status.get('in_reply_to_id')

     

       94
       94
        
           

     

       95
       95
        
           def get_cw(self) -> str:

     

       96
       96
        
               return util.safe_get(self.status, 'spoiler_text', '')

     
···

       98
       98
        
           def get_id(self) -> str:

     

       99
       99
        
               return self.status['id']

     

       100
       100
        
           

     

       101
       101
       +
           def get_languages(self) -> list[str]:

     

       102
       102
       +
               if self.status.get('language'):

     

       103
       103
       +
                   return [self.status['language']]

     

       104
       104
       +
               return []

     

       105
       105
       +
           

     

       101
       106
        
           def is_sensitive(self) -> bool:

     

       102
       102
       -
               return self.status['sensitive']

     

       107
       107
       +
               return self.status.get('sensitive', False)

     

       103
       108
        
           

     

       104
       109
        
           def get_attachments(self) -> list[cross.MediaAttachment]:

     

       105
       110
        
               return self.media_attachments

     
···

       240
       245
        
           

     

       241
       246
        
           async def listen(self, outputs: list[cross.Output], submit: Callable[[Callable[[], Any]], Any]):

     

       242
       247
        
               uri = f"{self.streaming}/api/v1/streaming?stream=user&access_token={self.token}"

     

       243
       243
       -
               async with websockets.connect(uri, extra_headers={

     

       244
       244
       -
                   "User-Agent": "XPost/0.0.2"

     

       245
       245
       -
               }) as ws:

     

       246
       246
       -
                   while True:

     

       247
       247
       -
                       message = await ws.recv()

     

       248
       248
       -
                       event: dict = json.loads(message)

     

       249
       249
       -
                       submit(lambda: self._on_post(outputs, str(event.get('event')), str(event.get('payload'))))

     

       248
       248
       +
               

     

       249
       249
       +
               async for ws in websockets.connect(uri, extra_headers={"User-Agent": "XPost/0.0.2"}):

     

       250
       250
       +
                   try:

     

       251
       251
       +
                       while True:

     

       252
       252
       +
                           message = await ws.recv()

     

       253
       253
       +
                           event: dict = json.loads(message)

     

       254
       254
       +
                           submit(lambda: self._on_post(outputs, str(event.get('event')), str(event.get('payload'))))

     

       255
       255
       +
                   except websockets.ConnectionClosedError as e:

     

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

     

       257
       257
       +
                       LOGGER.info("Reconnecting to %s...", self.streaming)

     

       258
       258
       +
                       continue