dazpycheck 0.4.0__py3-none-any.whl

dazpycheck/__init__.py

@@ -0,0 +1,11 @@
+# dazpycheck: ignore-banned-words
+"""
+dazpycheck - A tool to check and validate Python code repositories
+
+This tool enforces code quality standards, test coverage, and anti-mocking practices.
+"""
+
+from .main import main, cli
+
+__version__ = "0.4.0"
+__all__ = ["main", "cli"]

dazpycheck/main.py

@@ -0,0 +1,222 @@
+import os
+import subprocess
+import sys
+from multiprocessing import Pool, cpu_count
+import coverage
+import argparse
+import unittest
+
+# dazpycheck: ignore-banned-words
+BANNED_WORDS = ["mock", "fallback", "simulate", "pretend", "fake"]
+BANNED_WORDS_SPIEL = """
+Banned word found. This isn't about specific words - it's about practices. Mocking is always bad.
+Fallbacks are bad - if something fails, we want it to fail, not pretend to work. If you need or
+want a mock in a test, it suggests the structure of your actual code needs improvement. Look at
+your code and see if it can be restructured to separate dependencies so tests can run fast
+without mocks. Focus on creating small, testable functions with clear interfaces.
+"""
+
+
+def run_command(command):
+    try:
+        subprocess.run(command, capture_output=True, text=True, check=True)
+        return True, ""
+    except subprocess.CalledProcessError as e:
+        return False, f"{e.stdout}\n{e.stderr}"
+
+
+def check_banned_words_in_file(file_path):
+    try:
+        with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+            content = f.read()
+            if "dazpycheck: ignore-banned-words" in content:
+                return True, ""
+            lines = content.splitlines()
+            for line_num, line in enumerate(lines, 1):
+                for word in BANNED_WORDS:
+                    if word in line:
+                        return (
+                            False,
+                            f"{file_path}:{line_num}: Banned word '{word}' found.\n{BANNED_WORDS_SPIEL}",
+                        )
+    except Exception:
+        pass  # Ignore files that can't be read
+    return True, ""
+
+
+def compile_file(file_path):
+    return run_command(["python", "-m", "py_compile", file_path])
+
+
+def run_test_on_file(file_path):
+    source_file = file_path.replace("_test.py", ".py")
+    if not os.path.exists(source_file):
+        return (
+            False,
+            f"Test file {file_path} exists but corresponding source file {source_file} does not.",
+        )
+
+    # Add the directory of the test file to the python path
+    sys.path.insert(0, os.path.dirname(file_path))
+
+    cov = coverage.Coverage(source=[source_file])
+    cov.start()
+
+    # Try pytest first, then fall back to unittest
+    pytest_success, pytest_message = run_command(
+        ["python", "-m", "pytest", file_path, "-q", "--tb=no"]
+    )
+
+    if not pytest_success:
+        # Try unittest as fallback
+        suite = unittest.TestLoader().discover(
+            start_dir=os.path.dirname(file_path), pattern=os.path.basename(file_path)
+        )
+        result = unittest.TextTestRunner(
+            failfast=True, stream=open(os.devnull, "w")
+        ).run(suite)
+        if not result.wasSuccessful():
+            cov.stop()
+            sys.path.pop(0)
+            return (
+                False,
+                f"Tests failed in {file_path} (tried both pytest and unittest)",
+            )
+
+    cov.stop()
+    cov.save()
+
+    try:
+        filename, statements, excluded, missing, formatted = cov.analysis2(source_file)
+        total_statements = len(statements)
+        executed_statements = total_statements - len(missing)
+        coverage_percentage = (
+            (executed_statements / total_statements) * 100
+            if total_statements > 0
+            else 100
+        )
+    except coverage.misc.NoSource:
+        sys.path.pop(0)
+        return (
+            False,
+            f"Coverage data not available for {source_file}. Module may not have been imported.",
+        )
+
+    if coverage_percentage < 50:
+        sys.path.pop(0)
+        return (
+            False,
+            f"Coverage for {source_file} is {coverage_percentage:.2f}%, which is less than 50%.",
+        )
+
+    # Remove the directory from the python path
+    sys.path.pop(0)
+
+    return True, ""
+
+
+def main(directory, fix, single_thread, full):
+    if fix:
+        run_command(["python3", "-m", "black", directory])
+
+    py_files = []
+    test_files = []
+    for root, dirs, files in os.walk(directory):
+        # Skip build, dist, and cache directories
+        dirs[:] = [
+            d
+            for d in dirs
+            if d not in ("__pycache__", "build", "dist", ".git", ".pytest_cache")
+        ]
+        for file in files:
+            if file.endswith(".py"):
+                py_files.append(os.path.join(root, file))
+            if file.endswith("_test.py"):
+                test_files.append(os.path.join(root, file))
+
+    # Initial scan for missing tests and banned words
+    has_errors = False
+    for py_file in py_files:
+        if not py_file.endswith("_test.py"):
+            # Skip setup.py, __init__.py, and build directory
+            if (
+                py_file.endswith("/setup.py")
+                or py_file == "setup.py"
+                or py_file.endswith("/__init__.py")
+                or "/build/" in py_file
+            ):
+                continue
+            test_file = py_file.replace(".py", "_test.py")
+            if not os.path.exists(test_file):
+                has_errors = True
+                print(f"Missing test file for {py_file}", file=sys.stderr)
+                if not full:
+                    return 1
+
+        success, message = check_banned_words_in_file(py_file)
+        if not success:
+            has_errors = True
+            print(message, file=sys.stderr)
+            if not full:
+                return 1
+
+    # Parallelizable jobs
+    jobs = []
+    jobs.append(
+        (run_command, ["python3", "-m", "flake8", "--max-line-length=120", directory])
+    )
+    for py_file in py_files:
+        jobs.append((compile_file, py_file))
+    for test_file in test_files:
+        jobs.append((run_test_on_file, test_file))
+
+    if single_thread:
+        for job, *args in jobs:
+            success, message = job(*args)
+            if not success:
+                has_errors = True
+                print(message, file=sys.stderr)
+                if not full:
+                    return 1
+    else:
+        with Pool(processes=cpu_count()) as pool:
+            results = []
+            for job_func, *args in jobs:
+                result = pool.apply_async(job_func, args)
+                results.append(result)
+            for result in results:
+                success, message = result.get()
+                if not success:
+                    has_errors = True
+                    print(message, file=sys.stderr)
+                    if not full:
+                        return 1
+
+    return 1 if has_errors else 0
+
+
+def cli():
+    parser = argparse.ArgumentParser(
+        description="A tool to check and validate a Python code repository."
+    )
+    parser.add_argument(
+        "--full", action="store_true", help="Run all checks regardless of failures."
+    )
+    parser.add_argument(
+        "--readonly",
+        action="store_true",
+        help="Only check for issues, don't modify files.",
+    )
+    parser.add_argument(
+        "--single-thread", action="store_true", help="Run checks sequentially."
+    )
+    parser.add_argument(
+        "directory",
+        nargs="?",
+        default=".",
+        help="The directory to check (default: current directory).",
+    )
+
+    args = parser.parse_args()
+
+    sys.exit(main(args.directory, not args.readonly, args.single_thread, args.full))

dazpycheck/main_test.py

@@ -0,0 +1,99 @@
+# dazpycheck: ignore-banned-words
+import os
+import shutil
+import unittest
+from dazpycheck.main import (
+    check_banned_words_in_file,
+    compile_file,
+    run_test_on_file,
+    main,
+)
+
+
+class TestDazpycheck(unittest.TestCase):
+
+    def setUp(self):
+        self.output_dir = "output"
+        self.test_project_dir = os.path.join(self.output_dir, "test_project")
+        os.makedirs(self.test_project_dir, exist_ok=True)
+
+    def tearDown(self):
+        shutil.rmtree(self.output_dir)
+
+    def test_check_banned_words_in_file(self):
+        file_path = os.path.join(self.test_project_dir, "bad_file.py")
+        with open(file_path, "w") as f:
+            f.write("print('This is a mock file.')\n")
+        success, message = check_banned_words_in_file(file_path)
+        print(f"Success: {success}, Message: {message}")
+        self.assertFalse(success)
+        self.assertIn("Banned word 'mock' found", message)
+
+    def test_check_banned_words_in_file_ignored(self):
+        file_path = os.path.join(self.test_project_dir, "bad_file_ignored.py")
+        with open(file_path, "w") as f:
+            f.write("# dazpycheck: ignore-banned-words\n")
+            f.write("print('This is a mock file.')\n")
+        success, message = check_banned_words_in_file(file_path)
+        self.assertTrue(success)
+
+    def test_compile_file(self):
+        file_path = os.path.join(self.test_project_dir, "good_file.py")
+        with open(file_path, "w") as f:
+            f.write("print('Hello, world!')\n")
+        success, message = compile_file(file_path)
+        self.assertTrue(success)
+
+    def test_compile_file_with_error(self):
+        file_path = os.path.join(self.test_project_dir, "bad_file.py")
+        with open(file_path, "w") as f:
+            f.write("print('Hello, world!\n")
+        success, message = compile_file(file_path)
+        self.assertFalse(success)
+
+    def test_run_test_on_file_with_low_coverage(self):
+        source_file = os.path.join(self.test_project_dir, "my_module.py")
+        test_file = os.path.join(self.test_project_dir, "my_module_test.py")
+        with open(source_file, "w") as f:
+            f.write(
+                "def my_function():\n    return 1\n\n\ndef another_function():\n    return 2\n"
+            )
+        with open(test_file, "w") as f:
+            f.write(
+                "import unittest\nfrom my_module import my_function\n\n\n"
+                "class MyTest(unittest.TestCase):\n    def test_my_function(self):\n"
+                "        self.assertEqual(my_function(), 1)\n"
+            )
+        success, message = run_test_on_file(test_file)
+        self.assertFalse(success)
+        self.assertIn("less than 50%", message)
+
+    def test_integration_main(self):
+        # This is an integration test that runs the main function
+        # with a project that has multiple issues.
+        source_file = os.path.join(self.test_project_dir, "my_module.py")
+        test_file = os.path.join(self.test_project_dir, "my_module_test.py")
+        with open(source_file, "w") as f:
+            f.write(
+                "def my_function():\n    return 1\n\ndef another_function():\n    return 2\n"
+            )
+        with open(test_file, "w") as f:
+            f.write(
+                "import unittest\nfrom my_module import my_function\n\n"
+                "class MyTest(unittest.TestCase):\n    def test_my_function(self):\n"
+                "        self.assertEqual(my_function(), 1)\n"
+            )
+        with open(os.path.join(self.test_project_dir, "bad_file.py"), "w") as f:
+            f.write("print('This is a mock file.')\n")
+
+        # Fail fast should stop after the first error
+        result = main(self.test_project_dir, False, True, False)
+        self.assertEqual(result, 1)
+
+        # Full run should report all errors
+        result = main(self.test_project_dir, False, True, True)
+        self.assertEqual(result, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()

dazpycheck-0.4.0.dist-info/METADATA

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: dazpycheck
+Version: 0.4.0
+Summary: A tool to check and validate a Python code repository.
+Author-email: Darren Oakey <darren@oakey.net>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# dazpycheck: Your AI Code's Quality Guardian
+
+![dazpycheck banner](output/banner.png)
+
+**dazpycheck** is a powerful and comprehensive tool for ensuring your Python code is clean, correct, and consistent. It's especially useful for checking code generated by AI, which can sometimes take shortcuts or introduce subtle errors.
+
+## Why dazpycheck?
+
+AI is a powerful tool, but it's not perfect. AI-generated code can sometimes be messy, inefficient, or even contain bugs. `dazpycheck` helps you catch these issues before they become problems. It's the perfect last step in your development workflow to ensure your code is production-ready.
+
+![dazpycheck logo](output/logo.png)
+
+## Features
+
+*   **All-in-One Checking:** dazpycheck integrates `black` for formatting, `flake8` for linting, `pyright` for type checking, and `py_compile` for compilation, giving you a complete picture of your code's health.
+*   **Automated Fixing:** By default, `dazpycheck` will automatically fix formatting issues. Use the `--readonly` flag to see what would be changed without modifying any files.
+*   **Banned Words Enforcement:** Define a list of "banned words" to enforce your own coding standards. `dazpycheck` will scan your entire repository and flag any occurrences of these words.
+*   **Parallel Execution:** `dazpycheck` runs all readonly checks in parallel, making it fast and efficient, even on large codebases.
+*   **Integrated Test Runner:** By default, `dazpycheck` will run all your `unittest` and `pytest` tests. Use the `--no-test` flag to skip testing.
+
+![Parallel Checks](output/parallel_checks.png)
+
+## Installation
+
+`dazpycheck` is available on PyPI. You can install it using `pip`:
+
+```bash
+pip install dazpycheck
+```
+
+## Usage
+
+Once installed, you can run `dazpycheck` from anywhere on your system:
+
+```bash
+dazpycheck
+```
+
+This will run all checks and tests on the current directory. You can also specify a directory:
+
+```bash
+dazpycheck /path/to/your/project
+```
+
+### Options
+
+*   `--readonly`: Only check for issues, don't modify files.
+*   `--no-test`: Skip running tests.
+*   `--single-thread`: Run checks sequentially.
+*   `--full`: Run all checks regardless of failures.
+
+![Banned Words](output/banned_words.png)
+
+We hope you find `dazpycheck` to be a valuable addition to your development workflow!

dazpycheck-0.4.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+dazpycheck/__init__.py,sha256=9C9LMndxieKt8YrCA5PPGiwCMjGKfcWBrP79FEi7pXE,274
+dazpycheck/main.py,sha256=yie6YsDgWCGOI2yRaXUoPxvIgDRhRlYYZDVDR1XVgrw,7291
+dazpycheck/main_test.py,sha256=IMYLSUH9kKUWP9-NlAWjTiYgEAgIyM8wP-4BPgp9RJE,3945
+dazpycheck-0.4.0.dist-info/METADATA,sha256=ulqo3HUWu-oziPnVc9zWA3heR0z-c9WQe8LBSvrHAys,2684
+dazpycheck-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dazpycheck-0.4.0.dist-info/entry_points.txt,sha256=oo17m7-EPI_ac2Yv4aJaZAziv9B0x1f78wE4qbWadF4,51
+dazpycheck-0.4.0.dist-info/top_level.txt,sha256=FYXWrnnS8ScPGFGy-SUx4yr_GIgGYUq2FtRHic3dgWA,11
+dazpycheck-0.4.0.dist-info/RECORD,,

dazpycheck-0.4.0.dist-info/WHEEL

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

dazpycheck-0.4.0.dist-info/entry_points.txt

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

dazpycheck-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dazpycheck