threadcheck 0.0.1__tar.gz

threadcheck-0.0.1/.github/workflows/diagnose_hook.py

@@ -0,0 +1,125 @@
+"""Diagnose import hook pipeline on this Python version.
+
+Tests:
+1. Direct import through hook (proven to work)
+2. Import via spec_from_file_location (mimics pytest import_path)
+"""
+import sys
+import textwrap
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent.parent  # repo root
+sys.path.insert(0, str(REPO))
+sys.path.insert(0, str(REPO / "src"))
+
+print(f"Python: {sys.version}")
+
+# ── prepare helpers ──────────────────────────────────────────────
+tmp_dir = REPO / "tmp_diagnose"
+tmp_dir.mkdir(exist_ok=True)
+
+(new_module := tmp_dir / "diagnose_mod.py").write_text(
+    textwrap.dedent("""\
+        import threading
+        counter = 0
+        def run_racy():
+            global counter
+            def inc():
+                global counter
+                for _ in range(50):
+                    counter += 1
+            threads = [threading.Thread(target=inc) for _ in range(2)]
+            for t in threads:
+                t.start()
+            for t in threads:
+                t.join()
+    """),
+    encoding="utf-8",
+)
+
+(new_test := tmp_dir / "test_diag.py").write_text(
+    textwrap.dedent("""\
+        import sys; print(f"[diag] sys.path={sys.path[:3]}", flush=True)
+        print("[diag] importing diagnose_mod", flush=True)
+        sys.path.insert(0, __file__ and str(type(__file__)))
+        import diagnose_mod
+        _h = hasattr(diagnose_mod, "_threadcheck_tracker")
+        print(f"[diag] has_tracker={_h}", flush=True)
+        def test_diag():
+            diagnose_mod.run_racy()
+    """),
+    encoding="utf-8",
+)
+
+sys.path.insert(0, str(tmp_dir))
+
+from threadcheck.dynamic.hook import install_hook, uninstall_hook
+from threadcheck.dynamic.tracker import ThreadCheckTracker
+import importlib.util
+
+
+# ── Test A: direct import (like diagnose_hook did before) ────────
+print("\n=== Test A: direct import through hook ===")
+hook = install_hook(include_paths=[REPO])
+try:
+    ThreadCheckTracker.start()
+    sys.path.insert(0, str(tmp_dir))
+    import diagnose_mod
+    ok = hasattr(diagnose_mod, "_threadcheck_tracker")
+    print(f"  has _threadcheck_tracker: {ok}")
+    if ok:
+        diagnose_mod.run_racy()
+        races = ThreadCheckTracker.detect_races()
+        print(f"  races detected: {len(races)}")
+    else:
+        # fallback: check meta_path
+        print(f"  sys.meta_path[0]: {type(sys.meta_path[0]).__name__}")
+finally:
+    ThreadCheckTracker.reset()
+    uninstall_hook(hook)
+    sys.modules.pop("diagnose_mod", None)
+
+
+# ── Test B: import via spec_from_file_location (mimics pytest) ───
+print("\n=== Test B: import via spec_from_file_location (pytest-style) ===")
+hook = install_hook(include_paths=[REPO])
+try:
+    ThreadCheckTracker.start()
+
+    # pytest adds test file's parent dir to sys.path
+    sys.path.insert(0, str(tmp_dir))
+
+    # pytest imports test file via spec_from_file_location
+    spec = importlib.util.spec_from_file_location(
+        "test_diag", str(new_test),
+    )
+    mod = importlib.util.module_from_spec(spec)
+    sys.modules["test_diag"] = mod
+    spec.loader.exec_module(mod)
+
+    # now check if diagnose_mod was instrumented
+    diag_mod = sys.modules.get("diagnose_mod")
+    if diag_mod is None:
+        print("  diagnose_mod NOT in sys.modules (hook may not have been called)")
+    else:
+        ok = hasattr(diag_mod, "_threadcheck_tracker")
+        print(f"  diagnose_mod has _threadcheck_tracker: {ok}")
+        if ok:
+            # run the test
+            mod.test_diag()
+            races = ThreadCheckTracker.detect_races()
+            print(f"  races detected: {len(races)}")
+            for var, r1, r2 in races:
+                print(f"    {var}: T{r1.thread_id} {r1.operation} vs T{r2.thread_id} {r2.operation}")
+        else:
+            print("  hook did not instrument diagnose_mod!")
+            print(f"  sys.meta_path[0]: {type(sys.meta_path[0]).__name__}")
+finally:
+    ThreadCheckTracker.reset()
+    uninstall_hook(hook)
+    for m in list(sys.modules.keys()):
+        if m.startswith("diagnose_mod") or m.startswith("test_diag"):
+            sys.modules.pop(m, None)
+
+
+print("\n=== Done ===")

threadcheck-0.0.1/.github/workflows/diagnose_pytest.py

@@ -0,0 +1,206 @@
+"""Diagnose the full pytest plugin flow.
+- Test A: direct import (same process)
+- Test B: subprocess pytest (like the real test)
+"""
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parent.parent.parent  # repo root
+sys.path.insert(0, str(REPO))
+sys.path.insert(0, str(REPO / "src"))
+
+print(f"Python: {sys.version}")
+print(f"REPO: {REPO}")
+
+# ── 1. Create helper module (like test_plugin_detects_race does) ──
+tmp_dir = REPO / "tmp_test_plugin"
+tmp_dir.mkdir(exist_ok=True)
+
+helper = tmp_dir / "race_helpers.py"
+helper.write_text(
+    textwrap.dedent("""\
+        import threading
+        counter = 0
+        def run_racy_increment():
+            global counter
+            threads = []
+            def inc():
+                global counter
+                for _ in range(50):
+                    counter += 1
+            for _ in range(3):
+                t = threading.Thread(target=inc)
+                t.start()
+                threads.append(t)
+            for t in threads:
+                t.join()
+    """),
+    encoding="utf-8",
+)
+
+test_file = tmp_dir / "test_race.py"
+test_file.write_text(
+    textwrap.dedent("""\
+        import sys
+        from race_helpers import run_racy_increment
+        import race_helpers as rh
+        _has = "_threadcheck_tracker" in rh.__dict__
+        print(f"[DBG] has_tracker={_has}", flush=True)
+        if _has:
+            _t = type(rh.__dict__["_threadcheck_tracker"]).__name__
+            print(f"[DBG] tracker_type={_t}", flush=True)
+        def test_race():
+            run_racy_increment()
+    """),
+    encoding="utf-8",
+)
+
+# ═══════════════════════════════════════════════════════════════════
+# Test A: direct import (same process)
+# ═══════════════════════════════════════════════════════════════════
+print("\n" + "=" * 60)
+print("Test A: direct import (same process)")
+print("=" * 60)
+
+sys.path.insert(0, str(tmp_dir))
+
+from threadcheck.dynamic.hook import install_hook, uninstall_hook
+from threadcheck.dynamic.tracker import ThreadCheckTracker
+
+rootpath = REPO
+hook = install_hook(include_paths=[rootpath])
+print(f"include_paths: {[str(p) for p in hook._include_paths]}")
+
+ThreadCheckTracker.start()
+print(f"tracker active: {ThreadCheckTracker._active}")
+
+import importlib
+try:
+    test_mod = importlib.import_module("test_race")
+    print(f"imported: {test_mod}")
+except Exception as e:
+    print(f"import failed: {e}")
+    import traceback; traceback.print_exc()
+    sys.exit(1)
+
+import race_helpers as rh
+has_tracker = hasattr(rh, "_threadcheck_tracker")
+print(f"race_helpers has _threadcheck_tracker: {has_tracker}")
+if not has_tracker:
+    print("  HOOK FAILED!")
+    spec = hook.find_spec("race_helpers", None, None)
+    print(f"  find_spec: {spec}")
+    print(f"  meta_path[0]: {type(sys.meta_path[0]).__name__}")
+    sys.exit(1)
+
+# Show instrumented source of the inc function
+import ast, textwrap as _tw
+_rh_source = Path(__file__).resolve().parent.parent.parent / "tmp_test_plugin" / "race_helpers.py"
+_rh_text = _rh_source.read_text(encoding="utf-8")
+from threadcheck.dynamic.transform import transform_source
+_print_transformed = transform_source(_rh_text, str(_rh_source))
+print("--- transformed source (first 30 lines) ---")
+for _i, _line in enumerate(_print_transformed.splitlines()[:30]):
+    print(f"  {_i+1}: {_line}")
+print("--- end ---")
+
+ThreadCheckTracker.reset_logs()
+test_mod.test_race()
+races = ThreadCheckTracker.detect_races()
+print(f"races detected: {len(races)}")
+for var, r1, r2 in races:
+    print(f"  {var}: T{r1.thread_id} {r1.operation} vs T{r2.thread_id} {r2.operation}")
+
+if not races:
+    print(f"access_log: {dict((k, len(v)) for k, v in ThreadCheckTracker._access_log.items())}")
+    print(f"thread_clocks: {list(ThreadCheckTracker._thread_clocks.keys())}")
+    for var, recs in ThreadCheckTracker._access_log.items():
+        all_tids = set(r.thread_id for r in recs)
+        print(f"  thread_ids in '{var}': {len(all_tids)} unique ids: {all_tids}")
+    # Plain threading test (no instrumentation)
+    import threading as _th
+    _plain_results = []
+    _plain_lock = _th.Lock()
+    _started_tids = []
+    _started_nids = []
+    def _plain_worker():
+        with _plain_lock:
+            _plain_results.append(_th.get_ident())
+    _plain_threads = [_th.Thread(target=_plain_worker) for _ in range(3)]
+    _started_tids = [t.ident for t in _plain_threads]
+    for _t in _plain_threads:
+        _t.start()
+        _started_nids.append(_t.native_id)
+    for _t in _plain_threads:
+        _t.join()
+    print(f"  before_start_tids: {_started_tids}", flush=True)
+    print(f"  after_start_nids: {_started_nids}", flush=True)
+    print(f"  after_join_results: {_plain_results}", flush=True)
+    print(f"  unique_worker_tids: {set(_plain_results)}", flush=True)
+    # Run without closures (top-level import approach)
+    _simple_results2 = []
+    def _simple_worker2():
+        _simple_results2.append(1)
+    _simple_threads2 = [_th.Thread(target=_simple_worker2) for _ in range(3)]
+    for _t in _simple_threads2: _t.start()
+    for _t in _simple_threads2: _t.join()
+    print(f"  closure_worker_count: {len(_simple_results2)} values={_simple_results2}", flush=True)
+    # Absolute simplest: function that takes no closures
+    _worker3_results = []
+    import builtins
+    class _Worker3State:
+        results = _worker3_results
+    def _worker3():
+        _Worker3State.results.append(_th.get_ident())
+    _threads3 = [_th.Thread(target=_worker3) for _ in range(3)]
+    for _t in _threads3: _t.start()
+    for _t in _threads3: _t.join()
+    print(f"  class_attr_results: {_worker3_results}", flush=True)
+
+ThreadCheckTracker.reset()
+uninstall_hook(hook)
+
+# ═══════════════════════════════════════════════════════════════════
+# Test B: subprocess pytest (like the real test)
+# ═══════════════════════════════════════════════════════════════════
+print("\n" + "=" * 60)
+print("Test B: subprocess pytest (like test_plugin_detects_race)")
+print("=" * 60)
+
+# Clean up modules from Test A
+for m in list(sys.modules.keys()):
+    if m in ("test_race", "race_helpers"):
+        sys.modules.pop(m, None)
+
+result = subprocess.run(
+    [sys.executable, "-m", "pytest", str(test_file), "-v", "-s", "--threadcheck"],
+    capture_output=True, text=True, timeout=30,
+    cwd=REPO,
+)
+print(f"returncode: {result.returncode}")
+print(f"--- stdout ---")
+sys.stdout.flush()
+sys.stdout.write(result.stdout)
+sys.stdout.flush()
+if result.stderr:
+    print(f"--- stderr ---")
+    sys.stdout.flush()
+    sys.stdout.write(result.stderr)
+    sys.stdout.flush()
+
+if result.returncode != 0:
+    if "Data races detected" in result.stdout or "Data races detected" in result.stderr:
+        print("\nSUCCESS: subprocess detected race!")
+    else:
+        print(f"\nSubprocess failed but no 'Data races detected'")
+        if "Error" in result.stdout or "error" in result.stderr:
+            print("  (possibly a pytest error)")
+        sys.exit(1)
+else:
+    print("\nSUBPROCESS DID NOT DETECT RACE (exit 0)")
+    sys.exit(1)
+
+# ═══════════════════════════════════════════════════════════════════
+print("\nAll tests passed!")

threadcheck-0.0.1/.github/workflows/release.yml

@@ -0,0 +1,135 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*"
+
+permissions:
+  contents: write
+  id-token: write
+
+jobs:
+  test:
+    name: Test on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: pip install -e ".[test]"
+      - run: python -m pytest tests/ -v
+
+  release:
+    name: Create Release & Publish to PyPI
+    needs: test
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Generate changelog
+        run: |
+          echo "## What's Changed" > release_body.md
+          echo "" >> release_body.md
+
+          PREV_TAG=$(git describe --tags --abbrev=0 HEAD^ 2>/dev/null || true)
+
+          if [ -z "$PREV_TAG" ]; then
+            RANGE="HEAD"
+          else
+            RANGE="${PREV_TAG}..HEAD"
+          fi
+
+          while IFS= read -r ENTRY; do
+            [ -z "$ENTRY" ] && continue
+            MSG="${ENTRY%%|||*}"
+            HASH="${ENTRY##*|||}"
+
+            TYPE="other"
+            case "$MSG" in
+              "feat"*)   TYPE="feat"   ;;
+              "fix"*)    TYPE="fix"    ;;
+              "docs"*)   TYPE="docs"   ;;
+              "style"*)  TYPE="style"  ;;
+              "refactor"*) TYPE="refactor" ;;
+              "perf"*)   TYPE="perf"   ;;
+              "test"*)   TYPE="test"   ;;
+              "ci"*)     TYPE="ci"     ;;
+              "chore"*)  TYPE="chore"  ;;
+              "revert"*) TYPE="revert" ;;
+            esac
+
+            echo "- ${MSG} (\`${HASH}\`)" >> "/tmp/changelog_${TYPE}.txt"
+          done <<< "$(git log ${RANGE} --format='%s|||%h')"
+
+          declare -A LABEL
+          LABEL[feat]="Features"
+          LABEL[fix]="Bug Fixes"
+          LABEL[docs]="Documentation"
+          LABEL[style]="Style"
+          LABEL[refactor]="Refactor"
+          LABEL[perf]="Performance"
+          LABEL[test]="Tests"
+          LABEL[ci]="CI/CD"
+          LABEL[chore]="Chores"
+          LABEL[revert]="Reverts"
+          LABEL[other]="Other"
+
+          for T in feat fix docs refactor perf test ci style chore revert other; do
+            F="/tmp/changelog_${T}.txt"
+            if [ -f "$F" ]; then
+              printf "\n### %s\n\n" "${LABEL[$T]}" >> release_body.md
+              cat "$F" >> release_body.md
+            fi
+          done
+
+      - name: Get repository size
+        id: repo_size
+        run: |
+          SIZE=$(curl -s \
+            -H "Authorization: Bearer ${{ github.token }}" \
+            -H "Accept: application/vnd.github+json" \
+            "https://api.github.com/repos/${{ github.repository }}" \
+            | jq '.size')
+          echo "size=$SIZE" >> "$GITHUB_OUTPUT"
+
+      - name: Build time
+        id: build_time
+        run: |
+          echo "time=$(date -u '+%Y-%m-%d %H:%M:%S UTC')" >> "$GITHUB_OUTPUT"
+
+      - name: Append metadata
+        run: |
+          cat >> release_body.md << EOF
+
+          ---
+          **Build Time:** ${{ steps.build_time.outputs.time }}
+          **Repository Size:** ${{ steps.repo_size.outputs.size }} KB
+          EOF
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build package
+        run: |
+          pip install build
+          python -m build
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          body_path: release_body.md
+          files: dist/*
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

threadcheck-0.0.1/.github/workflows/test.yml

@@ -0,0 +1,37 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Test on Python ${{ matrix.python-version }}
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13", "3.14"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[test]"
+
+      - name: Diagnose import hook
+        run: python .github/workflows/diagnose_hook.py
+
+      - name: Diagnose pytest plugin
+        run: python .github/workflows/diagnose_pytest.py
+
+      - name: Run tests
+        run: python -m pytest tests/ -v --tb=short

threadcheck-0.0.1/.gitignore

@@ -0,0 +1,30 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+
+# OS
+Thumbs.db
+.DS_Store
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+tmp_test_plugin/
+tmp_diagnose/
+.github/tmp_diagnose/
+
+# Lock files
+uv.lock

threadcheck-0.0.1/LICENSE

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