tritonparse 0.2.4.dev20250930071536__py3-none-any.whl → 0.2.4.dev20251002071459__py3-none-any.whl

tritonparse/__main__.py

@@ -0,0 +1,5 @@
+from .run import main
+
+
+if __name__ == "__main__":
+    main()

tritonparse/reproducer/cli.py

@@ -5,9 +5,13 @@ def _add_reproducer_args(parser: argparse.ArgumentParser) -> None:
     """Add common arguments for the reproducer to a parser."""
     parser.add_argument("input", help="Path to the ndjson/ndjson.gz log file")
     parser.add_argument(
-        "--line-index",
+        "--line",
         type=int,
-        help="The line number of the launch event in the input file to reproduce.",
+        default=1,
+        help=(
+            "The line number (1-based) of the launch event in the input file to reproduce. "
+            "Defaults to 1."
+        ),
     )
     parser.add_argument(
         "--out-dir",

tritonparse/reproducer/orchestrator.py

@@ -18,7 +18,7 @@ def reproduce(
     line_index: int,
     out_dir: str,
     template: str,
-):
+) -> dict[str, Path]:
     """
     Generate a reproducer script from NDJSON trace file.
 
@@ -55,9 +55,15 @@ def reproduce(
         "# {{KERNEL_INVOCATION_PLACEHOLDER}}", invocation_snippet
     )
     out_py_path.write_text(final_code, encoding="utf-8")
-    logger.info(
-        "REPRODUCER_OUTPUT script=%s json=%s kernel=%s",
-        str(out_py_path.resolve()),
-        str(temp_json_path.resolve()),
-        context_bundle.kernel_info.function_name,
-    )
+
+    filepath = context_bundle.kernel_info.file_path
+    filepath = "/".join(filepath.split("/")[5:])
+    ret = {
+        "kernel_src_path": filepath,
+        "kernel": context_bundle.kernel_info.function_name,
+        "repo_script": str(out_py_path.resolve()),
+        "repo_context": str(temp_json_path.resolve()),
+    }
+    logger.info("REPRODUCER_OUTPUT\n%s", ret)
+
+    return ret

tritonparse/reproducer/templates/example.py

@@ -1,6 +1,12 @@
+"""
+This file is automatically generated by TritonParse reproducer.
+It contains a smallest testing example for a Triton kernel.
+"""
+
 import hashlib
 import importlib
 import json
+import logging
 import sys
 from functools import lru_cache
 from pathlib import Path
@@ -139,25 +145,62 @@ def _create_arg_from_info(arg_info):
     elif arg_type == "tensor":
         if arg_info.get("blob_path"):
             return load_tensor(arg_info.get("blob_path"), arg_info.get("device"))
+
+        # Extract basic tensor properties
         dtype_str = arg_info.get("dtype")
         try:
             torch_dtype = getattr(torch, dtype_str.split(".")[-1])
         except AttributeError:
+            logging.error(f"Unsupported dtype: {dtype_str}. Defaulting to float32.")
             torch_dtype = torch.float32
 
         shape = arg_info.get("shape", [])
         device = arg_info.get("device", "cpu")
 
+        # Extract statistical information if available
+        mean = arg_info.get("mean")
+        std = arg_info.get("std")
+        min_val = arg_info.get("min")
+        max_val = arg_info.get("max")
+        has_stats = (
+            mean is not None
+            and std is not None
+            and min_val is not None
+            and max_val is not None
+        )
+
+        if arg_info.get("tensor_capture_error", False):
+            logging.error(
+                f"Error: Tensor '{arg_info.get('name', '')}' had capture error. Generating random tensor instead."
+            )
+
         # Use a dummy tensor to check properties of the dtype
         tensor_props = torch.empty(0, dtype=torch_dtype)
 
-        # Case 1: Floating point, signed integers, uint8, and bool are supported by random_()
+        # Case 1: Floating point types
         if tensor_props.is_floating_point():
-            if torch_dtype in [torch.float8_e4m3fn, torch.float8_e5m2]:
-                tmp = torch.rand(shape, dtype=torch.float32, device=device)
-                return tmp.to(torch_dtype)
+            if has_stats:
+                # Generate tensor with statistical properties matching original data
+                if std == 0 or min_val == max_val:
+                    # Constant tensor
+                    return torch.full(shape, mean, dtype=torch_dtype, device=device)
+                # Generate normal distribution with mean and std, then clamp to [min, max]
+                tensor = (
+                    torch.randn(shape, dtype=torch.float32, device=device) * std + mean
+                )
+                tensor = torch.clamp(tensor, min=min_val, max=max_val)
+                return tensor.to(torch_dtype)
             else:
-                return torch.empty(shape, dtype=torch_dtype, device=device).random_()
+                # Fallback to original random generation
+                if torch_dtype in [torch.float8_e4m3fn, torch.float8_e5m2]:
+                    tmp = torch.rand(shape, dtype=torch.float32, device=device)
+                    return tmp.to(torch_dtype)
+                else:
+                    return torch.empty(
+                        shape, dtype=torch_dtype, device=device
+                    ).random_()
+
+        # Case 2: Integer types
         elif torch_dtype in [
             torch.int8,
             torch.int16,
@@ -166,9 +209,26 @@ def _create_arg_from_info(arg_info):
             torch.uint8,
             torch.bool,
         ]:
-            return torch.empty(shape, dtype=torch_dtype, device=device).random_()
-        # Case 2: Complex numbers need special handling
+            if has_stats and torch_dtype != torch.bool:
+                # Generate tensor with statistical properties, then round for integers
+                if std == 0 or min_val == max_val:
+                    # Constant tensor
+                    return torch.full(
+                        shape, int(mean), dtype=torch_dtype, device=device
+                    )
+                tensor = (
+                    torch.randn(shape, dtype=torch.float32, device=device) * std + mean
+                )
+                tensor = torch.clamp(tensor, min=min_val, max=max_val)
+                return torch.round(tensor).to(torch_dtype)
+            else:
+                # Fallback to original random generation
+                return torch.empty(shape, dtype=torch_dtype, device=device).random_()
+
+        # Case 3: Complex numbers need special handling
         elif tensor_props.is_complex():
+            # Complex types: fallback to original logic for now
+            # TODO: Could be improved to use statistical info if available
             float_dtype = (
                 torch.float32 if torch_dtype == torch.complex64 else torch.float64
             )
@@ -176,10 +236,24 @@ def _create_arg_from_info(arg_info):
             imag_part = torch.rand(shape, dtype=float_dtype, device=device)
             return torch.complex(real_part, imag_part)
 
-        # Case 3: Handle other unsigned integers (like uint32) which fail with random_()
+        # Case 4: Handle other unsigned integers (like uint32) which fail with random_()
         elif "uint" in str(torch_dtype):
-            return torch.randint(0, 1000, shape, dtype=torch_dtype, device=device)
-        # Case 4: If we don't know how to handle the type, raise an error
+            if has_stats:
+                # Generate tensor with statistical properties for unsigned integers
+                if std == 0 or min_val == max_val:
+                    return torch.full(
+                        shape, int(mean), dtype=torch_dtype, device=device
+                    )
+                tensor = (
+                    torch.randn(shape, dtype=torch.float32, device=device) * std + mean
+                )
+                tensor = torch.clamp(tensor, min=min_val, max=max_val)
+                return torch.round(tensor).to(torch_dtype)
+            else:
+                # Fallback to original random generation
+                return torch.randint(0, 1000, shape, dtype=torch_dtype, device=device)
+
+        # Case 5: If we don't know how to handle the type, raise an error
         else:
             raise NotImplementedError(
                 f"Random data generation not implemented for dtype: {torch_dtype}"

tritonparse/reproducer/utils.py

@@ -84,25 +84,57 @@ def _create_arg_from_info(arg_info):
     elif arg_type == "tensor":
         if arg_info.get("blob_path"):
             return load_tensor(arg_info.get("blob_path"), arg_info.get("device"))
+
+        # Extract basic tensor properties
         dtype_str = arg_info.get("dtype")
         try:
             torch_dtype = getattr(torch, dtype_str.split(".")[-1])
         except AttributeError:
+            logger.error(f"Unsupported dtype: {dtype_str}. Defaulting to float32.")
             torch_dtype = torch.float32
 
         shape = arg_info.get("shape", [])
         device = arg_info.get("device", "cpu")
 
+        # Extract statistical information if available
+        mean = arg_info.get("mean")
+        std = arg_info.get("std")
+        min_val = arg_info.get("min")
+        max_val = arg_info.get("max")
+        has_stats = (
+            mean is not None
+            and std is not None
+            and min_val is not None
+            and max_val is not None
+        )
+
         # Use a dummy tensor to check properties of the dtype
         tensor_props = torch.empty(0, dtype=torch_dtype)
 
-        # Case 1: Floating point, signed integers, uint8, and bool are supported by random_()
+        # Case 1: Floating point types
         if tensor_props.is_floating_point():
-            if torch_dtype in [torch.float8_e4m3fn, torch.float8_e5m2]:
-                tmp = torch.rand(shape, dtype=torch.float32, device=device)
-                return tmp.to(torch_dtype)
+            if has_stats:
+                # Generate tensor with statistical properties matching original data
+                if std == 0 or min_val == max_val:
+                    # Constant tensor
+                    return torch.full(shape, mean, dtype=torch_dtype, device=device)
+                # Generate normal distribution with mean and std, then clamp to [min, max]
+                tensor = (
+                    torch.randn(shape, dtype=torch.float32, device=device) * std + mean
+                )
+                tensor = torch.clamp(tensor, min=min_val, max=max_val)
+                return tensor.to(torch_dtype)
             else:
-                return torch.empty(shape, dtype=torch_dtype, device=device).random_()
+                # Fallback to original random generation
+                if torch_dtype in [torch.float8_e4m3fn, torch.float8_e5m2]:
+                    tmp = torch.rand(shape, dtype=torch.float32, device=device)
+                    return tmp.to(torch_dtype)
+                else:
+                    return torch.empty(
+                        shape, dtype=torch_dtype, device=device
+                    ).random_()
+
+        # Case 2: Integer types
         elif torch_dtype in [
             torch.int8,
             torch.int16,
@@ -111,9 +143,26 @@ def _create_arg_from_info(arg_info):
             torch.uint8,
             torch.bool,
         ]:
-            return torch.empty(shape, dtype=torch_dtype, device=device).random_()
-        # Case 2: Complex numbers need special handling
+            if has_stats and torch_dtype != torch.bool:
+                # Generate tensor with statistical properties, then round for integers
+                if std == 0 or min_val == max_val:
+                    # Constant tensor
+                    return torch.full(
+                        shape, int(mean), dtype=torch_dtype, device=device
+                    )
+                tensor = (
+                    torch.randn(shape, dtype=torch.float32, device=device) * std + mean
+                )
+                tensor = torch.clamp(tensor, min=min_val, max=max_val)
+                return torch.round(tensor).to(torch_dtype)
+            else:
+                # Fallback to original random generation
+                return torch.empty(shape, dtype=torch_dtype, device=device).random_()
+
+        # Case 3: Complex numbers need special handling
         elif tensor_props.is_complex():
+            # Complex types: fallback to original logic for now
+            # TODO: Could be improved to use statistical info if available
             float_dtype = (
                 torch.float32 if torch_dtype == torch.complex64 else torch.float64
             )
@@ -121,14 +170,29 @@ def _create_arg_from_info(arg_info):
             imag_part = torch.rand(shape, dtype=float_dtype, device=device)
             return torch.complex(real_part, imag_part)
 
-        # Case 3: Handle other unsigned integers (like uint32) which fail with random_()
+        # Case 4: Handle other unsigned integers (like uint32) which fail with random_()
         elif "uint" in str(torch_dtype):
-            return torch.randint(0, 1000, shape, dtype=torch_dtype, device=device)
-            # Case 4: If we don't know how to handle the type, raise an error
+            if has_stats:
+                # Generate tensor with statistical properties for unsigned integers
+                if std == 0 or min_val == max_val:
+                    return torch.full(
+                        shape, int(mean), dtype=torch_dtype, device=device
+                    )
+                tensor = (
+                    torch.randn(shape, dtype=torch.float32, device=device) * std + mean
+                )
+                tensor = torch.clamp(tensor, min=min_val, max=max_val)
+                return torch.round(tensor).to(torch_dtype)
+            else:
+                # Fallback to original random generation
+                return torch.randint(0, 1000, shape, dtype=torch_dtype, device=device)
+
+        # Case 5: If we don't know how to handle the type, raise an error
         else:
             raise NotImplementedError(
                 f"Random data generation not implemented for dtype: {torch_dtype}"
             )
+
     elif arg_type == "triton_kernels.tensor.Tensor":
         if not TRITON_KERNELS_CUSTOM_TYPES:
             raise RuntimeError(
@@ -162,7 +226,6 @@ def _create_arg_from_info(arg_info):
             )
         Tensor, Storage, StridedLayout = _get_triton_tensor_types()
         return StridedLayout(shape=arg_info.get("initial_shape"))
-
     else:
         print(f"Warning: Unhandled argument type '{arg_type}'. Returning None.")
         return None

tritonparse/structured_logging.py

@@ -10,6 +10,7 @@ import json
 import logging
 import math
 import os
+import subprocess
 from collections import defaultdict
 from collections.abc import Mapping
 from dataclasses import asdict, is_dataclass
@@ -41,6 +42,24 @@ TRITONPARSE_KERNEL_ALLOWLIST = os.environ.get("TRITONPARSE_KERNEL_ALLOWLIST", No
 _KERNEL_ALLOWLIST_PATTERNS: Optional[List[str]] = None
 # Enable launch trace. WARNNING: it will overwrite launch_metadata function for each triton kernel.
 TRITON_TRACE_LAUNCH = os.getenv("TRITON_TRACE_LAUNCH", None) in ["1", "true", "True"]
+# Enable more tensor information collection in trace logs.
+TRITONPARSE_MORE_TENSOR_INFORMATION = os.getenv(
+    "TRITONPARSE_MORE_TENSOR_INFORMATION", None
+) in ["1", "true", "True"]
+# Inductor compiled kernel's launch tracing needs this flag to be set.
+# If TRITON_TRACE_LAUNCH is enabled, also enable TORCHINDUCTOR_RUN_JIT_POST_COMPILE_HOOK
+TORCHINDUCTOR_RUN_JIT_POST_COMPILE_HOOK = (
+    os.getenv("TORCHINDUCTOR_RUN_JIT_POST_COMPILE_HOOK", None) in ["1", "true", "True"]
+    or TRITON_TRACE_LAUNCH
+)
+# Enable NVIDIA SASS dump. It requires the CUBIN file to be localable.
+# WARNNING: it will slow down the compilation significantly.
+TRITONPARSE_DUMP_SASS = os.getenv("TRITONPARSE_DUMP_SASS", None) in [
+    "1",
+    "true",
+    "True",
+]
+
 # The flag to mark if launch is traced. It is used to avoid initilizing the launch hook twice.
 _trace_launch_enabled = False
 
@@ -252,6 +271,15 @@ def _log_torch_tensor_info(tensor_value):
     # Add data_ptr for memory tracking (optional)
     if hasattr(tensor_value, "data_ptr"):
         arg_info["data_ptr"] = hex(tensor_value.data_ptr())
+    if TRITONPARSE_MORE_TENSOR_INFORMATION:
+        try:
+            arg_info["min"] = tensor_value.min().item()
+            arg_info["max"] = tensor_value.max().item()
+            arg_info["mean"] = tensor_value.float().mean().item()
+            arg_info["std"] = tensor_value.float().std().item()
+        except (RuntimeError, ValueError, TypeError) as e:
+            log.error(f"Error computing additional tensor statistics: {e}")
+            arg_info["tensor_capture_error"] = str(e)
     return arg_info
 
 
@@ -466,6 +494,26 @@ def extract_file_content(trace_data: Dict[str, Any], metadata_group: Dict[str, s
                 message = f"<error reading file: {str(e)}>"
                 trace_data["file_content"][ir_filename] = message
                 log.debug(f"Error reading file {file_path}: {e}")
+    cubin_keys = [key for key in metadata_group.keys() if key.endswith(".cubin")]
+    cubin_path = metadata_group[cubin_keys[0]] if cubin_keys else None
+
+    if TRITONPARSE_DUMP_SASS and cubin_path:
+        filename_no_ext = os.path.splitext(os.path.basename(cubin_path))[0]
+        sass_filename = f"{filename_no_ext}.sass"
+        try:
+            import tritonparse.tools.disasm
+
+            sass_content = tritonparse.tools.disasm.extract(cubin_path)
+            trace_data["file_content"][sass_filename] = sass_content
+        except subprocess.CalledProcessError as e:
+            message = f"<nvdisasm failed: {str(e)}>"
+            trace_data["file_content"][sass_filename] = message
+        except OSError as e:
+            message = f"<error reading cubin file: {str(e)}>"
+            trace_data["file_content"][sass_filename] = message
+        except Exception as e:
+            message = f"<error dumping SASS: {str(e)}>"
+            trace_data["file_content"][sass_filename] = message
 
 
 def extract_metadata_from_src(trace_data, src):
@@ -1068,7 +1116,7 @@ def init_basic(trace_folder: Optional[str] = None):
     """
     Initialize the basic logging system for Triton compilation.
 
-    This function sets up the basic logging system for Triton kernel compilation,
+    This function sets up the basic logging system for Triton kernel compilation.
 
     Args:
         trace_folder (Optional[str]): The folder to store the trace files.
@@ -1097,17 +1145,34 @@ def init_basic(trace_folder: Optional[str] = None):
     maybe_enable_trace_launch()
 
 
-def init(trace_folder: Optional[str] = None, enable_trace_launch: bool = False):
+def init(
+    trace_folder: Optional[str] = None,
+    enable_trace_launch: bool = False,
+    enable_more_tensor_information: bool = False,
+    enable_sass_dump: Optional[bool] = False,
+):
     """
-    This function is a wrapper around init_basic() that also sets up the compilation listener.
+    This function is a wrapper around init_basic() that also sets up the compilation listener. Its arguments have higher priority than the environment variables for same settings.
 
     Args:
         trace_folder (Optional[str]): The folder to store the trace files.
         enable_trace_launch (bool): Whether to enable the trace launch hook.
+        enable_more_tensor_information (bool): Whether to enable more tensor information logging.
+            It only works when enable_trace_launch/TRITON_TRACE_LAUNCH is True.
+        enable_sass_dump (Optional[bool]): Whether to enable SASS dumping.
     """
-    global TRITON_TRACE_LAUNCH
+    global \
+        TRITON_TRACE_LAUNCH, \
+        TRITONPARSE_MORE_TENSOR_INFORMATION, \
+        TORCHINDUCTOR_RUN_JIT_POST_COMPILE_HOOK, \
+        TRITONPARSE_DUMP_SASS
     if enable_trace_launch:
         TRITON_TRACE_LAUNCH = True
+        TORCHINDUCTOR_RUN_JIT_POST_COMPILE_HOOK = True
+    if enable_more_tensor_information:
+        TRITONPARSE_MORE_TENSOR_INFORMATION = True
+    if enable_sass_dump:
+        TRITONPARSE_DUMP_SASS = True
 
     init_basic(trace_folder)
     from triton import knobs

tritonparse/tools/disasm.py

@@ -0,0 +1,81 @@
+#  Copyright (c) Meta Platforms, Inc. and affiliates.
+import re
+import subprocess
+
+# Regex patterns for nvdisasm output
+NVDISASM_FNAME_RE = re.compile(r"^\s*\.global\s+(\w+)")
+
+
+def path_to_nvdisasm():
+    from triton import knobs
+
+    return knobs.nvidia.nvdisasm.path
+
+
+def is_nvdisasm_available():
+    try:
+        if path_to_nvdisasm():
+            return True
+        else:
+            return False
+    except RuntimeError:
+        return False
+
+
+def extract(file_path):
+    """Extract SASS from CUBIN using nvdisasm.
+
+    nvdisasm output is much cleaner than cuobjdump:
+    - Single line per instruction (no encoding lines)
+    - Labels are already symbolized (.L_x_0 instead of addresses)
+    - Source line information is included
+    - No need for complex address remapping
+
+    nvdisasm Documentation:
+    https://docs.nvidia.com/cuda/cuda-binary-utilities/index.html
+    """
+    nvdisasm = path_to_nvdisasm()
+    args = [nvdisasm, "-c", "-gp", "-g", "-gi", file_path]
+    sass_str = subprocess.check_output(args)
+    sass_lines = sass_str.splitlines()
+    line_idx = 0
+
+    while line_idx < len(sass_lines):
+        line = sass_lines[line_idx].decode()
+
+        # Find function definition (.global function_name)
+        while NVDISASM_FNAME_RE.match(line) is None:
+            line_idx += 1
+            if line_idx >= len(sass_lines):
+                return None
+            line = sass_lines[line_idx].decode()
+
+        # Extract function name
+        match = NVDISASM_FNAME_RE.match(line)
+        if match is None:
+            return None
+        fname = match.group(1)
+        ret = f"Function:{fname}\n"
+
+        # Find the actual start of function content (.text.kernel_name:)
+        text_section_pattern = f".text.{fname}:"
+        line_idx += 1
+        while line_idx < len(sass_lines):
+            line = sass_lines[line_idx].decode().strip()
+            if line == text_section_pattern:
+                line_idx += 1  # Move past the .text.kernel_name: line
+                break
+            line_idx += 1
+
+        # Process all lines until next .headerflags or end of file
+        while line_idx < len(sass_lines):
+            line = sass_lines[line_idx].decode().rstrip()
+
+            # Stop if we encounter next function's headerflags
+            if line.strip().startswith(".headerflags"):
+                break
+            ret += line + "\n"
+            line_idx += 1
+
+        ret += "\n"
+        return ret

{tritonparse-0.2.4.dev20250930071536.dist-info → tritonparse-0.2.4.dev20251002071459.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tritonparse
-Version: 0.2.4.dev20250930071536
+Version: 0.2.4.dev20251002071459
 Summary: TritonParse: A Compiler Tracer, Visualizer, and mini-Reproducer Generator for Triton Kernels
 Author-email: Yueming Hao <yhao@meta.com>
 License-Expression: BSD-3-Clause

{tritonparse-0.2.4.dev20250930071536.dist-info → tritonparse-0.2.4.dev20251002071459.dist-info}/RECORD

@@ -1,4 +1,5 @@
 tritonparse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tritonparse/__main__.py,sha256=YDBolsfpyAINExxCt7CDhHFno6nzEceE9Hzr3BUs6Hg,62
 tritonparse/common.py,sha256=aT7zIPKEiuvTq_MbHgMREuVIz-gVcsRskSDlvuIOHuQ,13662
 tritonparse/context_manager.py,sha256=M2HI4APCOZw3xQ05F1QAJIa89h-RajZByZJWpZDq7vI,596
 tritonparse/event_diff.py,sha256=yOD6uNxLJroatfx2nEGr-erw24ObOrHU9P6V5pzr8do,4907
@@ -8,25 +9,27 @@ 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=kUP5HYfoV7UtVQQt8b7xDNe6pfJmYLX-O2s1gQwh5zs,43681
+tritonparse/structured_logging.py,sha256=2M1UwC6eXUMV4ybIQiaibeUgYor2Zjh6S1CVGthOMDs,46720
 tritonparse/tp_logger.py,sha256=vXzY7hMDmVnRBGBhIjFZe3nHZzG5NKKPONGUszJhGgU,242
 tritonparse/trace_processor.py,sha256=QzUOKwnOkBbwTTKBsa5ZMUABPLMJIBFtTcG2SkhO0I8,12771
 tritonparse/utils.py,sha256=cO3c82PJfToW2pDsVicP3dFh1We3UVv3c3NqC_aTb_g,4312
 tritonparse/reproducer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tritonparse/reproducer/cli.py,sha256=JvnAi1FKSpNa6eHEapRn9jdXxsj1vvyrrEEnfxTJYa8,871
-tritonparse/reproducer/orchestrator.py,sha256=XUq4S44kcFi5rgiOlcjBCEOKqNrJIfHmSdLhIfXzbeo,2441
-tritonparse/reproducer/utils.py,sha256=qi4XTKk0pWV4hgYg_GPBISEfVXlrI6tZR0A5ZZbwVyo,11132
+tritonparse/reproducer/cli.py,sha256=bhtjD3k8pr7l2R2wmoleL-pGer2YndhUaLGnZq4rRBQ,948
+tritonparse/reproducer/orchestrator.py,sha256=Uy3CSntjzgd1VZrsHKARE0XTqBgpUukGo7C8b37m2JA,2640
+tritonparse/reproducer/utils.py,sha256=UTclw48vH49g6Z2ljJL5DOZ6Rl4UDudyr0PeUySa3p8,13857
 tritonparse/reproducer/ingestion/ndjson.py,sha256=pEujTl5xXW2E2DEW8ngxXQ8qP9oawb90wBVTWHDs1jk,7372
-tritonparse/reproducer/templates/example.py,sha256=XWfXD4tDOiE213YlWWK1l1ZgXbK3BX61NnvuVTkO-S0,8595
+tritonparse/reproducer/templates/example.py,sha256=RExB1HVcHafopic3RF5_T40uNcRKmCMyLc18Bg94p4A,11686
 tritonparse/reproducer/templates/loader.py,sha256=HqjfThdDVg7q2bYWry78sIaVRkUpkcA8KQDt83YrlVE,1920
 tritonparse/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tritonparse/tools/decompress_bin_ndjson.py,sha256=kpt7DM_sSA334F1X45xdkP2OR9LuB27Pc50EkGr6CPM,4144
+tritonparse/tools/disasm.py,sha256=c4HmNNoPPeXPQBQkPVcMaHwDHbHNZNxuqXn4UIIs1Z0,2434
 tritonparse/tools/format_fix.py,sha256=Ol0Sjui8D7OzHwbamAfGnq8V5Y63uwNaFTKSORN5HkQ,3867
 tritonparse/tools/load_tensor.py,sha256=tfdmNVd9gsZqO6msQBhbXIhOvUzgc83yF64k2GDWPNk,2122
 tritonparse/tools/prettify_ndjson.py,sha256=r2YlHwFDTHgML7KljRmMsHaDg29q8gOQAgyDKWJhxRM,11062
 tritonparse/tools/readme.md,sha256=w6PWYfYnRgoPArLjxG9rVrpcLUkoVMGuRlbpF-o0IQM,110
-tritonparse-0.2.4.dev20250930071536.dist-info/licenses/LICENSE,sha256=4ZciugpyN7wcM4L-9pyDh_etvMUeIfBhDTyH1zeZlQM,1515
-tritonparse-0.2.4.dev20250930071536.dist-info/METADATA,sha256=mjc5L2YgsgDRw970IxV0KdFhsWRASAaP8lMiX-pEKXw,6580
-tritonparse-0.2.4.dev20250930071536.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tritonparse-0.2.4.dev20250930071536.dist-info/top_level.txt,sha256=ITcTKgp3vf_bXV9vixuQU9IrZa3L1EfDSZwvRzRaoJU,12
-tritonparse-0.2.4.dev20250930071536.dist-info/RECORD,,
+tritonparse-0.2.4.dev20251002071459.dist-info/licenses/LICENSE,sha256=4ZciugpyN7wcM4L-9pyDh_etvMUeIfBhDTyH1zeZlQM,1515
+tritonparse-0.2.4.dev20251002071459.dist-info/METADATA,sha256=L9kPxL_yQ4BXVxTI0P-q-wP5c2ssREBOuSk6dwZqZRk,6580
+tritonparse-0.2.4.dev20251002071459.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tritonparse-0.2.4.dev20251002071459.dist-info/entry_points.txt,sha256=7P8TuH_nMXcPl1r8udA96SW8ccvAznZqTpCWLWDnV2o,53
+tritonparse-0.2.4.dev20251002071459.dist-info/top_level.txt,sha256=ITcTKgp3vf_bXV9vixuQU9IrZa3L1EfDSZwvRzRaoJU,12
+tritonparse-0.2.4.dev20251002071459.dist-info/RECORD,,

tritonparse-0.2.4.dev20251002071459.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+tritonparse = tritonparse.run:main