commit 5fa9521ffb044b788b565d9ba50a5d40af12e2c3 · zenfyr.dev/xpost

+45 -11

bluesky/input.py

···

       38
       38
        
               parent_ref = None

     

       39
       39
        
               if post.get('reply'):

     

       40
       40
        
                   parent_ref = json.dumps(post['reply']['parent'], sort_keys=True)

     

       41
       41
       +
               

     

       42
       42
       +
               embed = post.get('embed', {})

     

       43
       43
       +
               if embed.get('$type') in ('app.bsky.embed.record', 'app.bsky.embed.recordWithMedia'):

     

       44
       44
       +
                   did, collection, rid = str(embed['record']['uri'][len('at://'):]).split('/')

     

       45
       45
       +
                   if collection == 'app.bsky.feed.post':

     

       46
       46
       +
                       LOGGER.info("Skipping '%s'! Quote..", post_ref)

     

       47
       47
       +
                       return

     

       41
       48
        
                   

     

       42
       49
        
               success = database.try_insert_post(self.db, post_ref, parent_ref, self.user_id, self.service)

     

       43
       50
        
               if not success:

     
···

       55
       62
        
                   return f'{self.pds}/xrpc/com.atproto.sync.getBlob?did={self.user_id}&cid={blob}'

     

       56
       63
        
               

     

       57
       64
        
               attachments: list[MediaInfo] = []

     

       58
       58
       -
               embed = post.get('embed', {})

     

       59
       65
        
               if embed.get('$type') == 'app.bsky.embed.images':

     

       60
       66
        
                   model = get_model_or_create(embed, model=models.AppBskyEmbedImages.Main)

     

       61
       67
        
                   assert isinstance(model, models.AppBskyEmbedImages.Main)

     
···

       82
       88
        
               cross_post = BlueskyPost(post, tokens, attachments)

     

       83
       89
        
               for output in outputs:

     

       84
       90
        
                   output.accept_post(cross_post)

     

       85
       85
       -
               return

     

       86
       91
        
       

     

       87
       87
       -
           def _on_delete_post(self, outputs: list[cross.Output], post_id: dict):

     

       92
       92
       +
           def _on_delete_post(self, outputs: list[cross.Output], post_id: dict, repost: bool):

     

       88
       93
        
               identifier = json.dumps(post_id, sort_keys=True)

     

       89
       94
        
               post = database.find_post(self.db, identifier, self.user_id, self.service)

     

       90
       95
        
               if not post:

     

       91
       96
        
                   return

     

       92
       97
        
               

     

       93
       98
        
               LOGGER.info("Deleting '%s'...", identifier)

     

       94
       94
       -
               for output in outputs:

     

       95
       95
       -
                   output.delete_post(identifier)

     

       99
       99
       +
               if repost:

     

       100
       100
       +
                   for output in outputs:

     

       101
       101
       +
                       output.delete_repost(identifier)

     

       102
       102
       +
               else:

     

       103
       103
       +
                   for output in outputs:

     

       104
       104
       +
                       output.delete_post(identifier)

     

       96
       105
        
               database.delete_post(self.db, identifier, self.user_id, self.service)

     

       106
       106
       +
           

     

       107
       107
       +
           def _on_repost(self, outputs: list[cross.Output], post: dict[str, Any]):

     

       108
       108
       +
               post_ref = json.dumps(post['$xpost.strongRef'], sort_keys=True)

     

       109
       109
       +
               

     

       110
       110
       +
               reposted_ref = {

     

       111
       111
       +
                   'cid': post['subject']['cid'],

     

       112
       112
       +
                   'uri': post['subject']['uri']

     

       113
       113
       +
               }

     

       114
       114
       +
               reposted_ref = json.dumps(reposted_ref, sort_keys=True)

     

       115
       115
       +
               

     

       116
       116
       +
               success = database.try_insert_repost(self.db, post_ref, reposted_ref, self.user_id, self.service)

     

       117
       117
       +
               if not success:

     

       118
       118
       +
                   LOGGER.info("Skipping '%s' as reposted post was not found in db!", post_ref)

     

       119
       119
       +
                   return

     

       120
       120
       +
               

     

       121
       121
       +
               LOGGER.info("Crossposting '%s'...", post_ref)

     

       122
       122
       +
               for output in outputs:

     

       123
       123
       +
                   output.accept_repost(post_ref, reposted_ref)

     

       124
       124
       +
               

     

       97
       125
        
       

     

       98
       126
        
       class BlueskyPdsInput(BlueskyInput):

     

       99
       127
        
           def __init__(self, settings: dict, db: DataBaseWorker) -> None:

     
···

       127
       155
        
                       if not op.prev:

     

       128
       156
        
                           continue

     

       129
       157
        
       

     

       130
       130
       -
                       if not op.path.startswith('app.bsky.feed.post'):

     

       131
       131
       -
                           continue

     

       158
       158
       +
                       if op.path.startswith('app.bsky.feed.post'):

     

       159
       159
       +
                           self._on_delete_post(outputs, {

     

       160
       160
       +
                               'cid': op.prev.encode(),

     

       161
       161
       +
                               'uri': f'at://{parsed.repo}/{op.path}' 

     

       162
       162
       +
                           }, False)

     

       163
       163
       +
                       elif op.path.startswith('app.bsky.feed.repost'):

     

       164
       164
       +
                           self._on_delete_post(outputs, {

     

       165
       165
       +
                               'cid': op.prev.encode(),

     

       166
       166
       +
                               'uri': f'at://{parsed.repo}/{op.path}' 

     

       167
       167
       +
                           }, True)

     

       132
       168
        
                       

     

       133
       133
       -
                       self._on_delete_post(outputs, {

     

       134
       134
       -
                           'cid': op.prev.encode(),

     

       135
       135
       -
                           'uri': f'at://{parsed.repo}/{op.path}' 

     

       136
       136
       -
                       })

     

       137
       169
        
                       continue

     

       138
       170
        
                       

     

       139
       171
        
                   if op.action != 'create':

     
···

       153
       185
        
                   }

     

       154
       186
        
                   if record_dict['$type'] == 'app.bsky.feed.post':

     

       155
       187
        
                       self._on_post(outputs, record_dict)

     

       188
       188
       +
                   elif record_dict['$type'] == 'app.bsky.feed.repost':

     

       189
       189
       +
                       self._on_repost(outputs, record_dict)

     

       156
       190
        
                       

     

       157
       191
        
           

     

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

+50 -8

bluesky/output.py

···

       58
       58
        
               )

     

       59
       59
        
               self.bsky.login(did, as_envvar(settings.get('app-password')))

     

       60
       60
        
           

     

       61
       61
       -
           def _find_parent(self, parent_id: str):

     

       61
       61
       +
           def __check_login(self):

     

       62
       62
        
               login = self.bsky.me

     

       63
       63
        
               if not login:

     

       64
       64
        
                   raise Exception("Client not logged in!")

     

       65
       65
       +
               return login

     

       66
       66
       +
           

     

       67
       67
       +
           def _find_parent(self, parent_id: str):

     

       68
       68
       +
               login = self.__check_login()

     

       65
       69
        
               

     

       66
       70
        
               thread_tuple = database.find_mapped_thread(

     

       67
       71
        
                   self.db,

     
···

       147
       151
        
               return result

     

       148
       152
        
           

     

       149
       153
        
           def accept_post(self, post: cross.Post):

     

       150
       150
       -
               login = self.bsky.me

     

       151
       151
       -
               if not login:

     

       152
       152
       -
                   raise Exception("Client not logged in!")

     

       154
       154
       +
               login = self.__check_login()

     

       153
       155
        
               

     

       154
       156
        
               parent_id = post.get_parent_id()

     

       155
       157
        
               

     
···

       368
       370
        
                   database.insert_mapping(self.db, db_post['id'], new_parent_id)

     

       369
       371
        
                   

     

       370
       372
        
           def delete_post(self, identifier: str):

     

       371
       371
       -
               login = self.bsky.me

     

       372
       372
       -
               if not login:

     

       373
       373
       -
                   raise Exception("Client not logged in!")

     

       373
       373
       +
               login = self.__check_login()

     

       374
       374
        
               

     

       375
       375
        
               post = database.find_post(self.db, identifier, self.input.user_id, self.input.service)

     

       376
       376
        
               if not post:

     
···

       380
       380
        
               for mapping in mappings[::-1]:

     

       381
       381
        
                   LOGGER.info("Deleting '%s'...", mapping[0])

     

       382
       382
        
                   self.bsky.delete_post(json.loads(mapping[0])['uri'])

     

       383
       383
       -
                   database.delete_post(self.db, mapping[0], SERVICE, login.did)
     

       383
       383
       +
                   database.delete_post(self.db, mapping[0], SERVICE, login.did)

     

       384
       384
       +
           

     

       385
       385
       +
           def accept_repost(self, repost_id: str, reposted_id: str):

     

       386
       386
       +
               login, repost = self.__delete_repost(repost_id)

     

       387
       387
       +
               if not (login and repost):

     

       388
       388
       +
                   return

     

       389
       389
       +
               

     

       390
       390
       +
               reposted = database.find_post(self.db, reposted_id, self.input.user_id, self.input.service)

     

       391
       391
       +
               if not reposted:

     

       392
       392
       +
                   return

     

       393
       393
       +
               

     

       394
       394
       +
               # mappings of the reposted post

     

       395
       395
       +
               mappings = database.find_mappings(self.db, reposted['id'], SERVICE, login.did)

     

       396
       396
       +
               if mappings:

     

       397
       397
       +
                   id = json.loads(mappings[0][0])

     

       398
       398
       +
                   rsp = self.bsky.repost(id['uri'], id['cid'])

     

       399
       399
       +
                   

     

       400
       400
       +
                   internal_id = database.insert_repost(

     

       401
       401
       +
                       self.db, 

     

       402
       402
       +
                       json.dumps(rsp.model_dump(), sort_keys=True),

     

       403
       403
       +
                       reposted['id'],

     

       404
       404
       +
                       login.did,

     

       405
       405
       +
                       SERVICE)

     

       406
       406
       +
                   database.insert_mapping(self.db, repost['id'], internal_id)

     

       407
       407
       +
           

     

       408
       408
       +
           def __delete_repost(self, repost_id: str) -> tuple[models.AppBskyActorDefs.ProfileViewDetailed | None, dict | None]:

     

       409
       409
       +
               login = self.__check_login()

     

       410
       410
       +
               

     

       411
       411
       +
               repost = database.find_post(self.db, repost_id, self.input.user_id, self.input.service)

     

       412
       412
       +
               if not repost:

     

       413
       413
       +
                   return None, None

     

       414
       414
       +
               

     

       415
       415
       +
               mappings = database.find_mappings(self.db, repost['id'], SERVICE, login.did)

     

       416
       416
       +
               if mappings:

     

       417
       417
       +
                   LOGGER.info("Deleting '%s'...", mappings[0][0])

     

       418
       418
       +
                   self.bsky.unrepost(json.loads(mappings[0][0])['uri'])

     

       419
       419
       +
                   database.delete_post(self.db, mappings[0][0], login.did, SERVICE)

     

       420
       420
       +
               return login, repost

     

       421
       421
       +
           

     

       422
       422
       +
           def delete_repost(self, repost_id: str):

     

       423
       423
       +
               self.__delete_repost(repost_id)

     

       424
       424
       +
               

     

       425
       425
       +

main.py

···

       83
       83
        
               """

     

       84
       84
        
           )

     

       85
       85
        
           

     

       86
       86
       +
           columns = db_worker.execute("PRAGMA table_info(posts)")

     

       87
       87
       +
           column_names = [col[1] for col in columns]

     

       88
       88
       +
           if "reposted_id" not in column_names:

     

       89
       89
       +
               db_worker.execute("""

     

       90
       90
       +
                   ALTER TABLE posts

     

       91
       91
       +
                   ADD COLUMN reposted_id INTEGER NULL REFERENCES posts(id) ON DELETE SET NULL

     

       92
       92
       +
               """)

     

       93
       93
       +
           

     

       86
       94
        
           # create the mappings table

     

       87
       95
        
           # original_post_id - the post this was mapped from

     

       88
       96
        
           # mapped_post_id - the post this was mapped to

+36 -12

mastodon/input.py

···

       88
       88
        
               if (status.get('account') or {})['id'] != self.user_id:

     

       89
       89
        
                   return

     

       90
       90
        
               

     

       91
       91
       -
               if status.get('reblog') or (status.get('quote_id') or status.get('quote')) or status.get('poll'):

     

       92
       92
       -
                   # TODO polls not supported on bsky. maybe 3rd party? skip for now

     

       93
       93
       -
                   # we don't handle reblogs. possible with bridgy(?) and self

     

       94
       94
       -
                   # we don't handle quotes.

     

       95
       95
       -
                   LOGGER.info("Skipping '%s'! Reblog, quote or poll..", status['id'])

     

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

     

       92
       92
       +
                   # Skip f/o and direct posts

     

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

     

       94
       94
       +
                   return

     

       95
       95
       +
               

     

       96
       96
       +
               # TODO polls not supported on bsky. maybe 3rd party? skip for now

     

       97
       97
       +
               # we don't handle reblogs. possible with bridgy(?) and self

     

       98
       98
       +
               # we don't handle quotes.

     

       99
       99
       +
               if status.get('poll'):

     

       100
       100
       +
                   LOGGER.info("Skipping '%s'! Contains a poll..", status['id'])

     

       101
       101
       +
                   return

     

       102
       102
       +
               

     

       103
       103
       +
               if status.get('quote_id') or status.get('quote'):

     

       104
       104
       +
                   LOGGER.info("Skipping '%s'! Quote..", status['id'])

     

       105
       105
       +
                   return

     

       106
       106
       +
               

     

       107
       107
       +
               reblog: dict | None = status.get('reblog')

     

       108
       108
       +
               if reblog:

     

       109
       109
       +
                   if (reblog.get('account') or {})['id'] != self.user_id:

     

       110
       110
       +
                       LOGGER.info("Skipping '%s'! Reblog of other user..", status['id'])

     

       111
       111
       +
                       return

     

       112
       112
       +
                   

     

       113
       113
       +
                   success = database.try_insert_repost(self.db, status['id'], reblog['id'], self.user_id, self.service)

     

       114
       114
       +
                   if not success:

     

       115
       115
       +
                       LOGGER.info("Skipping '%s' as reblogged post was not found in db!", status['id'])

     

       116
       116
       +
                       return

     

       117
       117
       +
                   

     

       118
       118
       +
                   for output in outputs:

     

       119
       119
       +
                       output.accept_repost(status['id'], reblog['id'])

     

       96
       120
        
                   return

     

       97
       121
        
               

     

       98
       122
        
               in_reply: str | None = status.get('in_reply_to_id')

     
···

       100
       124
        
               if in_reply_to and in_reply_to != self.user_id:

     

       101
       125
        
                   # We don't support replies.

     

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

     

       103
       103
       -
                   return

     

       104
       104
       -
               

     

       105
       105
       -
               if status.get('visibility') not in self.options.allowed_visibility:

     

       106
       106
       -
                   # Skip f/o and direct posts

     

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

     

       108
       127
        
                   return

     

       109
       128
        
               

     

       110
       129
        
               success = database.try_insert_post(self.db, status['id'], in_reply, self.user_id, self.service)

     
···

       138
       157
        
                   return

     

       139
       158
        
               

     

       140
       159
        
               LOGGER.info("Deleting '%s'...", identifier)

     

       141
       141
       -
               for output in outputs:

     

       142
       142
       -
                   output.delete_post(identifier)

     

       160
       160
       +
               if post['reposted_id']:

     

       161
       161
       +
                   for output in outputs:

     

       162
       162
       +
                       output.delete_repost(identifier)

     

       163
       163
       +
               else:

     

       164
       164
       +
                   for output in outputs:

     

       165
       165
       +
                       output.delete_post(identifier)

     

       166
       166
       +
               

     

       143
       167
        
               database.delete_post(self.db, identifier, self.user_id, self.service)

     

       144
       168
        
           

     

       145
       169
        
           def _on_post(self, outputs: list[cross.Output], event: str, payload: str):

+45 -1

mastodon/output.py

···

       351
       351
        
                       'Authorization': f'Bearer {self.token}'

     

       352
       352
        
                   })

     

       353
       353
        
                   database.delete_post(self.db, mapping[0], self.service, self.user_id)

     

       354
       354
       -
               
     

       354
       354
       +
           

     

       355
       355
       +
           def accept_repost(self, repost_id: str, reposted_id: str):

     

       356
       356
       +
               repost = self.__delete_repost(repost_id)

     

       357
       357
       +
               if not repost:

     

       358
       358
       +
                   return None

     

       359
       359
       +
               

     

       360
       360
       +
               reposted = database.find_post(self.db, reposted_id, self.input.user_id, self.input.service)

     

       361
       361
       +
               if not reposted:

     

       362
       362
       +
                   return

     

       363
       363
       +
               

     

       364
       364
       +
               mappings = database.find_mappings(self.db, reposted['id'], self.service, self.user_id)

     

       365
       365
       +
               if mappings:

     

       366
       366
       +
                   rsp = requests.post(f'{self.service}/api/v1/statuses/{mappings[0][0]}/reblog', headers={

     

       367
       367
       +
                       'Authorization': f'Bearer {self.token}'

     

       368
       368
       +
                   })

     

       369
       369
       +
                   

     

       370
       370
       +
                   if rsp.status_code != 200:

     

       371
       371
       +
                       LOGGER.error("Failed to boost status! status_code: %s, msg: %s", rsp.status_code, rsp.content)

     

       372
       372
       +
                       return

     

       373
       373
       +
                   

     

       374
       374
       +
                   internal_id = database.insert_repost(

     

       375
       375
       +
                       self.db, 

     

       376
       376
       +
                       rsp.json()['id'],

     

       377
       377
       +
                       reposted['id'],

     

       378
       378
       +
                       self.user_id,

     

       379
       379
       +
                       self.service)

     

       380
       380
       +
                   database.insert_mapping(self.db, repost['id'], internal_id)

     

       381
       381
       +
           

     

       382
       382
       +
           def __delete_repost(self, repost_id: str) -> dict | None:

     

       383
       383
       +
               repost = database.find_post(self.db, repost_id, self.input.user_id, self.input.service)

     

       384
       384
       +
               if not repost:

     

       385
       385
       +
                   return None

     

       386
       386
       +
               

     

       387
       387
       +
               mappings = database.find_mappings(self.db, repost['id'], self.service, self.user_id)

     

       388
       388
       +
               reposted_mappings = database.find_mappings(self.db, repost['reposted_id'], self.service, self.user_id)

     

       389
       389
       +
               if mappings and reposted_mappings:

     

       390
       390
       +
                   LOGGER.info("Deleting '%s'...", mappings[0][0])

     

       391
       391
       +
                   requests.post(f'{self.service}/api/v1/statuses/{reposted_mappings[0][0]}/unreblog', headers={

     

       392
       392
       +
                       'Authorization': f'Bearer {self.token}'

     

       393
       393
       +
                   })

     

       394
       394
       +
                   database.delete_post(self.db, mappings[0][0], self.user_id, self.service)

     

       395
       395
       +
               return repost

     

       396
       396
       +
           

     

       397
       397
       +
           def delete_repost(self, repost_id: str):

     

       398
       398
       +
               self.__delete_repost(repost_id)

+27 -8

misskey/input.py

···

       48
       48
        
               if note['userId'] != self.user_id:

     

       49
       49
        
                   return

     

       50
       50
        
               

     

       51
       51
       -
               if note.get('renoteId') or note.get('poll'):

     

       52
       52
       -
                   # TODO polls not supported on bsky. maybe 3rd party? skip for now

     

       53
       53
       -
                   # we don't handle reblogs. possible with bridgy(?) and self

     

       54
       54
       -
                   LOGGER.info("Skipping '%s'! Renote or poll..", note['id'])

     

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

     

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

     

       53
       53
       +
                   return

     

       54
       54
       +
               

     

       55
       55
       +
               # TODO polls not supported on bsky. maybe 3rd party? skip for now

     

       56
       56
       +
               # we don't handle reblogs. possible with bridgy(?) and self

     

       57
       57
       +
               if note.get('poll'):

     

       58
       58
       +
                   LOGGER.info("Skipping '%s'! Contains a poll..", note['id'])

     

       59
       59
       +
                   return

     

       60
       60
       +
               

     

       61
       61
       +
               renote: dict | None = note.get('renote')

     

       62
       62
       +
               if renote:

     

       63
       63
       +
                   if note.get('text') is not None:

     

       64
       64
       +
                       LOGGER.info("Skipping '%s'! Quote..", note['id'])

     

       65
       65
       +
                       return

     

       66
       66
       +
                   

     

       67
       67
       +
                   if renote.get('userId') != self.user_id:

     

       68
       68
       +
                       LOGGER.info("Skipping '%s'! Reblog of other user..", note['id'])

     

       69
       69
       +
                       return

     

       70
       70
       +
                   

     

       71
       71
       +
                   success = database.try_insert_repost(self.db, note['id'], renote['id'], self.user_id, self.service)

     

       72
       72
       +
                   if not success:

     

       73
       73
       +
                       LOGGER.info("Skipping '%s' as renoted note was not found in db!", note['id'])

     

       74
       74
       +
                       return

     

       75
       75
       +
                   

     

       76
       76
       +
                   for output in outputs:

     

       77
       77
       +
                       output.accept_repost(note['id'], renote['id'])

     

       55
       78
        
                   return

     

       56
       79
        
               

     

       57
       80
        
               reply_id: str | None = note.get('replyId')

     
···

       59
       82
        
                   if note.get('reply', {}).get('userId') != self.user_id:

     

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

     

       61
       84
        
                       return

     

       62
       62
       -
               

     

       63
       63
       -
               if note.get('visibility') not in self.options.allowed_visibility:

     

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

     

       65
       65
       -
                   return

     

       66
       85
        
               

     

       67
       86
        
               success = database.try_insert_post(self.db, note['id'], reply_id, self.user_id, self.service)

     

       68
       87
        
               if not success:

+66 -43

util/database.py

···

       45
       45
        
               with self.lock:

     

       46
       46
        
                   self.conn.close()

     

       47
       47
        
       

     

       48
       48
       +
       def try_insert_repost(

     

       49
       49
       +
           db: DataBaseWorker,

     

       50
       50
       +
           post_id: str,

     

       51
       51
       +
           reposted_id: str,

     

       52
       52
       +
           input_user: str,

     

       53
       53
       +
           input_service: str) -> bool:

     

       54
       54
       +
           

     

       55
       55
       +
           reposted = find_post(db, reposted_id, input_user, input_service)

     

       56
       56
       +
           if not reposted:

     

       57
       57
       +
               return False

     

       58
       58
       +
           

     

       59
       59
       +
           insert_repost(db, post_id, reposted['id'], input_user, input_service)

     

       60
       60
       +
           return True

     

       61
       61
       +
           

     

       62
       62
       +
       

     

       48
       63
        
       def try_insert_post(

     

       49
       64
        
           db: DataBaseWorker, 

     

       50
       65
        
           post_id: str,

     
···

       70
       85
        
               insert_post(db, post_id, input_user, input_service)

     

       71
       86
        
           

     

       72
       87
        
           return True

     

       73
       73
       -
           

     

       74
       88
        
       

     

       75
       75
       -
       def find_mapped_thread(

     

       76
       76
       -
           db: DataBaseWorker, 

     

       77
       77
       -
           parent_id: str,

     

       78
       78
       -
           input_user: str,

     

       79
       79
       -
           input_service: str,

     

       80
       80
       -
           output_user: str,

     

       81
       81
       -
           output_service: str):

     

       82
       82
       -
               

     

       83
       83
       -
           reply_data: dict | None = find_post(db, parent_id, input_user, input_service)

     

       84
       84
       -
           if not reply_data:

     

       85
       85
       -
               return None

     

       86
       86
       -
                   

     

       87
       87
       -
           reply_mappings: list[str] | None = find_mappings(db, reply_data['id'], output_service, output_user)

     

       88
       88
       -
           if not reply_mappings:

     

       89
       89
       -
               return None

     

       90
       90
       -
                   

     

       91
       91
       -
           reply_identifier: str = reply_mappings[-1]

     

       92
       92
       -
           root_identifier: str = reply_mappings[0]

     

       93
       93
       -
           if reply_data['root_id']:

     

       94
       94
       -
               root_data = find_post_by_id(db, reply_data['root_id'])

     

       95
       95
       -
               if not root_data:

     

       96
       96
       -
                   return None

     

       97
       97
       -
                       

     

       98
       98
       -
               root_mappings = find_mappings(db, reply_data['root_id'], output_service, output_user)

     

       99
       99
       -
               if not root_mappings:

     

       100
       100
       -
                   return None

     

       101
       101
       -
               root_identifier = root_mappings[0]

     

       102
       102
       -
           

     

       103
       103
       -
           return (

     

       104
       104
       -
               root_identifier[0], # real ids

     

       105
       105
       -
               reply_identifier[0],

     

       106
       106
       -
               reply_data['root_id'], # db ids

     

       107
       107
       -
               reply_data['id']

     

       108
       108
       -
           )

     

       109
       109
       -
           

     

       89
       89
       +
       def insert_repost(db: DataBaseWorker, identifier: str, reposted_id: int, user_id: str, serivce: str) -> int:

     

       90
       90
       +
           db.execute(

     

       91
       91
       +
               """

     

       92
       92
       +
               INSERT INTO posts (user_id, service, identifier, reposted_id)

     

       93
       93
       +
               VALUES (?, ?, ?, ?);

     

       94
       94
       +
               """, (user_id, serivce, identifier, reposted_id))

     

       95
       95
       +
           return db.execute("SELECT last_insert_rowid();", ())[0][0]

     

       110
       96
        
       

     

       111
       97
        
       def insert_post(db: DataBaseWorker, identifier: str, user_id: str, serivce: str) -> int:

     

       112
       98
        
           db.execute(

     
···

       157
       143
        
       def find_post_by_id(db: DataBaseWorker, id: int) -> dict | None:

     

       158
       144
        
           result = db.execute(

     

       159
       145
        
               """

     

       160
       160
       -
               SELECT user_id, service, identifier, parent_id, root_id

     

       146
       146
       +
               SELECT user_id, service, identifier, parent_id, root_id, reposted_id

     

       161
       147
        
               FROM posts 

     

       162
       148
        
               WHERE id = ?

     

       163
       149
        
               """, (id,))

     

       164
       150
        
           if not result:

     

       165
       151
        
               return None

     

       166
       166
       -
           user_id, service, identifier, parent_id, root_id = result[0]

     

       152
       152
       +
           user_id, service, identifier, parent_id, root_id, reposted_id = result[0]

     

       167
       153
        
           return {

     

       168
       154
        
               'user_id': user_id,

     

       169
       155
        
               'service': service,

     

       170
       156
        
               'identifier': identifier,

     

       171
       157
        
               'parent_id': parent_id,

     

       172
       172
       -
               'root_id': root_id

     

       158
       158
       +
               'root_id': root_id,

     

       159
       159
       +
               'reposted_id': reposted_id

     

       173
       160
        
           }

     

       174
       161
        
       

     

       175
       162
        
       def find_post(db: DataBaseWorker, identifier: str, user_id: str, service: str) -> dict | None:

     

       176
       163
        
           result = db.execute(

     

       177
       164
        
               """

     

       178
       178
       -
               SELECT id, parent_id, root_id

     

       165
       165
       +
               SELECT id, parent_id, root_id, reposted_id

     

       179
       166
        
               FROM posts 

     

       180
       167
        
               WHERE identifier = ? 

     

       181
       168
        
                 AND user_id = ? 

     
···

       183
       170
        
               """, (identifier, user_id, service))

     

       184
       171
        
           if not result:

     

       185
       172
        
               return None

     

       186
       186
       -
           id, parent_id, root_id = result[0]

     

       173
       173
       +
           id, parent_id, root_id, reposted_id = result[0]

     

       187
       174
        
           return {

     

       188
       175
        
               'id': id,

     

       189
       176
        
               'parent_id': parent_id,

     

       190
       190
       -
               'root_id': root_id

     

       191
       191
       -
           }
     

       177
       177
       +
               'root_id': root_id,

     

       178
       178
       +
               'reposted_id': reposted_id

     

       179
       179
       +
           }

     

       180
       180
       +
       

     

       181
       181
       +
       def find_mapped_thread(

     

       182
       182
       +
           db: DataBaseWorker, 

     

       183
       183
       +
           parent_id: str,

     

       184
       184
       +
           input_user: str,

     

       185
       185
       +
           input_service: str,

     

       186
       186
       +
           output_user: str,

     

       187
       187
       +
           output_service: str):

     

       188
       188
       +
               

     

       189
       189
       +
           reply_data: dict | None = find_post(db, parent_id, input_user, input_service)

     

       190
       190
       +
           if not reply_data:

     

       191
       191
       +
               return None

     

       192
       192
       +
                   

     

       193
       193
       +
           reply_mappings: list[str] | None = find_mappings(db, reply_data['id'], output_service, output_user)

     

       194
       194
       +
           if not reply_mappings:

     

       195
       195
       +
               return None

     

       196
       196
       +
                   

     

       197
       197
       +
           reply_identifier: str = reply_mappings[-1]

     

       198
       198
       +
           root_identifier: str = reply_mappings[0]

     

       199
       199
       +
           if reply_data['root_id']:

     

       200
       200
       +
               root_data = find_post_by_id(db, reply_data['root_id'])

     

       201
       201
       +
               if not root_data:

     

       202
       202
       +
                   return None

     

       203
       203
       +
                       

     

       204
       204
       +
               root_mappings = find_mappings(db, reply_data['root_id'], output_service, output_user)

     

       205
       205
       +
               if not root_mappings:

     

       206
       206
       +
                   return None

     

       207
       207
       +
               root_identifier = root_mappings[0]

     

       208
       208
       +
           

     

       209
       209
       +
           return (

     

       210
       210
       +
               root_identifier[0], # real ids

     

       211
       211
       +
               reply_identifier[0],

     

       212
       212
       +
               reply_data['root_id'], # db ids

     

       213
       213
       +
               reply_data['id']

     

       214
       214
       +
           )