fluff-cutter 0.1.0__py3-none-any.whl

fluff_cutter/__init__.py

@@ -0,0 +1,3 @@
+"""Paper Fluff Cutter - Extract the core value from academic papers."""
+
+__version__ = "0.1.0"

fluff_cutter/analyzer.py

@@ -0,0 +1,62 @@
+"""Core paper analysis logic."""
+
+from .providers.base import BaseLLMProvider
+
+ANALYSIS_PROMPT = """You are analyzing an academic paper. Your job is to cut through all the fluff and extract only what matters.
+
+Answer these three questions concisely and critically:
+
+1. WHY SHOULD I CARE?
+   - What problem does this address?
+   - Why does it matter to the world (not just academia)?
+
+2. WHAT'S THE ACTUAL INNOVATION?
+   - What is the core idea or proposal?
+   - What makes it different from existing work?
+   - Describe it in plain terms, no jargon.
+
+3. IS THE EVIDENCE CONVINCING?
+   - What experiments or evidence do they provide?
+   - Are there obvious gaps or weaknesses?
+   - Does the evidence actually support their claims?
+
+Be brutally honest. If the paper is weak, say so.
+If it's mostly fluff with a tiny kernel of insight, identify that kernel.
+
+Also extract the paper's title at the beginning of your response in this format:
+TITLE: [Paper Title]
+
+Then provide your analysis."""
+
+
+def analyze_paper(provider: BaseLLMProvider, pdf_base64: str, filename: str) -> dict:
+    """
+    Analyze a paper using the provided LLM.
+
+    Args:
+        provider: The LLM provider to use for analysis.
+        pdf_base64: Base64-encoded PDF data.
+        filename: Original filename of the PDF.
+
+    Returns:
+        Dictionary with 'title', 'analysis', and 'model_info' keys.
+    """
+    raw_response = provider.analyze_paper(pdf_base64, filename, ANALYSIS_PROMPT)
+
+    # Try to extract the title from the response
+    title = "Unknown Title"
+    analysis = raw_response
+
+    lines = raw_response.strip().split("\n")
+    for i, line in enumerate(lines):
+        if line.strip().upper().startswith("TITLE:"):
+            title = line.split(":", 1)[1].strip()
+            # Remove the title line from the analysis
+            analysis = "\n".join(lines[i + 1 :]).strip()
+            break
+
+    return {
+        "title": title,
+        "analysis": analysis,
+        "model_info": provider.get_model_info(),
+    }

fluff_cutter/cli.py

@@ -0,0 +1,185 @@
+"""Command-line interface for Paper Fluff Cutter."""
+
+import sys
+
+import click
+
+from . import __version__
+from .analyzer import analyze_paper
+from .config import (
+    get_api_key,
+    get_config_path,
+    get_default_provider,
+    is_configured,
+    load_config,
+    save_config,
+)
+from .output import print_analysis, save_analysis
+from .pdf import get_pdf_filename, read_pdf_as_base64
+from .providers import AnthropicProvider, OpenAIProvider
+
+
+PROVIDERS = {
+    "openai": OpenAIProvider,
+    "anthropic": AnthropicProvider,
+}
+
+
+@click.group()
+@click.version_option(version=__version__)
+def main():
+    """Paper Fluff Cutter - Extract the core value from academic papers."""
+    pass
+
+
+@main.command()
+def init():
+    """Initialize configuration with API keys."""
+    click.echo("Paper Fluff Cutter Configuration")
+    click.echo("=" * 40)
+    click.echo()
+
+    config = {}
+
+    # OpenAI API Key
+    click.echo("Enter your API keys (press Enter to skip):")
+    click.echo()
+
+    openai_key = click.prompt(
+        "OpenAI API Key",
+        default="",
+        hide_input=True,
+        show_default=False,
+    )
+    if openai_key:
+        config["openai_api_key"] = openai_key
+        click.echo("  ✓ OpenAI API key saved")
+
+    # Anthropic API Key
+    anthropic_key = click.prompt(
+        "Anthropic API Key",
+        default="",
+        hide_input=True,
+        show_default=False,
+    )
+    if anthropic_key:
+        config["anthropic_api_key"] = anthropic_key
+        click.echo("  ✓ Anthropic API key saved")
+
+    if not config:
+        click.echo()
+        click.echo("No API keys provided. Configuration not saved.")
+        click.echo("You can set keys via environment variables instead:")
+        click.echo("  export OPENAI_API_KEY=sk-...")
+        click.echo("  export ANTHROPIC_API_KEY=sk-ant-...")
+        return
+
+    # Default provider
+    click.echo()
+    available_providers = []
+    if "openai_api_key" in config:
+        available_providers.append("openai")
+    if "anthropic_api_key" in config:
+        available_providers.append("anthropic")
+
+    if len(available_providers) > 1:
+        default_provider = click.prompt(
+            "Default provider",
+            type=click.Choice(available_providers),
+            default="anthropic" if "anthropic" in available_providers else "openai",
+        )
+    else:
+        default_provider = available_providers[0]
+
+    config["default_provider"] = default_provider
+
+    # Save configuration
+    save_config(config)
+
+    click.echo()
+    click.echo(f"Configuration saved to: {get_config_path()}")
+    click.echo(f"Default provider: {default_provider}")
+    click.echo()
+    click.echo("You're ready to analyze papers!")
+    click.echo("  fluff-cutter analyze <paper.pdf>")
+
+
+@main.command()
+@click.argument("paper_path", type=click.Path(exists=True))
+@click.option(
+    "-p",
+    "--provider",
+    type=click.Choice(["openai", "anthropic"]),
+    help="LLM provider to use",
+)
+@click.option(
+    "-m",
+    "--model",
+    help="Specific model to use (overrides provider default)",
+)
+@click.option(
+    "-o",
+    "--output",
+    type=click.Path(),
+    help="Save output to file instead of printing",
+)
+def analyze(paper_path: str, provider: str | None, model: str | None, output: str | None):
+    """Analyze an academic paper and extract its core value."""
+    # Check configuration
+    if not is_configured():
+        click.echo("Error: No API keys configured.", err=True)
+        click.echo("Run 'fluff-cutter init' to set up your API keys.", err=True)
+        click.echo("Or set environment variables:", err=True)
+        click.echo("  export OPENAI_API_KEY=sk-...", err=True)
+        click.echo("  export ANTHROPIC_API_KEY=sk-ant-...", err=True)
+        sys.exit(1)
+
+    # Load config and determine provider
+    config = load_config()
+    provider_name = provider or get_default_provider(config)
+
+    # Get API key for the selected provider
+    api_key = get_api_key(provider_name, config)
+    if not api_key:
+        click.echo(f"Error: No API key configured for {provider_name}.", err=True)
+        click.echo(f"Run 'fluff-cutter init' or set {provider_name.upper()}_API_KEY.", err=True)
+        sys.exit(1)
+
+    # Create provider instance
+    provider_class = PROVIDERS[provider_name]
+    llm_provider = provider_class(api_key=api_key, model=model)
+
+    click.echo(f"Analyzing paper: {paper_path}")
+    click.echo(f"Using: {llm_provider.get_model_info()}")
+    click.echo()
+
+    # Read PDF
+    click.echo("Reading PDF...")
+    try:
+        pdf_base64 = read_pdf_as_base64(paper_path)
+        filename = get_pdf_filename(paper_path)
+        click.echo("  PDF loaded successfully")
+    except Exception as e:
+        click.echo(f"Error reading PDF: {e}", err=True)
+        sys.exit(1)
+
+    # Analyze the paper
+    click.echo("Analyzing paper (this may take a minute)...")
+    try:
+        result = analyze_paper(llm_provider, pdf_base64, filename)
+    except Exception as e:
+        click.echo(f"Error during analysis: {e}", err=True)
+        sys.exit(1)
+
+    click.echo()
+
+    # Output results
+    if output:
+        save_analysis(result["title"], result["analysis"], result["model_info"], output)
+        click.echo(f"Analysis saved to: {output}")
+    else:
+        print_analysis(result["title"], result["analysis"], result["model_info"])
+
+
+if __name__ == "__main__":
+    main()

fluff_cutter/config.py

@@ -0,0 +1,118 @@
+"""Configuration management for Paper Fluff Cutter."""
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+# Config file location
+CONFIG_DIR = Path.home() / ".config" / "fluff-cutter"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+# Default values
+DEFAULT_PROVIDER = "anthropic"
+
+
+def get_config_path() -> Path:
+    """Get the path to the config file."""
+    return CONFIG_FILE
+
+
+def load_config_file() -> dict[str, Any]:
+    """
+    Load configuration from the config file.
+
+    Returns:
+        Dictionary with config values, or empty dict if file doesn't exist.
+    """
+    if not CONFIG_FILE.exists():
+        return {}
+
+    try:
+        with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_config(config: dict[str, Any]) -> None:
+    """
+    Save configuration to the config file.
+
+    Args:
+        config: Dictionary with config values to save.
+    """
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)
+
+
+def load_config() -> dict[str, Any]:
+    """
+    Load configuration with precedence:
+    1. Environment variables (highest)
+    2. Config file (lowest)
+
+    Returns:
+        Merged configuration dictionary.
+    """
+    # Start with config file values
+    config = load_config_file()
+
+    # Override with environment variables
+    if os.environ.get("OPENAI_API_KEY"):
+        config["openai_api_key"] = os.environ["OPENAI_API_KEY"]
+
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        config["anthropic_api_key"] = os.environ["ANTHROPIC_API_KEY"]
+
+    if os.environ.get("FLUFF_CUTTER_PROVIDER"):
+        config["default_provider"] = os.environ["FLUFF_CUTTER_PROVIDER"]
+
+    return config
+
+
+def get_api_key(provider: str, config: dict[str, Any] | None = None) -> str | None:
+    """
+    Get the API key for a specific provider.
+
+    Args:
+        provider: The provider name ('openai' or 'anthropic').
+        config: Optional pre-loaded config. If None, loads config.
+
+    Returns:
+        The API key or None if not configured.
+    """
+    if config is None:
+        config = load_config()
+
+    key_name = f"{provider}_api_key"
+    return config.get(key_name)
+
+
+def get_default_provider(config: dict[str, Any] | None = None) -> str:
+    """
+    Get the default provider.
+
+    Args:
+        config: Optional pre-loaded config. If None, loads config.
+
+    Returns:
+        The default provider name.
+    """
+    if config is None:
+        config = load_config()
+
+    return config.get("default_provider", DEFAULT_PROVIDER)
+
+
+def is_configured() -> bool:
+    """
+    Check if at least one provider is configured.
+
+    Returns:
+        True if at least one API key is available.
+    """
+    config = load_config()
+    return bool(config.get("openai_api_key") or config.get("anthropic_api_key"))

fluff_cutter/output.py

@@ -0,0 +1,56 @@
+"""Output formatting for paper analysis."""
+
+from datetime import datetime
+
+
+def format_analysis(title: str, analysis: str, model_info: str) -> str:
+    """
+    Format the analysis as clean markdown.
+
+    Args:
+        title: The paper title.
+        analysis: The raw analysis from the LLM.
+        model_info: Information about the model used.
+
+    Returns:
+        Formatted markdown string.
+    """
+    date_str = datetime.now().strftime("%Y-%m-%d")
+
+    output = f"""# Paper Analysis: {title}
+
+{analysis}
+
+---
+*Analyzed with {model_info} on {date_str}*
+"""
+    return output
+
+
+def print_analysis(title: str, analysis: str, model_info: str) -> None:
+    """
+    Print the formatted analysis to stdout.
+
+    Args:
+        title: The paper title.
+        analysis: The raw analysis from the LLM.
+        model_info: Information about the model used.
+    """
+    print(format_analysis(title, analysis, model_info))
+
+
+def save_analysis(
+    title: str, analysis: str, model_info: str, output_path: str
+) -> None:
+    """
+    Save the formatted analysis to a file.
+
+    Args:
+        title: The paper title.
+        analysis: The raw analysis from the LLM.
+        model_info: Information about the model used.
+        output_path: Path to save the output file.
+    """
+    content = format_analysis(title, analysis, model_info)
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(content)

fluff_cutter/pdf.py

@@ -0,0 +1,45 @@
+"""PDF handling for LLM analysis."""
+
+import base64
+from pathlib import Path
+
+
+def read_pdf_as_base64(pdf_path: str | Path) -> str:
+    """
+    Read a PDF file and encode it as base64.
+
+    Args:
+        pdf_path: Path to the PDF file.
+
+    Returns:
+        Base64-encoded PDF data.
+
+    Raises:
+        FileNotFoundError: If the PDF file doesn't exist.
+        ValueError: If the file is not a PDF.
+    """
+    pdf_path = Path(pdf_path)
+
+    if not pdf_path.exists():
+        raise FileNotFoundError(f"PDF file not found: {pdf_path}")
+
+    if pdf_path.suffix.lower() != ".pdf":
+        raise ValueError(f"File is not a PDF: {pdf_path}")
+
+    with open(pdf_path, "rb") as f:
+        pdf_data = f.read()
+
+    return base64.standard_b64encode(pdf_data).decode("utf-8")
+
+
+def get_pdf_filename(pdf_path: str | Path) -> str:
+    """
+    Get the filename from a PDF path.
+
+    Args:
+        pdf_path: Path to the PDF file.
+
+    Returns:
+        The filename.
+    """
+    return Path(pdf_path).name

fluff_cutter/providers/__init__.py

@@ -0,0 +1,7 @@
+"""LLM provider implementations."""
+
+from .base import BaseLLMProvider
+from .openai import OpenAIProvider
+from .anthropic import AnthropicProvider
+
+__all__ = ["BaseLLMProvider", "OpenAIProvider", "AnthropicProvider"]

fluff_cutter/providers/anthropic.py

@@ -0,0 +1,59 @@
+"""Anthropic provider implementation with native PDF support."""
+
+import anthropic
+
+from .base import BaseLLMProvider
+
+
+class AnthropicProvider(BaseLLMProvider):
+    """Anthropic Claude provider with native PDF support."""
+
+    @property
+    def default_model(self) -> str:
+        return "claude-sonnet-4-20250514"
+
+    @property
+    def provider_name(self) -> str:
+        return "Anthropic"
+
+    def analyze_paper(self, pdf_base64: str, filename: str, prompt: str) -> str:
+        """
+        Analyze a paper using Anthropic's native PDF support.
+
+        Args:
+            pdf_base64: Base64-encoded PDF data.
+            filename: Original filename of the PDF.
+            prompt: The analysis prompt to send to the model.
+
+        Returns:
+            The model's analysis as a string.
+        """
+        client = anthropic.Anthropic(api_key=self.api_key)
+
+        response = client.messages.create(
+            model=self.model,
+            max_tokens=4096,
+            messages=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "document",
+                            "source": {
+                                "type": "base64",
+                                "media_type": "application/pdf",
+                                "data": pdf_base64,
+                            },
+                        },
+                        {
+                            "type": "text",
+                            "text": prompt,
+                        },
+                    ],
+                }
+            ],
+        )
+
+        # Extract text from the response
+        text_blocks = [block.text for block in response.content if block.type == "text"]
+        return "\n".join(text_blocks)

fluff_cutter/providers/base.py

@@ -0,0 +1,49 @@
+"""Base class for LLM providers."""
+
+from abc import ABC, abstractmethod
+
+
+class BaseLLMProvider(ABC):
+    """Abstract base class for LLM providers with PDF support."""
+
+    def __init__(self, api_key: str, model: str | None = None):
+        """
+        Initialize the provider.
+
+        Args:
+            api_key: API key for the provider.
+            model: Optional model override. If not provided, uses default.
+        """
+        self.api_key = api_key
+        self.model = model or self.default_model
+
+    @property
+    @abstractmethod
+    def default_model(self) -> str:
+        """The default model to use for this provider."""
+        pass
+
+    @property
+    @abstractmethod
+    def provider_name(self) -> str:
+        """Human-readable name of the provider."""
+        pass
+
+    @abstractmethod
+    def analyze_paper(self, pdf_base64: str, filename: str, prompt: str) -> str:
+        """
+        Analyze a paper PDF using native PDF support.
+
+        Args:
+            pdf_base64: Base64-encoded PDF data.
+            filename: Original filename of the PDF.
+            prompt: The analysis prompt to send to the model.
+
+        Returns:
+            The model's analysis as a string.
+        """
+        pass
+
+    def get_model_info(self) -> str:
+        """Get a string describing the provider and model being used."""
+        return f"{self.provider_name} ({self.model})"

fluff_cutter/providers/openai.py

@@ -0,0 +1,54 @@
+"""OpenAI provider implementation with native PDF support."""
+
+from openai import OpenAI
+
+from .base import BaseLLMProvider
+
+
+class OpenAIProvider(BaseLLMProvider):
+    """OpenAI GPT-4o provider with native PDF support."""
+
+    @property
+    def default_model(self) -> str:
+        return "gpt-4o"
+
+    @property
+    def provider_name(self) -> str:
+        return "OpenAI"
+
+    def analyze_paper(self, pdf_base64: str, filename: str, prompt: str) -> str:
+        """
+        Analyze a paper using OpenAI's native PDF support.
+
+        Args:
+            pdf_base64: Base64-encoded PDF data.
+            filename: Original filename of the PDF.
+            prompt: The analysis prompt to send to the model.
+
+        Returns:
+            The model's analysis as a string.
+        """
+        client = OpenAI(api_key=self.api_key)
+
+        # Use the Responses API with native PDF support
+        response = client.responses.create(
+            model=self.model,
+            input=[
+                {
+                    "role": "user",
+                    "content": [
+                        {
+                            "type": "input_file",
+                            "filename": filename,
+                            "file_data": f"data:application/pdf;base64,{pdf_base64}",
+                        },
+                        {
+                            "type": "input_text",
+                            "text": prompt,
+                        },
+                    ],
+                }
+            ],
+        )
+
+        return response.output_text or ""

fluff_cutter-0.1.0.dist-info/METADATA

@@ -0,0 +1,104 @@
+Metadata-Version: 2.4
+Name: fluff-cutter
+Version: 0.1.0
+Summary: A CLI tool to analyze academic papers and extract their core value
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: click>=8.0
+Requires-Dist: openai>=1.0
+Requires-Dist: anthropic>=0.18
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# Paper Fluff Cutter
+
+A CLI tool that cuts through academic paper fluff to extract what actually matters.
+
+Most research has close to zero value. This tool uses multimodal LLMs to analyze papers and answer the three questions every paper should be able to answer:
+
+1. **Why should I care?** - What problem does this address and why does it matter?
+2. **What's the actual innovation?** - What's the core idea in plain terms?
+3. **Is the evidence convincing?** - Do the experiments actually support the claims?
+
+## Installation
+
+### Prerequisites
+
+- Python 3.10+
+
+### Install the tool
+
+```bash
+pip install -e .
+```
+
+## Configuration
+
+### Option 1: Interactive setup (recommended)
+
+```bash
+fluff-cutter init
+```
+
+This will prompt you for your API keys and save them to `~/.config/fluff-cutter/config.json`.
+
+### Option 2: Environment variables
+
+```bash
+export OPENAI_API_KEY=sk-your-key-here
+export ANTHROPIC_API_KEY=sk-ant-your-key-here
+export FLUFF_CUTTER_PROVIDER=anthropic  # optional, default provider
+```
+
+## Usage
+
+### Basic usage
+
+```bash
+fluff-cutter analyze paper.pdf
+```
+
+### Specify provider
+
+```bash
+fluff-cutter analyze paper.pdf --provider openai
+fluff-cutter analyze paper.pdf --provider anthropic
+```
+
+### Specify model
+
+```bash
+fluff-cutter analyze paper.pdf --provider openai --model gpt-4o
+fluff-cutter analyze paper.pdf --provider anthropic --model claude-sonnet-4-20250514
+```
+
+### Save output to file
+
+```bash
+fluff-cutter analyze paper.pdf --output analysis.md
+```
+
+## Supported Providers
+
+| Provider | Default Model | Environment Variable |
+|----------|---------------|---------------------|
+| OpenAI | gpt-4o | `OPENAI_API_KEY` |
+| Anthropic | claude-sonnet-4-20250514 | `ANTHROPIC_API_KEY` |
+
+Both providers now support native PDF input - no external dependencies like poppler needed.
+
+## Configuration Precedence
+
+Configuration is loaded with the following precedence (highest to lowest):
+
+1. Command-line arguments (`--provider`, `--model`)
+2. Environment variables
+3. Config file (`~/.config/fluff-cutter/config.json`)
+
+## License
+
+MIT

fluff_cutter-0.1.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+fluff_cutter/__init__.py,sha256=m54r3DTMukXFMTUNb6dqISi4-rYP-3cAwNlxO85B3WY,95
+fluff_cutter/analyzer.py,sha256=Er_ZFva5x12evkg4jiOLhYllGFjcTlch7OSHz0b-SAQ,2006
+fluff_cutter/cli.py,sha256=Txg4sAvbmzn1-HhViMeXWfOKJnqyuBItEfbHK--8Ytw,5354
+fluff_cutter/config.py,sha256=Ly5ZKz8JDWNxUPJx8m9jOEcWoxF24LX64Wr0nXNkfU4,2918
+fluff_cutter/output.py,sha256=vQblPNEdPs8jaeZT0RDw376FGPD9cqH39KMZlP5iDlg,1409
+fluff_cutter/pdf.py,sha256=9HYEMRbYwaJeZPFPvvUEkNbSxLLt0uwz1izBK-UZdkg,992
+fluff_cutter/providers/__init__.py,sha256=GHUJmPYf-f46LdiBN9RtCY25bJMIdp7Bp1PtIwbK_cw,217
+fluff_cutter/providers/anthropic.py,sha256=rtE8Io3QLu-svw8tD72WoTpfvY2_RAiZaHTomrUA4bA,1791
+fluff_cutter/providers/base.py,sha256=6KkfAgh1jSy3IeXiI6mp0oIX4aQMs9188JWWf9g6WXk,1385
+fluff_cutter/providers/openai.py,sha256=ObYGNBRMkvnlmK6jbCTv8nN6ReVrCTmTlV1oneq-Ii4,1559
+fluff_cutter-0.1.0.dist-info/licenses/LICENSE,sha256=Web8HWLb3-BT76oD6gp0yLeRc-6trinrOCE03-NCsWM,1070
+fluff_cutter-0.1.0.dist-info/METADATA,sha256=jaEyBW2AKz9DMDV5h-IjnGClrHrosff0-PT8H1-v2fk,2528
+fluff_cutter-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+fluff_cutter-0.1.0.dist-info/entry_points.txt,sha256=XbYJJc_MN1PgHB47-NWk76BnQ5l0Ba0B5jb9vwAEU5Y,55
+fluff_cutter-0.1.0.dist-info/top_level.txt,sha256=Hb1MmR3LbLIc9PXSm60Jn4a-fht1wwvCT5kxhnyB6VI,13
+fluff_cutter-0.1.0.dist-info/RECORD,,

fluff_cutter-0.1.0.dist-info/WHEEL

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

fluff_cutter-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fluff-cutter = fluff_cutter.cli:main

fluff_cutter-0.1.0.dist-info/licenses/LICENSE

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

fluff_cutter-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+fluff_cutter