commit c8f69581bf5f7359778548521f340ac1bfd55d0f · zenfyr.dev/xpost

+152

atproto2.py

···

       1
       1
       +
       from typing import Any

     

       2
       2
       +
       from atproto import client_utils, Client, AtUri

     

       3
       3
       +
       from atproto_client import models

     

       4
       4
       +
       

     

       5
       5
       +
       class Client2(Client):

     

       6
       6
       +
           def __init__(self, base_url: str | None = None, *args: Any, **kwargs: Any) -> None:

     

       7
       7
       +
               super().__init__(base_url, *args, **kwargs)

     

       8
       8
       +
           

     

       9
       9
       +
           def send_video(

     

       10
       10
       +
               self, 

     

       11
       11
       +
               text: str | client_utils.TextBuilder, 

     

       12
       12
       +
               video: bytes,

     

       13
       13
       +
               video_alt: str | None = None,

     

       14
       14
       +
               video_aspect_ratio: models.AppBskyEmbedDefs.AspectRatio | None = None,

     

       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

     

       19
       19
       +
               ) -> models.AppBskyFeedPost.CreateRecordResponse:

     

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

     

       21
       21
       +
               

     

       22
       22
       +
               if video_alt is None:

     

       23
       23
       +
                   video_alt = ''

     

       24
       24
       +
       

     

       25
       25
       +
               upload = self.upload_blob(video)

     

       26
       26
       +
               

     

       27
       27
       +
               return self.send_post(

     

       28
       28
       +
                   text,

     

       29
       29
       +
                   reply_to=reply_to,

     

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

     

       31
       31
       +
                   langs=langs,

     

       32
       32
       +
                   facets=facets,

     

       33
       33
       +
                   labels=labels

     

       34
       34
       +
               )

     

       35
       35
       +
           

     

       36
       36
       +
           def send_images(

     

       37
       37
       +
               self, 

     

       38
       38
       +
               text: str | client_utils.TextBuilder, 

     

       39
       39
       +
               images: list[bytes],

     

       40
       40
       +
               image_alts: list[str] | None = None,

     

       41
       41
       +
               image_aspect_ratios: list[models.AppBskyEmbedDefs.AspectRatio] | None = None,

     

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

     

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

     

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

     

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

     

       46
       46
       +
               ) -> models.AppBskyFeedPost.CreateRecordResponse:

     

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

     

       48
       48
       +
               

     

       49
       49
       +
               if image_alts is None:

     

       50
       50
       +
                   image_alts = [''] * len(images)

     

       51
       51
       +
               else:

     

       52
       52
       +
                   diff = len(images) - len(image_alts)

     

       53
       53
       +
                   image_alts = image_alts + [''] * diff

     

       54
       54
       +
               

     

       55
       55
       +
               if image_aspect_ratios is None:

     

       56
       56
       +
                   aligned_image_aspect_ratios = [None] * len(images)

     

       57
       57
       +
               else:

     

       58
       58
       +
                   diff = len(images) - len(image_aspect_ratios)

     

       59
       59
       +
                   aligned_image_aspect_ratios = image_aspect_ratios + [None] * diff

     

       60
       60
       +
               

     

       61
       61
       +
               uploads = [self.upload_blob(image) for image in images]

     

       62
       62
       +
               

     

       63
       63
       +
               embed_images = [

     

       64
       64
       +
                   models.AppBskyEmbedImages.Image(alt=alt, image=upload.blob, aspect_ratio=aspect_ratio)

     

       65
       65
       +
                   for alt, upload, aspect_ratio in zip(image_alts, uploads, aligned_image_aspect_ratios)

     

       66
       66
       +
               ]

     

       67
       67
       +
               

     

       68
       68
       +
               return self.send_post(

     

       69
       69
       +
                   text,

     

       70
       70
       +
                   reply_to=reply_to,

     

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

     

       72
       72
       +
                   langs=langs,

     

       73
       73
       +
                   facets=facets,

     

       74
       74
       +
                   labels=labels

     

       75
       75
       +
               )

     

       76
       76
       +
           

     

       77
       77
       +
           def send_post(

     

       78
       78
       +
               self, 

     

       79
       79
       +
               text: str | client_utils.TextBuilder, 

     

       80
       80
       +
               reply_to: models.AppBskyFeedPost.ReplyRef | None = None,

     

       81
       81
       +
               embed: 

     

       82
       82
       +
                   None |

     

       83
       83
       +
                   models.AppBskyEmbedImages.Main |

     

       84
       84
       +
                   models.AppBskyEmbedExternal.Main |

     

       85
       85
       +
                   models.AppBskyEmbedRecord.Main |

     

       86
       86
       +
                   models.AppBskyEmbedRecordWithMedia.Main |

     

       87
       87
       +
                   models.AppBskyEmbedVideo.Main = None,

     

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

     

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

     

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

     

       91
       91
       +
               ) -> models.AppBskyFeedPost.CreateRecordResponse:

     

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

     

       93
       93
       +
               

     

       94
       94
       +
               if isinstance(text, client_utils.TextBuilder):

     

       95
       95
       +
                   facets = text.build_facets()

     

       96
       96
       +
                   text = text.build_text()

     

       97
       97
       +
               

     

       98
       98
       +
               repo = self.me and self.me.did

     

       99
       99
       +
               if not repo:

     

       100
       100
       +
                   raise Exception("Client not logged in!")

     

       101
       101
       +
               

     

       102
       102
       +
               if not langs:

     

       103
       103
       +
                   langs = ['en']

     

       104
       104
       +
                   

     

       105
       105
       +
               record = models.AppBskyFeedPost.Record(

     

       106
       106
       +
                   created_at=self.get_current_time_iso(),

     

       107
       107
       +
                   text=text,

     

       108
       108
       +
                   reply=reply_to,

     

       109
       109
       +
                   embed=embed,

     

       110
       110
       +
                   langs=langs,

     

       111
       111
       +
                   facets=facets,

     

       112
       112
       +
                   labels=labels

     

       113
       113
       +
               )

     

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

     

       115
       115
       +
           

     

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

     

       117
       117
       +
               account = self.me

     

       118
       118
       +
               if not account:

     

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

     

       120
       120
       +
               

     

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

     

       122
       122
       +
               time = self.get_current_time_iso()

     

       123
       123
       +
               

     

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

     

       125
       125
       +
               if 'everybody' not in thread_gate_opts:

     

       126
       126
       +
                   allow = []

     

       127
       127
       +
                   if thread_gate_opts:

     

       128
       128
       +
                       if 'following' in thread_gate_opts:

     

       129
       129
       +
                           allow.append(models.AppBskyFeedThreadgate.FollowingRule())

     

       130
       130
       +
                       if 'followers' in thread_gate_opts:

     

       131
       131
       +
                           allow.append(models.AppBskyFeedThreadgate.FollowerRule())

     

       132
       132
       +
                       if 'mentioned' in thread_gate_opts:

     

       133
       133
       +
                           allow.append(models.AppBskyFeedThreadgate.MentionRule())

     

       134
       134
       +
                   

     

       135
       135
       +
                   thread_gate = models.AppBskyFeedThreadgate.Record(

     

       136
       136
       +
                       post=post_uri,

     

       137
       137
       +
                       created_at=time,

     

       138
       138
       +
                       allow=allow

     

       139
       139
       +
                   )

     

       140
       140
       +
                   

     

       141
       141
       +
                   self.app.bsky.feed.threadgate.create(account.did, thread_gate, rkey)

     

       142
       142
       +
                   

     

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

     

       144
       144
       +
                   post_gate = models.AppBskyFeedPostgate.Record(

     

       145
       145
       +
                       post=post_uri,

     

       146
       146
       +
                       created_at=time,

     

       147
       147
       +
                       embedding_rules=[

     

       148
       148
       +
                           models.AppBskyFeedPostgate.DisableRule()

     

       149
       149
       +
                       ]

     

       150
       150
       +
                   )

     

       151
       151
       +
                   

     

       152
       152
       +
                   self.app.bsky.feed.postgate.create(account.did, post_gate, rkey)

+22 -166

bluesky.py

···

       1
       1
       -
       from atproto import client_utils, Client, AtUri, IdResolver

     

       1
       1
       +
       from atproto import client_utils, IdResolver

     

       2
       2
        
       from atproto_client import models

     

       3
       3
       +
       from atproto2 import Client2

     

       3
       4
        
       import json

     

       4
       5
        
       import cross

     

       5
       6
        
       import database

     
···

       7
       8
        
       import util

     

       8
       9
        
       import media_util

     

       9
       10
        
       from util import LOGGER

     

       11
       11
       +
       import re

     

       10
       12
        
       

     

       11
       13
        
       # only for lexicon reference

     

       12
       14
        
       SERVICE = 'https://bsky.app'

     

       13
       15
        
       

     

       14
       14
       -
       ADULT_LABEL = ["sexual content", "nsfw"]

     

       15
       15
       -
       PORN_LABEL = ["porn", "yiff"]

     

       16
       16
       +
       # TODO this is terrible and stupid

     

       17
       17
       +
       ADULT_PATTERN = re.compile(r"\b(sexual content|nsfw|erotic|adult only|18\+)\b", re.IGNORECASE)

     

       18
       18
       +
       PORN_PATTERN  = re.compile(r"\b(porn|yiff|hentai|pornographic|fetish)\b", re.IGNORECASE)

     

       16
       19
        
       

     

       17
       20
        
       class BlueskyOutput(cross.Output):

     

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

     

       19
       22
        
               super().__init__(input, settings, db)

     

       20
       20
       -
               self.options = util.safe_get(settings, 'options', {})

     

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

     

       21
       24
        
               

     

       22
       22
       -
               if not util.get_or_envvar(settings, 'app-password'):

     

       25
       25
       +
               if not util.as_envvar(settings.get('app-password')):

     

       23
       26
        
                   raise Exception("Account app password not provided!")

     

       24
       27
        
               

     

       25
       28
        
               resolver = IdResolver()

     

       26
       26
       -
               did: str | None = util.get_or_envvar(settings, 'did')

     

       29
       29
       +
               did: str | None = util.as_envvar(settings.get('did'))

     

       27
       30
        
               if not did:

     

       28
       28
       -
                   if not util.get_or_envvar(settings, 'handle'):

     

       31
       31
       +
                   handle = util.as_envvar(settings.get('handle'))

     

       32
       32
       +
                   if not handle:

     

       29
       33
        
                       raise Exception("ATP handle not specified!")

     

       30
       30
       -
                   LOGGER.info("Resolving ATP identity for %s...", util.get_or_envvar(settings, 'handle'))

     

       31
       31
       -
                   did = resolver.handle.resolve(util.get_or_envvar(settings, 'handle'))

     

       34
       34
       +
                   LOGGER.info("Resolving ATP identity for %s...", handle)

     

       35
       35
       +
                   did = resolver.handle.resolve(handle)

     

       32
       36
        
               if not did:

     

       33
       37
        
                   raise Exception("Failed to resolve DID!")

     

       34
       38
        
               

     

       35
       35
       -
               pds: str | None = util.get_or_envvar(settings, 'pds')

     

       39
       39
       +
               pds: str | None = util.as_envvar(settings.get('pds'))

     

       36
       40
        
               if not pds:

     

       37
       41
        
                   LOGGER.info("Resolving PDS from DID document...")

     

       38
       42
        
                   did_doc = resolver.did.resolve(did)

     
···

       42
       46
        
               if not pds:

     

       43
       47
        
                   raise Exception("Failed to resolve PDS!")

     

       44
       48
        
               

     

       45
       45
       -
               self.client = Client(pds)

     

       46
       46
       -
               self.client.login(did, util.get_or_envvar(settings, 'app-password'))

     

       47
       47
       -
               self.bsky = Bluesky(self.client)

     

       49
       49
       +
               self.bsky = Client2(pds)

     

       50
       50
       +
               self.bsky.login(did, util.as_envvar(settings.get('app-password')))

     

       48
       51
        
           

     

       49
       52
        
           def _find_parent(self, parent_id: str):

     

       50
       50
       -
               login = self.client.me

     

       53
       53
       +
               login = self.bsky.me

     

       51
       54
        
               if not login:

     

       52
       55
        
                   raise Exception("Client not logged in!")

     

       53
       56
        
               

     
···

       140
       143
        
               return result

     

       141
       144
        
           

     

       142
       145
        
           def accept_post(self, post: cross.Post):

     

       143
       143
       -
               login = self.client.me

     

       146
       146
       +
               login = self.bsky.me

     

       144
       147
        
               if not login:

     

       145
       148
        
                   raise Exception("Client not logged in!")

     

       146
       149
        
               

     
···

       166
       169
        
                   tokens.insert(0, cross.TextToken("CW: " + cw + "\n\n"))

     

       167
       170
        
                   unique_labels.add('graphic-media')

     

       168
       171
        
               

     

       169
       169
       -
               if any(tag in cw for tag in ADULT_LABEL):

     

       172
       172
       +
               if ADULT_PATTERN.search(cw):

     

       170
       173
        
                   unique_labels.add('sexual')

     

       171
       174
        
               

     

       172
       172
       -
               if any(tag in cw for tag in PORN_LABEL):

     

       175
       175
       +
               if PORN_PATTERN.search(cw):

     

       173
       176
        
                   unique_labels.add('porn')

     

       174
       177
        
               

     

       175
       178
        
               if post.is_sensitive():

     
···

       344
       347
        
                   database.insert_mapping(self.db, db_post['id'], new_parent_id)

     

       345
       348
        
                   

     

       346
       349
        
           def delete_post(self, identifier: str):

     

       347
       347
       -
               login = self.client.me

     

       350
       350
       +
               login = self.bsky.me

     

       348
       351
        
               if not login:

     

       349
       352
        
                   raise Exception("Client not logged in!")

     

       350
       353
        
               

     
···

       354
       357
        
               

     

       355
       358
        
               mappings = database.find_mappings(self.db, post['id'], SERVICE, login.did)

     

       356
       359
        
               for mapping in mappings[::-1]:

     

       357
       357
       -
                   self.client.delete_post(json.loads(mapping[0])['uri'])

     

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

     

       358
       361
        
                   database.delete_post(self.db, mapping[0], SERVICE, login.did)

     

       359
       359
       -
                   

     

       360
       360
       -
       

     

       361
       361
       -
       class Bluesky():

     

       362
       362
       -
           def __init__(self, client: Client) -> None:

     

       363
       363
       -
               self.client = client

     

       364
       364
       -
               

     

       365
       365
       -
           def send_video(

     

       366
       366
       -
               self, 

     

       367
       367
       -
               text: str | client_utils.TextBuilder, 

     

       368
       368
       -
               video: bytes,

     

       369
       369
       -
               video_alt: str | None = None,

     

       370
       370
       -
               video_aspect_ratio: models.AppBskyEmbedDefs.AspectRatio | None = None,

     

       371
       371
       -
               reply_to: models.AppBskyFeedPost.ReplyRef | None = None,

     

       372
       372
       -
               langs: list[str] | None = None,

     

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

     

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

     

       375
       375
       -
               ) -> models.AppBskyFeedPost.CreateRecordResponse:

     

       376
       376
       -
               

     

       377
       377
       -
               if video_alt is None:

     

       378
       378
       -
                   video_alt = ''

     

       379
       379
       -
       

     

       380
       380
       -
               upload = self.client.upload_blob(video)

     

       381
       381
       -
               

     

       382
       382
       -
               return self.send_post(

     

       383
       383
       -
                   text,

     

       384
       384
       -
                   reply_to=reply_to,

     

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

     

       386
       386
       -
                   langs=langs,

     

       387
       387
       -
                   facets=facets,

     

       388
       388
       -
                   labels=labels

     

       389
       389
       -
               )

     

       390
       390
       -
           

     

       391
       391
       -
           def send_images(

     

       392
       392
       -
               self, 

     

       393
       393
       -
               text: str | client_utils.TextBuilder, 

     

       394
       394
       -
               images: list[bytes],

     

       395
       395
       -
               image_alts: list[str] | None = None,

     

       396
       396
       -
               image_aspect_ratios: list[models.AppBskyEmbedDefs.AspectRatio] | None = None,

     

       397
       397
       -
               reply_to: models.AppBskyFeedPost.ReplyRef | None = None,

     

       398
       398
       -
               langs: list[str] | None = None,

     

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

     

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

     

       401
       401
       -
               ) -> models.AppBskyFeedPost.CreateRecordResponse:

     

       402
       402
       -
               

     

       403
       403
       -
               if image_alts is None:

     

       404
       404
       -
                   image_alts = [''] * len(images)

     

       405
       405
       -
               else:

     

       406
       406
       -
                   diff = len(images) - len(image_alts)

     

       407
       407
       -
                   image_alts = image_alts + [''] * diff

     

       408
       408
       -
               

     

       409
       409
       -
               if image_aspect_ratios is None:

     

       410
       410
       -
                   aligned_image_aspect_ratios = [None] * len(images)

     

       411
       411
       -
               else:

     

       412
       412
       -
                   diff = len(images) - len(image_aspect_ratios)

     

       413
       413
       -
                   aligned_image_aspect_ratios = image_aspect_ratios + [None] * diff

     

       414
       414
       -
               

     

       415
       415
       -
               uploads = [self.client.upload_blob(image) for image in images]

     

       416
       416
       -
               

     

       417
       417
       -
               embed_images = [

     

       418
       418
       -
                   models.AppBskyEmbedImages.Image(alt=alt, image=upload.blob, aspect_ratio=aspect_ratio)

     

       419
       419
       -
                   for alt, upload, aspect_ratio in zip(image_alts, uploads, aligned_image_aspect_ratios)

     

       420
       420
       -
               ]

     

       421
       421
       -
               

     

       422
       422
       -
               return self.send_post(

     

       423
       423
       -
                   text,

     

       424
       424
       -
                   reply_to=reply_to,

     

       425
       425
       -
                   embed=models.AppBskyEmbedImages.Main(images=embed_images),

     

       426
       426
       -
                   langs=langs,

     

       427
       427
       -
                   facets=facets,

     

       428
       428
       -
                   labels=labels

     

       429
       429
       -
               )

     

       430
       430
       -
           

     

       431
       431
       -
           def send_post(

     

       432
       432
       -
               self, 

     

       433
       433
       -
               text: str | client_utils.TextBuilder, 

     

       434
       434
       -
               reply_to: models.AppBskyFeedPost.ReplyRef | None = None,

     

       435
       435
       -
               embed: 

     

       436
       436
       -
                   None |

     

       437
       437
       -
                   models.AppBskyEmbedImages.Main |

     

       438
       438
       -
                   models.AppBskyEmbedExternal.Main |

     

       439
       439
       -
                   models.AppBskyEmbedRecord.Main |

     

       440
       440
       -
                   models.AppBskyEmbedRecordWithMedia.Main |

     

       441
       441
       -
                   models.AppBskyEmbedVideo.Main = None,

     

       442
       442
       -
               langs: list[str] | None = None,

     

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

     

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

     

       445
       445
       -
               ) -> models.AppBskyFeedPost.CreateRecordResponse:

     

       446
       446
       -
               

     

       447
       447
       -
               if isinstance(text, client_utils.TextBuilder):

     

       448
       448
       -
                   facets = text.build_facets()

     

       449
       449
       -
                   text = text.build_text()

     

       450
       450
       -
               

     

       451
       451
       -
               repo = self.client.me and self.client.me.did

     

       452
       452
       -
               if not repo:

     

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

     

       454
       454
       -
               

     

       455
       455
       -
               if not langs:

     

       456
       456
       -
                   langs = ['en']

     

       457
       457
       -
                   

     

       458
       458
       -
               record = models.AppBskyFeedPost.Record(

     

       459
       459
       -
                   created_at=self.client.get_current_time_iso(),

     

       460
       460
       -
                   text=text,

     

       461
       461
       -
                   reply=reply_to,

     

       462
       462
       -
                   embed=embed,

     

       463
       463
       -
                   langs=langs,

     

       464
       464
       -
                   facets=facets,

     

       465
       465
       -
                   labels=labels

     

       466
       466
       -
               )

     

       467
       467
       -
               return self.client.app.bsky.feed.post.create(repo, record)

     

       468
       468
       -
           

     

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

     

       470
       470
       -
               account = self.client.me

     

       471
       471
       -
               if not account:

     

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

     

       473
       473
       -
               

     

       474
       474
       -
               rkey = AtUri.from_str(post_uri).rkey

     

       475
       475
       -
               time = self.client.get_current_time_iso()

     

       476
       476
       -
               

     

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

     

       478
       478
       -
               if 'everybody' not in thread_gate_opts:

     

       479
       479
       -
                   allow = []

     

       480
       480
       -
                   if thread_gate_opts:

     

       481
       481
       -
                       if 'following' in thread_gate_opts:

     

       482
       482
       -
                           allow.append(models.AppBskyFeedThreadgate.FollowingRule())

     

       483
       483
       -
                       if 'followers' in thread_gate_opts:

     

       484
       484
       -
                           allow.append(models.AppBskyFeedThreadgate.FollowerRule())

     

       485
       485
       -
                       if 'mentioned' in thread_gate_opts:

     

       486
       486
       -
                           allow.append(models.AppBskyFeedThreadgate.MentionRule())

     

       487
       487
       -
                   

     

       488
       488
       -
                   thread_gate = models.AppBskyFeedThreadgate.Record(

     

       489
       489
       -
                       post=post_uri,

     

       490
       490
       -
                       created_at=time,

     

       491
       491
       -
                       allow=allow

     

       492
       492
       -
                   )

     

       493
       493
       -
                   

     

       494
       494
       -
                   self.client.app.bsky.feed.threadgate.create(account.did, thread_gate, rkey)

     

       495
       495
       -
                   

     

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

     

       497
       497
       -
                   post_gate = models.AppBskyFeedPostgate.Record(

     

       498
       498
       -
                       post=post_uri,

     

       499
       499
       -
                       created_at=time,

     

       500
       500
       -
                       embedding_rules=[

     

       501
       501
       -
                           models.AppBskyFeedPostgate.DisableRule()

     

       502
       502
       -
                       ]

     

       503
       503
       -
                   )

     

       504
       504
       -
                   

     

       505
       505
       -
                   self.client.app.bsky.feed.postgate.create(account.did, post_gate, rkey)

     

       506
       362
        
           

     

       507
       363
        
       

     

       508
       364
        
       def tokens_to_richtext(tokens: list[cross.Token]) -> client_utils.TextBuilder | None:

+6 -6

mastodon.py

···

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

     

       97
       97
        
           

     

       98
       98
        
           def get_cw(self) -> str:

     

       99
       99
       -
               return util.safe_get(self.status, 'spoiler_text', '')

     

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

     

       100
       100
        
           

     

       101
       101
        
           def get_id(self) -> str:

     

       102
       102
        
               return self.status['id']

     
···

       145
       145
        
           

     

       146
       146
        
           # get media description

     

       147
       147
        
           def get_alt(self) -> str:

     

       148
       148
       -
               return util.safe_get(self.attachment, 'description', '')

     

       148
       148
       +
               return self.attachment.get('description') or ''

     

       149
       149
        
       

     

       150
       150
        
       class MastodonInput(cross.Input):

     

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

     

       152
       152
        
               self.options = settings.get('options', {})

     

       153
       153
       -
               self.token = util.get_or_envvar(settings, 'token')

     

       154
       154
       -
               instance: str = util.get_or_envvar(settings, 'instance')

     

       153
       153
       +
               self.token = util.as_envvar(settings.get('token')) or (_ for _ in ()).throw(ValueError("'token' is required"))

     

       154
       154
       +
               instance: str = util.as_envvar(settings.get('instance')) or (_ for _ in ()).throw(ValueError("'instance' is required"))

     

       155
       155
        
               

     

       156
       156
        
               service = instance[:-1] if instance.endswith('/') else instance

     

       157
       157
        
               

     
···

       174
       174
        
               response = requests.get(f"{self.service}/api/v1/instance")

     

       175
       175
        
               response.raise_for_status()

     

       176
       176
        
               data: dict = response.json()

     

       177
       177
       -
               return util.safe_get(data, "urls", {}).get("streaming_api")

     

       177
       177
       +
               return (data.get('urls') or {}).get('streaming_api')

     

       178
       178
        
           

     

       179
       179
        
           def _on_create_post(self, outputs: list[cross.Output], status: dict):

     

       180
       180
        
               # skip events from other users

     

       181
       181
       -
               if util.safe_get(status, 'account', {})['id'] != self.user_id:

     

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

     

       182
       182
        
                   return

     

       183
       183
        
               

     

       184
       184
        
               if status.get('reblog') or status.get('poll'):

+7 -8

misskey.py

···

       29
       29
        
           if not text:

     

       30
       30
        
               return []

     

       31
       31
        
           

     

       32
       32
       -
           mention_handles: dict = util.safe_get(note, 'mentionHandles', {})

     

       32
       32
       +
           mention_handles: dict = note.get('mentionHandles') or {}

     

       33
       33
       +
           tags: list[str] = note.get('tags') or []

     

       34
       34
       +
           

     

       33
       35
        
           handles: list[str] = []

     

       34
       34
       -
           

     

       35
       36
        
           for key, value in mention_handles.items():

     

       36
       37
        
               handles.append(value)

     

       37
       37
       -
           

     

       38
       38
       -
           tags: list[str] = util.safe_get(note, 'tags', [])

     

       39
       38
        
           

     

       40
       39
        
           index: int = 0

     

       41
       40
        
           total: int = len(text)

     
···

       133
       132
        
               return self.note['id']

     

       134
       133
        
           

     

       135
       134
        
           def get_cw(self) -> str:

     

       136
       136
       -
               return util.safe_get(self.note, 'cw', '')

     

       135
       135
       +
               return self.note.get('cw') or ''

     

       137
       136
        
           

     

       138
       137
        
           def get_languages(self) -> list[str]:

     

       139
       138
        
               return []

     
···

       160
       159
        
               return get_image_common(self.attachment['type'])

     

       161
       160
        
           

     

       162
       161
        
           def get_alt(self) -> str:

     

       163
       163
       -
               return util.safe_get(self.attachment, 'comment', '')

     

       162
       162
       +
               return self.attachment.get('comment') or ''

     

       164
       163
        
       

     

       165
       164
        
       class MisskeyInput(cross.Input):

     

       166
       165
        
           def __init__(self, settings: dict, db: cross.DataBaseWorker) -> None:

     

       167
       166
        
               self.options = settings.get('options', {})

     

       168
       168
       -
               self.token = util.get_or_envvar(settings, 'token')

     

       169
       169
       -
               instance: str = util.get_or_envvar(settings, 'instance')

     

       167
       167
       +
               self.token = util.as_envvar(settings.get('token')) or (_ for _ in ()).throw(ValueError("'token' is required"))

     

       168
       168
       +
               instance: str = util.as_envvar(settings.get('instance')) or (_ for _ in ()).throw(ValueError("'instance' is required"))

     

       170
       169
        
               

     

       171
       170
        
               service = instance[:-1] if instance.endswith('/') else instance

     

       172
       171

+6 -5

util.py

···

       140
       140
        
           val = obj.get(key, default)

     

       141
       141
        
           return val if val else default

     

       142
       142
        
       

     

       143
       143
       -
       def value_or_envvar(text: str) -> str:

     

       143
       143
       +
       def as_envvar(text: str | None) -> str | None:

     

       144
       144
       +
           if not text:

     

       145
       145
       +
               return None

     

       146
       146
       +
           

     

       144
       147
        
           if text.startswith('env:'):

     

       145
       148
        
               return os.environ.get(text[4:], '')

     

       146
       146
       -
           return text

     

       147
       147
       -
       

     

       148
       148
       -
       def get_or_envvar(obj: dict, key: str):

     

       149
       149
       -
           return value_or_envvar(obj.get(key, ''))
     

       149
       149
       +
           

     

       150
       150
       +
           return text