cr-proc 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

code_recorder_processor/display.py

@@ -0,0 +1,201 @@
+"""Display utilities for CLI output."""
+import sys
+from datetime import datetime
+from typing import Any
+
+
+def display_time_info(time_info: dict[str, Any] | None, is_combined: bool = False) -> None:
+    """
+    Display elapsed time and time limit information.
+
+    Parameters
+    ----------
+    time_info : dict[str, Any] | None
+        Time information from check_time_limit, or None if no time data
+    is_combined : bool
+        Whether this is combined time info from multiple files
+    """
+    if not time_info:
+        return
+
+    if is_combined:
+        file_count = time_info.get("file_count", 1)
+        print(f"\nCOMBINED TIME REPORT ({file_count} recordings):", file=sys.stderr)
+        print(f"Total elapsed editing time: {time_info['minutes_elapsed']} minutes", file=sys.stderr)
+        print(f"Overall time span: {time_info['overall_span_minutes']:.2f} minutes", file=sys.stderr)
+    else:
+        print(
+            f"Elapsed editing time: {time_info['minutes_elapsed']} minutes",
+            file=sys.stderr,
+        )
+
+        first_ts = datetime.fromisoformat(
+            time_info["first_timestamp"].replace("Z", "+00:00")
+        )
+        last_ts = datetime.fromisoformat(
+            time_info["last_timestamp"].replace("Z", "+00:00")
+        )
+        time_span = (last_ts - first_ts).total_seconds() / 60
+
+        print(f"Time span (first to last edit): {time_span:.2f} minutes", file=sys.stderr)
+
+    if time_info["exceeds_limit"]:
+        print("\nTime limit exceeded!", file=sys.stderr)
+        print(f"  Limit: {time_info['time_limit_minutes']} minutes", file=sys.stderr)
+        if not is_combined:
+            print(f"  First edit: {time_info['first_timestamp']}", file=sys.stderr)
+            print(f"  Last edit: {time_info['last_timestamp']}", file=sys.stderr)
+
+
+def display_suspicious_event(event: dict[str, Any], show_details: bool) -> None:
+    """
+    Display a single suspicious event.
+
+    Parameters
+    ----------
+    event : dict[str, Any]
+        Suspicious event data
+    show_details : bool
+        Whether to show detailed autocomplete events
+    """
+    reason = event.get("reason", "unknown")
+
+    # Handle aggregate auto-complete events
+    if event.get("event_index") == -1 and "detailed_events" in event:
+        event_count = event["event_count"]
+        total_chars = event["total_chars"]
+        print(
+            f"  Aggregate: {event_count} auto-complete/small paste events "
+            f"({total_chars} total chars)",
+            file=sys.stderr,
+        )
+
+        if show_details:
+            print("    Detailed events:", file=sys.stderr)
+            for detail in event["detailed_events"]:
+                detail_idx = detail["event_index"]
+                detail_lines = detail["line_count"]
+                detail_chars = detail["char_count"]
+                detail_frag = detail["newFragment"]
+                print(
+                    f"      Event #{detail_idx}: {detail_lines} lines, "
+                    f"{detail_chars} chars",
+                    file=sys.stderr,
+                )
+                print("        ```", file=sys.stderr)
+                for line in detail_frag.split("\n"):
+                    print(f"        {line}", file=sys.stderr)
+                print("        ```", file=sys.stderr)
+
+    elif "event_indices" in event and reason == "rapid one-line pastes (AI indicator)":
+        # Rapid paste sequences (AI indicator) - show aggregate style
+        indices = event["event_indices"]
+        print(
+            f"  AI Rapid Paste: Events #{indices[0]}-#{indices[-1]} "
+            f"({event['line_count']} lines, {event['char_count']} chars, "
+            f"{len(indices)} events in < 1 second)",
+            file=sys.stderr,
+        )
+
+        if show_details and "detailed_events" in event:
+            # Combine all detailed events into one block
+            combined_content = "".join(
+                detail["newFragment"] for detail in event["detailed_events"]
+            )
+            print("    Combined output:", file=sys.stderr)
+            print("        ```", file=sys.stderr)
+            for line in combined_content.split("\n"):
+                print(f"        {line}", file=sys.stderr)
+            print("        ```", file=sys.stderr)
+
+    elif "event_indices" in event:
+        # Other multi-event clusters
+        indices = event.get("event_indices", [event["event_index"]])
+        print(
+            f"  Events #{indices[0]}-#{indices[-1]} ({reason}): "
+            f"{event['line_count']} lines, {event['char_count']} chars",
+            file=sys.stderr,
+        )
+
+    else:
+        new_fragment = event["newFragment"].replace("\n", "\n    ")
+        print(
+            f"  Event #{event['event_index']} ({reason}): "
+            f"{event['line_count']} lines, {event['char_count']} chars - "
+            f"newFragment:\n    ```\n    {new_fragment}\n    ```",
+            file=sys.stderr,
+        )
+
+
+def display_suspicious_events(
+    suspicious_events: list[dict[str, Any]], show_details: bool
+) -> None:
+    """
+    Display all suspicious events or success message.
+
+    Parameters
+    ----------
+    suspicious_events : list[dict[str, Any]]
+        List of suspicious events detected
+    show_details : bool
+        Whether to show detailed autocomplete events
+    """
+    if suspicious_events:
+        print("\nSuspicious events detected:", file=sys.stderr)
+
+        # Sort events by their index for chronological display
+        def get_sort_key(event: dict[str, Any]) -> int | float:
+            if "event_indices" in event and event["event_indices"]:
+                return event["event_indices"][0]
+            if "detailed_events" in event and event["detailed_events"]:
+                return event["detailed_events"][0].get("event_index", float("inf"))
+            event_idx = event.get("event_index", -1)
+            return event_idx if event_idx >= 0 else float("inf")
+
+        sorted_events = sorted(suspicious_events, key=get_sort_key)
+
+        for event in sorted_events:
+            display_suspicious_event(event, show_details)
+    else:
+        print("Success! No suspicious events detected.", file=sys.stderr)
+
+
+def display_template_diff(diff_text: str) -> None:
+    """
+    Display template diff output when verification fails.
+
+    Parameters
+    ----------
+    diff_text : str
+        Unified diff text between template and initial snapshot
+    """
+    if not diff_text:
+        return
+
+    print("\nTemplate mismatch diff:", file=sys.stderr)
+    print(diff_text, file=sys.stderr)
+
+
+def print_separator() -> None:
+    """Print a separator line."""
+    print(f"{'='*80}", file=sys.stderr)
+
+
+def print_batch_header(current: int, total: int, filename: str) -> None:
+    """Print a batch processing header for a file."""
+    print_separator()
+    print(f"[{current}/{total}] Processing: {filename}", file=sys.stderr)
+    print_separator()
+
+
+def print_batch_summary(total: int, verified_count: int, failed_files: list[str]) -> None:
+    """Print a summary of batch processing results."""
+    print_separator()
+    print(f"BATCH SUMMARY: Processed {total} files", file=sys.stderr)
+    print_separator()
+    print(f"Verified: {verified_count}/{total}", file=sys.stderr)
+
+    if failed_files:
+        print("\nFailed files:", file=sys.stderr)
+        for filename in failed_files:
+            print(f"  - {filename}", file=sys.stderr)

code_recorder_processor/playback.py

@@ -0,0 +1,116 @@
+"""Playback functionality for viewing code evolution."""
+import os
+import sys
+import time
+from datetime import datetime
+from typing import Any
+
+
+def playback_recording(
+    json_data: tuple[dict[str, Any], ...],
+    document: str,
+    template: str,
+    speed: float = 1.0,
+) -> None:
+    """
+    Play back a recording, showing the code evolving in real-time.
+
+    Only plays back edit events (type="edit" or no type field for backwards compatibility).
+
+    Parameters
+    ----------
+    json_data : tuple[dict[str, Any], ...]
+        The recording events (all event types)
+    document : str
+        The document to play back
+    template : str
+        The initial template content
+    speed : float
+        Playback speed multiplier (1.0 = real-time, 2.0 = 2x speed, 0.5 = half speed)
+    """
+    # Filter to only edit events (backwards compatible)
+    from .api.load import is_edit_event
+    edit_events = [e for e in json_data if is_edit_event(e)]
+
+    # Filter events for the target document
+    doc_events = [e for e in edit_events if e.get("document") == document]
+
+    if not doc_events:
+        print(f"No events found for document: {document}", file=sys.stderr)
+        return
+
+    # Start with template
+    current_content = template
+    last_timestamp = None
+
+    def clear_screen():
+        """Clear the terminal screen."""
+        os.system('cls' if os.name == 'nt' else 'clear')
+
+    def parse_timestamp(ts_str: str) -> datetime:
+        """Parse ISO timestamp string."""
+        return datetime.fromisoformat(ts_str.replace("Z", "+00:00"))
+
+    # Show initial template
+    clear_screen()
+    print(f"=" * 80)
+    print(f"PLAYBACK: {document} (Speed: {speed}x)")
+    print(f"Event 0 / {len(doc_events)} - Initial Template")
+    print(f"=" * 80)
+    print(current_content)
+    print(f"\n{'=' * 80}")
+    print("Press Ctrl+C to stop playback")
+    time.sleep(2.0 / speed)
+
+    try:
+        for idx, event in enumerate(doc_events, 1):
+            old_frag = event.get("oldFragment", "")
+            new_frag = event.get("newFragment", "")
+            offset = event.get("offset", 0)
+            timestamp = event.get("timestamp")
+
+            # Calculate delay based on timestamp difference
+            if last_timestamp and timestamp:
+                try:
+                    ts1 = parse_timestamp(last_timestamp)
+                    ts2 = parse_timestamp(timestamp)
+                    delay = (ts2 - ts1).total_seconds() / speed
+                    # Cap delay at 5 seconds for very long pauses
+                    delay = min(delay, 5.0)
+                    if delay > 0:
+                        time.sleep(delay)
+                except (ValueError, KeyError):
+                    time.sleep(0.1 / speed)
+            else:
+                time.sleep(0.1 / speed)
+
+            last_timestamp = timestamp
+
+            # Apply the edit
+            if new_frag != old_frag:
+                current_content = current_content[:offset] + new_frag + current_content[offset + len(old_frag):]
+
+            # Display current state
+            clear_screen()
+            print(f"=" * 80)
+            print(f"PLAYBACK: {document} (Speed: {speed}x)")
+            print(f"Event {idx} / {len(doc_events)} - {timestamp or 'unknown time'}")
+
+            # Show what changed
+            if new_frag != old_frag:
+                change_type = "INSERT" if not old_frag else ("DELETE" if not new_frag else "REPLACE")
+                print(f"Action: {change_type} at offset {offset} ({len(new_frag)} chars)")
+
+            print(f"=" * 80)
+            print(current_content)
+            print(f"\n{'=' * 80}")
+            print(f"Progress: [{('#' * (idx * 40 // len(doc_events))).ljust(40)}] {idx}/{len(doc_events)}")
+            print("Press Ctrl+C to stop playback")
+
+    except KeyboardInterrupt:
+        print("\n\nPlayback stopped by user.", file=sys.stderr)
+        return
+
+    # Final summary
+    print("\n\nPlayback complete!", file=sys.stderr)
+    print(f"Total events: {len(doc_events)}", file=sys.stderr)

cr_proc-0.1.9.dist-info/METADATA

@@ -0,0 +1,280 @@
+Metadata-Version: 2.4
+Name: cr_proc
+Version: 0.1.9
+Summary: A tool for processing BYU CS code recording files.
+Author: Ethan Dye
+Author-email: mrtops03@gmail.com
+Requires-Python: >=3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: py-jsonl (>=1.3.22,<2.0.0)
+Description-Content-Type: text/markdown
+
+# `code_recorder_processor`
+
+[![CI](https://github.com/BYU-CS-Course-Ops/code_recorder_processor/actions/workflows/ci.yml/badge.svg)](https://github.com/BYU-CS-Course-Ops/code_recorder_processor/actions/workflows/ci.yml)
+
+This contains code to process and verify the `*.recorder.jsonl.gz` files that
+are produced by the
+[jetbrains-recorder](https://github.com/BYU-CS-Course-Ops/jetbrains-recorder).
+
+## Installation
+
+Install the package and its dependencies using Poetry:
+
+```bash
+poetry install
+```
+
+## Usage
+
+The processor can be run using the `cr_proc` command with recording file(s) and a template:
+
+```bash
+poetry run cr_proc <path-to-jsonl-file> <path-to-template-file>
+```
+
+### Batch Processing
+
+You can process multiple recording files at once (e.g., for different students' submissions):
+
+```bash
+# Process multiple files
+poetry run cr_proc file1.jsonl.gz file2.jsonl.gz template.py
+
+# Using glob patterns
+poetry run cr_proc recordings/*.jsonl.gz template.py
+```
+
+When processing multiple files:
+- Each recording is processed independently (for different students/documents)
+- Time calculations and verification are done separately for each file
+- A combined time report is shown at the end summarizing total editing time across all recordings
+- Results can be output to individual files using `--output-dir`
+
+### Arguments
+
+- `<path-to-jsonl-file>`: Path(s) to compressed JSONL file(s)
+  (`*.recorder.jsonl.gz`) produced by the jetbrains-recorder. Supports multiple
+  files and glob patterns like `recordings/*.jsonl.gz`
+- `<path-to-template-file>`: Path to the initial template file that was recorded
+
+### Options
+
+- `-t, --time-limit MINUTES`: (Optional) Maximum allowed time in minutes between the
+  first and last edit in the recording. Applied individually to each recording file and
+  also to the combined total in batch mode. If the elapsed time exceeds this limit, the
+  recording is flagged as suspicious.
+- `-d, --document DOCUMENT`: (Optional) Document path or filename to process from the
+  recording. Defaults to the document whose extension matches the template file.
+- `-o, --output-json OUTPUT_JSON`: (Optional) Path to output JSON file with verification
+  results (time info and suspicious events). In batch mode, creates a single JSON file
+  containing all recordings plus the combined time report.
+- `-f, --output-file OUTPUT_FILE`: (Optional) Write reconstructed code to specified file
+  instead of stdout. For single files only.
+- `--output-dir OUTPUT_DIR`: (Optional) Directory to write reconstructed code files in
+  batch mode. Files are named based on input recording filenames.
+- `-s, --show-autocomplete-details`: (Optional) Show individual auto-complete events in
+  addition to aggregate statistics.
+- `-p, --playback`: (Optional) Play back the recording in real-time, showing code evolution.
+- `--playback-speed SPEED`: (Optional) Playback speed multiplier (1.0 = real-time, 2.0 = 2x
+  speed, 0.5 = half speed).
+
+### Examples
+
+Basic usage:
+
+```bash
+poetry run cr_proc homework0.recording.jsonl.gz homework0.py
+```
+
+With time limit flag:
+
+```bash
+poetry run cr_proc homework0.recording.jsonl.gz homework0.py --time-limit 30
+```
+
+Batch processing with output directory:
+
+```bash
+poetry run cr_proc recordings/*.jsonl.gz template.py --output-dir output/
+```
+
+Save JSON results:
+
+```bash
+poetry run cr_proc student1.jsonl.gz student2.jsonl.gz template.py -o results/
+```
+
+This will process each recording independently and flag any that exceed 30 minutes.
+
+The processor will:
+
+1. Load the recorded events from the JSONL file
+2. Verify that the initial event matches the template (allowances for newline
+   differences are made)
+3. Reconstruct the final file state by applying all recorded events
+4. Output the reconstructed file contents to stdout
+
+### Output
+
+Reconstructed code files are written to disk using `-f/--output-file` (single file)
+or `--output-dir` (batch mode). The processor does not output reconstructed code to stdout.
+
+Verification information, warnings, and errors are printed to stderr, including:
+
+- The document path being processed
+- Time information (elapsed time, time span) for each recording
+- Suspicious copy-paste and AI activity indicators for each file
+- Batch summary showing:
+  - Verification status of all processed files
+  - Combined time report (total editing time across all recordings)
+  - Time limit violations if applicable
+
+### Suspicious Activity Detection
+
+The processor automatically detects and reports three types of suspicious activity
+patterns:
+
+#### 1. Time Limit Exceeded
+
+When the `--time-limit` flag is specified, the processor flags recordings where
+the elapsed time between the first and last edit exceeds the specified limit.
+This can indicate unusually long work sessions or potential external assistance.
+
+Each recording file is checked independently against the time limit. In batch mode,
+the combined total time is also checked against the limit.
+
+**Example warning (single file):**
+
+```
+Elapsed editing time: 45.5 minutes
+Time span (first to last edit): 62.30 minutes
+
+Time limit exceeded!
+  Limit: 30 minutes
+  First edit: 2025-01-15T10:00:00+00:00
+  Last edit: 2025-01-15T11:02:18+00:00
+```
+
+**Example warning (batch mode combined report):**
+
+```
+================================================================================
+BATCH SUMMARY: Processed 3 files
+================================================================================
+Verified: 3/3
+
+COMBINED TIME REPORT (3 recordings):
+Total elapsed editing time: 65.5 minutes
+Overall time span: 120.45 minutes
+
+Time limit exceeded!
+  Limit: 60 minutes
+```
+
+#### 2. External Copy-Paste (Multi-line Pastes)
+
+The processor flags multi-line additions (more than one line) that do not appear
+to be copied from within the document itself. These indicate content pasted from
+external sources.
+
+**Example warning:**
+
+```
+Event #15 (multi-line external paste): 5 lines, 156 chars - newFragment: def helper_function():...
+```
+
+#### 3. Rapid One-line Pastes (AI Indicator)
+
+When 3 or more single-line pastes occur within a 1-second window, this is
+flagged as a potential AI activity indicator. Human typing does not typically
+produce this pattern; rapid sequential pastes suggest automated code generation.
+
+**Example warning:**
+
+```
+Events #42-#44 (rapid one-line pastes (AI indicator)): 3 lines, 89 chars
+```
+
+### JSON Output Format
+
+The `--output-json` flag generates JSON files with verification results using a consistent format
+for both single file and batch modes, making it easier for tooling to consume.
+
+#### JSON Structure
+
+All JSON output follows this unified format:
+- `batch_mode`: Boolean indicating if multiple files were processed
+- `total_files`: Number of files processed
+- `verified_count`: How many files passed verification
+- `all_verified`: Whether all files passed
+- `combined_time_info`: Time information (present in both modes):
+  - Single file: Contains time info for that file
+  - Batch mode: Contains combined time report with:
+    - `minutes_elapsed`: Total editing time across all recordings
+    - `overall_span_minutes`: Time span from first to last edit
+    - `file_count`: Number of recordings
+    - `exceeds_limit`: Whether combined time exceeds the limit
+- `files`: Array of individual results for each recording
+
+**Single file example:**
+```json
+{
+  "batch_mode": false,
+  "total_files": 1,
+  "verified_count": 1,
+  "all_verified": true,
+  "combined_time_info": {
+    "minutes_elapsed": 15.74,
+    "first_timestamp": "2026-01-15T01:21:35.360168Z",
+    "exceeds_limit": false
+  },
+  "files": [
+    {
+      "jsonl_file": "recording.jsonl.gz",
+      "document": "/path/to/homework.py",
+      "verified": true,
+      "time_info": { ... },
+      "suspicious_events": [ ... ],
+      "reconstructed_code": "..."
+    }
+  ]
+}
+```
+
+**Batch file example:**
+```json
+{
+  "batch_mode": true,
+  "total_files": 2,
+  "verified_count": 2,
+  "all_verified": true,
+  "combined_time_info": {
+    "minutes_elapsed": 31.24,
+    "overall_span_minutes": 18739.29,
+    "file_count": 2,
+    "exceeds_limit": false
+  },
+  "files": [ /* individual results for each file */ ]
+}
+```
+
+### Error Handling
+
+If verification fails (the recorded initial state doesn't match the template),
+the processor will:
+
+- Print an error message to stderr
+- Display a diff showing the differences
+- Exit with status code 1
+
+If file loading or processing errors occur, the processor will:
+
+- Print a descriptive error message to stderr
+- Exit with status code 1
+
+## Future Ideas
+
+- Check for odd typing behavior
+

cr_proc-0.1.9.dist-info/RECORD

@@ -0,0 +1,13 @@
+code_recorder_processor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+code_recorder_processor/api/build.py,sha256=tljtuEFH-ZU-hSFYmlAMSY61W-DSptQo_D5-GjAasco,7951
+code_recorder_processor/api/document.py,sha256=mBvATBZs8yyCY_nDOX2qhw0Gp1mmwI3PgOAzFgHUiSY,9486
+code_recorder_processor/api/load.py,sha256=Br-USpFQJ6W8c5hjmCnunM3V0_MURKZp5Yyl1IJdahc,5514
+code_recorder_processor/api/output.py,sha256=H2SC3pQ0C9V8YyN4yeA_KmvSoWXy_3T3TKWKhywIax4,2161
+code_recorder_processor/api/verify.py,sha256=9GpeoFQIiTzZd-DNSyN5OUM6YB5iMslO85oAjc0yoSU,34073
+code_recorder_processor/cli.py,sha256=ardcM3bLNhf6abOQ1Aj746x4hp8gerdklfDwszLlYKc,20504
+code_recorder_processor/display.py,sha256=IVTNFB3Vjzpc5ZHceAFQI2-o-N6bvjYmotLDaEy0KoU,7368
+code_recorder_processor/playback.py,sha256=6-OJtQOHKgfutxUNBMunWl-VVSIB0zUDENSl0EsPCh4,4008
+cr_proc-0.1.9.dist-info/METADATA,sha256=3yqgqvpe1juNoinP6Xn59UiowZen06mgFTh1eG2ZC8M,8915
+cr_proc-0.1.9.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+cr_proc-0.1.9.dist-info/entry_points.txt,sha256=xb5dPAAWN1Z9NUHpvZgNakaslR1MVOERf_IfpG_M04M,77
+cr_proc-0.1.9.dist-info/RECORD,,