Set up new feed

.python-version

···
+3.12

.vscode/settings.json

···
-{
-    "cSpell.words": [
-        "ATPROTO",
-        "bluesky",
-        "bsky",
-        "dotenv"
-    ]
-}

publish_feed.py

···
 
 load_dotenv()
 
+
 def _get_bool_env_var(value: str) -> bool:
     # Helper function to convert string to bool
 
···
         return False
 
     normalized_value = value.strip().lower()
-    if normalized_value in {'1', 'true', 't', 'yes', 'y'}:
+    if normalized_value in {"1", "true", "t", "yes", "y"}:
         return True
 
     return False
···
 
 # YOUR bluesky handle
 # Ex: user.bsky.social
-HANDLE: str = os.environ.get('HANDLE')
+HANDLE: str = os.environ.get("HANDLE")
 
 # YOUR bluesky password, or preferably an App Password (found in your client settings)
 # Ex: abcd-1234-efgh-5678
-PASSWORD: str = os.environ.get('PASSWORD')
+PASSWORD: str = os.environ.get("PASSWORD")
 
 # The hostname of the server where feed server will be hosted
 # Ex: feed.bsky.dev
-HOSTNAME: str = os.environ.get('HOSTNAME')
+HOSTNAME: str = os.environ.get("HOSTNAME")
 
 # A short name for the record that will show in urls
 # Lowercase with no spaces.
 # Ex: whats-hot
-RECORD_NAME: str = os.environ.get('RECORD_NAME')
+RECORD_NAME: str = os.environ.get("RECORD_NAME")
 
 # A display name for your feed
 # Ex: What's Hot
-DISPLAY_NAME: str = os.environ.get('DISPLAY_NAME')
+DISPLAY_NAME: str = os.environ.get("DISPLAY_NAME")
 
 # (Optional) A description of your feed
 # Ex: Top trending content from the whole network
-DESCRIPTION: str = os.environ.get('DESCRIPTION')
+DESCRIPTION: str = os.environ.get("DESCRIPTION")
 
 # (Optional) The path to an image to be used as your feed's avatar
 # Ex: ./path/to/avatar.jpeg
-AVATAR_PATH: str = os.environ.get('AVATAR_PATH')
+AVATAR_PATH: str = os.environ.get("AVATAR_PATH")
 
 # (Optional). Only use this if you want a service did different from did:web
-SERVICE_DID: str = os.environ.get('SERVICE_DID')
+SERVICE_DID: str = os.environ.get("SERVICE_DID")
 
 # (Optional). If your feed accepts interactions from clients
-ACCEPTS_INTERACTIONS: bool = _get_bool_env_var(os.environ.get('ACCEPTS_INTERACTIONS'))
+ACCEPTS_INTERACTIONS: bool = _get_bool_env_var(os.environ.get("ACCEPTS_INTERACTIONS"))
 
 # (Optional). If your feed is a video feed
-IS_VIDEO_FEED: bool = _get_bool_env_var(os.environ.get('IS_VIDEO_FEED'))
+IS_VIDEO_FEED: bool = _get_bool_env_var(os.environ.get("IS_VIDEO_FEED"))
 
 # -------------------------------------
 # NO NEED TO TOUCH ANYTHING BELOW HERE
···
 
     feed_did = SERVICE_DID
     if not feed_did:
-        feed_did = f'did:web:{HOSTNAME}'
+        feed_did = f"did:web:{HOSTNAME}"
 
     avatar_blob = None
     if AVATAR_PATH:
-        with open(AVATAR_PATH, 'rb') as f:
+        with open(AVATAR_PATH, "rb") as f:
             avatar_data = f.read()
             avatar_blob = client.upload_blob(avatar_data).blob
 
-    response = client.com.atproto.repo.put_record(models.ComAtprotoRepoPutRecord.Data(
-        repo=client.me.did,
-        collection=models.ids.AppBskyFeedGenerator,
-        rkey=RECORD_NAME,
-        record=models.AppBskyFeedGenerator.Record(
-            did=feed_did,
-            display_name=DISPLAY_NAME,
-            accepts_interactions=ACCEPTS_INTERACTIONS,
-            description=DESCRIPTION,
-            avatar=avatar_blob,
-            content_mode='app.bsky.feed.defs#contentModeVideo' if IS_VIDEO_FEED else None,
-            created_at=client.get_current_time_iso(),
+    response = client.com.atproto.repo.put_record(
+        models.ComAtprotoRepoPutRecord.Data(
+            repo=client.me.did,
+            collection=models.ids.AppBskyFeedGenerator,
+            rkey=RECORD_NAME,
+            record=models.AppBskyFeedGenerator.Record(
+                did=feed_did,
+                display_name=DISPLAY_NAME,
+                accepts_interactions=ACCEPTS_INTERACTIONS,
+                description=DESCRIPTION,
+                avatar=avatar_blob,
+                content_mode="app.bsky.feed.defs#contentModeVideo"
+                if IS_VIDEO_FEED
+                else None,
+                created_at=client.get_current_time_iso(),
+            ),
         )
-    ))
+    )
 
-    print('Successfully published!')
+    print("Successfully published!")
     print('Feed URI (put in "FEED_URI" env var):', response.uri)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

pyproject.toml

···
 [project]
 name = ""
 version = "0.0.1"
+requires-python = ">=3.12"
 dependencies = [
     "atproto==0.0.59",
-    "peewee~=3.16.2",
+    "peewee~=3.18.2",
     "flask~=2.3.2",
     "python-dotenv~=1.0.0",
+]
+
+[dependency-groups]
+dev = [
+  {include-group = "lint"},
+  {include-group = "test"}
+]
+lint = [
+  "ruff"
+]
+test = [
+  "pytest"
 ]
 
 [tool.uv]

server/__init__.py

···
+from atproto import models
+
+RELEVANT_RECORDS = {
+    models.AppBskyFeedLike: models.ids.AppBskyFeedLike,
+    models.AppBskyFeedPost: models.ids.AppBskyFeedPost,
+    models.AppBskyGraphFollow: models.ids.AppBskyGraphFollow,
+    models.AppBskyFeedRepost: models.ids.AppBskyFeedRepost,
+}

server/__main__.py

···
 from app import app
 from server.logger import logger
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     # FOR DEBUG PURPOSE ONLY
     logger.setLevel(logging.DEBUG)
-    app.run(host='127.0.0.1', port=8000, debug=True)
+    app.run(host="127.0.0.1", port=8000, debug=True)

server/algos/__init__.py

···
-from . import feed
+from . import following_sans_politics, since_u_been_gone
 
 algos = {
-    feed.uri: feed.handler
+    since_u_been_gone.uri: since_u_been_gone.handler,
+    following_sans_politics.uri: following_sans_politics.handler,
 }

server/algos/feed.py

···
-from datetime import datetime
-from typing import Optional
-
-from server import config
-from server.database import Post
-
-uri = config.FEED_URI
-CURSOR_EOF = 'eof'
-
-
-def handler(cursor: Optional[str], limit: int) -> dict:
-    posts = Post.select().order_by(Post.cid.desc()).order_by(Post.indexed_at.desc()).limit(limit)
-
-    if cursor:
-        if cursor == CURSOR_EOF:
-            return {
-                'cursor': CURSOR_EOF,
-                'feed': []
-            }
-        cursor_parts = cursor.split('::')
-        if len(cursor_parts) != 2:
-            raise ValueError('Malformed cursor')
-
-        indexed_at, cid = cursor_parts
-        indexed_at = datetime.fromtimestamp(int(indexed_at) / 1000)
-        posts = posts.where(((Post.indexed_at == indexed_at) & (Post.cid < cid)) | (Post.indexed_at < indexed_at))
-
-    feed = [{'post': post.uri} for post in posts]
-
-    cursor = CURSOR_EOF
-    last_post = posts[-1] if posts else None
-    if last_post:
-        cursor = f'{int(last_post.indexed_at.timestamp() * 1000)}::{last_post.cid}'
-
-    return {
-        'cursor': cursor,
-        'feed': feed
-    }

server/algos/following_sans_politics.py

···
+from datetime import datetime
+from typing import Optional
+
+from server import config
+from server.database import Follow, Post
+
+uri = config.FEED_URI
+CURSOR_EOF = "eof"
+
+
+def handler(cursor: Optional[str], limit: int, requester_did: str | None = None) -> dict:
+    following = Follow.select('subject').where(Follow.author == requester_did).dicts()
+    following_dids: list[str] = [follow['subject'] for follow in following]
+
+    posts_by_following = (
+        Post.select()
+        .where(Post.author.in_(following_dids))
+        .order_by(Post.cid.desc())
+        .order_by(Post.indexed_at.desc())
+        .limit(limit)
+    )
+
+    if cursor:
+        if cursor == CURSOR_EOF:
+            return {"cursor": CURSOR_EOF, "feed": []}
+        cursor_parts = cursor.split("::")
+        if len(cursor_parts) != 2:
+            raise ValueError("Malformed cursor")
+
+        indexed_at, cid = cursor_parts
+        indexed_at = datetime.fromtimestamp(int(indexed_at) / 1000)
+        posts_by_following = posts_by_following.where(
+            ((Post.indexed_at == indexed_at) & (Post.cid < cid))
+            | (Post.indexed_at < indexed_at)
+        )
+
+    feed = [{"post": post.uri} for post in posts_by_following]
+
+    cursor = CURSOR_EOF
+    last_post = posts_by_following[-1] if posts_by_following else None
+    if last_post:
+        cursor = f"{int(last_post.indexed_at.timestamp() * 1000)}::{last_post.cid}"
+
+    return {"cursor": cursor, "feed": feed}

server/algos/since_u_been_gone.py

···
+from datetime import datetime
+from typing import Optional
+
+from server import config
+from server.database import Post
+
+uri = config.FEED_URI
+CURSOR_EOF = "eof"
+
+
+def handler(cursor: Optional[str], limit: int, _: str | None = None) -> dict:
+    posts = (
+        Post.select()
+        .order_by(Post.cid.desc())
+        .order_by(Post.indexed_at.desc())
+        .limit(limit)
+    )
+
+    if cursor:
+        if cursor == CURSOR_EOF:
+            return {"cursor": CURSOR_EOF, "feed": []}
+        cursor_parts = cursor.split("::")
+        if len(cursor_parts) != 2:
+            raise ValueError("Malformed cursor")
+
+        indexed_at, cid = cursor_parts
+        indexed_at = datetime.fromtimestamp(int(indexed_at) / 1000)
+        posts = posts.where(
+            ((Post.indexed_at == indexed_at) & (Post.cid < cid))
+            | (Post.indexed_at < indexed_at)
+        )
+
+    feed = [{"post": post.uri} for post in posts]
+
+    cursor = CURSOR_EOF
+    last_post = posts[-1] if posts else None
+    if last_post:
+        cursor = f"{int(last_post.indexed_at.timestamp() * 1000)}::{last_post.cid}"
+
+    return {"cursor": cursor, "feed": feed}

server/app.py

···
-import sys
 import signal
+import sys
 import threading
-
-from server import config
-from server import data_stream
 
 from flask import Flask, jsonify, request
 
+from server import config, data_stream
 from server.algos import algos
+from server.auth import AuthorizationError, validate_auth
 from server.data_filter import operations_callback
 
 app = Flask(__name__)
 
 stream_stop_event = threading.Event()
 stream_thread = threading.Thread(
-    target=data_stream.run, args=(config.SERVICE_DID, operations_callback, stream_stop_event,)
+    target=data_stream.run,
+    args=(
+        config.SERVICE_DID,
+        operations_callback,
+        stream_stop_event,
+    ),
 )
 stream_thread.start()
 
 
 def sigint_handler(*_):
-    print('Stopping data stream...')
+    print("Stopping data stream...")
     stream_stop_event.set()
     sys.exit(0)
 
···
 signal.signal(signal.SIGINT, sigint_handler)
 
 
[e-mail]('/')
[e-mail]("/")
 def index():
-    return 'ATProto Feed Generator powered by The AT Protocol SDK for Python (https://github.com/MarshalX/atproto).'
+    return "ATProto Feed Generator powered by The AT Protocol SDK for Python (https://github.com/MarshalX/atproto)."
 
 
[e-mail]('/.well-known/did.json', methods=['GET'])
[e-mail]("/.well-known/did.json", methods=["GET"])
 def did_json():
     if not config.SERVICE_DID.endswith(config.HOSTNAME):
-        return '', 404
+        return "", 404
 
-    return jsonify({
-        '@context': ['https://www.w3.org/ns/did/v1'],
-        'id': config.SERVICE_DID,
-        'service': [
-            {
-                'id': '#bsky_fg',
-                'type': 'BskyFeedGenerator',
-                'serviceEndpoint': f'https://{config.HOSTNAME}'
-            }
-        ]
-    })
+    return jsonify(
+        {
+            "@context": ["https://www.w3.org/ns/did/v1"],
+            "id": config.SERVICE_DID,
+            "service": [
+                {
+                    "id": "#bsky_fg",
+                    "type": "BskyFeedGenerator",
+                    "serviceEndpoint": f"https://{config.HOSTNAME}",
+                }
+            ],
+        }
+    )
 
 
[e-mail]('/xrpc/app.bsky.feed.describeFeedGenerator', methods=['GET'])
[e-mail]("/xrpc/app.bsky.feed.describeFeedGenerator", methods=["GET"])
 def describe_feed_generator():
-    feeds = [{'uri': uri} for uri in algos.keys()]
+    feeds = [{"uri": uri} for uri in algos.keys()]
     response = {
-        'encoding': 'application/json',
-        'body': {
-            'did': config.SERVICE_DID,
-            'feeds': feeds
-        }
+        "encoding": "application/json",
+        "body": {"did": config.SERVICE_DID, "feeds": feeds},
     }
     return jsonify(response)
 
 
[e-mail]('/xrpc/app.bsky.feed.getFeedSkeleton', methods=['GET'])
[e-mail]("/xrpc/app.bsky.feed.getFeedSkeleton", methods=["GET"])
 def get_feed_skeleton():
-    feed = request.args.get('feed', default=None, type=str)
+    feed = request.args.get("feed", default=None, type=str)
     algo = algos.get(feed)
     if not algo:
-        return 'Unsupported algorithm', 400
+        return "Unsupported algorithm", 400
 
     # Example of how to check auth if giving user-specific results:
     """
···
     """
 
     try:
-        cursor = request.args.get('cursor', default=None, type=str)
-        limit = request.args.get('limit', default=20, type=int)
-        body = algo(cursor, limit)
+        requester_did = validate_auth(request)
+        cursor = request.args.get("cursor", default=None, type=str)
+        limit = request.args.get("limit", default=20, type=int)
+        body = algo(cursor, limit, requester_did)
+    except AuthorizationError:
+        return "Unauthorized", 401
     except ValueError:
-        return 'Malformed cursor', 400
+        return "Malformed cursor", 400
 
     return jsonify(body)

server/auth.py

···
 _CACHE = DidInMemoryCache()
 _ID_RESOLVER = IdResolver(cache=_CACHE)
 
-_AUTHORIZATION_HEADER_NAME = 'Authorization'
-_AUTHORIZATION_HEADER_VALUE_PREFIX = 'Bearer '
+_AUTHORIZATION_HEADER_NAME = "Authorization"
+_AUTHORIZATION_HEADER_VALUE_PREFIX = "Bearer "
 
 
-class AuthorizationError(Exception):
-    ...
+class AuthorizationError(Exception): ...
 
 
-def validate_auth(request: 'Request') -> str:
+def validate_auth(request: "Request") -> str:
     """Validate authorization header.
 
     Args:
···
     """
     auth_header = request.headers.get(_AUTHORIZATION_HEADER_NAME)
     if not auth_header:
-        raise AuthorizationError('Authorization header is missing')
+        raise AuthorizationError("Authorization header is missing")
 
     if not auth_header.startswith(_AUTHORIZATION_HEADER_VALUE_PREFIX):
-        raise AuthorizationError('Invalid authorization header')
+        raise AuthorizationError("Invalid authorization header")
 
     jwt = auth_header[len(_AUTHORIZATION_HEADER_VALUE_PREFIX) :].strip()
 
     try:
         return verify_jwt(jwt, _ID_RESOLVER.did.resolve_atproto_key).iss
     except TokenInvalidSignatureError as e:
-        raise AuthorizationError('Invalid signature') from e
+        raise AuthorizationError("Invalid signature") from e

server/config.py

···
 
 load_dotenv()
 
-SERVICE_DID = os.environ.get('SERVICE_DID')
-HOSTNAME = os.environ.get('HOSTNAME')
-FLASK_RUN_FROM_CLI = os.environ.get('FLASK_RUN_FROM_CLI')
+SERVICE_DID = os.environ.get("SERVICE_DID")
+HOSTNAME = os.environ.get("HOSTNAME")
+FLASK_RUN_FROM_CLI = os.environ.get("FLASK_RUN_FROM_CLI")
 
 if FLASK_RUN_FROM_CLI:
     logger.setLevel(logging.DEBUG)
···
     raise RuntimeError('You should set "HOSTNAME" environment variable first.')
 
 if not SERVICE_DID:
-    SERVICE_DID = f'did:web:{HOSTNAME}'
+    SERVICE_DID = f"did:web:{HOSTNAME}"
 
 
-FEED_URI = os.environ.get('FEED_URI')
+FEED_URI = os.environ.get("FEED_URI")
 if not FEED_URI:
-    raise RuntimeError('Publish your feed first (run publish_feed.py) to obtain Feed URI. '
-                       'Set this URI to "FEED_URI" environment variable.')
+    raise RuntimeError(
+        "Publish your feed first (run publish_feed.py) to obtain Feed URI. "
+        'Set this URI to "FEED_URI" environment variable.'
+    )
 
 
 def _get_bool_env_var(value: str) -> bool:
···
         return False
 
     normalized_value = value.strip().lower()
-    if normalized_value in {'1', 'true', 't', 'yes', 'y'}:
+    if normalized_value in {"1", "true", "t", "yes", "y"}:
         return True
 
     return False
 
 
-IGNORE_ARCHIVED_POSTS = _get_bool_env_var(os.environ.get('IGNORE_ARCHIVED_POSTS'))
-IGNORE_REPLY_POSTS = _get_bool_env_var(os.environ.get('IGNORE_REPLY_POSTS'))
+IGNORE_ARCHIVED_POSTS = _get_bool_env_var(os.environ.get("IGNORE_ARCHIVED_POSTS"))
+IGNORE_REPLY_POSTS = _get_bool_env_var(os.environ.get("IGNORE_REPLY_POSTS"))

server/data_filter.py

···
 import datetime
-
 from collections import defaultdict
 
 from atproto import models
 
 from server import config
+from server.database import Follow, Like, Post, Repost, db
 from server.logger import logger
-from server.database import db, Post
+from server.utils import get_author_from_uri
 
 
-def is_archive_post(record: 'models.AppBskyFeedPost.Record') -> bool:
+def is_archive_post(record: "models.AppBskyFeedPost.Record") -> bool:
     # Sometimes users will import old posts from Twitter/X which con flood a feed with
     # old posts. Unfortunately, the only way to test for this is to look an old
     # created_at date. However, there are other reasons why a post might have an old
···
 
 
 def should_ignore_post(created_post: dict) -> bool:
-    record = created_post['record']
-    uri = created_post['uri']
+    record = created_post["record"]
+    uri = created_post["uri"]
 
     if config.IGNORE_ARCHIVED_POSTS and is_archive_post(record):
-        logger.debug(f'Ignoring archived post: {uri}')
+        logger.debug(f"Ignoring archived post: {uri}")
         return True
 
     if config.IGNORE_REPLY_POSTS and record.reply:
-        logger.debug(f'Ignoring reply post: {uri}')
+        logger.debug(f"Ignoring reply post: {uri}")
         return True
 
     return False
···
     # After our feed alg we can save posts into our DB
     # Also, we should process deleted posts to remove them from our DB and keep it in sync
 
-    # for example, let's create our custom feed that will contain all posts that contains 'python' related text
-
+    # Create posts
     posts_to_create = []
-    for created_post in ops[models.ids.AppBskyFeedPost]['created']:
-        author = created_post['author']
-        record = created_post['record']
+    for created_post in ops[models.ids.AppBskyFeedPost]["created"]:
+        author = get_author_from_uri(created_post["uri"])
+        record = created_post["record"]
 
         is_post_with_images = isinstance(record.embed, models.AppBskyEmbedImages.Main)
         is_post_with_video = isinstance(record.embed, models.AppBskyEmbedVideo.Main)
-        inlined_text = record.text.replace('\n', ' ')
+        inlined_text = record.text.replace("\n", " ")
 
         # print all texts just as demo that data stream works
         logger.debug(
-            f'NEW POST '
-            f'[CREATED_AT={record.created_at}]'
-            f'[AUTHOR={author}]'
-            f'[WITH_IMAGE={is_post_with_images}]'
-            f'[WITH_VIDEO={is_post_with_video}]'
-            f': {inlined_text}'
+            f"NEW POST "
+            f"[CREATED_AT={record.created_at}]"
+            f"[AUTHOR={author}]"
+            f"[WITH_IMAGE={is_post_with_images}]"
+            f"[WITH_VIDEO={is_post_with_video}]"
+            f": {inlined_text}"
         )
 
         if should_ignore_post(created_post):
             continue
 
-        # only python-related posts
-        if 'python' in record.text.lower():
-            reply_root = reply_parent = None
-            if record.reply:
-                reply_root = record.reply.root.uri
-                reply_parent = record.reply.parent.uri
+        reply_root = reply_parent = None
+        if record.reply:
+            reply_root = record.reply.root.uri
+            reply_parent = record.reply.parent.uri
 
-            post_dict = {
-                'uri': created_post['uri'],
-                'cid': created_post['cid'],
-                'reply_parent': reply_parent,
-                'reply_root': reply_root,
-            }
-            posts_to_create.append(post_dict)
+        post_dict = {
+            "created_at": record.created_at,
+            "author": author,
+            "uri": created_post["uri"],
+            "cid": created_post["cid"],
+            "text": record.text,
+            "reply_parent": reply_parent,
+            "reply_root": reply_root,
+        }
+        posts_to_create.append(post_dict)
 
-    posts_to_delete = ops[models.ids.AppBskyFeedPost]['deleted']
-    if posts_to_delete:
-        post_uris_to_delete = [post['uri'] for post in posts_to_delete]
-        Post.delete().where(Post.uri.in_(post_uris_to_delete))
-        logger.debug(f'Deleted from feed: {len(post_uris_to_delete)}')
+    # Create likes
+    likes_to_create = []
+    for like in ops[models.ids.AppBskyFeedLike]["created"]:
+        like_dict = {
+            "created_at": like["record"]["created_at"],
+            "author": like["author"],
+            "uri": like["record"]["subject"]["uri"],
+            "cid": like["record"]["subject"]["cid"],
+        }
+        likes_to_create.append(like_dict)
 
+    # Create reposts
+    reposts_to_create = []
+    for repost in ops[models.ids.AppBskyFeedRepost]["created"]:
+        repost_dict = {
+            "created_at": repost["record"]["created_at"],
+            "author": repost["author"],
+            "uri": repost["record"]["subject"]["uri"],
+            "cid": repost["record"]["subject"]["cid"],
+        }
+        reposts_to_create.append(repost_dict)
+
+    # Create follows
+    follows_to_create = []
+    for follow in ops[models.ids.AppBskyGraphFollow]["created"]:
+        follow_dict = {
+            "created_at": follow["record"]["created_at"],
+            "author": follow["author"],
+            "subject": follow["record"]["subject"],
+        }
+        follows_to_create.append(follow_dict)
+
+    # Create follows in db
+    if follows_to_create:
+        with db.atomic():
+            for follow_dict in follows_to_create:
+                Follow.create(**follow_dict)
+        logger.debug(f"Follows indexed: {len(follows_to_create)}")
+
+    # Create posts in db
     if posts_to_create:
         with db.atomic():
             for post_dict in posts_to_create:
                 Post.create(**post_dict)
-        logger.debug(f'Added to feed: {len(posts_to_create)}')
+        logger.debug(f"Posts indexed: {len(posts_to_create)}")
+
+    # Create likes in db
+    if likes_to_create:
+        with db.atomic():
+            for like_dict in likes_to_create:
+                Like.create(**like_dict)
+        logger.debug(f"Likes indexed: {len(likes_to_create)}")
+
+    # Create reposts in db
+    if reposts_to_create:
+        with db.atomic():
+            for repost_dict in reposts_to_create:
+                Repost.create(**repost_dict)
+        logger.debug(f"Reposts indexed: {len(reposts_to_create)}")
+
+    # Delete posts in db
+    posts_to_delete = ops[models.ids.AppBskyFeedPost]["deleted"]
+    if posts_to_delete:
+        post_uris_to_delete = [post["uri"] for post in posts_to_delete]
+        Post.delete().where(Post.uri.in_(post_uris_to_delete))
+        logger.debug(f"Posts deleted: {len(post_uris_to_delete)}")
+
+    # Delete follows in db
+    follows_to_delete = ops[models.ids.AppBskyGraphFollow]["deleted"]
+    follow_uris = []
+    if follows_to_delete:
+        for follow in follows_to_delete:
+            follow_uris.append(follow["uri"])
+        Follow.delete().where(
+            Follow.uri.in_(follow_uris)
+        )
+        logger.debug(f"Follows deleted: {len(follows_to_delete)}")
+
+    # Delete likes in db
+    likes_to_delete = ops[models.ids.AppBskyFeedLike]["deleted"]
+    like_uris = []
+    if likes_to_delete:
+        for like in likes_to_delete:
+            like_uris.append(like["uri"])
+        Like.delete().where(
+            Like.uri.in_(like_uris)
+        )
+        logger.debug(f"Likes deleted: {len(likes_to_delete)}")
+
+    # Delete reposts in db
+    reposts_to_delete = ops[models.ids.AppBskyFeedRepost]["deleted"]
+    repost_uris = []
+    if reposts_to_delete:
+        for repost in reposts_to_delete:
+            repost_uris.append(repost["uri"])
+        Repost.delete().where(
+            Repost.uri.in_(repost_uris)
+        )
+        logger.debug(f"Reposts deleted: {len(reposts_to_delete)}")

server/data_stream.py

···
 import logging
 from collections import defaultdict
 
-from atproto import AtUri, CAR, firehose_models, FirehoseSubscribeReposClient, models, parse_subscribe_repos_message
+from atproto import (
+    CAR,
+    AtUri,
+    FirehoseSubscribeReposClient,
+    firehose_models,
+    models,
+    parse_subscribe_repos_message,
+)
 from atproto.exceptions import FirehoseError
 
-from server.database import SubscriptionState
+from server import RELEVANT_RECORDS
+from server.database import FirehoseSubscriptionState
 from server.logger import logger
 
-_INTERESTED_RECORDS = {
-    models.AppBskyFeedLike: models.ids.AppBskyFeedLike,
-    models.AppBskyFeedPost: models.ids.AppBskyFeedPost,
-    models.AppBskyGraphFollow: models.ids.AppBskyGraphFollow,
-}
-
 
 def _get_ops_by_type(commit: models.ComAtprotoSyncSubscribeRepos.Commit) -> defaultdict:
-    operation_by_type = defaultdict(lambda: {'created': [], 'deleted': []})
+    """
+    Returns a dictionary of operations by type.
+
+    The keys are the record types, and the values are dictionaries with two keys:
+    - 'created': a list of dictionaries with the following keys:
+        - 'record': the record
+        - 'uri': the URI of the record
+        - 'cid': the CID of the record
+        - 'author': the author of the record
+    - 'deleted': a list of dictionaries with the following keys:
+        - 'uri': the URI of the record
+
+    Args:
+        commit: The commit object.
+
+    Returns:
+        A dictionary of operations by type.
+    """
+
+    operation_by_type = defaultdict(lambda: {"created": [], "deleted": []})
 
     car = CAR.from_bytes(commit.blocks)
     for op in commit.ops:
-        if op.action == 'update':
+        if op.action == "update":
             # we are not interested in updates
             continue
 
-        uri = AtUri.from_str(f'at://{commit.repo}/{op.path}')
+        at_uri = AtUri.from_str(f"at://{commit.repo}/{op.path}")
 
-        if op.action == 'create':
+        if op.action == "create":
             if not op.cid:
                 continue
 
-            create_info = {'uri': str(uri), 'cid': str(op.cid), 'author': commit.repo}
+            create_info = {
+                "uri": str(at_uri),
+                "cid": str(op.cid),
+                "author": commit.repo,
+            }
 
             record_raw_data = car.blocks.get(op.cid)
             if not record_raw_data:
···
             if record is None:  # unknown record (out of bsky lexicon)
                 continue
 
-            for record_type, record_nsid in _INTERESTED_RECORDS.items():
-                if uri.collection == record_nsid and models.is_record_type(record, record_type):
-                    operation_by_type[record_nsid]['created'].append({'record': record, **create_info})
+            for record_type, record_nsid in RELEVANT_RECORDS.items():
+                if at_uri.collection == record_nsid and models.is_record_type(
+                    record, record_type
+                ):
+                    operation_by_type[record_nsid]["created"].append(
+                        {"record": record, **create_info}
+                    )
                     break
 
-        if op.action == 'delete':
-            operation_by_type[uri.collection]['deleted'].append({'uri': str(uri)})
+        if op.action == "delete":
+            operation_by_type[at_uri.collection]["deleted"].append({"uri": str(at_uri)})
 
     return operation_by_type
 
···
         except FirehoseError as e:
             if logger.level == logging.DEBUG:
                 raise e
-            logger.error(f'Firehose error: {e}. Reconnecting to the firehose.')
+            logger.error(f"Firehose error: {e}. Reconnecting to the firehose.")
 
 
 def _run(name, operations_callback, stream_stop_event=None):
-    state = SubscriptionState.get_or_none(SubscriptionState.service == name)
+    state = FirehoseSubscriptionState.get_or_none(
+        FirehoseSubscriptionState.service == name
+    )
 
     params = None
     if state:
···
     client = FirehoseSubscribeReposClient(params)
 
     if not state:
-        SubscriptionState.create(service=name, cursor=0)
+        FirehoseSubscriptionState.create(service=name, cursor=0)
 
     def on_message_handler(message: firehose_models.MessageFrame) -> None:
         # stop on next message if requested
···
 
         # update stored state every ~1k events
         if commit.seq % 1000 == 0:  # lower value could lead to performance issues
-            logger.debug(f'Updated cursor for {name} to {commit.seq}')
-            client.update_params(models.ComAtprotoSyncSubscribeRepos.Params(cursor=commit.seq))
-            SubscriptionState.update(cursor=commit.seq).where(SubscriptionState.service == name).execute()
+            logger.debug(f"Updated cursor for {name} to {commit.seq}")
+            client.update_params(
+                models.ComAtprotoSyncSubscribeRepos.Params(cursor=commit.seq)
+            )
+            FirehoseSubscriptionState.update(cursor=commit.seq).where(
+                FirehoseSubscriptionState.service == name
+            ).execute()
 
         if not commit.blocks:
             return

server/database.py

···
 
 import peewee
 
-db = peewee.SqliteDatabase('feed_database.db')
+db = peewee.SqliteDatabase("feed_database.db")
 
 
 class BaseModel(peewee.Model):
···
 
 
 class Post(BaseModel):
+    author = peewee.CharField(index=True)
     uri = peewee.CharField(index=True)
     cid = peewee.CharField()
+    text = peewee.TextField()
     reply_parent = peewee.CharField(null=True, default=None)
     reply_root = peewee.CharField(null=True, default=None)
+    created_at = peewee.DateTimeField()
     indexed_at = peewee.DateTimeField(default=datetime.now(timezone.utc))
 
 
-class SubscriptionState(BaseModel):
+class Like(BaseModel):
+    author = peewee.CharField(index=True)
+    uri = peewee.CharField(index=True)
+    cid = peewee.CharField()
+    created_at = peewee.DateTimeField()
+    indexed_at = peewee.DateTimeField(default=datetime.now(timezone.utc))
+
+
+class Repost(BaseModel):
+    author = peewee.CharField(index=True)
+    uri = peewee.CharField(index=True)
+    cid = peewee.CharField()
+    created_at = peewee.DateTimeField()
+    indexed_at = peewee.DateTimeField(default=datetime.now(timezone.utc))
+
+
+class Follow(BaseModel):
+    author = peewee.CharField(index=True)
+    subject = peewee.CharField(index=True)
+    uri = peewee.CharField(index=True)
+    created_at = peewee.DateTimeField()
+    indexed_at = peewee.DateTimeField(default=datetime.now(timezone.utc))
+
+
+class FirehoseSubscriptionState(BaseModel):
     service = peewee.CharField(unique=True)
     cursor = peewee.BigIntegerField()
 
 
 if db.is_closed():
     db.connect()
-    db.create_tables([Post, SubscriptionState])
+    db.create_tables([Post, Like, Repost, Follow, FirehoseSubscriptionState])

server/utils.py

···
+def get_author_from_uri(uri: str) -> str:
+    return uri.split("/")[2]

uv.lock

···
     { name = "python-dotenv" },
 ]
 
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "ruff" },
+]
+lint = [
+    { name = "ruff" },
+]
+test = [
+    { name = "pytest" },
+]
+
 [package.metadata]
 requires-dist = [
     { name = "atproto", specifier = "==0.0.59" },
     { name = "flask", specifier = "~=2.3.2" },
-    { name = "peewee", specifier = "~=3.16.2" },
+    { name = "peewee", specifier = "~=3.18.2" },
     { name = "python-dotenv", specifier = "~=1.0.0" },
 ]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest" },
+    { name = "ruff" },
+]
+lint = [{ name = "ruff" }]
+test = [{ name = "pytest" }]
 
 [[package]]
 name = "annotated-types"
···
 ]
 
 [[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
 name = "itsdangerous"
 version = "2.2.0"
 source = { registry = "https://pypi.org/simple" }
···
 ]
 
 [[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
 name = "peewee"
-version = "3.16.3"
+version = "3.18.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e2/1e/6455dc3c759af3e565414985c5c6f845d3e5f83bbf4a24cdd0aef9cc3f83/peewee-3.16.3.tar.gz", hash = "sha256:12b30e931193bc37b11f7c2ac646e3f67125a8b1a543ad6ab37ad124c8df7d16", size = 928003, upload-time = "2023-08-14T14:15:20.65Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/89/76f6f1b744c8608e0d416b588b9d63c2a500ff800065ae610f7c80f532d6/peewee-3.18.2.tar.gz", hash = "sha256:77a54263eb61aff2ea72f63d2eeb91b140c25c1884148e28e4c0f7c4f64996a0", size = 949220, upload-time = "2025-07-08T12:52:03.941Z" }
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
 
 [[package]]
 name = "pycparser"
···
 ]
 
 [[package]]
+name = "pygments"
+version = "2.19.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "8.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/5c/00a0e072241553e1a7496d638deababa67c5058571567b92a7eaa258397c/pytest-8.4.2.tar.gz", hash = "sha256:86c0d0b93306b961d58d62a4db4879f27fe25513d4b969df351abdddb3c30e01", size = 1519618, upload-time = "2025-09-04T14:34:22.711Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a8/a4/20da314d277121d6534b3a980b29035dcd51e6744bd79075a6ce8fa4eb8d/pytest-8.4.2-py3-none-any.whl", hash = "sha256:872f880de3fc3a5bdc88a11b39c9710c3497a547cfa9320bc3c5e62fbf272e79", size = 365750, upload-time = "2025-09-04T14:34:20.226Z" },
+]
+
+[[package]]
 name = "python-dotenv"
 version = "1.0.1"
 source = { registry = "https://pypi.org/simple" }
 sdist = { url = "https://files.pythonhosted.org/packages/bc/57/e84d88dfe0aec03b7a2d4327012c1627ab5f03652216c63d49846d7a6c58/python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca", size = 39115, upload-time = "2024-01-23T06:33:00.505Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863, upload-time = "2024-01-23T06:32:58.246Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.14.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/34/8218a19b2055b80601e8fd201ec723c74c7fe1ca06d525a43ed07b6d8e85/ruff-0.14.2.tar.gz", hash = "sha256:98da787668f239313d9c902ca7c523fe11b8ec3f39345553a51b25abc4629c96", size = 5539663, upload-time = "2025-10-23T19:37:00.956Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/16/dd/23eb2db5ad9acae7c845700493b72d3ae214dce0b226f27df89216110f2b/ruff-0.14.2-py3-none-linux_armv6l.whl", hash = "sha256:7cbe4e593505bdec5884c2d0a4d791a90301bc23e49a6b1eb642dd85ef9c64f1", size = 12533390, upload-time = "2025-10-23T19:36:18.044Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/8c/5f9acff43ddcf3f85130d0146d0477e28ccecc495f9f684f8f7119b74c0d/ruff-0.14.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:8d54b561729cee92f8d89c316ad7a3f9705533f5903b042399b6ae0ddfc62e11", size = 12887187, upload-time = "2025-10-23T19:36:22.664Z" },
+    { url = "https://files.pythonhosted.org/packages/99/fa/047646491479074029665022e9f3dc6f0515797f40a4b6014ea8474c539d/ruff-0.14.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:5c8753dfa44ebb2cde10ce5b4d2ef55a41fb9d9b16732a2c5df64620dbda44a3", size = 11925177, upload-time = "2025-10-23T19:36:24.778Z" },
+    { url = "https://files.pythonhosted.org/packages/15/8b/c44cf7fe6e59ab24a9d939493a11030b503bdc2a16622cede8b7b1df0114/ruff-0.14.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3d0bbeffb8d9f4fccf7b5198d566d0bad99a9cb622f1fc3467af96cb8773c9e3", size = 12358285, upload-time = "2025-10-23T19:36:26.979Z" },
+    { url = "https://files.pythonhosted.org/packages/45/01/47701b26254267ef40369aea3acb62a7b23e921c27372d127e0f3af48092/ruff-0.14.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7047f0c5a713a401e43a88d36843d9c83a19c584e63d664474675620aaa634a8", size = 12303832, upload-time = "2025-10-23T19:36:29.192Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/5c/ae7244ca4fbdf2bee9d6405dcd5bc6ae51ee1df66eb7a9884b77b8af856d/ruff-0.14.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3bf8d2f9aa1602599217d82e8e0af7fd33e5878c4d98f37906b7c93f46f9a839", size = 13036995, upload-time = "2025-10-23T19:36:31.861Z" },
+    { url = "https://files.pythonhosted.org/packages/27/4c/0860a79ce6fd4c709ac01173f76f929d53f59748d0dcdd662519835dae43/ruff-0.14.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:1c505b389e19c57a317cf4b42db824e2fca96ffb3d86766c1c9f8b96d32048a7", size = 14512649, upload-time = "2025-10-23T19:36:33.915Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/7f/d365de998069720a3abfc250ddd876fc4b81a403a766c74ff9bde15b5378/ruff-0.14.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a307fc45ebd887b3f26b36d9326bb70bf69b01561950cdcc6c0bdf7bb8e0f7cc", size = 14088182, upload-time = "2025-10-23T19:36:36.983Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/ea/d8e3e6b209162000a7be1faa41b0a0c16a133010311edc3329753cc6596a/ruff-0.14.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:61ae91a32c853172f832c2f40bd05fd69f491db7289fb85a9b941ebdd549781a", size = 13599516, upload-time = "2025-10-23T19:36:39.208Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ea/c7810322086db68989fb20a8d5221dd3b79e49e396b01badca07b433ab45/ruff-0.14.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1967e40286f63ee23c615e8e7e98098dedc7301568bd88991f6e544d8ae096", size = 13272690, upload-time = "2025-10-23T19:36:41.453Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/39/10b05acf8c45786ef501d454e00937e1b97964f846bf28883d1f9619928a/ruff-0.14.2-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:2877f02119cdebf52a632d743a2e302dea422bfae152ebe2f193d3285a3a65df", size = 13496497, upload-time = "2025-10-23T19:36:43.61Z" },
+    { url = "https://files.pythonhosted.org/packages/59/a1/1f25f8301e13751c30895092485fada29076e5e14264bdacc37202e85d24/ruff-0.14.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:e681c5bc777de5af898decdcb6ba3321d0d466f4cb43c3e7cc2c3b4e7b843a05", size = 12266116, upload-time = "2025-10-23T19:36:45.625Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/fa/0029bfc9ce16ae78164e6923ef392e5f173b793b26cc39aa1d8b366cf9dc/ruff-0.14.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e21be42d72e224736f0c992cdb9959a2fa53c7e943b97ef5d081e13170e3ffc5", size = 12281345, upload-time = "2025-10-23T19:36:47.618Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/ab/ece7baa3c0f29b7683be868c024f0838770c16607bea6852e46b202f1ff6/ruff-0.14.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:b8264016f6f209fac16262882dbebf3f8be1629777cf0f37e7aff071b3e9b92e", size = 12629296, upload-time = "2025-10-23T19:36:49.789Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/7f/638f54b43f3d4e48c6a68062794e5b367ddac778051806b9e235dfb7aa81/ruff-0.14.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:5ca36b4cb4db3067a3b24444463ceea5565ea78b95fe9a07ca7cb7fd16948770", size = 13371610, upload-time = "2025-10-23T19:36:51.882Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/35/3654a973ebe5b32e1fd4a08ed2d46755af7267da7ac710d97420d7b8657d/ruff-0.14.2-py3-none-win32.whl", hash = "sha256:41775927d287685e08f48d8eb3f765625ab0b7042cc9377e20e64f4eb0056ee9", size = 12415318, upload-time = "2025-10-23T19:36:53.961Z" },
+    { url = "https://files.pythonhosted.org/packages/71/30/3758bcf9e0b6a4193a6f51abf84254aba00887dfa8c20aba18aa366c5f57/ruff-0.14.2-py3-none-win_amd64.whl", hash = "sha256:0df3424aa5c3c08b34ed8ce099df1021e3adaca6e90229273496b839e5a7e1af", size = 13565279, upload-time = "2025-10-23T19:36:56.578Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/5d/aa883766f8ef9ffbe6aa24f7192fb71632f31a30e77eb39aa2b0dc4290ac/ruff-0.14.2-py3-none-win_arm64.whl", hash = "sha256:ea9d635e83ba21569fbacda7e78afbfeb94911c9434aff06192d9bc23fd5495a", size = 12554956, upload-time = "2025-10-23T19:36:58.714Z" },
 ]
 
 [[package]]