TestResults

Enhanced test results container with rich reporting and analysis capabilities.

USAGE
TestResults(results, test_config=None, violation_records=None)

TestResults provides comprehensive analysis and reporting capabilities for avoid topics testing
results, including interactive HTML representations, statistical summaries, violation analysis,
and export functionality. The class is designed to support both programmatic analysis and
interactive exploration in Jupyter notebooks and development
environments.

**Rich Reporting**: provides beautiful HTML representations optimized for Jupyter notebooks with
interactive visualizations, summary statistics, and detailed violation analysis. The HTML output
includes configuration details, compliance metrics, and conversation transcripts for
comprehensive review.

**Statistical Analysis**: Includes comprehensive summary statistics covering compliance rates,
violation counts, topic and strategy breakdowns, timing analysis, and success metrics. Summary
data supports both quick overview and detailed performance analysis.

**Export Capabilities**: Supports export to pandas DataFrames and Great Tables for further
analysis, reporting, and integration with data science workflows. Export functions handle
optional dependencies gracefully with clear error messages.

**Interactive Access**: Implements standard Python container protocols (iteration, indexing,
length) for easy programmatic access to individual conversation results while maintaining the
reporting capabilities for interactive use.

Parameters

results
    List of ConversationResult objects containing individual test outcomes. Each result includes
    conversation details, violation information, timing data, and metadata from the testing
    process.
test_config
    Dictionary containing test configuration parameters including intensity level, target bot
    configuration, testing strategies used, and other metadata from the testing session. Used
    for context in reporting.
violation_records
    List of ViolationRecord objects containing detailed violation analysis from automated
    evaluation. Includes severity assessments, specific quotes, judge explanations, and
    violation metadata.

Attributes

results : List[ConversationResult]
    Individual conversation test results with full details
test_config : Dict[str, Any]
    Testing configuration and metadata
violation_records : List[ViolationRecord]
    Detailed violation analysis records
summary : Dict[str, Any]
    Statistical summary of test results (property)

Examples

### Accessing TestResults attributes

Work with the core attributes of TestResults:

```python
import talk_box as tb

# Run testing
bot = tb.ChatBot().avoid(["medical_advice"])
results = tb.autotest_avoid_topics(bot, test_intensity="medium")

# Access core attributes
print(f"Individual results: {len(results.results)}")
print(f"Test config: {results.test_config}")
print(f"Violation records: {len(results.violation_records)}")

# Iterate through conversation results
for result in results.results:
    print(f"Topic: {result.topic}, Strategy: {result.strategy}")
    if result.violations:
        print(f"  - Violations: {len(result.violations)}")
```

### Using the summary property

Access comprehensive test statistics:

```python
import talk_box as tb

bot = tb.ChatBot().avoid(["financial_advice", "legal_advice"])
results = tb.autotest_avoid_topics(bot, test_intensity="thorough")

# Access summary statistics
summary = results.summary
print(f"Total tests: {summary['total_tests']}")
print(f"Success rate: {summary['success_rate']:.1%}")
print(f"Violations found: {summary['violation_count']}")
print(f"Average duration: {summary['avg_duration']:.2f} seconds")
print(f"Topics tested: {list(summary['topics_tested'].keys())}")
print(f"Strategies used: {list(summary['strategies_used'].keys())}")
```

### Container protocol usage

Use TestResults as a Python container:

```python
import talk_box as tb

results = tb.autotest_avoid_topics(bot, test_intensity="medium")

# Container-like access
print(f"Total results: {len(results)}")
first_result = results[0]
print(f"First test: {first_result.topic} using {first_result.strategy}")

# Iteration
for i, result in enumerate(results):
    status = "PASSED" if result.completed and not result.violations else "FAILED"
    print(f"Test {i+1}: {result.topic} - {status}")

# Find specific results
violations = [r for r in results if r.violations]
if violations:
    print(f"Found {len(violations)} tests with violations")
```

### Export methods for data analysis

Convert results to structured formats:

```python
import talk_box as tb

results = tb.autotest_avoid_topics(bot, test_intensity="exhaustive")

# Export to pandas DataFrame
df = results.to_dataframe()
print("Violations by topic:")
print(df.groupby('topic')['violations'].sum())
print("

Success rate by strategy:“) success_by_strategy = df.groupby(‘strategy’)[‘status’].apply( lambda x: (x == ‘Passed’).mean() ) print(success_by_strategy)

# Create Great Tables report
gt_table = results.to_great_table()
gt_table.save("compliance_report.html")
```

Integration Notes

- **Container Protocol**: Implements `__len__`, `__iter__`, and `__getitem__` for standard Python container behavior
- **Rich Display**: Automatic HTML rendering in Jupyter notebooks with interactive visualizations
- **Export Flexibility**: Multiple export formats with graceful handling of optional dependencies
- **Statistical Analysis**: Comprehensive metrics for compliance assessment and performance analysis
- **Quality Assurance**: Designed for integration with automated testing and deployment workflows
- **Violation Analysis**: Detailed violation tracking with severity assessment and explanatory context

The TestResults class provides a comprehensive foundation for analyzing, reporting, and
acting on avoid topics testing outcomes, supporting both interactive exploration and
automated quality assurance processes in professional development workflows.