commit afce401dbb69fb99dd3e4b1418133ee04bcc1353 · zenfyr.dev/xpost

+15 -10

atproto2.py

···

       15
       15
        
               reply_to: models.AppBskyFeedPost.ReplyRef | None = None,

     

       16
       16
        
               langs: list[str] | None = None,

     

       17
       17
        
               facets: list[models.AppBskyRichtextFacet.Main] | None = None,

     

       18
       18
       -
               labels: models.ComAtprotoLabelDefs.SelfLabels | None = None

     

       18
       18
       +
               labels: models.ComAtprotoLabelDefs.SelfLabels | None = None,

     

       19
       19
       +
               time_iso: str | None = None

     

       19
       20
        
               ) -> models.AppBskyFeedPost.CreateRecordResponse:

     

       20
       21
        
               """same as send_video, but with labels"""

     

       21
       22
        
               

     
···

       30
       31
        
                   embed=models.AppBskyEmbedVideo.Main(video=upload.blob, alt=video_alt, aspect_ratio=video_aspect_ratio),

     

       31
       32
        
                   langs=langs,

     

       32
       33
        
                   facets=facets,

     

       33
       33
       -
                   labels=labels

     

       34
       34
       +
                   labels=labels,

     

       35
       35
       +
                   time_iso=time_iso

     

       34
       36
        
               )

     

       35
       37
        
           

     

       36
       38
        
           def send_images(

     
···

       42
       44
        
               reply_to: models.AppBskyFeedPost.ReplyRef | None = None,

     

       43
       45
        
               langs: list[str] | None = None,

     

       44
       46
        
               facets: list[models.AppBskyRichtextFacet.Main] | None = None,

     

       45
       45
       -
               labels: models.ComAtprotoLabelDefs.SelfLabels | None = None

     

       47
       47
       +
               labels: models.ComAtprotoLabelDefs.SelfLabels | None = None,

     

       48
       48
       +
               time_iso: str | None = None

     

       46
       49
        
               ) -> models.AppBskyFeedPost.CreateRecordResponse:

     

       47
       50
        
               """same as send_images, but with labels"""

     

       48
       51
        
               

     
···

       71
       74
        
                   embed=models.AppBskyEmbedImages.Main(images=embed_images),

     

       72
       75
        
                   langs=langs,

     

       73
       76
        
                   facets=facets,

     

       74
       74
       -
                   labels=labels

     

       77
       77
       +
                   labels=labels,

     

       78
       78
       +
                   time_iso=time_iso

     

       75
       79
        
               )

     

       76
       80
        
           

     

       77
       81
        
           def send_post(

     
···

       87
       91
        
                   models.AppBskyEmbedVideo.Main = None,

     

       88
       92
        
               langs: list[str] | None = None,

     

       89
       93
        
               facets: list[models.AppBskyRichtextFacet.Main] | None = None,

     

       90
       90
       -
               labels: models.ComAtprotoLabelDefs.SelfLabels | None = None

     

       94
       94
       +
               labels: models.ComAtprotoLabelDefs.SelfLabels | None = None,

     

       95
       95
       +
               time_iso: str | None = None

     

       91
       96
        
               ) -> models.AppBskyFeedPost.CreateRecordResponse:

     

       92
       97
        
               """same as send_post, but with labels"""

     

       93
       98
        
               

     
···

       103
       108
        
                   langs = ['en']

     

       104
       109
        
                   

     

       105
       110
        
               record = models.AppBskyFeedPost.Record(

     

       106
       106
       -
                   created_at=self.get_current_time_iso(),

     

       111
       111
       +
                   created_at=time_iso or self.get_current_time_iso(),

     

       107
       112
        
                   text=text,

     

       108
       113
        
                   reply=reply_to or None,

     

       109
       114
        
                   embed=embed or None,

     
···

       113
       118
        
               )

     

       114
       119
        
               return self.app.bsky.feed.post.create(repo, record)

     

       115
       120
        
           

     

       116
       116
       -
           def create_gates(self, options: dict, post_uri: str):

     

       121
       121
       +
           def create_gates(self, options: dict, post_uri: str, time_iso: str | None = None):

     

       117
       122
        
               account = self.me

     

       118
       123
        
               if not account:

     

       119
       124
        
                   raise Exception("Client not logged in!")

     

       120
       125
        
               

     

       121
       126
        
               rkey = AtUri.from_str(post_uri).rkey

     

       122
       122
       -
               time = self.get_current_time_iso()

     

       127
       127
       +
               time_iso = time_iso or self.get_current_time_iso()

     

       123
       128
        
               

     

       124
       129
        
               thread_gate_opts = options.get('thread_gate', [])

     

       125
       130
        
               if 'everybody' not in thread_gate_opts:

     
···

       134
       139
        
                   

     

       135
       140
        
                   thread_gate = models.AppBskyFeedThreadgate.Record(

     

       136
       141
        
                       post=post_uri,

     

       137
       137
       -
                       created_at=time,

     

       142
       142
       +
                       created_at=time_iso,

     

       138
       143
        
                       allow=allow

     

       139
       144
        
                   )

     

       140
       145
        
                   

     
···

       143
       148
        
               if options.get('quote_gate', False):

     

       144
       149
        
                   post_gate = models.AppBskyFeedPostgate.Record(

     

       145
       150
        
                       post=post_uri,

     

       146
       146
       -
                       created_at=time,

     

       151
       151
       +
                       created_at=time_iso,

     

       147
       152
        
                       embedding_rules=[

     

       148
       153
        
                           models.AppBskyFeedPostgate.DisableRule()

     

       149
       154
        
                       ]

+9 -7

bluesky.py

···

       236
       236
        
                           new_post = self.bsky.send_post(text, reply_to=models.AppBskyFeedPost.ReplyRef(

     

       237
       237
        
                               parent=reply_ref,

     

       238
       238
        
                               root=root_ref

     

       239
       239
       -
                           ), labels=labels)

     

       239
       239
       +
                           ), labels=labels, time_iso=post.get_post_date_iso())

     

       240
       240
        
                       else:

     

       241
       241
       -
                           new_post = self.bsky.send_post(text, labels=labels)

     

       241
       241
       +
                           new_post = self.bsky.send_post(text, labels=labels, time_iso=post.get_post_date_iso())

     

       242
       242
        
                           root_ref = models.create_strong_ref(new_post)

     

       243
       243
        
                       

     

       244
       244
       -
                       self.bsky.create_gates(self.options, new_post.uri)

     

       244
       244
       +
                       self.bsky.create_gates(self.options, new_post.uri, time_iso=post.get_post_date_iso())

     

       245
       245
        
                       reply_ref = models.create_strong_ref(new_post)

     

       246
       246
        
                       created_records.append(new_post)

     

       247
       247
        
                   else:

     
···

       275
       275
        
                                   parent=reply_ref,

     

       276
       276
        
                                   root=root_ref

     

       277
       277
        
                               ) if root_ref and reply_ref else None, 

     

       278
       278
       -
                               labels=labels

     

       278
       278
       +
                               labels=labels, 

     

       279
       279
       +
                               time_iso=post.get_post_date_iso()

     

       279
       280
        
                           )

     

       280
       281
        
                           if not root_ref:

     

       281
       282
        
                               root_ref = models.create_strong_ref(new_post)

     

       282
       283
        
                           

     

       283
       283
       -
                           self.bsky.create_gates(self.options, new_post.uri)

     

       284
       284
       +
                           self.bsky.create_gates(self.options, new_post.uri, time_iso=post.get_post_date_iso())

     

       284
       285
        
                           reply_ref = models.create_strong_ref(new_post)

     

       285
       286
        
                           created_records.append(new_post)

     

       286
       287
        
                       else: # video is guarantedd to be one

     
···

       313
       314
        
                                   parent=reply_ref,

     

       314
       315
        
                                   root=root_ref

     

       315
       316
        
                               ) if root_ref and reply_ref else None,

     

       316
       316
       -
                               labels=labels

     

       317
       317
       +
                               labels=labels,

     

       318
       318
       +
                               time_iso=post.get_post_date_iso()

     

       317
       319
        
                           )

     

       318
       320
        
                           if not root_ref:

     

       319
       321
        
                               root_ref = models.create_strong_ref(new_post)

     

       320
       322
        
                           

     

       321
       321
       -
                           self.bsky.create_gates(self.options, new_post.uri)

     

       323
       323
       +
                           self.bsky.create_gates(self.options, new_post.uri, time_iso=post.get_post_date_iso())

     

       322
       324
        
                           reply_ref = models.create_strong_ref(new_post)

     

       323
       325
        
                           created_records.append(new_post)

     

       324
       326

cross.py

···

       1
       1
        
       from typing import Callable, Any

     

       2
       2
        
       from database import DataBaseWorker

     

       3
       3
       +
       from datetime import datetime, timezone

     

       3
       4
        
       

     

       4
       5
        
       # generic token

     

       5
       6
        
       class Token():

     
···

       72
       73
        
           

     

       73
       74
        
           def get_parent_id(self) -> str | None:

     

       74
       75
        
               return None

     

       76
       76
       +
           

     

       77
       77
       +
           def get_post_date_iso(self) -> str:

     

       78
       78
       +
               return datetime.now(timezone.utc).isoformat()

     

       75
       79
        
           

     

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

     

       77
       81
        
               return []

mastodon.py

···

       95
       95
        
           def get_parent_id(self) -> str | None:

     

       96
       96
        
               return self.status.get('in_reply_to_id')

     

       97
       97
        
           

     

       98
       98
       +
           def get_post_date_iso(self) -> str:

     

       99
       99
       +
               date = self.status.get('created_at')

     

       100
       100
       +
               return date or super().get_post_date_iso()

     

       101
       101
       +
           

     

       98
       102
        
           def get_cw(self) -> str:

     

       99
       103
        
               return self.status.get('spoiler_text') or ''

     

       100
       104

misskey.py

···

       125
       125
        
           def get_parent_id(self) -> str | None:

     

       126
       126
        
               return self.note.get('replyId')

     

       127
       127
        
           

     

       128
       128
       +
           def get_post_date_iso(self) -> str:

     

       129
       129
       +
               date = self.note.get('createdAt')

     

       130
       130
       +
               return date or super().get_post_date_iso()

     

       131
       131
       +
           

     

       128
       132
        
           def get_attachments(self) -> list[cross.MediaAttachment]:

     

       129
       133
        
               return self.media_attachments

     

       130
       134