austin-python 2.1.2__py3-none-any.whl → 2.3.0__py3-none-any.whl

austin/base.py

@@ -43,7 +43,6 @@ from austin.errors import AustinError
 from austin.events import AustinMetadata
 from austin.events import AustinSample
 
-
 SemVer = Tuple[int, int, int]
 
 

austin/events.py

@@ -1,7 +1,6 @@
 import typing as t
 from dataclasses import dataclass
 
-
 ProcessId = int
 ThreadName = str
 InterpreterId = int
@@ -44,6 +43,35 @@ class AustinMetadata(AustinEvent):
     value: str
 
 
+@dataclass(frozen=True)
+class AustinTask:
+    """A node in an asyncio task tree (3.14+ only).
+
+    ``frames`` is this task's own last-known suspended coroutine-chain
+    snapshot -- empty if it was never captured suspended (e.g. it was only
+    ever seen actively running rather than awaiting something). ``awaiting``
+    are the tasks this task is itself awaiting, i.e. the tasks for which this
+    task is the direct waiter.
+
+    ``elapsed`` does NOT describe ``frames``. Austin only re-samples a task's
+    chain (and reports a new node) when its identity has actually changed
+    since the last scan, so the two are always one step apart: ``frames`` is
+    the task's brand new position (just captured because it changed), while
+    ``elapsed`` is how long the task dwelled at its *previous*, now-replaced
+    position -- the earliest point at which that duration could be known at
+    all. None on a task's first-ever sighting, when there is no previous
+    position to report a duration for. Always a wall/CPU time value, or None
+    if Austin was run in pure memory mode (no per-task memory delta exists to
+    report -- see austin's own py_proc.c, _py_proc__maybe_discover_asyncio).
+    """
+
+    task_id: int
+    name: t.Optional[str]
+    frames: t.Tuple[AustinFrame, ...] = ()
+    elapsed: t.Optional[MicroSeconds] = None
+    awaiting: t.Tuple["AustinTask", ...] = ()
+
+
 @dataclass(frozen=True)
 class AustinSample(AustinEvent):
     """Austin sample."""
@@ -64,6 +92,7 @@ class AustinSample(AustinEvent):
     frames: t.Optional[t.Tuple[AustinFrame, ...]] = None
     gc: t.Optional[bool] = None
     idle: t.Optional[bool] = None
+    tasks: t.Tuple[AustinTask, ...] = ()
 
     def key(
         self,

austin/format/collapsed_stack.py

@@ -1,6 +1,6 @@
+import typing as t
 from functools import singledispatchmethod
 from pathlib import Path
-import typing as t
 
 from austin.events import AustinEvent
 from austin.events import AustinEventIterator
@@ -10,7 +10,6 @@ from austin.events import AustinMetrics
 from austin.events import AustinSample
 from austin.format.mojo import MojoStreamReader
 
-
 __version__ = "0.1.0"
 
 
@@ -66,17 +65,17 @@ def parse_collapsed_stack(sample: str) -> AustinSample:
         raise InvalidSample(sample)
 
     if sample[0] != "P":
-        raise InvalidSample(f"No process ID in sample '{sample}'")
+        raise InvalidSample(f"No process ID in sample {sample!r}")
 
     head, _, metrics = sample.rpartition(" ")
     process, _, rest = head.partition(";")
     try:
         pid = int(process[1:])
     except ValueError:
-        raise InvalidSample(f"Invalid process ID in sample '{sample}'") from None
+        raise InvalidSample(f"Invalid process ID in sample {sample!r}") from None
 
     if rest[0] != "T":
-        raise InvalidSample(f"No thread ID in sample '{sample}'")
+        raise InvalidSample(f"No thread ID in sample {sample!r}")
 
     thread, _, frames_data = rest.partition(";")
     thread = thread[1:]

austin/format/compress.py

@@ -62,9 +62,11 @@ def compress(source: AustinFileReader, dest: TextIO, counts: bool = False) -> No
         formatter.format(
             AustinSample.from_key_and_metrics(
                 key,
-                AustinMetrics(memory=metrics)
-                if is_memory
-                else AustinMetrics(time=metrics),
+                (
+                    AustinMetrics(memory=metrics)
+                    if is_memory
+                    else AustinMetrics(time=metrics)
+                ),
             )
         )
         + "\n"
@@ -108,10 +110,10 @@ def main() -> None:
 
     try:
         with (
-            AustinFileReader(args.input) as fin,
+            open(args.input) as _fin,
             open(args.output or args.input, "w") as fout,
         ):
-            compress(fin, fout, args.counts)
+            compress(AustinFileReader(_fin), fout, args.counts)
     except FileNotFoundError:
         print(f"No such input file: {args.input}")
         exit(1)

austin/format/mojo.py

@@ -1,6 +1,5 @@
 import abc
 import asyncio
-import io
 import typing as t
 from dataclasses import dataclass
 from dataclasses import field
@@ -13,10 +12,16 @@ from austin.events import AustinFrame
 from austin.events import AustinMetadata
 from austin.events import AustinMetrics
 from austin.events import AustinSample
+from austin.events import AustinTask
 from austin.events import InterpreterId
 from austin.events import ProcessId
 from austin.events import ThreadName
 
+# Guards against a corrupted/cyclic waiter graph in the source stream -- a
+# real await chain never comes anywhere close to this. Mirrors austin's own
+# WHERE_MAX_TREE_DEPTH (src/events.c).
+MAX_TASK_TREE_DEPTH = 64
+
 
 def to_varint(n: int) -> bytes:
     """Convert an integer to a variable-length integer."""
@@ -67,6 +72,9 @@ class MojoEvents:
     METRIC_MEMORY = 10
     STRING = 11
     STRING_REF = 12
+    STACK_REPEAT = 13
+    TASK_STACK = 14
+    TASK_WAITER = 15
 
 
 class MojoEventHandler:
@@ -84,6 +92,7 @@ class MojoEvent:
     """MOJO event."""
 
     EVENT_ID: t.ClassVar = None
+    raw: t.ClassVar[bytes] = b""
 
     def ref(self) -> int:
         return getattr(self, fields(self)[0].name)
@@ -93,9 +102,7 @@ class MojoEvent:
         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
+                t.get_args(f.type)[0] if t.get_origin(f.type) is t.Union else f.type
             )
             if field_type is str:
                 buffer += value.encode()
@@ -127,9 +134,11 @@ class MojoMetric(MojoEvent):
     def to_bytes(self) -> bytes:
         buffer = bytearray(
             [
-                MojoEvents.METRIC_TIME
-                if self.metric_type is MojoMetricType.TIME
-                else MojoEvents.METRIC_MEMORY
+                (
+                    MojoEvents.METRIC_TIME
+                    if self.metric_type is MojoMetricType.TIME
+                    else MojoEvents.METRIC_MEMORY
+                )
             ]
         )
         buffer += to_varint(self.value)
@@ -184,6 +193,56 @@ class MojoStack(MojoEvent):
     tid: str
 
 
+@dataclass(frozen=True, eq=True)
+class MojoStackRepeat(MojoEvent):
+    """MOJO stack repeat event.
+
+    Signals that the previous sample for this thread provides the base
+    (outermost) frames for the current sample.  The frames accumulated so
+    far in the current sample are the innermost (top) part of the call stack.
+    """
+
+    EVENT_ID = MojoEvents.STACK_REPEAT
+
+
+@dataclass(frozen=True, eq=True)
+class MojoTaskWaiter(MojoEvent):
+    """MOJO task waiter event.
+
+    One edge of a task's waiter DAG: ``task_id`` is awaited by
+    ``waiter_id``.
+    """
+
+    EVENT_ID = MojoEvents.TASK_WAITER
+
+    task_id: int
+    waiter_id: int
+
+
+@dataclass(frozen=True, eq=True)
+class MojoTaskStack(MojoEvent):
+    """MOJO task stack event.
+
+    Introduces the coroutine stack of a suspended task, keyed by the remote
+    address of its TaskObj and its (possibly cached) name key (0 if
+    unresolved). The frames that make up the stack, and the trailing time
+    metric that terminates it, follow as ordinary MOJO_FRAME/MOJO_FRAME_REF/
+    MOJO_METRIC_TIME events rather than being part of this event itself --
+    see BaseMojoStreamReader's task-stack handling.
+
+    The trailing metric is always a time value, and describes how long the
+    task dwelled at its PREVIOUS position, not the frames that just followed
+    this event -- see AustinTask's own docstring for why the two are always
+    one step apart. It never appears at all when austin was run in pure
+    memory mode.
+    """
+
+    EVENT_ID = MojoEvents.TASK_STACK
+
+    task_id: int
+    name_key: int
+
+
 @dataclass(frozen=True, eq=True)
 class MojoFrame(MojoEvent):
     """MOJO frame."""
@@ -253,6 +312,29 @@ class _RunningSample:
     idle: t.Optional[bool] = None
 
 
+@dataclass
+class _RunningTaskStack:
+    task_id: int
+    name_key: int
+    frames: t.List[MojoFrame] = field(default_factory=list)
+
+
+@dataclass
+class _TaskInfo:
+    """Best-known state for one task_id.
+
+    Built up from MOJO_TASK_STACK events as they arrive. ``owner`` is the
+    (pid, thread) of whichever sample's wire bracket this task's most recent
+    MOJO_TASK_STACK fell within -- see BaseMojoStreamReader's task-stack
+    handling for why that bracket is the only ownership signal that exists.
+    """
+
+    name: t.Optional[str]
+    owner: t.Tuple[ProcessId, ThreadName]
+    frames: t.Tuple[AustinFrame, ...] = ()
+    elapsed: t.Optional[int] = None
+
+
 def int_reader() -> t.Generator[t.Optional[int], bytes, int]:
     (b,) = yield None
     while True:
@@ -322,6 +404,31 @@ class BaseMojoStreamReader(AustinEventIterator):
         self._str_reader = str_reader()
         next(self._str_reader)
 
+        # Per-thread previous frame list for STACK_REPEAT expansion.
+        # Key: (pid, thread_name); value: list of MojoFrame accumulated by the
+        # last fully-finalised sample for that thread.
+        self._prev_frames: t.Dict[t.Tuple[int, str], t.List[MojoFrame]] = {}
+
+        # Suspended-task coroutine-chain state (3.14+ asyncio). A task stack's
+        # frames/terminating time metric are ordinary MOJO_FRAME/MOJO_FRAME_REF/
+        # MOJO_METRIC_TIME events on the wire, indistinguishable by event ID
+        # alone from those of the enclosing regular stack sample -- so while
+        # this is not None, get_frame_ref/get_time_metric route to it instead
+        # of the running sample.
+        self._running_task_stack: t.Optional[_RunningTaskStack] = None
+
+        # Best-known state per task_id, keyed by remote TaskObj address.
+        self._task_info: t.Dict[int, _TaskInfo] = {}
+
+        # Best-known waiter DAG edges: (task_id, waiter_id) pairs, meaning
+        # task_id is awaited by waiter_id. The wire re-emits a task's
+        # *complete* current waiter set whenever it changes (never a diff --
+        # see py_asyncio.c's fingerprint comment), so a fresh batch for a
+        # task_id replaces its previous edges; batch boundaries are inferred
+        # from consecutive same-task_id events (see get_task_waiter).
+        self._task_edges: t.Set[t.Tuple[int, int]] = set()
+        self._last_waiter_task_id: t.Optional[int] = None
+
         # Austin events
         self.metadata: t.Dict[str, str] = {}
         self.samples: t.List[AustinSample] = []
@@ -381,28 +488,64 @@ class BaseMojoStreamReader(AustinEventIterator):
                         for metric_type, metric in self._running_sample.metrics.items()
                     }
                 ),
-                frames=tuple(
-                    AustinFrame(
-                        filename=mf.filename.value,
-                        function=mf.scope.value,
-                        line=mf.line,
-                        line_end=mf.line_end,
-                        column=mf.column,
-                        column_end=mf.column_end,
+                frames=(
+                    tuple(
+                        AustinFrame(
+                            filename=mf.filename.value,
+                            function=mf.scope.value,
+                            line=mf.line,
+                            line_end=mf.line_end,
+                            column=mf.column,
+                            column_end=mf.column_end,
+                        )
+                        for mf in self._running_sample.frames
                     )
-                    for mf in self._running_sample.frames
-                )
-                if self._running_sample.frames
-                else None,
+                    if self._running_sample.frames
+                    else None
+                ),
                 gc=self._running_sample.gc,
                 idle=self._running_sample.idle,
+                tasks=self.get_tasks(
+                    self._running_sample.pid, self._running_sample.thread
+                ),
             )
         )
 
+        # Save fully-expanded frame list for future STACK_REPEAT events from
+        # this thread.
+        self._prev_frames[(self._running_sample.pid, self._running_sample.thread)] = (
+            list(self._running_sample.frames)
+        )
+
         self._running_sample = None
 
         return sample
 
+    @staticmethod
+    def _is_native_frame(frame: MojoFrame) -> bool:
+        name = frame.filename.value
+        return not name.endswith(".py") and not (
+            name.startswith("<") and name.endswith(">")
+        )
+
+    def get_stack_repeat(self) -> MojoStackRepeat:
+        """Handle a STACK_REPEAT event.
+
+        The previous sample's frames (minus any trailing native frames that
+        belonged to the old top-of-stack above the eval frame) are prepended
+        to the frames accumulated so far.
+        """
+        assert self._running_sample is not None
+        key = (self._running_sample.pid, self._running_sample.thread)
+        prev = list(self._prev_frames.get(key, []))
+        # Strip native frames from the innermost (top) end of the previous
+        # stack — those were above the eval frame and have now been replaced
+        # by the new frames in the current sample.
+        while prev and self._is_native_frame(prev[-1]):
+            prev.pop()
+        self._running_sample.frames = prev + self._running_sample.frames
+        return MojoStackRepeat()
+
     def get_stack(self, pid: int, iid: t.Optional[int], thread: str) -> MojoStack:
         """Parse a stack."""
         if self._running_sample is not None:
@@ -448,11 +591,148 @@ class BaseMojoStreamReader(AustinEventIterator):
         """Parse a frame reference."""
         frame = self._frame_map[self.ref(ref)]
 
-        assert self._running_sample is not None, self._running_sample
-        self._running_sample.frames.append(frame)
+        if self._running_task_stack is not None:
+            self._running_task_stack.frames.append(frame)
+        else:
+            assert self._running_sample is not None, self._running_sample
+            self._running_sample.frames.append(frame)
 
         return MojoFrameReference(frame)
 
+    def get_task_waiter(self, task_id: int, waiter_id: int) -> MojoTaskWaiter:
+        """Parse a task waiter edge."""
+        if self._last_waiter_task_id != task_id:
+            # Starting a fresh batch for this task_id: the wire re-emits the
+            # complete current waiter set whenever it changes, so drop
+            # whatever we knew about this task_id's waiters before.
+            self._task_edges = {e for e in self._task_edges if e[0] != task_id}
+            self._last_waiter_task_id = task_id
+
+        self._task_edges.add((task_id, waiter_id))
+
+        return MojoTaskWaiter(task_id, waiter_id)
+
+    def get_task_stack(self, task_id: int, name_key: int) -> MojoTaskStack:
+        """Parse the header of a suspended task's coroutine-chain snapshot.
+
+        The frames and terminating time metric that complete it arrive as
+        subsequent, ordinary events -- see get_frame_ref/get_time_metric.
+        """
+        self._running_task_stack = _RunningTaskStack(task_id, name_key)
+
+        return MojoTaskStack(task_id, name_key)
+
+    def _finalize_task_stack(self, elapsed: int) -> None:
+        """Finalize the running task stack.
+
+        Triggered by its terminating MOJO_METRIC_TIME (see get_time_metric).
+        ``ts.frames`` (the task's brand new position) and ``elapsed`` (how
+        long it dwelled at its previous one) describe two different moments
+        even though they land in the same _TaskInfo/AustinTask -- see
+        AustinTask's own docstring. The task's owner is recorded as whichever
+        sample is currently being assembled: this event only ever arrives
+        bracketed inside that sample's own MOJO_STACK...next-MOJO_STACK
+        window, so there's nothing else it could belong to.
+
+        An empty ``ts.frames`` is a closing flush -- the task has just been
+        evicted (completed, or otherwise gone), and this only carries its
+        final dwell time, with no new content and no meaningful owner (by
+        the time eviction runs, every thread for this cycle has already had
+        its turn, so "whichever sample is currently being assembled" is
+        arbitrary here, not this task's actual owner). Only update elapsed
+        on whatever's already known; leave frames/owner untouched rather
+        than wiping the task's last real position right as it disappears.
+        """
+        ts = self._running_task_stack
+        assert ts is not None, ts
+        assert self._running_sample is not None, self._running_sample
+
+        if not ts.frames:
+            existing = self._task_info.get(ts.task_id)
+            if existing is not None:
+                existing.elapsed = elapsed
+            self._running_task_stack = None
+            return
+
+        name = self._lookup_string(ts.name_key).value if ts.name_key else None
+
+        self._task_info[ts.task_id] = _TaskInfo(
+            name=name,
+            owner=(self._running_sample.pid, self._running_sample.thread),
+            frames=tuple(
+                AustinFrame(
+                    filename=mf.filename.value,
+                    function=mf.scope.value,
+                    line=mf.line,
+                    line_end=mf.line_end,
+                    column=mf.column,
+                    column_end=mf.column_end,
+                )
+                for mf in ts.frames
+            ),
+            elapsed=elapsed,
+        )
+
+        self._running_task_stack = None
+
+    def get_tasks(self, pid: ProcessId, thread: ThreadName) -> t.Tuple[AustinTask, ...]:
+        """Return the current best-known root tasks owned by (pid, thread).
+
+        Every root task it owns (nobody awaits it), and everything it
+        transitively awaits, as one AustinTask per root -- a thread can own
+        more than one at once (e.g. several siblings under one gather()).
+
+        Mirrors austin's own where_event_handler__render_tree: a task only
+        appears if it was itself captured suspended at least once (a waiter
+        edge naming a task we never saw a MOJO_TASK_STACK for -- e.g. it was
+        only ever seen actively running -- is omitted, exactly like austin's
+        own where_event_handler__find_task returning NULL for it). Like that
+        C-side counterpart, this is a no-op (returns empty) when (pid,
+        thread) owns no tasks, so callers can call it unconditionally.
+        """
+
+        def has_parent(task_id: int) -> bool:
+            return any(t_id == task_id for t_id, _ in self._task_edges)
+
+        def build(task_id: int, depth: int) -> AustinTask:
+            info = self._task_info[task_id]
+            awaiting = (
+                tuple(
+                    build(awaited_id, depth + 1)
+                    for awaited_id, waiter_id in self._task_edges
+                    if waiter_id == task_id and awaited_id in self._task_info
+                )
+                if depth < MAX_TASK_TREE_DEPTH
+                else ()
+            )
+            return AustinTask(
+                task_id=task_id,
+                name=info.name,
+                frames=info.frames,
+                elapsed=info.elapsed,
+                awaiting=awaiting,
+            )
+
+        owner = (pid, thread)
+        roots = [
+            task_id
+            for task_id, info in self._task_info.items()
+            if info.owner == owner and not has_parent(task_id)
+        ]
+
+        if not roots:
+            # Best-effort fallback, matching austin's own render_tree: if
+            # every one of this owner's tasks appears to have a parent (a
+            # cyclic/bogus edge), there's no true root -- show each as its
+            # own top-level tree rather than silently showing nothing.
+            roots = [
+                task_id
+                for task_id, info in self._task_info.items()
+                if info.owner == owner
+            ]
+
+        return tuple(build(task_id, 0) for task_id in roots)
+
     def get_kernel_frame(self, name: str) -> MojoKernelFrame:
         """Parse kernel frame."""
         return MojoKernelFrame(name)
@@ -466,7 +746,17 @@ class BaseMojoStreamReader(AustinEventIterator):
         return metric
 
     def get_time_metric(self, value: int) -> MojoMetric:
-        """Parse time metric."""
+        """Parse time metric.
+
+        A task stack's frame sequence has no length prefix on the wire -- its
+        end is only knowable by the terminating MOJO_METRIC_TIME that always
+        follows it (see mojo_event_handler__handle_task_stack_end), which is
+        why this, rather than get_task_stack, is where finalization happens.
+        """
+        if self._running_task_stack is not None:
+            self._finalize_task_stack(value)
+            return MojoMetric(MojoMetricType.TIME, value)
+
         return self._get_metric(MojoMetricType.TIME, value)
 
     def get_memory_metric(self, value: int) -> MojoMetric:
@@ -579,7 +869,7 @@ class MojoStreamReader(BaseMojoStreamReader):
     @handles(MojoEvents.METRIC_TIME)
     def parse_time_metric(self) -> MojoMetric:
         """Parse time metric."""
-        return self._parse_metric(MojoMetricType.TIME)
+        return self.get_time_metric(self.read_int())
 
     @handles(MojoEvents.METRIC_MEMORY)
     def parse_memory_metric(self) -> MojoMetric:
@@ -611,6 +901,21 @@ class MojoStreamReader(BaseMojoStreamReader):
         """Parse string reference."""
         return self.get_string_ref(self.read_int())
 
+    @handles(MojoEvents.STACK_REPEAT)
+    def parse_stack_repeat(self) -> MojoStackRepeat:
+        """Parse a stack repeat event."""
+        return self.get_stack_repeat()
+
+    @handles(MojoEvents.TASK_WAITER)
+    def parse_task_waiter(self) -> MojoTaskWaiter:
+        """Parse a task waiter edge."""
+        return self.get_task_waiter(self.read_int(), self.read_int())
+
+    @handles(MojoEvents.TASK_STACK)
+    def parse_task_stack(self) -> MojoTaskStack:
+        """Parse the header of a suspended task's coroutine-chain snapshot."""
+        return self.get_task_stack(self.read_int(), self.read_int())
+
     def parse_event(self) -> t.Optional[MojoEvent]:
         """Parse a single event."""
         try:
@@ -670,7 +975,12 @@ class MojoStreamReader(BaseMojoStreamReader):
         if self._running_sample is not None:
             yield self._finalize_sample()
 
-    def hexdump(self, start: int, end: int, highlight: t.Set[int] = set()) -> None:  # noqa: B006
+    def hexdump(
+        self,
+        start: int,
+        end: int,
+        highlight: t.Set[int] = set(),  # noqa: B006
+    ) -> None:
         """Print a hexdump of the MOJO file."""
         self.mojo.seek(start)
         data = self.mojo.read(end - start)
@@ -760,7 +1070,7 @@ class AsyncMojoStreamReader(BaseMojoStreamReader):
     @handles(MojoEvents.METRIC_TIME)
     async def parse_time_metric(self) -> MojoMetric:
         """Parse time metric."""
-        return await self._parse_metric(MojoMetricType.TIME)
+        return self.get_time_metric(await self.read_int())
 
     @handles(MojoEvents.METRIC_MEMORY)
     async def parse_memory_metric(self) -> MojoMetric:
@@ -794,6 +1104,21 @@ class AsyncMojoStreamReader(BaseMojoStreamReader):
         """Parse string reference."""
         return self.get_string_ref(await self.read_int())
 
+    @handles(MojoEvents.STACK_REPEAT)
+    async def parse_stack_repeat(self) -> MojoStackRepeat:
+        """Parse a stack repeat event."""
+        return self.get_stack_repeat()
+
+    @handles(MojoEvents.TASK_WAITER)
+    async def parse_task_waiter(self) -> MojoTaskWaiter:
+        """Parse a task waiter edge."""
+        return self.get_task_waiter(await self.read_int(), await self.read_int())
+
+    @handles(MojoEvents.TASK_STACK)
+    async def parse_task_stack(self) -> MojoTaskStack:
+        """Parse the header of a suspended task's coroutine-chain snapshot."""
+        return self.get_task_stack(await self.read_int(), await self.read_int())
+
     async def parse_event(self) -> t.Optional[MojoEvent]:
         """Parse a single event."""
         try:
@@ -855,7 +1180,9 @@ class AsyncMojoStreamReader(BaseMojoStreamReader):
 
 
 class BaseMojoStreamWriter(abc.ABC):
-    HEADER = b"MOJ\x03"
+    """Base class for MOJO stream writers."""
+
+    HEADER = b"MOJ\x04"
 
     def __init__(self, mojo: t.Any) -> None:
         self.mojo = mojo
@@ -871,6 +1198,7 @@ class BaseMojoStreamWriter(abc.ABC):
         self._gc = False
 
         self._new_entries: t.List[MojoEvent] = []
+        self._task_ids: t.Dict[int, int] = {}
 
     def set_metadata(self, metadata: AustinMetadata) -> None:
         self._meta[metadata.name] = metadata.value
@@ -887,6 +1215,14 @@ class BaseMojoStreamWriter(abc.ABC):
             self._new_entries.append(mojo_string)
             return mojo_string
 
+    def resolve_task_id(self, task_id: int) -> int:
+        try:
+            return self._task_ids[task_id]
+        except KeyError:
+            compact_id = len(self._task_ids)
+            self._task_ids[task_id] = compact_id
+            return compact_id
+
     def resolve_frame(self, frame: AustinFrame) -> MojoFrame:
         try:
             return self._frames[frame]
@@ -903,12 +1239,85 @@ class BaseMojoStreamWriter(abc.ABC):
             self._new_entries.append(mojo_frame)
             return mojo_frame
 
+    def _collect_tasks(
+        self,
+        tasks: t.Sequence[AustinTask],
+        seen: t.Dict[int, AustinTask],
+        edges: t.Dict[int, t.Set[int]],
+    ) -> None:
+        """Flatten a root-task list into its distinct tasks and waiter edges.
+
+        A task can legitimately appear more than once (once per waiter, if
+        it has more than one -- see AustinTask's own docstring on
+        ``awaiting``), so this collects each task_id's own stack exactly
+        once (``seen``, first occurrence wins) and every one of its waiters
+        together (``edges``), rather than re-walking and re-emitting it once
+        per occurrence.
+        """
+        for task in tasks:
+            seen.setdefault(task.task_id, task)
+            for awaited in task.awaiting:
+                edges.setdefault(awaited.task_id, set()).add(task.task_id)
+            self._collect_tasks(task.awaiting, seen, edges)
+
+    def write_tasks(self, tasks: t.Sequence[AustinTask]) -> int:
+        """Write every task's own coroutine-chain snapshot, then every waiter edge.
+
+        See _collect_tasks for why each is written exactly once, and edges
+        for one task_id are always written contiguously (required for
+        MojoStreamReader.get_task_waiter's own batch-replace logic to
+        reconstruct a multi-waiter task correctly).
+        """
+        size = 0
+
+        seen: t.Dict[int, AustinTask] = {}
+        edges: t.Dict[int, t.Set[int]] = {}
+        self._collect_tasks(tasks, seen, edges)
+
+        for task in seen.values():
+            name_key = self.resolve_string(task.name).key if task.name else 0
+
+            while self._new_entries:
+                size += self.mojo.write(self._new_entries.pop(0).to_bytes())
+
+            size += self.mojo.write(
+                MojoTaskStack(
+                    task_id=self.resolve_task_id(task.task_id), name_key=name_key
+                ).to_bytes()
+            )
+
+            task_frames = [self.resolve_frame(f) for f in task.frames]
+
+            while self._new_entries:
+                size += self.mojo.write(self._new_entries.pop(0).to_bytes())
+
+            for frame in task_frames:
+                size += self.mojo.write(MojoFrameReference(frame).to_bytes())
+
+            size += self.mojo.write(
+                MojoMetric(MojoMetricType.TIME, task.elapsed or 0).to_bytes()
+            )
+
+        for task_id, waiter_ids in edges.items():
+            compact_task_id = self.resolve_task_id(task_id)
+            for waiter_id in waiter_ids:
+                size += self.mojo.write(
+                    MojoTaskWaiter(
+                        task_id=compact_task_id,
+                        waiter_id=self.resolve_task_id(waiter_id),
+                    ).to_bytes()
+                )
+
+        return size
+
     @abc.abstractmethod
-    def write(self, event: AustinEvent) -> int: ...
+    def write(self, event: AustinEvent) -> int: ...  # noqa: E704
 
 
 class MojoStreamWriter(BaseMojoStreamWriter):
-    def __init__(self, mojo: io.BytesIO):
+    """MOJO stream writer."""
+
+    def __init__(self, mojo: t.BinaryIO) -> None:
         super().__init__(mojo)
 
         mojo.write(self.HEADER)
@@ -923,23 +1332,31 @@ class MojoStreamWriter(BaseMojoStreamWriter):
             )
 
         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()
             )
 
+            # Task-scan payload (waiter edges + suspended coroutine-chain
+            # snapshots) is written before this sample's own frames -- it
+            # rides between the enclosing MOJO_STACK header and the sample's
+            # own frame dump on the real wire too (see austin's own
+            # py_proc.c, _py_proc__sample_threads).
+            if event.tasks:
+                size += self.write_tasks(event.tasks)
+
+            frames = (
+                [self.resolve_frame(f) for f in event.frames] if event.frames else []
+            )
+
             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:
+            if event.gc:
                 size += self.mojo.write(bytes([MojoEvents.GC]))
 
             if self._mode == "full":

austin/format/mojo_compress.py

@@ -0,0 +1,122 @@
+# This file is part of "austin-python" which is released under GPL.
+#
+# See file LICENCE or go to http://www.gnu.org/licenses/ for full license
+# details.
+#
+# austin-python is a Python wrapper around Austin, the CPython frame stack
+# sampler.
+#
+# Copyright (c) 2018-2020 Gabriele N. Tornetta <phoenix1987@gmail.com>.
+# All rights reserved.
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import typing as t
+from io import BytesIO
+
+from austin.events import AustinMetadata
+from austin.events import AustinMetrics
+from austin.events import AustinSample
+from austin.format.mojo import MojoStreamReader
+from austin.format.mojo import MojoStreamWriter
+
+
+def compress(source: t.BinaryIO, dest: t.BinaryIO) -> None:
+    """Compress a MOJO source stream.
+
+    Aggregates all metrics on equal stacks, where equality is determined by
+    pid, interpreter id, thread, frames, gc flag, and idle flag.
+    """
+    time_stats: t.Dict[AustinSample.Key, int] = {}
+    memory_stats: t.Dict[AustinSample.Key, int] = {}
+    metadata: t.List[AustinMetadata] = []
+    samples: t.Dict[AustinSample.Key, AustinSample] = {}
+
+    reader = MojoStreamReader(source)
+
+    for event in reader:
+        if isinstance(event, AustinMetadata):
+            metadata.append(event)
+            continue
+
+        assert isinstance(event, AustinSample)
+
+        key = event.key()
+        if key not in samples:
+            samples[key] = event
+        if event.metrics.time is not None:
+            time_stats[key] = time_stats.get(key, 0) + event.metrics.time
+        if event.metrics.memory is not None:
+            memory_stats[key] = memory_stats.get(key, 0) + event.metrics.memory
+
+    writer = MojoStreamWriter(dest)
+
+    for m in metadata:
+        writer.write(m)
+
+    for key in samples:
+        writer.write(
+            AustinSample.from_key_and_metrics(
+                key,
+                AustinMetrics(
+                    time=time_stats.get(key),
+                    memory=memory_stats.get(key),
+                ),
+            )
+        )
+
+
+def main() -> None:
+    """mojo-compress entry point."""
+    from argparse import ArgumentParser
+
+    arg_parser = ArgumentParser(
+        prog="mojo-compress",
+        description=(
+            "Compress a MOJO sample file by aggregating the collected samples."
+        ),
+    )
+
+    arg_parser.add_argument(
+        "input",
+        type=str,
+        help="The input MOJO file.",
+    )
+    arg_parser.add_argument(
+        "output",
+        type=str,
+        help="The output MOJO file; defaults to the input file for in-place compression.",
+        nargs="?",
+        default=None,
+    )
+
+    arg_parser.add_argument("-V", "--version", action="version", version="0.1.0")
+
+    args = arg_parser.parse_args()
+
+    try:
+        with open(args.input, "rb") as fin:
+            buffer = BytesIO()
+            compress(fin, buffer)
+
+        output_path = args.output or args.input
+        with open(output_path, "wb") as fout:
+            fout.write(buffer.getvalue())
+
+    except FileNotFoundError:
+        print(f"No such input file: {args.input}")
+        exit(1)
+
+
+if __name__ == "__main__":
+    main()

austin/format/pprof/__init__.py

@@ -33,7 +33,6 @@ from austin.format import Mode
 from austin.format.pprof.profile_pb2 import Profile
 from austin.format.pprof.profile_pb2 import Sample
 
-
 PROCESS_ID_LABEL = "Process ID"
 THREAD_ID_LABEL = "Thread ID"
 INTERPRETER_ID_LABEL = "Interpreter ID"

austin/format/speedscope.py

@@ -38,8 +38,6 @@ 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.1"
 

austin/stats.py

@@ -42,7 +42,6 @@ from austin.events import AustinSample
 from austin.events import ProcessId
 from austin.format.collapsed_stack import AustinEventCollapsedStackFormatter
 
-
 ThreadInfo = namedtuple("ThreadInfo", ["thread", "iid"])
 
 
@@ -123,9 +122,11 @@ class FrameStats(HierarchicalStats):
         if self.own:
             yield (
                 [frame],
-                AustinMetrics(time=self.own)
-                if stats_type in {AustinStatsType.CPU, AustinStatsType.WALL}
-                else AustinMetrics(memory=self.own),
+                (
+                    AustinMetrics(time=self.own)
+                    if stats_type in {AustinStatsType.CPU, AustinStatsType.WALL}
+                    else AustinMetrics(memory=self.own)
+                ),
             )
 
         if self.children:
@@ -146,14 +147,15 @@ class ThreadStats(HierarchicalStats):
         self, stats_type: AustinStatsType
     ) -> Generator[Tuple[ThreadInfo, List[AustinFrame], AustinMetrics], None, None]:
         """Collapse the hierarchical statistics."""
-
         if self.own:
             yield (
                 self.label,
                 [],
-                AustinMetrics(time=self.own)
-                if stats_type in {AustinStatsType.CPU, AustinStatsType.WALL}
-                else AustinMetrics(memory=self.own),
+                (
+                    AustinMetrics(time=self.own)
+                    if stats_type in {AustinStatsType.CPU, AustinStatsType.WALL}
+                    else AustinMetrics(memory=self.own)
+                ),
             )
 
         if self.children:

austin/tools/diff.py

@@ -30,9 +30,11 @@ from typing import TextIO
 from typing import Tuple
 
 from austin.events import AustinFrame
+from austin.events import AustinMetrics
+from austin.format.collapsed_stack import InvalidSample
+from austin.format.collapsed_stack import parse_collapsed_stack
 from austin.format.compress import compress
 
-
 FoldedStack = List[AustinFrame]
 
 
@@ -41,7 +43,7 @@ def _similarities(
 ) -> List[Tuple[Tuple[int, int], float]]:
     """O(n * log(n)), n = len(x) * len(y)."""
 
-    def score(a: List[Frame], b: List[Frame]) -> float:
+    def score(a: List[AustinFrame], b: List[AustinFrame]) -> float:
         """Score two folded stacks."""
         if not len(a) and not len(b):
             return 1
@@ -90,12 +92,12 @@ def diff(a: TextIO, b: TextIO) -> str:
         compress(source, _)
         return _.getvalue()
 
-    def get_frames(text: str) -> List[Tuple[FoldedStack, Metric]]:
+    def get_frames(text: str) -> List[Tuple[FoldedStack, AustinMetrics]]:
         """Get the folded stacks and metrics from a string of samples."""
         x = []
         for _ in text.splitlines(keepends=False):
             try:
-                sample = Sample.parse(_)
+                sample = parse_collapsed_stack(_)
                 x.append((sample.frames, sample.metrics))
             except InvalidSample:
                 continue

austin/tools/mojodbg.py

@@ -29,7 +29,6 @@ from traceback import print_exc
 from austin.format.mojo import MojoEvent
 from austin.format.mojo import MojoStreamReader
 
-
 __version__ = "0.1.0"
 
 

austin/tools/resolve.py

@@ -30,7 +30,6 @@ from austin.format.mojo import MojoStreamReader
 from austin.format.mojo import MojoString
 from austin.format.mojo import to_varint
 
-
 __version__ = "0.2.0"
 
 
@@ -176,8 +175,10 @@ def resolve_mojo(input: str, output: str) -> None:
                     filename, scope, line = resolved
                     new_value = filename or scope
 
-                    event.raw = event.raw.replace(
-                        event.value.encode(), new_value.encode()
+                    object.__setattr__(
+                        event,
+                        "raw",
+                        event.raw.replace(event.value.encode(), new_value.encode()),
                     )
 
                     if filename is not None:
@@ -185,9 +186,11 @@ def resolve_mojo(input: str, output: str) -> None:
 
             elif isinstance(event, MojoFrame):
                 if event.filename.key in maps.lines:
-                    event.raw = (
+                    object.__setattr__(
+                        event,
+                        "raw",
                         event.raw[: -len(to_varint(event.line))]
-                        + maps.lines[event.filename.key]
+                        + maps.lines[event.filename.key],
                     )
 
             fout.write(event.raw)

{austin_python-2.1.2.dist-info → austin_python-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: austin-python
-Version: 2.1.2
+Version: 2.3.0
 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
@@ -15,12 +15,12 @@ Keywords: development,performance,profiling,testing
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Python: >=3.9
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
 Requires-Dist: protobuf~=3.12
 Requires-Dist: psutil>=5.7.0
 Requires-Dist: toml~=0.10
@@ -187,7 +187,7 @@ raw samples by aggregation.
 # Compatibility
 
 The latest `austin-python` package is tested on Linux, macOS and Windows with
-Python 3.9-3.13.
+Python 3.9-3.14.
 
 
 # Documentation

austin_python-2.3.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+austin/__init__.py,sha256=1SCBrKP0MCtuALvQ3tZ8N8-L7pzIzqrMfA3emxtpHkM,974
+austin/aio.py,sha256=Cpq_W1YxL_fUPKBbkupLBHSKi3Sys9OQCcsyq8wYHKY,6594
+austin/base.py,sha256=Xq734VKzE2ggShs6UThsGznBGazg-gCw_nZEJDJKMlM,7553
+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=6d-rNYG_yXx6VOqyyMWalcBHvstriCZNWWPttDhO_zM,3579
+austin/simple.py,sha256=iTmJGAjSBeUv82SgdMTwdNlAQwuK33RyU8FkBCE8rRg,5579
+austin/stats.py,sha256=xY4BZtiE1Z4Bfucah1da6jwkEREvd1jLfmW4WuCgbP0,11084
+austin/threads.py,sha256=AvcoOkr3FeFAGBcqgXukNIt9xOZUipv7pXMqPIL_Qts,3649
+austin/format/__init__.py,sha256=ZtBJCLpTiZaLFwCN1UbMXLQvYjOSpwmtyGwqgK8yruQ,405
+austin/format/collapsed_stack.py,sha256=vD0CFkUgnRqHaA7dYsh4QYRZubE5IxyhVFnuPa37BSs,7245
+austin/format/compress.py,sha256=by6i79o0pEmGf2Py8edC6RWHVdr5RGsG2FWT6xQjUvk,3797
+austin/format/mojo.py,sha256=mEmMdRreh60p_-rKTCecqVSd7bCxkHssa-pK2_vHKrM,45734
+austin/format/mojo_compress.py,sha256=qhzXsenUThxwAz1lX1Z8xtGgBpPEIbD3cqZz2Iar3ws,3711
+austin/format/speedscope.py,sha256=hIuB1A8wbGFFLQUpZqdM7Tlf4dqFwyy01zFHDybs2Iw,8324
+austin/format/pprof/__init__.py,sha256=E2JJDaw_k_m18OZeITKtepUUIo3n09UHdkpvabSSABc,6804
+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=5yrHlniofIeMSqzOUD55l2h6Ps0GqEpfisFRj65gpdQ,5008
+austin/tools/mojodbg.py,sha256=l8Lsa4rTQLXfkau8RyGziyz8ZyPEgacFVXafbHT9FN4,2816
+austin/tools/resolve.py,sha256=bTXkll68nOtXqa0XHW79mp_seAJW8_bhd6ej6wa2_Oc,7816
+austin_python-2.3.0.dist-info/METADATA,sha256=K7EAem3JpnpvVlVY0XQ3WyV-sSfkY5UcAP-hPKLZYF8,7537
+austin_python-2.3.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+austin_python-2.3.0.dist-info/entry_points.txt,sha256=xmPVC_6UkSOYu7-YMYm3BwIcMFYEhRw0qlF05Cq5gf0,378
+austin_python-2.3.0.dist-info/licenses/AUTHORS,sha256=pARRmpJQYH8iWy_0SonXsxOiV02AFitowle4AtURxUI,45
+austin_python-2.3.0.dist-info/licenses/COPYING,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
+austin_python-2.3.0.dist-info/licenses/LICENSE.md,sha256=edVDhmEiPf2W5lWzqLkrj6EYLSrCeYg9MJy28YsiMFU,34937
+austin_python-2.3.0.dist-info/RECORD,,

{austin_python-2.1.2.dist-info → austin_python-2.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.32.0
 Root-Is-Purelib: true
 Tag: py3-none-any

{austin_python-2.1.2.dist-info → austin_python-2.3.0.dist-info}/entry_points.txt

@@ -4,5 +4,6 @@ austin-diff = austin.tools.diff:main
 austin2pprof = austin.format.pprof.__main__:main
 austin2speedscope = austin.format.speedscope:main
 austinp-resolve = austin.tools.resolve:main
+mojo-compress = austin.format.mojo_compress:main
 mojo2austin = austin.format.collapsed_stack:main
 mojodbg = austin.tools.mojodbg:main

austin_python-2.1.2.dist-info/RECORD

@@ -1,29 +0,0 @@
-austin/__init__.py,sha256=1SCBrKP0MCtuALvQ3tZ8N8-L7pzIzqrMfA3emxtpHkM,974
-austin/aio.py,sha256=Cpq_W1YxL_fUPKBbkupLBHSKi3Sys9OQCcsyq8wYHKY,6594
-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=NppffZg_lbKIin2TyvIGgfJXnOmBKzB2e0nQV4_94JA,2160
-austin/simple.py,sha256=iTmJGAjSBeUv82SgdMTwdNlAQwuK33RyU8FkBCE8rRg,5579
-austin/stats.py,sha256=4kVeZ5NJsoSEnogqiDyjAbLeuf5DPiELHfCEbjFb0zk,10990
-austin/threads.py,sha256=AvcoOkr3FeFAGBcqgXukNIt9xOZUipv7pXMqPIL_Qts,3649
-austin/format/__init__.py,sha256=ZtBJCLpTiZaLFwCN1UbMXLQvYjOSpwmtyGwqgK8yruQ,405
-austin/format/collapsed_stack.py,sha256=VCkTJssgcF4IHGP6kzV5dT9AC9Qjbq8eGx9AVOp6cyU,7246
-austin/format/compress.py,sha256=YEceebWzVB7eSCntnJ89_rIcbzBskvZGy86D5QgZli0,3741
-austin/format/mojo.py,sha256=mEcKgaZkVkH4YGVLj4m31_MAPKfYK-BNI7oWyiPub0U,28824
-austin/format/speedscope.py,sha256=RvlFugm0S3ATMf9lmzH8jrX4oBt8PJ0j9EsuXWayOQc,8381
-austin/format/pprof/__init__.py,sha256=DvY1CDnPqBc-GUv9fidtMplshIIXj_HWZ3SlWOJoLxc,6805
-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=BGdngj-r1c-GAQDrs_oJ_x4QZxuL4t_OQ194fvJJm7A,2817
-austin/tools/resolve.py,sha256=pEOBiP8FNkaJqDTj3fOK8dx5-EocroqZDXLL3CzCWLY,7677
-austin_python-2.1.2.dist-info/METADATA,sha256=wdZJGpu-uI1aH1NwbKstmCYnYdsXzX2UZ-6c-gFzjTg,7535
-austin_python-2.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-austin_python-2.1.2.dist-info/entry_points.txt,sha256=YatHOUQsHQ3WABcrNKPf4RWatQ0CzbR-1ClXjMjZys8,329
-austin_python-2.1.2.dist-info/licenses/AUTHORS,sha256=pARRmpJQYH8iWy_0SonXsxOiV02AFitowle4AtURxUI,45
-austin_python-2.1.2.dist-info/licenses/COPYING,sha256=jOtLnuWt7d5Hsx6XXB2QxzrSe2sWWh3NgMfFRetluQM,35147
-austin_python-2.1.2.dist-info/licenses/LICENSE.md,sha256=edVDhmEiPf2W5lWzqLkrj6EYLSrCeYg9MJy28YsiMFU,34937
-austin_python-2.1.2.dist-info/RECORD,,