getred 0.1.3__tar.gz

getred-0.1.3/.claude/agents/pytest-runner.md

@@ -0,0 +1,89 @@
+---
+name: pytest-runner
+description: "Use this agent when unit tests need to be executed via pytest."
+tools: Bash, Glob, Grep, Read, WebFetch, WebSearch, Skill, TaskCreate, TaskGet, TaskUpdate, TaskList, ToolSearch
+model: haiku
+---
+
+You are a specialized test execution agent with expertise in pytest and Python testing frameworks. Your sole responsibility is to run unit tests and provide clear, actionable results.
+
+## Core Responsibilities
+
+1. **Test Execution**: Run pytest with appropriate flags and configuration to execute the requested tests
+2. **Results Analysis**: Parse test output to extract key metrics (pass/fail counts, percentages, duration)
+3. **Failure Reporting**: Provide concise but sufficient detail on failing tests to enable quick debugging
+4. **Output Formatting**: Present results in a clear, scannable format that highlights the most important information first
+
+## Execution Protocol
+
+1. **Determine Test Scope**:
+   - If specific tests/modules are mentioned, run only those (e.g., `pytest tests/test_parser.py`)
+   - If specific test functions are mentioned, target them (e.g., `pytest tests/test_utils.py::test_validate_url`)
+   - If no specification is given, run the entire test suite (`pytest`)
+   - Always run from the project root directory
+
+2. **Use Appropriate Flags**:
+   - Use `-v` for verbose output to get detailed test names
+   - Use `--tb=short` for concise tracebacks
+   - Use `-x` to stop at first failure only if explicitly requested
+   - Use `--no-header` and `--no-summary` to reduce noise when needed
+
+3. **Execute Tests**: Run pytest using the bash tool with the determined scope and flags. Very important: always use a virtual environment when working with Python.
+
+4. **Parse Output**: Extract from pytest output:
+   - Total number of tests run
+   - Number passed, failed, skipped, errored
+   - Pass percentage (calculate as: passed / total * 100)
+   - Execution time
+   - Names of failed tests
+   - Key error messages or assertion failures
+
+## Output Format
+
+Present results in this structure:
+
+**Test Results Summary**
+- **Pass Rate**: X% (Y/Z tests passed)
+- **Duration**: Xs
+
+If all tests passed:
+✅ All tests passed successfully!
+
+If tests failed:
+❌ **Failed Tests** (N failures):
+
+1. `test_module::test_name`
+   - Error: Brief description of failure
+   - Location: file:line
+
+2. `test_module::test_name`
+   - Error: Brief description of failure
+   - Location: file:line
+
+[Include relevant traceback snippets only if they add clarity]
+
+If tests were skipped:
+ℹ️ Skipped: N tests
+
+## Guidelines
+
+- **Be Concise**: Focus on actionable information. Avoid repeating full tracebacks unless necessary for understanding.
+- **Highlight Failures**: Failed tests are the priority. Make them immediately visible.
+- **Calculate Accurately**: Always show pass percentage as a clear metric of test health.
+- **Preserve Context**: Include enough error detail to understand what went wrong without needing to re-run tests.
+- **Handle Edge Cases**: 
+  - If pytest isn't installed, clearly state this and suggest installation
+  - If no tests are found, report this explicitly
+  - If tests error during collection, report collection errors separately from test failures
+- **No Interpretation**: Report facts from test execution. Don't speculate about why tests failed or suggest fixes unless explicitly asked.
+- **Respect Verbosity**: If the user asks for detailed output, include full tracebacks and debugging information.
+
+## Self-Verification
+
+Before returning results:
+1. Confirm pytest command executed successfully (even if tests failed)
+2. Verify pass percentage calculation is correct
+3. Check that all failed test names are captured
+4. Ensure error messages are meaningful and not truncated mid-sentence
+
+You are the definitive source for test execution results. Be accurate, concise, and action-oriented.

getred-0.1.3/.github/workflows/publish.yml

@@ -0,0 +1,56 @@
+name: Publish to PyPI
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  test:
+    name: Run tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e ".[test]"
+
+      - name: Run tests
+        run: pytest
+
+  build-and-publish:
+    name: Build and publish to PyPI
+    needs: test
+    runs-on: ubuntu-latest
+
+    permissions:
+      id-token: write
+      contents: read
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install build dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build
+
+      - name: Build package
+        run: python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

getred-0.1.3/.github/workflows/version-check.yml

@@ -0,0 +1,43 @@
+name: Version Bump Check
+
+on:
+  pull_request:
+    branches: [master]
+
+jobs:
+  check-version:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout PR branch
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Get PR branch version
+        id: pr-version
+        run: |
+          PR_VERSION=$(grep -Po '(?<=^version = ")[^"]+' pyproject.toml)
+          echo "version=$PR_VERSION" >> $GITHUB_OUTPUT
+          echo "PR branch version: $PR_VERSION"
+
+      - name: Get master branch version
+        id: master-version
+        run: |
+          MASTER_VERSION=$(git show origin/master:pyproject.toml | grep -Po '(?<=^version = ")[^"]+')
+          echo "version=$MASTER_VERSION" >> $GITHUB_OUTPUT
+          echo "Master branch version: $MASTER_VERSION"
+
+      - name: Compare versions
+        run: |
+          if [ "${{ steps.pr-version.outputs.version }}" == "${{ steps.master-version.outputs.version }}" ]; then
+            echo "❌ Version bump required!"
+            echo "Current version in PR: ${{ steps.pr-version.outputs.version }}"
+            echo "Version in master: ${{ steps.master-version.outputs.version }}"
+            echo ""
+            echo "Please update the version in pyproject.toml before merging to master."
+            exit 1
+          else
+            echo "✅ Version bumped successfully!"
+            echo "Old version (master): ${{ steps.master-version.outputs.version }}"
+            echo "New version (PR): ${{ steps.pr-version.outputs.version }}"
+          fi

getred-0.1.3/.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

getred-0.1.3/CLAUDE.md

@@ -0,0 +1,65 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+`getred` is a CLI tool that fetches Reddit threads and saves them as structured JSON files. It uses Reddit's public JSON API (no authentication required) to retrieve thread data including all nested comments.
+
+## Development Commands
+
+### Installation
+```bash
+# Create and activate virtual environment
+python -m venv .venv
+source .venv/bin/activate  # On Windows: .venv\Scripts\activate
+
+# Install in development mode
+pip install -e .
+```
+
+### Running the CLI
+```bash
+# After installation
+getred <reddit_url>
+
+# Or directly via Python module
+python -m getred <reddit_url>
+
+# Common options
+getred <url> -o /path/to/output.json  # Custom output path
+getred <url> --no-pretty              # Compact JSON output
+getred <url> -q                       # Quiet mode
+```
+
+## Architecture
+
+### Data Flow
+1. **CLI Layer** (`cli.py`): Handles command-line arguments and orchestrates the fetch-parse-save pipeline
+2. **Fetcher** (`fetcher.py`): HTTP client that requests Reddit's `.json` endpoint using httpx
+3. **Parser** (`parser.py`): Converts Reddit's JSON response into structured `Thread` and `Comment` models
+4. **Models** (`models.py`): Dataclass definitions with `to_dict()` methods for serialization
+5. **Utils** (`utils.py`): URL validation, slug generation, and file I/O helpers
+
+### Key Design Patterns
+
+**Reddit API Response Structure**: The API returns a 2-element list:
+- `json_data[0]`: Post/thread data (single item listing)
+- `json_data[1]`: Comments data (listing with nested replies)
+
+**Comment Nesting**: Comments are recursively parsed with `depth` tracking. Each comment has a `replies` list containing nested `Comment` objects. The parser handles Reddit's "more" objects (kind='more') by skipping them - these indicate additional comments not included in the initial response.
+
+**Output Format**: By default, files are saved to `~/Downloads/<thread_id>_<title_slug>.json` with pretty-printed JSON. Thread metadata includes `fetched_at` timestamp in ISO format.
+
+## Project Structure
+- `src/getred/`: Main package
+  - `models.py`: Thread and Comment dataclasses
+  - `fetcher.py`: RedditFetcher class (httpx-based HTTP client)
+  - `parser.py`: Recursive comment parsing logic
+  - `cli.py`: Click-based CLI entry point
+  - `utils.py`: URL validation, slug generation, file operations
+  - `__main__.py`: Module entry point for `python -m getred`
+
+## Custom instructions
+- Always use a virtual environment when working with Python (`.venv`)
+- Never run tests directly, always use the pytest-runner agent to do that

getred-0.1.3/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.

getred-0.1.3/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,2 @@
+# getred
+Fetches a Reddit thread in a structured JSON

getred-0.1.3/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "getred"
+version = "0.1.3"
+description = "A CLI tool to fetch Reddit threads and save them as structured JSON"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    { name="Mate Gelei-Szego", email="hello@mategelei.com" }
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable", 
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "click>=8.0.0",
+    "httpx>=0.24.0",
+]
+
+[project.scripts]
+getred = "getred.cli:main"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/mgelei/getred"
+Issues = "https://github.com/mgelei/getred/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/getred"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

getred-0.1.3/src/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-0.1.3/src/getred/__main__.py

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

getred-0.1.3/src/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-0.1.3/src/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-0.1.3/src/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-0.1.3/src/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-0.1.3/src/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/tests/__init__.py

@@ -0,0 +1 @@
+"""Test suite for getred."""

getred-0.1.3/tests/conftest.py

@@ -0,0 +1,105 @@
+"""Shared fixtures for getred tests."""
+
+import pytest
+
+
+@pytest.fixture
+def sample_comment_data():
+    """Minimal comment structure from Reddit API."""
+    return {
+        "kind": "t1",
+        "data": {
+            "id": "comment123",
+            "author": "test_user",
+            "body": "This is a test comment",
+            "score": 42,
+            "created_utc": 1609459200.0,  # 2021-01-01 00:00:00 UTC
+            "replies": ""
+        }
+    }
+
+
+@pytest.fixture
+def sample_comment_with_replies():
+    """Comment with nested reply."""
+    return {
+        "kind": "t1",
+        "data": {
+            "id": "parent123",
+            "author": "parent_user",
+            "body": "Parent comment",
+            "score": 100,
+            "created_utc": 1609459200.0,
+            "replies": {
+                "kind": "Listing",
+                "data": {
+                    "children": [
+                        {
+                            "kind": "t1",
+                            "data": {
+                                "id": "child123",
+                                "author": "child_user",
+                                "body": "Child comment",
+                                "score": 50,
+                                "created_utc": 1609462800.0,  # 1 hour later
+                                "replies": ""
+                            }
+                        }
+                    ]
+                }
+            }
+        }
+    }
+
+
+@pytest.fixture
+def sample_thread_json():
+    """Full 2-element Reddit API response."""
+    return [
+        {
+            "kind": "Listing",
+            "data": {
+                "children": [
+                    {
+                        "kind": "t3",
+                        "data": {
+                            "id": "thread123",
+                            "title": "Test Thread Title",
+                            "author": "thread_author",
+                            "subreddit": "python",
+                            "url": "https://reddit.com/r/python/comments/thread123/test_thread_title/",
+                            "selftext": "This is the thread body",
+                            "score": 500,
+                            "created_utc": 1609459200.0,
+                            "num_comments": 2
+                        }
+                    }
+                ]
+            }
+        },
+        {
+            "kind": "Listing",
+            "data": {
+                "children": [
+                    {
+                        "kind": "t1",
+                        "data": {
+                            "id": "comment1",
+                            "author": "user1",
+                            "body": "First comment",
+                            "score": 10,
+                            "created_utc": 1609462800.0,
+                            "replies": ""
+                        }
+                    },
+                    {
+                        "kind": "more",
+                        "data": {
+                            "count": 5,
+                            "children": ["abc", "def"]
+                        }
+                    }
+                ]
+            }
+        }
+    ]

getred-0.1.3/tests/test_models.py

@@ -0,0 +1,108 @@
+"""Tests for data models."""
+
+import pytest
+from getred.models import Comment, Thread
+
+
+class TestCommentToDict:
+    """Tests for Comment.to_dict() method."""
+
+    def test_comment_to_dict(self):
+        """Serializes comment fields correctly."""
+        comment = Comment(
+            id="test123",
+            author="test_user",
+            body="Test comment body",
+            score=42,
+            created_utc="2021-01-01T00:00:00Z",
+            depth=0,
+            replies=[]
+        )
+
+        result = comment.to_dict()
+
+        assert result == {
+            "id": "test123",
+            "author": "test_user",
+            "body": "Test comment body",
+            "score": 42,
+            "created_utc": "2021-01-01T00:00:00Z",
+            "depth": 0,
+            "replies": []
+        }
+
+    def test_comment_to_dict_nested(self):
+        """Serializes nested replies recursively."""
+        child = Comment(
+            id="child123",
+            author="child_user",
+            body="Child comment",
+            score=10,
+            created_utc="2021-01-01T01:00:00Z",
+            depth=1,
+            replies=[]
+        )
+
+        parent = Comment(
+            id="parent123",
+            author="parent_user",
+            body="Parent comment",
+            score=50,
+            created_utc="2021-01-01T00:00:00Z",
+            depth=0,
+            replies=[child]
+        )
+
+        result = parent.to_dict()
+
+        assert result["id"] == "parent123"
+        assert result["depth"] == 0
+        assert len(result["replies"]) == 1
+        assert result["replies"][0]["id"] == "child123"
+        assert result["replies"][0]["depth"] == 1
+        assert result["replies"][0]["replies"] == []
+
+
+class TestThreadToDict:
+    """Tests for Thread.to_dict() method."""
+
+    def test_thread_to_dict(self):
+        """Serializes thread with comments."""
+        comment = Comment(
+            id="comment123",
+            author="commenter",
+            body="Great post!",
+            score=25,
+            created_utc="2021-01-01T01:00:00Z",
+            depth=0,
+            replies=[]
+        )
+
+        thread = Thread(
+            id="thread123",
+            title="Test Thread",
+            author="thread_author",
+            subreddit="python",
+            url="https://reddit.com/r/python/comments/thread123/test_thread/",
+            selftext="Thread body content",
+            score=500,
+            created_utc="2021-01-01T00:00:00Z",
+            fetched_at="2021-01-01T02:00:00Z",
+            comment_count=1,
+            comments=[comment]
+        )
+
+        result = thread.to_dict()
+
+        assert result["id"] == "thread123"
+        assert result["title"] == "Test Thread"
+        assert result["author"] == "thread_author"
+        assert result["subreddit"] == "python"
+        assert result["url"] == "https://reddit.com/r/python/comments/thread123/test_thread/"
+        assert result["selftext"] == "Thread body content"
+        assert result["score"] == 500
+        assert result["created_utc"] == "2021-01-01T00:00:00Z"
+        assert result["fetched_at"] == "2021-01-01T02:00:00Z"
+        assert result["comment_count"] == 1
+        assert len(result["comments"]) == 1
+        assert result["comments"][0]["id"] == "comment123"

getred-0.1.3/tests/test_parser.py

@@ -0,0 +1,132 @@
+"""Tests for Reddit JSON parser."""
+
+import pytest
+from getred.parser import parse_timestamp, parse_comment, parse_comments, parse_thread
+from getred.models import Comment, Thread
+
+
+class TestParseTimestamp:
+    """Tests for parse_timestamp function."""
+
+    def test_parse_timestamp(self):
+        """Unix timestamp converts to ISO format."""
+        timestamp = 1609459200.0  # 2021-01-01 00:00:00 UTC
+        result = parse_timestamp(timestamp)
+        assert result == "2021-01-01T00:00:00Z"
+
+
+class TestParseComment:
+    """Tests for parse_comment function."""
+
+    def test_parse_comment_basic(self, sample_comment_data):
+        """Parses comment fields correctly."""
+        comment = parse_comment(sample_comment_data, depth=0)
+
+        assert comment.id == "comment123"
+        assert comment.author == "test_user"
+        assert comment.body == "This is a test comment"
+        assert comment.score == 42
+        assert comment.created_utc == "2021-01-01T00:00:00Z"
+        assert comment.depth == 0
+        assert comment.replies == []
+
+    def test_parse_comment_with_replies(self, sample_comment_with_replies):
+        """Handles nested replies and depth tracking."""
+        parent = parse_comment(sample_comment_with_replies, depth=0)
+
+        assert parent.id == "parent123"
+        assert parent.author == "parent_user"
+        assert parent.depth == 0
+        assert len(parent.replies) == 1
+
+        child = parent.replies[0]
+        assert child.id == "child123"
+        assert child.author == "child_user"
+        assert child.body == "Child comment"
+        assert child.depth == 1
+        assert child.replies == []
+
+    def test_parse_comment_deleted(self):
+        """Handles deleted/removed comments."""
+        deleted_data = {
+            "kind": "t1",
+            "data": {
+                "id": "deleted123",
+                "author": "[deleted]",
+                "body": "[removed]",
+                "score": 0,
+                "created_utc": 1609459200.0,
+                "replies": ""
+            }
+        }
+        comment = parse_comment(deleted_data, depth=0)
+
+        assert comment.author == "[deleted]"
+        assert comment.body == "[removed]"
+
+
+class TestParseComments:
+    """Tests for parse_comments function."""
+
+    def test_parse_comments_filters_more(self):
+        """Skips 'more' objects (kind != t1)."""
+        comments_listing = [
+            {
+                "kind": "t1",
+                "data": {
+                    "id": "comment1",
+                    "author": "user1",
+                    "body": "Valid comment",
+                    "score": 10,
+                    "created_utc": 1609459200.0,
+                    "replies": ""
+                }
+            },
+            {
+                "kind": "more",
+                "data": {
+                    "count": 5,
+                    "children": ["abc", "def"]
+                }
+            },
+            {
+                "kind": "t1",
+                "data": {
+                    "id": "comment2",
+                    "author": "user2",
+                    "body": "Another valid comment",
+                    "score": 20,
+                    "created_utc": 1609462800.0,
+                    "replies": ""
+                }
+            }
+        ]
+
+        comments = parse_comments(comments_listing)
+
+        assert len(comments) == 2
+        assert comments[0].id == "comment1"
+        assert comments[1].id == "comment2"
+
+
+class TestParseThread:
+    """Tests for parse_thread function."""
+
+    def test_parse_thread(self, sample_thread_json):
+        """Full thread parsing with metadata and comments."""
+        thread = parse_thread(sample_thread_json)
+
+        assert thread.id == "thread123"
+        assert thread.title == "Test Thread Title"
+        assert thread.author == "thread_author"
+        assert thread.subreddit == "python"
+        assert thread.url == "https://reddit.com/r/python/comments/thread123/test_thread_title/"
+        assert thread.selftext == "This is the thread body"
+        assert thread.score == 500
+        assert thread.created_utc == "2021-01-01T00:00:00Z"
+        assert thread.comment_count == 2
+        assert thread.fetched_at.endswith("Z")
+
+        # Should only parse t1 comments, not 'more' objects
+        assert len(thread.comments) == 1
+        assert thread.comments[0].id == "comment1"

getred-0.1.3/tests/test_utils.py

@@ -0,0 +1,56 @@
+"""Tests for utility functions."""
+
+import pytest
+from getred.utils import validate_reddit_url, generate_slug
+
+
+class TestValidateRedditUrl:
+    """Tests for validate_reddit_url function."""
+
+    def test_validate_reddit_url_valid(self):
+        """Valid URLs with/without www should pass validation."""
+        valid_urls = [
+            "https://reddit.com/r/python/comments/abc123/cool_title/",
+            "https://www.reddit.com/r/python/comments/abc123/cool_title/",
+            "http://reddit.com/r/AskReddit/comments/xyz789/interesting_question/",
+            "https://reddit.com/r/programming/comments/test123/test/extra/path/",
+        ]
+        for url in valid_urls:
+            assert validate_reddit_url(url), f"Expected {url} to be valid"
+
+    def test_validate_reddit_url_invalid(self):
+        """Non-Reddit and malformed URLs should fail validation."""
+        invalid_urls = [
+            "https://example.com/r/python/comments/abc123/",
+            "https://reddit.com/r/python/",  # Missing /comments/
+            "https://reddit.com/comments/abc123/",  # Missing /r/subreddit/
+            "not a url",
+            "",
+            "ftp://reddit.com/r/python/comments/abc123/",
+        ]
+        for url in invalid_urls:
+            assert not validate_reddit_url(url), f"Expected {url} to be invalid"
+
+
+class TestGenerateSlug:
+    """Tests for generate_slug function."""
+
+    def test_generate_slug_full_url(self):
+        """Extracts {id}_{title} from complete URL."""
+        url = "https://reddit.com/r/python/comments/abc123/cool_python_feature/"
+        assert generate_slug(url) == "abc123_cool_python_feature"
+
+    def test_generate_slug_id_only(self):
+        """Handles URL without title, returns only ID."""
+        url = "https://reddit.com/r/python/comments/xyz789/"
+        assert generate_slug(url) == "xyz789"
+
+    def test_generate_slug_with_extra_path(self):
+        """Handles URLs with additional path segments."""
+        url = "https://reddit.com/r/AskReddit/comments/test123/interesting_question/extra/path/"
+        assert generate_slug(url) == "test123_interesting_question"
+
+    def test_generate_slug_fallback(self):
+        """Returns default for malformed URLs."""
+        url = "https://reddit.com/not/a/valid/url/"
+        assert generate_slug(url) == "reddit_thread"