printsection 0.4.0__tar.gz → 0.5.0__tar.gz

{printsection-0.4.0 → printsection-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: printsection
-Version: 0.4.0
+Version: 0.5.0
 Summary: 출력 구간을 나누는 가운데 정렬 구분선 + 라이브러리 호출 흐름 추적 출력
 License-Expression: MIT
 License-File: LICENSE
@@ -85,7 +85,8 @@ s = format_section("실습 결과")   # 출력하지 않고 문자열 반환
 ## 라이브러리 호출 추적: `print_trace_start` / `print_trace_end`
 
 두 함수 사이에서 실행된 **라이브러리 내부 호출**을 순서대로 보여줍니다.
-**메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 끝나면 파일·메소드별로 묶은 요약을 출력합니다.
+`print_trace_end()`를 호출하면 **메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 이어서 파일·메소드별로 묶은 요약을 출력합니다.
+(같은 호출 반복을 접으려면 끝까지 모아야 해서, 트리는 추적이 끝날 때 한꺼번에 나옵니다.)
 라이브러리가 내부에서 어떤 순서로 무엇을 호출하는지 공부할 때 쓰면 좋습니다.
 
 ```python
@@ -106,6 +107,10 @@ print_trace_end()
 │  │  ├ Tokenizer.__init__  ·  _tokenizer.py:105  ·  packaging
 │  │  ├ _parse_requirement  ·  _parser.py:110  ·  packaging
 │  │  │  ├ Tokenizer.consume  ·  _tokenizer.py:116  ·  packaging
+│  │  │  │  ├ Tokenizer.check  ·  _tokenizer.py:121  ·  packaging
+│  │  │  ├ Tokenizer.expect  ·  _tokenizer.py:142  ·  packaging
+│  │  │  │  ├ Tokenizer.check  ·  _tokenizer.py:121  ·  packaging
+│  │  │  │  ├ Tokenizer.read  ·  _tokenizer.py:151  ·  packaging
 ...
 
 --------------------TRACE END---------------------
@@ -123,6 +128,30 @@ packaging/_tokenizer.py
 
 기본으로는 `site-packages`에 설치된 라이브러리만 보여줍니다. 내가 작성한 코드와 파이썬 표준 라이브러리는 빠집니다.
 
+### 출력이 너무 많을 때
+
+LangChain 같은 큰 라이브러리는 한 번 호출에도 수백~수천 줄이 나옵니다. 아래 순서대로 좁혀 보세요.
+
+```python
+print_trace_start(
+    ["langchain_core"],   # 1. 공부할 패키지만 (pydantic, httpx 등 제외)
+    hide_private=True,    # 2. _로 시작하는 내부 함수 숨기기
+    unique=True,          # 3. 같은 메소드는 처음 한 번만
+    max_depth=3,          # 4. 깊이 제한
+)
+```
+
+`langchain-core`의 `prompt | RunnableLambda(...)` 체인 `invoke` 한 번 기준:
+
+| 설정 | 줄 수 |
+|---|---|
+| 접기 없음 (`collapse=False`) | 231 |
+| 기본값 (연속 반복 접기) | 193 |
+| `+ hide_private=True` | 153 |
+| `+ unique=True` | 48 |
+| `+ ["langchain_core"]` | 38 |
+| `+ max_depth=3` | 29 |
+
 ### 추적 옵션
 
 ```python
@@ -131,6 +160,8 @@ print_trace_start(max_depth=2)                     # 3단계 깊이까지만
 print_trace_start(user=True)                       # 내 코드 호출도 함께
 print_trace_start(file="trace.log")                # 화면 대신 파일로 저장
 print_trace_start(hide_private=True)               # _로 시작하는 내부 함수 숨기기
+print_trace_start(unique=True)                     # 메소드마다 처음 호출만
+print_trace_start(collapse=False)                  # 반복 호출도 접지 않고 전부
 ```
 
 | 옵션 | 기본값 | 설명 |
@@ -143,6 +174,8 @@ print_trace_start(hide_private=True)               # _로 시작하는 내부
 | `file` | 화면 | 파일 객체 또는 파일 경로 |
 | `show_line` | `True` | 파일 이름 뒤에 함수 정의 줄 번호 표시 |
 | `hide_private` | `False` | `_parse`, `_Foo.run`처럼 `_`로 시작하는 내부 함수·클래스 숨김 (`__init__` 같은 특수 메소드는 표시) |
+| `collapse` | `True` | 같은 메소드가 연달아 호출되면 `Foo.bar ×3` 한 줄로 접음 (하위 호출은 첫 번째 것만 표시) |
+| `unique` | `False` | 메소드마다 처음 호출만 표시. 이후 같은 메소드는 줄을 생략하고, 그 안에서 처음 등장하는 메소드만 위 단계에 붙여 표시 |
 | `threads` | `False` | 이후 새로 시작되는 스레드도 추적 |
 | `header` | `True` | 시작/종료 구분선 출력 |
 
@@ -160,7 +193,7 @@ with trace(["langchain_core"], max_depth=3):
 
 ### 참고
 
-- 출력이 너무 많으면 `packages`로 패키지를 좁히고, `hide_private=True`로 내부 함수를 숨기고, `max_depth`로 깊이를 제한해 보세요. 숨긴 함수 안에서 호출된 공개 함수는 그대로 보이고, 가장 가까운 상위 호출 아래에 붙습니다.
-- LangChain 같은 큰 라이브러리는 호출이 수천 개 나올 수 있습니다. `packages`나 `max_depth`로 범위를 좁혀 쓰세요.
+- `hide_private`나 `unique`로 숨긴 호출 안에서 불린 새 함수는 그대로 보이고, 가장 가까운 상위 호출 아래에 붙습니다.
+- 요약의 호출 횟수·시간에는 접히거나 생략된 호출까지 모두 포함됩니다 (`hide_private`로 숨긴 함수는 제외).
 - 제너레이터/코루틴(스트리밍, async)은 처음 호출될 때 한 번만 표시합니다.
 - 추적하는 동안에는 코드가 느려집니다. 공부하거나 디버깅할 때만 쓰세요.

{printsection-0.4.0 → printsection-0.5.0}/README.md

@@ -72,7 +72,8 @@ s = format_section("실습 결과")   # 출력하지 않고 문자열 반환
 ## 라이브러리 호출 추적: `print_trace_start` / `print_trace_end`
 
 두 함수 사이에서 실행된 **라이브러리 내부 호출**을 순서대로 보여줍니다.
-**메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 끝나면 파일·메소드별로 묶은 요약을 출력합니다.
+`print_trace_end()`를 호출하면 **메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 이어서 파일·메소드별로 묶은 요약을 출력합니다.
+(같은 호출 반복을 접으려면 끝까지 모아야 해서, 트리는 추적이 끝날 때 한꺼번에 나옵니다.)
 라이브러리가 내부에서 어떤 순서로 무엇을 호출하는지 공부할 때 쓰면 좋습니다.
 
 ```python
@@ -93,6 +94,10 @@ print_trace_end()
 │  │  ├ Tokenizer.__init__  ·  _tokenizer.py:105  ·  packaging
 │  │  ├ _parse_requirement  ·  _parser.py:110  ·  packaging
 │  │  │  ├ Tokenizer.consume  ·  _tokenizer.py:116  ·  packaging
+│  │  │  │  ├ Tokenizer.check  ·  _tokenizer.py:121  ·  packaging
+│  │  │  ├ Tokenizer.expect  ·  _tokenizer.py:142  ·  packaging
+│  │  │  │  ├ Tokenizer.check  ·  _tokenizer.py:121  ·  packaging
+│  │  │  │  ├ Tokenizer.read  ·  _tokenizer.py:151  ·  packaging
 ...
 
 --------------------TRACE END---------------------
@@ -110,6 +115,30 @@ packaging/_tokenizer.py
 
 기본으로는 `site-packages`에 설치된 라이브러리만 보여줍니다. 내가 작성한 코드와 파이썬 표준 라이브러리는 빠집니다.
 
+### 출력이 너무 많을 때
+
+LangChain 같은 큰 라이브러리는 한 번 호출에도 수백~수천 줄이 나옵니다. 아래 순서대로 좁혀 보세요.
+
+```python
+print_trace_start(
+    ["langchain_core"],   # 1. 공부할 패키지만 (pydantic, httpx 등 제외)
+    hide_private=True,    # 2. _로 시작하는 내부 함수 숨기기
+    unique=True,          # 3. 같은 메소드는 처음 한 번만
+    max_depth=3,          # 4. 깊이 제한
+)
+```
+
+`langchain-core`의 `prompt | RunnableLambda(...)` 체인 `invoke` 한 번 기준:
+
+| 설정 | 줄 수 |
+|---|---|
+| 접기 없음 (`collapse=False`) | 231 |
+| 기본값 (연속 반복 접기) | 193 |
+| `+ hide_private=True` | 153 |
+| `+ unique=True` | 48 |
+| `+ ["langchain_core"]` | 38 |
+| `+ max_depth=3` | 29 |
+
 ### 추적 옵션
 
 ```python
@@ -118,6 +147,8 @@ print_trace_start(max_depth=2)                     # 3단계 깊이까지만
 print_trace_start(user=True)                       # 내 코드 호출도 함께
 print_trace_start(file="trace.log")                # 화면 대신 파일로 저장
 print_trace_start(hide_private=True)               # _로 시작하는 내부 함수 숨기기
+print_trace_start(unique=True)                     # 메소드마다 처음 호출만
+print_trace_start(collapse=False)                  # 반복 호출도 접지 않고 전부
 ```
 
 | 옵션 | 기본값 | 설명 |
@@ -130,6 +161,8 @@ print_trace_start(hide_private=True)               # _로 시작하는 내부
 | `file` | 화면 | 파일 객체 또는 파일 경로 |
 | `show_line` | `True` | 파일 이름 뒤에 함수 정의 줄 번호 표시 |
 | `hide_private` | `False` | `_parse`, `_Foo.run`처럼 `_`로 시작하는 내부 함수·클래스 숨김 (`__init__` 같은 특수 메소드는 표시) |
+| `collapse` | `True` | 같은 메소드가 연달아 호출되면 `Foo.bar ×3` 한 줄로 접음 (하위 호출은 첫 번째 것만 표시) |
+| `unique` | `False` | 메소드마다 처음 호출만 표시. 이후 같은 메소드는 줄을 생략하고, 그 안에서 처음 등장하는 메소드만 위 단계에 붙여 표시 |
 | `threads` | `False` | 이후 새로 시작되는 스레드도 추적 |
 | `header` | `True` | 시작/종료 구분선 출력 |
 
@@ -147,7 +180,7 @@ with trace(["langchain_core"], max_depth=3):
 
 ### 참고
 
-- 출력이 너무 많으면 `packages`로 패키지를 좁히고, `hide_private=True`로 내부 함수를 숨기고, `max_depth`로 깊이를 제한해 보세요. 숨긴 함수 안에서 호출된 공개 함수는 그대로 보이고, 가장 가까운 상위 호출 아래에 붙습니다.
-- LangChain 같은 큰 라이브러리는 호출이 수천 개 나올 수 있습니다. `packages`나 `max_depth`로 범위를 좁혀 쓰세요.
+- `hide_private`나 `unique`로 숨긴 호출 안에서 불린 새 함수는 그대로 보이고, 가장 가까운 상위 호출 아래에 붙습니다.
+- 요약의 호출 횟수·시간에는 접히거나 생략된 호출까지 모두 포함됩니다 (`hide_private`로 숨긴 함수는 제외).
 - 제너레이터/코루틴(스트리밍, async)은 처음 호출될 때 한 번만 표시합니다.
 - 추적하는 동안에는 코드가 느려집니다. 공부하거나 디버깅할 때만 쓰세요.

{printsection-0.4.0 → printsection-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "printsection"
-version = "0.4.0"
+version = "0.5.0"
 description = "출력 구간을 나누는 가운데 정렬 구분선 + 라이브러리 호출 흐름 추적 출력"
 readme = "README.md"
 requires-python = ">=3.8"

{printsection-0.4.0 → printsection-0.5.0}/src/printsection/__init__.py

@@ -19,7 +19,7 @@ __all__ = [
     "print_trace_end",
     "trace",
 ]
-__version__ = "0.4.0"
+__version__ = "0.5.0"
 
 _FACTORY_DEFAULTS = {
     "width": 50,

{printsection-0.4.0 → printsection-0.5.0}/src/printsection/_trace.py

@@ -84,22 +84,45 @@ def _short_path(real, norm):
     return (real[len(best):] if best else real).replace("\\", "/")
 
 
+class _Node:
+    __slots__ = ("key", "method", "fname", "line", "folder", "depth", "count", "children")
+
+    def __init__(self, key, method, fname, line, folder, depth):
+        self.key = key
+        self.method = method
+        self.fname = fname
+        self.line = line
+        self.folder = folder
+        self.depth = depth
+        self.count = 1
+        self.children = []
+
+
+_DROP = object()  # 출력하지 않는 하위 트리 (반복 호출, 깊이 제한)
+_OVER = object()  # max_lines를 넘어 생략된 하위 트리 (개수 집계)
+
+
 class _Tracer:
-    def __init__(self, packages, stdlib, user, max_depth, max_lines, out, show_line, hide_private):
+    def __init__(
+        self, packages, stdlib, user, max_depth, max_lines, show_line, hide_private, collapse, unique
+    ):
         self.packages = tuple(packages or ())
         self.kinds = {"library"} | ({"stdlib"} if stdlib else set()) | ({"user"} if user else set())
         self.max_depth = max_depth
         self.max_lines = max_lines
-        self.out = out
         self.show_line = show_line
         self.hide_private = hide_private
+        self.collapse = collapse
+        self.unique = unique
 
         self.code_cache = {}  # code -> (경로, 파일명, 폴더) 또는 None(출력 안 함)
-        self.stacks = {}  # 스레드 id -> [(frame, 시작시각, 통계키)]
+        self.stacks = {}  # 스레드 id -> [(frame, 시작시각, 통계키, 하위 호출이 붙을 곳)]
         self.seen_gens = {}  # id(frame) -> frame, 제너레이터 재개 구분용
         self.stats = {}  # (경로, 메소드) -> [횟수, 누적초]
+        self.shown = set()  # 트리에 한 번이라도 나온 (경로, 메소드)
+        self.root = _Node(None, "", "", 0, "", -1)
         self.records = []
-        self.printed = 0
+        self.nodes = 0
         self.hidden = 0
         self.started = time.perf_counter()
 
@@ -129,7 +152,7 @@ class _Tracer:
         elif event == "return":
             stack = self.stacks.get(threading.get_ident())
             if stack and stack[-1][0] is frame:
-                _, start, key = stack.pop()
+                _, start, key, _ = stack.pop()
                 self.stats[key][1] += time.perf_counter() - start
 
     def _on_call(self, frame):
@@ -145,33 +168,62 @@ class _Tracer:
             self.seen_gens[id(frame)] = frame
 
         path, fname, folder = info
-        stack = self.stacks.setdefault(threading.get_ident(), [])
-        depth = len(stack)
         key = (path, method)
         stat = self.stats.get(key)
         if stat is None:
             self.stats[key] = [1, 0.0]
         else:
             stat[0] += 1
-        stack.append((frame, time.perf_counter(), key))
 
+        stack = self.stacks.setdefault(threading.get_ident(), [])
+        parent = stack[-1][3] if stack else self.root
         line = frame.f_code.co_firstlineno
+        child = self._place(parent, key, method, fname, line, folder)
+        stack.append((frame, time.perf_counter(), key, child))
+
+        depth = parent.depth + 1 if isinstance(parent, _Node) else -1
         self.records.append(
             {"depth": depth, "method": method, "file": fname, "line": line, "path": path}
         )
+
+    def _place(self, parent, key, method, fname, line, folder):
+        """이 호출을 트리 어디에 둘지 정한다. 반환값은 이 호출의 하위 호출이 붙을 곳."""
+        if parent is _DROP:
+            return _DROP
+        if parent is _OVER:
+            self.hidden += 1
+            return _OVER
+        if self.unique and key in self.shown:
+            return parent  # 이미 나온 메소드: 줄은 생략하고 하위 호출은 위 단계에 붙임
+        siblings = parent.children
+        if self.collapse and siblings and siblings[-1].key == key:
+            siblings[-1].count += 1
+            return _DROP  # 바로 앞과 같은 호출: ×N으로 접고 하위 호출은 첫 번째 것만 표시
+        depth = parent.depth + 1
         if self.max_depth is not None and depth > self.max_depth:
-            return
-        if self.max_lines is not None and self.printed >= self.max_lines:
+            return _DROP
+        if self.max_lines is not None and self.nodes >= self.max_lines:
             self.hidden += 1
-            return
-        self.printed += 1
-        where = f"{fname}:{line}" if self.show_line else fname
-        print(f"{'│  ' * depth}├ {method}  ·  {where}  ·  {folder}", file=self.out)
+            return _OVER
+        node = _Node(key, method, fname, line, folder, depth)
+        siblings.append(node)
+        self.nodes += 1
+        self.shown.add(key)
+        return node
+
+    def print_tree(self, out):
+        todo = list(reversed(self.root.children))
+        while todo:
+            node = todo.pop()
+            where = f"{node.fname}:{node.line}" if self.show_line else node.fname
+            times = f" ×{node.count}" if node.count > 1 else ""
+            print(f"{'│  ' * node.depth}├ {node.method}{times}  ·  {where}  ·  {node.folder}", file=out)
+            todo.extend(reversed(node.children))
+        if self.hidden:
+            print(f"... 출력 제한(max_lines={self.max_lines})으로 {self.hidden}개 호출 생략", file=out)
 
-    def print_summary(self):
+    def print_summary(self, out):
         elapsed = time.perf_counter() - self.started
-        if self.hidden:
-            print(f"... 출력 제한(max_lines={self.max_lines})으로 {self.hidden}개 호출 생략", file=self.out)
         by_file = {}
         for (path, method), (count, total) in self.stats.items():
             by_file.setdefault(path, []).append((method, count, total))
@@ -179,12 +231,12 @@ class _Tracer:
         print(
             f"[요약] 호출 {calls}회 · 메소드 {len(self.stats)}개 · 파일 {len(by_file)}개"
             f" · 전체 {elapsed:.3f}초",
-            file=self.out,
+            file=out,
         )
         for path, methods in by_file.items():
-            print(f"\n{path}", file=self.out)
+            print(f"\n{path}", file=out)
             for method, count, total in methods:
-                print(f"    {count:>5}회  {total * 1000:>9.1f}ms  {method}", file=self.out)
+                print(f"    {count:>5}회  {total * 1000:>9.1f}ms  {method}", file=out)
 
 
 def print_trace_start(
@@ -197,10 +249,13 @@ def print_trace_start(
     file=None,
     show_line=True,
     hide_private=False,
+    collapse=True,
+    unique=False,
     threads=False,
     header=True,
 ):
-    """지금부터 실행되는 함수 호출을 추적해 '메소드 · 파일:줄 · 경로' 형태로 출력한다.
+    """지금부터 실행되는 함수 호출을 추적한다. print_trace_end()에서 '메소드 · 파일:줄 · 경로'
+    트리로 한꺼번에 출력한다 (반복 호출을 접으려면 끝까지 모아야 하므로).
 
     packages   추적할 패키지 이름 목록 (예: ["langchain_core", "openai"]).
                지정하면 위치와 상관없이 이 패키지들만 출력한다.
@@ -213,6 +268,10 @@ def print_trace_start(
     show_line  파일 이름 뒤에 함수가 정의된 줄 번호 표시
     hide_private  True면 _parse, _Foo.run처럼 '_'로 시작하는 내부용 함수/클래스를 숨김
                (__init__ 같은 특수 메소드는 표시). 숨긴 함수 안에서 부른 공개 함수는 계속 표시
+    collapse   True면 바로 앞과 같은 메소드가 연달아 호출될 때 'Foo.bar ×3' 한 줄로 접음
+               (하위 호출은 첫 번째 것만 표시)
+    unique     True면 메소드마다 처음 호출만 표시. 이후 같은 메소드는 줄을 생략하고,
+               그 안에서 처음 등장하는 메소드만 위 단계에 붙여 표시 → 전체 흐름만 빠르게 파악
     threads    True면 이후 새로 시작되는 스레드도 추적
     header     시작/종료 구분선 출력
     """
@@ -222,23 +281,25 @@ def print_trace_start(
 
     owns_file = isinstance(file, (str, os.PathLike))
     out = open(file, "w", encoding="utf-8") if owns_file else (file or sys.stdout)
-    tracer = _Tracer(packages, stdlib, user, max_depth, max_lines, out, show_line, hide_private)
+    tracer = _Tracer(
+        packages, stdlib, user, max_depth, max_lines, show_line, hide_private, collapse, unique
+    )
 
     if header:
         from . import print_section
 
         print_section("TRACE START", file=out)
-        print("메소드  ·  파일:줄  ·  경로", file=out)
 
     previous = (sys.getprofile(), getattr(threading, "getprofile", lambda: None)())
-    _active = (tracer, previous, owns_file, header, threads)
+    _active = (tracer, out, previous, owns_file, header, threads)
     if threads:
         threading.setprofile(tracer)
     sys.setprofile(tracer)
 
 
 def print_trace_end(summary=True):
-    """추적을 멈추고, summary=True면 파일·메소드별 호출 횟수와 누적 시간을 출력한다.
+    """추적을 멈추고 호출 트리를 출력한다. summary=True면 파일·메소드별 호출 횟수와
+    누적 시간도 출력한다.
 
     추적된 호출 목록을 반환한다: [{"depth", "method", "file", "line", "path"}, ...]
     """
@@ -246,19 +307,21 @@ def print_trace_end(summary=True):
     sys.setprofile(None)
     if _active is None:
         return []
-    tracer, (prev_sys, prev_thread), owns_file, header, threads = _active
+    tracer, out, (prev_sys, prev_thread), owns_file, header, threads = _active
     _active = None
     sys.setprofile(prev_sys)
     if threads:
         threading.setprofile(prev_thread)
 
-    out = tracer.out
+    if header:
+        print("메소드  ·  파일:줄  ·  경로", file=out)
+    tracer.print_tree(out)
     if header:
         from . import print_section
 
         print_section("TRACE END", file=out)
     if summary:
-        tracer.print_summary()
+        tracer.print_summary(out)
         print(file=out)
     if owns_file:
         out.close()

{printsection-0.4.0 → printsection-0.5.0}/tests/test_trace.py

@@ -54,7 +54,7 @@ def _lines(out):
 
 def test_tree_with_file_method_path(fakelib):
     out = io.StringIO()
-    print_trace_start(["fakelib_ps"], file=out)
+    print_trace_start(["fakelib_ps"], file=out, collapse=False)
     fakelib.Client().run(2)
     records = print_trace_end()
 
@@ -102,7 +102,7 @@ def test_limits(fakelib):
     assert len(_lines(out)) == 1
 
     out = io.StringIO()
-    print_trace_start(["fakelib_ps"], file=out, max_lines=2)
+    print_trace_start(["fakelib_ps"], file=out, max_lines=2, collapse=False)
     fakelib.Client().run(3)
     print_trace_end()
     assert len(_lines(out)) == 2
@@ -131,8 +131,7 @@ def test_hide_private(fakelib):
     lines = _lines(out)
     assert lines == [
         "├ Client.run  ·  core.py:3  ·  fakelib_ps",
-        "│  ├ helper  ·  core.py:9  ·  fakelib_ps",  # _step은 숨기고 helper는 run 바로 아래에
-        "│  ├ helper  ·  core.py:9  ·  fakelib_ps",
+        "│  ├ helper ×2  ·  core.py:9  ·  fakelib_ps",  # _step은 숨기고 helper는 run 바로 아래에
         "├ Box.__init__  ·  core.py:21  ·  fakelib_ps",  # __init__은 표시
         "│  ├ helper  ·  core.py:9  ·  fakelib_ps",  # _Inner.go는 숨김
     ]
@@ -154,3 +153,43 @@ def test_hide_private(fakelib):
 )
 def test_is_private(name, private):
     assert _is_private(name) is private
+
+
+def test_collapse_repeats_by_default(fakelib):
+    out = io.StringIO()
+    print_trace_start(["fakelib_ps"], file=out)
+    fakelib.Client().run(3)
+    print_trace_end()
+
+    assert _lines(out) == [
+        "├ Client.run  ·  core.py:3  ·  fakelib_ps",
+        "│  ├ Client._step ×3  ·  core.py:6  ·  fakelib_ps",
+        "│  │  ├ helper  ·  core.py:9  ·  fakelib_ps",  # 하위 호출은 첫 번째 것만
+    ]
+    assert "[요약] 호출 7회" in out.getvalue()  # 요약은 접힌 호출까지 모두 셈
+
+
+def test_unique_shows_first_call_only(fakelib):
+    out = io.StringIO()
+    print_trace_start(["fakelib_ps"], file=out, unique=True, collapse=False)
+    fakelib.Client().run(2)
+    fakelib.Box()
+    print_trace_end()
+
+    assert _lines(out) == [
+        "├ Client.run  ·  core.py:3  ·  fakelib_ps",
+        "│  ├ Client._step  ·  core.py:6  ·  fakelib_ps",
+        "│  │  ├ helper  ·  core.py:9  ·  fakelib_ps",
+        "├ Box.__init__  ·  core.py:21  ·  fakelib_ps",
+        "│  ├ _Inner.go  ·  core.py:17  ·  fakelib_ps",  # 안의 helper는 이미 나왔으므로 생략
+    ]
+
+
+def test_tree_printed_at_end(fakelib):
+    out = io.StringIO()
+    print_trace_start(["fakelib_ps"], file=out)
+    fakelib.helper(1)
+    print("내 출력", file=out)
+    print_trace_end(summary=False)
+    text = out.getvalue()
+    assert text.index("TRACE START") < text.index("내 출력") < text.index("├ helper") < text.index("TRACE END")