austin-python 2.0.0__py3-none-any.whl → 2.1.1__py3-none-any.whl

austin/events.py

@@ -1,8 +1,9 @@
 import typing as t
+from collections import namedtuple
 from dataclasses import dataclass
 
 
-ThreadName = str
+ThreadName = namedtuple("ThreadName", ["thread", "iid"])
 ProcessId = int
 InterpreterId = int
 MicroSeconds = int

austin/format/collapsed_stack.py

@@ -48,7 +48,7 @@ def parse_frame(frame: str) -> AustinFrame:
         filename, function, line = frame.rsplit(":", maxsplit=2)
     except ValueError:
         raise InvalidFrame(frame) from None
-    return AustinFrame(filename=filename, function=function, line=int(line))
+    return AustinFrame(filename=filename, function=function, line=int(line or 0))
 
 
 def parse_collapsed_stack(sample: str) -> AustinSample:

austin/format/mojo.py

@@ -1,7 +1,10 @@
+import abc
 import asyncio
+import io
 import typing as t
 from dataclasses import dataclass
 from dataclasses import field
+from dataclasses import fields
 from enum import Enum
 
 from austin.events import AustinEvent
@@ -76,12 +79,35 @@ class MojoEventHandler:
         ...
 
 
+@dataclass(frozen=True, eq=True)
 class MojoEvent:
     """MOJO event."""
 
-    def __init__(self) -> None:
-        """Initialize the event."""
-        self.raw = bytes([])
+    EVENT_ID: t.ClassVar = None
+
+    def ref(self) -> int:
+        return getattr(self, fields(self)[0].name)
+
+    def to_bytes(self) -> bytes:
+        buffer = bytearray([self.EVENT_ID])
+        for f in fields(self):
+            value = getattr(self, f.name)
+            field_type = (
+                f.type.__args__[0]
+                if isinstance(f.type, t._UnionGenericAlias)
+                else f.type
+            )
+            if field_type is str:
+                buffer += value.encode()
+                buffer += b"\x00"
+            elif field_type is int:
+                buffer += to_varint(value)
+            elif issubclass(field_type, MojoEvent):
+                buffer += to_varint(value.ref())
+            else:
+                msg = f"Invalid MOJO event field type {f.type}"
+                raise TypeError(msg)
+        return bytes(buffer)
 
 
 class MojoMetricType(str, Enum):
@@ -98,11 +124,24 @@ class MojoMetric(MojoEvent):
     metric_type: MojoMetricType
     value: int
 
+    def to_bytes(self) -> bytes:
+        buffer = bytearray(
+            [
+                MojoEvents.METRIC_TIME
+                if self.metric_type is MojoMetricType.TIME
+                else MojoEvents.METRIC_MEMORY
+            ]
+        )
+        buffer += to_varint(self.value)
+        return bytes(buffer)
+
 
 @dataclass(frozen=True, eq=True)
 class MojoString(MojoEvent):
     """MOJO string."""
 
+    EVENT_ID = MojoEvents.STRING
+
     key: int
     value: str
 
@@ -111,12 +150,16 @@ class MojoString(MojoEvent):
 class MojoStringReference(MojoEvent):
     """MOJO string reference."""
 
+    EVENT_ID = MojoEvents.STRING_REF
+
     string: MojoString
 
 
 class MojoIdle(MojoEvent):
     """MOJO idle event."""
 
+    EVENT_ID = MojoEvents.IDLE
+
     pass
 
 
@@ -124,6 +167,8 @@ class MojoIdle(MojoEvent):
 class MojoMetadata(MojoEvent):
     """MOJO metadata."""
 
+    EVENT_ID = MojoEvents.METADATA
+
     key: str
     value: str
 
@@ -132,6 +177,8 @@ class MojoMetadata(MojoEvent):
 class MojoStack(MojoEvent):
     """MOJO stack."""
 
+    EVENT_ID = MojoEvents.STACK
+
     pid: int
     iid: int
     tid: str
@@ -141,6 +188,8 @@ class MojoStack(MojoEvent):
 class MojoFrame(MojoEvent):
     """MOJO frame."""
 
+    EVENT_ID = MojoEvents.FRAME
+
     key: int
     filename: MojoString
     scope: MojoString
@@ -154,6 +203,8 @@ class MojoFrame(MojoEvent):
 class MojoKernelFrame(MojoEvent):
     """MOJO kernel frame."""
 
+    EVENT_ID = MojoEvents.FRAME_KERNEL
+
     scope: str
 
 
@@ -161,6 +212,8 @@ class MojoKernelFrame(MojoEvent):
 class MojoSpecialFrame(MojoEvent):
     """MOJO special frame."""
 
+    EVENT_ID = MojoEvents.FRAME_INVALID
+
     label: str
 
 
@@ -168,6 +221,8 @@ class MojoSpecialFrame(MojoEvent):
 class MojoFrameReference(MojoEvent):
     """MOJO frame reference."""
 
+    EVENT_ID = MojoEvents.FRAME_REF
+
     frame: MojoFrame
 
 
@@ -778,3 +833,120 @@ class AsyncMojoStreamReader(BaseMojoStreamReader):
                     yield self.samples[-1]
         if self._running_sample is not None:
             yield self._finalize_sample()
+
+
+class BaseMojoStreamWriter(abc.ABC):
+    HEADER = b"MOJ\x03"
+
+    def __init__(self, mojo: t.Any) -> None:
+        self.mojo = mojo
+        self._frames: t.Dict[AustinFrame, MojoFrame] = {}
+        self._strings: t.Dict[str, MojoString] = {
+            EMPTY.value: EMPTY,
+            UNKNOWN.value: UNKNOWN,
+        }
+
+        self._meta: t.Dict[str, str] = {}
+
+        self._mode: t.Optional[str] = None
+        self._gc = False
+
+        self._new_entries: t.List[MojoEvent] = []
+
+    def set_metadata(self, metadata: AustinMetadata) -> None:
+        self._meta[metadata.name] = metadata.value
+        if metadata.name == "gc" and metadata.value == "on":
+            self._gc = True
+        elif metadata.name == "mode":
+            self._mode = metadata.value
+
+    def resolve_string(self, value: str) -> MojoString:
+        try:
+            return self._strings[value]
+        except KeyError:
+            self._strings[value] = mojo_string = MojoString(len(self._strings), value)
+            self._new_entries.append(mojo_string)
+            return mojo_string
+
+    def resolve_frame(self, frame: AustinFrame) -> MojoFrame:
+        try:
+            return self._frames[frame]
+        except KeyError:
+            self._frames[frame] = mojo_frame = MojoFrame(
+                len(self._frames),
+                self.resolve_string(frame.filename),
+                self.resolve_string(frame.function),
+                frame.line,
+                frame.line_end or 0,
+                frame.column or 0,
+                frame.column_end or 0,
+            )
+            self._new_entries.append(mojo_frame)
+            return mojo_frame
+
+    @abc.abstractmethod
+    def write(self, event: AustinEvent) -> int: ...
+
+
+class MojoStreamWriter(BaseMojoStreamWriter):
+    def __init__(self, mojo: io.BytesIO):
+        super().__init__(mojo)
+
+        mojo.write(self.HEADER)
+
+    def write(self, event: AustinEvent) -> int:
+        size = 0
+
+        if isinstance(event, AustinMetadata):
+            self.set_metadata(event)
+            size += self.mojo.write(
+                MojoMetadata(key=event.name, value=event.value).to_bytes()
+            )
+
+        elif isinstance(event, AustinSample):
+            frames = (
+                [self.resolve_frame(f) for f in event.frames] if event.frames else []
+            )
+
+            size += self.mojo.write(
+                MojoStack(
+                    pid=event.pid, iid=event.iid or 0, tid=event.thread
+                ).to_bytes()
+            )
+
+            while self._new_entries:
+                size += self.mojo.write(self._new_entries.pop(0).to_bytes())
+
+            for frame in frames:
+                size += self.mojo.write(MojoFrameReference(frame).to_bytes())
+
+            if self._gc:
+                size += self.mojo.write(bytes([MojoEvents.GC]))
+
+            if self._mode == "full":
+                if event.idle:
+                    size += self.mojo.write(bytes([MojoEvents.IDLE]))
+                size += self.mojo.write(
+                    MojoMetric(MojoMetricType.TIME, event.metrics.time or 0).to_bytes()
+                )
+                size += self.mojo.write(
+                    MojoMetric(
+                        MojoMetricType.MEMORY, event.metrics.memory or 0
+                    ).to_bytes()
+                )
+            elif self._mode == "memory":
+                size += self.mojo.write(
+                    MojoMetric(
+                        MojoMetricType.MEMORY, event.metrics.memory or 0
+                    ).to_bytes()
+                )
+            else:
+                size += self.mojo.write(
+                    MojoMetric(MojoMetricType.TIME, event.metrics.time or 0).to_bytes()
+                )
+
+        else:
+            msg = f"Unhandled event type {type(event)}"
+            raise TypeError(msg)
+
+        return size

austin/format/pprof/__main__.py

@@ -22,6 +22,7 @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 from argparse import ArgumentParser
+from pathlib import Path
 
 from austin.events import AustinMetadata
 from austin.events import AustinSample
@@ -41,19 +42,21 @@ def main() -> None:
 
     arg_parser.add_argument(
         "input",
-        type=str,
+        type=Path,
         help="The input file containing Austin samples.",
     )
     arg_parser.add_argument(
-        "output", type=str, help="The name of the output pprof file."
+        "output",
+        type=Path,
+        help="The name of the output pprof file.",
     )
 
-    arg_parser.add_argument("-V", "--version", action="version", version="0.2.0")
+    arg_parser.add_argument("-V", "--version", action="version", version="0.2.1")
 
     args = arg_parser.parse_args()
 
     try:
-        with AustinFileReader(args.input) as fin:
+        with args.input.open() as austin, AustinFileReader(austin) as fin:
             pprof = None
             for e in fin:
                 if isinstance(e, AustinMetadata) and e.name == "mode":

austin/format/speedscope.py

@@ -26,6 +26,7 @@ from dataclasses import asdict
 from dataclasses import dataclass
 from dataclasses import field
 from enum import Enum
+from pathlib import Path
 from typing import Dict
 from typing import List
 from typing import Optional
@@ -33,13 +34,14 @@ from typing import TextIO
 from typing import Union
 
 from austin.events import AustinFrame
+from austin.events import AustinMetadata
 from austin.events import AustinSample
 from austin.format import Mode
 from austin.format.collapsed_stack import AustinFileReader
 from austin.format.collapsed_stack import InvalidSample
 
 
-__version__ = "0.3.0"
+__version__ = "0.3.1"
 
 SpeedscopeJson = Dict
 SpeedscopeWeight = int
@@ -208,11 +210,11 @@ def main() -> None:
 
     arg_parser.add_argument(
         "input",
-        type=str,
+        type=Path,
         help="The input file containing Austin samples in normal format.",
     )
     arg_parser.add_argument(
-        "output", type=str, help="The name of the output Speedscope JSON file."
+        "output", type=Path, help="The name of the output Speedscope JSON file."
     )
     arg_parser.add_argument(
         "--indent", type=int, help="Give a non-null value to prettify the JSON output."
@@ -223,24 +225,30 @@ def main() -> None:
     args = arg_parser.parse_args()
 
     try:
-        with AustinFileReader(args.input) as fin:
-            mode = fin.metadata["mode"]
-            speedscope = Speedscope(os.path.basename(args.input), mode, args.indent)
+        with args.input.open() as austin, AustinFileReader(austin) as fin:
+            speedscope = None
             for event in fin:
-                if not isinstance(event, AustinSample):
-                    continue
-                try:
-                    speedscope.add_sample(event)
-                except InvalidSample:
-                    continue
+                if isinstance(event, AustinMetadata):
+                    if event.name == "mode":
+                        speedscope = Speedscope(
+                            os.path.basename(args.input), event.value, args.indent
+                        )
+                elif isinstance(event, AustinSample):
+                    if speedscope is not None:
+                        speedscope.add_sample(event)
+                else:
+                    raise ValueError("Invalid sample found in input file")
+
+        if speedscope is None:
+            raise RuntimeError("Invalid input file: no mode metadata found")
+
+        with args.output.open("w") as fout:
+            speedscope.dump(fout)
 
     except FileNotFoundError:
         print(f"No such input file: {args.input}")
         exit(1)
 
-    with open(args.output, "w") as fout:
-        speedscope.dump(fout)
-
 
 if __name__ == "__main__":
     main()

austin/stats.py

@@ -28,13 +28,15 @@ from enum import Enum
 from threading import Lock
 from typing import Any
 from typing import Dict
+from typing import Generator
 from typing import List
 from typing import Optional
-from typing import TextIO
+from typing import Tuple
 
 from austin.events import AustinEventIterator
 from austin.events import AustinFrame
 from austin.events import AustinMetadata
+from austin.events import AustinMetrics
 from austin.events import AustinSample
 from austin.events import ProcessId
 from austin.events import ThreadName
@@ -44,6 +46,15 @@ from austin.format.collapsed_stack import AustinEventCollapsedStackFormatter
 COLLAPSED_STACK_FORMATTER = AustinEventCollapsedStackFormatter()
 
 
+class AustinStatsType(Enum):
+    """Austin stats type."""
+
+    WALL = "wall"
+    CPU = "cpu"
+    MEMORY_ALLOC = "memory_alloc"
+    MEMORY_DEALLOC = "memory_dealloc"
+
+
 @dataclass
 class HierarchicalStats:
     """Base dataclass for representing hierarchical statistics.
@@ -87,7 +98,7 @@ class HierarchicalStats:
         """Get a child from the children collection."""
         return self.children[label]
 
-    def collapse(self, prefix: str = "") -> List[str]:
+    def collapse(self, stats_type: AustinStatsType) -> Generator[Any, None, None]:
         """Collapse the hierarchical statistics."""
         raise NotImplementedError()
 
@@ -100,19 +111,26 @@ class FrameStats(HierarchicalStats):
     height: int = 0
     children: Dict[AustinFrame, "FrameStats"] = field(default_factory=dict)  # type: ignore[assignment]
 
-    def collapse(self, prefix: str = "") -> List[str]:
+    def collapse(
+        self, stats_type: AustinStatsType
+    ) -> Generator[Tuple[List[AustinFrame], AustinMetrics], None, None]:
         """Collapse the hierarchical statistics."""
-        frame = COLLAPSED_STACK_FORMATTER.format(self.label)
+        frame = self.label
 
-        if not self.children:
-            return [f";{prefix}{frame} {self.own}"]
+        if self.own:
+            yield (
+                [frame],
+                AustinMetrics(time=self.own)
+                if stats_type in {AustinStatsType.CPU, AustinStatsType.WALL}
+                else AustinMetrics(memory=self.own),
+            )
 
-        own = [] if self.own == 0 else [f";{prefix}{frame} {self.own}"]
-        return own + [
-            f";{prefix}{frame}{rest}"
-            for _, child in self.children.items()
-            for rest in child.collapse()
-        ]
+        if self.children:
+            yield from (
+                ([frame, *rest], metric)
+                for child in self.children.values()
+                for rest, metric in child.collapse(stats_type)
+            )
 
 
 class ThreadStats(HierarchicalStats):
@@ -121,16 +139,26 @@ class ThreadStats(HierarchicalStats):
     label: ThreadName
     children: Dict[AustinFrame, FrameStats] = field(default_factory=dict)  # type: ignore[assignment]
 
-    def collapse(self, prefix: str = "") -> List[str]:
+    def collapse(
+        self, stats_type: AustinStatsType
+    ) -> Generator[Tuple[ThreadName, List[AustinFrame], AustinMetrics], None, None]:
         """Collapse the hierarchical statistics."""
-        if not self.children:
-            return [f";T{self.label} {self.own}"]
-        own = [] if self.own == 0 else [f";T{self.label} {self.own}"]
-        return own + [
-            f";T{self.label}{rest}"
-            for stats in self.children.values()
-            for rest in stats.collapse()
-        ]
+
+        if self.own:
+            yield (
+                self.label,
+                [],
+                AustinMetrics(time=self.own)
+                if stats_type in {AustinStatsType.CPU, AustinStatsType.WALL}
+                else AustinMetrics(memory=self.own),
+            )
+
+        if self.children:
+            yield from (
+                (self.label, frames, metric)
+                for stats in self.children.values()
+                for frames, metric in stats.collapse(stats_type)
+            )
 
 
 @dataclass
@@ -140,13 +168,21 @@ class ProcessStats:
     pid: ProcessId
     threads: Dict[ThreadName, ThreadStats] = field(default_factory=dict)
 
-    def collapse(self) -> List[str]:
+    def collapse(
+        self, stats_type: AustinStatsType
+    ) -> Generator[AustinSample, None, None]:
         """Collapse the hierarchical statistics."""
-        return [
-            f"P{self.pid}{rest}"
-            for _, thread in self.threads.items()
-            for rest in thread.collapse()
-        ]
+        yield from (
+            AustinSample(
+                pid=self.pid,
+                iid=thread_name.iid,
+                thread=thread_name.thread,
+                frames=tuple(frames),
+                metrics=metric,
+            )
+            for thread in self.threads.values()
+            for thread_name, frames, metric in thread.collapse(stats_type)
+        )
 
     def get_thread(self, thread_name: ThreadName) -> Optional[ThreadStats]:
         """Get thread statistics from this process by name.
@@ -157,15 +193,6 @@ class ProcessStats:
         return self.threads.get(thread_name)
 
 
-class AustinStatsType(Enum):
-    """Austin stats type."""
-
-    WALL = "wall"
-    CPU = "cpu"
-    MEMORY_ALLOC = "memory_alloc"
-    MEMORY_DEALLOC = "memory_dealloc"
-
-
 @dataclass
 class AustinStats:
     """Austin statistics.
@@ -190,19 +217,6 @@ class AustinStats:
 
         return copy
 
-    def dump(self, stream: TextIO) -> None:
-        """Dump the statistics to the given text stream."""
-        with self._lock:
-            stream.write(f"# mode: {self.stats_type.value.partition('_')[0]}\n\n")
-            for _, process in self.processes.items():
-                samples = process.collapse()
-
-                if all(sample.endswith(" 0 0") for sample in samples):
-                    samples = [sample[:-4] for sample in samples]
-
-                for sample in samples:
-                    stream.write(sample + "\n")
-
     def get_process(self, pid: ProcessId) -> ProcessStats:
         """Get process statistics for the given PID."""
         return self.processes[pid]
@@ -272,7 +286,8 @@ class AustinStats:
             return
 
         pid = sample.pid
-        thread_stats = ThreadStats(sample.thread, own=0, total=metric)
+        thread_name = ThreadName(sample.thread, sample.iid or 0)
+        thread_stats = ThreadStats(thread_name, own=0, total=metric)
 
         # Convert the list of frames into a nested FrameStats instance
         stats: HierarchicalStats = thread_stats
@@ -285,12 +300,16 @@ class AustinStats:
 
         with self._lock:
             if pid not in self.processes:
-                self.processes[pid] = ProcessStats(pid, {sample.thread: thread_stats})
+                self.processes[pid] = ProcessStats(pid, {thread_name: thread_stats})
                 return
 
             process = self.processes[pid]
-            if sample.thread not in process.threads:
-                process.threads[sample.thread] = thread_stats
+            if thread_name not in process.threads:
+                process.threads[thread_name] = thread_stats
                 return
 
-            process.threads[sample.thread] << thread_stats
+            process.threads[thread_name] << thread_stats
+
+    def flatten(self) -> Generator[AustinSample, None, None]:
+        for process in self.processes.values():
+            yield from process.collapse(self.stats_type)

austin/tools/mojodbg.py

@@ -33,12 +33,13 @@ from austin.format.mojo import MojoStreamReader
 __version__ = "0.1.0"
 
 
-def mojodbg(args: t.Any) -> None:
-    mojo = MojoStreamReader(args.input.expanduser().open("rb"))
+def mojodbg(mojo: MojoStreamReader, echo: bool = False) -> None:
     offset = 4
     last_event_data: t.Tuple[t.Optional[MojoEvent], int] = (None, 0)
     try:
         for e in mojo.parse():
+            if echo:
+                print(e)
             last_event_data = (e, offset)
             offset = mojo._offset + 1
     except Exception as exc:
@@ -63,10 +64,15 @@ def main() -> None:
     argp = ArgumentParser(prog="mojodbg", description="Debug MOJO files.")
 
     argp.add_argument("input", type=Path, help="The MOJO file to debug.")
+    argp.add_argument(
+        "-e", "echo", action="store_true", help="Echo all the MOJO events"
+    )
     argp.add_argument("-V", "--version", action="version", version=__version__)
 
+    args = argp.parse_args()
+
     try:
-        mojodbg(args := argp.parse_args())
+        mojodbg(MojoStreamReader(args.input.expanduser().open("rb")), args.echo)
     except FileNotFoundError:
         print(f"No such input file: {args.input}")
         exit(2)

{austin_python-2.0.0.dist-info → austin_python-2.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: austin-python
-Version: 2.0.0
+Version: 2.1.1
 Summary: Python wrapper for Austin, the CPython frame stack sampler.
 Project-URL: homepage, https://github.com/P403n1x87/austin-python
 Project-URL: documentation, https://austin-python.readthedocs.io

{austin_python-2.0.0.dist-info → austin_python-2.1.1.dist-info}/RECORD

@@ -4,26 +4,26 @@ austin/base.py,sha256=wAYVZQi3hcgJA9cVg3mfc3f3E0qwFXmeX7UX6qgn2Pk,7554
 austin/cli.py,sha256=--PKm2I4NBBSSSBV5l-YC0mcmLjrvb1FHzxgY4dkby4,7826
 austin/config.py,sha256=PEwdG2Cy8ay1SrFr2N6YfQSZwseYBA1BA5dMfocKR3A,2091
 austin/errors.py,sha256=lCDSTANW_95Az_eDXbn__JRBllB9yw7tGnFo1-tw09Q,1046
-austin/events.py,sha256=yk1FZVNfQJxxUDjUmXb5Q_ajhgVCJS_CS3aObCYQv_M,2160
+austin/events.py,sha256=39BHP-pUHotZZxJ-MbECFu5_QOAnRJP-_hFEdYPYwKY,2235
 austin/simple.py,sha256=iTmJGAjSBeUv82SgdMTwdNlAQwuK33RyU8FkBCE8rRg,5579
-austin/stats.py,sha256=ef3_vOI4xIACDo3l6wl0fwuz2k3qvRI57R2ZSuUEGFs,10368
+austin/stats.py,sha256=8cpuq3cyZUpGkm2VZS3j1Zpz-Yhr3i9Wg6bR-sGwWJM,10933
 austin/threads.py,sha256=AvcoOkr3FeFAGBcqgXukNIt9xOZUipv7pXMqPIL_Qts,3649
 austin/format/__init__.py,sha256=ZtBJCLpTiZaLFwCN1UbMXLQvYjOSpwmtyGwqgK8yruQ,405
-austin/format/collapsed_stack.py,sha256=D1JaB3vREouVW_CcO_yY3IuuIRP3lhi2WXHr2AXxYZM,7241
+austin/format/collapsed_stack.py,sha256=61iEu3oFl9e3vUNHvhpAQzgJndxtE7WcbRwvRLO03S4,7246
 austin/format/compress.py,sha256=YEceebWzVB7eSCntnJ89_rIcbzBskvZGy86D5QgZli0,3741
-austin/format/mojo.py,sha256=fGY_6o-7_XMQvb1lt2T1-RzxLywmn0x0OAnkQklt04U,22983
-austin/format/speedscope.py,sha256=Ydfi02f90F9BZftA-tb5qSZO-zzbE-lKXPz3f6_YRUc,7981
+austin/format/mojo.py,sha256=IlnFsH9gGofENWBMdbpAc0BrutNGvetk5JLLJeCHKuo,28294
+austin/format/speedscope.py,sha256=RvlFugm0S3ATMf9lmzH8jrX4oBt8PJ0j9EsuXWayOQc,8381
 austin/format/pprof/__init__.py,sha256=DvY1CDnPqBc-GUv9fidtMplshIIXj_HWZ3SlWOJoLxc,6805
-austin/format/pprof/__main__.py,sha256=4O4gmVvw807A1Wmxajj7dGly0M9kd-NYhEq9m47Bjas,2583
+austin/format/pprof/__main__.py,sha256=pzWoSmlFrjfmAAq5I4SIIDmxavdLStCnlw3NlBxgyDo,2652
 austin/format/pprof/profile.proto,sha256=fPfBgzXIEmFdrrwgTQWs-9GwKjt-TShRmJq-eaxDx88,8840
 austin/format/pprof/profile_pb2.py,sha256=i_uM8lDExR95yz7qnEVikhpkpNvetKaYzoiH7AbMAt8,28214
 austin/tools/diff.py,sha256=KnY9kD5mmSKALCNxnSe-dSObC4LgkoxLGnoTiklKa5M,4821
-austin/tools/mojodbg.py,sha256=gpNhPJf1qrIEruBgAQ4wZk7cte0gE29vL3ZDi6HES4U,2632
+austin/tools/mojodbg.py,sha256=BGdngj-r1c-GAQDrs_oJ_x4QZxuL4t_OQ194fvJJm7A,2817
 austin/tools/resolve.py,sha256=pEOBiP8FNkaJqDTj3fOK8dx5-EocroqZDXLL3CzCWLY,7677
-austin_python-2.0.0.dist-info/METADATA,sha256=OKQj3tS0abH3Eox2TNORgeohIaIs5JiH1K2pz6LLjcw,7535
-austin_python-2.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-austin_python-2.0.0.dist-info/entry_points.txt,sha256=YatHOUQsHQ3WABcrNKPf4RWatQ0CzbR-1ClXjMjZys8,329
-austin_python-2.0.0.dist-info/licenses/AUTHORS,sha256=pARRmpJQYH8iWy_0SonXsxOiV02AFitowle4AtURxUI,45
-austin_python-2.0.0.dist-info/licenses/COPYING,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-austin_python-2.0.0.dist-info/licenses/LICENSE.md,sha256=edVDhmEiPf2W5lWzqLkrj6EYLSrCeYg9MJy28YsiMFU,34937
-austin_python-2.0.0.dist-info/RECORD,,
+austin_python-2.1.1.dist-info/METADATA,sha256=t22jsfhB6Ssk8vR8LIwD0l9bcw0LnUb0eEXKx-uJEp0,7535
+austin_python-2.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+austin_python-2.1.1.dist-info/entry_points.txt,sha256=YatHOUQsHQ3WABcrNKPf4RWatQ0CzbR-1ClXjMjZys8,329
+austin_python-2.1.1.dist-info/licenses/AUTHORS,sha256=pARRmpJQYH8iWy_0SonXsxOiV02AFitowle4AtURxUI,45
+austin_python-2.1.1.dist-info/licenses/COPYING,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+austin_python-2.1.1.dist-info/licenses/LICENSE.md,sha256=edVDhmEiPf2W5lWzqLkrj6EYLSrCeYg9MJy28YsiMFU,34937
+austin_python-2.1.1.dist-info/RECORD,,