argus-header 0.5.0__py3-none-any.whl

argus_header/__init__.py

@@ -0,0 +1,3 @@
+__version__ = "0.5.0"
+
+APP_NAME = "Argus Header"

argus_header/analyzer.py

@@ -0,0 +1,99 @@
+def analyze_headers(headers_data):
+    """
+    Analyzes the raw headers and returns a list of findings.
+    """
+    if not headers_data.get("success"):
+        return []
+
+    headers = {k.lower(): v for k, v in headers_data["headers"].items()}
+    findings = []
+
+    # --- 1. Security Headers Analysis ---
+    
+    # Content-Security-Policy
+    if "content-security-policy" not in headers:
+        findings.append({
+            "category": "Security",
+            "issue": "Missing Content-Security-Policy",
+            "severity": "HIGH",
+            "risk": "XSS (Cross-Site Scripting) attacks are easier to exploit.",
+            "fix": "Add a 'Content-Security-Policy' header defining allowed content sources."
+        })
+
+    # Strict-Transport-Security (HSTS)
+    if "strict-transport-security" not in headers:
+        findings.append({
+            "category": "Security",
+            "issue": "Missing Strict-Transport-Security",
+            "severity": "HIGH",
+            "risk": "Susceptible to Man-in-the-Middle (MITM) protocol downgrade attacks.",
+            "fix": "Add 'Strict-Transport-Security: max-age=63072000; includeSubDomains'."
+        })
+
+    # X-Frame-Options
+    if "x-frame-options" not in headers and "content-security-policy" not in headers:
+        findings.append({
+            "category": "Security",
+            "issue": "Missing X-Frame-Options",
+            "severity": "HIGH",
+            "risk": "Vulnerable to Clickjacking attacks.",
+            "fix": "Add 'X-Frame-Options: DENY' or 'SAMEORIGIN'."
+        })
+
+    # X-Content-Type-Options
+    if "x-content-type-options" not in headers:
+        findings.append({
+            "category": "Security",
+            "issue": "Missing X-Content-Type-Options",
+            "severity": "MEDIUM",
+            "risk": "Browsers may MIME-sniff the response body, leading to XSS.",
+            "fix": "Add 'X-Content-Type-Options: nosniff'."
+        })
+
+    # --- 2. Information Leakage ---
+
+    # Server Header
+    if "server" in headers:
+        findings.append({
+            "category": "Leakage",
+            "issue": f"Server Header Leaked: {headers['server']}",
+            "severity": "LOW",
+            "risk": "Reveals server technology, helping attackers verify CVEs.",
+            "fix": "Configure server to suppress or obfuscate the 'Server' header."
+        })
+
+    # X-Powered-By
+    if "x-powered-by" in headers:
+        findings.append({
+            "category": "Leakage",
+            "issue": f"X-Powered-By Leaked: {headers['x-powered-by']}",
+            "severity": "MEDIUM",
+            "risk": "Reveals specific framework/version info.",
+            "fix": "Remove the 'X-Powered-By' header in server config."
+        })
+
+    # --- 3. CORS Misconfiguration ---
+    
+    if "access-control-allow-origin" in headers:
+        if headers["access-control-allow-origin"] == "*":
+            findings.append({
+                "category": "CORS",
+                "issue": "CORS Access-Control-Allow-Origin is '*'",
+                "severity": "MEDIUM",
+                "risk": "Allows any domain to access resources (dangerous if auth is used).",
+                "fix": "Restrict to specific trusted domains."
+            })
+
+    # --- 4. Performance ---
+    
+    # Cache-Control
+    if "cache-control" not in headers:
+        findings.append({
+            "category": "Performance",
+            "issue": "Missing Cache-Control Header",
+            "severity": "LOW",
+            "risk": "Browser may not cache resources efficiently, slowing load times.",
+            "fix": "Add 'Cache-Control' header (e.g., max-age=3600)."
+        })
+
+    return findings

argus_header/cli.py

@@ -0,0 +1,138 @@
+import argparse
+import sys
+from concurrent.futures import ThreadPoolExecutor
+
+from rich.console import Console
+
+from argus_header import __version__
+from .requester import fetch_headers
+from .analyzer import analyze_headers
+from .reporter import print_report, save_json
+
+console = Console()
+
+BANNER = r"""
+   ___                             
+  / _ | _______ _____ _____ _____  
+ / __ |/ __/ _ `/ // (_-</(_-<(_-<  
+/_/ |_/_/  \_, /\_,_/___/___/___/  
+            /_/                    
+
+ Argus Header
+ HTTP Header Security Analyzer
+"""
+
+def print_banner():
+    console.print(f"[bold cyan]{BANNER}[/bold cyan]")
+    console.print(f"[bold]Version:[/bold] {__version__}\n")
+
+def scan_target(url: str, args):
+    response_data = fetch_headers(
+        url,
+        method=args.method,
+        follow_redirects=not args.no_redirect,
+        timeout=args.timeout,
+    )
+
+    findings = analyze_headers(response_data)
+    print_report(response_data, findings)
+
+    if args.json and len(args.url) == 1:
+        save_json(response_data, findings, args.json)
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="argus-header",
+        description="Argus Header - HTTP Header Security Analyzer",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  argus-header https://example.com
+  argus-header https://example.com --method HEAD
+  argus-header https://example.com --json report.json
+  argus-header https://google.com https://github.com --parallel
+  argus-header --version
+""",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--version",
+        action="version",
+        version=f"Argus Header {__version__}",
+    )
+
+    parser.add_argument(
+        "url",
+        nargs="+",
+        help="One or more target URLs to analyze.",
+    )
+
+    parser.add_argument(
+        "--method",
+        choices=["GET", "HEAD"],
+        default="GET",
+        help="HTTP request method (default: GET).",
+    )
+
+    parser.add_argument(
+        "--no-redirect",
+        action="store_true",
+        help="Disable HTTP redirect following.",
+    )
+
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=10,
+        help="Request timeout in seconds (default: 10).",
+    )
+
+    parser.add_argument(
+        "--json",
+        metavar="FILE",
+        help="Save the report to a JSON file.",
+    )
+
+    parser.add_argument(
+        "--parallel",
+        action="store_true",
+        help="Scan multiple URLs concurrently.",
+    )
+
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Reserved for future verbose output.",
+    )
+
+    args = parser.parse_args()
+
+    print_banner()
+
+    try:
+        if args.parallel and len(args.url) > 1:
+            console.print(
+                f"[bold green][*][/bold green] Scanning {len(args.url)} targets in parallel...\n"
+            )
+
+            with ThreadPoolExecutor(max_workers=5) as executor:
+                list(executor.map(lambda u: scan_target(u, args), args.url))
+        else:
+            for url in args.url:
+                scan_target(url, args)
+                console.rule()
+
+        sys.exit(0)
+
+    except KeyboardInterrupt:
+        console.print("\n[bold yellow]Scan cancelled by user.[/bold yellow]")
+        sys.exit(130)
+
+    except Exception as exc:
+        console.print(f"\n[bold red]Unexpected error:[/bold red] {exc}")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

argus_header/reporter.py

@@ -0,0 +1,70 @@
+import json
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+def print_report(response_data, findings):
+    """Prints a pretty CLI report."""
+    
+    # 1. Status Section
+    if not response_data["success"]:
+        console.print(f"[bold red]Error connecting to {response_data['url']}: {response_data.get('error')}[/bold red]")
+        return
+
+    console.print(Panel(
+        f"[bold green]Target:[/bold green] {response_data['url']}\n"
+        f"[bold blue]Status:[/bold blue] {response_data['status_code']}\n"
+        f"[bold]Headers Found:[/bold] {len(response_data['headers'])}",
+        title="Scan Summary",
+        expand=False
+    ))
+
+    # 2. Findings Table
+    if findings:
+        table = Table(title="Analysis Findings", show_header=True, header_style="bold magenta")
+        table.add_column("Severity", style="dim", width=12)
+        table.add_column("Issue", style="cyan")
+        table.add_column("Risk")
+        table.add_column("Recommendation", style="green")
+
+        # Sort findings: HIGH -> MEDIUM -> LOW
+        severity_map = {"HIGH": 0, "MEDIUM": 1, "LOW": 2}
+        sorted_findings = sorted(findings, key=lambda x: severity_map.get(x["severity"], 3))
+
+        for f in sorted_findings:
+            severity_color = "red" if f["severity"] == "HIGH" else "yellow" if f["severity"] == "MEDIUM" else "blue"
+            
+            table.add_row(
+                f"[{severity_color}]{f['severity']}[/{severity_color}]",
+                f["issue"],
+                f["risk"],
+                f["fix"]
+            )
+        
+        console.print(table)
+    else:
+        console.print("[bold green]No significant issues found![/bold green]")
+
+    # 3. Raw Headers (Optional or summarized)
+    console.print("\n[dim]Run with --verbose to see full header dump (not implemented in basic guide).[/dim]")
+
+
+def save_json(response_data, findings, filepath):
+    """Saves the report to a JSON file."""
+    output = {
+        "target": response_data.get("url"),
+        "status": response_data.get("status_code"),
+        "scan_time": "Now", # You can use datetime here
+        "headers": response_data.get("headers"),
+        "findings": findings
+    }
+    
+    try:
+        with open(filepath, 'w') as f:
+            json.dump(output, f, indent=4)
+        console.print(f"[bold green]✔ Report saved to {filepath}[/bold green]")
+    except Exception as e:
+        console.print(f"[bold red]Failed to save JSON:[/bold red] {e}")

argus_header/requester.py

@@ -0,0 +1,83 @@
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from .utils import normalize_url
+
+def fetch_headers(url: str, method="GET", follow_redirects=True, timeout=10):
+    """
+    Fetches headers from the target URL.
+    Returns a dictionary containing headers, status code, and URL.
+    """
+    target_url = normalize_url(url)
+    
+    # Configure retry logic (3 attempts)
+    retry_strategy = Retry(
+        total=3,
+        backoff_factor=1,
+        status_forcelist=[429, 500, 502, 503, 504]
+    )
+    adapter = HTTPAdapter(max_retries=retry_strategy)
+    session = requests.Session()
+    session.mount("https://", adapter)
+    session.mount("http://", adapter)
+
+    try:
+        response = session.request(
+            method=method,
+            url=target_url,
+            allow_redirects=follow_redirects,
+            timeout=timeout,
+            headers={"User-Agent": "HeaderScan-Tool/1.0"} # Polite User-Agent
+        )
+        
+        return {
+            "success": True,
+            "url": response.url,
+            "status_code": response.status_code,
+            "headers": dict(response.headers),
+            "http_version": response.raw.version
+        }
+
+    except requests.exceptions.Timeout:
+        return {
+            "success": False,
+            "url": target_url,
+            "error": "Request timed out. The server took too long to respond."
+        }
+    except requests.exceptions.SSLError:
+        return {
+            "success": False,
+            "url": target_url,
+            "error": "SSL verification failed. The certificate might be invalid."
+        }
+    except requests.exceptions.ConnectionError:
+        return {
+            "success": False,
+            "url": target_url,
+            "error": "Failed to connect to the server. Please check the URL and your internet connection."
+        }
+    except requests.exceptions.TooManyRedirects:
+        return {
+            "success": False,
+            "url": target_url,
+            "error": "Too many redirects. The URL might be in a redirect loop."
+        }
+    except requests.exceptions.MissingSchema:
+        return {
+            "success": False,
+            "url": target_url,
+            "error": "Invalid URL format. Missing schema (http:// or https://)."
+        }
+    except requests.exceptions.InvalidURL:
+        return {
+            "success": False,
+            "url": target_url,
+            "error": "Invalid URL. Please check the URL and try again."
+        }
+    except requests.exceptions.RequestException as e:
+        return {
+            "success": False,
+            "url": target_url,
+            "error": f"An error occurred: {str(e)}"
+        }
+        

argus_header/schemas.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel, HttpUrl
+from typing import Dict, List
+
+class AnalysisSummary(BaseModel):
+    total_checked: int
+    missing: int
+    risk_level: str
+
+class AnalysisResult(BaseModel):
+    summary: AnalysisSummary
+    details: List[Dict]
+
+class AnalyzeRequest(BaseModel):
+    url: HttpUrl

argus_header/utils.py

@@ -0,0 +1,9 @@
+from urllib.parse import urlparse
+
+def normalize_url(url: str) -> str:
+    """Ensure URL has a scheme (default to https)."""
+    parsed = urlparse(url)
+    if not parsed.scheme:
+        return f"https://{url}"
+    return url
+

argus_header-0.5.0.dist-info/METADATA

@@ -0,0 +1,402 @@
+Metadata-Version: 2.4
+Name: argus-header
+Version: 0.5.0
+Summary: A Python CLI tool for analyzing HTTP response headers and identifying security issues.
+Author-email: Sriram <sriram060106@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2025 sriram
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/heyshreee/argus-header
+Project-URL: Repository, https://github.com/heyshreee/argus-header
+Project-URL: Issues, https://github.com/heyshreee/argus-header/issues
+Keywords: http,https,headers,security,cybersecurity,cli,pentesting,web-security,header-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Security
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.32.0
+Requires-Dist: rich>=13.7.0
+Dynamic: license-file
+
+# 🛡️ Argus Header
+
+> Fast, lightweight HTTP security header analyzer built for developers, security engineers, and penetration testers.
+
+![Python](https://img.shields.io/badge/Python-3.9+-blue.svg)
+![Version](https://img.shields.io/badge/version-v0.5.0-orange.svg)
+![License](https://img.shields.io/badge/license-MIT-green.svg)
+
+Argus Header is a command-line tool that analyzes HTTP response headers and identifies common security misconfigurations, information leakage, and header-related best practice issues.
+
+---
+
+## ✨ Features
+
+### HTTP Request Engine
+
+- GET and HEAD request support
+- Configurable request timeout
+- Redirect support
+- Retry mechanism for temporary failures
+- Multiple URL scanning
+- Parallel scanning
+
+### Security Analysis
+
+Detects missing security headers including:
+
+- Content-Security-Policy (CSP)
+- Strict-Transport-Security (HSTS)
+- X-Frame-Options
+- X-Content-Type-Options
+
+### Information Disclosure Detection
+
+Checks for exposed:
+
+- Server
+- X-Powered-By
+
+### CORS Analysis
+
+Detects:
+
+- Access-Control-Allow-Origin: *
+
+### Performance Checks
+
+Checks:
+
+- Cache-Control
+
+### Reports
+
+- Beautiful Rich CLI output
+- JSON report export
+- Severity levels
+- Recommendations
+
+---
+
+# Installation
+
+## From Source
+
+```bash
+git clone https://github.com/heyshreee/argus-header.git
+
+cd argus-header
+
+python -m venv .venv
+
+source .venv/bin/activate
+```
+
+Windows
+
+```powershell
+.venv\Scripts\activate
+```
+
+Install
+
+```bash
+pip install -e .
+```
+
+---
+
+## Verify Installation
+
+```bash
+argus-header --version
+```
+
+Expected output
+
+```text
+argus-header 0.5.0
+```
+
+---
+
+# Usage
+
+Basic scan
+
+```bash
+argus-header https://example.com
+```
+
+HEAD request
+
+```bash
+argus-header https://example.com --method HEAD
+```
+
+Custom timeout
+
+```bash
+argus-header https://example.com --timeout 5
+```
+
+Multiple URLs
+
+```bash
+argus-header https://google.com https://github.com --parallel
+```
+
+Disable redirects
+
+```bash
+argus-header https://example.com --no-redirect
+```
+
+Export JSON
+
+```bash
+argus-header https://example.com --json report.json
+```
+
+Help
+
+```bash
+argus-header --help
+```
+
+---
+
+# Command Line Options
+
+| Option | Description |
+|---------|-------------|
+| --method | HTTP Method (GET / HEAD) |
+| --timeout | Request timeout |
+| --parallel | Scan multiple URLs concurrently |
+| --json FILE | Save report as JSON |
+| --no-redirect | Disable redirect following |
+| --verbose | Verbose output |
+| --version | Display version |
+| --help | Show help |
+
+---
+
+# Example Output
+
+```text
+Target
+https://example.com
+
+Status
+200
+
+Headers Found
+18
+
+HIGH
+Missing Content-Security-Policy
+
+HIGH
+Missing Strict-Transport-Security
+
+MEDIUM
+X-Powered-By Header Exposed
+
+LOW
+Missing Cache-Control
+```
+
+---
+
+# Project Structure
+
+```
+argus-header/
+
+src/
+└── argus_header/
+    ├── __init__.py
+    ├── cli.py
+    ├── requester.py
+    ├── analyzer.py
+    ├── reporter.py
+    └── utils.py
+
+tests/
+
+README.md
+LICENSE
+pyproject.toml
+```
+
+---
+
+# Current Checks
+
+## Security Headers
+
+- Content-Security-Policy
+- Strict-Transport-Security
+- X-Frame-Options
+- X-Content-Type-Options
+
+## Information Leakage
+
+- Server
+- X-Powered-By
+
+## CORS
+
+- Wildcard Access-Control-Allow-Origin
+
+## Performance
+
+- Cache-Control
+
+---
+
+# Roadmap
+
+## v0.6.0
+
+- Security score
+- Grade (A–F)
+- Cookie analysis
+- CSP validation
+- HSTS validation
+
+## v0.7.0
+
+- HTML reports
+- Markdown reports
+- Response time
+- Redirect chain
+- HTTP version display
+
+## v0.8.0
+
+- Unit tests
+- GitHub Actions
+- Documentation improvements
+- Better architecture
+
+## v0.9.0
+
+- TLS inspection
+- Certificate analysis
+- HTTP/2 detection
+- Advanced CORS analysis
+
+## v1.0.0
+
+- Stable public release
+- Complete security analysis
+- Production-ready documentation
+- Comprehensive testing
+
+---
+
+# Development
+
+Clone
+
+```bash
+git clone https://github.com/heyshreee/argus-header.git
+```
+
+Install development version
+
+```bash
+pip install -e .
+```
+
+Run
+
+```bash
+argus-header https://example.com
+```
+
+---
+
+# Contributing
+
+Contributions are welcome.
+
+1. Fork the repository
+2. Create a feature branch
+
+```bash
+git checkout -b feature/my-feature
+```
+
+3. Commit
+
+```bash
+git commit -m "feat: add awesome feature"
+```
+
+4. Push
+
+```bash
+git push origin feature/my-feature
+```
+
+5. Open a Pull Request
+
+---
+
+# License
+
+Released under the MIT License.
+
+See LICENSE for details.
+
+---
+
+# Author
+
+**Sriram**
+
+GitHub
+
+https://github.com/heyshreee
+
+---
+
+## Disclaimer
+
+Argus Header is intended for defensive security, security auditing, learning, and authorized penetration testing only.
+
+Only scan systems that you own or have explicit permission to assess.

argus_header-0.5.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+argus_header/__init__.py,sha256=uQVjPzsddEJGsZjXUB0SHzx9tAoc0of3C58EGEfc8oU,50
+argus_header/analyzer.py,sha256=bnWgGBNnw_5oEIG908A8UJxdVoB3ri-p05KyZYsvDh8,3747
+argus_header/cli.py,sha256=V0jmBZFLqJGhBBt_SwfUwXlF197iTRNCb5Eat5ZXHKA,3578
+argus_header/reporter.py,sha256=0pLQw5b4amUGAGswyh4SJSHDgy9klJbV_Sj05lTIPt8,2605
+argus_header/requester.py,sha256=C3s5KjiTaUUH7fqZtTSf7u9X2d4ePWji_7-jkUCb0JI,2795
+argus_header/schemas.py,sha256=PmZdt2qasD1g1Ro_wUPODP3WCix15ZaN4VKBPJDFaSI,315
+argus_header/utils.py,sha256=v7W6XE04DY7obHgvySu5OJPw_9OTJaFw2CXjAseSxlo,235
+argus_header-0.5.0.dist-info/licenses/LICENSE,sha256=MURT6Y_IYDbgb8tnFKQG68FzIpFANsOdsueZDdMX_50,1084
+argus_header-0.5.0.dist-info/METADATA,sha256=AhMwwTA6VRpMHAYyD0IRCFT3F4_3ZJ2VpgvvaZdTchQ,7579
+argus_header-0.5.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+argus_header-0.5.0.dist-info/entry_points.txt,sha256=k5foSrq495f7voIC_gC7TQHXcqmrap3a49lb330DYBA,55
+argus_header-0.5.0.dist-info/top_level.txt,sha256=M7zERlzbzua16PH1OvPAWR0zowIjFFwVnygXKtVnOA0,13
+argus_header-0.5.0.dist-info/RECORD,,

argus_header-0.5.0.dist-info/WHEEL

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

argus_header-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+argus-header = argus_header.cli:main

argus_header-0.5.0.dist-info/licenses/LICENSE

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

argus_header-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+argus_header