aipr-py 0.2.4__py3-none-any.whl

aipr/__init__.py

@@ -0,0 +1,3 @@
+"""aipr: read an open-source repository's AI contribution policy."""
+
+__version__ = "0.2.3"

aipr/cache.py

@@ -0,0 +1,84 @@
+"""Thread-safe TTL cache for policy detection results."""
+
+from __future__ import annotations
+
+import copy
+import os
+import threading
+import time
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from aipr.detector import Policy
+
+
+# Default TTL: 24 hours (in seconds)
+DEFAULT_CACHE_TTL = int(os.environ.get("AIPR_CACHE_TTL", "86400"))
+MAX_CACHE_SIZE = int(os.environ.get("AIPR_CACHE_SIZE", "1024"))
+
+
+@dataclass
+class CacheEntry:
+    ts: float
+    policy: object  # Policy dataclass
+
+
+class TTLCache:
+    """Thread-safe TTL cache with LRU eviction and deep copy on read.
+    
+    Replaces lru_cache for Policy objects to ensure:
+    1. Thread safety via threading.Lock
+    2. TTL-based expiration (configurable via AIPR_CACHE_TTL env var)
+    3. Deep copy on read to prevent mutation of cached state
+    """
+
+    def __init__(self, ttl: int = DEFAULT_CACHE_TTL, maxsize: int = MAX_CACHE_SIZE):
+        self._ttl = ttl
+        self._maxsize = maxsize
+        self._cache: dict[str, CacheEntry] = {}
+        self._lock = threading.Lock()
+
+    def get(self, key: str) -> Optional[object]:
+        """Get a cached Policy, returning a deep copy.
+        
+        Returns None if key not found or entry expired.
+        """
+        with self._lock:
+            entry = self._cache.get(key)
+            if entry is None:
+                return None
+            if time.time() - entry.ts > self._ttl:
+                del self._cache[key]
+                return None
+            return copy.deepcopy(entry.policy)
+
+    def put(self, key: str, policy: object) -> None:
+        """Store a Policy with current timestamp.
+        
+        Evicts oldest entries if cache exceeds maxsize.
+        """
+        with self._lock:
+            while len(self._cache) >= self._maxsize:
+                oldest_key = min(self._cache, key=lambda k: self._cache[k].ts)
+                del self._cache[oldest_key]
+            self._cache[key] = CacheEntry(ts=time.time(), policy=copy.deepcopy(policy))
+
+    def clear(self) -> None:
+        """Clear all cached entries."""
+        with self._lock:
+            self._cache.clear()
+
+    def __len__(self) -> int:
+        with self._lock:
+            return len(self._cache)
+
+    def __contains__(self, key: str) -> bool:
+        with self._lock:
+            entry = self._cache.get(key)
+            if entry is None:
+                return False
+            if time.time() - entry.ts > self._ttl:
+                del self._cache[key]
+                return False
+            return True

aipr/cli.py

@@ -0,0 +1,448 @@
+"""aipr CLI: read an open-source repository's AI contribution policy.
+
+Usage:
+  aipr <owner/repo>          # fetch governance files from GitHub and classify
+  aipr --text <file>         # classify a local file
+  aipr --json <owner/repo>   # machine-readable output
+  aipr init                  # scaffold AI_POLICY.md and AI_TOOL_POLICY.md
+
+Exit codes: 0 = autonomous-safe, 1 = not safe / restricted, 2 = unknown, 64 = usage error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import os
+import sys
+import time
+from pathlib import Path
+
+from . import __version__
+from .detector import Verdict, detect_policy
+from .http import fetch_with_retry, RateLimitError
+
+logger = logging.getLogger(__name__)
+
+# Files that commonly carry AI policy, in priority order. The org-level
+# .github repo is also probed because many foundations centralize there.
+CANDIDATE_FILES = [
+    "AI_POLICY.md",
+    "AI_POLICY.rst",
+    "AI_TOOL_POLICY.md",
+    "CONTRIBUTING.md",
+    "CONTRIBUTING.rst",
+    "CONTRIBUTING-BEGINNERS.md",
+    ".github/AI_POLICY.md",
+    ".github/CONTRIBUTING.md",
+    ".github/copilot-instructions.md",
+    "docs/CONTRIBUTING.md",
+    "docs/CONTRIBUTING-BEGINNERS.md",
+    "AGENTS.md",
+    "CLAUDE.md",
+    ".cursorrules",
+    ".windsurfrules",
+    ".aider.conf.yml",
+    "README.md",
+]
+
+ORG_FALLBACK_FILES = [".github/AI_POLICY.md", ".github/CONTRIBUTING.md"]
+
+EXIT_OK = 0
+EXIT_UNSAFE = 1
+EXIT_UNKNOWN = 2
+EXIT_USAGE = 64
+
+# --- on-disk cache ----------------------------------------------------------
+# Each governance file fetch is cached under AIPR_CACHE_DIR (default:
+# ~/.cache/aipr) with a TTL (AIPR_CACHE_TTL seconds, default 86400 = 24h).
+# The cron scans ~10 repos/day and each repo costs up to 11 API calls; the
+# cache keeps repeat scans free of charge. --no-cache bypasses it entirely.
+
+
+def _cache_dir() -> Path:
+    return Path(os.environ.get("AIPR_CACHE_DIR", str(Path.home() / ".cache" / "aipr")))
+
+
+def _cache_ttl() -> int:
+    try:
+        return int(os.environ.get("AIPR_CACHE_TTL", "86400"))
+    except ValueError:
+        return 86400
+
+
+def clear_cache() -> None:
+    """Delete every cached policy entry."""
+    d = _cache_dir()
+    if d.exists():
+        for f in d.glob("*.json"):
+            f.unlink(missing_ok=True)
+
+
+def _cache_get(key: str):
+    path = _cache_dir() / f"{key}.json"
+    try:
+        entry = json.loads(path.read_text())
+        if time.time() - entry["ts"] <= _cache_ttl():
+            return entry["files"]
+        path.unlink(missing_ok=True)
+    except Exception as e:
+        logger.warning("Cache read failed for %s: %s", key, e)
+    return None
+
+
+def _cache_put(key: str, files: list) -> None:
+    d = _cache_dir()
+    d.mkdir(parents=True, exist_ok=True)
+    path = d / f"{key}.json"
+    try:
+        path.write_text(json.dumps({"ts": time.time(), "files": files}))
+    except OSError:
+        pass
+
+
+def _fetch_gh(url: str) -> str | None:
+    """Fetch raw content via the GitHub API (honors GH_TOKEN; no hard dep on gh).
+
+    Delegates to :func:`aipr.http.fetch_with_retry` for retry + rate-limit
+    handling. Transient errors (502/503/504/408/429) are retried up to 3 times
+    with exponential backoff. HTTP 403 (rate limit) raises RateLimitError.
+    """
+    return fetch_with_retry(url)
+
+
+def fetch_policy_text(repo: str, use_cache: bool = True) -> list[tuple[str, str]]:
+    """Return [(filename, text), ...] for every candidate file found in owner/repo.
+
+    Raises :class:`RateLimitError` if rate-limited by the GitHub API. In that case,
+    no caching occurs — a later retry can succeed.
+    """
+    key = repo.replace("/", "__")
+    if use_cache:
+        cached = _cache_get(key)
+        if cached is not None:
+            return [(name, text) for name, text in cached]
+
+    results: list[tuple[str, str]] = []
+    for name in CANDIDATE_FILES:
+        try:
+            text = _fetch_gh(f"https://api.github.com/repos/{repo}/contents/{name}")
+        except RateLimitError:
+            raise  # propagate — caller handles, no caching
+        if text and text.strip():
+            results.append((name, text))
+    if not results and "/" in repo:
+        org = repo.split("/")[0]
+        for name in ORG_FALLBACK_FILES:
+            try:
+                text = _fetch_gh(f"https://api.github.com/repos/{org}/.github/contents/{name}")
+            except RateLimitError:
+                raise
+            if text and text.strip():
+                results.append((f"{org}/.github/{name}", text))
+                break
+    if use_cache and results:
+        _cache_put(key, [(name, text) for name, text in results])
+    return results
+
+
+def _validate_repo(repo: str) -> bool:
+    """Validate that repo matches the expected OWNER/REPO format."""
+    import re
+    return bool(re.match(r'^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+$', repo))
+
+
+def classify_repo(repo: str, use_cache: bool = True) -> dict:
+    """Fetch + classify all governance files of one repository.
+
+    On :class:`RateLimitError`, the cache is NOT populated with an empty result
+    so that a later retry can succeed. The returned dict contains
+    ``rate_limited: true`` to allow callers to distinguish this case from
+    genuine "no policy found" unknowns.
+    """
+    if not _validate_repo(repo):
+        raise ValueError(f"Invalid repository format: {repo!r}. Expected OWNER/REPO with alphanumeric, hyphen, underscore, dot characters.")
+    try:
+        files = fetch_policy_text(repo, use_cache=use_cache)
+    except RateLimitError as e:
+        logger.warning("Rate-limited on %s: %s", repo, e)
+        return {
+            "repo": repo,
+            "verdict": Verdict.UNKNOWN.value,
+            "files": [],
+            "rate_limited": True,
+            "autonomous_safe": False,
+            "confidence": 0.0,
+            "score": 0.0,
+        }
+    if not files:
+        return {"repo": repo, "verdict": Verdict.UNKNOWN.value, "files": [],
+                "autonomous_safe": False, "confidence": 0.0, "score": 0.0}
+
+    combined = "\n\n".join(text for _, text in files)
+    policy = detect_policy(combined)
+    return {
+        "repo": repo,
+        "verdict": policy.verdict.value,
+        "files": [name for name, _ in files],
+        "evidence": policy.evidence,
+        "autonomous_safe": policy.autonomous_safe,
+        "confidence": policy.confidence,
+        "score": policy.score,
+    }
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    """Build the argument parser for aipr."""
+    parser = argparse.ArgumentParser(
+        prog="aipr",
+        description="Read a repository's AI contribution policy before contributing.",
+    )
+    parser.add_argument("repo", nargs="*", help="owner/repo to inspect (accepts several for batch)")
+    parser.add_argument("--text", metavar="FILE", help="classify a local file instead")
+    parser.add_argument("--json", action="store_true", dest="as_json", help="JSON output")
+    parser.add_argument("--sarif", action="store_true", dest="as_sarif", help="SARIF 2.1.0 output (for GitHub Code Scanning)")
+    parser.add_argument(
+        "--explain",
+        action="store_true",
+        dest="explain",
+        help="explain verdict with contributing policy sources and snippets",
+    )
+    parser.add_argument(
+        "--no-cache",
+        action="store_true",
+        dest="no_cache",
+        help="fetch fresh policy files even if a cached copy exists",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    return parser
+
+
+def _parse_init_args(argv: list[str]) -> argparse.Namespace:
+    """Parse args for the 'init' subcommand."""
+    parser = argparse.ArgumentParser(prog="aipr init", description="Scaffold AI policy files")
+    parser.add_argument(
+        "--dir",
+        type=Path,
+        default=Path("."),
+        help="Directory to create policy files (default: current dir)",
+    )
+    parser.add_argument(
+        "--type",
+        choices=["permissive", "disclose", "human_only"],
+        default="disclose",
+        help="Policy preset (default: disclose)",
+    )
+    parser.add_argument(
+        "--org",
+        help="Organization name for centralized policies",
+    )
+    return parser.parse_args(argv)
+
+
+def _cmd_init(args: argparse.Namespace) -> int:
+    """Scaffold AI policy files in the target directory."""
+    target_dir: Path = args.dir
+    target_dir.mkdir(parents=True, exist_ok=True)
+
+    policy_file = target_dir / "AI_POLICY.md"
+    tool_policy_file = target_dir / "AI_TOOL_POLICY.md"
+
+    org_line = f" for {args.org}" if args.org else ""
+
+    if args.type == "permissive":
+        policy_text = f"""# AI Usage Policy{org_line}
+
+This repository welcomes contributions made with the assistance of AI tools.
+
+## Guidelines
+
+- AI-assisted contributions are encouraged.
+- Contributors are responsible for verifying the correctness of all submitted code.
+- No disclosure is required for AI-assisted work.
+
+## Scope
+
+This policy applies to all contributions: code, documentation, tests, and design.
+"""
+    elif args.type == "human_only":
+        policy_text = f"""# AI Usage Policy{org_line}
+
+This repository does NOT accept contributions generated by AI tools.
+
+## Policy
+
+- All contributions must be authored by humans.
+- AI-generated code, documentation, or design submissions will be rejected.
+- Automated pull requests from bots or AI agents are not permitted.
+
+## Rationale
+
+[Explain why human authorship is required: e.g., IP concerns, code quality, regulatory requirements.]
+"""
+    else:  # disclose
+        policy_text = f"""# AI Usage Policy{org_line}
+
+This repository accepts AI-assisted contributions with disclosure.
+
+## Guidelines
+
+- Contributions made with AI assistance are welcome.
+- You MUST disclose the use of AI tools in your pull request description.
+- Add the following trailer to your commit messages when AI was involved:
+
+  `Assisted-by: AI`
+
+- You are responsible for reviewing and verifying all AI-generated content.
+
+## Scope
+
+This policy applies to all contributions: code, documentation, tests, and design.
+"""
+
+    tool_policy_text = f"""# AI Tool Policy{org_line}
+
+Classification of AI tools and their permitted usage.
+
+## Permitted Tools
+
+| Tool | Usage | Notes |
+|------|-------|-------|
+| GitHub Copilot | Code completion | Must review all suggestions |
+| ChatGPT / Claude | Code generation | Must disclose in PR |
+| aipr | Policy checking | Encouraged before contributing |
+
+## Restricted Tools
+
+- Fully autonomous coding agents (without human review) are not permitted.
+- Tools that submit PRs automatically without human oversight.
+
+## Disclosure Format
+
+In your PR description, include:
+
+- Tool name and version
+- What it was used for
+- How you verified the output
+"""
+
+    created = []
+    if not policy_file.exists():
+        policy_file.write_text(policy_text)
+        created.append(str(policy_file))
+    else:
+        print(f"WARNING: {policy_file} already exists — skipping", file=sys.stderr)
+
+    if not tool_policy_file.exists():
+        tool_policy_file.write_text(tool_policy_text)
+        created.append(str(tool_policy_file))
+    else:
+        print(f"WARNING: {tool_policy_file} already exists — skipping", file=sys.stderr)
+
+    if created:
+        print(f"✓ Created {', '.join(created)}")
+        return 0
+    else:
+        print("No files created (already exist).", file=sys.stderr)
+        return 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    # Fast-path: if first arg is "init", dispatch to init subcommand
+    # before building the main parser (avoids argparse subparser conflicts
+    # with "owner/repo" positional args).
+    if argv is not None and argv and argv[0] == "init":
+        args = _parse_init_args(argv[1:])
+        return _cmd_init(args)
+
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    if not args.repo and not args.text:
+        parser.print_usage(sys.stderr)
+        return EXIT_USAGE
+
+    if args.text:
+        if args.repo:
+            parser.error("--text cannot be combined with repo")
+        text = Path(args.text).read_text(encoding="utf-8", errors="replace")
+        result = detect_policy(text)
+        payload = {
+            "source": args.text,
+            "files": [args.text],
+            "verdict": result.verdict.value,
+            "evidence": result.evidence,
+            "autonomous_safe": result.autonomous_safe,
+            "confidence": result.confidence,
+            "score": result.score,
+        }
+        exit_code = {
+            Verdict.UNKNOWN: EXIT_UNKNOWN,
+        }.get(result.verdict, EXIT_OK if result.autonomous_safe else EXIT_UNSAFE)
+        if args.as_sarif:
+            from .sarif import to_sarif
+            print(json.dumps(to_sarif(payload), indent=2))
+        else:
+            print(json.dumps(payload, indent=2) if args.as_json else _render(payload))
+        return exit_code
+
+    # Batch mode: classify every repo, aggregate the exit code, and emit either
+    # a JSON array or a per-repo human-readable block.
+    try:
+        if args.no_cache:
+            from .detector import clear_policy_cache
+            clear_policy_cache()
+        results = [classify_repo(repo, use_cache=not args.no_cache) for repo in args.repo]
+    except ValueError as e:
+        print(f"ERROR: {e}", file=sys.stderr)
+        return EXIT_USAGE
+
+    def _exit_code(r: dict) -> int:
+        if r["verdict"] == Verdict.UNKNOWN.value:
+            return EXIT_UNKNOWN
+        return EXIT_OK if r["autonomous_safe"] else EXIT_UNSAFE
+
+    worst = max(_exit_code(r) for r in results)
+
+    if args.as_sarif:
+        from .sarif import to_sarif
+        print(json.dumps(to_sarif(results), indent=2))
+    elif args.as_json:
+        print(json.dumps(results if len(results) > 1 else results[0], indent=2))
+    else:
+        for i, r in enumerate(results):
+            if i:
+                print()
+            print(_render(r))
+    return worst
+
+
+def _render(payload: dict) -> str:
+    icon = {
+        Verdict.HUMAN_ONLY.value: "[BLOCKED] human-only policy",
+        Verdict.RESTRICTIVE.value: "[CAUTION] restrictive policy",
+        Verdict.DISCLOSE_OK.value: "[OK] allowed with disclosure",
+        Verdict.PERMISSIVE.value: "[OK] permissive",
+        Verdict.UNKNOWN.value: "[UNKNOWN] no explicit AI policy found",
+    }[payload["verdict"]]
+    lines = [f"aipr: {payload.get('repo') or payload.get('source')}", icon]
+    if "files" in payload and payload["files"]:
+        lines.append(f"sources: {', '.join(payload['files'])}")
+    if payload.get("confidence") is not None:
+        lines.append(f"confidence: {payload['confidence']}  score: {payload.get('score')}")
+    if payload.get("autonomous_safe"):
+        lines.append("autonomous contribution: SAFE (still follow disclosure rules)")
+    elif payload["verdict"] != Verdict.UNKNOWN.value:
+        lines.append("autonomous contribution: NOT SAFE - require human co-authorship")
+    for ev in payload.get("evidence", [])[:3]:
+        lines.append(f"  {ev}")
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

aipr/detector.py

@@ -0,0 +1,169 @@
+"""Detect a repository's AI contribution policy from its governance text.
+
+Scoring model: weighted phrase matching over the files most likely to carry
+governance (CONTRIBUTING.md, AI_POLICY.md, README.md, AGENTS.md, CLAUDE.md).
+Restrictive signals outweigh permissive ones; silence yields UNKNOWN.
+"""
+
+from __future__ import annotations
+
+import re as _re
+import regex
+from dataclasses import dataclass, field
+from enum import Enum
+
+from aipr.cache import TTLCache
+
+
+class Verdict(Enum):
+    HUMAN_ONLY = "human_only"      # AI must not be the main author / human-written only
+    RESTRICTIVE = "restrictive"    # heavy limits: mandatory process, bans on parts
+    DISCLOSE_OK = "disclose_ok"    # allowed with disclosure / trailer
+    PERMISSIVE = "permissive"      # explicitly welcomes AI contributions
+    UNKNOWN = "unknown"            # no policy text found
+
+
+# Maximum input length before truncation (prevents ReDoS on adversarial input)
+MAX_INPUT_LENGTH = 1_000_000  # 1 MB
+
+# Timeout in milliseconds for regex operations (prevents catastrophic backtracking)
+REGEX_TIMEOUT_MS = 500  # 0.5 seconds
+
+# Global TTL cache instance (replaces lru_cache)
+_policy_cache = TTLCache()
+
+# (compiled pattern, weight). Positive = restrictive signal, negative = permissive.
+# Note: patterns use regex module (not re) for timeout support.
+RULES: list[tuple[regex.Pattern[str], float]] = [
+    # --- human-only / ban level (strongest) ---
+    (regex.compile(r"must\s+be\s+fully\s+human[- ]written", regex.I), 5.0),
+    (regex.compile(r"ai\s+should\s+never\s+be\s+the\s+main\s+author", regex.I), 5.0),
+    (regex.compile(r"human[\s-]+authored\s+only", regex.I), 5.0),
+    (regex.compile(r"(?:\bwe\s+)?(?:do\s+not|don't)\s+accept\s+(?:any\s+)?ai", regex.I), 4.5),
+    (regex.compile(r"(?:will\s+not\s+be\s+accepted|not\s+accepted\s+here)[^.]*\bai\b", regex.I), 4.5),
+    (regex.compile(r"no\s+ai[- ]generated\s+(?:code|content|contributions)", regex.I), 4.5),
+    (regex.compile(r"ai\s+contributions?\s+are\s+(?:strictly\s+)?(?:forbidden|prohibited|banned)", regex.I), 4.5),
+    (regex.compile(r"(?:full(?:y|)\s+)?ai[- ]generated\s+contributions?[^.]{0,80}are\s+not\s+(?:allowed|permitted)", regex.I), 4.5),
+    (regex.compile(r"fully\s+generated\s+code\s+is\s+not\s+allowed", regex.I), 4.5),
+    (regex.compile(r"agents?\s+are\s+strictly\s+forbidden", regex.I), 5.0),
+    (regex.compile(r"bad\s+ai\s+\w+\s+will\s+be\s+(?:denounced|blocked)", regex.I), 3.0),
+    (regex.compile(r"human[\s-]+in[\s-]+the[\s-]+loop\s+is\s+(?:required|mandatory)", regex.I), 2.0),
+    (regex.compile(r"(?:\b)?ai[- ]automation\s+without\s+human\s+review\s+is\s+not\s+(?:currently\s+)?permitted", regex.I), 3.0),
+    (regex.compile(r"write\s+pr\s+descriptions?\s+yourself", regex.I), 1.5),
+    # --- restrictive ---
+    (regex.compile(r"all\s+ai\s+usage[^.]{0,60}must\s+be\s+disclosed", regex.I), 2.5),
+    (regex.compile(r"mandatory\s+disclosure", regex.I), 2.0),
+    (regex.compile(r"must\s+state\s+the\s+tool\s+you\s+used", regex.I), 2.0),
+    (regex.compile(r"may\s+not\s+use\s+ai\s+for\s+['\"]?good\s+first\s+issues?", regex.I), 2.0),
+    (regex.compile(r"extractive\s+contribution", regex.I), 1.5),
+    (regex.compile(r"assisted[- ]by:\s*ai\s+(?:trailer\s+)?is\s+(?:required|mandatory)", regex.I), 1.5),
+    # --- understanding / human-in-the-loop mandate (e.g. alibaba/open-code-review AGENTS.md) ---
+    (regex.compile(r"(?:you\s+must|contributors?\s+must)\s+(?:disclose|report|declare)[^.]{0,80}\b(?:ai|artificial\s+intelligence|llm|copilot|claude|gpt|coding\s+agent)\b", regex.I), 2.5),
+    (regex.compile(r"(?:review|understand)\s+(?:every\s+line|all\s+(?:code|content|text))\s+(?:written|generated)\s+by\s+ai", regex.I), 2.0),
+    (regex.compile(r"(?:must\s+not|shall\s+not)\s+attribute\s+commits?\s+(?:to\s+(?:ai|llm)|through\s+(?:assisted[- ]by|co[- ]developed))", regex.I), 1.5),
+    # --- local AI tool policy rules (.cursorrules, copilot-instructions, etc.) ---
+    (regex.compile(r"never\s+(?:generate|write|create)(?:\s+or\s+(?:generate|write|create))?\s+(?:any\s+)?(?:code|content)\s+(?:for|in|without)\b", regex.I), 2.5),
+    (regex.compile(r"all\s+(?:(?:code|ai)\s+)?(?:changes|edits|modifications)\s+must\s+be\s+(?:human[- ]?)?reviewed\b", regex.I), 2.0),
+    (regex.compile(r"(?:do\s+not|don't|never|may\s+not)\s+use\s+(?:ai|copilot|cursor|windsurf|aider|llms?)\s+(?:for|to)\b", regex.I), 2.5),
+    # --- disclose-ok ---
+    (regex.compile(r"assisted[- ]by:\s*ai", regex.I), -1.5),
+    (regex.compile(r"disclos\w+[^.]{0,40}\b(?:is|are)\s+(?:required|expected)\b", regex.I), -1.0),
+    (regex.compile(r"ai[- ]assisted\s+contributions?\s+are\s+(?:welcome|allowed|accepted)", regex.I), -3.0),
+    (regex.compile(r"ai\s+(?:usage|assistance)\s+is\s+(?:welcome|allowed|fine|ok)\b", regex.I), -3.0),
+    # --- permissive ---
+    (regex.compile(r"(?:\bwe\s+)?(?:warmly\s+)?welcome\s+ai[- ](?:assisted|generated)", regex.I), -3.5),
+    (regex.compile(r"feel\s+free\s+to\s+use\s+(?:claude|copilot|chatgpt|llms?|ai\s+tools)", regex.I), -3.0),
+    (regex.compile(r"agents?\s+are\s+welcome", regex.I), -3.0),
+    # --- permissive (agent-guide patterns seen in the wild: openhuman etc.) ---
+    (regex.compile(r"let\s+an\s+ai\s+coding\s+agent\s+guide\s+you", regex.I), -3.0),
+    (regex.compile(r"if\s+you\s+use\s+(?:claude\s+code|cursor|ampcode|codex).*?coding\s+agent", regex.I | regex.S), -3.0),
+    (regex.compile(r"paste\s+this\s+prompt.*?(?:agents\.md|claude\.md)", regex.I | regex.S), -2.5),
+]
+
+RESTRICTIVE_THRESHOLD = 2.0
+DISCLOSE_THRESHOLD = -0.5
+
+
+@dataclass
+class Policy:
+    verdict: Verdict
+    confidence: float
+    evidence: list[str] = field(default_factory=list)
+    score: float = 0.0
+
+    @property
+    def autonomous_safe(self) -> bool:
+        """True when an autonomous agent may contribute without human co-authorship."""
+        return self.verdict in (Verdict.DISCLOSE_OK, Verdict.PERMISSIVE)
+
+
+def _score_text(text: str) -> Policy:
+    """Score a single blob of governance text (pure computation, no caching)."""
+    score = 0.0
+    evidence: list[str] = []
+    matched_strong = False
+
+    for pattern, weight in RULES:
+        try:
+            match = pattern.search(text, timeout=REGEX_TIMEOUT_MS)
+        except TimeoutError:
+            continue
+        if not match:
+            continue
+        score += weight
+        start = max(0, match.start() - 30)
+        end = min(len(text), match.end() + 50)
+        snippet = _re.sub(r"\s+", " ", text[start:end]).strip()
+        evidence.append(f"[{weight:+.1f}] ...{snippet}...")
+        if abs(weight) >= 3.0:
+            matched_strong = True
+
+    if not evidence or score == 0.0:
+        return Policy(Verdict.UNKNOWN, 0.0, evidence, score)
+
+    if score >= 4.0:
+        verdict = Verdict.HUMAN_ONLY
+    elif score >= RESTRICTIVE_THRESHOLD:
+        verdict = Verdict.RESTRICTIVE
+    elif score <= DISCLOSE_THRESHOLD:
+        verdict = (
+            Verdict.PERMISSIVE if score <= -3.0 else Verdict.DISCLOSE_OK
+        )
+    else:
+        verdict = Verdict.RESTRICTIVE if score > 0 else Verdict.DISCLOSE_OK
+
+    confidence = min(1.0, abs(score) / 5.0)
+    if matched_strong:
+        confidence = max(confidence, 0.7)
+    return Policy(verdict, round(confidence, 2), evidence, round(score, 2))
+
+
+def clear_policy_cache() -> None:
+    """Clear the in-memory cache for policy scoring."""
+    _policy_cache.clear()
+
+
+def detect_policy(text: str) -> Policy:
+    """Score one blob of governance text and classify the stance.
+    
+    Uses a thread-safe TTL cache with deep copy on read to prevent
+    mutation of shared state across concurrent callers.
+    
+    Input text is truncated to MAX_INPUT_LENGTH to prevent ReDoS on
+    adversarial input.
+    """
+    if not text or not text.strip():
+        return Policy(Verdict.UNKNOWN, 0.0)
+    # Truncate to prevent catastrophic backtracking on adversarial input
+    if len(text) > MAX_INPUT_LENGTH:
+        text = text[:MAX_INPUT_LENGTH]
+    
+    # Check cache first (returns deep copy on hit)
+    cached = _policy_cache.get(text)
+    if cached is not None:
+        return cached
+    
+    # Compute and cache
+    result = _score_text(text)
+    _policy_cache.put(text, result)
+    return result

aipr/http.py

@@ -0,0 +1,84 @@
+"""HTTP helpers for aipr: retry + rate-limit awareness for GitHub API calls."""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+import urllib.error
+import urllib.request
+
+logger = logging.getLogger(__name__)
+
+
+class RateLimitError(Exception):
+    """Raised when the GitHub API returns HTTP 403 (rate limit)."""
+
+    def __init__(self, message: str = "GitHub API rate limit exceeded"):
+        super().__init__(message)
+
+
+def fetch_with_retry(
+    url: str,
+    max_retries: int = 3,
+    base_delay: float = 1.0,
+    timeout: int = 15,
+) -> str | None:
+    """Fetch raw content via the GitHub API with retry + rate-limit handling.
+
+    Transient errors (502/503/504/408/429) are retried up to *max_retries* times
+    with exponential backoff. HTTP 403 (rate limit) raises :class:`RateLimitError`.
+
+    Returns the decoded text on success, or ``None`` if the request fails
+    for any non-rate-limit reason (e.g. 404 Not Found).
+    """
+    token = os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN")
+
+    for attempt in range(max_retries + 1):
+        from . import __version__
+        req = urllib.request.Request(
+            url, headers={
+                "Accept": "application/vnd.github.raw+json",
+                "User-Agent": f"aipr/{__version__}",
+            }
+        )
+        if token:
+            req.add_header("Authorization", f"Bearer {token}")
+
+        try:
+            with urllib.request.urlopen(req, timeout=timeout) as resp:
+                return resp.read().decode("utf-8", errors="replace")
+        except urllib.error.HTTPError as e:
+            if e.code == 403:
+                raise RateLimitError(
+                    f"GitHub API rate limit exceeded (HTTP 403) for {url}"
+                )
+            if e.code in (502, 503, 504, 408, 429) and attempt < max_retries:
+                delay = base_delay * (2**attempt)
+                logger.warning(
+                    "Transient HTTP %s on attempt %s/%s, retrying in %.1fs",
+                    e.code,
+                    attempt + 1,
+                    max_retries + 1,
+                    delay,
+                )
+                time.sleep(delay)
+                continue
+            logger.warning("HTTP error %s fetching %s", e.code, url)
+            return None
+        except Exception as e:
+            if attempt < max_retries:
+                delay = base_delay * (2**attempt)
+                logger.warning(
+                    "Fetch error on attempt %s/%s, retrying in %.1fs: %s",
+                    attempt + 1,
+                    max_retries + 1,
+                    delay,
+                    e,
+                )
+                time.sleep(delay)
+                continue
+            logger.warning("GitHub fetch failed for %s: %s", url, e)
+            return None
+
+    return None

aipr/sarif.py

@@ -0,0 +1,186 @@
+"""SARIF output generation for aipr.
+
+Converts aipr classification results to SARIF 2.1.0 for ingestion by GitHub Code Scanning,
+GitLab Vulnerability Reports, and any other consumer that speaks SARIF.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+SARIF_SCHEMA = "https://json.schemastore.org/sarif-2.1.0.json"
+
+# Verdict metadata: (rule_id, rule_name, rule_description)
+# Maps aipr verdict strings to SARIF rule metadata.
+VERDICT_RULES = {
+    "human_only": (
+        "ai-policy-human-only",
+        "AI Contributions Prohibited",
+        "Repository policy forbids AI-generated contributions without human co-authorship.",
+    ),
+    "restrictive": (
+        "ai-policy-restrictive",
+        "AI Contributions Restricted",
+        "Repository policy imposes heavy limits on AI contributions (mandatory process, partial bans).",
+    ),
+    "disclose_ok": (
+        "ai-policy-disclose-required",
+        "AI Disclosure Required",
+        "Repository allows AI-assisted contributions but requires disclosure in PR/commit.",
+    ),
+    "permissive": (
+        "ai-policy-permissive",
+        "AI Contributions Allowed",
+        "Repository explicitly welcomes AI-assisted contributions.",
+    ),
+    "unknown": (
+        "ai-policy-unknown",
+        "No AI Policy Found",
+        "Repository has no explicit AI contribution policy — contribution risk is unknown.",
+    ),
+}
+
+# Map verdict to SARIF level.
+# human_only / restrictive = error (blocks contribution)
+# unknown = warning (needs manual review)
+# permissive / disclose_ok = note (safe to proceed)
+VERDICT_LEVEL = {
+    "human_only": "error",
+    "restrictive": "error",
+    "disclose_ok": "note",
+    "permissive": "note",
+    "unknown": "warning",
+}
+
+
+def _make_rule(rule_id: str, name: str, description: str) -> dict:
+    return {
+        "id": rule_id,
+        "name": name,
+        "shortDescription": {"text": description},
+        "fullDescription": {"text": description},
+        "helpUri": "https://github.com/yunaremaia/aipr",
+    }
+
+
+def _make_result(
+    rule_id: str,
+    message: str,
+    *,
+    level: str = "warning",
+    repo: str | None = None,
+    source: str | None = None,
+) -> dict:
+    result: dict[str, Any] = {
+        "ruleId": rule_id,
+        "message": {"text": message},
+        "level": level,
+    }
+    # repo for remote, source for local text mode
+    qualified_name = repo or source or "unknown"
+    result["locations"] = [
+        {
+            "logicalLocations": [
+                {
+                    "fullyQualifiedName": qualified_name,
+                    "kind": "repository" if repo else "file",
+                }
+            ]
+        }
+    ]
+    return result
+
+
+def to_sarif(results: list[dict] | dict, version: str | None = None) -> dict:
+    """Convert aipr classification results to SARIF 2.1.0 document.
+
+    Args:
+        results: list of classification dicts from classify_repo() or single-mode payload.
+        version: aipr version string (for the tool metadata).
+
+    Returns:
+        SARIF 2.1.0 document as a dict.
+    """
+    if version is None:
+        try:
+            from . import __version__ as version
+        except ImportError:
+            version = "0.2.2"
+
+    # Normalize to list
+    if isinstance(results, dict):
+        results = [results]
+
+    rules: list[dict] = []
+    sarif_results: list[dict] = []
+    rule_set: set[str] = set()
+
+    for r in results:
+        verdict = r.get("verdict", "unknown")
+        repo = r.get("repo")
+        source = r.get("source")
+        meta = VERDICT_RULES.get(verdict)
+        if not meta:
+            continue
+        rule_id, rule_name, rule_desc = meta
+
+        if rule_id not in rule_set:
+            rules.append(_make_rule(rule_id, rule_name, rule_desc))
+            rule_set.add(rule_id)
+
+        level = VERDICT_LEVEL.get(verdict, "warning")
+
+        # Build message
+        evidence = r.get("evidence", [])
+        evidence_text = ""
+        if evidence:
+            evidence_text = " | Evidence: " + "; ".join(evidence[:3])
+        files = r.get("files", [])
+        source_text = f" Sources: {', '.join(files)}" if files else ""
+
+        target = repo or source or "repository"
+        if verdict == "human_only":
+            message = (
+                f"Autonomous AI contributions NOT SAFE for {target}. "
+                f"Policy requires human authorship.{evidence_text}{source_text}"
+            )
+        elif verdict == "restrictive":
+            message = (
+                f"Autonomous AI contributions NOT SAFE for {target}. "
+                f"Policy has restrictive AI requirements.{evidence_text}{source_text}"
+            )
+        elif verdict == "disclose_ok":
+            message = (
+                f"AI contributions allowed with disclosure for {target}. "
+                f"Remember to add 'Assisted-by: AI' trailer.{evidence_text}{source_text}"
+            )
+        elif verdict == "permissive":
+            message = (
+                f"AI contributions welcome for {target}.{evidence_text}{source_text}"
+            )
+        else:  # unknown
+            message = (
+                f"No explicit AI policy found for {target}. "
+                f"Manual review recommended before contributing.{source_text}"
+            )
+
+        sarif_results.append(
+            _make_result(rule_id, message, level=level, repo=repo, source=source)
+        )
+
+    return {
+        "$schema": SARIF_SCHEMA,
+        "version": "2.1.0",
+        "runs": [
+            {
+                "tool": {
+                    "driver": {
+                        "name": "aipr",
+                        "version": version,
+                        "informationUri": "https://github.com/yunaremaia/aipr",
+                        "rules": rules,
+                    }
+                },
+                "results": sarif_results,
+            }
+        ],
+    }

aipr_py-0.2.4.dist-info/METADATA

@@ -0,0 +1,239 @@
+Metadata-Version: 2.4
+Name: aipr-py
+Version: 0.2.4
+Summary: Read a repository's AI contribution policy before you (or your agent) contribute.
+Author-email: Yunare Maia <yunare@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yunaremaia/aipr
+Keywords: ai-policy,open-source,contributing,cli,agents
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Version Control :: Git
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: regex>=2024.1.0
+Dynamic: license-file
+
+# aipr
+
+[![CI](https://github.com/yunaremaia/aipr/actions/workflows/ci.yml/badge.svg)](https://github.com/yunaremaia/aipr/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/yunaremaia/aipr/blob/main/LICENSE)
+
+**AI Policy Read** - read an open-source repository's AI contribution policy
+before you (or your agent) contribute.
+
+`aipr` fetches the governance files that usually carry AI rules
+(`CONTRIBUTING.md`, `AI_POLICY.md`, `AGENTS.md`, `CLAUDE.md`, ...), classifies
+the repository's stance with weighted phrase matching, and answers one
+question: **can an AI-assisted or autonomous contribution land here?**
+
+```
+$ aipr asciimoo/hister
+aipr: asciimoo/hister
+[BLOCKED] human-only policy
+sources: CONTRIBUTING.md, README.md
+confidence: 1.0  score: 19.0
+autonomous contribution: NOT SAFE - require human co-authorship
+  [+5.0] ...Issues and PR descriptions must be fully human-written...
+  [+5.0] ...AI should never be the main author of the PR...
+
+$ aipr apache/maka
+aipr: apache/maka
+[UNKNOWN] no explicit AI policy found
+exit=2
+```
+
+## Why
+
+More repositories are publishing explicit AI policies - from "we welcome
+AI-assisted work" to "agents are strictly forbidden". Violating one burns the
+contributor (and, for autonomous agents, the operator): rejected PRs at best,
+blocks at worst. `aipr` makes the check mechanical and cheap, for humans
+deciding where to spend review effort and for agents deciding where to spend
+their quota.
+
+## Install
+
+```bash
+# 1. From PyPI
+pip install aipr-py
+
+# 2. Standalone from GitHub
+pip install git+https://github.com/yunaremaia/aipr.git
+# requires Python 3.10+; GH_TOKEN recommended (anonymous API calls rate-limit fast)
+export GH_TOKEN=ghp_xxx   # classic token with public repo read access
+
+# 3. As a GitHub CLI extension (recommended)
+gh extension install yunaremaia/aipr
+```
+
+The `gh extension install` method is the easiest — after install, `gh aipr OWNER/REPO` works immediately.
+
+No dependencies beyond the standard library. `pytest` only to develop.
+
+## Usage
+
+### Standalone
+
+```bash
+aipr OWNER/REPO            # classify a GitHub repository
+aipr --text FILE           # classify a local governance file
+aipr --json OWNER/REPO     # machine-readable output
+aipr --sarif OWNER/REPO    # SARIF 2.1.0 output for GitHub Code Scanning
+```
+
+### As a GitHub CLI extension
+
+After `gh extension install yunaremaia/aipr`, use `gh aipr` identically:
+
+```bash
+gh aipr OWNER/REPO
+gh aipr --json OWNER/REPO
+gh aipr --sarif OWNER/REPO
+gh aipr --text FILE
+```
+
+Exit codes are preserved (0/1/2) for CI conditionals.
+
+### `init` — scaffold AI policy files
+
+Generate `AI_POLICY.md` and `AI_TOOL_POLICY.md` in your repo:
+
+```bash
+aipr init [--dir .] [--type disclose|permissive|human_only] [--org ORG]
+```
+
+Presets:
+- `permissive` — explicitly welcomes AI-assisted contributions (aipr-safe)
+- `disclose_ok` (default) — allowed with `Assisted-by: AI` disclosure trailer
+- `human_only` — AI must not be the main author (NOT autonomous-safe)
+
+### Verdicts
+
+| Verdict | Meaning | Autonomous-safe? |
+|---|---|---|
+| `human_only` | AI must not be the main author / human-written only / bans agents | no |
+| `restrictive` | heavy process: mandatory disclosure + human-in-the-loop requirements | no |
+| `disclose_ok` | allowed with a disclosure trailer (`Assisted-by: AI`) | yes* |
+| `permissive` | explicitly welcomes AI-assisted contributions | yes |
+| `unknown` | no explicit policy found | ask first |
+
+\* still follow the disclosure rules - "safe" means *no human co-authorship
+required by policy*, not *no obligations*.
+
+### Exit codes (for CI and agents)
+
+| Code | Meaning |
+|---|---|
+| 0 | all inspected repos are autonomous-safe |
+| 1 | at least one repo is restricted or human-only |
+| 2 | at least one repo is unknown / no policy found (ranks worse than 1) |
+| 64 | usage error |
+
+Batch mode: `aipr owner/repo1 owner/repo2 ...` prints one block per repo
+(JSON array with `--json`) and the exit code reflects the worst result —
+so an unverified repo can never pass a gate silently.
+
+Policy fetches are cached on disk for 24h (`~/.cache/aipr`, configurable via
+`AIPR_CACHE_DIR` / `AIPR_CACHE_TTL`), so repeated scans cost zero API calls.
+Use `--no-cache` to force a fresh fetch.
+
+## How classification works
+
+Weighted regex matching over concatenated governance text. Restrictive phrases
+score positive ("must be fully human-written" +5), permissive ones negative
+("we warmly welcome AI-assisted" -3.5). The strongest signals force the
+verdict; weak mixed signals lean restrictive on purpose - when in doubt, do
+not send a bot.
+
+Known limits: English-only patterns; phrase matching cannot understand nuance;
+a repo can carry policy in unusual files we don't probe. Treat UNKNOWN as
+"read it yourself".
+
+## CI/CD Integration
+
+### Block PRs Violating AI Policy
+
+Drop `.github/workflows/aipr.yml` into your repository to automatically block pull requests targeting repos with human-only or restrictive AI policies:
+
+```yaml
+# .github/workflows/aipr.yml – block PRs against repos with human-only AI policies
+name: AI Policy Check
+on:
+  pull_request:
+    branches: [main, master]
+
+jobs:
+  aipr:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+      - run: pip install git+https://github.com/yunaremaia/aipr.git
+      - name: Check AI policy
+        run: |
+          aipr "$GITHUB_REPOSITORY" --json || true
+          # Exit 1 = human_only/restrictive (block)
+          # Exit 2 = unknown (warn, not block)
+          aipr "$GITHUB_REPOSITORY" --json | jq -e '.verdict == "human_only" or .verdict == "restrictive"' && exit 1 || exit 0
+```
+
+### GitHub Code Scanning (SARIF)
+
+Use `--sarif` to output SARIF 2.1.0 (Static Analysis Results Interchange Format)
+and upload to GitHub Code Scanning. This surfaces AI policy compliance as
+alerts in the GitHub Security tab.
+
+```bash
+# Generate SARIF output
+aipr --sarif OWNER/REPO > aipr-results.sarif
+# Upload to GitHub Code Scanning via GitHub Actions:
+#   github/codeql-action/upload-sarif with sarif_file: aipr-results.sarif
+```
+
+Verdict mapping to SARIF levels:
+- `human_only` / `restrictive` → `error` (blocks contribution)
+- `unknown` → `warning` (needs manual review)
+- `permissive` / `disclose_ok` → `note` (safe to proceed)
+
+Example GitHub Actions workflow snippet:
+
+```yaml
+name: AI Policy Check (SARIF)
+on:
+  pull_request:
+    branches: [main]
+
+jobs:
+  aipr-check:
+    runs-on: ubuntu-latest
+    permissions:
+      security-events: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+      - run: pip install git+https://github.com/yunaremaia/aipr.git
+      - run: aipr --sarif ${{ github.event.pull_request.head.repo.full_name }} > aipr-results.sarif
+      - uses: github/codeql-action/upload-sarif@v3
+        with:
+          sarif_file: aipr-results.sarif
+```
+
+## Status
+
+Early beta - battle-tested against a handful of real policies (hister,
+modular, polars, MDAnalysis, maka). Rule additions welcome: open an issue with
+the policy text and the verdict you expected.
+
+## License
+
+MIT

aipr_py-0.2.4.dist-info/RECORD

@@ -0,0 +1,13 @@
+aipr/__init__.py,sha256=Wc0wOm-z7mHTzyWVPxf_OmgVyfxlywkefPQhfHOugSw,92
+aipr/cache.py,sha256=YB9etlQyNgPB2P0J5hjDMfBTOqWf3f3WF2lKsvmS2BQ,2557
+aipr/cli.py,sha256=OOYhgz14gACTcjpUhBbe3aAi6BqcN-nmjtB0ogz8nf0,15050
+aipr/detector.py,sha256=I2_PEftqLx5pJ-EPP0JG6dzd8_IF3Ule9emHBPBY7jc,8193
+aipr/http.py,sha256=igNk2gOVVVWbhse8-J14LmtwQLuNuA_5uFLR9Sq3t7Y,2820
+aipr/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+aipr/sarif.py,sha256=6VwjDFIxONppmgJjVHjGUp5cKvuYQLA7Stb4EA1ViAY,5849
+aipr_py-0.2.4.dist-info/licenses/LICENSE,sha256=jaJ4N5zOiHxuIAaPgohynRXOjhcZsCwBBU6lpDNG-IE,1068
+aipr_py-0.2.4.dist-info/METADATA,sha256=3FYKMmzKeBeB7VoNyaOje3ftpFbqk5OuXOfWRORHrYE,8077
+aipr_py-0.2.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+aipr_py-0.2.4.dist-info/entry_points.txt,sha256=39kVAlqlSgRaNNmA3jMfOj3TTaViXnQiBcI2Q_VsXdM,39
+aipr_py-0.2.4.dist-info/top_level.txt,sha256=3iYRlJDj8wYDnTXX2xK3SwMUaWDxLv2UXY_9CDHd6hY,5
+aipr_py-0.2.4.dist-info/RECORD,,

aipr_py-0.2.4.dist-info/WHEEL

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

aipr_py-0.2.4.dist-info/entry_points.txt

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

aipr_py-0.2.4.dist-info/licenses/LICENSE

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

aipr_py-0.2.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+aipr