devdoctor-cli 0.1.0__py3-none-any.whl

devdoctor/checks/postgres.py

@@ -0,0 +1,65 @@
+"""PostgreSQL service and connection diagnostics."""
+
+from __future__ import annotations
+
+import re
+import socket
+from typing import List
+
+from devdoctor.checks.base import Check, register_check
+from devdoctor.models import Confidence, Diagnostic, FixAction, ScanContext, Severity
+from devdoctor.utils.platform_info import is_windows
+from devdoctor.utils.process_utils import is_port_in_use
+
+
+@register_check
+class PostgresCheck(Check):
+    name = "postgres"
+    title = "PostgreSQL Diagnostics"
+    category = "framework"
+    description = "Checks PostgreSQL service availability, port 5432 reachability, and configuration."
+
+    def run(self, context: ScanContext) -> List[Diagnostic]:
+        diagnostics: List[Diagnostic] = []
+        is_postgres_project = context.project_info and "PostgreSQL" in context.project_info.technologies
+
+        # Check port 5432
+        port_open = is_port_in_use(5432)
+
+        if port_open:
+            diagnostics.append(Diagnostic(
+                title="PostgreSQL service listening",
+                severity=Severity.OK,
+                message="PostgreSQL server is listening on port 5432.",
+                check_id=f"{self.name}_port_ok",
+            ))
+        elif is_postgres_project:
+            start_cmd = "docker compose up -d postgres" if (context.project_path / "docker-compose.yml").exists() else ("net start postgresql-x64" if is_windows() else "sudo systemctl start postgresql")
+            diagnostics.append(Diagnostic(
+                title="PostgreSQL not running",
+                severity=Severity.ERROR,
+                message="PostgreSQL service is not listening on default port 5432.",
+                why="The project requires PostgreSQL, but no service was detected on port 5432.",
+                evidence="Port 5432 connection refused.",
+                fix=f"Start PostgreSQL service:\n     {start_cmd}",
+                command=start_cmd,
+                confidence=Confidence.HIGH,
+                check_id=f"{self.name}_not_running",
+            ))
+
+        # Check DATABASE_URL format if present in env
+        db_url = context.env_vars.get("DATABASE_URL")
+        if db_url:
+            if not re.match(r"^postgres(ql)?:\/\/", db_url):
+                diagnostics.append(Diagnostic(
+                    title="Malformed DATABASE_URL",
+                    severity=Severity.WARNING,
+                    message="DATABASE_URL does not start with postgres:// or postgresql://.",
+                    why=f"DATABASE_URL value is '{db_url[:15]}...', which might not be a valid PostgreSQL connection string.",
+                    evidence=f"DATABASE_URL = {db_url}",
+                    fix="Verify and correct the connection URL in .env.",
+                    confidence=Confidence.MEDIUM,
+                    check_id=f"{self.name}_malformed_url",
+                ))
+
+        return diagnostics

devdoctor/checks/python.py

@@ -0,0 +1,105 @@
+"""Check Python runtime version and project compatibility."""
+
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from packaging.specifiers import InvalidSpecifier, SpecifierSet
+from packaging.version import Version
+
+from devdoctor.checks.base import Check, register_check
+from devdoctor.models import Confidence, Diagnostic, FixAction, ScanContext, Severity
+from devdoctor.utils.platform_info import get_python_version_str
+
+
+def get_required_python_spec(project_path: Path) -> Optional[str]:
+    """Read Python version requirement from pyproject.toml, .python-version, or runtime.txt."""
+    pyproject = project_path / "pyproject.toml"
+    if pyproject.is_file():
+        try:
+            content = pyproject.read_text(encoding="utf-8", errors="replace")
+            # Match requires-python = ">=3.11"
+            match = re.search(r'requires-python\s*=\s*["\']([^"\']+)["\']', content)
+            if match:
+                return match.group(1).strip()
+        except Exception:
+            pass
+
+    python_version_file = project_path / ".python-version"
+    if python_version_file.is_file():
+        try:
+            version_str = python_version_file.read_text(encoding="utf-8", errors="replace").strip()
+            if version_str:
+                return f"=={version_str}" if not any(c in version_str for c in "<>=~") else version_str
+        except Exception:
+            pass
+
+    runtime_txt = project_path / "runtime.txt"
+    if runtime_txt.is_file():
+        try:
+            content = runtime_txt.read_text(encoding="utf-8", errors="replace").strip()
+            # python-3.12.2 -> ==3.12.2
+            match = re.search(r"python-([0-9.]+)", content)
+            if match:
+                return f"=={match.group(1)}"
+        except Exception:
+            pass
+
+    return None
+
+
+@register_check
+class PythonVersionCheck(Check):
+    name = "python_version"
+    title = "Python Version"
+    category = "system"
+    description = "Verifies Python version and project requirement compatibility."
+
+    def run(self, context: ScanContext) -> Diagnostic:
+        current_version_str = get_python_version_str()
+        current_ver = Version(current_version_str)
+        spec_str = get_required_python_spec(context.project_path)
+
+        if spec_str:
+            try:
+                spec = SpecifierSet(spec_str)
+                if current_ver not in spec:
+                    return Diagnostic(
+                        title="Python version incompatible",
+                        severity=Severity.ERROR,
+                        message=f"Your project requires Python {spec_str}, but you are running {current_version_str}.",
+                        why=f"The current Python runtime ({current_version_str}) does not satisfy the specified version constraints.",
+                        evidence=f"Active: {current_version_str} | Required: {spec_str}",
+                        fix=f"Install Python {spec_str} and recreate your virtual environment.",
+                        command=f"py -{spec_str.replace('>=', '').replace('==', '')} -m venv .venv",
+                        confidence=Confidence.HIGH,
+                        check_id=self.name,
+                        metadata={"current_version": current_version_str, "required_spec": spec_str},
+                    )
+            except InvalidSpecifier:
+                pass
+
+        # Check for ancient / unsupported Python versions (< 3.9)
+        if sys.version_info < (3, 9):
+            return Diagnostic(
+                title=f"Python {current_version_str}",
+                severity=Severity.WARNING,
+                message=f"Python {current_version_str} is End-Of-Life and no longer receives security updates.",
+                why="Python versions below 3.9 are deprecated by python.org and most modern libraries.",
+                evidence=f"Active runtime version: {current_version_str}",
+                fix="Upgrade to Python 3.11 or 3.12 for improved performance and security.",
+                command="py -3.12 -m venv .venv",
+                confidence=Confidence.HIGH,
+                check_id=self.name,
+            )
+
+        return Diagnostic(
+            title=f"Python {current_version_str}",
+            severity=Severity.OK,
+            message=f"Python {current_version_str} is installed and compatible.",
+            check_id=self.name,
+            metadata={"version": current_version_str},
+        )

devdoctor/checks/redis.py

@@ -0,0 +1,70 @@
+"""Redis server service and ping diagnostics."""
+
+from __future__ import annotations
+
+import socket
+from typing import List
+
+from devdoctor.checks.base import Check, register_check
+from devdoctor.models import Confidence, Diagnostic, ScanContext, Severity
+from devdoctor.utils.process_utils import is_port_in_use
+
+
+@register_check
+class RedisCheck(Check):
+    name = "redis"
+    title = "Redis Diagnostics"
+    category = "framework"
+    description = "Checks Redis server availability on port 6379 and RESP PING responsiveness."
+
+    def run(self, context: ScanContext) -> List[Diagnostic]:
+        diagnostics: List[Diagnostic] = []
+        is_redis_project = context.project_info and "Redis" in context.project_info.technologies
+
+        # Check port 6379
+        port_open = is_port_in_use(6379)
+
+        if port_open:
+            # Try raw RESP PING
+            ping_ok = False
+            try:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                    s.settimeout(1.0)
+                    s.connect(("127.0.0.1", 6379))
+                    s.sendall(b"*1\r\n$4\r\nPING\r\n")
+                    response = s.recv(1024)
+                    if b"+PONG" in response:
+                        ping_ok = True
+            except Exception:
+                pass
+
+            if ping_ok:
+                diagnostics.append(Diagnostic(
+                    title="Redis healthy",
+                    severity=Severity.OK,
+                    message="Redis server is running and responded to PING with PONG.",
+                    check_id=f"{self.name}_ping_ok",
+                ))
+            else:
+                diagnostics.append(Diagnostic(
+                    title="Redis port open",
+                    severity=Severity.OK,
+                    message="Port 6379 is listening (Redis server active).",
+                    check_id=f"{self.name}_port_ok",
+                ))
+
+        elif is_redis_project:
+            start_cmd = "docker run -d -p 6379:6379 --name redis redis:alpine"
+            diagnostics.append(Diagnostic(
+                title="Redis not running",
+                severity=Severity.ERROR,
+                message="Redis server is not listening on default port 6379.",
+                why="The project uses Redis, but no local Redis instance is reachable on port 6379.",
+                evidence="Port 6379 connection refused.",
+                fix=f"Start Redis with Docker:\n     {start_cmd}",
+                command=start_cmd,
+                confidence=Confidence.HIGH,
+                check_id=f"{self.name}_not_running",
+            ))
+
+        return diagnostics

devdoctor/checks/virtualenv.py

@@ -0,0 +1,79 @@
+"""Check virtual environment activation and isolation."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+from devdoctor.checks.base import Check, register_check
+from devdoctor.models import Confidence, Diagnostic, FixAction, ScanContext, Severity
+from devdoctor.utils.platform_info import (
+    find_local_venv,
+    get_venv_activation_command,
+    is_in_virtualenv,
+    is_windows,
+)
+
+
+@register_check
+class VirtualenvCheck(Check):
+    name = "virtual_environment"
+    title = "Virtual Environment"
+    category = "environment"
+    description = "Verifies that the shell is operating within an active virtual environment."
+
+    def run(self, context: ScanContext) -> Diagnostic:
+        in_venv = is_in_virtualenv()
+        context.is_venv = in_venv
+
+        if in_venv:
+            venv_name = os.environ.get("VIRTUAL_ENV") or sys.prefix
+            venv_display = Path(venv_name).name if venv_name else "active"
+            return Diagnostic(
+                title=f"Virtual environment ({venv_display})",
+                severity=Severity.OK,
+                message="Current shell is using an active virtual environment.",
+                check_id=self.name,
+                metadata={"venv_path": venv_name},
+            )
+
+        # Not in virtual environment
+        local_venv = find_local_venv(context.project_path)
+        venv_dir = local_venv.name if local_venv else ".venv"
+
+        if is_windows():
+            fix_text = f"Windows:\n     {venv_dir}\\Scripts\\activate"
+            activate_cmd = f"{venv_dir}\\Scripts\\activate"
+        else:
+            fix_text = f"Linux / macOS:\n     source {venv_dir}/bin/activate"
+            activate_cmd = f"source {venv_dir}/bin/activate"
+
+        if not local_venv:
+            create_cmd = f"{sys.executable} -m venv .venv"
+            fix_text = f"Create and activate virtualenv:\n     {create_cmd}\n     {activate_cmd}"
+            fix_action = FixAction(
+                description="Create .venv virtual environment",
+                command=create_cmd,
+                safe=True,
+            )
+        else:
+            fix_action = FixAction(
+                description=f"Activate existing {venv_dir} environment",
+                command=activate_cmd,
+                safe=True,
+            )
+
+        return Diagnostic(
+            title="Virtual environment",
+            severity=Severity.ERROR,
+            message="Current shell is not using a virtual environment.",
+            why="Installing packages or running tasks outside a virtual environment pollutes the global Python installation and causes dependency collisions.",
+            evidence=f"Active interpreter is global: {sys.executable}",
+            fix=fix_text,
+            command=activate_cmd,
+            confidence=Confidence.HIGH,
+            fix_action=fix_action,
+            check_id=self.name,
+            metadata={"local_venv_found": local_venv is not None},
+        )

devdoctor/cli.py

@@ -0,0 +1,319 @@
+"""Command-line interface for DevDoctor."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from rich.console import Console
+
+from devdoctor import __version__
+from devdoctor.fixer import Fixer
+from devdoctor.project import detect_project
+from devdoctor.reporter import Reporter
+from devdoctor.scanner import Scanner
+
+# Ensure UTF-8 output on Windows terminals
+if sys.stdout and hasattr(sys.stdout, "reconfigure"):
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+if sys.stderr and hasattr(sys.stderr, "reconfigure"):
+    try:
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+console = Console(legacy_windows=False)
+reporter = Reporter(console)
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Construct the command line argument parser for DevDoctor."""
+    parser = argparse.ArgumentParser(
+        prog="devdoctor",
+        description="Deterministic developer machine and project diagnostic doctor.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument(
+        "--version", "-V",
+        action="version",
+        version=f"DevDoctor {__version__}",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available subcommands")
+
+    # 1. scan (default command)
+    scan_parser = subparsers.add_parser("scan", help="Scan developer machine and project for issues.")
+    scan_parser.add_argument("path", nargs="?", default=".", help="Path to project directory (default: current directory)")
+    scan_parser.add_argument("--json", action="store_true", help="Output machine-readable JSON")
+    scan_parser.add_argument("--markdown", action="store_true", help="Output GitHub-flavored Markdown")
+    scan_parser.add_argument("-v", "--verbose", action="store_true", help="Show comprehensive diagnostic breakdown (WHY, EVIDENCE, FIX, COMMAND)")
+    scan_parser.add_argument("-o", "--output", help="Save diagnostic report to a specified file")
+    scan_parser.add_argument("--strict", action="store_true", help="Exit with code 1 if any warnings or errors are found")
+    scan_parser.add_argument("--checks-dir", help="Path to custom check plugins directory")
+
+    # 2. fix
+    fix_parser = subparsers.add_parser("fix", help="Interactively or automatically apply safe fixes for identified problems.")
+    fix_parser.add_argument("path", nargs="?", default=".", help="Path to project directory")
+    fix_parser.add_argument("--safe", action="store_true", help="Apply only safe, non-destructive automatic fixes")
+    fix_parser.add_argument("--dry-run", action="store_true", help="Show planned fixes without modifying anything")
+    fix_parser.add_argument("-y", "--yes", action="store_true", help="Confirm all fixes without interactive prompt")
+
+    # 3. dependencies
+    dep_parser = subparsers.add_parser("dependencies", help="Check for dependency conflicts and broken imports.")
+    dep_parser.add_argument("path", nargs="?", default=".", help="Path to project directory")
+    dep_parser.add_argument("-v", "--verbose", action="store_true", help="Show full evidence and fix commands")
+    dep_parser.add_argument("--json", action="store_true", help="Output dependency report as JSON")
+
+    # 4. port
+    port_parser = subparsers.add_parser("port", help="Network port tools and process management.")
+    port_sub = port_parser.add_subparsers(dest="port_action", required=True)
+    port_free_parser = port_sub.add_parser("free", help="Safely terminate process occupying a port.")
+    port_free_parser.add_argument("port_number", type=int, help="Port number to free (e.g. 8000)")
+    port_free_parser.add_argument("-y", "--yes", action="store_true", help="Terminate without interactive prompt")
+
+    # 5. project
+    proj_parser = subparsers.add_parser("project", help="Inspect detected project type, framework, and tech stack.")
+    proj_parser.add_argument("path", nargs="?", default=".", help="Path to project directory")
+    proj_parser.add_argument("--json", action="store_true", help="Output project profile as JSON")
+
+    # 6. report
+    rep_parser = subparsers.add_parser("report", help="Generate full diagnostic report in Markdown or JSON format.")
+    rep_parser.add_argument("path", nargs="?", default=".", help="Path to project directory")
+    rep_parser.add_argument("--format", choices=["terminal", "markdown", "json"], default="markdown", help="Output format")
+    rep_parser.add_argument("-o", "--output", help="Output file path (default: stdout)")
+
+    # 7. Framework commands
+    for fw in ["django", "fastapi", "docker", "postgres", "redis"]:
+        fw_parser = subparsers.add_parser(fw, help=f"Run diagnostics specifically for {fw.capitalize()}.")
+        fw_parser.add_argument("path", nargs="?", default=".", help="Path to project directory")
+        fw_parser.add_argument("-v", "--verbose", action="store_true", help="Show full diagnostics")
+        fw_parser.add_argument("--json", action="store_true", help="Output as JSON")
+
+    return parser
+
+
+def cmd_scan(args: argparse.Namespace) -> int:
+    """Execute devdoctor scan."""
+    project_path = Path(args.path).resolve()
+    checks_dir = Path(args.checks_dir).resolve() if getattr(args, "checks_dir", None) else None
+
+    scanner = Scanner(project_path, custom_checks_dir=checks_dir)
+    report = scanner.scan()
+
+    if getattr(args, "json", False):
+        output = reporter.render_json(report)
+        if getattr(args, "output", None):
+            Path(args.output).write_text(output, encoding="utf-8")
+            console.print(f"[green]Report saved to {args.output}[/green]")
+        else:
+            print(output)
+    elif getattr(args, "markdown", False):
+        output = reporter.render_markdown(report)
+        if getattr(args, "output", None):
+            Path(args.output).write_text(output, encoding="utf-8")
+            console.print(f"[green]Report saved to {args.output}[/green]")
+        else:
+            print(output)
+    else:
+        reporter.render_terminal(report, verbose=getattr(args, "verbose", False))
+        if getattr(args, "output", None):
+            Path(args.output).write_text(reporter.render_markdown(report), encoding="utf-8")
+            console.print(f"[dim]Markdown copy saved to {args.output}[/dim]")
+
+    if getattr(args, "strict", False):
+        return 1 if report.total_problems > 0 else 0
+    return 1 if report.errors else 0
+
+
+def cmd_fix(args: argparse.Namespace) -> int:
+    """Execute devdoctor fix."""
+    project_path = Path(args.path).resolve()
+    scanner = Scanner(project_path)
+    report = scanner.scan()
+    context = scanner.create_context()
+
+    fixer = Fixer(console)
+    plan = fixer.build_plan(report)
+
+    safe_only = getattr(args, "safe", False)
+    dry_run = getattr(args, "dry_run", False)
+    auto_yes = getattr(args, "yes", False)
+
+    res = fixer.execute_plan(
+        plan=plan,
+        context=context,
+        safe_only=safe_only,
+        dry_run=dry_run,
+        auto_yes=auto_yes,
+        interactive=not auto_yes and not dry_run,
+    )
+    return 0 if len(res.failed) == 0 else 1
+
+
+def cmd_dependencies(args: argparse.Namespace) -> int:
+    """Execute devdoctor dependencies."""
+    project_path = Path(args.path).resolve()
+    scanner = Scanner(project_path)
+    report = scanner.scan(check_names={"dependency_conflicts", "broken_imports"})
+
+    if getattr(args, "json", False):
+        print(reporter.render_json(report))
+        return 0
+
+    console.print("[bold cyan]DevDoctor Dependency Diagnostics[/bold cyan]")
+    console.print("──────────────────────────────────────────\n")
+
+    if not report.problems:
+        console.print("[bold green]✓ No dependency conflicts or broken imports detected.[/bold green]")
+        return 0
+
+    for d in report.problems:
+        sym = "[red]❌[/red]" if d.is_error else "[yellow]⚠[/yellow]"
+        console.print(f"{sym} [bold]{d.title}[/bold]\n")
+        if d.evidence:
+            for line in d.evidence.splitlines():
+                console.print(f"{line}")
+            console.print()
+        elif d.message:
+            console.print(f"{d.message}\n")
+
+        if d.fix:
+            console.print(f"[bold]Suggested action:[/bold]\n{d.fix}\n")
+
+    return 1 if report.errors else 0
+
+
+def cmd_port(args: argparse.Namespace) -> int:
+    """Execute devdoctor port free <port>."""
+    if args.port_action == "free":
+        port = args.port_number
+        auto_yes = getattr(args, "yes", False)
+        fixer = Fixer(console)
+        success = fixer.free_port_interactive(port, auto_yes=auto_yes)
+        return 0 if success else 1
+    return 0
+
+
+def cmd_project(args: argparse.Namespace) -> int:
+    """Execute devdoctor project."""
+    project_path = Path(args.path).resolve()
+    info = detect_project(project_path)
+
+    if getattr(args, "json", False):
+        import json
+        print(json.dumps(info.to_dict(), indent=2))
+        return 0
+
+    console.print(f"[bold cyan]Project Profile: {info.name}[/bold cyan]")
+    console.print("──────────────────────────────────────────")
+    console.print(f"[bold]Detected Type:[/bold]      {info.project_type or 'Generic Python'}")
+    console.print(f"[bold]Stack Summary:[/bold]      {info.summary_stack}")
+    console.print(f"[bold]Technologies:[/bold]       {', '.join(info.technologies) if info.technologies else 'None'}")
+    console.print(f"[bold]Frameworks:[/bold]         {', '.join(info.frameworks) if info.frameworks else 'None'}")
+    console.print(f"[bold]Config Files:[/bold]       {', '.join(info.config_files) if info.config_files else 'None'}")
+    console.print(f"[bold]Dependencies:[/bold]       {len(info.dependencies)} declared")
+    return 0
+
+
+def cmd_report(args: argparse.Namespace) -> int:
+    """Execute devdoctor report."""
+    project_path = Path(args.path).resolve()
+    scanner = Scanner(project_path)
+    report = scanner.scan()
+
+    fmt = getattr(args, "format", "markdown")
+    if fmt == "json":
+        output = reporter.render_json(report)
+    elif fmt == "markdown":
+        output = reporter.render_markdown(report)
+    else:
+        reporter.render_terminal(report, verbose=True)
+        return 0
+
+    if getattr(args, "output", None):
+        Path(args.output).write_text(output, encoding="utf-8")
+        console.print(f"[bold green]Report saved to {args.output}[/bold green]")
+    else:
+        print(output)
+    return 0
+
+
+def cmd_framework(name: str, args: argparse.Namespace) -> int:
+    """Execute framework diagnostic command."""
+    project_path = Path(args.path).resolve()
+    scanner = Scanner(project_path)
+    report = scanner.scan(check_names={name})
+
+    if getattr(args, "json", False):
+        print(reporter.render_json(report))
+        return 0
+
+    console.print(f"[bold cyan]DevDoctor: {name.capitalize()} Diagnostics[/bold cyan]")
+    console.print("──────────────────────────────────────────\n")
+
+    if not report.diagnostics:
+        console.print(f"[dim]No specific {name} checks triggered.[/dim]")
+        return 0
+
+    if report.passed:
+        for p in report.passed:
+            console.print(f"[green]✓[/green] {p.title}")
+        console.print()
+
+    if report.problems:
+        for d in report.problems:
+            sym = "[red]❌[/red]" if d.is_error else "[yellow]⚠[/yellow]"
+            console.print(f"{sym} [bold]{d.title}[/bold]")
+            if d.message:
+                console.print(f"   {d.message}\n")
+            if d.evidence:
+                console.print(f"   {d.evidence}\n")
+            if d.fix:
+                console.print(f"   Fix:\n     {d.fix}\n")
+    else:
+        console.print(f"[bold green]✓ All {name} diagnostics passed![/bold green]")
+
+    return 1 if report.errors else 0
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    """CLI entry point for DevDoctor."""
+    if argv is None:
+        argv = sys.argv[1:]
+
+    # Default to 'scan' if no arguments or flags provided
+    if not argv:
+        argv = ["scan"]
+    elif argv[0].startswith("-") and argv[0] not in ("-h", "--help", "-V", "--version"):
+        argv = ["scan"] + argv
+
+    parser = create_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "scan":
+        return cmd_scan(args)
+    elif args.command == "fix":
+        return cmd_fix(args)
+    elif args.command == "dependencies":
+        return cmd_dependencies(args)
+    elif args.command == "port":
+        return cmd_port(args)
+    elif args.command == "project":
+        return cmd_project(args)
+    elif args.command == "report":
+        return cmd_report(args)
+    elif args.command in ("django", "fastapi", "docker", "postgres", "redis"):
+        return cmd_framework(args.command, args)
+    else:
+        parser.print_help()
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())