import library properly, fix types

.gitignore

···
+__pycache__/

main.py

···
+import argparse
+import asyncio
 from collections import Counter
+from typing import List
 
-import requests
-from atproto import AtUri, Client
+from atproto import AtUri, Client, DidDocument
 from atproto_identity.did.resolver import DidResolver
+from microcosmClient import AsyncMicrocosmClient
 
 client = Client(base_url="https://bsky.social")
 resolver = DidResolver(plc_url="https://plc.directory")
 
 
-def getRecs(uri: AtUri, n=100):
-    # get the users that liked that item
-    # go get the n most recent liked items for each of those users
-    # return the most common items from that list
+async def getRecs(uri: AtUri, n: int = 100, concurrency: int = 10) -> List[tuple]:
+    """Return top liked subject URIs as (uri, count) tuples for likers of the given target.
 
-    response = requests.get(
-        f"https://constellation.microcosm.blue/links/distinct-dids?target={uri}&collection=app.bsky.feed.like&path=.subject.uri&limit={n}", headers={'Accept': 'application/json'})
+    - Uses Microcosm to find distinct likers of `uri`.
+    - For each liker (repo), resolves the DID and calls the blocking AtProto repo.list_records in a thread.
+    """
+    async with AsyncMicrocosmClient() as micro:
+        data = await micro.links_distinct_dids(uri, "app.bsky.feed.like", ".subject.uri")
 
-    if response.status_code == 200:
-        data = response.json()
-        likers = data['linking_dids']
+    likers = data.get("linking_dids", [])
+    if not likers:
+        return []
 
-        records = []
-        for user in likers:
-            didDoc = resolver.resolve(user)
-            client.update_base_url(didDoc.service[0].service_endpoint)
-            likes = client.com.atproto.repo.list_records(params={"collection": "app.bsky.feed.like",
-                                                                 "repo": user,
-                                                                 "limit": n})
-            for record in likes.records:
-                records.append(record.value.subject.uri)
+    semaphore = asyncio.Semaphore(concurrency)
 
-        c = Counter([r for r in records if r != str(uri)])
-        for item, count in c.most_common(10):
-            print(
-                f"https://bsky.app/profile/{item.split('at://')[1].split('/')[0] + '/post/' + item.split('/')[-1]}: {count}")
-    else:
-        print("Error fetching data:", response.status_code)
+    async def fetch(repo: str):
+        async with semaphore:
+            try:
+                did: DidDocument | None = await asyncio.to_thread(resolver.resolve, repo)
+                if not did or not did.service:
+                    return []
+                await asyncio.to_thread(client.update_base_url, did.service[0].service_endpoint)
+                likes = await asyncio.to_thread(lambda: client.com.atproto.repo.list_records(params={"collection": "app.bsky.feed.like", "repo": repo, "limit": n}))
+                return [r["value"]["subject"]["uri"] for r in likes["records"]]
+            except Exception:
+                return []
+
+    tasks = [asyncio.create_task(fetch(u)) for u in likers]
+    records: List[str] = []
+    for t in asyncio.as_completed(tasks):
+        records.extend(await t)
+
+    records = [r for r in records if r and r != str(uri)]
+    c = Counter(records)
+    return c.most_common(5)
 
 
 def fromPost(post: str) -> AtUri:
     handle, rkey = post.split("/post/")
     handle = handle.split("https://bsky.app/profile/")[1]
-    did = client.com.atproto.identity.resolve_handle(
-        params={"handle": handle})
+    did = client.com.atproto.identity.resolve_handle(params={"handle": handle})
     return AtUri.from_str(f"at://{did.did}/app.bsky.feed.post/{rkey}")
 
 
-getRecs(fromPost("https://bsky.app/profile/beverage2000.bsky.social/post/3lzpn5gewbc2e"))
+def toPost(uri) -> str:
+    did = uri.split('//')[1].split('/')[0]
+    rkey = uri.split('.post/')[1]
+    return f"https://bsky.app/profile/{did}/post/{rkey}"
+
+
+async def main(post: str):
+    uri = fromPost(post)
+    recs = await getRecs(uri)
+    if not recs:
+        print("No recommendations found.")
+        return
+    for item, count in recs:
+        print(f"{toPost(item)}: {count}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "post", nargs="?", default="https://bsky.app/profile/beverage2000.bsky.social/post/3lzpn5gewbc2e")
+    args = parser.parse_args()
+    asyncio.run(main(args.post))