commit d40d7a7fee295fe37bb3c82cd9b6453d382d3ac8 · zenfyr.dev/xpost

+12

.gitignore

···

       1
       1
       +
       # Python-generated files

     

       2
       2
       +
       __pycache__/

     

       3
       3
       +
       *.py[oc]

     

       4
       4
       +
       build/

     

       5
       5
       +
       dist/

     

       6
       6
       +
       wheels/

     

       7
       7
       +
       *.egg-info

     

       8
       8
       +
       

     

       9
       9
       +
       # Virtual environments

     

       10
       10
       +
       .venv

     

       11
       11
       +
       

     

       12
       12
       +
       data/

.python-version

+57

README.md

···

       1
       1
       +
       # XPost

     

       2
       2
       +
       

     

       3
       3
       +
       > put more readme here uhhh

     

       4
       4
       +
       

     

       5
       5
       +
       a silly little crossposting tool based on the mastodon streaming api.

     

       6
       6
       +
       

     

       7
       7
       +
       this tool is very, very not production ready or something. use with caution.

     

       8
       8
       +
       

     

       9
       9
       +
       # Installation

     

       10
       10
       +
       

     

       11
       11
       +
       first install `ffmpeg` with `ffprobe`, make sure they are available on PATH! `ffmpeg` is required to crosspost media.

     

       12
       12
       +
       

     

       13
       13
       +
       then get [uv](https://github.com/astral-sh/uv) and sync the project

     

       14
       14
       +
       

     

       15
       15
       +
       ```

     

       16
       16
       +
       uv sync

     

       17
       17
       +
       ```

     

       18
       18
       +
       

     

       19
       19
       +
       print help message:

     

       20
       20
       +
       

     

       21
       21
       +
       ```

     

       22
       22
       +
       uv run main.py run --help

     

       23
       23
       +
       ```

     

       24
       24
       +
       

     

       25
       25
       +
       # Settings

     

       26
       26
       +
       

     

       27
       27
       +
       ## Bluesky

     

       28
       28
       +
       

     

       29
       29
       +
       in the bluesky block, you can configure who is allowed to reply to and quote the new posts.

     

       30
       30
       +
       

     

       31
       31
       +
       `quote_gate`:

     

       32
       32
       +
       

     

       33
       33
       +
       prevent users from quoting the post. default: `false`

     

       34
       34
       +
       

     

       35
       35
       +
       `thread_gate`: 

     

       36
       36
       +
       

     

       37
       37
       +
       prevent users from replying to the post. leave empty to prevent replies completely.

     

       38
       38
       +
       

     

       39
       39
       +
       accepted values:

     

       40
       40
       +
       - `following` followed users.

     

       41
       41
       +
       - `followers` users following the account.

     

       42
       42
       +
       - `mentioned` users mentioned in the post.

     

       43
       43
       +
       - `everybody` everybody is allowed to reply to the post. all other options will be skipped.

     

       44
       44
       +
       

     

       45
       45
       +
       

     

       46
       46
       +
       # Supported Software

     

       47
       47
       +
       

     

       48
       48
       +
       any instance implementing `/api/v1/instance`, `/api/v1/accounts/verify_credentials` and `/api/v1/streaming?stream` will work fine.

     

       49
       49
       +
       

     

       50
       50
       +
       confirmed supported:

     

       51
       51
       +
       - Mastodon

     

       52
       52
       +
       - Iceshrimp.NET

     

       53
       53
       +
       - Sharkey

     

       54
       54
       +
       - Akkoma

     

       55
       55
       +
       

     

       56
       56
       +
       confirmed unsupported:

     

       57
       57
       +
       - Mitra

+167

bluesky.py

···

       1
       1
       +
       from atproto import client_utils, Client, AtUri

     

       2
       2
       +
       from atproto_client import models

     

       3
       3
       +
       

     

       4
       4
       +
       class Bluesky():

     

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

     

       6
       6
       +
               self.client = client

     

       7
       7
       +
               

     

       8
       8
       +
           def send_video(

     

       9
       9
       +
               self, 

     

       10
       10
       +
               text: str | client_utils.TextBuilder, 

     

       11
       11
       +
               video: bytes,

     

       12
       12
       +
               video_alt: str | None = None,

     

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

     

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

     

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

     

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

     

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

     

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

     

       19
       19
       +
               

     

       20
       20
       +
               if video_alt is None:

     

       21
       21
       +
                   video_alt = ''

     

       22
       22
       +
       

     

       23
       23
       +
               upload = self.client.upload_blob(video)

     

       24
       24
       +
               

     

       25
       25
       +
               return self.send_post(

     

       26
       26
       +
                   text,

     

       27
       27
       +
                   reply_to=reply_to,

     

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

     

       29
       29
       +
                   langs=langs,

     

       30
       30
       +
                   facets=facets,

     

       31
       31
       +
                   labels=labels

     

       32
       32
       +
               )

     

       33
       33
       +
           

     

       34
       34
       +
           def send_images(

     

       35
       35
       +
               self, 

     

       36
       36
       +
               text: str | client_utils.TextBuilder, 

     

       37
       37
       +
               images: list[bytes],

     

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

     

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

     

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

     

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

     

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

     

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

     

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

     

       45
       45
       +
               

     

       46
       46
       +
               if image_alts is None:

     

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

     

       48
       48
       +
               else:

     

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

     

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

     

       51
       51
       +
               

     

       52
       52
       +
               if image_aspect_ratios is None:

     

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

     

       54
       54
       +
               else:

     

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

     

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

     

       57
       57
       +
               

     

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

     

       59
       59
       +
               

     

       60
       60
       +
               embed_images = [

     

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

     

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

     

       63
       63
       +
               ]

     

       64
       64
       +
               

     

       65
       65
       +
               return self.send_post(

     

       66
       66
       +
                   text,

     

       67
       67
       +
                   reply_to=reply_to,

     

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

     

       69
       69
       +
                   langs=langs,

     

       70
       70
       +
                   facets=facets,

     

       71
       71
       +
                   labels=labels

     

       72
       72
       +
               )

     

       73
       73
       +
           

     

       74
       74
       +
           def send_post(

     

       75
       75
       +
               self, 

     

       76
       76
       +
               text: str | client_utils.TextBuilder, 

     

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

     

       78
       78
       +
               embed: 

     

       79
       79
       +
                   None |

     

       80
       80
       +
                   models.AppBskyEmbedImages.Main |

     

       81
       81
       +
                   models.AppBskyEmbedExternal.Main |

     

       82
       82
       +
                   models.AppBskyEmbedRecord.Main |

     

       83
       83
       +
                   models.AppBskyEmbedRecordWithMedia.Main |

     

       84
       84
       +
                   models.AppBskyEmbedVideo.Main = None,

     

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

     

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

     

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

     

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

     

       89
       89
       +
               

     

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

     

       91
       91
       +
                   facets = text.build_facets()

     

       92
       92
       +
                   text = text.build_text()

     

       93
       93
       +
               

     

       94
       94
       +
               repo = self.client.me and self.client.me.did

     

       95
       95
       +
               if not repo:

     

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

     

       97
       97
       +
               

     

       98
       98
       +
               if not langs:

     

       99
       99
       +
                   langs = ['en']

     

       100
       100
       +
                   

     

       101
       101
       +
               record = models.AppBskyFeedPost.Record(

     

       102
       102
       +
                   created_at=self.client.get_current_time_iso(),

     

       103
       103
       +
                   text=text,

     

       104
       104
       +
                   reply=reply_to,

     

       105
       105
       +
                   embed=embed,

     

       106
       106
       +
                   langs=langs,

     

       107
       107
       +
                   facets=facets,

     

       108
       108
       +
                   labels=labels

     

       109
       109
       +
               )

     

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

     

       111
       111
       +
           

     

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

     

       113
       113
       +
               account = self.client.me

     

       114
       114
       +
               if not account:

     

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

     

       116
       116
       +
               

     

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

     

       118
       118
       +
               time = self.client.get_current_time_iso()

     

       119
       119
       +
               

     

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

     

       121
       121
       +
               if 'everybody' not in thread_gate_opts:

     

       122
       122
       +
                   allow = []

     

       123
       123
       +
                   if thread_gate_opts:

     

       124
       124
       +
                       if 'following' in thread_gate_opts:

     

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

     

       126
       126
       +
                       if 'followers' in thread_gate_opts:

     

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

     

       128
       128
       +
                       if 'mentioned' in thread_gate_opts:

     

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

     

       130
       130
       +
                   

     

       131
       131
       +
                   thread_gate = models.AppBskyFeedThreadgate.Record(

     

       132
       132
       +
                       post=post_uri,

     

       133
       133
       +
                       created_at=time,

     

       134
       134
       +
                       allow=allow

     

       135
       135
       +
                   )

     

       136
       136
       +
                   

     

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

     

       138
       138
       +
                   

     

       139
       139
       +
               if options['quote_gate']:

     

       140
       140
       +
                   post_gate = models.AppBskyFeedPostgate.Record(

     

       141
       141
       +
                       post=post_uri,

     

       142
       142
       +
                       created_at=time,

     

       143
       143
       +
                       embedding_rules=[

     

       144
       144
       +
                           models.AppBskyFeedPostgate.DisableRule()

     

       145
       145
       +
                       ]

     

       146
       146
       +
                   )

     

       147
       147
       +
                   

     

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

     

       149
       149
       +
           

     

       150
       150
       +
       

     

       151
       151
       +
       def tokens_to_richtext(tokens: list[dict]) -> client_utils.TextBuilder | None:

     

       152
       152
       +
           builder: client_utils.TextBuilder = client_utils.TextBuilder()

     

       153
       153
       +
           

     

       154
       154
       +
           for token in tokens:

     

       155
       155
       +
               token_type = token['type']

     

       156
       156
       +
               

     

       157
       157
       +
               if token_type == 'text':

     

       158
       158
       +
                   builder.text(token['value'])

     

       159
       159
       +
               elif token_type == 'hashtag':

     

       160
       160
       +
                   builder.tag(token['value'], token['value'][1:])

     

       161
       161
       +
               elif token_type == 'link':

     

       162
       162
       +
                   builder.link(token['label'], token['value'])

     

       163
       163
       +
               else:

     

       164
       164
       +
                   # Fail on mention!

     

       165
       165
       +
                   return None

     

       166
       166
       +
           

     

       167
       167
       +
           return builder

+118

database.py

···

       1
       1
       +
       import sqlite3

     

       2
       2
       +
       import json

     

       3
       3
       +
       

     

       4
       4
       +
       import sqlite3

     

       5
       5
       +
       import json

     

       6
       6
       +
       

     

       7
       7
       +
       class DataBase():

     

       8
       8
       +
       

     

       9
       9
       +
           def __init__(self, path: str) -> None:

     

       10
       10
       +
               self.path = path

     

       11
       11
       +
               connection = sqlite3.connect(self.path, autocommit=True)

     

       12
       12
       +
               cursor = connection.cursor()

     

       13
       13
       +
               cursor.execute('''

     

       14
       14
       +
                   CREATE TABLE IF NOT EXISTS posts (

     

       15
       15
       +
                       id TEXT,

     

       16
       16
       +
                       user_id TEXT,

     

       17
       17
       +
                       data TEXT,

     

       18
       18
       +
                       PRIMARY KEY (id, user_id)

     

       19
       19
       +
                   )

     

       20
       20
       +
               ''')

     

       21
       21
       +
               cursor.close()

     

       22
       22
       +
           

     

       23
       23
       +
           def connect(self) -> sqlite3.Connection:

     

       24
       24
       +
               return sqlite3.connect(self.path, autocommit=True)

     

       25
       25
       +
       

     

       26
       26
       +
           def put_post(self, db: sqlite3.Connection, user_id: str, id: str, data: dict):

     

       27
       27
       +
               cursor = db.cursor()

     

       28
       28
       +
               cursor.execute('''

     

       29
       29
       +
                   INSERT OR REPLACE INTO posts (id, user_id, data) VALUES (?, ?, ?)

     

       30
       30
       +
               ''', (id, user_id, json.dumps(data)))

     

       31
       31
       +
               cursor.close()

     

       32
       32
       +
       

     

       33
       33
       +
           def del_post(self, db: sqlite3.Connection, user_id: str, id: str):

     

       34
       34
       +
               cursor = db.cursor()

     

       35
       35
       +
               cursor.execute('''

     

       36
       36
       +
                   DELETE FROM posts WHERE id = ? AND user_id = ?

     

       37
       37
       +
               ''', (id, user_id))

     

       38
       38
       +
               cursor.close()

     

       39
       39
       +
               

     

       40
       40
       +
           def read_data(self, db: sqlite3.Connection, user_id: str, id: str) -> dict | None:

     

       41
       41
       +
               cursor = db.cursor()

     

       42
       42
       +
               cursor.execute('''

     

       43
       43
       +
                   SELECT data FROM posts WHERE id = ? AND user_id = ?

     

       44
       44
       +
               ''', (id, user_id))

     

       45
       45
       +
               row = cursor.fetchone()

     

       46
       46
       +
               cursor.close()

     

       47
       47
       +
               if row:

     

       48
       48
       +
                   data_json = row[0]

     

       49
       49
       +
                   return json.loads(data_json)

     

       50
       50
       +
               return None

     

       51
       51
       +
       

     

       52
       52
       +
           def get_all_children(self, db: sqlite3.Connection, user_id: str, id: str) -> dict[str, dict]:

     

       53
       53
       +
               cursor = db.cursor()

     

       54
       54
       +
               cursor.execute('''

     

       55
       55
       +
                   WITH RECURSIVE thread_cte (id, user_id, data, current_post_uri) AS (

     

       56
       56
       +
                       SELECT

     

       57
       57
       +
                           T1.id,

     

       58
       58
       +
                           T1.user_id,

     

       59
       59
       +
                           T1.data,

     

       60
       60
       +
                           json_extract(

     

       61
       61
       +
                               T1.data,

     

       62
       62
       +
                               '$.mapped_post_refs[' || (json_array_length(T1.data, '$.mapped_post_refs') - 1) || '].uri'

     

       63
       63
       +
                           ) AS current_post_uri

     

       64
       64
       +
                       FROM

     

       65
       65
       +
                           posts AS T1

     

       66
       66
       +
                       WHERE

     

       67
       67
       +
                           T1.id = ? AND T1.user_id = ?

     

       68
       68
       +
       

     

       69
       69
       +
                       UNION ALL

     

       70
       70
       +
       

     

       71
       71
       +
                       SELECT

     

       72
       72
       +
                           C.id,

     

       73
       73
       +
                           C.user_id,

     

       74
       74
       +
                           C.data,

     

       75
       75
       +
                           json_extract(

     

       76
       76
       +
                               C.data,

     

       77
       77
       +
                               '$.mapped_post_refs[' || (json_array_length(C.data, '$.mapped_post_refs') - 1) || '].uri'

     

       78
       78
       +
                           ) AS current_post_uri

     

       79
       79
       +
                       FROM

     

       80
       80
       +
                           posts AS C

     

       81
       81
       +
                       JOIN

     

       82
       82
       +
                           thread_cte AS P ON json_extract(C.data, '$.parent_ref.uri') = P.current_post_uri

     

       83
       83
       +
                       WHERE

     

       84
       84
       +
                           C.user_id = ?

     

       85
       85
       +
                   )

     

       86
       86
       +
                   SELECT id, data FROM thread_cte;

     

       87
       87
       +
               ''', (id, user_id, user_id))

     

       88
       88
       +
               raw_data = cursor.fetchall()

     

       89
       89
       +
               cursor.close()

     

       90
       90
       +
       

     

       91
       91
       +
               if not raw_data:

     

       92
       92
       +
                   return {}

     

       93
       93
       +
       

     

       94
       94
       +
               data: dict[str, dict] = {}

     

       95
       95
       +
               for post_id, post_data in raw_data:

     

       96
       96
       +
                   data[post_id] = json.loads(post_data)

     

       97
       97
       +
       

     

       98
       98
       +
               return data

     

       99
       99
       +
       

     

       100
       100
       +
       class UserScopedDB:

     

       101
       101
       +
           def __init__(self, db: DataBase, user_id: str):

     

       102
       102
       +
               self.db = db

     

       103
       103
       +
               self.user_id = user_id

     

       104
       104
       +
       

     

       105
       105
       +
           def connect(self) -> sqlite3.Connection:

     

       106
       106
       +
               return self.db.connect()

     

       107
       107
       +
       

     

       108
       108
       +
           def put_post(self, db: sqlite3.Connection, id: str, data: dict):

     

       109
       109
       +
               return self.db.put_post(db, self.user_id, id, data)

     

       110
       110
       +
       

     

       111
       111
       +
           def del_post(self, db: sqlite3.Connection, id: str):

     

       112
       112
       +
               return self.db.del_post(db, self.user_id, id)

     

       113
       113
       +
       

     

       114
       114
       +
           def read_data(self, db: sqlite3.Connection, id: str) -> dict | None:

     

       115
       115
       +
               return self.db.read_data(db, self.user_id, id)

     

       116
       116
       +
       

     

       117
       117
       +
           def get_all_children(self, db: sqlite3.Connection, id: str) -> dict[str, dict]:

     

       118
       118
       +
               return self.db.get_all_children(db, self.user_id, id)

+408

main.py

···

       1
       1
       +
       import click

     

       2
       2
       +
       import json

     

       3
       3
       +
       import asyncio, threading, queue

     

       4
       4
       +
       from atproto import IdResolver, Client, client_utils

     

       5
       5
       +
       import atproto_client.models as models

     

       6
       6
       +
       import util, mastodon, bluesky, database

     

       7
       7
       +
       import os

     

       8
       8
       +
       import media_util

     

       9
       9
       +
       import traceback

     

       10
       10
       +
       

     

       11
       11
       +
       ADULT_LABEL = ["sexual content", "nsfw"]

     

       12
       12
       +
       PORN_LABEL = ["porn", "yiff"]

     

       13
       13
       +
       

     

       14
       14
       +
       class SocketListener():

     

       15
       15
       +
           def __init__(self, user_id: str, atproto: Client, settings: dict, db_path: str) -> None:

     

       16
       16
       +
               self.user_id = user_id

     

       17
       17
       +
               self.atp = bluesky.Bluesky(atproto)

     

       18
       18
       +
               self.settings = settings

     

       19
       19
       +
               self.db = database.UserScopedDB(database.DataBase(db_path), user_id)

     

       20
       20
       +
           

     

       21
       21
       +
           def create_post_records(self, status: dict) -> list[models.AppBskyFeedPost.CreateRecordResponse] | None:

     

       22
       22
       +
               tokens: list[dict] = util.tokenize_html(status['content'])

     

       23
       23
       +
               

     

       24
       24
       +
               label_text: set[str] = set()

     

       25
       25
       +
               status_spoiler = status['spoiler_text']

     

       26
       26
       +
               if status_spoiler:

     

       27
       27
       +
                   tokens.insert(0, {"type": "text", "value": "CW: " + status_spoiler + '\n\n'})

     

       28
       28
       +
                   label_text.add('graphic-media')

     

       29
       29
       +
               

     

       30
       30
       +
               if any(tag in status_spoiler for tag in ADULT_LABEL):

     

       31
       31
       +
                   label_text.add('sexual')

     

       32
       32
       +
               

     

       33
       33
       +
               if any(tag in status_spoiler for tag in PORN_LABEL):

     

       34
       34
       +
                   label_text.add('porn')

     

       35
       35
       +
               

     

       36
       36
       +
               if status['sensitive']:

     

       37
       37
       +
                   label_text.add('graphic-media')

     

       38
       38
       +
               

     

       39
       39
       +
               labels = models.ComAtprotoLabelDefs.SelfLabels(values=[models.ComAtprotoLabelDefs.SelfLabel(val=label) for label in label_text])

     

       40
       40
       +
               

     

       41
       41
       +
               split_tokens: list[list[dict]] = util.split_tokens(tokens, 300)

     

       42
       42
       +
               

     

       43
       43
       +
               post_text: list[client_utils.TextBuilder] = []

     

       44
       44
       +
               for funnel in split_tokens:

     

       45
       45
       +
                   rich_text = bluesky.tokens_to_richtext(funnel)

     

       46
       46
       +
                   

     

       47
       47
       +
                   if rich_text is None:

     

       48
       48
       +
                       click.echo(f"Skipping '{status["id"]}' as it contains invalid rich text types!")

     

       49
       49
       +
                       return None

     

       50
       50
       +
                   post_text.append(rich_text)

     

       51
       51
       +
                   

     

       52
       52
       +
               if not post_text:

     

       53
       53
       +
                   post_text = [client_utils.TextBuilder().text('')]

     

       54
       54
       +
               

     

       55
       55
       +
               records: list[models.AppBskyFeedPost.CreateRecordResponse] = []

     

       56
       56
       +
               

     

       57
       57
       +
               in_reply_to_id: str = status['in_reply_to_id']

     

       58
       58
       +
               

     

       59
       59
       +
               root_ref = None

     

       60
       60
       +
               reply_ref = None

     

       61
       61
       +
               if in_reply_to_id:

     

       62
       62
       +
                   db = self.db.connect()

     

       63
       63
       +
                   data: dict | None = self.db.read_data(db, in_reply_to_id)

     

       64
       64
       +
                   db.close()

     

       65
       65
       +
                   

     

       66
       66
       +
                   if data is not None:

     

       67
       67
       +
                       root_data = data['root_ref']

     

       68
       68
       +
                       if not root_data:

     

       69
       69
       +
                           root_data = data['mapped_post_refs'][0]

     

       70
       70
       +
                       

     

       71
       71
       +
                       reply_data = data['mapped_post_refs'][-1]

     

       72
       72
       +
                       

     

       73
       73
       +
                       root_post = models.AppBskyFeedPost.CreateRecordResponse(uri=str(root_data['uri']), cid=str(root_data['cid']))

     

       74
       74
       +
                       root_ref = models.create_strong_ref(root_post)

     

       75
       75
       +
                       

     

       76
       76
       +
                       reply_post = models.AppBskyFeedPost.CreateRecordResponse(uri=str(reply_data['uri']), cid=str(reply_data['cid']))

     

       77
       77
       +
                       reply_ref = models.create_strong_ref(reply_post)

     

       78
       78
       +
               

     

       79
       79
       +
               attachments: list[dict] = status['media_attachments']

     

       80
       80
       +
               if not attachments:

     

       81
       81
       +
                   for post in post_text:

     

       82
       82
       +
                       if reply_ref and root_ref:

     

       83
       83
       +
                           new_post = self.atp.send_post(post, reply_to=models.AppBskyFeedPost.ReplyRef(

     

       84
       84
       +
                               parent=reply_ref,

     

       85
       85
       +
                               root=root_ref

     

       86
       86
       +
                           ), labels=labels)

     

       87
       87
       +
                       else:

     

       88
       88
       +
                           new_post = self.atp.send_post(post, labels=labels)

     

       89
       89
       +
                           root_ref = models.create_strong_ref(new_post)

     

       90
       90
       +
                       

     

       91
       91
       +
                       self.atp.create_gates(self.settings.get('bluesky', {}), new_post.uri)

     

       92
       92
       +
                       reply_ref = models.create_strong_ref(new_post)

     

       93
       93
       +
                       records.append(new_post)

     

       94
       94
       +
                   

     

       95
       95
       +
                   return records

     

       96
       96
       +
               elif len(attachments) <= 4:

     

       97
       97
       +
                   if len(attachments) == 1 and attachments[0]['type'] == 'video':

     

       98
       98
       +
                       video: dict = attachments[0]

     

       99
       99
       +
                       

     

       100
       100
       +
                       video_io = media_util.download_blob(video['url'], max_bytes=100_000_000)

     

       101
       101
       +
                       if not video_io:

     

       102
       102
       +
                           click.echo(f"Skipping post_id '{status['id']}', failed to download attachment!")

     

       103
       103
       +
                           return None

     

       104
       104
       +
                       

     

       105
       105
       +
                       if len(video_io) > 100_000_000:

     

       106
       106
       +
                           click.echo(f"Skipping post_id '{status['id']}'. Video file too large")

     

       107
       107
       +
                           return None

     

       108
       108
       +
                       

     

       109
       109
       +
                       # some mastodon api implementations don't seem to provide video meta

     

       110
       110
       +
                       # try to probe it with ffmpeg

     

       111
       111
       +
                       meta = media_util.get_video_meta(video_io)

     

       112
       112
       +
                       if meta.get('duration', -1) > 180:

     

       113
       113
       +
                           click.echo(f"Skipping post_id '{status["id"]}'. Video attachment too long!")

     

       114
       114
       +
                           return None

     

       115
       115
       +
                       

     

       116
       116
       +
                       aspect_ratio = models.AppBskyEmbedDefs.AspectRatio(width=meta['width'], height=meta['height'])

     

       117
       117
       +
                       

     

       118
       118
       +
                       new_post = self.atp.send_video(

     

       119
       119
       +
                           text=post_text[0],

     

       120
       120
       +
                           video=video_io,

     

       121
       121
       +
                           video_aspect_ratio=aspect_ratio,

     

       122
       122
       +
                           video_alt=video['description'] if video['description'] else '',

     

       123
       123
       +
                           reply_to= models.AppBskyFeedPost.ReplyRef(

     

       124
       124
       +
                               parent=reply_ref,

     

       125
       125
       +
                               root=root_ref

     

       126
       126
       +
                           ) if root_ref and reply_ref else None,

     

       127
       127
       +
                           labels=labels

     

       128
       128
       +
                       )

     

       129
       129
       +
                       if not root_ref:

     

       130
       130
       +
                           root_ref = models.create_strong_ref(new_post)

     

       131
       131
       +
                           

     

       132
       132
       +
                       self.atp.create_gates(self.settings.get('bluesky', {}), new_post.uri)

     

       133
       133
       +
                       reply_ref = models.create_strong_ref(new_post)

     

       134
       134
       +
                   else:

     

       135
       135
       +
                       # check if all attachments are images.

     

       136
       136
       +
                       # bluesky doesn't support gifv and unknown (TODO link the file)

     

       137
       137
       +
                       for attachment in attachments:

     

       138
       138
       +
                           if attachment['type'] != 'image':

     

       139
       139
       +
                               click.echo(f"Skipping post_id '{status['id']}'. Attachment type mismatch. got: '{attachment['type']}' expected: 'image'")

     

       140
       140
       +
                               return None

     

       141
       141
       +
                           

     

       142
       142
       +
                       images: list[bytes] = []

     

       143
       143
       +
                       image_alts: list[str] = []

     

       144
       144
       +
                       image_aspect_ratios: list[models.AppBskyEmbedDefs.AspectRatio] = []

     

       145
       145
       +
                       for attachment in attachments:

     

       146
       146
       +
                           

     

       147
       147
       +
                           image_io = media_util.download_blob(attachment['url'], max_bytes=2_000_000)

     

       148
       148
       +
                           if not image_io:

     

       149
       149
       +
                               click.echo(f"Skipping post_id '{status['id']}', failed to download attachment!")

     

       150
       150
       +
                               return None

     

       151
       151
       +
                           

     

       152
       152
       +
                           # Try to compress image if it's too large

     

       153
       153
       +
                           if len(image_io) > 1_000_000:

     

       154
       154
       +
                               click.echo(f"Trying to compress {attachment['url']}..")

     

       155
       155
       +
                               image_io = media_util.compress_image(image_io)

     

       156
       156
       +
                               if len(image_io) > 1_000_000:

     

       157
       157
       +
                                   click.echo(f"Skipping post_id '{status['id']}', media attachment still too large after compression!")

     

       158
       158
       +
                                   return None

     

       159
       159
       +
                               

     

       160
       160
       +
                           meta = util.safe_get(attachment, 'meta', {}).get('original')

     

       161
       161
       +
                           

     

       162
       162
       +
                           # some mastodon api implementations don't seem to provide image meta

     

       163
       163
       +
                           # try to probe it with ffmpeg

     

       164
       164
       +
                           if not meta:

     

       165
       165
       +
                               meta = media_util.get_image_meta(image_io)

     

       166
       166
       +
                           

     

       167
       167
       +
                           images.append(image_io)

     

       168
       168
       +
                           image_alts.append(attachment['description'] if attachment['description'] else '')

     

       169
       169
       +
                           image_aspect_ratios.append(models.AppBskyEmbedDefs.AspectRatio(width=meta['width'], height=meta['height']))

     

       170
       170
       +
                       

     

       171
       171
       +
                       new_post = self.atp.send_images(

     

       172
       172
       +
                           text=post_text[0],

     

       173
       173
       +
                           images=images,

     

       174
       174
       +
                           image_alts=image_alts,

     

       175
       175
       +
                           image_aspect_ratios=image_aspect_ratios,

     

       176
       176
       +
                           reply_to= models.AppBskyFeedPost.ReplyRef(

     

       177
       177
       +
                               parent=reply_ref,

     

       178
       178
       +
                               root=root_ref

     

       179
       179
       +
                           ) if root_ref and reply_ref else None, 

     

       180
       180
       +
                           labels=labels

     

       181
       181
       +
                       )

     

       182
       182
       +
                       if not root_ref:

     

       183
       183
       +
                           root_ref = models.create_strong_ref(new_post)

     

       184
       184
       +
                           

     

       185
       185
       +
                       self.atp.create_gates(self.settings.get('bluesky', {}), new_post.uri)

     

       186
       186
       +
                       reply_ref = models.create_strong_ref(new_post)

     

       187
       187
       +
                   

     

       188
       188
       +
                   records.append(new_post)

     

       189
       189
       +
                   for post in post_text[1:]:

     

       190
       190
       +
                       new_post = self.atp.send_post(post, reply_to=models.AppBskyFeedPost.ReplyRef(

     

       191
       191
       +
                           parent=reply_ref,

     

       192
       192
       +
                           root=root_ref

     

       193
       193
       +
                       ), labels=labels)

     

       194
       194
       +
                       self.atp.create_gates(self.settings.get('bluesky', {}), new_post.uri)

     

       195
       195
       +
                       

     

       196
       196
       +
                       reply_ref = models.create_strong_ref(new_post)

     

       197
       197
       +
                       records.append(new_post)

     

       198
       198
       +
                   

     

       199
       199
       +
                   return records

     

       200
       200
       +
               else:

     

       201
       201
       +
                   click.echo(f"Skipping post_id '{status['id']}'. Too many attachments!")

     

       202
       202
       +
                   return records if records else None

     

       203
       203
       +
           

     

       204
       204
       +
           def on_update(self, status: dict):

     

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

     

       206
       206
       +
                   return

     

       207
       207
       +
               

     

       208
       208
       +
               if status['reblog'] or status['poll']:

     

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

     

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

     

       211
       211
       +
                   return

     

       212
       212
       +
       

     

       213
       213
       +
               in_reply: str | None = status['in_reply_to_id']

     

       214
       214
       +
               in_reply_to: str | None = status['in_reply_to_account_id']

     

       215
       215
       +
               if in_reply_to and in_reply_to != self.user_id:

     

       216
       216
       +
                   # We don't support replies. possible with bridgy(?)

     

       217
       217
       +
                   return

     

       218
       218
       +
               

     

       219
       219
       +
               if status['visibility'] not in ['public', 'unlisted']:

     

       220
       220
       +
                   # Skip f/o and direct posts

     

       221
       221
       +
                   return

     

       222
       222
       +
               

     

       223
       223
       +
               click.echo(f"Got 'update' event for post '{status['id']}'")

     

       224
       224
       +
               

     

       225
       225
       +
               records = self.create_post_records(status)

     

       226
       226
       +
               if records is None:

     

       227
       227
       +
                   click.echo(f"Skipped crossposting '{status['id']}' due to above erros..")

     

       228
       228
       +
                   return

     

       229
       229
       +
               

     

       230
       230
       +
               refs: list[dict] = []

     

       231
       231
       +
               

     

       232
       232
       +
               for record in records:

     

       233
       233
       +
                   refs.append({'cid': record.cid, 'uri': record.uri})

     

       234
       234
       +
               

     

       235
       235
       +
               db = self.db.connect()

     

       236
       236
       +
               if not in_reply:

     

       237
       237
       +
                   self.db.put_post(db, status['id'], {

     

       238
       238
       +
                       'parent_ref': None,

     

       239
       239
       +
                       'root_ref': None,

     

       240
       240
       +
                       'mapped_post_refs': refs

     

       241
       241
       +
                   })

     

       242
       242
       +
               else:

     

       243
       243
       +
                   data: dict | None = self.db.read_data(db, in_reply)

     

       244
       244
       +
                   if not data:

     

       245
       245
       +
                       click.echo(f"Post '{status['id']}' is missing parent in the database!")

     

       246
       246
       +
                       return

     

       247
       247
       +
                   

     

       248
       248
       +
                   self.db.put_post(db, status['id'], {

     

       249
       249
       +
                       'parent_ref': data['mapped_post_refs'][-1],

     

       250
       250
       +
                       'root_ref': data['mapped_post_refs'][-1],

     

       251
       251
       +
                       'mapped_post_refs': refs

     

       252
       252
       +
                   })

     

       253
       253
       +
               db.close()

     

       254
       254
       +
           

     

       255
       255
       +
           def on_delete(self, id: str):

     

       256
       256
       +
               db = self.db.connect()

     

       257
       257
       +
               post_data = self.db.read_data(db, id)

     

       258
       258
       +
               

     

       259
       259
       +
               if not post_data:

     

       260
       260
       +
                   return

     

       261
       261
       +
               

     

       262
       262
       +
               click.echo(f"Got 'delete' event for post '{id}'...")

     

       263
       263
       +
               

     

       264
       264
       +
               for ref in post_data['mapped_post_refs']:

     

       265
       265
       +
                   self.atp.client.delete_post(ref['uri'])

     

       266
       266
       +
               

     

       267
       267
       +
               children: dict[str, dict] = self.db.get_all_children(db, id)

     

       268
       268
       +
               for id, data in children.items():

     

       269
       269
       +
                   for ref in data['mapped_post_refs']:

     

       270
       270
       +
                       self.atp.client.delete_post(ref['uri'])

     

       271
       271
       +
                   self.db.del_post(db, id)

     

       272
       272
       +
               self.db.del_post(db, id)

     

       273
       273
       +
               

     

       274
       274
       +
               db.close()

     

       275
       275
       +
               click.echo(f"Removed post '{id}' and {len(children.items())} replies")

     

       276
       276
       +
                   

     

       277
       277
       +
           # TODO Handle edits

     

       278
       278
       +
           # The issue is that since there are no edits on bluesky, 

     

       279
       279
       +
           # we have to recreate the records while keeping the media in tact.

     

       280
       280
       +
           # also, since the db only stores post relations, we have to pull all the replies from masto and the pds.

     

       281
       281
       +
           def on_status_update(self, status: dict):

     

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

     

       283
       283
       +
                   return

     

       284
       284
       +
               if status.get('in_reply_to_account_id') != self.user_id:

     

       285
       285
       +
                   return

     

       286
       286
       +
               

     

       287
       287
       +
               click.echo(f"Got 'status.update' event for post '{status['id']}'")

     

       288
       288
       +
       

     

       289
       289
       +
       @click.group()

     

       290
       290
       +
       def main():

     

       291
       291
       +
           pass

     

       292
       292
       +
       

     

       293
       293
       +
       @main.command('run')

     

       294
       294
       +
       @click.option(

     

       295
       295
       +
           "-I", "--instance",

     

       296
       296
       +
           envvar="MASTODON_INSTANCE",

     

       297
       297
       +
           required=True,

     

       298
       298
       +
           help="Mastodon compatible instance domain (e.g. https://mastodon.social)"

     

       299
       299
       +
       )

     

       300
       300
       +
       @click.option(

     

       301
       301
       +
           "-T", "--token",

     

       302
       302
       +
           envvar="MASTODON_TOKEN",

     

       303
       303
       +
           required=True,

     

       304
       304
       +
           help="Mastodon access token"

     

       305
       305
       +
       )

     

       306
       306
       +
       @click.option(

     

       307
       307
       +
           "-H", "--handle",

     

       308
       308
       +
           envvar="ATPROTO_HANDLE",

     

       309
       309
       +
           required=True,

     

       310
       310
       +
           help="ATProto handle (e.g. melontini.me)"

     

       311
       311
       +
       )

     

       312
       312
       +
       @click.option(

     

       313
       313
       +
           "-P", "--password",

     

       314
       314
       +
           envvar="ATPROTO_PASSWORD",

     

       315
       315
       +
           required=True,

     

       316
       316
       +
           help="ATProto/Bluesky app password (https://bsky.app/settings/app-passwords)"

     

       317
       317
       +
       )

     

       318
       318
       +
       @click.option('--data_dir', default='./data', type=click.Path(exists=True, file_okay=False, dir_okay=True, readable=True, writable=True))

     

       319
       319
       +
       def run(instance, token, handle, password, data_dir):

     

       320
       320
       +
           settings_path = os.path.join(data_dir, 'settings.json')

     

       321
       321
       +
           if not os.path.exists(settings_path):

     

       322
       322
       +
               click.echo(f"First launch detected! creating {settings_path} and exiting..")

     

       323
       323
       +
               

     

       324
       324
       +
               with open(settings_path, 'w') as f:

     

       325
       325
       +
                   json.dump(util.DEFAULT_SETTINGS, f, indent=2)

     

       326
       326
       +
               return 0

     

       327
       327
       +
       

     

       328
       328
       +
           with open(settings_path, 'rb') as f:

     

       329
       329
       +
               settings = json.load(f)

     

       330
       330
       +
           

     

       331
       331
       +
           click.echo(f"Connecting to {instance}...")

     

       332
       332
       +
           fedi = mastodon.Mastodon(instance, token)

     

       333
       333
       +
           

     

       334
       334
       +
           if not fedi.streaming:

     

       335
       335
       +
               click.echo(f"{fedi.instance} does not support streaming timelines!", err=True)

     

       336
       336
       +
               return -1

     

       337
       337
       +
               

     

       338
       338
       +
           id = fedi.get_user_id()

     

       339
       339
       +
           if not id:

     

       340
       340
       +
               click.echo(f"Failed to get user id from token for {fedi.instance}", err=True)

     

       341
       341
       +
               return -1

     

       342
       342
       +
           click.echo(f"Got user ID '{id}'")

     

       343
       343
       +
           

     

       344
       344
       +
           click.echo(f"Resolving ATP identity for {handle}...")

     

       345
       345
       +
           resolver = IdResolver()

     

       346
       346
       +
           did: str | None = resolver.handle.resolve(handle)

     

       347
       347
       +
           if not did:

     

       348
       348
       +
               click.echo(f"Failed to resolve atproto did for handle {handle}!", err=True)

     

       349
       349
       +
               return -1

     

       350
       350
       +
           

     

       351
       351
       +
           did_doc = resolver.did.resolve(did)

     

       352
       352
       +
           if not did_doc:

     

       353
       353
       +
               click.echo(f"Failed to resolve did document from {did}")

     

       354
       354
       +
               return -1

     

       355
       355
       +
           

     

       356
       356
       +
           pds = did_doc.get_pds_endpoint()

     

       357
       357
       +
           if not pds:

     

       358
       358
       +
               click.echo(f"Failed to resolve PDS endpoint for did {did}")

     

       359
       359
       +
               return -1

     

       360
       360
       +
       

     

       361
       361
       +
           click.echo(f"Logging in to {handle} through {pds}...")

     

       362
       362
       +
           atp = Client(pds)

     

       363
       363
       +
           atp.login(handle, password)

     

       364
       364
       +
       

     

       365
       365
       +
           click.echo("Starting worker thread...")

     

       366
       366
       +
           task_queue = queue.Queue()

     

       367
       367
       +
       

     

       368
       368
       +
           def worker():

     

       369
       369
       +
               while True:

     

       370
       370
       +
                   task = task_queue.get()

     

       371
       371
       +
                   if task is None:

     

       372
       372
       +
                       break

     

       373
       373
       +
                   try:

     

       374
       374
       +
                       task()

     

       375
       375
       +
                   except Exception as e:

     

       376
       376
       +
                       click.echo(f"Exception in worker thread!\n{e}", err=True)

     

       377
       377
       +
                       traceback.print_exc()

     

       378
       378
       +
                   

     

       379
       379
       +
           thread = threading.Thread(target=worker, daemon=True)

     

       380
       380
       +
           thread.start()

     

       381
       381
       +
           

     

       382
       382
       +
           click.echo(f"Listening to {fedi.streaming}...")

     

       383
       383
       +
           listener = SocketListener(id, atp, settings, os.path.join(data_dir, 'data.db'))

     

       384
       384
       +
           

     

       385
       385
       +
           def handler(event_type, payload):

     

       386
       386
       +
               def handle_event():

     

       387
       387
       +
                   try:

     

       388
       388
       +
                       if event_type == 'update':

     

       389
       389
       +
                           listener.on_update(json.loads(payload))

     

       390
       390
       +
                       elif event_type == 'delete':

     

       391
       391
       +
                           listener.on_delete(payload)

     

       392
       392
       +
                       elif event_type == 'status.update':

     

       393
       393
       +
                           listener.on_status_update(json.loads(payload))

     

       394
       394
       +
                   except Exception as e:

     

       395
       395
       +
                       click.echo(f"Error in event handler: {e}", err=True)

     

       396
       396
       +
                       traceback.print_exc()

     

       397
       397
       +
               task_queue.put(handle_event)

     

       398
       398
       +
           

     

       399
       399
       +
           asyncio.run(fedi.connect_websocket(handler))

     

       400
       400
       +
           

     

       401
       401
       +
           task_queue.join()

     

       402
       402
       +
           

     

       403
       403
       +
           task_queue.put(None)

     

       404
       404
       +
           thread.join()

     

       405
       405
       +
           return 0

     

       406
       406
       +
       

     

       407
       407
       +
       if __name__ == "__main__":

     

       408
       408
       +
           main()

+37

mastodon.py

···

       1
       1
       +
       import requests, websockets

     

       2
       2
       +
       import util, json

     

       3
       3
       +
       

     

       4
       4
       +
       class Mastodon():

     

       5
       5
       +
           def __init__(self, instance: str, token: str) -> None:

     

       6
       6
       +
               self.token = token

     

       7
       7
       +
               self.instance = instance

     

       8
       8
       +
               self.streaming = self.get_streaming_url()

     

       9
       9
       +
       

     

       10
       10
       +
           def get_streaming_url(self):

     

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

     

       12
       12
       +
               response.raise_for_status()

     

       13
       13
       +
               data: dict = response.json()

     

       14
       14
       +
               return util.safe_get(data, "urls", {}).get("streaming_api")

     

       15
       15
       +
           

     

       16
       16
       +
           def get_user_id(self):

     

       17
       17
       +
               responce = requests.get(f"{self.instance}/api/v1/accounts/verify_credentials", headers={

     

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

     

       19
       19
       +
               })

     

       20
       20
       +
           

     

       21
       21
       +
               if responce.status_code == 401:

     

       22
       22
       +
                   raise Exception("Invalid Mastodon API token provided!")

     

       23
       23
       +
           

     

       24
       24
       +
               return responce.json()["id"]

     

       25
       25
       +
           

     

       26
       26
       +
           async def connect_websocket(self, handler):

     

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

     

       28
       28
       +
               async with websockets.connect(uri, extra_headers={

     

       29
       29
       +
                   "User-Agent": "XPost/0.0.1"

     

       30
       30
       +
               }) as websocket:

     

       31
       31
       +
                   while True:

     

       32
       32
       +
                       message = await websocket.recv()

     

       33
       33
       +
                       event: dict = json.loads(message)

     

       34
       34
       +
                   

     

       35
       35
       +
                       event_type = event.get('event')

     

       36
       36
       +
                       payload = event.get('payload')

     

       37
       37
       +
                       handler(event_type, payload)

+88

media_util.py

···

       1
       1
       +
       import requests

     

       2
       2
       +
       import click

     

       3
       3
       +
       import subprocess

     

       4
       4
       +
       import json

     

       5
       5
       +
       

     

       6
       6
       +
       def probe_bytes(bytes: bytes) -> dict:

     

       7
       7
       +
           cmd = [

     

       8
       8
       +
               'ffprobe',

     

       9
       9
       +
               '-v', 'error',

     

       10
       10
       +
               '-show_format',

     

       11
       11
       +
               '-show_streams',

     

       12
       12
       +
               '-print_format', 'json',

     

       13
       13
       +
               'pipe:0'

     

       14
       14
       +
           ]

     

       15
       15
       +
           proc = subprocess.run(cmd, input=bytes, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

     

       16
       16
       +
       

     

       17
       17
       +
           if proc.returncode != 0:

     

       18
       18
       +
               raise RuntimeError(f"ffprobe failed: {proc.stderr.decode()}")

     

       19
       19
       +
       

     

       20
       20
       +
           return json.loads(proc.stdout)

     

       21
       21
       +
       

     

       22
       22
       +
       def compress_image(image_bytes: bytes):

     

       23
       23
       +
           cmd = [

     

       24
       24
       +
                   'ffmpeg',

     

       25
       25
       +
                   '-f', 'image2pipe',

     

       26
       26
       +
                   '-i', 'pipe:0',

     

       27
       27
       +
                   '-c:v', 'webp',

     

       28
       28
       +
                   '-q:v', '90',

     

       29
       29
       +
                   '-f', 'image2pipe',

     

       30
       30
       +
                   'pipe:1'

     

       31
       31
       +
               ]

     

       32
       32
       +
       

     

       33
       33
       +
           proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

     

       34
       34
       +
           out_bytes, err = proc.communicate(input=image_bytes)

     

       35
       35
       +
           

     

       36
       36
       +
           if proc.returncode != 0:

     

       37
       37
       +
               raise RuntimeError(f"ffmpeg compress failed: {err.decode()}")

     

       38
       38
       +
           

     

       39
       39
       +
           return out_bytes

     

       40
       40
       +
       

     

       41
       41
       +
       def download_blob(url: str, max_bytes: int = 5_000_000) -> bytes | None:

     

       42
       42
       +
           response = requests.get(url, stream=True, timeout=20)

     

       43
       43
       +
           if response.status_code != 200:

     

       44
       44
       +
               click.echo(f"Failed to download {url}! {response}")

     

       45
       45
       +
               return None

     

       46
       46
       +
           

     

       47
       47
       +
           downloaded_bytes = b""

     

       48
       48
       +
           current_size = 0

     

       49
       49
       +
           

     

       50
       50
       +
           for chunk in response.iter_content(chunk_size=8192):

     

       51
       51
       +
               if not chunk: 

     

       52
       52
       +
                   continue

     

       53
       53
       +
               

     

       54
       54
       +
               current_size += len(chunk)

     

       55
       55
       +
               if current_size > max_bytes:

     

       56
       56
       +
                   click.echo(f"Failed to download {url}, file too large!")

     

       57
       57
       +
                   response.close()

     

       58
       58
       +
                   return None

     

       59
       59
       +
               

     

       60
       60
       +
               downloaded_bytes += chunk

     

       61
       61
       +
           

     

       62
       62
       +
           return downloaded_bytes

     

       63
       63
       +
           

     

       64
       64
       +
       

     

       65
       65
       +
       def get_video_meta(video_bytes: bytes):

     

       66
       66
       +
           probe = probe_bytes(video_bytes)

     

       67
       67
       +
           video_streams = [s for s in probe['streams'] if s['codec_type'] == 'video']

     

       68
       68
       +
           if not video_streams:

     

       69
       69
       +
               raise ValueError("No video stream found")

     

       70
       70
       +
               

     

       71
       71
       +
           video = video_streams[0]

     

       72
       72
       +
           return {

     

       73
       73
       +
               'width': int(video['width']),

     

       74
       74
       +
               'height': int(video['height']),

     

       75
       75
       +
               'duration': float(video.get('duration', probe['format'].get('duration', -1)))

     

       76
       76
       +
           }

     

       77
       77
       +
       

     

       78
       78
       +
       def get_image_meta(image_bytes: bytes):

     

       79
       79
       +
           probe = probe_bytes(image_bytes)

     

       80
       80
       +
           stream = next((s for s in probe['streams'] if s['codec_type'] == 'video'), None)

     

       81
       81
       +
               

     

       82
       82
       +
           if not stream:

     

       83
       83
       +
               raise ValueError("No video stream found")

     

       84
       84
       +
               

     

       85
       85
       +
           return {

     

       86
       86
       +
               'width': int(stream['width']),

     

       87
       87
       +
               'height': int(stream['height'])

     

       88
       88
       +
           }

+11

pyproject.toml

···

       1
       1
       +
       [project]

     

       2
       2
       +
       name = "xpost"

     

       3
       3
       +
       version = "0.0.1"

     

       4
       4
       +
       description = "mastodon -> bluesky crossposting tool"

     

       5
       5
       +
       readme = "README.md"

     

       6
       6
       +
       requires-python = ">=3.12"

     

       7
       7
       +
       dependencies = [

     

       8
       8
       +
           "atproto>=0.0.61",

     

       9
       9
       +
           "click>=8.2.1",

     

       10
       10
       +
           "requests>=2.32.3",

     

       11
       11
       +
       ]

+92

util.py

···

       1
       1
       +
       import re, html

     

       2
       2
       +
       

     

       3
       3
       +
       NEWLINE = re.compile(r'</p>|<br\s*/?>', re.IGNORECASE)

     

       4
       4
       +
       NON_ANCHORS = re.compile(r'(?i)</?(?!a\b)[a-z][^>]*>')

     

       5
       5
       +
       ANCHORS = re.compile(r'<a\s+[^>]*href=["\'](.*?)["\'][^>]*>(.*?)</a>', re.IGNORECASE)

     

       6
       6
       +
       

     

       7
       7
       +
       DEFAULT_SETTINGS: dict = {

     

       8
       8
       +
           'bluesky': {

     

       9
       9
       +
               'quote_gate': False,

     

       10
       10
       +
               'thread_gate': [

     

       11
       11
       +
                   'everybody'

     

       12
       12
       +
               ]

     

       13
       13
       +
           }

     

       14
       14
       +
       }

     

       15
       15
       +
       

     

       16
       16
       +
       def tokenize_html(content: str) -> list[dict]:

     

       17
       17
       +
           text = content.replace('<p>', '')

     

       18
       18
       +
           text = NEWLINE.sub('\n', text)

     

       19
       19
       +
           text = html.unescape(text)

     

       20
       20
       +
           text = NON_ANCHORS.sub('', text)

     

       21
       21
       +
           text = text.rstrip('\n')

     

       22
       22
       +
       

     

       23
       23
       +
           tokens = []

     

       24
       24
       +
           pos = 0

     

       25
       25
       +
       

     

       26
       26
       +
           for anchor in ANCHORS.finditer(text):

     

       27
       27
       +
               start, end = anchor.span()

     

       28
       28
       +
               

     

       29
       29
       +
               if start > pos:

     

       30
       30
       +
                   tokens.append({"type": "text", "value": text[pos:start]})

     

       31
       31
       +
       

     

       32
       32
       +
               href = anchor.group(1).strip()

     

       33
       33
       +
               label = anchor.group(2).strip()

     

       34
       34
       +
       

     

       35
       35
       +
               if label.startswith("#"):

     

       36
       36
       +
                   tokens.append({"type": "hashtag", "value": label})

     

       37
       37
       +
               elif label.startswith("@"):

     

       38
       38
       +
                   tokens.append({"type": "mention", "value": label})

     

       39
       39
       +
               else:

     

       40
       40
       +
                   tokens.append({"type": "link", "value": href, "label": label})

     

       41
       41
       +
       

     

       42
       42
       +
               pos = end

     

       43
       43
       +
       

     

       44
       44
       +
           if pos < len(text):

     

       45
       45
       +
               tokens.append({"type": "text", "value": text[pos:]})

     

       46
       46
       +
       

     

       47
       47
       +
           return tokens

     

       48
       48
       +
       

     

       49
       49
       +
       def split_tokens(tokens: list[dict], max_chars: int) -> list[list[dict]]:

     

       50
       50
       +
           chunks = []

     

       51
       51
       +
           current_chunk = []

     

       52
       52
       +
           current_length = 0

     

       53
       53
       +
       

     

       54
       54
       +
           for token in tokens:

     

       55
       55
       +
               token_type = token["type"]

     

       56
       56
       +
               value = token["value"]

     

       57
       57
       +
       

     

       58
       58
       +
               val_len = len(value)

     

       59
       59
       +
       

     

       60
       60
       +
               if token_type != "text":

     

       61
       61
       +
                   if current_length + val_len > max_chars:

     

       62
       62
       +
                       if current_chunk:

     

       63
       63
       +
                           chunks.append(current_chunk)

     

       64
       64
       +
                       current_chunk = [token]

     

       65
       65
       +
                       current_length = val_len

     

       66
       66
       +
                   else:

     

       67
       67
       +
                       current_chunk.append(token)

     

       68
       68
       +
                       current_length += val_len

     

       69
       69
       +
               else:

     

       70
       70
       +
                   start = 0

     

       71
       71
       +
                   while start < val_len:

     

       72
       72
       +
                       space_left = max_chars - current_length

     

       73
       73
       +
                       if space_left == 0:

     

       74
       74
       +
                           chunks.append(current_chunk)

     

       75
       75
       +
                           current_chunk = []

     

       76
       76
       +
                           current_length = 0

     

       77
       77
       +
                           space_left = max_chars

     

       78
       78
       +
       

     

       79
       79
       +
                       end = min(start + space_left, val_len)

     

       80
       80
       +
                       piece = value[start:end]

     

       81
       81
       +
                       current_chunk.append({"type": "text", "value": piece})

     

       82
       82
       +
                       current_length += len(piece)

     

       83
       83
       +
                       start = end

     

       84
       84
       +
       

     

       85
       85
       +
           if current_chunk:

     

       86
       86
       +
               chunks.append(current_chunk)

     

       87
       87
       +
       

     

       88
       88
       +
           return chunks

     

       89
       89
       +
       

     

       90
       90
       +
       def safe_get(obj: dict, key: str, default):

     

       91
       91
       +
           val = obj.get(key, default)

     

       92
       92
       +
           return val if val else default

+435

uv.lock

···

       1
       1
       +
       version = 1

     

       2
       2
       +
       revision = 2

     

       3
       3
       +
       requires-python = ">=3.12"

     

       4
       4
       +
       

     

       5
       5
       +
       [[package]]

     

       6
       6
       +
       name = "annotated-types"

     

       7
       7
       +
       version = "0.7.0"

     

       8
       8
       +
       source = { registry = "https://pypi.org/simple" }

     

       9
       9
       +
       sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }

     

       10
       10
       +
       wheels = [

     

       11
       11
       +
           { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },

     

       12
       12
       +
       ]

     

       13
       13
       +
       

     

       14
       14
       +
       [[package]]

     

       15
       15
       +
       name = "anyio"

     

       16
       16
       +
       version = "4.9.0"

     

       17
       17
       +
       source = { registry = "https://pypi.org/simple" }

     

       18
       18
       +
       dependencies = [

     

       19
       19
       +
           { name = "idna" },

     

       20
       20
       +
           { name = "sniffio" },

     

       21
       21
       +
           { name = "typing-extensions", marker = "python_full_version < '3.13'" },

     

       22
       22
       +
       ]

     

       23
       23
       +
       sdist = { url = "https://files.pythonhosted.org/packages/95/7d/4c1bd541d4dffa1b52bd83fb8527089e097a106fc90b467a7313b105f840/anyio-4.9.0.tar.gz", hash = "sha256:673c0c244e15788651a4ff38710fea9675823028a6f08a5eda409e0c9840a028", size = 190949, upload-time = "2025-03-17T00:02:54.77Z" }

     

       24
       24
       +
       wheels = [

     

       25
       25
       +
           { url = "https://files.pythonhosted.org/packages/a1/ee/48ca1a7c89ffec8b6a0c5d02b89c305671d5ffd8d3c94acf8b8c408575bb/anyio-4.9.0-py3-none-any.whl", hash = "sha256:9f76d541cad6e36af7beb62e978876f3b41e3e04f2c1fbf0884604c0a9c4d93c", size = 100916, upload-time = "2025-03-17T00:02:52.713Z" },

     

       26
       26
       +
       ]

     

       27
       27
       +
       

     

       28
       28
       +
       [[package]]

     

       29
       29
       +
       name = "atproto"

     

       30
       30
       +
       version = "0.0.61"

     

       31
       31
       +
       source = { registry = "https://pypi.org/simple" }

     

       32
       32
       +
       dependencies = [

     

       33
       33
       +
           { name = "click" },

     

       34
       34
       +
           { name = "cryptography" },

     

       35
       35
       +
           { name = "dnspython" },

     

       36
       36
       +
           { name = "httpx" },

     

       37
       37
       +
           { name = "libipld" },

     

       38
       38
       +
           { name = "pydantic" },

     

       39
       39
       +
           { name = "typing-extensions" },

     

       40
       40
       +
           { name = "websockets" },

     

       41
       41
       +
       ]

     

       42
       42
       +
       sdist = { url = "https://files.pythonhosted.org/packages/b1/59/6f5074b3a45e0e3c1853544240e9039e86219feb30ff1bb5e8582c791547/atproto-0.0.61.tar.gz", hash = "sha256:98e022daf538d14f134ce7c91d42c4c973f3493ac56e43a84daa4c881f102beb", size = 189208, upload-time = "2025-04-19T00:20:11.918Z" }

     

       43
       43
       +
       wheels = [

     

       44
       44
       +
           { url = "https://files.pythonhosted.org/packages/bd/b6/da9963bf54d4c0a8a590b6297d8858c395243dbb04cb581fdadb5fe7eac7/atproto-0.0.61-py3-none-any.whl", hash = "sha256:658da5832aaeea4a12a9a74235f9c90c11453e77d596fdccb1f8b39d56245b88", size = 380426, upload-time = "2025-04-19T00:20:10.026Z" },

     

       45
       45
       +
       ]

     

       46
       46
       +
       

     

       47
       47
       +
       [[package]]

     

       48
       48
       +
       name = "certifi"

     

       49
       49
       +
       version = "2025.4.26"

     

       50
       50
       +
       source = { registry = "https://pypi.org/simple" }

     

       51
       51
       +
       sdist = { url = "https://files.pythonhosted.org/packages/e8/9e/c05b3920a3b7d20d3d3310465f50348e5b3694f4f88c6daf736eef3024c4/certifi-2025.4.26.tar.gz", hash = "sha256:0a816057ea3cdefcef70270d2c515e4506bbc954f417fa5ade2021213bb8f0c6", size = 160705, upload-time = "2025-04-26T02:12:29.51Z" }

     

       52
       52
       +
       wheels = [

     

       53
       53
       +
           { url = "https://files.pythonhosted.org/packages/4a/7e/3db2bd1b1f9e95f7cddca6d6e75e2f2bd9f51b1246e546d88addca0106bd/certifi-2025.4.26-py3-none-any.whl", hash = "sha256:30350364dfe371162649852c63336a15c70c6510c2ad5015b21c2345311805f3", size = 159618, upload-time = "2025-04-26T02:12:27.662Z" },

     

       54
       54
       +
       ]

     

       55
       55
       +
       

     

       56
       56
       +
       [[package]]

     

       57
       57
       +
       name = "cffi"

     

       58
       58
       +
       version = "1.17.1"

     

       59
       59
       +
       source = { registry = "https://pypi.org/simple" }

     

       60
       60
       +
       dependencies = [

     

       61
       61
       +
           { name = "pycparser" },

     

       62
       62
       +
       ]

     

       63
       63
       +
       sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload-time = "2024-09-04T20:45:21.852Z" }

     

       64
       64
       +
       wheels = [

     

       65
       65
       +
           { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178, upload-time = "2024-09-04T20:44:12.232Z" },

     

       66
       66
       +
           { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840, upload-time = "2024-09-04T20:44:13.739Z" },

     

       67
       67
       +
           { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803, upload-time = "2024-09-04T20:44:15.231Z" },

     

       68
       68
       +
           { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850, upload-time = "2024-09-04T20:44:17.188Z" },

     

       69
       69
       +
           { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729, upload-time = "2024-09-04T20:44:18.688Z" },

     

       70
       70
       +
           { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256, upload-time = "2024-09-04T20:44:20.248Z" },

     

       71
       71
       +
           { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424, upload-time = "2024-09-04T20:44:21.673Z" },

     

       72
       72
       +
           { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568, upload-time = "2024-09-04T20:44:23.245Z" },

     

       73
       73
       +
           { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736, upload-time = "2024-09-04T20:44:24.757Z" },

     

       74
       74
       +
           { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload-time = "2024-09-04T20:44:26.208Z" },

     

       75
       75
       +
           { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload-time = "2024-09-04T20:44:27.578Z" },

     

       76
       76
       +
           { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989, upload-time = "2024-09-04T20:44:28.956Z" },

     

       77
       77
       +
           { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802, upload-time = "2024-09-04T20:44:30.289Z" },

     

       78
       78
       +
           { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792, upload-time = "2024-09-04T20:44:32.01Z" },

     

       79
       79
       +
           { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893, upload-time = "2024-09-04T20:44:33.606Z" },

     

       80
       80
       +
           { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810, upload-time = "2024-09-04T20:44:35.191Z" },

     

       81
       81
       +
           { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200, upload-time = "2024-09-04T20:44:36.743Z" },

     

       82
       82
       +
           { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447, upload-time = "2024-09-04T20:44:38.492Z" },

     

       83
       83
       +
           { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358, upload-time = "2024-09-04T20:44:40.046Z" },

     

       84
       84
       +
           { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469, upload-time = "2024-09-04T20:44:41.616Z" },

     

       85
       85
       +
           { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475, upload-time = "2024-09-04T20:44:43.733Z" },

     

       86
       86
       +
           { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009, upload-time = "2024-09-04T20:44:45.309Z" },

     

       87
       87
       +
       ]

     

       88
       88
       +
       

     

       89
       89
       +
       [[package]]

     

       90
       90
       +
       name = "charset-normalizer"

     

       91
       91
       +
       version = "3.4.2"

     

       92
       92
       +
       source = { registry = "https://pypi.org/simple" }

     

       93
       93
       +
       sdist = { url = "https://files.pythonhosted.org/packages/e4/33/89c2ced2b67d1c2a61c19c6751aa8902d46ce3dacb23600a283619f5a12d/charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63", size = 126367, upload-time = "2025-05-02T08:34:42.01Z" }

     

       94
       94
       +
       wheels = [

     

       95
       95
       +
           { url = "https://files.pythonhosted.org/packages/d7/a4/37f4d6035c89cac7930395a35cc0f1b872e652eaafb76a6075943754f095/charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7", size = 199936, upload-time = "2025-05-02T08:32:33.712Z" },

     

       96
       96
       +
           { url = "https://files.pythonhosted.org/packages/ee/8a/1a5e33b73e0d9287274f899d967907cd0bf9c343e651755d9307e0dbf2b3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3", size = 143790, upload-time = "2025-05-02T08:32:35.768Z" },

     

       97
       97
       +
           { url = "https://files.pythonhosted.org/packages/66/52/59521f1d8e6ab1482164fa21409c5ef44da3e9f653c13ba71becdd98dec3/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a", size = 153924, upload-time = "2025-05-02T08:32:37.284Z" },

     

       98
       98
       +
           { url = "https://files.pythonhosted.org/packages/86/2d/fb55fdf41964ec782febbf33cb64be480a6b8f16ded2dbe8db27a405c09f/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214", size = 146626, upload-time = "2025-05-02T08:32:38.803Z" },

     

       99
       99
       +
           { url = "https://files.pythonhosted.org/packages/8c/73/6ede2ec59bce19b3edf4209d70004253ec5f4e319f9a2e3f2f15601ed5f7/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a", size = 148567, upload-time = "2025-05-02T08:32:40.251Z" },

     

       100
       100
       +
           { url = "https://files.pythonhosted.org/packages/09/14/957d03c6dc343c04904530b6bef4e5efae5ec7d7990a7cbb868e4595ee30/charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd", size = 150957, upload-time = "2025-05-02T08:32:41.705Z" },

     

       101
       101
       +
           { url = "https://files.pythonhosted.org/packages/0d/c8/8174d0e5c10ccebdcb1b53cc959591c4c722a3ad92461a273e86b9f5a302/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981", size = 145408, upload-time = "2025-05-02T08:32:43.709Z" },

     

       102
       102
       +
           { url = "https://files.pythonhosted.org/packages/58/aa/8904b84bc8084ac19dc52feb4f5952c6df03ffb460a887b42615ee1382e8/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c", size = 153399, upload-time = "2025-05-02T08:32:46.197Z" },

     

       103
       103
       +
           { url = "https://files.pythonhosted.org/packages/c2/26/89ee1f0e264d201cb65cf054aca6038c03b1a0c6b4ae998070392a3ce605/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b", size = 156815, upload-time = "2025-05-02T08:32:48.105Z" },

     

       104
       104
       +
           { url = "https://files.pythonhosted.org/packages/fd/07/68e95b4b345bad3dbbd3a8681737b4338ff2c9df29856a6d6d23ac4c73cb/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d", size = 154537, upload-time = "2025-05-02T08:32:49.719Z" },

     

       105
       105
       +
           { url = "https://files.pythonhosted.org/packages/77/1a/5eefc0ce04affb98af07bc05f3bac9094513c0e23b0562d64af46a06aae4/charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f", size = 149565, upload-time = "2025-05-02T08:32:51.404Z" },

     

       106
       106
       +
           { url = "https://files.pythonhosted.org/packages/37/a0/2410e5e6032a174c95e0806b1a6585eb21e12f445ebe239fac441995226a/charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c", size = 98357, upload-time = "2025-05-02T08:32:53.079Z" },

     

       107
       107
       +
           { url = "https://files.pythonhosted.org/packages/6c/4f/c02d5c493967af3eda9c771ad4d2bbc8df6f99ddbeb37ceea6e8716a32bc/charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e", size = 105776, upload-time = "2025-05-02T08:32:54.573Z" },

     

       108
       108
       +
           { url = "https://files.pythonhosted.org/packages/ea/12/a93df3366ed32db1d907d7593a94f1fe6293903e3e92967bebd6950ed12c/charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0", size = 199622, upload-time = "2025-05-02T08:32:56.363Z" },

     

       109
       109
       +
           { url = "https://files.pythonhosted.org/packages/04/93/bf204e6f344c39d9937d3c13c8cd5bbfc266472e51fc8c07cb7f64fcd2de/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf", size = 143435, upload-time = "2025-05-02T08:32:58.551Z" },

     

       110
       110
       +
           { url = "https://files.pythonhosted.org/packages/22/2a/ea8a2095b0bafa6c5b5a55ffdc2f924455233ee7b91c69b7edfcc9e02284/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e", size = 153653, upload-time = "2025-05-02T08:33:00.342Z" },

     

       111
       111
       +
           { url = "https://files.pythonhosted.org/packages/b6/57/1b090ff183d13cef485dfbe272e2fe57622a76694061353c59da52c9a659/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1", size = 146231, upload-time = "2025-05-02T08:33:02.081Z" },

     

       112
       112
       +
           { url = "https://files.pythonhosted.org/packages/e2/28/ffc026b26f441fc67bd21ab7f03b313ab3fe46714a14b516f931abe1a2d8/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c", size = 148243, upload-time = "2025-05-02T08:33:04.063Z" },

     

       113
       113
       +
           { url = "https://files.pythonhosted.org/packages/c0/0f/9abe9bd191629c33e69e47c6ef45ef99773320e9ad8e9cb08b8ab4a8d4cb/charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691", size = 150442, upload-time = "2025-05-02T08:33:06.418Z" },

     

       114
       114
       +
           { url = "https://files.pythonhosted.org/packages/67/7c/a123bbcedca91d5916c056407f89a7f5e8fdfce12ba825d7d6b9954a1a3c/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0", size = 145147, upload-time = "2025-05-02T08:33:08.183Z" },

     

       115
       115
       +
           { url = "https://files.pythonhosted.org/packages/ec/fe/1ac556fa4899d967b83e9893788e86b6af4d83e4726511eaaad035e36595/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b", size = 153057, upload-time = "2025-05-02T08:33:09.986Z" },

     

       116
       116
       +
           { url = "https://files.pythonhosted.org/packages/2b/ff/acfc0b0a70b19e3e54febdd5301a98b72fa07635e56f24f60502e954c461/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff", size = 156454, upload-time = "2025-05-02T08:33:11.814Z" },

     

       117
       117
       +
           { url = "https://files.pythonhosted.org/packages/92/08/95b458ce9c740d0645feb0e96cea1f5ec946ea9c580a94adfe0b617f3573/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b", size = 154174, upload-time = "2025-05-02T08:33:13.707Z" },

     

       118
       118
       +
           { url = "https://files.pythonhosted.org/packages/78/be/8392efc43487ac051eee6c36d5fbd63032d78f7728cb37aebcc98191f1ff/charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148", size = 149166, upload-time = "2025-05-02T08:33:15.458Z" },

     

       119
       119
       +
           { url = "https://files.pythonhosted.org/packages/44/96/392abd49b094d30b91d9fbda6a69519e95802250b777841cf3bda8fe136c/charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7", size = 98064, upload-time = "2025-05-02T08:33:17.06Z" },

     

       120
       120
       +
           { url = "https://files.pythonhosted.org/packages/e9/b0/0200da600134e001d91851ddc797809e2fe0ea72de90e09bec5a2fbdaccb/charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980", size = 105641, upload-time = "2025-05-02T08:33:18.753Z" },

     

       121
       121
       +
           { url = "https://files.pythonhosted.org/packages/20/94/c5790835a017658cbfabd07f3bfb549140c3ac458cfc196323996b10095a/charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0", size = 52626, upload-time = "2025-05-02T08:34:40.053Z" },

     

       122
       122
       +
       ]

     

       123
       123
       +
       

     

       124
       124
       +
       [[package]]

     

       125
       125
       +
       name = "click"

     

       126
       126
       +
       version = "8.2.1"

     

       127
       127
       +
       source = { registry = "https://pypi.org/simple" }

     

       128
       128
       +
       dependencies = [

     

       129
       129
       +
           { name = "colorama", marker = "sys_platform == 'win32'" },

     

       130
       130
       +
       ]

     

       131
       131
       +
       sdist = { url = "https://files.pythonhosted.org/packages/60/6c/8ca2efa64cf75a977a0d7fac081354553ebe483345c734fb6b6515d96bbc/click-8.2.1.tar.gz", hash = "sha256:27c491cc05d968d271d5a1db13e3b5a184636d9d930f148c50b038f0d0646202", size = 286342, upload-time = "2025-05-20T23:19:49.832Z" }

     

       132
       132
       +
       wheels = [

     

       133
       133
       +
           { url = "https://files.pythonhosted.org/packages/85/32/10bb5764d90a8eee674e9dc6f4db6a0ab47c8c4d0d83c27f7c39ac415a4d/click-8.2.1-py3-none-any.whl", hash = "sha256:61a3265b914e850b85317d0b3109c7f8cd35a670f963866005d6ef1d5175a12b", size = 102215, upload-time = "2025-05-20T23:19:47.796Z" },

     

       134
       134
       +
       ]

     

       135
       135
       +
       

     

       136
       136
       +
       [[package]]

     

       137
       137
       +
       name = "colorama"

     

       138
       138
       +
       version = "0.4.6"

     

       139
       139
       +
       source = { registry = "https://pypi.org/simple" }

     

       140
       140
       +
       sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }

     

       141
       141
       +
       wheels = [

     

       142
       142
       +
           { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },

     

       143
       143
       +
       ]

     

       144
       144
       +
       

     

       145
       145
       +
       [[package]]

     

       146
       146
       +
       name = "cryptography"

     

       147
       147
       +
       version = "45.0.3"

     

       148
       148
       +
       source = { registry = "https://pypi.org/simple" }

     

       149
       149
       +
       dependencies = [

     

       150
       150
       +
           { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },

     

       151
       151
       +
       ]

     

       152
       152
       +
       sdist = { url = "https://files.pythonhosted.org/packages/13/1f/9fa001e74a1993a9cadd2333bb889e50c66327b8594ac538ab8a04f915b7/cryptography-45.0.3.tar.gz", hash = "sha256:ec21313dd335c51d7877baf2972569f40a4291b76a0ce51391523ae358d05899", size = 744738, upload-time = "2025-05-25T14:17:24.777Z" }

     

       153
       153
       +
       wheels = [

     

       154
       154
       +
           { url = "https://files.pythonhosted.org/packages/82/b2/2345dc595998caa6f68adf84e8f8b50d18e9fc4638d32b22ea8daedd4b7a/cryptography-45.0.3-cp311-abi3-macosx_10_9_universal2.whl", hash = "sha256:7573d9eebaeceeb55285205dbbb8753ac1e962af3d9640791d12b36864065e71", size = 7056239, upload-time = "2025-05-25T14:16:12.22Z" },

     

       155
       155
       +
           { url = "https://files.pythonhosted.org/packages/71/3d/ac361649a0bfffc105e2298b720d8b862330a767dab27c06adc2ddbef96a/cryptography-45.0.3-cp311-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d377dde61c5d67eb4311eace661c3efda46c62113ff56bf05e2d679e02aebb5b", size = 4205541, upload-time = "2025-05-25T14:16:14.333Z" },

     

       156
       156
       +
           { url = "https://files.pythonhosted.org/packages/70/3e/c02a043750494d5c445f769e9c9f67e550d65060e0bfce52d91c1362693d/cryptography-45.0.3-cp311-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fae1e637f527750811588e4582988932c222f8251f7b7ea93739acb624e1487f", size = 4433275, upload-time = "2025-05-25T14:16:16.421Z" },

     

       157
       157
       +
           { url = "https://files.pythonhosted.org/packages/40/7a/9af0bfd48784e80eef3eb6fd6fde96fe706b4fc156751ce1b2b965dada70/cryptography-45.0.3-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ca932e11218bcc9ef812aa497cdf669484870ecbcf2d99b765d6c27a86000942", size = 4209173, upload-time = "2025-05-25T14:16:18.163Z" },

     

       158
       158
       +
           { url = "https://files.pythonhosted.org/packages/31/5f/d6f8753c8708912df52e67969e80ef70b8e8897306cd9eb8b98201f8c184/cryptography-45.0.3-cp311-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:af3f92b1dc25621f5fad065288a44ac790c5798e986a34d393ab27d2b27fcff9", size = 3898150, upload-time = "2025-05-25T14:16:20.34Z" },

     

       159
       159
       +
           { url = "https://files.pythonhosted.org/packages/8b/50/f256ab79c671fb066e47336706dc398c3b1e125f952e07d54ce82cf4011a/cryptography-45.0.3-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2f8f8f0b73b885ddd7f3d8c2b2234a7d3ba49002b0223f58cfde1bedd9563c56", size = 4466473, upload-time = "2025-05-25T14:16:22.605Z" },

     

       160
       160
       +
           { url = "https://files.pythonhosted.org/packages/62/e7/312428336bb2df0848d0768ab5a062e11a32d18139447a76dfc19ada8eed/cryptography-45.0.3-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:9cc80ce69032ffa528b5e16d217fa4d8d4bb7d6ba8659c1b4d74a1b0f4235fca", size = 4211890, upload-time = "2025-05-25T14:16:24.738Z" },

     

       161
       161
       +
           { url = "https://files.pythonhosted.org/packages/e7/53/8a130e22c1e432b3c14896ec5eb7ac01fb53c6737e1d705df7e0efb647c6/cryptography-45.0.3-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:c824c9281cb628015bfc3c59335163d4ca0540d49de4582d6c2637312907e4b1", size = 4466300, upload-time = "2025-05-25T14:16:26.768Z" },

     

       162
       162
       +
           { url = "https://files.pythonhosted.org/packages/ba/75/6bb6579688ef805fd16a053005fce93944cdade465fc92ef32bbc5c40681/cryptography-45.0.3-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:5833bb4355cb377ebd880457663a972cd044e7f49585aee39245c0d592904578", size = 4332483, upload-time = "2025-05-25T14:16:28.316Z" },

     

       163
       163
       +
           { url = "https://files.pythonhosted.org/packages/2f/11/2538f4e1ce05c6c4f81f43c1ef2bd6de7ae5e24ee284460ff6c77e42ca77/cryptography-45.0.3-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9bb5bf55dcb69f7067d80354d0a348368da907345a2c448b0babc4215ccd3497", size = 4573714, upload-time = "2025-05-25T14:16:30.474Z" },

     

       164
       164
       +
           { url = "https://files.pythonhosted.org/packages/f5/bb/e86e9cf07f73a98d84a4084e8fd420b0e82330a901d9cac8149f994c3417/cryptography-45.0.3-cp311-abi3-win32.whl", hash = "sha256:3ad69eeb92a9de9421e1f6685e85a10fbcfb75c833b42cc9bc2ba9fb00da4710", size = 2934752, upload-time = "2025-05-25T14:16:32.204Z" },

     

       165
       165
       +
           { url = "https://files.pythonhosted.org/packages/c7/75/063bc9ddc3d1c73e959054f1fc091b79572e716ef74d6caaa56e945b4af9/cryptography-45.0.3-cp311-abi3-win_amd64.whl", hash = "sha256:97787952246a77d77934d41b62fb1b6f3581d83f71b44796a4158d93b8f5c490", size = 3412465, upload-time = "2025-05-25T14:16:33.888Z" },

     

       166
       166
       +
           { url = "https://files.pythonhosted.org/packages/71/9b/04ead6015229a9396890d7654ee35ef630860fb42dc9ff9ec27f72157952/cryptography-45.0.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:c92519d242703b675ccefd0f0562eb45e74d438e001f8ab52d628e885751fb06", size = 7031892, upload-time = "2025-05-25T14:16:36.214Z" },

     

       167
       167
       +
           { url = "https://files.pythonhosted.org/packages/46/c7/c7d05d0e133a09fc677b8a87953815c522697bdf025e5cac13ba419e7240/cryptography-45.0.3-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5edcb90da1843df85292ef3a313513766a78fbbb83f584a5a58fb001a5a9d57", size = 4196181, upload-time = "2025-05-25T14:16:37.934Z" },

     

       168
       168
       +
           { url = "https://files.pythonhosted.org/packages/08/7a/6ad3aa796b18a683657cef930a986fac0045417e2dc428fd336cfc45ba52/cryptography-45.0.3-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:38deed72285c7ed699864f964a3f4cf11ab3fb38e8d39cfcd96710cd2b5bb716", size = 4423370, upload-time = "2025-05-25T14:16:39.502Z" },

     

       169
       169
       +
           { url = "https://files.pythonhosted.org/packages/4f/58/ec1461bfcb393525f597ac6a10a63938d18775b7803324072974b41a926b/cryptography-45.0.3-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:5555365a50efe1f486eed6ac7062c33b97ccef409f5970a0b6f205a7cfab59c8", size = 4197839, upload-time = "2025-05-25T14:16:41.322Z" },

     

       170
       170
       +
           { url = "https://files.pythonhosted.org/packages/d4/3d/5185b117c32ad4f40846f579369a80e710d6146c2baa8ce09d01612750db/cryptography-45.0.3-cp37-abi3-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9e4253ed8f5948a3589b3caee7ad9a5bf218ffd16869c516535325fece163dcc", size = 3886324, upload-time = "2025-05-25T14:16:43.041Z" },

     

       171
       171
       +
           { url = "https://files.pythonhosted.org/packages/67/85/caba91a57d291a2ad46e74016d1f83ac294f08128b26e2a81e9b4f2d2555/cryptography-45.0.3-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:cfd84777b4b6684955ce86156cfb5e08d75e80dc2585e10d69e47f014f0a5342", size = 4450447, upload-time = "2025-05-25T14:16:44.759Z" },

     

       172
       172
       +
           { url = "https://files.pythonhosted.org/packages/ae/d1/164e3c9d559133a38279215c712b8ba38e77735d3412f37711b9f8f6f7e0/cryptography-45.0.3-cp37-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:a2b56de3417fd5f48773ad8e91abaa700b678dc7fe1e0c757e1ae340779acf7b", size = 4200576, upload-time = "2025-05-25T14:16:46.438Z" },

     

       173
       173
       +
           { url = "https://files.pythonhosted.org/packages/71/7a/e002d5ce624ed46dfc32abe1deff32190f3ac47ede911789ee936f5a4255/cryptography-45.0.3-cp37-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:57a6500d459e8035e813bd8b51b671977fb149a8c95ed814989da682314d0782", size = 4450308, upload-time = "2025-05-25T14:16:48.228Z" },

     

       174
       174
       +
           { url = "https://files.pythonhosted.org/packages/87/ad/3fbff9c28cf09b0a71e98af57d74f3662dea4a174b12acc493de00ea3f28/cryptography-45.0.3-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:f22af3c78abfbc7cbcdf2c55d23c3e022e1a462ee2481011d518c7fb9c9f3d65", size = 4325125, upload-time = "2025-05-25T14:16:49.844Z" },

     

       175
       175
       +
           { url = "https://files.pythonhosted.org/packages/f5/b4/51417d0cc01802304c1984d76e9592f15e4801abd44ef7ba657060520bf0/cryptography-45.0.3-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:232954730c362638544758a8160c4ee1b832dc011d2c41a306ad8f7cccc5bb0b", size = 4560038, upload-time = "2025-05-25T14:16:51.398Z" },

     

       176
       176
       +
           { url = "https://files.pythonhosted.org/packages/80/38/d572f6482d45789a7202fb87d052deb7a7b136bf17473ebff33536727a2c/cryptography-45.0.3-cp37-abi3-win32.whl", hash = "sha256:cb6ab89421bc90e0422aca911c69044c2912fc3debb19bb3c1bfe28ee3dff6ab", size = 2924070, upload-time = "2025-05-25T14:16:53.472Z" },

     

       177
       177
       +
           { url = "https://files.pythonhosted.org/packages/91/5a/61f39c0ff4443651cc64e626fa97ad3099249152039952be8f344d6b0c86/cryptography-45.0.3-cp37-abi3-win_amd64.whl", hash = "sha256:d54ae41e6bd70ea23707843021c778f151ca258081586f0cfa31d936ae43d1b2", size = 3395005, upload-time = "2025-05-25T14:16:55.134Z" },

     

       178
       178
       +
       ]

     

       179
       179
       +
       

     

       180
       180
       +
       [[package]]

     

       181
       181
       +
       name = "dnspython"

     

       182
       182
       +
       version = "2.7.0"

     

       183
       183
       +
       source = { registry = "https://pypi.org/simple" }

     

       184
       184
       +
       sdist = { url = "https://files.pythonhosted.org/packages/b5/4a/263763cb2ba3816dd94b08ad3a33d5fdae34ecb856678773cc40a3605829/dnspython-2.7.0.tar.gz", hash = "sha256:ce9c432eda0dc91cf618a5cedf1a4e142651196bbcd2c80e89ed5a907e5cfaf1", size = 345197, upload-time = "2024-10-05T20:14:59.362Z" }

     

       185
       185
       +
       wheels = [

     

       186
       186
       +
           { url = "https://files.pythonhosted.org/packages/68/1b/e0a87d256e40e8c888847551b20a017a6b98139178505dc7ffb96f04e954/dnspython-2.7.0-py3-none-any.whl", hash = "sha256:b4c34b7d10b51bcc3a5071e7b8dee77939f1e878477eeecc965e9835f63c6c86", size = 313632, upload-time = "2024-10-05T20:14:57.687Z" },

     

       187
       187
       +
       ]

     

       188
       188
       +
       

     

       189
       189
       +
       [[package]]

     

       190
       190
       +
       name = "h11"

     

       191
       191
       +
       version = "0.16.0"

     

       192
       192
       +
       source = { registry = "https://pypi.org/simple" }

     

       193
       193
       +
       sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }

     

       194
       194
       +
       wheels = [

     

       195
       195
       +
           { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },

     

       196
       196
       +
       ]

     

       197
       197
       +
       

     

       198
       198
       +
       [[package]]

     

       199
       199
       +
       name = "httpcore"

     

       200
       200
       +
       version = "1.0.9"

     

       201
       201
       +
       source = { registry = "https://pypi.org/simple" }

     

       202
       202
       +
       dependencies = [

     

       203
       203
       +
           { name = "certifi" },

     

       204
       204
       +
           { name = "h11" },

     

       205
       205
       +
       ]

     

       206
       206
       +
       sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }

     

       207
       207
       +
       wheels = [

     

       208
       208
       +
           { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },

     

       209
       209
       +
       ]

     

       210
       210
       +
       

     

       211
       211
       +
       [[package]]

     

       212
       212
       +
       name = "httpx"

     

       213
       213
       +
       version = "0.28.1"

     

       214
       214
       +
       source = { registry = "https://pypi.org/simple" }

     

       215
       215
       +
       dependencies = [

     

       216
       216
       +
           { name = "anyio" },

     

       217
       217
       +
           { name = "certifi" },

     

       218
       218
       +
           { name = "httpcore" },

     

       219
       219
       +
           { name = "idna" },

     

       220
       220
       +
       ]

     

       221
       221
       +
       sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }

     

       222
       222
       +
       wheels = [

     

       223
       223
       +
           { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },

     

       224
       224
       +
       ]

     

       225
       225
       +
       

     

       226
       226
       +
       [[package]]

     

       227
       227
       +
       name = "idna"

     

       228
       228
       +
       version = "3.10"

     

       229
       229
       +
       source = { registry = "https://pypi.org/simple" }

     

       230
       230
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f1/70/7703c29685631f5a7590aa73f1f1d3fa9a380e654b86af429e0934a32f7d/idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9", size = 190490, upload-time = "2024-09-15T18:07:39.745Z" }

     

       231
       231
       +
       wheels = [

     

       232
       232
       +
           { url = "https://files.pythonhosted.org/packages/76/c6/c88e154df9c4e1a2a66ccf0005a88dfb2650c1dffb6f5ce603dfbd452ce3/idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3", size = 70442, upload-time = "2024-09-15T18:07:37.964Z" },

     

       233
       233
       +
       ]

     

       234
       234
       +
       

     

       235
       235
       +
       [[package]]

     

       236
       236
       +
       name = "libipld"

     

       237
       237
       +
       version = "3.0.1"

     

       238
       238
       +
       source = { registry = "https://pypi.org/simple" }

     

       239
       239
       +
       sdist = { url = "https://files.pythonhosted.org/packages/d4/ad/b440c64e2d1ee84f2933979175399ff09bd0ba7b1b07c6bc20ba585825cd/libipld-3.0.1.tar.gz", hash = "sha256:2970752de70e5fdcac4646900cdefaa0dca08db9b5d59c40b5496d99e3bffa64", size = 4359070, upload-time = "2025-02-18T11:19:59.924Z" }

     

       240
       240
       +
       wheels = [

     

       241
       241
       +
           { url = "https://files.pythonhosted.org/packages/b8/6b/87c3b3222a1ebc9b8654a2ec168d177e85c993a679b698f53f199b367e37/libipld-3.0.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:27313adb70ca9ecfaaa34f1ca6e45ee0569935b7ba9802f78c2f37f7a633a7dd", size = 307914, upload-time = "2025-02-18T11:18:13.449Z" },

     

       242
       242
       +
           { url = "https://files.pythonhosted.org/packages/62/fc/9cd90e1bf5e50fa31ced3a9e4eced8b386a509f693d915ff483c320f8556/libipld-3.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bf5a14647350aa6779d634b7dc0f6967296fe52e9ca1d6132e24aa388c77c68e", size = 295778, upload-time = "2025-02-18T11:18:15.223Z" },

     

       243
       243
       +
           { url = "https://files.pythonhosted.org/packages/9b/17/c4ee7f38d43d513935179706011aa8fa5ef70d223626477de05ae301f4ae/libipld-3.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d9e619573d500eb4a4ab4a8ef90882305fba43a5a405eb80fcc0afe5d6e9dcd", size = 675489, upload-time = "2025-02-18T11:18:16.808Z" },

     

       244
       244
       +
           { url = "https://files.pythonhosted.org/packages/8f/93/f7ba7d2ce896a774634f3a279a0d7900ea2b76e0d93c335727b01c564fd6/libipld-3.0.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a2fbfaed3fc98c95cd412e61e960cd41633fc880de24327613b0cb0b974d277b", size = 681145, upload-time = "2025-02-18T11:18:18.835Z" },

     

       245
       245
       +
           { url = "https://files.pythonhosted.org/packages/92/16/c247088ec2194bfc5b5ed71059c468d1f16987696905fe9b5aaaac336521/libipld-3.0.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b36044476920455a26d30df75728eab069201c42c0af3e3610a30fd62b96ab55", size = 685159, upload-time = "2025-02-18T11:18:20.172Z" },

     

       246
       246
       +
           { url = "https://files.pythonhosted.org/packages/e1/f3/3d0442d0bd92f2bbc5bc7259569c2886bd1398a6f090ea30cd19e8c45f00/libipld-3.0.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4586a3442f12065a64a36ae56d80c71d05a87413fbf17bae330c42793c8ecfac", size = 820381, upload-time = "2025-02-18T11:18:22.398Z" },

     

       247
       247
       +
           { url = "https://files.pythonhosted.org/packages/c7/a7/63998349b924f0d2225ed194497d24bf088fad34fc02085fd97c4777164c/libipld-3.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d243ca7dea89e1579fd95f95ff612a7b56a980743c25e2a0b1a39cae7b67e55e", size = 681046, upload-time = "2025-02-18T11:18:23.954Z" },

     

       248
       248
       +
           { url = "https://files.pythonhosted.org/packages/0b/5a/bdbadafe5cb3c5ae1b4e7fd1517a436d7bda8b63621f3d39af92622d905e/libipld-3.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1525c07363abb20e8cd416df7ca316ddfc4f592ed2da694b02e0e4a4af1b9418", size = 689931, upload-time = "2025-02-18T11:18:26.868Z" },

     

       249
       249
       +
           { url = "https://files.pythonhosted.org/packages/b1/3c/759fcc3f12e41485ef374fab202b7ba84e9f001ca821d3811ff8cd030fdf/libipld-3.0.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:372768df5540867962c3c16fe80976f8b162a9771e8fe1b2175f18dabf23b9ce", size = 849420, upload-time = "2025-02-18T11:18:28.847Z" },

     

       250
       250
       +
           { url = "https://files.pythonhosted.org/packages/c4/ac/d697be6d9f20c5176d11193edbac70d55bdeaa70cd110a156ac87aaecaae/libipld-3.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:47bf15f9fc5890ff4807c0c5cb0ff99d625bcea3cd222aaa500d57466da529bd", size = 841270, upload-time = "2025-02-18T11:18:30.588Z" },

     

       251
       251
       +
           { url = "https://files.pythonhosted.org/packages/6e/91/5c64cd11e2daee21c968baa6a0669a0f402ead5fc99ad78b92e06a42e4e5/libipld-3.0.1-cp312-cp312-win32.whl", hash = "sha256:989d37ae0cb31380e6b76391e0272342de830adad2821c2de7b925b360fc45f3", size = 182583, upload-time = "2025-02-18T11:18:31.775Z" },

     

       252
       252
       +
           { url = "https://files.pythonhosted.org/packages/84/b7/37f88ada4e6fb762a71e93366c320f58995022cf8f67c4ad91d4b9a4568d/libipld-3.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:4557f20d4b8e61ac6c89ab4cea04f3a518a266f3c3d7348cf4cc8ac9b02c89dc", size = 197643, upload-time = "2025-02-18T11:18:32.86Z" },

     

       253
       253
       +
           { url = "https://files.pythonhosted.org/packages/3a/23/184f246a3ef1f6fe9775ad27851091a3779c14657e5591f6bdbe910bfe88/libipld-3.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:92ec97dac2e978f09343ebb64b0bb9bed9c294e8a224490552cfc200e9101f5c", size = 176991, upload-time = "2025-02-18T11:18:34.147Z" },

     

       254
       254
       +
           { url = "https://files.pythonhosted.org/packages/9d/a2/28c89265a107f9e92e32e308084edd7669e3fe40acb5e21b9e5af231f627/libipld-3.0.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:2cc452e533b7af10a66134aa33a064b40e05fe51fa4a509a969342768543953f", size = 305678, upload-time = "2025-02-18T11:18:36.125Z" },

     

       255
       255
       +
           { url = "https://files.pythonhosted.org/packages/05/41/ccb2251240547e0903a55f84bcab0de3b766297f5112c9a3519ce0c66dee/libipld-3.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6cd8e21c0c7ee87831dc262794637cf6c47b55c55689bc917d2c3d2518221048", size = 295909, upload-time = "2025-02-18T11:18:37.246Z" },

     

       256
       256
       +
           { url = "https://files.pythonhosted.org/packages/9b/01/93f4e7f751eaafb6e7ba2a5c2dc859eda743837f3edbd06b712a5e92e63e/libipld-3.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9de6425fc8ba0e9072c77826e66ece2dcb1d161f933cc35f2ad94470d5a304fb", size = 675461, upload-time = "2025-02-18T11:18:38.328Z" },

     

       257
       257
       +
           { url = "https://files.pythonhosted.org/packages/5e/a7/d1ff7b19e48f814f4fc908bd0a9160d80539a0128fe9b51285af09f65625/libipld-3.0.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:23c84465181ed30760ba9483e3ae71027573903cfbadf173be9fdd44bd83d8bd", size = 681427, upload-time = "2025-02-18T11:18:39.638Z" },

     

       258
       258
       +
           { url = "https://files.pythonhosted.org/packages/e2/42/7c3b45b9186f7f67015b0d717feeaa920ea215c51df675e27419f598ffb2/libipld-3.0.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:45052b7f9b6a61a425318ff611b115571965d00e42c2ca66dfd0c56a4f3002b4", size = 684988, upload-time = "2025-02-18T11:18:42.021Z" },

     

       259
       259
       +
           { url = "https://files.pythonhosted.org/packages/33/02/dd30f423e8e74ba830dff5bbbd2d7f68c474e5df1d3b56fce5e59bc08a1e/libipld-3.0.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6d183c2543db326d9a4e21819ba5674ae4f1e69dcfd853c654fba471cfbbaa88", size = 820272, upload-time = "2025-02-18T11:18:46.181Z" },

     

       260
       260
       +
           { url = "https://files.pythonhosted.org/packages/80/cd/bdd10568306ed1d71d24440e08b526ae69b93405d75a5289e0d54cf7b961/libipld-3.0.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ceb82681b6985e34609636186ac00b51105816d310ed510de1169cd65f903622", size = 680986, upload-time = "2025-02-18T11:18:48.285Z" },

     

       261
       261
       +
           { url = "https://files.pythonhosted.org/packages/0a/20/d03eddce8c41f1f928efb37268424e336d97d2aca829bd267b1f12851759/libipld-3.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e3c71ffe0b9c182664bac3a2386e6c6580744f5aa46513d0d6823e671ab71d82", size = 689783, upload-time = "2025-02-18T11:18:49.501Z" },

     

       262
       262
       +
           { url = "https://files.pythonhosted.org/packages/27/17/fdfcb6d0b0d7120eb3ad9361173cc6d5c24814b6ea2e7b135b3bb8d6920e/libipld-3.0.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:6ed68ff00bb8d63e18bf823eb89ec86e9f30b997c6d152a35ec6c4c8502ea080", size = 849382, upload-time = "2025-02-18T11:18:51.183Z" },

     

       263
       263
       +
           { url = "https://files.pythonhosted.org/packages/6c/99/237d618fa6707300a60b8b4b859855e4e34dadb00233dc1e92d911166ae2/libipld-3.0.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:8d517c69b8f29acca27b0ced0ecb78f6e54f70952a35bc8f3060b628069c63ec", size = 841299, upload-time = "2025-02-18T11:18:53.398Z" },

     

       264
       264
       +
           { url = "https://files.pythonhosted.org/packages/93/49/32c73fd530fab341bebc4e400657f5c2189a8d4d627bcdeb774eb37dd90f/libipld-3.0.1-cp313-cp313-win32.whl", hash = "sha256:21989622e02a3bd8be16e97c412af4f48b5ddf3b32f9b0da9d7c6b0724d01e91", size = 182567, upload-time = "2025-02-18T11:18:54.635Z" },

     

       265
       265
       +
           { url = "https://files.pythonhosted.org/packages/7f/1e/ea73ea525d716ce836367daa212d4d0b1c25a89ffa281c9fee535cb99840/libipld-3.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:da81784d00597a0c9ac0a133ac820aaea60599b077778046dde4726e1a08685c", size = 196204, upload-time = "2025-02-18T11:18:55.706Z" },

     

       266
       266
       +
           { url = "https://files.pythonhosted.org/packages/e2/ba/56e9082bdd997c41b3e58d3afb9d40cf08725cbd486f7e334538a41bc2a8/libipld-3.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:d670dea8a76188e2977b5c3d780a6393bb270b0d04976436ce3afbc2cf4da516", size = 177044, upload-time = "2025-02-18T11:18:56.786Z" },

     

       267
       267
       +
       ]

     

       268
       268
       +
       

     

       269
       269
       +
       [[package]]

     

       270
       270
       +
       name = "pycparser"

     

       271
       271
       +
       version = "2.22"

     

       272
       272
       +
       source = { registry = "https://pypi.org/simple" }

     

       273
       273
       +
       sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload-time = "2024-03-30T13:22:22.564Z" }

     

       274
       274
       +
       wheels = [

     

       275
       275
       +
           { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload-time = "2024-03-30T13:22:20.476Z" },

     

       276
       276
       +
       ]

     

       277
       277
       +
       

     

       278
       278
       +
       [[package]]

     

       279
       279
       +
       name = "pydantic"

     

       280
       280
       +
       version = "2.11.5"

     

       281
       281
       +
       source = { registry = "https://pypi.org/simple" }

     

       282
       282
       +
       dependencies = [

     

       283
       283
       +
           { name = "annotated-types" },

     

       284
       284
       +
           { name = "pydantic-core" },

     

       285
       285
       +
           { name = "typing-extensions" },

     

       286
       286
       +
           { name = "typing-inspection" },

     

       287
       287
       +
       ]

     

       288
       288
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f0/86/8ce9040065e8f924d642c58e4a344e33163a07f6b57f836d0d734e0ad3fb/pydantic-2.11.5.tar.gz", hash = "sha256:7f853db3d0ce78ce8bbb148c401c2cdd6431b3473c0cdff2755c7690952a7b7a", size = 787102, upload-time = "2025-05-22T21:18:08.761Z" }

     

       289
       289
       +
       wheels = [

     

       290
       290
       +
           { url = "https://files.pythonhosted.org/packages/b5/69/831ed22b38ff9b4b64b66569f0e5b7b97cf3638346eb95a2147fdb49ad5f/pydantic-2.11.5-py3-none-any.whl", hash = "sha256:f9c26ba06f9747749ca1e5c94d6a85cb84254577553c8785576fd38fa64dc0f7", size = 444229, upload-time = "2025-05-22T21:18:06.329Z" },

     

       291
       291
       +
       ]

     

       292
       292
       +
       

     

       293
       293
       +
       [[package]]

     

       294
       294
       +
       name = "pydantic-core"

     

       295
       295
       +
       version = "2.33.2"

     

       296
       296
       +
       source = { registry = "https://pypi.org/simple" }

     

       297
       297
       +
       dependencies = [

     

       298
       298
       +
           { name = "typing-extensions" },

     

       299
       299
       +
       ]

     

       300
       300
       +
       sdist = { url = "https://files.pythonhosted.org/packages/ad/88/5f2260bdfae97aabf98f1778d43f69574390ad787afb646292a638c923d4/pydantic_core-2.33.2.tar.gz", hash = "sha256:7cb8bc3605c29176e1b105350d2e6474142d7c1bd1d9327c4a9bdb46bf827acc", size = 435195, upload-time = "2025-04-23T18:33:52.104Z" }

     

       301
       301
       +
       wheels = [

     

       302
       302
       +
           { url = "https://files.pythonhosted.org/packages/18/8a/2b41c97f554ec8c71f2a8a5f85cb56a8b0956addfe8b0efb5b3d77e8bdc3/pydantic_core-2.33.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a7ec89dc587667f22b6a0b6579c249fca9026ce7c333fc142ba42411fa243cdc", size = 2009000, upload-time = "2025-04-23T18:31:25.863Z" },

     

       303
       303
       +
           { url = "https://files.pythonhosted.org/packages/a1/02/6224312aacb3c8ecbaa959897af57181fb6cf3a3d7917fd44d0f2917e6f2/pydantic_core-2.33.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3c6db6e52c6d70aa0d00d45cdb9b40f0433b96380071ea80b09277dba021ddf7", size = 1847996, upload-time = "2025-04-23T18:31:27.341Z" },

     

       304
       304
       +
           { url = "https://files.pythonhosted.org/packages/d6/46/6dcdf084a523dbe0a0be59d054734b86a981726f221f4562aed313dbcb49/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e61206137cbc65e6d5256e1166f88331d3b6238e082d9f74613b9b765fb9025", size = 1880957, upload-time = "2025-04-23T18:31:28.956Z" },

     

       305
       305
       +
           { url = "https://files.pythonhosted.org/packages/ec/6b/1ec2c03837ac00886ba8160ce041ce4e325b41d06a034adbef11339ae422/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb8c529b2819c37140eb51b914153063d27ed88e3bdc31b71198a198e921e011", size = 1964199, upload-time = "2025-04-23T18:31:31.025Z" },

     

       306
       306
       +
           { url = "https://files.pythonhosted.org/packages/2d/1d/6bf34d6adb9debd9136bd197ca72642203ce9aaaa85cfcbfcf20f9696e83/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c52b02ad8b4e2cf14ca7b3d918f3eb0ee91e63b3167c32591e57c4317e134f8f", size = 2120296, upload-time = "2025-04-23T18:31:32.514Z" },

     

       307
       307
       +
           { url = "https://files.pythonhosted.org/packages/e0/94/2bd0aaf5a591e974b32a9f7123f16637776c304471a0ab33cf263cf5591a/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:96081f1605125ba0855dfda83f6f3df5ec90c61195421ba72223de35ccfb2f88", size = 2676109, upload-time = "2025-04-23T18:31:33.958Z" },

     

       308
       308
       +
           { url = "https://files.pythonhosted.org/packages/f9/41/4b043778cf9c4285d59742281a769eac371b9e47e35f98ad321349cc5d61/pydantic_core-2.33.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f57a69461af2a5fa6e6bbd7a5f60d3b7e6cebb687f55106933188e79ad155c1", size = 2002028, upload-time = "2025-04-23T18:31:39.095Z" },

     

       309
       309
       +
           { url = "https://files.pythonhosted.org/packages/cb/d5/7bb781bf2748ce3d03af04d5c969fa1308880e1dca35a9bd94e1a96a922e/pydantic_core-2.33.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:572c7e6c8bb4774d2ac88929e3d1f12bc45714ae5ee6d9a788a9fb35e60bb04b", size = 2100044, upload-time = "2025-04-23T18:31:41.034Z" },

     

       310
       310
       +
           { url = "https://files.pythonhosted.org/packages/fe/36/def5e53e1eb0ad896785702a5bbfd25eed546cdcf4087ad285021a90ed53/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:db4b41f9bd95fbe5acd76d89920336ba96f03e149097365afe1cb092fceb89a1", size = 2058881, upload-time = "2025-04-23T18:31:42.757Z" },

     

       311
       311
       +
           { url = "https://files.pythonhosted.org/packages/01/6c/57f8d70b2ee57fc3dc8b9610315949837fa8c11d86927b9bb044f8705419/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:fa854f5cf7e33842a892e5c73f45327760bc7bc516339fda888c75ae60edaeb6", size = 2227034, upload-time = "2025-04-23T18:31:44.304Z" },

     

       312
       312
       +
           { url = "https://files.pythonhosted.org/packages/27/b9/9c17f0396a82b3d5cbea4c24d742083422639e7bb1d5bf600e12cb176a13/pydantic_core-2.33.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:5f483cfb75ff703095c59e365360cb73e00185e01aaea067cd19acffd2ab20ea", size = 2234187, upload-time = "2025-04-23T18:31:45.891Z" },

     

       313
       313
       +
           { url = "https://files.pythonhosted.org/packages/b0/6a/adf5734ffd52bf86d865093ad70b2ce543415e0e356f6cacabbc0d9ad910/pydantic_core-2.33.2-cp312-cp312-win32.whl", hash = "sha256:9cb1da0f5a471435a7bc7e439b8a728e8b61e59784b2af70d7c169f8dd8ae290", size = 1892628, upload-time = "2025-04-23T18:31:47.819Z" },

     

       314
       314
       +
           { url = "https://files.pythonhosted.org/packages/43/e4/5479fecb3606c1368d496a825d8411e126133c41224c1e7238be58b87d7e/pydantic_core-2.33.2-cp312-cp312-win_amd64.whl", hash = "sha256:f941635f2a3d96b2973e867144fde513665c87f13fe0e193c158ac51bfaaa7b2", size = 1955866, upload-time = "2025-04-23T18:31:49.635Z" },

     

       315
       315
       +
           { url = "https://files.pythonhosted.org/packages/0d/24/8b11e8b3e2be9dd82df4b11408a67c61bb4dc4f8e11b5b0fc888b38118b5/pydantic_core-2.33.2-cp312-cp312-win_arm64.whl", hash = "sha256:cca3868ddfaccfbc4bfb1d608e2ccaaebe0ae628e1416aeb9c4d88c001bb45ab", size = 1888894, upload-time = "2025-04-23T18:31:51.609Z" },

     

       316
       316
       +
           { url = "https://files.pythonhosted.org/packages/46/8c/99040727b41f56616573a28771b1bfa08a3d3fe74d3d513f01251f79f172/pydantic_core-2.33.2-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:1082dd3e2d7109ad8b7da48e1d4710c8d06c253cbc4a27c1cff4fbcaa97a9e3f", size = 2015688, upload-time = "2025-04-23T18:31:53.175Z" },

     

       317
       317
       +
           { url = "https://files.pythonhosted.org/packages/3a/cc/5999d1eb705a6cefc31f0b4a90e9f7fc400539b1a1030529700cc1b51838/pydantic_core-2.33.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f517ca031dfc037a9c07e748cefd8d96235088b83b4f4ba8939105d20fa1dcd6", size = 1844808, upload-time = "2025-04-23T18:31:54.79Z" },

     

       318
       318
       +
           { url = "https://files.pythonhosted.org/packages/6f/5e/a0a7b8885c98889a18b6e376f344da1ef323d270b44edf8174d6bce4d622/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a9f2c9dd19656823cb8250b0724ee9c60a82f3cdf68a080979d13092a3b0fef", size = 1885580, upload-time = "2025-04-23T18:31:57.393Z" },

     

       319
       319
       +
           { url = "https://files.pythonhosted.org/packages/3b/2a/953581f343c7d11a304581156618c3f592435523dd9d79865903272c256a/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2b0a451c263b01acebe51895bfb0e1cc842a5c666efe06cdf13846c7418caa9a", size = 1973859, upload-time = "2025-04-23T18:31:59.065Z" },

     

       320
       320
       +
           { url = "https://files.pythonhosted.org/packages/e6/55/f1a813904771c03a3f97f676c62cca0c0a4138654107c1b61f19c644868b/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ea40a64d23faa25e62a70ad163571c0b342b8bf66d5fa612ac0dec4f069d916", size = 2120810, upload-time = "2025-04-23T18:32:00.78Z" },

     

       321
       321
       +
           { url = "https://files.pythonhosted.org/packages/aa/c3/053389835a996e18853ba107a63caae0b9deb4a276c6b472931ea9ae6e48/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0fb2d542b4d66f9470e8065c5469ec676978d625a8b7a363f07d9a501a9cb36a", size = 2676498, upload-time = "2025-04-23T18:32:02.418Z" },

     

       322
       322
       +
           { url = "https://files.pythonhosted.org/packages/eb/3c/f4abd740877a35abade05e437245b192f9d0ffb48bbbbd708df33d3cda37/pydantic_core-2.33.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fdac5d6ffa1b5a83bca06ffe7583f5576555e6c8b3a91fbd25ea7780f825f7d", size = 2000611, upload-time = "2025-04-23T18:32:04.152Z" },

     

       323
       323
       +
           { url = "https://files.pythonhosted.org/packages/59/a7/63ef2fed1837d1121a894d0ce88439fe3e3b3e48c7543b2a4479eb99c2bd/pydantic_core-2.33.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:04a1a413977ab517154eebb2d326da71638271477d6ad87a769102f7c2488c56", size = 2107924, upload-time = "2025-04-23T18:32:06.129Z" },

     

       324
       324
       +
           { url = "https://files.pythonhosted.org/packages/04/8f/2551964ef045669801675f1cfc3b0d74147f4901c3ffa42be2ddb1f0efc4/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c8e7af2f4e0194c22b5b37205bfb293d166a7344a5b0d0eaccebc376546d77d5", size = 2063196, upload-time = "2025-04-23T18:32:08.178Z" },

     

       325
       325
       +
           { url = "https://files.pythonhosted.org/packages/26/bd/d9602777e77fc6dbb0c7db9ad356e9a985825547dce5ad1d30ee04903918/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:5c92edd15cd58b3c2d34873597a1e20f13094f59cf88068adb18947df5455b4e", size = 2236389, upload-time = "2025-04-23T18:32:10.242Z" },

     

       326
       326
       +
           { url = "https://files.pythonhosted.org/packages/42/db/0e950daa7e2230423ab342ae918a794964b053bec24ba8af013fc7c94846/pydantic_core-2.33.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:65132b7b4a1c0beded5e057324b7e16e10910c106d43675d9bd87d4f38dde162", size = 2239223, upload-time = "2025-04-23T18:32:12.382Z" },

     

       327
       327
       +
           { url = "https://files.pythonhosted.org/packages/58/4d/4f937099c545a8a17eb52cb67fe0447fd9a373b348ccfa9a87f141eeb00f/pydantic_core-2.33.2-cp313-cp313-win32.whl", hash = "sha256:52fb90784e0a242bb96ec53f42196a17278855b0f31ac7c3cc6f5c1ec4811849", size = 1900473, upload-time = "2025-04-23T18:32:14.034Z" },

     

       328
       328
       +
           { url = "https://files.pythonhosted.org/packages/a0/75/4a0a9bac998d78d889def5e4ef2b065acba8cae8c93696906c3a91f310ca/pydantic_core-2.33.2-cp313-cp313-win_amd64.whl", hash = "sha256:c083a3bdd5a93dfe480f1125926afcdbf2917ae714bdb80b36d34318b2bec5d9", size = 1955269, upload-time = "2025-04-23T18:32:15.783Z" },

     

       329
       329
       +
           { url = "https://files.pythonhosted.org/packages/f9/86/1beda0576969592f1497b4ce8e7bc8cbdf614c352426271b1b10d5f0aa64/pydantic_core-2.33.2-cp313-cp313-win_arm64.whl", hash = "sha256:e80b087132752f6b3d714f041ccf74403799d3b23a72722ea2e6ba2e892555b9", size = 1893921, upload-time = "2025-04-23T18:32:18.473Z" },

     

       330
       330
       +
           { url = "https://files.pythonhosted.org/packages/a4/7d/e09391c2eebeab681df2b74bfe6c43422fffede8dc74187b2b0bf6fd7571/pydantic_core-2.33.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61c18fba8e5e9db3ab908620af374db0ac1baa69f0f32df4f61ae23f15e586ac", size = 1806162, upload-time = "2025-04-23T18:32:20.188Z" },

     

       331
       331
       +
           { url = "https://files.pythonhosted.org/packages/f1/3d/847b6b1fed9f8ed3bb95a9ad04fbd0b212e832d4f0f50ff4d9ee5a9f15cf/pydantic_core-2.33.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:95237e53bb015f67b63c91af7518a62a8660376a6a0db19b89acc77a4d6199f5", size = 1981560, upload-time = "2025-04-23T18:32:22.354Z" },

     

       332
       332
       +
           { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" },

     

       333
       333
       +
       ]

     

       334
       334
       +
       

     

       335
       335
       +
       [[package]]

     

       336
       336
       +
       name = "requests"

     

       337
       337
       +
       version = "2.32.3"

     

       338
       338
       +
       source = { registry = "https://pypi.org/simple" }

     

       339
       339
       +
       dependencies = [

     

       340
       340
       +
           { name = "certifi" },

     

       341
       341
       +
           { name = "charset-normalizer" },

     

       342
       342
       +
           { name = "idna" },

     

       343
       343
       +
           { name = "urllib3" },

     

       344
       344
       +
       ]

     

       345
       345
       +
       sdist = { url = "https://files.pythonhosted.org/packages/63/70/2bf7780ad2d390a8d301ad0b550f1581eadbd9a20f896afe06353c2a2913/requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760", size = 131218, upload-time = "2024-05-29T15:37:49.536Z" }

     

       346
       346
       +
       wheels = [

     

       347
       347
       +
           { url = "https://files.pythonhosted.org/packages/f9/9b/335f9764261e915ed497fcdeb11df5dfd6f7bf257d4a6a2a686d80da4d54/requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6", size = 64928, upload-time = "2024-05-29T15:37:47.027Z" },

     

       348
       348
       +
       ]

     

       349
       349
       +
       

     

       350
       350
       +
       [[package]]

     

       351
       351
       +
       name = "sniffio"

     

       352
       352
       +
       version = "1.3.1"

     

       353
       353
       +
       source = { registry = "https://pypi.org/simple" }

     

       354
       354
       +
       sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }

     

       355
       355
       +
       wheels = [

     

       356
       356
       +
           { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },

     

       357
       357
       +
       ]

     

       358
       358
       +
       

     

       359
       359
       +
       [[package]]

     

       360
       360
       +
       name = "typing-extensions"

     

       361
       361
       +
       version = "4.14.0"

     

       362
       362
       +
       source = { registry = "https://pypi.org/simple" }

     

       363
       363
       +
       sdist = { url = "https://files.pythonhosted.org/packages/d1/bc/51647cd02527e87d05cb083ccc402f93e441606ff1f01739a62c8ad09ba5/typing_extensions-4.14.0.tar.gz", hash = "sha256:8676b788e32f02ab42d9e7c61324048ae4c6d844a399eebace3d4979d75ceef4", size = 107423, upload-time = "2025-06-02T14:52:11.399Z" }

     

       364
       364
       +
       wheels = [

     

       365
       365
       +
           { url = "https://files.pythonhosted.org/packages/69/e0/552843e0d356fbb5256d21449fa957fa4eff3bbc135a74a691ee70c7c5da/typing_extensions-4.14.0-py3-none-any.whl", hash = "sha256:a1514509136dd0b477638fc68d6a91497af5076466ad0fa6c338e44e359944af", size = 43839, upload-time = "2025-06-02T14:52:10.026Z" },

     

       366
       366
       +
       ]

     

       367
       367
       +
       

     

       368
       368
       +
       [[package]]

     

       369
       369
       +
       name = "typing-inspection"

     

       370
       370
       +
       version = "0.4.1"

     

       371
       371
       +
       source = { registry = "https://pypi.org/simple" }

     

       372
       372
       +
       dependencies = [

     

       373
       373
       +
           { name = "typing-extensions" },

     

       374
       374
       +
       ]

     

       375
       375
       +
       sdist = { url = "https://files.pythonhosted.org/packages/f8/b1/0c11f5058406b3af7609f121aaa6b609744687f1d158b3c3a5bf4cc94238/typing_inspection-0.4.1.tar.gz", hash = "sha256:6ae134cc0203c33377d43188d4064e9b357dba58cff3185f22924610e70a9d28", size = 75726, upload-time = "2025-05-21T18:55:23.885Z" }

     

       376
       376
       +
       wheels = [

     

       377
       377
       +
           { url = "https://files.pythonhosted.org/packages/17/69/cd203477f944c353c31bade965f880aa1061fd6bf05ded0726ca845b6ff7/typing_inspection-0.4.1-py3-none-any.whl", hash = "sha256:389055682238f53b04f7badcb49b989835495a96700ced5dab2d8feae4b26f51", size = 14552, upload-time = "2025-05-21T18:55:22.152Z" },

     

       378
       378
       +
       ]

     

       379
       379
       +
       

     

       380
       380
       +
       [[package]]

     

       381
       381
       +
       name = "urllib3"

     

       382
       382
       +
       version = "2.4.0"

     

       383
       383
       +
       source = { registry = "https://pypi.org/simple" }

     

       384
       384
       +
       sdist = { url = "https://files.pythonhosted.org/packages/8a/78/16493d9c386d8e60e442a35feac5e00f0913c0f4b7c217c11e8ec2ff53e0/urllib3-2.4.0.tar.gz", hash = "sha256:414bc6535b787febd7567804cc015fee39daab8ad86268f1310a9250697de466", size = 390672, upload-time = "2025-04-10T15:23:39.232Z" }

     

       385
       385
       +
       wheels = [

     

       386
       386
       +
           { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680, upload-time = "2025-04-10T15:23:37.377Z" },

     

       387
       387
       +
       ]

     

       388
       388
       +
       

     

       389
       389
       +
       [[package]]

     

       390
       390
       +
       name = "websockets"

     

       391
       391
       +
       version = "13.1"

     

       392
       392
       +
       source = { registry = "https://pypi.org/simple" }

     

       393
       393
       +
       sdist = { url = "https://files.pythonhosted.org/packages/e2/73/9223dbc7be3dcaf2a7bbf756c351ec8da04b1fa573edaf545b95f6b0c7fd/websockets-13.1.tar.gz", hash = "sha256:a3b3366087c1bc0a2795111edcadddb8b3b59509d5db5d7ea3fdd69f954a8878", size = 158549, upload-time = "2024-09-21T17:34:21.54Z" }

     

       394
       394
       +
       wheels = [

     

       395
       395
       +
           { url = "https://files.pythonhosted.org/packages/df/46/c426282f543b3c0296cf964aa5a7bb17e984f58dde23460c3d39b3148fcf/websockets-13.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:9d75baf00138f80b48f1eac72ad1535aac0b6461265a0bcad391fc5aba875cfc", size = 157821, upload-time = "2024-09-21T17:32:56.442Z" },

     

       396
       396
       +
           { url = "https://files.pythonhosted.org/packages/aa/85/22529867010baac258da7c45848f9415e6cf37fef00a43856627806ffd04/websockets-13.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:9b6f347deb3dcfbfde1c20baa21c2ac0751afaa73e64e5b693bb2b848efeaa49", size = 155480, upload-time = "2024-09-21T17:32:57.698Z" },

     

       397
       397
       +
           { url = "https://files.pythonhosted.org/packages/29/2c/bdb339bfbde0119a6e84af43ebf6275278698a2241c2719afc0d8b0bdbf2/websockets-13.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de58647e3f9c42f13f90ac7e5f58900c80a39019848c5547bc691693098ae1bd", size = 155715, upload-time = "2024-09-21T17:32:59.429Z" },

     

       398
       398
       +
           { url = "https://files.pythonhosted.org/packages/9f/d0/8612029ea04c5c22bf7af2fd3d63876c4eaeef9b97e86c11972a43aa0e6c/websockets-13.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1b54689e38d1279a51d11e3467dd2f3a50f5f2e879012ce8f2d6943f00e83f0", size = 165647, upload-time = "2024-09-21T17:33:00.495Z" },

     

       399
       399
       +
           { url = "https://files.pythonhosted.org/packages/56/04/1681ed516fa19ca9083f26d3f3a302257e0911ba75009533ed60fbb7b8d1/websockets-13.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf1781ef73c073e6b0f90af841aaf98501f975d306bbf6221683dd594ccc52b6", size = 164592, upload-time = "2024-09-21T17:33:02.223Z" },

     

       400
       400
       +
           { url = "https://files.pythonhosted.org/packages/38/6f/a96417a49c0ed132bb6087e8e39a37db851c70974f5c724a4b2a70066996/websockets-13.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8d23b88b9388ed85c6faf0e74d8dec4f4d3baf3ecf20a65a47b836d56260d4b9", size = 165012, upload-time = "2024-09-21T17:33:03.288Z" },

     

       401
       401
       +
           { url = "https://files.pythonhosted.org/packages/40/8b/fccf294919a1b37d190e86042e1a907b8f66cff2b61e9befdbce03783e25/websockets-13.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3c78383585f47ccb0fcf186dcb8a43f5438bd7d8f47d69e0b56f71bf431a0a68", size = 165311, upload-time = "2024-09-21T17:33:04.728Z" },

     

       402
       402
       +
           { url = "https://files.pythonhosted.org/packages/c1/61/f8615cf7ce5fe538476ab6b4defff52beb7262ff8a73d5ef386322d9761d/websockets-13.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:d6d300f8ec35c24025ceb9b9019ae9040c1ab2f01cddc2bcc0b518af31c75c14", size = 164692, upload-time = "2024-09-21T17:33:05.829Z" },

     

       403
       403
       +
           { url = "https://files.pythonhosted.org/packages/5c/f1/a29dd6046d3a722d26f182b783a7997d25298873a14028c4760347974ea3/websockets-13.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a9dcaf8b0cc72a392760bb8755922c03e17a5a54e08cca58e8b74f6902b433cf", size = 164686, upload-time = "2024-09-21T17:33:06.823Z" },

     

       404
       404
       +
           { url = "https://files.pythonhosted.org/packages/0f/99/ab1cdb282f7e595391226f03f9b498f52109d25a2ba03832e21614967dfa/websockets-13.1-cp312-cp312-win32.whl", hash = "sha256:2f85cf4f2a1ba8f602298a853cec8526c2ca42a9a4b947ec236eaedb8f2dc80c", size = 158712, upload-time = "2024-09-21T17:33:07.877Z" },

     

       405
       405
       +
           { url = "https://files.pythonhosted.org/packages/46/93/e19160db48b5581feac8468330aa11b7292880a94a37d7030478596cc14e/websockets-13.1-cp312-cp312-win_amd64.whl", hash = "sha256:38377f8b0cdeee97c552d20cf1865695fcd56aba155ad1b4ca8779a5b6ef4ac3", size = 159145, upload-time = "2024-09-21T17:33:09.202Z" },

     

       406
       406
       +
           { url = "https://files.pythonhosted.org/packages/51/20/2b99ca918e1cbd33c53db2cace5f0c0cd8296fc77558e1908799c712e1cd/websockets-13.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a9ab1e71d3d2e54a0aa646ab6d4eebfaa5f416fe78dfe4da2839525dc5d765c6", size = 157828, upload-time = "2024-09-21T17:33:10.987Z" },

     

       407
       407
       +
           { url = "https://files.pythonhosted.org/packages/b8/47/0932a71d3d9c0e9483174f60713c84cee58d62839a143f21a2bcdbd2d205/websockets-13.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b9d7439d7fab4dce00570bb906875734df13d9faa4b48e261c440a5fec6d9708", size = 155487, upload-time = "2024-09-21T17:33:12.153Z" },

     

       408
       408
       +
           { url = "https://files.pythonhosted.org/packages/a9/60/f1711eb59ac7a6c5e98e5637fef5302f45b6f76a2c9d64fd83bbb341377a/websockets-13.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:327b74e915cf13c5931334c61e1a41040e365d380f812513a255aa804b183418", size = 155721, upload-time = "2024-09-21T17:33:13.909Z" },

     

       409
       409
       +
           { url = "https://files.pythonhosted.org/packages/6a/e6/ba9a8db7f9d9b0e5f829cf626ff32677f39824968317223605a6b419d445/websockets-13.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:325b1ccdbf5e5725fdcb1b0e9ad4d2545056479d0eee392c291c1bf76206435a", size = 165609, upload-time = "2024-09-21T17:33:14.967Z" },

     

       410
       410
       +
           { url = "https://files.pythonhosted.org/packages/c1/22/4ec80f1b9c27a0aebd84ccd857252eda8418ab9681eb571b37ca4c5e1305/websockets-13.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:346bee67a65f189e0e33f520f253d5147ab76ae42493804319b5716e46dddf0f", size = 164556, upload-time = "2024-09-21T17:33:17.113Z" },

     

       411
       411
       +
           { url = "https://files.pythonhosted.org/packages/27/ac/35f423cb6bb15600438db80755609d27eda36d4c0b3c9d745ea12766c45e/websockets-13.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:91a0fa841646320ec0d3accdff5b757b06e2e5c86ba32af2e0815c96c7a603c5", size = 164993, upload-time = "2024-09-21T17:33:18.168Z" },

     

       412
       412
       +
           { url = "https://files.pythonhosted.org/packages/31/4e/98db4fd267f8be9e52e86b6ee4e9aa7c42b83452ea0ea0672f176224b977/websockets-13.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:18503d2c5f3943e93819238bf20df71982d193f73dcecd26c94514f417f6b135", size = 165360, upload-time = "2024-09-21T17:33:19.233Z" },

     

       413
       413
       +
           { url = "https://files.pythonhosted.org/packages/3f/15/3f0de7cda70ffc94b7e7024544072bc5b26e2c1eb36545291abb755d8cdb/websockets-13.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:a9cd1af7e18e5221d2878378fbc287a14cd527fdd5939ed56a18df8a31136bb2", size = 164745, upload-time = "2024-09-21T17:33:20.361Z" },

     

       414
       414
       +
           { url = "https://files.pythonhosted.org/packages/a1/6e/66b6b756aebbd680b934c8bdbb6dcb9ce45aad72cde5f8a7208dbb00dd36/websockets-13.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:70c5be9f416aa72aab7a2a76c90ae0a4fe2755c1816c153c1a2bcc3333ce4ce6", size = 164732, upload-time = "2024-09-21T17:33:23.103Z" },

     

       415
       415
       +
           { url = "https://files.pythonhosted.org/packages/35/c6/12e3aab52c11aeb289e3dbbc05929e7a9d90d7a9173958477d3ef4f8ce2d/websockets-13.1-cp313-cp313-win32.whl", hash = "sha256:624459daabeb310d3815b276c1adef475b3e6804abaf2d9d2c061c319f7f187d", size = 158709, upload-time = "2024-09-21T17:33:24.196Z" },

     

       416
       416
       +
           { url = "https://files.pythonhosted.org/packages/41/d8/63d6194aae711d7263df4498200c690a9c39fb437ede10f3e157a6343e0d/websockets-13.1-cp313-cp313-win_amd64.whl", hash = "sha256:c518e84bb59c2baae725accd355c8dc517b4a3ed8db88b4bc93c78dae2974bf2", size = 159144, upload-time = "2024-09-21T17:33:25.96Z" },

     

       417
       417
       +
           { url = "https://files.pythonhosted.org/packages/56/27/96a5cd2626d11c8280656c6c71d8ab50fe006490ef9971ccd154e0c42cd2/websockets-13.1-py3-none-any.whl", hash = "sha256:a9a396a6ad26130cdae92ae10c36af09d9bfe6cafe69670fd3b6da9b07b4044f", size = 152134, upload-time = "2024-09-21T17:34:19.904Z" },

     

       418
       418
       +
       ]

     

       419
       419
       +
       

     

       420
       420
       +
       [[package]]

     

       421
       421
       +
       name = "xpost"

     

       422
       422
       +
       version = "0.1.0"

     

       423
       423
       +
       source = { virtual = "." }

     

       424
       424
       +
       dependencies = [

     

       425
       425
       +
           { name = "atproto" },

     

       426
       426
       +
           { name = "click" },

     

       427
       427
       +
           { name = "requests" },

     

       428
       428
       +
       ]

     

       429
       429
       +
       

     

       430
       430
       +
       [package.metadata]

     

       431
       431
       +
       requires-dist = [

     

       432
       432
       +
           { name = "atproto", specifier = ">=0.0.61" },

     

       433
       433
       +
           { name = "click", specifier = ">=8.2.1" },

     

       434
       434
       +
           { name = "requests", specifier = ">=2.32.3" },

     

       435
       435
       +
       ]