printsection 0.2.0__tar.gz → 0.3.0__tar.gz

printsection-0.3.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.5
+Name: printsection
+Version: 0.3.0
+Summary: 출력 구간을 나누는 가운데 정렬 구분선 + 라이브러리 호출 흐름 추적 출력
+License-Expression: MIT
+License-File: LICENSE
+Keywords: center,console,debug,divider,korean,print,section,trace
+Classifier: Natural Language :: Korean
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+
+# printsection
+
+`print("\n", "실습 결과".center(50, "-"), end="\n\n")` 를 한 줄로.
+출력 결과를 구간별로 나눠 보기 좋게 구분해 줍니다.
+
+```bash
+pip install printsection
+# uv 사용 시: uv add printsection
+```
+
+```python
+from printsection import print_section
+
+print_section("실습 1")
+print("...")
+print_section("실습 2")
+```
+
+```
+
+----------------------실습 1----------------------
+
+...
+
+----------------------실습 2----------------------
+
+```
+
+위아래 빈 줄과 가운데 정렬이 기본입니다. 한글처럼 화면에서 2칸을 차지하는 글자도 폭을 계산해서 실제 화면 기준으로 가운데에 맞춥니다.
+
+## 옵션
+
+호출할 때 원하는 값만 바꾸면 됩니다.
+
+```python
+print_section("실습 결과", width=60, fillchar="=")
+print_section("왼쪽 정렬", align="left")          # "center" / "left" / "right"
+print_section("빈 줄 조절", top=2, bottom=0)
+print_section("str.center처럼", wide=False)       # 글자 수 기준으로 계산
+print_section()                                   # 글자 없이 구분선만
+```
+
+| 옵션 | 기본값 | 설명 |
+|---|---|---|
+| `width` | `50` | 전체 너비 |
+| `fillchar` | `"-"` | 채움 문자 (한 글자) |
+| `align` | `"center"` | `"center"`, `"left"`, `"right"` |
+| `top` | `1` | 위쪽 빈 줄 수 |
+| `bottom` | `1` | 아래쪽 빈 줄 수 |
+| `wide` | `True` | 한글 등 전각 문자를 2칸으로 계산 |
+| `file` | `sys.stdout` | 출력 대상 |
+
+## 기본값 한 번에 바꾸기
+
+```python
+from printsection import print_section, set_defaults, reset_defaults
+
+set_defaults(width=70, fillchar="*")
+print_section("1번 문제")
+print_section("2번 문제")
+reset_defaults()
+```
+
+## 문자열만 받기
+
+```python
+from printsection import format_section
+
+s = format_section("실습 결과")   # 출력하지 않고 문자열 반환
+```
+
+## 라이브러리 호출 추적: `print_trace_start` / `print_trace_end`
+
+두 함수 사이에서 실행된 **라이브러리 내부 호출**을 순서대로 보여줍니다.
+**메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 끝나면 파일·메소드별로 묶은 요약을 출력합니다.
+라이브러리가 내부에서 어떤 순서로 무엇을 호출하는지 공부할 때 쓰면 좋습니다.
+
+```python
+from printsection import print_trace_start, print_trace_end
+from packaging.requirements import Requirement
+
+print_trace_start()
+Requirement("requests>=2.0; python_version>'3.8'")
+print_trace_end()
+```
+
+```
+-------------------TRACE START--------------------
+
+메소드  ·  파일:줄  ·  경로
+├ Requirement.__init__  ·  requirements.py:82  ·  packaging
+│  ├ parse_requirement  ·  _parser.py:106  ·  packaging
+│  │  ├ Tokenizer.__init__  ·  _tokenizer.py:105  ·  packaging
+│  │  ├ _parse_requirement  ·  _parser.py:110  ·  packaging
+│  │  │  ├ Tokenizer.consume  ·  _tokenizer.py:116  ·  packaging
+...
+
+--------------------TRACE END---------------------
+
+[요약] 호출 87회 · 메소드 29개 · 파일 6개 · 전체 0.008초
+
+packaging/requirements.py
+        1회        6.3ms  Requirement.__init__
+
+packaging/_tokenizer.py
+       14회        0.2ms  Tokenizer.consume
+       33회        0.1ms  Tokenizer.check
+...
+```
+
+기본으로는 `site-packages`에 설치된 라이브러리만 보여줍니다. 내가 작성한 코드와 파이썬 표준 라이브러리는 빠집니다.
+
+### 추적 옵션
+
+```python
+print_trace_start(["langchain_core", "openai"])   # 이 패키지들만 보기
+print_trace_start(max_depth=2)                     # 3단계 깊이까지만
+print_trace_start(user=True)                       # 내 코드 호출도 함께
+print_trace_start(file="trace.log")                # 화면 대신 파일로 저장
+```
+
+| 옵션 | 기본값 | 설명 |
+|---|---|---|
+| `packages` | `None` | 추적할 패키지 이름 목록. 지정하면 위치와 상관없이 이 패키지만 출력 |
+| `stdlib` | `False` | 파이썬 표준 라이브러리 호출도 출력 |
+| `user` | `False` | 내가 작성한 프로젝트 코드 호출도 출력 |
+| `max_depth` | `None` | 이 깊이보다 깊은 호출은 생략 (0부터 시작) |
+| `max_lines` | `2000` | 최대 출력 줄 수. 넘으면 생략하고 개수만 알려줌 (`None`이면 무제한) |
+| `file` | 화면 | 파일 객체 또는 파일 경로 |
+| `show_line` | `True` | 파일 이름 뒤에 함수 정의 줄 번호 표시 |
+| `threads` | `False` | 이후 새로 시작되는 스레드도 추적 |
+| `header` | `True` | 시작/종료 구분선 출력 |
+
+`print_trace_end(summary=False)`로 요약 출력을 끌 수 있습니다.
+반환값은 호출 목록입니다: `[{"depth", "method", "file", "line", "path"}, ...]`.
+
+`with` 문으로도 쓸 수 있습니다.
+
+```python
+from printsection import trace
+
+with trace(["langchain_core"], max_depth=3):
+    chain.invoke({"question": "안녕"})
+```
+
+### 참고
+
+- LangChain 같은 큰 라이브러리는 호출이 수천 개 나올 수 있습니다. `packages`나 `max_depth`로 범위를 좁혀 쓰세요.
+- 제너레이터/코루틴(스트리밍, async)은 처음 호출될 때 한 번만 표시합니다.
+- 추적하는 동안에는 코드가 느려집니다. 공부하거나 디버깅할 때만 쓰세요.

printsection-0.3.0/README.md

@@ -0,0 +1,150 @@
+# printsection
+
+`print("\n", "실습 결과".center(50, "-"), end="\n\n")` 를 한 줄로.
+출력 결과를 구간별로 나눠 보기 좋게 구분해 줍니다.
+
+```bash
+pip install printsection
+# uv 사용 시: uv add printsection
+```
+
+```python
+from printsection import print_section
+
+print_section("실습 1")
+print("...")
+print_section("실습 2")
+```
+
+```
+
+----------------------실습 1----------------------
+
+...
+
+----------------------실습 2----------------------
+
+```
+
+위아래 빈 줄과 가운데 정렬이 기본입니다. 한글처럼 화면에서 2칸을 차지하는 글자도 폭을 계산해서 실제 화면 기준으로 가운데에 맞춥니다.
+
+## 옵션
+
+호출할 때 원하는 값만 바꾸면 됩니다.
+
+```python
+print_section("실습 결과", width=60, fillchar="=")
+print_section("왼쪽 정렬", align="left")          # "center" / "left" / "right"
+print_section("빈 줄 조절", top=2, bottom=0)
+print_section("str.center처럼", wide=False)       # 글자 수 기준으로 계산
+print_section()                                   # 글자 없이 구분선만
+```
+
+| 옵션 | 기본값 | 설명 |
+|---|---|---|
+| `width` | `50` | 전체 너비 |
+| `fillchar` | `"-"` | 채움 문자 (한 글자) |
+| `align` | `"center"` | `"center"`, `"left"`, `"right"` |
+| `top` | `1` | 위쪽 빈 줄 수 |
+| `bottom` | `1` | 아래쪽 빈 줄 수 |
+| `wide` | `True` | 한글 등 전각 문자를 2칸으로 계산 |
+| `file` | `sys.stdout` | 출력 대상 |
+
+## 기본값 한 번에 바꾸기
+
+```python
+from printsection import print_section, set_defaults, reset_defaults
+
+set_defaults(width=70, fillchar="*")
+print_section("1번 문제")
+print_section("2번 문제")
+reset_defaults()
+```
+
+## 문자열만 받기
+
+```python
+from printsection import format_section
+
+s = format_section("실습 결과")   # 출력하지 않고 문자열 반환
+```
+
+## 라이브러리 호출 추적: `print_trace_start` / `print_trace_end`
+
+두 함수 사이에서 실행된 **라이브러리 내부 호출**을 순서대로 보여줍니다.
+**메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 끝나면 파일·메소드별로 묶은 요약을 출력합니다.
+라이브러리가 내부에서 어떤 순서로 무엇을 호출하는지 공부할 때 쓰면 좋습니다.
+
+```python
+from printsection import print_trace_start, print_trace_end
+from packaging.requirements import Requirement
+
+print_trace_start()
+Requirement("requests>=2.0; python_version>'3.8'")
+print_trace_end()
+```
+
+```
+-------------------TRACE START--------------------
+
+메소드  ·  파일:줄  ·  경로
+├ Requirement.__init__  ·  requirements.py:82  ·  packaging
+│  ├ parse_requirement  ·  _parser.py:106  ·  packaging
+│  │  ├ Tokenizer.__init__  ·  _tokenizer.py:105  ·  packaging
+│  │  ├ _parse_requirement  ·  _parser.py:110  ·  packaging
+│  │  │  ├ Tokenizer.consume  ·  _tokenizer.py:116  ·  packaging
+...
+
+--------------------TRACE END---------------------
+
+[요약] 호출 87회 · 메소드 29개 · 파일 6개 · 전체 0.008초
+
+packaging/requirements.py
+        1회        6.3ms  Requirement.__init__
+
+packaging/_tokenizer.py
+       14회        0.2ms  Tokenizer.consume
+       33회        0.1ms  Tokenizer.check
+...
+```
+
+기본으로는 `site-packages`에 설치된 라이브러리만 보여줍니다. 내가 작성한 코드와 파이썬 표준 라이브러리는 빠집니다.
+
+### 추적 옵션
+
+```python
+print_trace_start(["langchain_core", "openai"])   # 이 패키지들만 보기
+print_trace_start(max_depth=2)                     # 3단계 깊이까지만
+print_trace_start(user=True)                       # 내 코드 호출도 함께
+print_trace_start(file="trace.log")                # 화면 대신 파일로 저장
+```
+
+| 옵션 | 기본값 | 설명 |
+|---|---|---|
+| `packages` | `None` | 추적할 패키지 이름 목록. 지정하면 위치와 상관없이 이 패키지만 출력 |
+| `stdlib` | `False` | 파이썬 표준 라이브러리 호출도 출력 |
+| `user` | `False` | 내가 작성한 프로젝트 코드 호출도 출력 |
+| `max_depth` | `None` | 이 깊이보다 깊은 호출은 생략 (0부터 시작) |
+| `max_lines` | `2000` | 최대 출력 줄 수. 넘으면 생략하고 개수만 알려줌 (`None`이면 무제한) |
+| `file` | 화면 | 파일 객체 또는 파일 경로 |
+| `show_line` | `True` | 파일 이름 뒤에 함수 정의 줄 번호 표시 |
+| `threads` | `False` | 이후 새로 시작되는 스레드도 추적 |
+| `header` | `True` | 시작/종료 구분선 출력 |
+
+`print_trace_end(summary=False)`로 요약 출력을 끌 수 있습니다.
+반환값은 호출 목록입니다: `[{"depth", "method", "file", "line", "path"}, ...]`.
+
+`with` 문으로도 쓸 수 있습니다.
+
+```python
+from printsection import trace
+
+with trace(["langchain_core"], max_depth=3):
+    chain.invoke({"question": "안녕"})
+```
+
+### 참고
+
+- LangChain 같은 큰 라이브러리는 호출이 수천 개 나올 수 있습니다. `packages`나 `max_depth`로 범위를 좁혀 쓰세요.
+- 제너레이터/코루틴(스트리밍, async)은 처음 호출될 때 한 번만 표시합니다.
+- 추적하는 동안에는 코드가 느려집니다. 공부하거나 디버깅할 때만 쓰세요.

{printsection-0.2.0 → printsection-0.3.0}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "hatchling.build"
 
 [project]
 name = "printsection"
-version = "0.2.0"
-description = "출력 구간을 나누는 위아래 빈 줄 + 가운데 정렬 구분선 (한글 폭 자동 보정)"
+version = "0.3.0"
+description = "출력 구간을 나누는 가운데 정렬 구분선 + 라이브러리 호출 흐름 추적 출력"
 readme = "README.md"
 requires-python = ">=3.8"
 license = "MIT"
-keywords = ["print", "section", "divider", "center", "korean", "console"]
+keywords = ["print", "section", "divider", "trace", "debug", "center", "korean", "console"]
 classifiers = [
     "Programming Language :: Python :: 3",
     "Operating System :: OS Independent",

{printsection-0.2.0 → printsection-0.3.0}/src/printsection/__init__.py

@@ -10,8 +10,16 @@
 import sys
 import unicodedata
 
-__all__ = ["print_section", "format_section", "set_defaults", "reset_defaults"]
-__version__ = "0.2.0"
+__all__ = [
+    "print_section",
+    "format_section",
+    "set_defaults",
+    "reset_defaults",
+    "print_trace_start",
+    "print_trace_end",
+    "trace",
+]
+__version__ = "0.3.0"
 
 _FACTORY_DEFAULTS = {
     "width": 50,
@@ -89,3 +97,6 @@ def reset_defaults():
     """set_defaults로 바꾼 기본값을 처음 상태로 되돌린다."""
     _defaults.clear()
     _defaults.update(_FACTORY_DEFAULTS)
+
+
+from ._trace import print_trace_end, print_trace_start, trace  # noqa: E402

printsection-0.3.0/src/printsection/_trace.py

@@ -0,0 +1,261 @@
+"""print_trace_start() ~ print_trace_end() 사이에 실행된 라이브러리 호출을 추적해 출력한다.
+
+    >>> from printsection import print_trace_start, print_trace_end
+    >>> print_trace_start()
+    >>> chain.invoke("안녕")          # 이 사이에서 호출된 라이브러리 함수가 출력됨
+    >>> print_trace_end()
+"""
+
+import os
+import sys
+import sysconfig
+import threading
+import time
+from contextlib import contextmanager
+
+_CO_GENERATOR_LIKE = 0x20 | 0x80 | 0x200  # GENERATOR | COROUTINE | ASYNC_GENERATOR
+_COMPREHENSIONS = {"<listcomp>", "<dictcomp>", "<setcomp>", "<genexpr>"}  # 3.11 이하
+_LIB_MARKERS = ("site-packages", "dist-packages")
+_STDLIB_DIRS = tuple(
+    {
+        os.path.normcase(os.path.realpath(sysconfig.get_paths()[key])) + os.sep
+        for key in ("stdlib", "platstdlib")
+    }
+)
+
+_active = None
+
+
+def _qualname(frame):
+    """'클래스.메소드' 형태 이름. 3.11+는 co_qualname, 그 이전은 self/cls로 추정."""
+    code = frame.f_code
+    name = getattr(code, "co_qualname", None)
+    if name:
+        return name
+    if code.co_argcount:
+        first = code.co_varnames[0]
+        obj = frame.f_locals.get(first)
+        if first == "self" and obj is not None:
+            return f"{type(obj).__name__}.{code.co_name}"
+        if first == "cls" and isinstance(obj, type):
+            return f"{obj.__name__}.{code.co_name}"
+    return code.co_name
+
+
+def _location(filename):
+    """(종류, 표시용 경로). 종류는 'library' / 'stdlib' / 'user'."""
+    if filename.startswith("<"):
+        return ("stdlib" if filename.startswith("<frozen") else "user"), filename
+    real = os.path.realpath(filename)
+    norm = os.path.normcase(real)
+    for marker in _LIB_MARKERS:
+        idx = norm.rfind(os.sep + marker + os.sep)
+        if idx != -1:
+            return "library", real[idx + len(marker) + 2:].replace("\\", "/")
+    if norm.startswith(_STDLIB_DIRS):
+        for d in _STDLIB_DIRS:
+            if norm.startswith(d):
+                return "stdlib", real[len(d):].replace("\\", "/")
+    return "user", _short_path(real, norm)
+
+
+def _short_path(real, norm):
+    """현재 폴더 기준 경로. 현재 폴더 밖이면 sys.path 기준 경로 (예: editable 설치)."""
+    try:
+        rel = os.path.relpath(real)
+        if not rel.startswith(".."):
+            return rel.replace("\\", "/")
+    except ValueError:  # 다른 드라이브
+        pass
+    best = ""
+    for entry in sys.path:
+        base = os.path.normcase(os.path.realpath(entry or ".")) + os.sep
+        if norm.startswith(base) and len(base) > len(best):
+            best = base
+    return (real[len(best):] if best else real).replace("\\", "/")
+
+
+class _Tracer:
+    def __init__(self, packages, stdlib, user, max_depth, max_lines, out, show_line):
+        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.code_cache = {}  # code -> (경로, 파일명, 폴더) 또는 None(출력 안 함)
+        self.stacks = {}  # 스레드 id -> [(frame, 시작시각, 통계키)]
+        self.seen_gens = {}  # id(frame) -> frame, 제너레이터 재개 구분용
+        self.stats = {}  # (경로, 메소드) -> [횟수, 누적초]
+        self.records = []
+        self.printed = 0
+        self.hidden = 0
+        self.started = time.perf_counter()
+
+    def _code_info(self, frame):
+        code = frame.f_code
+        try:
+            return self.code_cache[code]
+        except KeyError:
+            pass
+        module = frame.f_globals.get("__name__", "") or ""
+        info = None
+        if not module.startswith("printsection") and code.co_name not in _COMPREHENSIONS:
+            kind, path = _location(code.co_filename)
+            if self.packages:
+                wanted = any(module == p or module.startswith(p + ".") for p in self.packages)
+            else:
+                wanted = kind in self.kinds
+            if wanted:
+                folder, _, fname = path.rpartition("/")
+                info = (path, fname, folder or ".")
+        self.code_cache[code] = info
+        return info
+
+    def __call__(self, frame, event, arg):
+        if event == "call":
+            self._on_call(frame)
+        elif event == "return":
+            stack = self.stacks.get(threading.get_ident())
+            if stack and stack[-1][0] is frame:
+                _, start, key = stack.pop()
+                self.stats[key][1] += time.perf_counter() - start
+
+    def _on_call(self, frame):
+        info = self._code_info(frame)
+        if info is None:
+            return
+        if frame.f_code.co_flags & _CO_GENERATOR_LIKE:
+            if id(frame) in self.seen_gens:
+                return  # 제너레이터/코루틴 재개 — 처음 호출만 출력
+            self.seen_gens[id(frame)] = frame
+
+        path, fname, folder = info
+        method = _qualname(frame)
+        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))
+
+        line = frame.f_code.co_firstlineno
+        self.records.append(
+            {"depth": depth, "method": method, "file": fname, "line": line, "path": path}
+        )
+        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:
+            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)
+
+    def print_summary(self):
+        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))
+        calls = sum(c for c, _ in self.stats.values())
+        print(
+            f"[요약] 호출 {calls}회 · 메소드 {len(self.stats)}개 · 파일 {len(by_file)}개"
+            f" · 전체 {elapsed:.3f}초",
+            file=self.out,
+        )
+        for path, methods in by_file.items():
+            print(f"\n{path}", file=self.out)
+            for method, count, total in methods:
+                print(f"    {count:>5}회  {total * 1000:>9.1f}ms  {method}", file=self.out)
+
+
+def print_trace_start(
+    packages=None,
+    *,
+    stdlib=False,
+    user=False,
+    max_depth=None,
+    max_lines=2000,
+    file=None,
+    show_line=True,
+    threads=False,
+    header=True,
+):
+    """지금부터 실행되는 함수 호출을 추적해 '메소드 · 파일:줄 · 경로' 형태로 출력한다.
+
+    packages   추적할 패키지 이름 목록 (예: ["langchain_core", "openai"]).
+               지정하면 위치와 상관없이 이 패키지들만 출력한다.
+               생략하면 site-packages에 설치된 모든 라이브러리를 출력한다.
+    stdlib     True면 파이썬 표준 라이브러리 호출도 출력
+    user       True면 내가 작성한 코드(프로젝트 파일) 호출도 출력
+    max_depth  이 깊이보다 깊은 호출은 출력하지 않음 (0부터 시작)
+    max_lines  최대 출력 줄 수. 넘으면 생략하고 마지막에 개수만 알려줌 (None이면 무제한)
+    file       출력 대상. 파일 객체 또는 파일 경로 문자열 (기본: 화면)
+    show_line  파일 이름 뒤에 함수가 정의된 줄 번호 표시
+    threads    True면 이후 새로 시작되는 스레드도 추적
+    header     시작/종료 구분선 출력
+    """
+    global _active
+    if _active is not None:
+        print_trace_end(summary=False)
+
+    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)
+
+    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)
+    if threads:
+        threading.setprofile(tracer)
+    sys.setprofile(tracer)
+
+
+def print_trace_end(summary=True):
+    """추적을 멈추고, summary=True면 파일·메소드별 호출 횟수와 누적 시간을 출력한다.
+
+    추적된 호출 목록을 반환한다: [{"depth", "method", "file", "line", "path"}, ...]
+    """
+    global _active
+    sys.setprofile(None)
+    if _active is None:
+        return []
+    tracer, (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:
+        from . import print_section
+
+        print_section("TRACE END", file=out)
+    if summary:
+        tracer.print_summary()
+        print(file=out)
+    if owns_file:
+        out.close()
+    tracer.seen_gens.clear()
+    return tracer.records
+
+
+@contextmanager
+def trace(packages=None, **options):
+    """with 문으로 쓰는 버전. with trace(): ... 블록 안의 호출만 추적한다."""
+    print_trace_start(packages, **options)
+    try:
+        yield
+    finally:
+        print_trace_end()

printsection-0.3.0/tests/test_trace.py

@@ -0,0 +1,112 @@
+import importlib
+import io
+import sys
+import textwrap
+
+import pytest
+
+from printsection import print_trace_end, print_trace_start, trace
+
+FAKELIB = textwrap.dedent(
+    """
+    class Client:
+        def run(self, n):
+            return [self._step(i) for i in range(n)]
+
+        def _step(self, i):
+            return helper(i)
+
+    def helper(i):
+        return i * 2
+
+    def gen():
+        yield 1
+        yield 2
+    """
+)
+
+
+@pytest.fixture
+def fakelib(tmp_path, monkeypatch):
+    pkg = tmp_path / "fakelib_ps"
+    pkg.mkdir()
+    (pkg / "__init__.py").write_text("")
+    (pkg / "core.py").write_text(FAKELIB)
+    monkeypatch.syspath_prepend(str(tmp_path))
+    mod = importlib.import_module("fakelib_ps.core")
+    yield mod
+    sys.modules.pop("fakelib_ps.core", None)
+    sys.modules.pop("fakelib_ps", None)
+
+
+def _lines(out):
+    return [l for l in out.getvalue().splitlines() if "├" in l]
+
+
+def test_tree_with_file_method_path(fakelib):
+    out = io.StringIO()
+    print_trace_start(["fakelib_ps"], file=out)
+    fakelib.Client().run(2)
+    records = print_trace_end()
+
+    lines = _lines(out)
+    assert lines[0] == "├ Client.run  ·  core.py:3  ·  fakelib_ps"
+    assert lines[1].startswith("│  ├ Client._step  ·  core.py:6")
+    assert lines[2].startswith("│  │  ├ helper  ·  core.py:9")
+    assert len(lines) == 5
+    assert [r["depth"] for r in records] == [0, 1, 2, 1, 2]
+    text = out.getvalue()
+    assert "TRACE START" in text and "TRACE END" in text
+    assert "[요약] 호출 5회 · 메소드 3개 · 파일 1개" in text
+    assert "fakelib_ps/core.py" in text
+
+
+def test_default_skips_non_library_code(fakelib):
+    out = io.StringIO()
+    print_trace_start(file=out)  # tmp 폴더 코드는 site-packages가 아니므로 출력 안 됨
+    fakelib.helper(1)
+    assert print_trace_end() == []
+    assert _lines(out) == []
+
+
+def test_user_option_includes_project_code(fakelib):
+    out = io.StringIO()
+    print_trace_start(user=True, file=out, header=False)
+    fakelib.helper(1)
+    print_trace_end(summary=False)
+    assert any("helper" in l for l in _lines(out))
+
+
+def test_generator_resume_printed_once(fakelib):
+    out = io.StringIO()
+    print_trace_start(["fakelib_ps"], file=out, header=False)
+    list(fakelib.gen())
+    print_trace_end(summary=False)
+    assert [l for l in _lines(out) if "gen" in l] == ["├ gen  ·  core.py:12  ·  fakelib_ps"]
+
+
+def test_limits(fakelib):
+    out = io.StringIO()
+    print_trace_start(["fakelib_ps"], file=out, max_depth=0)
+    fakelib.Client().run(3)
+    print_trace_end()
+    assert len(_lines(out)) == 1
+
+    out = io.StringIO()
+    print_trace_start(["fakelib_ps"], file=out, max_lines=2)
+    fakelib.Client().run(3)
+    print_trace_end()
+    assert len(_lines(out)) == 2
+    assert "5개 호출 생략" in out.getvalue()
+
+
+def test_file_path_and_context_manager(fakelib, tmp_path):
+    log = tmp_path / "trace.log"
+    with trace(["fakelib_ps"], file=str(log)):
+        fakelib.helper(1)
+    assert "├ helper" in log.read_text(encoding="utf-8")
+    assert sys.getprofile() is None
+
+
+def test_end_without_start_is_safe():
+    assert print_trace_end() == []

printsection-0.3.0/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 5
+requires-python = ">=3.8"
+
+[[package]]
+name = "printsection"
+version = "0.2.0"
+source = { editable = "." }

printsection-0.2.0/PKG-INFO

@@ -1,83 +0,0 @@
-Metadata-Version: 2.5
-Name: printsection
-Version: 0.2.0
-Summary: 출력 구간을 나누는 위아래 빈 줄 + 가운데 정렬 구분선 (한글 폭 자동 보정)
-License-Expression: MIT
-License-File: LICENSE
-Keywords: center,console,divider,korean,print,section
-Classifier: Natural Language :: Korean
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-
-# printsection
-
-`print("\n", "실습 결과".center(50, "-"), end="\n\n")` 를 한 줄로.
-출력 결과를 구간별로 나눠 보기 좋게 구분해 줍니다.
-
-```bash
-pip install printsection
-# uv 사용 시: uv add printsection
-```
-
-```python
-from printsection import print_section
-
-print_section("실습 1")
-print("...")
-print_section("실습 2")
-```
-
-```
-
-----------------------실습 1----------------------
-
-...
-
-----------------------실습 2----------------------
-
-```
-
-위아래 빈 줄과 가운데 정렬이 기본입니다. 한글처럼 화면에서 2칸을 차지하는 글자도 폭을 계산해서 실제 화면 기준으로 가운데에 맞춥니다.
-
-## 옵션
-
-호출할 때 원하는 값만 바꾸면 됩니다.
-
-```python
-print_section("실습 결과", width=60, fillchar="=")
-print_section("왼쪽 정렬", align="left")          # "center" / "left" / "right"
-print_section("빈 줄 조절", top=2, bottom=0)
-print_section("str.center처럼", wide=False)       # 글자 수 기준으로 계산
-print_section()                                   # 글자 없이 구분선만
-```
-
-| 옵션 | 기본값 | 설명 |
-|---|---|---|
-| `width` | `50` | 전체 너비 |
-| `fillchar` | `"-"` | 채움 문자 (한 글자) |
-| `align` | `"center"` | `"center"`, `"left"`, `"right"` |
-| `top` | `1` | 위쪽 빈 줄 수 |
-| `bottom` | `1` | 아래쪽 빈 줄 수 |
-| `wide` | `True` | 한글 등 전각 문자를 2칸으로 계산 |
-| `file` | `sys.stdout` | 출력 대상 |
-
-## 기본값 한 번에 바꾸기
-
-```python
-from printsection import print_section, set_defaults, reset_defaults
-
-set_defaults(width=70, fillchar="*")
-print_section("1번 문제")
-print_section("2번 문제")
-reset_defaults()
-```
-
-## 문자열만 받기
-
-```python
-from printsection import format_section
-
-s = format_section("실습 결과")   # 출력하지 않고 문자열 반환
-```

printsection-0.2.0/README.md

@@ -1,70 +0,0 @@
-# printsection
-
-`print("\n", "실습 결과".center(50, "-"), end="\n\n")` 를 한 줄로.
-출력 결과를 구간별로 나눠 보기 좋게 구분해 줍니다.
-
-```bash
-pip install printsection
-# uv 사용 시: uv add printsection
-```
-
-```python
-from printsection import print_section
-
-print_section("실습 1")
-print("...")
-print_section("실습 2")
-```
-
-```
-
-----------------------실습 1----------------------
-
-...
-
-----------------------실습 2----------------------
-
-```
-
-위아래 빈 줄과 가운데 정렬이 기본입니다. 한글처럼 화면에서 2칸을 차지하는 글자도 폭을 계산해서 실제 화면 기준으로 가운데에 맞춥니다.
-
-## 옵션
-
-호출할 때 원하는 값만 바꾸면 됩니다.
-
-```python
-print_section("실습 결과", width=60, fillchar="=")
-print_section("왼쪽 정렬", align="left")          # "center" / "left" / "right"
-print_section("빈 줄 조절", top=2, bottom=0)
-print_section("str.center처럼", wide=False)       # 글자 수 기준으로 계산
-print_section()                                   # 글자 없이 구분선만
-```
-
-| 옵션 | 기본값 | 설명 |
-|---|---|---|
-| `width` | `50` | 전체 너비 |
-| `fillchar` | `"-"` | 채움 문자 (한 글자) |
-| `align` | `"center"` | `"center"`, `"left"`, `"right"` |
-| `top` | `1` | 위쪽 빈 줄 수 |
-| `bottom` | `1` | 아래쪽 빈 줄 수 |
-| `wide` | `True` | 한글 등 전각 문자를 2칸으로 계산 |
-| `file` | `sys.stdout` | 출력 대상 |
-
-## 기본값 한 번에 바꾸기
-
-```python
-from printsection import print_section, set_defaults, reset_defaults
-
-set_defaults(width=70, fillchar="*")
-print_section("1번 문제")
-print_section("2번 문제")
-reset_defaults()
-```
-
-## 문자열만 받기
-
-```python
-from printsection import format_section
-
-s = format_section("실습 결과")   # 출력하지 않고 문자열 반환
-```