pyfixit-cli 0.1.0__py3-none-any.whl

pyfixit/cleaner.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+
+from pyfixit.requirements_parser import parse_requirement
+from pyfixit.package_names import get_import_name
+
+
+def clean_requirements(project_directory=".", apply=False):
+    project_directory = Path(project_directory)
+
+    requirements_file = project_directory / "requirements.txt"
+
+    if not requirements_file.exists():
+        return []
+
+    lines = requirements_file.read_text(
+        encoding="utf-8"
+    ).splitlines()
+
+    from pyfixit.imports import get_project_imports
+
+    imports = get_project_imports(project_directory)
+
+    kept = []
+    removed = []
+
+    for line in lines:
+
+        original_line = line
+        line = line.strip()
+
+        if not line:
+            kept.append(original_line)
+            continue
+
+        if line.startswith("#"):
+            kept.append(original_line)
+            continue
+
+        parsed = parse_requirement(line)
+
+        if parsed is None:
+            kept.append(original_line)
+            continue
+
+        package_name = parsed["package"]
+
+        import_name = get_import_name(package_name)
+
+        if import_name not in imports:
+            removed.append(original_line)
+        else:
+            kept.append(original_line)
+
+    # Only modify requirements.txt when --apply is used
+    if apply and removed:
+
+        requirements_file.write_text(
+            "\n".join(kept) + "\n",
+            encoding="utf-8"
+        )
+
+    return removed

pyfixit/cli.py

@@ -0,0 +1,265 @@
+import argparse
+import json
+from pyfixit.diagnostics import diagnose_project, get_fix_suggestion
+from pyfixit.cleaner import clean_requirements
+
+
+def main():
+
+    parser = argparse.ArgumentParser(
+        description="Diagnose common Python import and dependency problems."
+    )
+
+    parser.add_argument(
+    "command",
+    nargs="?",
+    default="diagnose",
+    help="Command to run"
+    )
+
+    parser.add_argument(
+        "project_directory",
+        nargs="?",
+        default=".",
+        help="Python project directory"
+    )
+
+    parser.add_argument(
+        "--apply",
+        action="store_true",
+        help="Apply cleanup changes"
+    )
+
+    parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output diagnosis as JSON"
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="PyFixIt 0.1.0"
+    )
+
+    args = parser.parse_args()
+
+    # ------------------------------------------------
+    # Support: pyfixit .
+    # ------------------------------------------------
+
+    if args.command not in ["diagnose", "clean", "check"]:
+        args.project_directory = args.command
+        args.command = "diagnose"
+
+    # ------------------------------------------------
+    # CLEAN
+    # ------------------------------------------------
+
+    if args.command == "clean":
+
+        print("PyFixIt v0.1.0")
+        print("Python Project Troubleshooter")
+        print()
+
+        removed = clean_requirements(
+            args.project_directory,
+            apply=args.apply
+        )
+
+        print("Cleaning requirements.txt")
+        print("------------------------------")
+
+        if len(removed) == 0:
+            print("Nothing to remove.")
+
+        elif args.apply:
+
+            for dependency in removed:
+                print(f"[REMOVED] {dependency}")
+
+            print()
+            print(f"{len(removed)} dependencies removed.")
+
+        else:
+
+            for dependency in removed:
+                print(f"[REMOVE] {dependency}")
+
+            print()
+            print(
+                f"{len(removed)} unused dependencies found."
+            )
+
+            print(
+                "Run 'pyfixit clean --apply' to remove them."
+            )
+
+        return
+    
+
+
+    # ------------------------------------------------
+    # CHECK
+    # ------------------------------------------------
+
+    if args.command == "check":
+
+        print("PyFixIt v0.1.0")
+        print("Python Project Troubleshooter")
+        print()
+
+        result = diagnose_project(
+            args.project_directory
+        )
+
+        dependency_problems = 0
+
+        for item in result["dependencies"]:
+
+            if item["status"] != "ok":
+                dependency_problems += 1
+
+        unused_count = len(
+            result["unused_dependencies"]
+        )
+
+        print("Checking project...")
+        print()
+
+        if dependency_problems == 0:
+            print("[OK] No dependency problems found")
+        else:
+            print(
+                f"[FAIL] {dependency_problems} "
+                f"dependency problems found"
+            )
+
+        if unused_count == 0:
+            print("[OK] No unused dependencies found")
+        else:
+            print(
+                f"[FAIL] {unused_count} "
+                f"unused dependencies found"
+            )
+
+        print()
+
+        if dependency_problems > 0 or unused_count > 0:
+            raise SystemExit(1)
+
+        raise SystemExit(0)
+    
+    
+
+    # ------------------------------------------------
+    # DIAGNOSE
+    # ------------------------------------------------
+
+    result = diagnose_project(
+        args.project_directory
+    )
+
+    if args.json:
+        print(json.dumps(result, indent=2))
+        
+        has_problems = any(
+            item["status"] != "ok"
+            for item in result["dependencies"]
+        )
+
+        if len(result["unused_dependencies"]) > 0:
+            has_problems = True
+
+        if has_problems:
+            raise SystemExit(1)
+
+        raise SystemExit(0)
+    
+    print("PyFixIt v0.1.0")
+    print("Python Project Troubleshooter")
+    print()
+
+    print("Dependencies")
+    print("------------------------------")
+
+    has_problems = False
+
+    for item in result["dependencies"]:
+
+        status = item["status"]
+
+        if status == "ok":
+            print(f"[OK] {item['module']}")
+            continue
+
+        has_problems = True
+
+        if status == "version_conflict":
+
+            print(
+                f"[VERSION CONFLICT] {item['module']}"
+            )
+
+            print(
+                f"  Required: "
+                f"{item['operator']}{item['required_version']}"
+            )
+
+            print(
+                f"  Installed: "
+                f"{item['installed_version']}"
+            )
+
+            print(
+                f"  Fix: "
+                f"{get_fix_suggestion(item)}"
+            )
+
+            print()
+
+            continue
+
+        print(f"[PROBLEM] {item['module']}")
+        print(f"  Status: {status}")
+        print(
+            f"  Fix: "
+            f"{get_fix_suggestion(item)}"
+        )
+
+        print()
+
+    print("Unused dependencies")
+    print("------------------------------")
+
+    unused = result["unused_dependencies"]
+
+    if len(unused) == 0:
+
+        print("None")
+
+    else:
+
+        has_problems = True
+
+        for dependency in unused:
+
+            print(f"[UNUSED] {dependency}")
+
+            print(
+                f"  Fix: Remove "
+                f"'{dependency}' from requirements.txt"
+            )
+
+    # ------------------------------------------------
+    # EXIT CODE
+    # ------------------------------------------------
+
+    if has_problems:
+        raise SystemExit(1)
+
+    raise SystemExit(0)
+
+
+if __name__ == "__main__":
+    main()

pyfixit/dependencies.py

@@ -0,0 +1,32 @@
+from pathlib import Path
+from importlib.metadata import version, PackageNotFoundError
+
+
+def find_requirements_file():
+    requirements_file = Path("requirements.txt")
+
+    if requirements_file.exists():
+        return requirements_file
+
+    return None
+
+
+def read_requirements(requirements_file):
+    dependencies = []
+
+    with open(requirements_file, "r", encoding="utf-8") as file:
+        for line in file:
+            line = line.strip()
+
+            if line and not line.startswith("#"):
+                dependencies.append(line)
+
+    return dependencies
+
+
+def is_package_installed(package_name):
+    try:
+        version(package_name)
+        return True
+    except PackageNotFoundError:
+        return False

pyfixit/diagnostics.py

@@ -0,0 +1,294 @@
+import importlib.util
+from importlib.metadata import version, PackageNotFoundError
+from pathlib import Path
+
+from pyfixit.package_names import get_import_name, get_package_name
+from pyfixit.requirements_parser import parse_requirement, check_version
+
+
+def check_dependency_declared(package_name, dependencies):
+    for dependency in dependencies:
+
+        parsed = parse_requirement(dependency)
+
+        if parsed is None:
+            continue
+
+        if parsed["package"].lower() == package_name.lower():
+            return True
+
+    return False
+
+
+def check_dependency_installed(module_name):
+    try:
+        spec = importlib.util.find_spec(module_name)
+
+        if spec is None:
+            return False
+
+        return True
+
+    except ModuleNotFoundError:
+        return False
+
+
+def get_installed_version(package_name):
+    try:
+        return version(package_name)
+
+    except PackageNotFoundError:
+        return None
+
+
+def diagnose_dependency(module_name, dependencies):
+
+    import_name = module_name
+    package_name = get_package_name(module_name)
+
+    declared = False
+    required_version = None
+    operator = None
+
+    for dependency in dependencies:
+
+        parsed = parse_requirement(dependency)
+
+        if parsed is None:
+            continue
+
+        declared_package = parsed["package"]
+
+        if declared_package.lower() == package_name.lower():
+
+            declared = True
+            required_version = parsed["version"]
+            operator = parsed["operator"]
+
+            break
+
+    installed = check_dependency_installed(
+        import_name
+    )
+
+    installed_version = None
+
+    if installed:
+        installed_version = get_installed_version(
+            package_name
+        )
+
+    if not declared and not installed:
+
+        status = "missing_declaration_and_installation"
+
+    elif declared and not installed:
+
+        status = "missing_installation"
+
+    elif not declared and installed:
+
+        status = "missing_declaration"
+
+    elif required_version is not None:
+
+        if check_version(
+            installed_version,
+            operator,
+            required_version
+        ):
+
+            status = "ok"
+
+        else:
+
+            status = "version_conflict"
+
+    else:
+
+        status = "ok"
+
+    return {
+        "module": module_name,
+        "package_name": package_name,
+        "import_name": import_name,
+        "declared": declared,
+        "installed": installed,
+        "installed_version": installed_version,
+        "required_version": required_version,
+        "operator": operator,
+        "status": status
+    }
+
+
+def diagnose_dependencies(modules, dependencies):
+
+    results = []
+
+    for module in modules:
+
+        result = diagnose_dependency(
+            module,
+            dependencies
+        )
+
+        results.append(result)
+
+    return results
+
+
+def read_requirements(project_directory="."):
+
+    requirements_file = Path(
+        project_directory
+    ) / "requirements.txt"
+
+    if not requirements_file.exists():
+        return []
+
+    dependencies = []
+
+    with open(
+        requirements_file,
+        "r",
+        encoding="utf-8"
+    ) as file:
+
+        for line in file:
+
+            line = line.strip()
+
+            if not line:
+                continue
+
+            if line.startswith("#"):
+                continue
+
+            dependencies.append(line)
+
+    return dependencies
+
+
+def find_unused_dependencies(imports, dependencies):
+
+    unused = []
+
+    for dependency in dependencies:
+
+        parsed = parse_requirement(dependency)
+
+        if parsed is None:
+            continue
+
+        package_name = parsed["package"]
+
+        import_name = get_import_name(
+            package_name
+        )
+
+        if import_name not in imports:
+
+            unused.append(dependency)
+
+    return unused
+
+
+def diagnose_project(project_directory="."):
+
+    from pyfixit.imports import get_project_imports
+    from pyfixit.module_classifier import classify_modules
+
+    imports = get_project_imports(
+        project_directory
+    )
+
+    classified = classify_modules(
+        imports,
+        project_directory
+    )
+
+    declared_dependencies = read_requirements(
+        project_directory
+    )
+
+    third_party_modules = classified[
+        "third_party"
+    ]
+
+    results = diagnose_dependencies(
+        third_party_modules,
+        declared_dependencies
+    )
+
+    unused_dependencies = find_unused_dependencies(
+        imports,
+        declared_dependencies
+    )
+
+    return {
+        "dependencies": results,
+        "unused_dependencies": unused_dependencies
+    }
+
+
+def get_fix_suggestion(result):
+
+    status = result["status"]
+
+    module = result["module"]
+
+    package_name = result.get(
+        "package_name",
+        module
+    )
+
+    if status == "missing_installation":
+
+        return f"pip install {package_name}"
+
+    if status == "missing_declaration_and_installation":
+
+        return (
+            f"Install it with: pip install {package_name}\n"
+            f"Then add '{package_name}' to requirements.txt"
+        )
+
+    if status == "missing_declaration":
+
+        return (
+            f"Add '{package_name}' to requirements.txt"
+        )
+
+    if status == "version_conflict":
+
+        required_version = result["required_version"]
+        operator = result["operator"]
+
+        return (
+            f"pip install "
+            f"{package_name}{operator}{required_version}"
+        )
+
+    if status == "ok":
+
+        return "No action needed"
+
+    return "No fix available"
+
+
+
+def get_diagnosis_summary(diagnosis):
+    dependencies = diagnosis["dependencies"]
+    unused_dependencies = diagnosis["unused_dependencies"]
+
+    problems = 0
+
+    for dependency in dependencies:
+        if dependency["status"] != "ok":
+            problems += 1
+
+    return {
+        "total_dependencies": len(dependencies),
+        "problems": problems,
+        "unused_dependencies": len(unused_dependencies)
+    }

pyfixit/environment.py

@@ -0,0 +1,21 @@
+import sys
+
+
+def get_python_version():
+    return f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+
+
+def get_python_executable():
+    return sys.executable
+
+
+def is_virtual_environment():
+    return sys.prefix != sys.base_prefix
+
+
+def get_environment_info():
+    return {
+        "python_version": get_python_version(),
+        "python_executable": get_python_executable(),
+        "virtual_environment": is_virtual_environment()
+    }