### Build and Development Commands Source: https://github.com/plasma-umass/slipcover/blob/main/CLAUDE.md Standard commands for installing the package in editable mode, running tests, and managing build artifacts. ```bash # Install in development/editable mode pip install -e . # Run all tests pytest # Run a single test file pytest tests/test_coverage.py # Run a specific test pytest tests/test_coverage.py::test_function_name # Run with pytest-forked (Unix only, useful for isolation) pytest --forked # Clean build artifacts make clean # Run benchmarks make bench ``` -------------------------------- ### Install SlipCover Source: https://github.com/plasma-umass/slipcover/blob/main/README.md Install the package using pip. ```console pip3 install slipcover ``` -------------------------------- ### Initialize and Configure FileMatcher Source: https://context7.com/plasma-umass/slipcover/llms.txt Use FileMatcher to define which source files should be included in coverage analysis and which should be omitted. It automatically excludes standard library, site-packages, and binary files. ```python import slipcover as sc from pathlib import Path # Create a file matcher file_matcher = sc.FileMatcher() # Add source directories (files here will be covered) file_matcher.addSource(Path('src')) file_matcher.addSource(Path('lib')) # Add omit patterns (files matching these will be excluded) file_matcher.addOmit('*_test.py') file_matcher.addOmit('tests/*') # Check if a file matches coverage criteria if file_matcher.matches('/path/to/src/module.py'): print("This file will be covered") if not file_matcher.matches('/path/to/tests/test_module.py'): print("This file will be skipped") ``` -------------------------------- ### Run a Python script with SlipCover Source: https://github.com/plasma-umass/slipcover/blob/main/README.md Execute a target script under the coverage monitor. ```console python3 -m slipcover myscript.py ``` -------------------------------- ### Running SlipCover Source: https://github.com/plasma-umass/slipcover/blob/main/CLAUDE.md Common CLI patterns for executing scripts or modules with coverage tracking enabled. ```bash # Run a script with coverage python -m slipcover myscript.py # Run with a module (e.g., pytest) python -m slipcover -m pytest # Enable branch coverage python -m slipcover --branch myscript.py # Output JSON format python -m slipcover --json --out coverage.json myscript.py ``` -------------------------------- ### Run a test harness with SlipCover Source: https://github.com/plasma-umass/slipcover/blob/main/README.md Execute a module like pytest to collect coverage during test suite execution. ```console python3 -m slipcover -m pytest -x -v ``` -------------------------------- ### Use Programmatic Slipcover API Source: https://context7.com/plasma-umass/slipcover/llms.txt Instantiate the Slipcover class to instrument code and retrieve coverage data programmatically. ```python import slipcover as sc # Create a Slipcover instance sci = sc.Slipcover( immediate=False, # Immediate de-instrumentation (True for lower overhead) d_miss_threshold=50, # Threshold for gradual de-instrumentation branch=True, # Enable branch coverage source=['src'], # Directories to cover omit=['tests/*'] # Patterns to exclude ) # Instrument a code object code = compile(open('myscript.py').read(), 'myscript.py', 'exec') instrumented_code = sci.instrument(code) # Execute the instrumented code exec(instrumented_code, {'__name__': '__main__'}) # Get coverage results coverage = sci.get_coverage() print(f"Total coverage: {coverage['summary']['percent_covered']:.1f}%") ``` -------------------------------- ### Run Script Coverage via CLI Source: https://context7.com/plasma-umass/slipcover/llms.txt Execute Python scripts through the slipcover module to generate coverage reports in various formats. ```bash # Basic script coverage python -m slipcover myscript.py # Pass arguments to the script python -m slipcover myscript.py --arg1 value1 --arg2 # Output coverage to JSON file python -m slipcover --json --out coverage.json myscript.py # Output coverage to XML (Cobertura format) python -m slipcover --xml --out coverage.xml myscript.py # Pretty-print JSON output python -m slipcover --json --pretty-print --out coverage.json myscript.py ``` -------------------------------- ### Export coverage data to JSON Source: https://context7.com/plasma-umass/slipcover/llms.txt Demonstrates the structure of the coverage data object and how to persist it to a file. The structure includes metadata, file-specific line/branch coverage, and summary statistics. ```python import slipcover as sc import json # Sample coverage data structure coverage = { "meta": { "software": "slipcover", "version": "1.0.18", "timestamp": "2024-01-15T10:30:00.000000", "branch_coverage": True, "show_contexts": False }, "files": { "src/calculator.py": { "executed_lines": [1, 2, 3, 5, 6, 10, 11, 12], "missing_lines": [7, 8, 15, 16], "executed_branches": [[5, 6], [5, 10], [10, 11]], "missing_branches": [[10, 15]], # branch from line 10 to 15 not taken "summary": { "covered_lines": 8, "missing_lines": 4, "covered_branches": 3, "missing_branches": 1, "percent_covered": 78.57 } }, "src/utils.py": { "executed_lines": [1, 2, 3, 4, 5], "missing_lines": [], "executed_branches": [[2, 3], [2, 5]], "missing_branches": [], "summary": { "covered_lines": 5, "missing_lines": 0, "covered_branches": 2, "missing_branches": 0, "percent_covered": 100.0 } } }, "summary": { "covered_lines": 13, "missing_lines": 4, "covered_branches": 5, "missing_branches": 1, "percent_covered": 82.61, "percent_covered_display": "83" } } # Save coverage to JSON with open('coverage.json', 'w') as f: json.dump(coverage, f, indent=4) ``` -------------------------------- ### Branch Pre-instrumentation Source: https://context7.com/plasma-umass/slipcover/llms.txt Provides AST transformation for branch coverage tracking by inserting markers at branch points before bytecode compilation. ```APIDOC ## Branch Pre-instrumentation ### Description Provides AST transformation for branch coverage tracking, inserting markers at branch points before bytecode compilation. ### Method N/A (This is a module and function call within a Python script) ### Endpoint N/A ### Parameters #### Path Parameters None #### Query Parameters None #### Request Body None ### Request Example ```python import ast import slipcover.branch as br source = """ def example(x): if x > 0: return "positive" elif x < 0: return "negative" else: return "zero" for i in range(3): print(i) """ tree = ast.parse(source) instrumented_tree = br.preinstrument(tree) code = compile(instrumented_tree, '', 'exec') ``` ### Response N/A (This function returns an instrumented AST, not a direct response) ``` -------------------------------- ### Run pytest Coverage via CLI Source: https://context7.com/plasma-umass/slipcover/llms.txt Integrate SlipCover with pytest to track test suite coverage, supporting parallel execution and threshold enforcement. ```bash # Basic pytest coverage python -m slipcover -m pytest # Pass pytest options python -m slipcover -m pytest -x -v tests/ # Run with pytest-xdist for parallel testing (automatically supported) python -m slipcover -m pytest -n auto # Skip fully covered files in output python -m slipcover --skip-covered -m pytest # Fail if coverage is below threshold python -m slipcover --fail-under 80 -m pytest ``` -------------------------------- ### Enable Branch Coverage Source: https://context7.com/plasma-umass/slipcover/llms.txt Track execution of branches like if/else, for/while, and match statements. ```bash # Enable branch coverage for a script python -m slipcover --branch myscript.py # Branch coverage with pytest python -m slipcover --branch -m pytest # Branch coverage with JSON output python -m slipcover --branch --json --out coverage.json myscript.py ``` -------------------------------- ### Run Pytest with SlipCover Source: https://github.com/plasma-umass/slipcover/blob/main/README.md Execute the pytest test suite using SlipCover to generate a coverage report. This command analyzes test execution and reports on code coverage percentages and missing lines. ```console $ python3 -m slipcover -m pytest ================================================================ test session starts ================================================================ platform darwin -- Python 3.9.12, pytest-7.1.2, pluggy-1.0.0 rootdir: /Users/juan/project/wally/d2k-5, configfile: pytest.ini plugins: hypothesis-6.39.3, mock-3.7.0, repeat-0.9.1, doctestplus-0.12.0, arraydiff-0.5.0 collected 439 items tests/box_test.py ......................... [ 5%] tests/image_test.py ............... [ 9%] tests/network_equivalence_test.py .........................................s................................................................. [ 33%] .............................................................................. [ 51%] tests/network_test.py ....................................................................................................................... [ 78%] ............................................................................................... [100%] =================================================== 438 passed, 1 skipped, 62 warnings in 48.43s =================================================== File #lines #miss Cover% Lines missing --------------------------------- -------- ------- -------- ------------------------ d2k/__init__.py 3 0 100 d2k/box.py 105 27 74 73, 142-181 d2k/image.py 38 4 89 70-73 d2k/network.py 359 1 99 236 tests/box_test.py 178 0 100 tests/darknet.py 132 11 91 146, 179-191 tests/image_test.py 45 0 100 tests/network_equivalence_test.py 304 30 90 63, 68, 191-215, 455-465 tests/network_test.py 453 0 100 $ ``` -------------------------------- ### FileMatcher Class Source: https://context7.com/plasma-umass/slipcover/llms.txt The FileMatcher class determines which files should be instrumented based on source directories and omit patterns. ```APIDOC ## FileMatcher Class ### Description The FileMatcher class is used to define which files are included in or excluded from coverage analysis. ### Methods - **addSource(path)**: Adds a directory to the list of source files to be covered. - **addOmit(pattern)**: Adds a glob pattern for files to be excluded from coverage. - **matches(path)**: Returns a boolean indicating if the given file path matches the coverage criteria. ``` -------------------------------- ### Pre-instrument AST for branch coverage Source: https://context7.com/plasma-umass/slipcover/llms.txt Transforms an AST to insert branch markers before compilation. Useful for tracking branch execution in control flow structures like if/else and loops. ```python import ast import slipcover.branch as br # Parse source code source = """ def example(x): if x > 0: return "positive" elif x < 0: return "negative" else: return "zero" for i in range(3): print(i) """ # Parse to AST tree = ast.parse(source) # Pre-instrument for branch coverage # This inserts branch markers at if/elif/else, for/while, match/case instrumented_tree = br.preinstrument(tree) # Compile the instrumented AST code = compile(instrumented_tree, '', 'exec') # The instrumented code tracks branches like: # - if x > 0: (line 3) -> positive branch (line 4) # - if x > 0: (line 3) -> elif branch (line 5) # - elif x < 0: (line 5) -> negative branch (line 6) # - elif x < 0: (line 5) -> else branch (line 7) # - for loop (line 10) -> body (line 11) # - for loop (line 10) -> exit (line 0) ``` -------------------------------- ### Filter Coverage with Source and Omit Source: https://context7.com/plasma-umass/slipcover/llms.txt Restrict coverage tracking to specific directories or exclude files using patterns. ```bash # Only cover files in specific directories python -m slipcover --source src,lib -m pytest # Omit specific files or patterns python -m slipcover --omit "tests/*,conftest.py" -m pytest # Combine source and omit python -m slipcover --source src --omit "src/migrations/*" -m pytest ``` -------------------------------- ### Merge Coverage Files Source: https://context7.com/plasma-umass/slipcover/llms.txt Combine multiple coverage data files into a single report. ```bash # Merge multiple JSON coverage files python -m slipcover --merge coverage1.json coverage2.json coverage3.json --out merged.json # Merge and output as XML python -m slipcover --merge coverage1.json coverage2.json --xml --out merged.xml # Merge with branch coverage python -m slipcover --merge cov1.json cov2.json --branch --out merged.json ``` -------------------------------- ### Load and analyze coverage data Source: https://context7.com/plasma-umass/slipcover/llms.txt Parses a JSON coverage file to extract and print the percentage covered and missing lines for each file. ```python with open('coverage.json') as f: data = json.load(f) for filename, file_cov in data['files'].items(): pct = file_cov['summary']['percent_covered'] missing = file_cov['missing_lines'] print(f"{filename}: {pct:.1f}% coverage, missing lines: {missing}") ``` -------------------------------- ### print_xml Function Source: https://context7.com/plasma-umass/slipcover/llms.txt Generates Cobertura-compatible XML coverage reports. ```APIDOC ## print_xml(coverage, source_paths, with_branches=True, xml_package_depth=2, outfile=sys.stdout) ### Description Generates an XML report in Cobertura format, suitable for CI/CD integration. ### Parameters - **coverage** (dict): The coverage data object. - **source_paths** (list): List of source directories. - **with_branches** (bool): Whether to include branch coverage in the XML. - **xml_package_depth** (int): Controls the nesting depth of packages in the XML output. - **outfile** (file-like): The output destination. ``` -------------------------------- ### Coverage Output Format Source: https://context7.com/plasma-umass/slipcover/llms.txt Details the structure of coverage data returned by `get_coverage()` and used by reporting functions. ```APIDOC ## Coverage Output Format ### Description Details the coverage data structure returned by `get_coverage()` and expected by all reporting functions. ### Method N/A (This describes a data structure) ### Endpoint N/A ### Parameters None ### Request Example N/A ### Response #### Success Response (200) - **meta** (object) - Metadata about the coverage run. - **software** (string) - Name of the coverage tool. - **version** (string) - Version of the coverage tool. - **timestamp** (string) - Timestamp of the coverage run. - **branch_coverage** (boolean) - Indicates if branch coverage is enabled. - **show_contexts** (boolean) - Indicates if execution contexts are shown. - **files** (object) - Coverage data per file. - **[filename]** (object) - Coverage details for a specific file. - **executed_lines** (array of integers) - Lines that were executed. - **missing_lines** (array of integers) - Lines that were not executed. - **executed_branches** (array of arrays of integers) - Branches that were taken. - **missing_branches** (array of arrays of integers) - Branches that were not taken. - **summary** (object) - Summary statistics for the file. - **covered_lines** (integer) - Number of lines covered. - **missing_lines** (integer) - Number of lines missing. - **covered_branches** (integer) - Number of branches covered. - **missing_branches** (integer) - Number of branches missing. - **percent_covered** (float) - Percentage of lines covered. - **summary** (object) - Overall summary statistics. - **covered_lines** (integer) - Total lines covered. - **missing_lines** (integer) - Total lines missing. - **covered_branches** (integer) - Total branches covered. - **missing_branches** (integer) - Total branches missing. - **percent_covered** (float) - Overall percentage of lines covered. - **percent_covered_display** (string) - Overall percentage of lines covered for display. #### Response Example ```json { "meta": { "software": "slipcover", "version": "1.0.18", "timestamp": "2024-01-15T10:30:00.000000", "branch_coverage": true, "show_contexts": false }, "files": { "src/calculator.py": { "executed_lines": [1, 2, 3, 5, 6, 10, 11, 12], "missing_lines": [7, 8, 15, 16], "executed_branches": [[5, 6], [5, 10], [10, 11]], "missing_branches": [[10, 15]], "summary": { "covered_lines": 8, "missing_lines": 4, "covered_branches": 3, "missing_branches": 1, "percent_covered": 78.57 } }, "src/utils.py": { "executed_lines": [1, 2, 3, 4, 5], "missing_lines": [], "executed_branches": [[2, 3], [2, 5]], "missing_branches": [], "summary": { "covered_lines": 5, "missing_lines": 0, "covered_branches": 2, "missing_branches": 0, "percent_covered": 100.0 } } }, "summary": { "covered_lines": 13, "missing_lines": 4, "covered_branches": 5, "missing_branches": 1, "percent_covered": 82.61, "percent_covered_display": "83" } } ``` ``` -------------------------------- ### print_coverage Function Source: https://context7.com/plasma-umass/slipcover/llms.txt Outputs human-readable coverage reports to stdout or a file. ```APIDOC ## print_coverage(coverage, outfile=sys.stdout, missing_width=60, skip_covered=False) ### Description Generates a formatted table showing coverage statistics including lines, branches, and missing lines. ### Parameters - **coverage** (dict): The coverage data object. - **outfile** (file-like): The output destination. - **missing_width** (int): Maximum width for the missing lines column. - **skip_covered** (bool): If True, omits files with 100% coverage. ``` -------------------------------- ### Instrument pytest with wrap_pytest Source: https://context7.com/plasma-umass/slipcover/llms.txt Hooks into pytest's assertion rewriting mechanism to enable coverage for rewritten modules. Requires a configured Slipcover instance and FileMatcher. ```python import slipcover as sc # Create Slipcover and FileMatcher sci = sc.Slipcover(branch=True) file_matcher = sc.FileMatcher() file_matcher.addSource('src') file_matcher.addSource('tests') # Wrap pytest's assertion rewriter # This intercepts exec() calls in pytest to instrument code sc.wrap_pytest(sci, file_matcher) # Now when pytest runs, all matching files get instrumented # This is automatically called by slipcover when using: # python -m slipcover -m pytest ``` -------------------------------- ### Slipcover Class API Source: https://context7.com/plasma-umass/slipcover/llms.txt The programmatic API allows for fine-grained control over code instrumentation and coverage collection within Python applications. ```APIDOC ## Class: slipcover.Slipcover ### Description The Slipcover class provides the core functionality for instrumenting code objects and retrieving coverage data programmatically. ### Constructor Parameters - **immediate** (bool) - Optional - If True, uses immediate de-instrumentation for lower overhead. - **d_miss_threshold** (int) - Optional - Threshold for gradual de-instrumentation. - **branch** (bool) - Optional - Enable branch coverage tracking. - **source** (list) - Optional - List of directories to include in coverage. - **omit** (list) - Optional - List of file patterns to exclude from coverage. ### Methods - **instrument(code)**: Instruments a code object for coverage tracking. - **get_coverage()**: Returns the collected coverage data as a dictionary. ### Response Example { "meta": {"software": "slipcover", "version": "1.0.18"}, "files": { "myscript.py": { "executed_lines": [1, 2, 5, 6, 10], "missing_lines": [3, 4, 7], "summary": {"percent_covered": 62.5} } }, "summary": {"percent_covered": 62.5, "covered_lines": 5, "missing_lines": 3} } ``` -------------------------------- ### wrap_function for Fuzzing Source: https://context7.com/plasma-umass/slipcover/llms.txt Wraps a function to enable coverage-guided fuzzing, providing incremental coverage information. ```APIDOC ## wrap_function for Fuzzing ### Description Wraps a function for coverage-guided fuzzing, providing incremental coverage information during test generation. ### Method N/A (This is a decorator and function call within a Python script) ### Endpoint N/A ### Parameters #### Path Parameters None #### Query Parameters None #### Request Body None ### Request Example ```python import slipcover as sc @sc.wrap_function def target_function(sci, input_data): """Function to be fuzzed with coverage tracking.""" # ... function logic ... return True # Usage with a fuzzer: def test_fuzz(): for _ in range(1000): data = generate_random_input() target_function(data) # Coverage is tracked incrementally ``` ### Response N/A (This function modifies the target function's behavior for coverage tracking) ``` -------------------------------- ### Instrument Imports with ImportManager Source: https://context7.com/plasma-umass/slipcover/llms.txt The ImportManager context manager automatically instruments modules as they are imported within its block. This is useful for ensuring coverage of dynamically loaded or imported code. ```python import slipcover as sc # Create Slipcover and FileMatcher instances sci = sc.Slipcover(branch=True) file_matcher = sc.FileMatcher() file_matcher.addSource('src') # Use ImportManager as a context manager with sc.ImportManager(sci, file_matcher): # All imports within this block are automatically instrumented import mymodule import mypackage.submodule # Run your code mymodule.run_something() mypackage.submodule.process() # Get coverage after execution coverage = sci.get_coverage() for filename, data in coverage['files'].items(): print(f"{filename}: {data['summary']['percent_covered']:.1f}%") ``` -------------------------------- ### Generate Cobertura XML Reports Source: https://context7.com/plasma-umass/slipcover/llms.txt The print_xml function generates Cobertura-compatible XML reports, suitable for CI/CD integration. It allows specifying source paths, branch coverage inclusion, and output destination. ```python import slipcover as sc # Get coverage data sci = sc.Slipcover(branch=True) # ... instrument and run code ... coverage = sci.get_coverage() # Print XML to stdout sc.print_xml( coverage, source_paths=['/path/to/project'], with_branches=True ) # Write XML to file with open('coverage.xml', 'w') as f: sc.print_xml( coverage, source_paths=['/path/to/project', '/path/to/lib'], with_branches=True, xml_package_depth=2, # Control package nesting depth outfile=f ) # Example output (Cobertura format): # # # # # # # # # # # # # # # ``` -------------------------------- ### Print Human-Readable Coverage Reports Source: https://context7.com/plasma-umass/slipcover/llms.txt The print_coverage function outputs formatted coverage statistics to stdout or a specified file. It supports options to control output width and skip fully covered files. ```python import slipcover as sc # Get coverage data sci = sc.Slipcover(branch=True) # ... instrument and run code ... coverage = sci.get_coverage() # Print to stdout (default) sc.print_coverage(coverage) # Output: # File #lines #l.miss #br. #br.miss brCov% totCov% Missing # module.py 50 10 8 2 75 80 15-20, 35 # utils.py 30 0 4 0 100 100 # --- # (summary) 80 10 12 2 83 87 # Print with options sc.print_coverage( coverage, outfile=sys.stdout, # Output destination missing_width=60, # Max width for missing column skip_covered=True # Omit 100% covered files ) # Write to file with open('report.txt', 'w') as f: sc.print_coverage(coverage, outfile=f) ``` -------------------------------- ### ImportManager Context Manager Source: https://context7.com/plasma-umass/slipcover/llms.txt The ImportManager intercepts module imports to automatically instrument code as it loads. ```APIDOC ## ImportManager Context Manager ### Description Used as a context manager to ensure that all modules imported within the block are automatically instrumented by Slipcover. ### Usage - **Constructor**: `ImportManager(sci, file_matcher)` where `sci` is a Slipcover instance and `file_matcher` is a FileMatcher instance. ``` -------------------------------- ### wrap_pytest Function Source: https://context7.com/plasma-umass/slipcover/llms.txt Instruments test files for coverage when using pytest by hooking into its assertion rewriting mechanism. ```APIDOC ## wrap_pytest Function ### Description Hooks into pytest's assertion rewriting mechanism to instrument test files, enabling coverage for pytest-rewritten modules. ### Method N/A (This is a function call within a Python script) ### Endpoint N/A ### Parameters #### Path Parameters None #### Query Parameters None #### Request Body None ### Request Example ```python import slipcover as sc # Create Slipcover and FileMatcher sci = sc.Slipcover(branch=True) file_matcher = sc.FileMatcher() file_matcher.addSource('src') file_matcher.addSource('tests') # Wrap pytest's assertion rewriter sc.wrap_pytest(sci, file_matcher) # Usage: python -m slipcover -m pytest ``` ### Response N/A (This function modifies pytest's behavior) ``` -------------------------------- ### merge_coverage Function Source: https://context7.com/plasma-umass/slipcover/llms.txt Merges coverage data from multiple Slipcover runs. ```APIDOC ## merge_coverage(coverage_a, coverage_b) ### Description Merges coverage data from two sources. Modifies `coverage_a` in place by combining executed and missing line/branch information from `coverage_b`. ### Parameters - **coverage_a** (dict): The primary coverage data object. - **coverage_b** (dict): The secondary coverage data object to merge into the first. ``` -------------------------------- ### Wrap functions for fuzzing with wrap_function Source: https://context7.com/plasma-umass/slipcover/llms.txt Decorates a function to provide incremental coverage information during test execution. The Slipcover instance is automatically injected as the first argument. ```python import slipcover as sc @sc.wrap_function def target_function(sci, input_data): """Function to be fuzzed with coverage tracking. Args: sci: Slipcover instance (injected automatically) input_data: Test input from fuzzer """ if len(input_data) > 10: if input_data[0] == 'A': process_type_a(input_data) else: process_type_b(input_data) return True # Usage with a fuzzer (e.g., Hypothesis or custom) def test_fuzz(): import random import string for _ in range(1000): # Generate random input length = random.randint(1, 20) data = ''.join(random.choices(string.ascii_letters, k=length)) # Run with coverage tracking target_function(data) # Coverage information is tracked incrementally # Fuzzer can use this to guide input generation ``` -------------------------------- ### Merge Coverage Data Source: https://context7.com/plasma-umass/slipcover/llms.txt The merge_coverage function combines coverage data from multiple Slipcover runs. Ensure that all coverage files share the same branch_coverage settings and do not have show_contexts enabled. ```python import slipcover as sc import json # Load first coverage file with open('coverage1.json') as f: coverage_a = json.load(f) # Load and merge second coverage file with open('coverage2.json') as f: coverage_b = json.load(f) # Merge coverage_b into coverage_a (modifies coverage_a in place) sc.merge_coverage(coverage_a, coverage_b) # Lines executed in either run are now in executed_lines # Lines missing in both runs remain in missing_lines print(f"Merged coverage: {coverage_a['summary']['percent_covered']:.1f}%") # Save merged coverage with open('merged.json', 'w') as f: json.dump(coverage_a, f, indent=4) # Note: Both coverage files must: # - Be generated by SlipCover (meta.software == 'slipcover') # - Have matching branch_coverage settings # - Not have show_contexts enabled ``` === COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.