commit f8af20657e40fca52bd4da38886694e03aa217bb · zenfyr.dev/xpost

README.md

···

       136
       136
        
           "did": "env:BLUESKY_DID", // use a DID instead of handle (avoids handle resolution)

     

       137
       137
        
           "pds": "env:BLUESKY_PDS", // specify Your PDS directly (avoids DID doc lookup)

     

       138
       138
        
           "options": {

     

       139
       139
       +
               "encode_videos": true, // bluesky only accepts mp4 videos, try to convert if the video is not mp4

     

       139
       140
        
               "quote_gate": false, // block users from quoting the post

     

       140
       141
        
               "thread_gate": [ // block replies. leave empty to disable replies

     

       141
       142
        
                 "mentioned",

+2 -3

atproto2.py

···

       148
       148
        
               )

     

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

     

       150
       150
        
           

     

       151
       151
       -
           def create_gates(self, options: dict, post_uri: str, time_iso: str | None = None):

     

       151
       151
       +
           def create_gates(self, thread_gate_opts: list[str], quote_gate: bool, post_uri: str, time_iso: str | None = None):

     

       152
       152
        
               account = self.me

     

       153
       153
        
               if not account:

     

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

     
···

       156
       156
        
               rkey = AtUri.from_str(post_uri).rkey

     

       157
       157
        
               time_iso = time_iso or self.get_current_time_iso()

     

       158
       158
        
               

     

       159
       159
       -
               thread_gate_opts = options.get('thread_gate', [])

     

       160
       159
        
               if 'everybody' not in thread_gate_opts:

     

       161
       160
        
                   allow = []

     

       162
       161
        
                   if thread_gate_opts:

     
···

       175
       174
        
                   

     

       176
       175
        
                   self.app.bsky.feed.threadgate.create(account.did, thread_gate, rkey)

     

       177
       176
        
                   

     

       178
       178
       -
               if options.get('quote_gate', False):

     

       177
       177
       +
               if quote_gate:

     

       179
       178
        
                   post_gate = models.AppBskyFeedPostgate.Record(

     

       180
       179
        
                       post=post_uri,

     

       181
       180
        
                       created_at=time_iso,

+32 -8

bluesky.py

···

       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']

     

       300
       300
       +
               self.quote_gate: bool = False

     

       301
       301
       +
               self.thread_gate: list[str] = ['everybody']

     

       302
       302
       +
               self.encode_videos: bool = True

     

       302
       303
        
               

     

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

     

       304
       305
        
               if quote_gate is not None:

     
···

       306
       307
        
               

     

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

     

       308
       309
        
               if thread_gate is not None:

     

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

     

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

     

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

     

       311
       312
        
                   self.thread_gate = thread_gate

     

       313
       313
       +
               

     

       314
       314
       +
               encode_videos = o.get('encode_videos')

     

       315
       315
       +
               if encode_videos is not None:

     

       316
       316
       +
                   self.encode_videos = bool(encode_videos)

     

       312
       317
        
       

     

       313
       318
        
       class BlueskyOutput(cross.Output):

     

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

     

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

     

       316
       316
       -
               self.options = settings.get('options') or {}

     

       321
       321
       +
               self.options = BlueskyOutputOptions(settings.get('options') or {})

     

       317
       322
        
               

     

       318
       323
        
               if not util.as_envvar(settings.get('app-password')):

     

       319
       324
        
                   raise Exception("Account app password not provided!")

     
···

       490
       495
        
                           return

     

       491
       496
        
                   

     

       492
       497
        
                   if m.mime.startswith('video/'):

     

       498
       498
       +
                       if m.mime != 'video/mp4' and not self.options.encode_videos:

     

       499
       499
       +
                           LOGGER.info("Video is not mp4, but encoding is disabled. Skipping '%s'...", post.get_id())

     

       500
       500
       +
                           return

     

       501
       501
       +
                       

     

       493
       502
        
                       if len(m.io) > 100_000_000:

     

       494
       503
        
                           LOGGER.error("Skipping post_id '%s', failed to download attachment! File too large?", post.get_id())

     

       495
       504
        
                           return

     
···

       508
       517
        
                           new_post = self.bsky.send_post(text, labels=labels, time_iso=post.get_post_date_iso())

     

       509
       518
        
                           root_ref = models.create_strong_ref(new_post)

     

       510
       519
        
                       

     

       511
       511
       -
                       self.bsky.create_gates(self.options, new_post.uri, time_iso=post.get_post_date_iso())

     

       520
       520
       +
                       self.bsky.create_gates(

     

       521
       521
       +
                           self.options.thread_gate, 

     

       522
       522
       +
                           self.options.quote_gate, 

     

       523
       523
       +
                           new_post.uri, 

     

       524
       524
       +
                           time_iso=post.get_post_date_iso()

     

       525
       525
       +
                       )

     

       512
       526
        
                       reply_ref = models.create_strong_ref(new_post)

     

       513
       527
        
                       created_records.append(new_post)

     

       514
       528
        
                   else:

     
···

       548
       562
        
                           if not root_ref:

     

       549
       563
        
                               root_ref = models.create_strong_ref(new_post)

     

       550
       564
        
                           

     

       551
       551
       -
                           self.bsky.create_gates(self.options, new_post.uri, time_iso=post.get_post_date_iso())

     

       565
       565
       +
                           self.bsky.create_gates(

     

       566
       566
       +
                               self.options.thread_gate, 

     

       567
       567
       +
                               self.options.quote_gate,

     

       568
       568
       +
                               new_post.uri, 

     

       569
       569
       +
                               time_iso=post.get_post_date_iso()

     

       570
       570
       +
                           )

     

       552
       571
        
                           reply_ref = models.create_strong_ref(new_post)

     

       553
       572
        
                           created_records.append(new_post)

     

       554
       573
        
                       else: # video is guarantedd to be one

     
···

       559
       578
        
                       

     

       560
       579
        
                           video_io = attachments[0].io

     

       561
       580
        
                           if attachments[0].mime != 'video/mp4':

     

       562
       562
       -
                               LOGGER.error("Converting %s to mp4...", attachments[0].name)

     

       581
       581
       +
                               LOGGER.info("Converting %s to mp4...", attachments[0].name)

     

       563
       582
        
                               video_io = media_util.convert_to_mp4(video_io)

     

       564
       583
        
                               

     

       565
       584
        
                           aspect_ratio = models.AppBskyEmbedDefs.AspectRatio(

     
···

       582
       601
        
                           if not root_ref:

     

       583
       602
        
                               root_ref = models.create_strong_ref(new_post)

     

       584
       603
        
                           

     

       585
       585
       -
                           self.bsky.create_gates(self.options, new_post.uri, time_iso=post.get_post_date_iso())

     

       604
       604
       +
                           self.bsky.create_gates(

     

       605
       605
       +
                               self.options.thread_gate,

     

       606
       606
       +
                               self.options.quote_gate, 

     

       607
       607
       +
                               new_post.uri, 

     

       608
       608
       +
                               time_iso=post.get_post_date_iso()

     

       609
       609
       +
                           )

     

       586
       610
        
                           reply_ref = models.create_strong_ref(new_post)

     

       587
       611
        
                           created_records.append(new_post)

     

       588
       612