···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
MIT License

     

       
2
       
+
       


     

       
3
       
+
       
Copyright (c) 2025

     

       
4
       
+
       


     

       
5
       
+
       
Permission is hereby granted, free of charge, to any person obtaining a copy

     

       
6
       
+
       
of this software and associated documentation files (the "Software"), to deal

     

       
7
       
+
       
in the Software without restriction, including without limitation the rights

     

       
8
       
+
       
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

     

       
9
       
+
       
copies of the Software, and to permit persons to whom the Software is

     

       
10
       
+
       
furnished to do so, subject to the following conditions:

     

       
11
       
+
       


     

       
12
       
+
       
The above copyright notice and this permission notice shall be included in all

     

       
13
       
+
       
copies or substantial portions of the Software.

     

       
14
       
+
       


     

       
15
       
+
       
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

     

       
16
       
+
       
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

     

       
17
       
+
       
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

     

       
18
       
+
       
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

     

       
19
       
+
       
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

     

       
20
       
+
       
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

     

       
21
       
+
       
SOFTWARE.
     

···

       
1
       
 
       
from util import LOGGER

     

       
2
       
 
       
import requests, websockets

     

       
3
       
-
       
import util, media_util, json

     

       
4
       
-
       
import cross

     

       
5
       
 
       
import database

     

       
6
       
 
       
from database import DataBaseWorker

     

       
7
       
 
       
from typing import Callable, Any

     

       
0
       
 
       

     

       
8
       
 
       


     

       
9
       
 
       
from bs4 import BeautifulSoup, Tag

     

       
10
       
 
       
from bs4.element import NavigableString

     
···

       
245
       
 
       
        if event == 'update':

     

       
246
       
 
       
            self._on_create_post(outputs, json.loads(payload))

     

       
247
       
 
       
        elif event == 'delete':

     

       
248
       
-
       
            self._on_delete_post(outputs, payload)

     

       
249
       
-
       
                

     

       
250
       
 
       
    

     

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

     

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

     
···

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

     

       
255
       
 
       
            try:

     

       
256
       
 
       
                LOGGER.info("Listening to %s...", self.streaming)

     

       
257
       
-
       
                while True:

     

       
258
       
-
       
                    message = await ws.recv()

     

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

     

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

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
261
       
 
       
            except websockets.ConnectionClosedError as e:

     

       
262
       
 
       
                LOGGER.error(e, stack_info=True, exc_info=True)

     

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

     

···

       
1
       
 
       
from util import LOGGER

     

       
2
       
 
       
import requests, websockets

     

       
3
       
+
       
import util, media_util, json, cross

     

       
0
       
 
       

     

       
4
       
 
       
import database

     

       
5
       
 
       
from database import DataBaseWorker

     

       
6
       
 
       
from typing import Callable, Any

     

       
7
       
+
       
import asyncio

     

       
8
       
 
       


     

       
9
       
 
       
from bs4 import BeautifulSoup, Tag

     

       
10
       
 
       
from bs4.element import NavigableString

     
···

       
245
       
 
       
        if event == 'update':

     

       
246
       
 
       
            self._on_create_post(outputs, json.loads(payload))

     

       
247
       
 
       
        elif event == 'delete':

     

       
248
       
+
       
            self._on_delete_post(outputs, payload)          

     

       
0
       
 
       

     

       
249
       
 
       
    

     

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

     

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

     
···

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

     

       
254
       
 
       
            try:

     

       
255
       
 
       
                LOGGER.info("Listening to %s...", self.streaming)

     

       
256
       
+
       
                

     

       
257
       
+
       
                async def listen_for_messages():

     

       
258
       
+
       
                    async for msg in ws:

     

       
259
       
+
       
                        data = json.loads(msg)

     

       
260
       
+
       
                        event: str = data.get('event')

     

       
261
       
+
       
                        payload: str = data.get('payload')

     

       
262
       
+
       
            

     

       
263
       
+
       
                        submit(lambda: self._on_post(outputs, str(event), str(payload)))

     

       
264
       
+
       
            

     

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

     

       
266
       
+
       
                

     

       
267
       
+
       
                await asyncio.gather(listen)

     

       
268
       
 
       
            except websockets.ConnectionClosedError as e:

     

       
269
       
 
       
                LOGGER.error(e, stack_info=True, exc_info=True)

     

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

     

···

       
237
       
 
       
            output.accept_post(cross_post)

     

       
238
       
 
       
    

     

       
239
       
 
       
    def _on_delete(self, outputs: list[cross.Output], note: dict):

     

       
0
       
 
       

     

       
240
       
 
       
        pass

     

       
241
       
 
       
    

     

       
242
       
 
       
    def _on_message(self, outputs: list[cross.Output], data: dict):

     
···

       
264
       
 
       
                LOGGER.error(f"Error sending keepalive: {e}")

     

       
265
       
 
       
                break

     

       
266
       
 
       
    

     

       
267
       
-
       
    async def _listen_for_messages(

     

       
268
       
-
       
        self, 

     

       
269
       
-
       
        ws: websockets.WebSocketClientProtocol, 

     

       
270
       
-
       
        submit: Callable[[Callable[[], Any]], Any], 

     

       
271
       
-
       
        outputs: list[cross.Output]):

     

       
272
       
-
       
        

     

       
273
       
-
       
        async for msg in ws:

     

       
274
       
-
       
            data = json.loads(msg)

     

       
275
       
-
       
            

     

       
276
       
-
       
            # TODO listen to deletes somehow

     

       
277
       
-
       
            if False and data['type'] == 'channel':

     

       
278
       
-
       
                payload_type = data['body']['type']

     

       
279
       
-
       
                if payload_type == 'reply' or payload_type == 'note':

     

       
280
       
-
       
                    user_id = data['body']['body']['userId']

     

       
281
       
-
       
                    if self.user_id == user_id:

     

       
282
       
-
       
                        note_id = data['body']['body']['id']

     

       
283
       
-
       
                        await ws.send(json.dumps({

     

       
284
       
-
       
                            'type': 's',

     

       
285
       
-
       
                            'body': {

     

       
286
       
-
       
                                'id': note_id

     

       
287
       
-
       
                            }

     

       
288
       
-
       
                        }))

     

       
289
       
-
       
                        LOGGER.info('Subscribed to note %s updates.', note_id)

     

       
290
       
-
       
            

     

       
291
       
-
       
            submit(lambda: self._on_message(outputs, data))

     

       
292
       
-
       
    

     

       
293
       
 
       
    async def _subscribe_to_home(self, ws: websockets.WebSocketClientProtocol):

     

       
294
       
-
       
        home_message = json.dumps({

     

       
295
       
 
       
            "type": "connect",

     

       
296
       
 
       
            "body": {

     

       
297
       
 
       
                "channel": "homeTimeline",

     

       
298
       
 
       
                "id": str(uuid.uuid4())

     

       
299
       
 
       
            }

     

       
300
       
-
       
        })

     

       
301
       
-
       
        await ws.send(home_message)

     

       
302
       
 
       
        LOGGER.info("Subscribed to 'homeTimeline' channel...")

     

       
303
       
 
       
        

     

       
304
       
 
       
    

     
···

       
311
       
 
       
                LOGGER.info("Listening to %s...", streaming)

     

       
312
       
 
       
                await self._subscribe_to_home(ws)

     

       
313
       
 
       
                

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
314
       
 
       
                keepalive = asyncio.create_task(self._send_keepalive(ws))

     

       
315
       
-
       
                listen = asyncio.create_task(self._listen_for_messages(ws, submit, outputs))

     

       
316
       
 
       
                

     

       
317
       
 
       
                await asyncio.gather(keepalive, listen)

     

       
318
       
 
       
            except websockets.ConnectionClosedError as e:

     

···

       
237
       
 
       
            output.accept_post(cross_post)

     

       
238
       
 
       
    

     

       
239
       
 
       
    def _on_delete(self, outputs: list[cross.Output], note: dict):

     

       
240
       
+
       
        # TODO handle deletes

     

       
241
       
 
       
        pass

     

       
242
       
 
       
    

     

       
243
       
 
       
    def _on_message(self, outputs: list[cross.Output], data: dict):

     
···

       
265
       
 
       
                LOGGER.error(f"Error sending keepalive: {e}")

     

       
266
       
 
       
                break

     

       
267
       
 
       
    

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
268
       
 
       
    async def _subscribe_to_home(self, ws: websockets.WebSocketClientProtocol):

     

       
269
       
+
       
        await ws.send(json.dumps({

     

       
270
       
 
       
            "type": "connect",

     

       
271
       
 
       
            "body": {

     

       
272
       
 
       
                "channel": "homeTimeline",

     

       
273
       
 
       
                "id": str(uuid.uuid4())

     

       
274
       
 
       
            }

     

       
275
       
+
       
        }))

     

       
0
       
 
       

     

       
276
       
 
       
        LOGGER.info("Subscribed to 'homeTimeline' channel...")

     

       
277
       
 
       
        

     

       
278
       
 
       
    

     
···

       
285
       
 
       
                LOGGER.info("Listening to %s...", streaming)

     

       
286
       
 
       
                await self._subscribe_to_home(ws)

     

       
287
       
 
       
                

     

       
288
       
+
       
                async def listen_for_messages():

     

       
289
       
+
       
                    async for msg in ws:

     

       
290
       
+
       
                        # TODO listen to deletes somehow

     

       
291
       
+
       
                        submit(lambda: self._on_message(outputs, json.loads(msg)))

     

       
292
       
+
       
                

     

       
293
       
 
       
                keepalive = asyncio.create_task(self._send_keepalive(ws))

     

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

     

       
295
       
 
       
                

     

       
296
       
 
       
                await asyncio.gather(keepalive, listen)

     

       
297
       
 
       
            except websockets.ConnectionClosedError as e: