reddrix 0.1.0__py3-none-any.whl

reddrix/__init__.py

@@ -0,0 +1,2 @@
+from .reddrix import Reddrix
+__version__ = "0.1.0"

reddrix/cli.py

@@ -0,0 +1,25 @@
+from camoufox.pkgman import CamoufoxFetcher
+import argparse
+
+
+def install_binary():
+    CamoufoxFetcher().install(replace=True)
+
+def main():
+    parser = argparse.ArgumentParser(prog="reddrix", description="Reddrix --- all-in-one Reddit scraper")
+    subparsers = parser.add_subparsers(dest="command")
+    subparsers.add_parser(
+        name="install",
+        help="Installs the Camoufox binary dependency."
+    )
+    
+    args = parser.parse_args()
+    
+    if args.command == "install":
+        install_binary()
+    else:
+        print(f"[reddrix] `{args.command}` is not a valid command.", flush=True)
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

reddrix/exceptions.py

@@ -0,0 +1,8 @@
+class FatalAntiBotBlockError(Exception):
+    """Raised when the scraper is blocked after exhausting all attempts."""
+    pass
+
+
+class AntiBotBlockError(Exception):
+    """Raised when the scraper is blocked once."""
+    pass

reddrix/reddrix.py

@@ -0,0 +1,772 @@
+from playwright.async_api import Browser, BrowserContext, Page, TimeoutError as PlaywrightTimeoutError, Error
+from curl_cffi.requests.exceptions import SessionClosed, HTTPError, JSONDecodeError
+from .exceptions import AntiBotBlockError, FatalAntiBotBlockError
+from playwright._impl._errors import TargetClosedError
+from camoufox.exceptions import UnknownIPLocation
+from camoufox.async_api import AsyncCamoufox
+from urllib.parse import urlencode, urlparse
+from collections.abc import AsyncGenerator
+from datetime import datetime, timezone
+from whiskeysour import WhiskeySour
+from curl_cffi import AsyncSession
+from functools import wraps
+from platform import system
+from typing import Literal
+import asyncio
+import random
+import time
+
+
+COOKIE_URL = "https://www.reddit.com/r/kasralainy" # Lightweight sub page to reduce network bandwidth if using a proxy.
+LOGIN_BTN_SELECTOR = "#login-button" # Used as a success signal for session cookies.
+MAX_RETRIES = 5
+PLATFORMS = {
+    "windows": "windows",
+    "linux": "linux",
+    "darwin": "macos"
+}
+TIME_FRAMES = {
+    "all_time": "all",
+    "past_hour": "hour",
+    "today": "day",
+    "past_week": "week",
+    "past_month": "month",
+    "past_year": "year"
+}
+COOKIE_LOCK = asyncio.Lock()
+
+def auto_retry(max_attempts: int):
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            url = kwargs.get("url") or args[1] if func.__name__ == "fetch_page_data" else None
+            scraper: Reddrix = args[0]
+
+            for attempt in range(max_attempts + 1):
+                current_time = time.time()
+                try:
+                    result = await func(*args, **kwargs)
+                except AntiBotBlockError:
+                    if attempt == max_attempts:
+                        if url:
+                            raise FatalAntiBotBlockError(f"Error fetching URL: {url}\n\nError Message: Cookies expired, and attempts have been exhausted.")
+                        else:
+                            raise FatalAntiBotBlockError(f"Error executing function: {func.__name__}\n\nError Message: Cookies expired, and attempts have been exhausted.")
+
+                    async with COOKIE_LOCK:
+                        if current_time - scraper.cookies_last_renewed_at >= 8:
+                            await scraper.refresh_cookies()
+
+                    await asyncio.sleep(min(2 ** attempt + random.uniform(0, 5), 60))
+                else:
+                    return result
+
+        return wrapper
+
+    return decorator
+
+class Reddrix:
+    def __init__(
+        self,
+        mode: Literal["standard", "keyword_search", "domain_search"]="standard",
+        http_client: Literal["curl_cffi", "camoufox"]="curl_cffi",
+        max_results: int=999999,
+        max_posts_per_collection: int=999999,
+        sort: Literal["default", "new", "hot"]="default",
+        time_frame: Literal["all_time", "past_hour", "today", "past_week", "past_month", "past_year"]="all_time",
+        subreddit_urls: list[str]=[],
+        post_urls: list[str]=[],
+        profile_urls: list[str]=[],
+        domains: list[str]=[],
+        query: str=None,
+        include_comments: bool=False,
+        max_comments_depth: int=10,
+        max_comments_per_post: int=999999,
+        max_top_comments_per_post: int=999999,
+        proxies: list[str]=[],
+        verbose: bool=False
+    ):
+        self.mode = mode
+        self.max_results = max_results
+        self.max_posts_per_collection = max_posts_per_collection
+        self.sort = sort
+        self.time_frame = TIME_FRAMES[time_frame]
+        self.subreddit_urls = subreddit_urls
+        self.post_urls = post_urls
+        self.profile_urls = profile_urls
+        self.domains = domains
+        self.query = query
+        self.include_comments = include_comments
+        self.max_comments_depth = max_comments_depth
+        self.max_comments_per_post = max_comments_per_post
+        self.max_top_comments_per_post = max_top_comments_per_post
+        self.proxies = proxies
+        self.is_verbose = verbose
+        self.used_proxies = set()
+        
+        self.http_client = http_client
+        self.browser: Browser | None = None
+        self.context: BrowserContext | None = None
+        self.page: Page | None = None
+        self.session: AsyncSession | None = None
+        self.started = False
+        self.cookie_renewal_in_progress = False
+        self.cookies_last_accessed_at = 0.0
+        self.request_semaphore = asyncio.Semaphore(10)
+        self.items_queue = asyncio.Queue(maxsize=1000)
+    
+    async def start(self):
+        return await self.__aenter__()
+    
+    async def stop(self):
+        await self.__aexit__(None, None, None)
+    
+    def new_proxy_url(self) -> str | None:
+        if not self.proxies:
+            return None
+        
+        proxy_to_be_used = None
+        for proxy in self.proxies:
+            if proxy not in self.used_proxies:
+                self.used_proxies.add(proxy)
+                proxy_to_be_used = proxy
+                break
+        
+        if not proxy_to_be_used:
+            self.used_proxies.clear()
+            proxy_to_be_used = random.choice(self.proxies)
+            self.used_proxies.add(proxy_to_be_used)
+        
+        return proxy_to_be_used
+    
+    async def __aenter__(self):
+        initialization_successful = False
+        self.log("INITIALIZING SCRAPER")
+        for attempt in range(1, MAX_RETRIES + 1):
+            try:
+                if self.http_client == "camoufox":
+                    proxy_url = self.new_proxy_url()
+                    parsed_url = urlparse(proxy_url)
+                    self.camoufox = AsyncCamoufox(
+                        os=PLATFORMS[system().lower()],
+                        headless=True,
+                        fingerprint_preset=True,
+                        proxy={
+                            "server": f"{parsed_url.scheme}://{parsed_url.hostname}:{parsed_url.port}",
+                            "username": parsed_url.username,
+                            "password": parsed_url.password
+                        } if proxy_url else None,
+                        geoip=True if proxy_url else False
+                    )
+                    self.browser: Browser = await self.camoufox.start()
+                    self.context = await self.browser.new_context()
+                    self.page = await self.context.new_page()
+                    await self.page.goto(COOKIE_URL)
+                    await self.page.wait_for_selector(LOGIN_BTN_SELECTOR, timeout=15000)
+                else:
+                    self.session = AsyncSession(proxy=self.new_proxy_url(), allow_redirects=True)
+                    self.session.headers["User-Agent"] = f"Reddrix{random.randint(0, 999999)}/v0.1.0"
+                    res = await self.session.get("https://old.reddit.com/login")
+                    res.raise_for_status()
+                
+                self.started = True
+            except (ValueError, PlaywrightTimeoutError, TimeoutError, Error, HTTPError, UnknownIPLocation):
+                self.log(f"INITIALIZATION ATTEMPT {attempt}/{MAX_RETRIES} FAILED. RETRYING...", level="error")
+                if self.http_client == "camoufox":
+                    try:
+                        await self.context.close()
+                        await self.browser.__aexit__(None, None, None)
+                        await self.session.__aexit__(None, None, None)
+                    except AttributeError:
+                        pass
+                else:
+                    await self.session.close()
+                
+                self.started = False
+            else:
+                initialization_successful = True
+                self.started = True
+                self.cookies_last_accessed_at = time.time()
+                break
+        
+        if not initialization_successful:
+            raise FatalAntiBotBlockError(f"FAILED TO CONNECT TO REDDIT AFTER {MAX_RETRIES} ATTEMPTS.")
+        
+        return self
+    
+    async def __aexit__(self, exc_type, exc, tb):
+        if self.http_client == "camoufox":
+            try:
+                await self.context.close()
+                await self.browser.__aexit__(None, None, None)
+                await self.camoufox.__aexit__(None, None, None)
+            except AttributeError:
+                pass
+        else:
+            await self.session.close()
+        
+        self.started = False
+    
+    async def refresh_cookies(self):
+        if self.cookie_renewal_in_progress:
+            return
+        
+        self.cookie_renewal_in_progress = True
+        cookie_refresh_successful = False
+        self.log("REFRESHING COOKIES...")
+        
+        if self.http_client == "camoufox":
+            try:
+                await self.context.close()
+                await self.browser.__aexit__(None, None, None)
+                await self.session.__aexit__(None, None, None)
+            except AttributeError:
+                pass
+        else:
+            await self.session.close()
+        
+        
+        for attempt in range(1, MAX_RETRIES + 1):
+            try:
+                if self.http_client == "camoufox":
+                    proxy_url = self.new_proxy_url()
+                    parsed_url = urlparse(proxy_url)
+                    self.camoufox = AsyncCamoufox(
+                        os=PLATFORMS[system().lower()],
+                        headless=True,
+                        fingerprint_preset=True,
+                        proxy={
+                            "server": f"{parsed_url.scheme}://{parsed_url.hostname}:{parsed_url.port}",
+                            "username": parsed_url.username,
+                            "password": parsed_url.password
+                        } if proxy_url else None,
+                        geoip=True if proxy_url else False
+                    )
+                    self.browser: Browser = await self.camoufox.start()
+                    self.context = await self.browser.new_context()
+                    self.page = await self.context.new_page()
+                    await self.page.goto(COOKIE_URL)
+                    await self.page.wait_for_selector(LOGIN_BTN_SELECTOR, timeout=15000)
+                else:
+                    self.session = AsyncSession(proxy=self.new_proxy_url(), allow_redirects=True)
+                    self.session.headers["User-Agent"] = f"Reddrix{random.randint(0, 999999)}/v0.1.0"
+                    res = await self.session.get("https://old.reddit.com/login")
+                    res.raise_for_status()
+            except (ValueError, PlaywrightTimeoutError, TimeoutError, Error, HTTPError, UnknownIPLocation):
+                self.log(f"COOKIE REFRESH ATTEMPT {attempt}/{MAX_RETRIES} FAILED. RETRYING...", level="error")
+                
+                if self.http_client == "camoufox":
+                    try:
+                        await self.context.close()
+                        await self.browser.__aexit__(None, None, None)
+                        await self.session.__aexit__(None, None, None)
+                    except AttributeError:
+                        pass
+                else:
+                    await self.session.close()
+                
+                self.cookies_last_accessed_at = time.time()
+            else:
+                cookie_refresh_successful = True
+                self.cookies_last_accessed_at = time.time()
+                break
+        
+        if not cookie_refresh_successful:
+            raise FatalAntiBotBlockError(f"FAILED TO REFRESH COOKIES AFTER {MAX_RETRIES} ATTEMPTS.")
+        
+        self.cookie_renewal_in_progress = False
+    
+    def log(self, msg: str=None, level: Literal["info", "warning", "error"]="info"):
+        if msg and self.is_verbose:
+            now = datetime.fromtimestamp(time.time(), tz=timezone.utc).isoformat()
+            print(f"{now} [reddrix] [{level.upper()}] {msg}", flush=True)
+    
+    def parse_item(self, raw: dict) -> dict:
+        """Parses each raw post or comment."""
+
+        data: dict = raw["data"]
+        if raw["kind"] == "t3": # Posts
+            submission_id = data["id"]
+            submission_id_prefixed = f"t3_{submission_id}"
+            submission_type = "post"
+            submission_url = "https://www.reddit.com" + data["permalink"]
+            submitted_at = datetime.fromtimestamp(data["created_utc"], tz=timezone.utc).isoformat()
+            parent_id = None
+            parent_post_id = None
+            parent_post_url = None
+            post_type = None
+            is_crosspost = "crosspost_parent" in data
+            crosspost_parent_id = data.get("crosspost_parent")
+            
+            if is_crosspost:
+                crosspost_parent_url = "https://www.reddit.com" + data.get("url_overridden_by_dest")
+            else:
+                crosspost_parent_url = None
+
+            if (data.get("is_self", False) or False) and "poll_data" in data:
+                post_type = "poll"
+            elif (data.get("is_self", False) or False) and "poll_data" not in data:
+                post_type = "text"
+            elif data.get("post_hint", "") == "link":
+                post_type = "link"
+            elif data["is_video"] or data.get("domain") == "v.redd.it" or ((data.get("media", {}) or {}).get("oembed", {}) or {}).get("type") == "video":
+                post_type = "video"
+            elif data.get("post_hint", "") == "image" or data.get("domain") == "i.redd.it":
+                post_type = "image"
+            elif data.get("is_gallery", False):
+                post_type = "gallery"
+            elif "self." not in (data.get("domain", "") or ""):
+                post_type = "link"
+
+            title = data["title"]
+            body_text = data["selftext"]
+            is_edited = False if not data["edited"] else True
+            author = data["author"]
+            author_flair_text = data.get("author_flair_text")
+            author_flair_image_url = (data.get("author_flair_richtext", [{}]) or [{}])[0].get("u")
+            depth = None
+            post_flair = data.get("link_flair_text") or None
+            is_nsfw = data.get("over_18", False) or False
+            subreddit = data.get("subreddit_name_prefixed") or None
+            score = data["score"]
+            upvote_ratio = data.get("upvote_ratio") or None
+            num_comments = data["num_comments"]
+            num_crossposts = data.get("num_crossposts", 0) or 0
+            
+            if is_crosspost:
+                external_url = "https://www.reddit.com" + data.get("url_overridden_by_dest")
+            else:
+                external_url = data.get("url_overridden_by_dest")
+
+            if "preview.redd.it" in (data.get("thumbnail", "") or ""):
+                if not ((data.get("secure_media", {}) or {}).get("oembed", {}) or {}).get("thumbnail_url"):
+                    thumbnail_url = f'https://i.redd.it/{data.get("thumbnail").split(".it/")[-1].split("?")[0]}'
+                else:
+                    thumbnail_url = ((data.get("secure_media", {}) or {}).get("oembed", {}) or {}).get("thumbnail_url")
+            else:
+                thumbnail_url = None
+
+            if post_type == "video":
+                video_url = (((data.get("media", {}) or {}).get("reddit_video", {}) or {}).get("fallback_url", "") or "").split("?")[0]
+                if not video_url:
+                    video_url = external_url
+            else:
+                video_url = None
+
+            if post_type == "image":
+                image_url = thumbnail_url if isinstance(thumbnail_url, str) and "preview.reddit" in thumbnail_url else external_url
+            else:
+                image_url = None
+
+            if post_type == "gallery":
+                img_extension = data["thumbnail"].split("?")[0].split(".")[-1]
+                gallery_images_urls = [f'https://i.redd.it/{id_}.{img_extension}' for id_ in [item["media_id"] for item in data["gallery_data"]["items"]]]
+
+            else:
+                gallery_images_urls = []
+
+            return {
+                "submissionId": submission_id,
+                "submissionIdPrefixed": submission_id_prefixed,
+                "submissionType": submission_type,
+                "submissionUrl": submission_url,
+                "submittedAt": submitted_at,
+                "parentId": parent_id,
+                "parentPostId": parent_post_id,
+                "parentPostUrl": parent_post_url,
+                "postType": post_type,
+                "isCrosspost": is_crosspost,
+                "crosspostParentId": crosspost_parent_id,
+                "crosspostParentUrl": crosspost_parent_url,
+                "title": title,
+                "bodyText": body_text,
+                "isEdited": is_edited,
+                "author": author,
+                "authorFlairText": author_flair_text,
+                "authorFlairImageUrl": author_flair_image_url,
+                "depth": depth,
+                "postFlair": post_flair,
+                "isNSFW": is_nsfw,
+                "subreddit": subreddit,
+                "score": score,
+                "upvoteRatio": upvote_ratio,
+                "numComments": num_comments,
+                "numCrossposts": num_crossposts,
+                "externalUrl": external_url,
+                "thumbnailUrl": thumbnail_url,
+                "videoUrl": video_url,
+                "imageUrl": image_url,
+                "galleryImagesUrls": gallery_images_urls
+            }
+            
+        else: # Comments
+            submission_id = data["id"]
+            submission_id_prefixed = f"t1_{submission_id}"
+            submission_type = "comment"
+            submission_url: str = "https://www.reddit.com" + data["permalink"]
+            submitted_at = datetime.fromtimestamp(data["created_utc"], tz=timezone.utc).isoformat()
+            parent_id = data["parent_id"]
+            parent_post_id = data["link_id"]
+            parent_post_url = submission_url.split("/comments/")[0] + "/comments/"  + submission_url.split("/comments/")[-1].split("/")[0]
+            post_type = None
+            is_crosspost = False
+            crosspost_parent_id = None
+            crosspost_parent_url = None
+            title = None
+            body_text = data["body"]
+            is_edited = False if not data["edited"] else True
+            author = data["author"]
+            author_flair_text = data.get("author_flair_text")
+            author_flair_image_url = (data.get("author_flair_richtext", [{}]) or [{}])[0].get("u")
+            depth = data["depth"]
+            post_flair = None
+            is_nsfw = False
+            subreddit = data.get("subreddit_name_prefixed")
+            score = data["score"]
+            upvote_ratio = None
+            num_comments = None
+            num_crossposts = None
+            external_url = None
+            thumbnail_url = None
+            image_url = None
+            video_url = None
+            gallery_images_urls = []
+
+            return {
+                "submissionId": submission_id,
+                "submissionIdPrefixed": submission_id_prefixed,
+                "submissionType": submission_type,
+                "submissionUrl": submission_url,
+                "submittedAt": submitted_at,
+                "parentId": parent_id,
+                "parentPostId": parent_post_id,
+                "parentPostUrl": parent_post_url,
+                "postType": post_type,
+                "isCrosspost": is_crosspost,
+                "crosspostParentId": crosspost_parent_id,
+                "crosspostParentUrl": crosspost_parent_url,
+                "title": title,
+                "bodyText": body_text,
+                "isEdited": is_edited,
+                "author": author,
+                "authorFlairText": author_flair_text,
+                "authorFlairImageUrl": author_flair_image_url,
+                "depth": depth,
+                "postFlair": post_flair,
+                "isNSFW": is_nsfw,
+                "subreddit": subreddit,
+                "score": score,
+                "upvoteRatio": upvote_ratio,
+                "numComments": num_comments,
+                "numCrossposts": num_crossposts,
+                "externalUrl": external_url,
+                "thumbnailUrl": thumbnail_url,
+                "videoUrl": video_url,
+                "imageUrl": image_url,
+                "galleryImagesUrls": gallery_images_urls
+            }
+    
+    @auto_retry(max_attempts=3)
+    async def get(self, url: str, params: dict={}, expected_data_type: Literal["JSON", "HTML/XML"]="JSON") -> dict | list | str:
+        if params:
+            url += f"{'?' if '?' not in url else ''}{urlencode(params) if '?' not in url else f'&{urlencode(params)}'}"
+        
+        while self.cookie_renewal_in_progress:
+            await asyncio.sleep(0.07)
+        
+        if self.http_client == "camoufox":
+            try:
+                if expected_data_type == "JSON":
+                    data: list | dict = await self.page.evaluate(r"async (url) => {const res = await fetch(url); return await res.json();}", url)
+                else:
+                    data: str = await self.page.evaluate(r"async (url) => {const res = await fetch(url); return await res.text();}", url)
+                
+                if isinstance(data, dict) and data.get("error", 200) in [403, 404] and ("/user/" in url or "/u/" in url) and "/comments/" not in url:
+                    return {} if expected_data_type == "JSON" else ""
+                elif isinstance(data, dict) and data.get("error", 200) >= 400:
+                    raise AntiBotBlockError
+            except Error:
+                raise AntiBotBlockError
+            except AttributeError:
+                data = {} if expected_data_type == "JSON" else ""
+                pass
+        else:
+            try:
+                res = await self.session.get(url)
+                res.raise_for_status()
+                
+                if expected_data_type == "JSON":
+                    data: list | dict = res.json()
+                else:
+                    data: str = res.text       
+            except HTTPError:
+                if "/user/" in url or "/u/" in url:
+                    return {} if expected_data_type == "JSON" else ""
+                else:
+                    raise AntiBotBlockError
+            except JSONDecodeError:
+                raise AntiBotBlockError
+        
+        return data
+
+    @auto_retry(max_attempts=3)
+    async def fetch_children_batch(self, post_id: str, id_batch: list) -> tuple[list[dict]]:
+        api_url = f"https://www.reddit.com/api/morechildren.json?api_type=json&link_id={post_id}&children={','.join(id_batch)}"
+        async with self.request_semaphore:
+            await asyncio.sleep(random.uniform(0.5, 4)) # Random jitter
+            page_data = await self.get(api_url)
+            if page_data["json"]["errors"]:
+                raise AntiBotBlockError
+
+        return [item for item in page_data["json"]["data"]["things"] if item["kind"] == "t1" and item["data"]["id"] != "_" and item["data"]["depth"] <= self.max_comments_depth], [item for item in page_data["json"]["data"]["things"] if item["kind"] == "more" and item["data"]["id"] != "_" and item["data"]["depth"] <= self.max_comments_depth]
+
+    @auto_retry(max_attempts=3)
+    async def fetch_more_comments(self, post_id: str, more_items: list, fetched_comments_count: int, fetched_top_comments_count: int) -> tuple[dict, int, int]:
+        more_ids_batches = {}
+        more = []
+
+        for item in more_items:
+            item_id = item["data"]["id"]
+            more_ids_batches.update({item_id: [[]]})
+
+            for child in item["data"]["children"]:
+                more_ids_batches[item_id][-1].append(child)
+                if len(more_ids_batches[item_id][-1]) % 100 == 0:
+                    more_ids_batches[item_id].append([])
+
+            if not more_ids_batches[item_id][-1]:
+                more_ids_batches[item_id] = more_ids_batches[item_id][:-1]
+
+        all_batches = [batch for batches in more_ids_batches.values() for batch in batches]
+        batch_tasks = [self.fetch_children_batch(post_id, batch) for batch in all_batches]
+
+        for future in asyncio.as_completed(batch_tasks):
+            comments, new_more = await future
+
+            if fetched_comments_count >= self.max_comments_per_post:
+                break
+
+            more.extend(new_more)
+
+            for comment in comments:
+                if fetched_comments_count >= self.max_comments_per_post:
+                    break
+
+                if comment["kind"] == "t1" and comment["data"]["depth"] <= self.max_comments_depth:
+                    if comment["data"]["depth"] == 0:
+                        if fetched_comments_count < self.max_comments_per_post and fetched_top_comments_count < self.max_top_comments_per_post:
+                            await self.items_queue.put(comment)
+                            fetched_comments_count += 1
+                            fetched_top_comments_count += 1
+                    else:
+                        if fetched_comments_count < self.max_comments_per_post:
+                            await self.items_queue.put(comment)
+                            fetched_comments_count += 1
+
+        return more, fetched_comments_count, fetched_top_comments_count
+
+    async def fetch_post(self, url: str) -> None:
+        fetched_comments_count = 0
+        fetched_top_comments_count = 0
+        more = []
+
+        async with self.request_semaphore:
+            await asyncio.sleep(random.uniform(0.5, 4)) # Random jitter
+            page_data = await self.get(url)
+
+        post = page_data[0]["data"]["children"][0]
+        comments: list = page_data[1]["data"]["children"] or []
+
+        await self.items_queue.put(post)
+
+        if not self.include_comments:
+            return
+
+        for comment in comments:
+            if fetched_comments_count >= self.max_comments_per_post:
+                break
+
+            if comment["kind"] == "t1" and comment["data"]["depth"] <= self.max_comments_depth:
+                if comment["data"]["depth"] == 0:
+                    if fetched_comments_count < self.max_comments_per_post and fetched_top_comments_count < self.max_top_comments_per_post:
+                        await self.items_queue.put(comment)
+                        fetched_comments_count += 1
+                        fetched_top_comments_count += 1
+                else:
+                    if fetched_comments_count < self.max_comments_per_post:
+                        await self.items_queue.put(comment)
+                        fetched_comments_count += 1
+
+            elif comment["kind"] == "more" and comment["data"]["id"] != "_":
+                more.append(comment)
+
+        while more and fetched_comments_count < self.max_comments_per_post:
+            more, fetched_comments_count, fetched_top_comments_count = await self.fetch_more_comments(post_id=post["data"]["name"], more_items=more, fetched_comments_count=fetched_comments_count, fetched_top_comments_count=fetched_top_comments_count)
+
+    async def fetch_collection(self, url: str) -> None:
+        after = ""
+        next_page_url = ""
+        fetched_posts_count = 0
+        post_tasks = []
+        if self.mode != "keyword_search":
+            while True:
+                async with self.request_semaphore:
+                    await asyncio.sleep(random.uniform(0.5, 4)) # Random jitter
+                    page_data = await self.get(url, params={"after": after})
+
+                if not page_data:
+                    break
+
+                after = page_data["data"]["after"] or ""
+                posts = page_data["data"]["children"]
+
+                for post in posts:
+                    if fetched_posts_count >= self.max_posts_per_collection:
+                        break
+
+                    if post["kind"] == "t3" and fetched_posts_count < self.max_posts_per_collection:
+                        post_url = "https://www.reddit.com" + post["data"]["permalink"] + ".json?threaded=false"
+
+                        if self.include_comments and post["data"]["num_comments"] > 0:
+                            post_tasks.append(asyncio.create_task(self.fetch_post(post_url)))
+                        else:
+                            await self.items_queue.put(post)
+
+                        fetched_posts_count += 1
+
+                if not after or fetched_posts_count >= self.max_posts_per_collection:
+                    break
+
+            if post_tasks:
+                await asyncio.gather(*post_tasks)
+        else:
+            while True:
+                async with self.request_semaphore:
+                    await asyncio.sleep(random.uniform(0.5, 4)) # Random jitter
+                    page_html: str = await self.get(url if not next_page_url else next_page_url, expected_data_type="HTML/XML")
+
+                if not page_html:
+                    break
+
+                soup = WhiskeySour(page_html)
+                next_page_el = soup.select_one("faceplate-partial[loading=lazy]")
+                next_page_url = "https://www.reddit.com" + next_page_el.get("src") if next_page_el else ""
+
+                posts = soup.select('a[data-testid="post-title"]')
+                for post in posts:
+                    if fetched_posts_count >= self.max_posts_per_collection:
+                        break
+
+                    if fetched_posts_count < self.max_posts_per_collection:
+                        post_url = "https://www.reddit.com" + post.get("href") + ".json?threaded=false"
+                        post_tasks.append(asyncio.create_task(self.fetch_post(post_url)))
+
+                        fetched_posts_count += 1
+
+                if not next_page_url or fetched_posts_count >= self.max_posts_per_collection:
+                    break
+
+            if post_tasks:
+                await asyncio.gather(*post_tasks)
+    
+    async def get_items(self) -> AsyncGenerator[dict, None]:
+        tasks = []
+
+        async def run_all_tasks():
+            try:
+                await asyncio.gather(*tasks)
+            except Exception as e:
+                await self.items_queue.put(e)
+            else:
+                await self.items_queue.put("done")
+
+        if self.mode == "standard":
+            # Subreddits
+            for url in self.subreddit_urls:
+                initial_url = url
+                if "reddit.com" not in initial_url or "/r/" not in initial_url:
+                    continue
+
+                params = {"limit": 100, "t": self.time_frame}
+
+                raw_sub_name = initial_url.split("/r/")[-1].split("/")[0]
+                final_url = f"https://www.reddit.com/r/{raw_sub_name}"
+
+                if self.sort != "default":
+                    final_url += f"/{self.sort}/"
+
+                final_url += f".json?{urlencode(params)}"
+
+                tasks.append(self.fetch_collection(final_url))
+
+            # Posts
+            for url in self.post_urls:
+                initial_url = url
+                if "reddit.com" not in initial_url or "/comments/" not in initial_url:
+                    continue
+
+                final_url = initial_url.split("/comments/")[0] + "/comments/" + initial_url.split("/comments/")[-1].split("/")[0] + ".json?threaded=false"
+                tasks.append(self.fetch_post(final_url))
+
+            # Profiles
+            for url in self.profile_urls:
+                initial_url = url
+                if "reddit.com" not in initial_url or ("/u/" not in initial_url and "/user/" not in initial_url):
+                    continue
+
+                params = {
+                    "limit": 100,
+                    "sort": self.sort if self.sort != "default" else "",
+                    "t": self.time_frame
+                }
+
+                if "/u/" in initial_url:
+                    final_url = initial_url.split("/u/")[0] + "/u/" + initial_url.split("/u/")[-1].split("/")[0] + f"/submitted/.json?{urlencode(params)}"
+                elif "/user/" in initial_url:
+                    final_url = initial_url.split("/user/")[0] + "/user/" + initial_url.split("/user/")[-1].split("/")[0] + f"/submitted/.json?{urlencode(params)}"
+
+                tasks.append(self.fetch_collection(final_url))
+        elif self.mode == "keyword_search":
+            final_url = ""
+
+            if self.query:
+                params = {
+                    "q": self.query,
+                    "type": "posts",
+                    "sort": "relevance"
+                }
+
+                final_url = f"https://www.reddit.com/search/?{urlencode(params)}"
+                tasks.append(self.fetch_collection(final_url))
+        else: # domain_search
+            for domain in self.domains:
+                final_url = f"https://www.reddit.com/domain/{domain}/"
+                if self.sort != "default":
+                    final_url += f"{self.sort}/"
+
+                final_url += ".json?limit=100"
+                tasks.append(self.fetch_collection(final_url))
+
+
+        
+        runner = asyncio.create_task(run_all_tasks())
+        results_count = 0
+
+        try:
+            while True:
+                item = await self.items_queue.get()
+
+                if isinstance(item, Exception):
+                    raise item
+
+                if item != "done":
+                    results_count += 1
+
+                    if results_count > self.max_results:
+                        break
+                    else:
+                        yield self.parse_item(item)
+                else:
+                    break
+        finally:
+            runner.cancel()

reddrix-0.1.0.dist-info/METADATA

@@ -0,0 +1,341 @@
+Metadata-Version: 2.4
+Name: reddrix
+Version: 0.1.0
+Summary: Reddrix is an open-source, blazing fast Reddit Scraper for Python (No API Key)
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: camoufox[geoip]
+Requires-Dist: whiskeysour
+Requires-Dist: curl-cffi
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary
+
+<p align="center">
+    <img src="https://raw.githubusercontent.com/Coding-Doctor-Omar/reddrix/main/images/reddrix.png" width="350" alt="reddrix logo">
+</p>
+
+<p align="center">
+    <a href="https://ko-fi.com/CodingDoctorOmar">
+        <img src="https://ko-fi.com/img/githubbutton_sm.svg" alt="Support Me on Ko-fi">
+    </a>
+</p>
+
+# Reddrix &mdash; An open-source, blazing fast Reddit Scraper for Python (No API Key)
+
+<p align="center"><h3>A powerful, async-first Reddit scraper (with built-in proxy support) for posts and comments with detailed metrics. No API key required. Scrape subreddits, profiles, and specific posts, or search Reddit site-wide by keywords or domains. Collect rich, structured data including authors, scores, timestamps, flairs, comment threads, and more (30+ fields).</h3></p>
+
+> If this repo is useful to you or saved your time, consider starring ⭐ it to support me and help other find it and have an easier time scraping Reddit ❤️.
+
+> Need a hosted version, check [Reddit Scraper Pro](https://apify.com/coding-doctor-omar/Reddit-Scraper-Pro) on Apify.
+
+<p align="center">
+    <a href="#installation">Installation</a> • <a href="#quick-start">Quick Start</a> • <a href="#output-dataset">Output Dataset</a> • 
+    <a href="#features">Features</a> • <a href="#scraper-options">Scraper Options</a>
+</p>
+
+## Installation
+
+```bash
+pip install reddrix
+
+reddrix install # Optional for installing Camoufox if you want to use Reddrix with Camoufox
+```
+
+## Quick start
+
+**Using Async Context Manager:**
+
+```python
+from reddrix import Reddrix
+import asyncio
+
+async def main():
+    async with Reddrix(
+        mode="standard",
+        subreddit_urls=["https://www.reddit.com/r/webscraping"],
+        sort="new",
+        include_comments=True,
+        max_results=500,
+        max_posts_per_collection=500,
+        verbose=True
+    ) as reddrix:
+        async for item in reddrix.get_items():
+            print(item["submissionType"], item["submissionUrl"])
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+**Without the context manager:**
+
+```python
+from reddrix import Reddrix
+import asyncio
+
+async def main():
+    reddrix = Reddrix(
+        mode="standard",
+        subreddit_urls=["https://www.reddit.com/r/webscraping"],
+        sort="new",
+        include_comments=True,
+        max_results=500,
+        max_posts_per_collection=500,
+        proxies=["http://user:pass@hostname:port", "http://user2:pass2@hostname2:port2"], # Built-in automatic proxy rotation
+        verbose=True
+    )
+    await reddrix.start()
+    
+    async for item in reddrix.get_items():
+        print(item["submissionType"], item["submissionUrl"])
+    
+    await reddrix.stop()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+**Scraping Posts and Comments Based on Keywords:**
+
+```python
+from reddrix import Reddrix
+import asyncio
+
+async def main():
+    async with Reddrix(
+        mode="keyword_search",
+        sort="new", # The sort option is ignored for this mode
+        query="how to scrape reddit",
+        include_comments=True,
+        max_results=500,
+        max_posts_per_collection=500,
+        verbose=True
+    ) as reddrix:
+        async for item in reddrix.get_items():
+            print(item["submissionType"], item["submissionUrl"])
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+**Scraping Posts and Comments Based on Domains:**
+
+```python
+from reddrix import Reddrix
+import asyncio
+
+async def main():
+    async with Reddrix(
+        mode="domain_search",
+        sort="new",
+        domains=["github.com", "apify.com"],
+        include_comments=True,
+        max_results=500,
+        max_posts_per_collection=500,
+        verbose=True
+    ) as reddrix:
+        async for item in reddrix.get_items():
+            print(item["submissionType"], item["submissionUrl"])
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+
+
+**Using Reddrix as a standalone Reddit http client for your custom scraping setup:**
+
+```python
+from reddrix import Reddrix
+import asyncio
+
+async def main():
+    async with Reddrix() as reddrix:
+        json_data = await reddrix.get("https://www.reddit.com/r/webscraping.json")
+        html_content = await reddrix.get(
+            url="https://www.reddit.com/search?q=how+to+scrape+reddit",
+            expected_data_type="HTML/XML" # You must specify the data type if you want to fetch html or xml.
+        )
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+**Using Reddrix with Camoufox:**
+
+```bash
+pip install reddrix
+reddrix install # Installs the camoufox browser
+```
+
+```python
+from reddrix import Reddrix
+import asyncio
+
+async def main():
+    async with Reddrix(
+        mode="standard",
+        http_client="camoufox", # By default, the http_client is "curl_cffi", but you can choose Camoufox.
+        subreddit_urls=["https://www.reddit.com/r/webscraping"],
+        sort="new",
+        include_comments=True,
+        max_results=500,
+        max_posts_per_collection=500,
+        verbose=True
+    ) as reddrix:
+        async for item in reddrix.get_items():
+            print(item["submissionType"], item["submissionUrl"])
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+This option is included in anticipation of future aggressive anti-scraping measures from Reddit. Even when Camoufox is used as the http client, the scraper uses it intelligently. It still utilizes the same JSON endpoints that curl_cffi uses via `page.evaluate()` with JS fetch. This results in nearly the same scraping speed, but with more stealth. The only caveat is more resource usage and slower scraper initialization speed.
+
+## Output Dataset
+
+If you use the preset scraping setup from `reddrix.get_items()`, the output dataset is a Python dictionary.
+
+**Example Reddit Post Output:**
+
+```python
+{
+  "submissionId": "1w1gc8p",
+  "submissionIdPrefixed": "t3_1w1gc8p",
+  "submissionType": "post",
+  "submissionUrl": "https://www.reddit.com/r/Sat/comments/1w1gc8p/is_this_good_improvement_for_10_hours_of/",
+  "submittedAt": "2026-08-29T07:53:42+00:00",
+  "parentId": None,
+  "parentPostId": None,
+  "parentPostUrl": None,
+  "postType": "image",
+  "isCrosspost": False,
+  "crosspostParentId": None,
+  "crosspostParentUrl": None,
+  "title": "Is this good improvement for 10 hours of dedicated study + need help for rw section",
+  "bodyText": "math significantly improved but reading writing is too tough for me (international student)\n\nplease help, i have to give the sat in two months, will reading novels improve my rw score?",
+  "isEdited": False,
+  "author": "stcer",
+  "authorFlairText": None,
+  "authorFlairImageUrl": None,
+  "depth": None,
+  "postFlair": None,
+  "isNSFW": False,
+  "subreddit": "r/Sat",
+  "score": 32,
+  "upvoteRatio": 0.98,
+  "numComments": 29,
+  "numCrossposts": 0,
+  "externalUrl": "https://i.redd.it/cjhezz5bs9mh1.jpeg",
+  "thumbnailUrl": None,
+  "videoUrl": None,
+  "imageUrl": "https://i.redd.it/cjhezz5bs9mh1.jpeg",
+  "galleryImagesUrls": None
+}
+```
+
+**Example Comment Output:**
+
+```python
+{
+  "submissionId": "p6lwobb",
+  "submissionIdPrefixed": "t1_p6lwobb",
+  "submissionType": "comment",
+  "submissionUrl": "https://www.reddit.com/r/Sat/comments/1w1gc8p/is_this_good_improvement_for_10_hours_of/p6lwobb/",
+  "submittedAt": "2026-08-29T13:41:52+00:00",
+  "parentId": "t3_1w1gc8p",
+  "parentPostId": "t3_1w1gc8p",
+  "parentPostUrl": "https://www.reddit.com/r/Sat/comments/1w1gc8p",
+  "postType": None,
+  "isCrosspost": False,
+  "crosspostParentId": None,
+  "crosspostParentUrl": None,
+  "title": None,
+  "bodyText": "How did you do that in 10 hours? Can you please give me the sources that you used? I also need help in rw section and I’ll take the sat in 2 weeks",
+  "isEdited": False,
+  "author": "AnalysisStill4932",
+  "authorFlairText": None,
+  "authorFlairImageUrl": None,
+  "depth": 0,
+  "postFlair": None,
+  "isNSFW": False,
+  "subreddit": "r/Sat",
+  "score": 9,
+  "upvoteRatio": None,
+  "numComments": None,
+  "numCrossposts": None,
+  "externalUrl": None,
+  "thumbnailUrl": None,
+  "videoUrl": None,
+  "imageUrl": None,
+  "galleryImagesUrls": None
+}
+```
+**Output Fields Explanation:**
+
+1. `submissionId` &mdash; [`string`] The ID of the post or comment.
+2. `submissionIdPrefixed` &mdash; [`string`] The prefixed ID of the post or comment.
+3. `submissionType` &mdash; [`string`] Whether the submission is a `post` or `comment`.
+4. `submissionUrl` &mdash; [`string`] The URL for the submission.
+5. `submittedAt` &mdash; [`string`] The date and time the post or comment was submitted in UTC timezone and ISO format.
+6. `parentId` &mdash; [`string`, `None`] The ID of the direct parent post or comment.
+7. `parentPostId` &mdash; [`string`, `None`] The ID of the parent post. For posts, this field will always be `None` since posts have no parent.
+8. `parentPostUrl` &mdash; [`string`, `None`] The URL of the parent post. For posts, this field will always be `None` since posts have no parent.
+9. `postType` &mdash; [`string`, `None`] The post type. Can be any of `text`, `poll`, `link`, `image`, `gallery`, or `video`. For comments, this field will always be `None`.
+10. `isCrosspost` &mdash; [`boolean`] Whether the post is a crosspost.
+11. `crosspostParentId` &mdash; [`string`, `None`] The ID of the parent of the crosspost (for posts that are not crossposts, will be `None`).
+12. `crosspostParentUrl` &mdash; [`string`, `None`] The URL of the parent of the crosspost (for posts that are not crossposts, will be `None`).
+13. `title` &mdash; [`string`, `None`] The post title (will always be `None` for comments).
+14. `bodyText` &mdash; [`string`, `None`] The main text content of a post or comment.
+15. `isEdited` &mdash; [`boolean`] Whether the post or comment is edited.
+16. `author` &mdash; [`string`] The author of the post or comment.
+17. `authorFlairText` &mdash; [`string`, `None`] The text content of the author flair or a text version of it.
+18. `authorFlairImageUrl` &mdash; [`string`, `None`] The URL for the image in an author flair.
+19. `depth` &mdash; [`integer`, `None`] The comment depth (top-level comments have a depth of `0` and posts have a depth of `None`).
+20. `postFlair` &mdash; [`string`, `None`] The post flair (will be `None` for comments).
+21. `isNSFW` &mdash; [`boolean`] Whether the post or comment is NSFW.
+22. `subreddit` &mdash; [`string`, `None`] The subreddit in which the post or comment was submitted.
+23. `score` &mdash; [`integer`, `None`] The vote score of the post or comment.
+24. `upvoteRatio` &mdash; [`float`, `None`] The ratio of upvotes to total number of votes of a post (always `None` for comments).
+25. `numComments` &mdash; [`integer`, `None`] The number of comments in a post (always `None` for comments).
+26. `numCrossposts` &mdash; [`integer`, `None`] The number of crossposts for a post (always `None` for comments).
+27. `externalUrl` &mdash; [`string`, `None`] The external URL in a post. For comments, this field will be `None` because external URLs will be included in the `bodyText` anyway.
+28. `thumbnailUrl` &mdash; [`string`, `None`] The thumbnail image URL for `video`, `image`, and `gallery` post types (always `None` for any other submission).
+29. `videoUrl` &mdash; [`string`, `None`] The URL for the video in a post (always `None` for any submission other than `video` posts).
+30. `imageUrl` &mdash; [`string`, `None`] The URL for the image in a post (always `None` for any submission other than `image` posts).
+31. `galleryImagesUrls` &mdash; [`list`] A list of URLs for all images in a gallery (always empty for any submission other than `gallery` posts).
+
+## Features
+
+- 🚀 **Async-First:** High-performance asynchronous scraping with `asyncio` and an async iterator for streaming results.
+- 🔑 **No API Key Required:** Scrape Reddit without requiring an API key.
+- 🔍 **Multiple Search Modes:** Scrape subreddits, user profiles, and specific posts, or search Reddit by keywords and domains.
+- 💬 **Comprehensive Data Extraction:** Collect posts and comments with 30+ structured fields, including authors, scores, timestamps, flairs, media URLs, and comment thread metadata.
+- 🌐 **Flexible HTTP Clients:** Choose between `curl_cffi` for lightweight HTTP requests and `camoufox` for intelligent, browser-based fetching.
+- 🛡️ **Resilient Scraping:** Built-in retries, cookie renewal, and configurable proxies.
+- ⚙️ **Fine-Grained Control:** Configure sorting, time frames, result limits, comment depth, and comment counts.
+- 🧩 **Standalone HTTP Client:** Use Reddrix's asynchronous `get()` method in your own custom scraping workflows.
+- 🐍 **Pythonic API:** Manage scraper resources with an async context manager or explicit `start()` and `stop()` methods.
+
+## Scraper Options
+
+1. `mode` (string) &mdash; One of `standard`, `keyword_search`, and `domain_search`. Default is `standard`.
+2. `http_client` (string) &mdash; One of `curl_cffi` and `camoufox`. Default is `curl_cffi`.
+3. `max_results` (integer) &mdash; The maximum total number of items (posts and comments combined) to return across all sources. Default is `999999`.
+4. `max_posts_per_collection` (integer) &mdash; The maximum number of posts to scrape from each collection. A collection is a single subreddit, profile, keyword search, or domain. Default is `999999`.
+5. `sort` (string) &mdash; One of `default`, `new`, and `hot`. Applies to subreddits, profiles, and `domain_search`. This option is ignored in `keyword_search` mode, which always uses Reddit's relevance sorting. Default is `default`.
+6. `time_frame` (string) &mdash; One of `all_time`, `past_hour`, `today`, `past_week`, `past_month`, and `past_year`. Used in `standard` mode for subreddits and profiles, and ignored in `keyword_search` and `domain_search` modes. Default is `all_time`.
+7. `subreddit_urls` (list of strings) &mdash; Subreddit URLs to scrape, e.g. `["https://www.reddit.com/r/webscraping"]`. Used in `standard` mode only. URLs that are not valid subreddit URLs are skipped. Default is `[]`.
+8. `post_urls` (list of strings) &mdash; Specific post URLs to scrape, e.g. `["https://www.reddit.com/r/webscraping/comments/abc123/post_title/"]`. Used in `standard` mode only. URLs that are not valid post URLs are skipped. Default is `[]`.
+9. `profile_urls` (list of strings) &mdash; User profile URLs to scrape the submitted posts of, e.g. `["https://www.reddit.com/user/username"]`. Both `/user/` and `/u/` URLs are supported. Used in `standard` mode only. URLs that are not valid profile URLs are skipped. Default is `[]`.
+10. `domains` (list of strings) &mdash; Domains to search for in Reddit posts that link to them, e.g. `["github.com", "apify.com"]`. Used in `domain_search` mode only. Default is `[]`.
+11. `query` (string) &mdash; The search keywords to look up site-wide on Reddit. Used in `keyword_search` mode only. Default is `None`.
+12. `include_comments` (boolean) &mdash; Whether to scrape the comments of each post in addition to the post itself. Comments are returned as separate items with `submissionType` set to `comment`. Default is `False`.
+13. `max_comments_depth` (integer) &mdash; The maximum comment depth to scrape. Top-level comments have a depth of `0`, their replies have a depth of `1`, and so on. Only applies if `include_comments` is `True`. Default is `10`.
+14. `max_comments_per_post` (integer) &mdash; The maximum total number of comments (top-level comments and replies) to scrape per post. Only applies if `include_comments` is `True`. Default is `999999`.
+15. `max_top_comments_per_post` (integer) &mdash; The maximum number of top-level comments (depth `0`) to scrape per post. Only applies if `include_comments` is `True`. Default is `999999`.
+16. `proxies` (list of strings) &mdash; A list of proxy URLs in the format `scheme://user:pass@hostname:port`. Reddrix rotates through them automatically, picking an unused proxy first and reusing proxies only after the whole list has been used. Default is `[]` (no proxy).
+17. `verbose` (boolean) &mdash; Whether to print timestamped log messages (initialization, retries, etc.) to the console. Default is `False`.

reddrix-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+reddrix/__init__.py,sha256=ijAbs5HKh-89Vbmo8j9TJn2yvMyGKFSntgyXquNJ8Kk,53
+reddrix/cli.py,sha256=g3lzM-9CBPb3vd5odmPKpISODJQX574cLSHVn_Vq7zk,698
+reddrix/exceptions.py,sha256=ie91Rj3GoGsodWlQ8om2JC2IuzE3qlLJBG6XhQtl8_I,230
+reddrix/reddrix.py,sha256=SH5KCWxSyHU1SvA_Thcz1LQ8kEsy6FpyChtga2Wpl3A,34219
+reddrix-0.1.0.dist-info/licenses/LICENSE.md,sha256=jyoYoLT3j1Gzbj0bo0OaGZjLKpjdEJ_01R31byfJQDw,1091
+reddrix-0.1.0.dist-info/METADATA,sha256=BNv-6a4Zjkwc38BPPyPkFfmGgq8KX--19LM37HzGeq4,16800
+reddrix-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+reddrix-0.1.0.dist-info/entry_points.txt,sha256=JlLGCBJqrnLvveS11NF6ReiS56FwIkRWLuBP3XaAAQw,45
+reddrix-0.1.0.dist-info/top_level.txt,sha256=XOi5znNdB6-QZgZZY6y5NQ4EfmF7pgXTkfAY733iZP4,8
+reddrix-0.1.0.dist-info/RECORD,,

reddrix-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

reddrix-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+reddrix = reddrix.cli:main

reddrix-0.1.0.dist-info/licenses/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Omar Abdelhamid
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

reddrix-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+reddrix