tritonparse 0.1.1__py3-none-any.whl

tritonparse/trace_processor.py

@@ -0,0 +1,331 @@
+import gzip
+import json
+import logging
+import os
+from collections import defaultdict
+from typing import Any, Dict, List
+
+from .event_diff import _generate_launch_diff
+
+from .ir_parser import (
+    extract_code_locations,
+    extract_loc_definitions,
+    extract_ptx_amdgcn_mappings,
+)
+from .mapper import create_bidirectional_mapping, create_python_mapping
+from .sourcemap_utils import get_file_extension
+
+logger = logging.getLogger("SourceMapping")
+
+
+def generate_source_mappings(
+    ir_content: str, ir_type: str, other_mappings: List[Any] = None
+) -> Dict[str, Dict[str, Any]]:
+    """
+    Generate source mappings from intermediate representation (IR) content to the source file.
+    Example:
+    loc definition: Line 39 in ttir: #loc2 = loc("/tmp/torchinductor_yhao/yp/abcdef.py":20:28)
+    loc reference: Line 9 in ttir: %0 = tt.get_program_id x : i32 loc(#loc2)
+    Then, the output will be:
+    {
+        "9": {
+            "file": "/tmp/torchinductor_yhao/yp/abcdef.py",
+            "line": 20,
+            "column": 28,
+            "ttir_line": 9
+        },
+    }
+
+    Args:
+        ir_content (str): The content of the intermediate representation.
+        ir_type (str): The type of the intermediate representation (e.g., 'ttir').
+        other_mappings (List[Any]): A collection of additional mappings, primarily utilized for PTX mappings since PTX's location annotations reference the file name instead of the complete path.
+
+    Returns:
+        Dict[str, Dict[str, Any]]: A dictionary mapping line numbers to their corresponding source file,
+        line, column, and the line number in the IR.
+    """
+    if other_mappings is None:
+        other_mappings = []
+    if ir_type == "ptx" or ir_type == "amdgcn":
+        return extract_ptx_amdgcn_mappings(ir_content, other_mappings, ir_type)
+
+    loc_defs = extract_loc_definitions(ir_content)
+    logger.debug(f"Found {len(loc_defs)} #loc definitions")
+
+    loc_refs = extract_code_locations(ir_content)
+    logger.debug(f"Found {len(loc_refs)} loc references")
+
+    mappings = {}
+    for ln, loc_id in loc_refs.items():
+        if loc_id.startswith("direct:"):
+            _, file_path, line, col = loc_id.split(":", 3)
+            mappings[str(ln)] = {
+                "file": file_path,
+                "line": int(line),
+                "column": int(col),
+                f"{ir_type}_line": ln,
+            }
+        elif loc_id in loc_defs:
+            info = loc_defs[loc_id]
+            mappings[str(ln)] = {
+                "file": info["file"],
+                "line": info["line"],
+                "column": info["column"],
+                f"{ir_type}_line": ln,
+            }
+
+    return mappings
+
+
+def process_ir(
+    key: str,
+    file_content: Dict[str, str],
+    file_path: Dict[str, str],
+    other_mappings: List[Any] = None,
+):
+    # Generate source mappings for each IR type
+    # the key should be the full file name with extension for the IR files
+    if not key:
+        return {}
+    logger.debug(f"Processing {key}")
+    ir_content = file_content.get(key, None)
+    if not ir_content:
+        ir_file_path = file_path.get(key, None)
+        if not ir_file_path:
+            logger.warning(f"No content found for {key}")
+            return {}
+        with open(ir_file_path, "r") as f:
+            ir_content = f.read()
+    mapping = generate_source_mappings(ir_content, key.split(".")[1], other_mappings)
+    logger.debug(f"Generated source mapping for {key}")
+    return mapping
+
+
+def parse_single_trace_content(trace_content: str) -> str:
+    """
+    Process a single trace content and extract source code mappings.
+
+    This function takes a trace content as input, extracts the IR files, generates source mappings,
+    creates bidirectional mappings between different IR types, and updates the payload with the mappings.
+
+    Args:
+        trace_content (str): The content of the trace file as a string.
+
+    Returns:
+        str: The updated trace content with source mappings as a JSON string.
+    """
+
+    entry = json.loads(trace_content)
+    if entry.get("event_type") == "compilation":
+        payload = entry.setdefault("payload", {})
+        file_content = payload.get("file_content", {})
+        file_path = payload.get("file_path", {})
+
+        # Find the IR file keys
+        ttir_key = next((k for k in file_content if k.endswith(".ttir")), None)
+        ttgir_key = next((k for k in file_content if k.endswith(".ttgir")), None)
+        ptx_key = next((k for k in file_content if k.endswith(".ptx")), None)
+        amdgcn_key = next((k for k in file_content if k.endswith(".amdgcn")), None)
+        # Skip if no IR files found
+        if not (ttir_key or ttgir_key or ptx_key or amdgcn_key):
+            logger.warning("No IR files found in the payload.")
+            return trace_content
+
+        # generate ttir->source, ttgir->source, ptx->source
+        ttir_map = process_ir(ttir_key, file_content, file_path)
+        ttgir_map = process_ir(ttgir_key, file_content, file_path)
+        ptx_map = process_ir(ptx_key, file_content, file_path, [ttir_map, ttgir_map])
+        amdgcn_map = process_ir(
+            amdgcn_key, file_content, file_path, [ttir_map, ttgir_map]
+        )
+
+        # Create bidirectional mappings between all IR types
+        ir_maps = {
+            "ttir": ttir_map,
+            "ttgir": ttgir_map,
+            "ptx": ptx_map,
+            "amdgcn": amdgcn_map,
+        }
+
+        # Create mappings between all pairs of IR types
+        ir_types = list(ir_maps.keys())
+        for i, src_type in enumerate(ir_types):
+            for tgt_type in ir_types[i + 1 :]:
+                if ir_maps[src_type] and ir_maps[tgt_type]:
+                    create_bidirectional_mapping(
+                        ir_maps[src_type], ir_maps[tgt_type], src_type, tgt_type
+                    )
+                    logger.debug(
+                        f"Created bidirectional mapping between {src_type} and {tgt_type}"
+                    )
+
+        py_map = {}
+
+        if "python_source" in payload:
+            logger.debug(
+                f"Added Python source information (lines {payload['python_source']['start_line']}-{payload['python_source']['end_line']})"
+            )
+
+            # 4. Create Python source to IR mappings. We use the original line numbers as key in the python source code.
+            # Create a list of valid IR mappings, filtering out None keys
+            ir_mappings = []
+            ir_keys_and_maps = [
+                (ttir_key, ttir_map),
+                (ttgir_key, ttgir_map),
+                (ptx_key, ptx_map),
+                (amdgcn_key, amdgcn_map),
+            ]
+
+            for key, mapping in ir_keys_and_maps:
+                if key:
+                    ir_mappings.append((get_file_extension(key), mapping))
+
+            py_map = create_python_mapping(ir_mappings)
+
+        # Store the mappings in the payload
+        payload["source_mappings"] = {
+            "ttir": ttir_map,
+            "ttgir": ttgir_map,
+            **({"ptx": ptx_map} if ptx_map else {}),
+            **({"amdgcn": amdgcn_map} if amdgcn_map else {}),
+            "python": py_map,
+        }
+    # NDJSON format requires a newline at the end of each line
+    return json.dumps(entry, separators=(",", ":")) + "\n"
+
+
+def parse_single_file(
+    file_path: str,
+    output_dir: str = None,
+    split_by_frame_id_and_compile_id: bool = True,
+):
+    """
+    Process a single file, correctly group events by kernel, and extract mappings.
+
+    This function reads a trace file, groups compilation and launch events by
+    their kernel hash, generates a launch_diff event for each kernel, and writes
+    the processed data to output files.
+
+    Args:
+        file_path (str): The path to the file to be processed.
+        output_dir (str, optional): Directory to save the output files.
+        split_by_frame_id_and_compile_id (bool, optional): Whether to split
+            output files by frame_id and compile_id. Defaults to True.
+    """
+    kernels_by_hash = defaultdict(
+        lambda: {"compilation": None, "launches": [], "output_file": None}
+    )
+
+    output_dir = output_dir or os.path.dirname(file_path)
+    is_compressed_input = file_path.endswith(".bin.ndjson")
+    file_handle = (
+        gzip.open(file_path, "rt", encoding="utf-8")
+        if is_compressed_input
+        else open(file_path, "r")
+    )
+
+    with file_handle as f:
+        file_name = os.path.basename(file_path)
+        file_name_without_extension = (
+            file_name[:-11] if is_compressed_input else os.path.splitext(file_name)[0]
+        )
+
+        for i, line in enumerate(f):
+            logger.debug(f"Processing line {i + 1} in {file_path}")
+            json_str = line.strip()
+            if not json_str:
+                continue
+
+            # We don't need to generate full mappings for every line here,
+            # just enough to get the event type and necessary IDs.
+            try:
+                parsed_json = json.loads(json_str)
+            except json.JSONDecodeError:
+                logger.warning(f"Failed to parse JSON on line {i + 1} in {file_path}")
+                continue
+
+            event_type = parsed_json.get("event_type", None)
+            payload = parsed_json.get("payload", {})
+
+            if event_type == "compilation":
+                kernel_hash = payload.get("metadata", {}).get("hash")
+                if not kernel_hash:
+                    continue
+
+                if split_by_frame_id_and_compile_id:
+                    pt_info = payload.get("pt_info", {})
+                    frame_id = pt_info.get("frame_id")
+                    frame_compile_id = pt_info.get("frame_compile_id")
+                    attempt_id = pt_info.get("attempt_id", 0)
+                    cai = pt_info.get("compiled_autograd_id", "-")
+                    if frame_id is not None or frame_compile_id is not None:
+                        fname = f"f{frame_id}_fc{frame_compile_id}_a{attempt_id}_cai{cai}.ndjson"
+                    else:
+                        fname = f"{file_name_without_extension}_mapped.ndjson"
+                else:
+                    fname = f"{file_name_without_extension}_mapped.ndjson"
+
+                output_file = os.path.join(output_dir, fname)
+                # The full processing is deferred until the final write.
+                kernels_by_hash[kernel_hash]["compilation"] = json_str
+                kernels_by_hash[kernel_hash]["output_file"] = output_file
+
+            elif event_type == "launch":
+                kernel_hash = parsed_json.get("compilation_metadata", {}).get("hash")
+                if kernel_hash:
+                    kernels_by_hash[kernel_hash]["launches"].append(
+                        (parsed_json, i + 1)
+                    )
+
+    # Organize lines for final output, keyed by output file path
+    all_output_lines = defaultdict(list)
+    for _kernel_hash, data in kernels_by_hash.items():
+        compilation_json_str = data["compilation"]
+        launches_with_indices = data["launches"]
+        output_file = data["output_file"]
+
+        if not output_file:
+            logger.warning(f"No output file for kernel hash {_kernel_hash}, skipping.")
+            continue
+
+        # Process the compilation event now to include source mappings
+        if compilation_json_str:
+            processed_compilation_line = parse_single_trace_content(
+                compilation_json_str
+            )
+            all_output_lines[output_file].append(processed_compilation_line)
+            compilation_event = json.loads(processed_compilation_line)
+        else:
+            compilation_event = None
+
+        for launch_event, _ in launches_with_indices:
+            all_output_lines[output_file].append(
+                json.dumps(launch_event, separators=(",", ":")) + "\n"
+            )
+
+        if compilation_event and launches_with_indices:
+            sames, diffs, launch_index_map = _generate_launch_diff(
+                launches_with_indices
+            )
+            launch_diff_event = {
+                "event_type": "launch_diff",
+                "hash": _kernel_hash,
+                "name": compilation_event.get("payload", {})
+                .get("metadata", {})
+                .get("name"),
+                "total_launches": len(launches_with_indices),
+                "launch_index_map": launch_index_map,
+                "diffs": diffs,
+                "sames": sames,
+            }
+            all_output_lines[output_file].append(
+                json.dumps(launch_diff_event, separators=(",", ":")) + "\n"
+            )
+
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+
+    for output_file, final_lines in all_output_lines.items():
+        with open(output_file, "w") as out:
+            out.writelines(final_lines)

tritonparse/utils.py

@@ -0,0 +1,156 @@
+#  Copyright (c) Meta Platforms, Inc. and affiliates.
+
+import argparse
+import os
+import shutil
+from pathlib import Path
+from typing import Optional
+
+from .common import (
+    copy_local_to_tmpdir,
+    is_fbcode,
+    parse_logs,
+    print_parsed_files_summary,
+    RankConfig,
+    save_logs,
+)
+from .source_type import Source, SourceType
+
+# argument parser for OSS
+parser = None
+
+
+def init_parser():
+    global parser
+
+    parser = argparse.ArgumentParser(
+        description="analyze triton structured logs", conflict_handler="resolve"
+    )
+
+    # Add arguments for the parse command
+    parser.add_argument(
+        "source",
+        help="Source of torch logs to be analyzed. It is expected to path to a local directory or log",
+    )
+    parser.add_argument(
+        "-o",
+        "--out",
+        help="Output directory.",
+        type=str,
+    )
+    parser.add_argument(
+        "--overwrite",
+        help="Delete out directory if it already exists. Only does something if --out is set",
+        action="store_true",
+    )
+    parser.add_argument("-r", "--rank", help="Rank of logs to be analyzed", type=int)
+    parser.add_argument(
+        "--all-ranks",
+        help="Analyze all ranks",
+        action="store_true",
+    )
+    parser.add_argument("-v", "--verbose", help="Verbose logging", action="store_true")
+    if is_fbcode():
+        from tritonparse.fb.utils import append_parser
+
+        append_parser(parser)
+    return parser
+
+
+def oss_run(
+    source: str,
+    out: Optional[str] = None,
+    overwrite: Optional[bool] = False,
+    rank: Optional[int] = None,
+    all_ranks: bool = False,
+    verbose: bool = False,
+):
+    """
+    Main function for tritonparse. It is for OSS only.
+
+    Args:
+        source: Source of torch logs to be analyzed (required)
+        out: Output directory
+        overwrite: Delete out directory if it already exists
+        rank: Rank of logs to be analyzed
+        all_ranks: Analyze all ranks
+        verbose: Verbose logging
+    """
+    source = Source(source, verbose)
+    rank_config = RankConfig.from_cli_args(rank, all_ranks, source.type)
+
+    # Check output directory early if specified
+    if out is not None:
+        out_dir = Path(out)
+        if out_dir.exists():
+            if not overwrite:
+                raise RuntimeError(
+                    f"{out_dir} already exists, pass --overwrite to overwrite"
+                )
+            shutil.rmtree(out_dir)
+        os.makedirs(out_dir, exist_ok=True)
+
+    # For signpost logging (not implemented in Python version)
+
+    if source.type == SourceType.LOCAL:
+        local_path = source.value
+        # Copy the results to a temp directory, then parse them
+        logs = copy_local_to_tmpdir(local_path, verbose)
+
+    elif source.type == SourceType.LOCAL_FILE:
+        local_path = source.value
+        # Copy the single file to a temp directory, then parse it
+        logs = copy_local_to_tmpdir(local_path, verbose)
+
+    parsed_log_dir, _ = parse_logs(logs, rank_config, verbose)
+    if out is not None:
+        save_logs(Path(out), parsed_log_dir, overwrite, verbose)
+    # Print beautiful summary of all parsed files
+    if out is not None:
+        out_dir = str(Path(out).absolute())
+    else:
+        out_dir = str(Path(parsed_log_dir).absolute())
+    print_parsed_files_summary(out_dir)
+
+
+def unified_parse_from_cli():
+    parser = init_parser()
+    args = parser.parse_args()
+    return unified_parse(**vars(args))
+
+
+def unified_parse(
+    source: str,
+    out: Optional[str] = None,
+    overwrite: Optional[bool] = False,
+    rank: Optional[int] = None,
+    all_ranks: bool = False,
+    verbose: bool = False,
+    **kwargs,
+):
+    """
+    Unified parse function that provides a flexible interface for parsing triton logs.
+
+    Args:
+        source: Input directory containing logs to parse.
+        out: Output directory for parsed results. By default, parsed logs will be saved to a temporary directory.
+        overwrite: Whether to overwrite existing output directory
+        rank: Specific rank to analyze
+        all_ranks: Whether to analyze all ranks
+        verbose: Whether to enable verbose logging
+    """
+    # Choose the appropriate parse function
+    if is_fbcode():
+        from tritonparse.fb.utils import fb_run as parse
+    else:
+        parse = oss_run
+
+    parse(
+        source=source,
+        out=out,
+        overwrite=overwrite,
+        rank=rank,
+        all_ranks=all_ranks,
+        verbose=verbose,
+        **kwargs,
+    )

tritonparse-0.1.1.dist-info/METADATA

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: tritonparse
+Version: 0.1.1
+Project-URL: Homepage, https://github.com/meta-pytorch/tritonparse
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: triton>3.3.1
+Provides-Extra: test
+Requires-Dist: coverage>=7.0.0; extra == "test"
+Dynamic: license-file

tritonparse-0.1.1.dist-info/RECORD

@@ -0,0 +1,40 @@
+tritonparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tritonparse/common.py,sha256=VWKFZJG7msIExMH0QNYCO8SHKqUBFtdRuLaCy_K8DFI,13725
+tritonparse/event_diff.py,sha256=yOD6uNxLJroatfx2nEGr-erw24ObOrHU9P6V5pzr8do,4907
+tritonparse/extract_source_mappings.py,sha256=Z6UxFj2cCE5NCWLQTYPKqUpLfbYhqP8xgCl5mvud9KI,1451
+tritonparse/ir_parser.py,sha256=1j1tP9jpUN7wH3e01bKUkUPgTMlNXUdp8LKRCC-WTro,9324
+tritonparse/mapper.py,sha256=prrczfi13P7Aa042OrEBsmRF1HW3jDhwxicANgPkWIM,4150
+tritonparse/shared_vars.py,sha256=-c9CvXJSDm9spYhDOJPEQProeT_xl3PaNmqTEYi_u4s,505
+tritonparse/source_type.py,sha256=nmYEQS8rfkIN9BhNhQbkmEvKnvS-3zAxRGLY4TaZdi8,1676
+tritonparse/sourcemap_utils.py,sha256=qsQmTDuEe9yuUVyxSHRbjTR38gi0hvJEijnPkrJVAV4,2037
+tritonparse/structured_logging.py,sha256=qWGkAr2oZT8Adxj-EfQqQdX2l-jq9xKi7WhBecYq2bg,39600
+tritonparse/tp_logger.py,sha256=vXzY7hMDmVnRBGBhIjFZe3nHZzG5NKKPONGUszJhGgU,242
+tritonparse/trace_processor.py,sha256=QzUOKwnOkBbwTTKBsa5ZMUABPLMJIBFtTcG2SkhO0I8,12771
+tritonparse/utils.py,sha256=wt61tpbkqjGqHh0c7Nr2WlOv7PbQssmjULd6uA6aAko,4475
+tritonparse/reproducer/__init__.py,sha256=VcCpYVUUmclWotkQmPLlDu5iFOUE4N-4FzcbzXwIow0,773
+tritonparse/reproducer/__main__.py,sha256=ydLMbWx7SFlvAb1erObvKcJ-uxhHNShGRHRrZO6-5ww,2266
+tritonparse/reproducer/cli.py,sha256=nnMgdT4tQzBWjPowOy2a_5QRsnsTMEAA3uegYpLEyRE,1165
+tritonparse/reproducer/config.py,sha256=-hmE5ZqEtYo2WKjXbwMi6k6XzzfQZAbL50UURPvcF3A,478
+tritonparse/reproducer/factory.py,sha256=sFcIjIayfHAqPqMVT8Rnsz9tpMmQXBzoOlKprS1P_1g,341
+tritonparse/reproducer/orchestrator.py,sha256=iD7zZZHE4FU3nNOwNV9SUY2WUcpv_Amg0SvnRxrseEQ,2045
+tritonparse/reproducer/param_generator.py,sha256=m-C_Z1TLd1ZX49EpsWELVfB6tkwOfi-ZHma7wXwz2g4,4654
+tritonparse/reproducer/ingestion/__init__.py,sha256=2AQHxWlUl5JXM4a8F033wzxVnjCVPBEf-4H99kep-OA,99
+tritonparse/reproducer/ingestion/ndjson.py,sha256=_E_dXXjxu438OYomQ1zFFk3jV9Wr1jNoXHiP2gJG7_4,5172
+tritonparse/reproducer/prompts/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
+tritonparse/reproducer/prompts/loader.py,sha256=n6Of98eEXNz9mI7ZH073X5FihNZD7tI-ehfjN_4yEl0,610
+tritonparse/reproducer/providers/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
+tritonparse/reproducer/providers/base.py,sha256=DgP_4AdrEf48kstOfBJFvK3pndcHH0vRUGjp6k1bdsY,362
+tritonparse/reproducer/providers/gemini.py,sha256=VlOCdTGRTQdr3c2HMclKFIk-133puGSAjhK_6m6Zj9g,1609
+tritonparse/reproducer/runtime/__init__.py,sha256=da1PTClDMl-IBkrSvq6JC1lnS-K_BASzCvxVhNxN5Ls,13
+tritonparse/reproducer/runtime/executor.py,sha256=AqBFnoEqURoMGDdLC2G3WpHIP3Y4wWGJHEZrjS-NQFM,304
+tritonparse/reproducer/utils/io.py,sha256=95NF9QCGawl-5p5c5yCQHynVBNKS_B_7nIrqnRvAt-E,200
+tritonparse/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tritonparse/tools/decompress_bin_ndjson.py,sha256=kpt7DM_sSA334F1X45xdkP2OR9LuB27Pc50EkGr6CPM,4144
+tritonparse/tools/format_fix.py,sha256=Ol0Sjui8D7OzHwbamAfGnq8V5Y63uwNaFTKSORN5HkQ,3867
+tritonparse/tools/load_tensor.py,sha256=tfdmNVd9gsZqO6msQBhbXIhOvUzgc83yF64k2GDWPNk,2122
+tritonparse/tools/prettify_ndjson.py,sha256=VOzVWoXpCbaAXYA4i_wBcQIHfh-JhAx7xR4cF_L8yDs,10928
+tritonparse-0.1.1.dist-info/licenses/LICENSE,sha256=4ZciugpyN7wcM4L-9pyDh_etvMUeIfBhDTyH1zeZlQM,1515
+tritonparse-0.1.1.dist-info/METADATA,sha256=qETEInGJRT7fzf-Rl8cAf6QnEa5eJgiYo4rbwBA63yc,287
+tritonparse-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tritonparse-0.1.1.dist-info/top_level.txt,sha256=ITcTKgp3vf_bXV9vixuQU9IrZa3L1EfDSZwvRzRaoJU,12
+tritonparse-0.1.1.dist-info/RECORD,,

tritonparse-0.1.1.dist-info/WHEEL

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

tritonparse-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2019, pytorch
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tritonparse-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+tritonparse