getred 0.1.3__py3-none-any.whl

getred/__init__.py

@@ -0,0 +1,7 @@
+"""getred - A CLI tool to fetch Reddit threads and save them as structured JSON."""
+
+__version__ = "0.1.0"
+
+from getred.models import Thread, Comment
+
+__all__ = ["Thread", "Comment", "__version__"]

getred/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m getred."""
+
+from getred.cli import main
+
+if __name__ == '__main__':
+    main()

getred/cli.py

@@ -0,0 +1,77 @@
+"""Command-line interface for getred."""
+
+import sys
+import click
+from pathlib import Path
+from getred import __version__
+from getred.fetcher import RedditFetcher
+from getred.parser import parse_thread
+from getred.utils import validate_reddit_url, get_default_output_path, save_json
+
+
+@click.command()
+@click.argument('url')
+@click.option(
+    '-o', '--output',
+    type=click.Path(path_type=Path),
+    help='Custom output path (default: ~/Downloads/<slug>.json)'
+)
+@click.option(
+    '-p', '--pretty/--no-pretty',
+    default=True,
+    help='Pretty-print JSON (default: enabled)'
+)
+@click.option(
+    '-q', '--quiet',
+    is_flag=True,
+    help='Suppress progress output'
+)
+@click.version_option(version=__version__, prog_name='getred')
+def main(url: str, output: Path, pretty: bool, quiet: bool):
+    """
+    Fetch a Reddit thread and save it as structured JSON.
+
+    URL should be a full Reddit thread URL like:
+    https://www.reddit.com/r/python/comments/abc123/title/
+    """
+    # Validate URL
+    if not validate_reddit_url(url):
+        click.echo("Error: Invalid Reddit thread URL", err=True)
+        click.echo("Expected format: https://www.reddit.com/r/SUBREDDIT/comments/ID/TITLE/", err=True)
+        sys.exit(1)
+
+    # Determine output path
+    output_path = output if output else get_default_output_path(url)
+
+    if not quiet:
+        click.echo(f"Fetching thread from Reddit...")
+
+    try:
+        # Fetch thread data
+        fetcher = RedditFetcher()
+        json_data = fetcher.fetch_thread(url)
+
+        if not quiet:
+            click.echo(f"Parsing comments...")
+
+        # Parse into structured format
+        thread = parse_thread(json_data)
+
+        if not quiet:
+            click.echo(f"Found {thread.comment_count} comments (parsed {len(thread.comments)} top-level)")
+
+        # Save to file
+        save_json(thread.to_dict(), output_path, pretty=pretty)
+
+        if not quiet:
+            click.echo(f"✓ Saved to: {output_path}")
+        else:
+            click.echo(str(output_path))
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()

getred/fetcher.py

@@ -0,0 +1,38 @@
+"""HTTP client for fetching Reddit data."""
+
+import httpx
+from typing import Dict, Any
+
+
+class RedditFetcher:
+    """Fetches Reddit thread data using the public JSON API."""
+
+    USER_AGENT = "getred/0.1.0 (Reddit Thread Fetcher CLI)"
+    TIMEOUT = 30.0
+
+    def __init__(self):
+        """Initialize the fetcher with custom headers."""
+        self.headers = {
+            "User-Agent": self.USER_AGENT
+        }
+
+    def fetch_thread(self, url: str) -> Dict[str, Any]:
+        """
+        Fetch a Reddit thread as JSON.
+
+        Args:
+            url: Reddit thread URL (will be converted to JSON endpoint)
+
+        Returns:
+            Dict containing Reddit API response
+
+        Raises:
+            httpx.HTTPError: If request fails
+        """
+        # Ensure URL ends with .json
+        json_url = url.rstrip('/') + '.json'
+
+        with httpx.Client(headers=self.headers, timeout=self.TIMEOUT) as client:
+            response = client.get(json_url)
+            response.raise_for_status()
+            return response.json()

getred/models.py

@@ -0,0 +1,62 @@
+"""Data models for Reddit threads and comments."""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+
+
+@dataclass
+class Comment:
+    """Represents a Reddit comment."""
+
+    id: str
+    author: str
+    body: str
+    score: int
+    created_utc: str
+    depth: int
+    replies: List['Comment'] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert comment to dictionary format."""
+        return {
+            "id": self.id,
+            "author": self.author,
+            "body": self.body,
+            "score": self.score,
+            "created_utc": self.created_utc,
+            "depth": self.depth,
+            "replies": [reply.to_dict() for reply in self.replies]
+        }
+
+
+@dataclass
+class Thread:
+    """Represents a Reddit thread."""
+
+    id: str
+    title: str
+    author: str
+    subreddit: str
+    url: str
+    selftext: str
+    score: int
+    created_utc: str
+    fetched_at: str
+    comment_count: int
+    comments: List[Comment] = field(default_factory=list)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert thread to dictionary format."""
+        return {
+            "id": self.id,
+            "title": self.title,
+            "author": self.author,
+            "subreddit": self.subreddit,
+            "url": self.url,
+            "selftext": self.selftext,
+            "score": self.score,
+            "created_utc": self.created_utc,
+            "fetched_at": self.fetched_at,
+            "comment_count": self.comment_count,
+            "comments": [comment.to_dict() for comment in self.comments]
+        }

getred/parser.py

@@ -0,0 +1,99 @@
+"""Parser for Reddit JSON responses."""
+
+from datetime import datetime
+from typing import Dict, Any, List
+from getred.models import Thread, Comment
+
+
+def parse_timestamp(timestamp: float) -> str:
+    """Convert Unix timestamp to ISO format string."""
+    return datetime.utcfromtimestamp(timestamp).isoformat() + 'Z'
+
+
+def parse_comment(comment_data: Dict[str, Any], depth: int = 0) -> Comment:
+    """
+    Parse a comment from Reddit JSON data.
+
+    Args:
+        comment_data: Raw comment data from Reddit API
+        depth: Nesting depth of the comment
+
+    Returns:
+        Comment object with nested replies
+    """
+    data = comment_data.get('data', {})
+
+    # Handle deleted/removed comments
+    author = data.get('author', '[deleted]')
+    body = data.get('body', '[deleted]')
+
+    comment = Comment(
+        id=data.get('id', ''),
+        author=author,
+        body=body,
+        score=data.get('score', 0),
+        created_utc=parse_timestamp(data.get('created_utc', 0)),
+        depth=depth,
+        replies=[]
+    )
+
+    # Parse nested replies
+    replies_data = data.get('replies')
+    if replies_data and isinstance(replies_data, dict):
+        replies_listing = replies_data.get('data', {}).get('children', [])
+        for reply_data in replies_listing:
+            # Skip "more" objects that indicate additional comments
+            if reply_data.get('kind') == 't1':
+                comment.replies.append(parse_comment(reply_data, depth + 1))
+
+    return comment
+
+
+def parse_comments(comments_listing: List[Dict[str, Any]]) -> List[Comment]:
+    """
+    Parse all top-level comments from the comments listing.
+
+    Args:
+        comments_listing: List of comment objects from Reddit API
+
+    Returns:
+        List of Comment objects
+    """
+    comments = []
+    for item in comments_listing:
+        # Only parse actual comments (kind = t1), skip "more" objects
+        if item.get('kind') == 't1':
+            comments.append(parse_comment(item, depth=0))
+
+    return comments
+
+
+def parse_thread(json_data: List[Dict[str, Any]]) -> Thread:
+    """
+    Parse a Reddit thread from JSON response.
+
+    Args:
+        json_data: Raw JSON response from Reddit API (list with 2 elements)
+
+    Returns:
+        Thread object with all data and nested comments
+    """
+    # Reddit API returns [post_data, comments_data]
+    post_listing = json_data[0]['data']['children'][0]['data']
+    comments_listing = json_data[1]['data']['children']
+
+    thread = Thread(
+        id=post_listing.get('id', ''),
+        title=post_listing.get('title', ''),
+        author=post_listing.get('author', '[deleted]'),
+        subreddit=post_listing.get('subreddit', ''),
+        url=post_listing.get('url', ''),
+        selftext=post_listing.get('selftext', ''),
+        score=post_listing.get('score', 0),
+        created_utc=parse_timestamp(post_listing.get('created_utc', 0)),
+        fetched_at=datetime.utcnow().isoformat() + 'Z',
+        comment_count=post_listing.get('num_comments', 0),
+        comments=parse_comments(comments_listing)
+    )
+
+    return thread

getred/utils.py

@@ -0,0 +1,83 @@
+"""Utility functions for URL validation, slug generation, and file operations."""
+
+import json
+import re
+from pathlib import Path
+from typing import Dict, Any
+
+
+def validate_reddit_url(url: str) -> bool:
+    """
+    Validate that a URL is a Reddit thread URL.
+
+    Args:
+        url: URL to validate
+
+    Returns:
+        True if valid Reddit thread URL, False otherwise
+    """
+    pattern = r'^https?://(www\.)?reddit\.com/r/[^/]+/comments/[^/]+/'
+    return bool(re.match(pattern, url))
+
+
+def generate_slug(url: str) -> str:
+    """
+    Generate a filename slug from a Reddit URL.
+
+    Extracts the thread ID and title from the URL.
+    Example: https://reddit.com/r/python/comments/abc123/cool_title/
+    Returns: abc123_cool_title
+
+    Args:
+        url: Reddit thread URL
+
+    Returns:
+        Slug string suitable for filename
+    """
+    # Extract thread ID and title from URL
+    # Pattern: /r/subreddit/comments/ID/title/
+    match = re.search(r'/comments/([^/]+)/([^/]+)', url)
+    if match:
+        thread_id = match.group(1)
+        title_slug = match.group(2)
+        return f"{thread_id}_{title_slug}"
+
+    # Fallback to just using the thread ID
+    match = re.search(r'/comments/([^/]+)', url)
+    if match:
+        return match.group(1)
+
+    return "reddit_thread"
+
+
+def get_default_output_path(url: str) -> Path:
+    """
+    Generate default output path in ~/Downloads.
+
+    Args:
+        url: Reddit thread URL
+
+    Returns:
+        Path object for output file
+    """
+    downloads_dir = Path.home() / "Downloads"
+    slug = generate_slug(url)
+    return downloads_dir / f"{slug}.json"
+
+
+def save_json(data: Dict[str, Any], output_path: Path, pretty: bool = True) -> None:
+    """
+    Save data as JSON file.
+
+    Args:
+        data: Dictionary to save
+        output_path: Path where to save the file
+        pretty: Whether to pretty-print the JSON (default: True)
+    """
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with open(output_path, 'w', encoding='utf-8') as f:
+        if pretty:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        else:
+            json.dump(data, f, ensure_ascii=False)

getred-0.1.3.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: getred
+Version: 0.1.3
+Summary: A CLI tool to fetch Reddit threads and save them as structured JSON
+Project-URL: Homepage, https://github.com/mgelei/getred
+Project-URL: Issues, https://github.com/mgelei/getred/issues
+Author-email: Mate Gelei-Szego <hello@mategelei.com>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: click>=8.0.0
+Requires-Dist: httpx>=0.24.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# getred
+Fetches a Reddit thread in a structured JSON

getred-0.1.3.dist-info/RECORD

@@ -0,0 +1,12 @@
+getred/__init__.py,sha256=OV8_4Tk9tyvGAfZ4flBb_clJWWhQzPyMNjbsmdo0YJc,198
+getred/__main__.py,sha256=feAHoe3sKnTtTZZQ8CQntbtVBbkDL3EqaldR6LpLU48,108
+getred/cli.py,sha256=ZcXE9yirkiwwmfohxSpsuaoC8lt_ubY4BgoPWYZQ_bI,2149
+getred/fetcher.py,sha256=kdFb8lWAdQzEFGzGaSKI2W-YQyZyD5tclSDXC2j5o_o,1033
+getred/models.py,sha256=DJGHsXQJnKdgUSv_mXzsQd9luzsamw5UgkZT2WAZHBg,1613
+getred/parser.py,sha256=hx_SHTZEcCmkfS1F2E8vlj5Z-v_xYRhJtcxiEFABJK4,3066
+getred/utils.py,sha256=z4mKfCbME6ffi9PC7CnMcYZNFEMtVDTF5JJKMoBgirg,2155
+getred-0.1.3.dist-info/METADATA,sha256=1KoRMD9X42ZYdC0xSJtG-SMxk6Z6t7YaLE67enUdsoY,729
+getred-0.1.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+getred-0.1.3.dist-info/entry_points.txt,sha256=sUbiNDbmjeRZLW1zij_nhtxM9761F6DMmGeRl60xenY,43
+getred-0.1.3.dist-info/licenses/LICENSE,sha256=GJ-Sk2Q9pSMeuVlqqZQe5P5DLvOjKQRVpTA1fy_JftI,1073
+getred-0.1.3.dist-info/RECORD,,

getred-0.1.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

getred-0.1.3.dist-info/entry_points.txt

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

getred-0.1.3.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mate Gelei-Szego
+
+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.