printsection 0.3.0__tar.gz → 0.5.0__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. {printsection-0.3.0 → printsection-0.5.0}/PKG-INFO +39 -3
  2. {printsection-0.3.0 → printsection-0.5.0}/README.md +186 -150
  3. {printsection-0.3.0 → printsection-0.5.0}/pyproject.toml +1 -1
  4. {printsection-0.3.0 → printsection-0.5.0}/src/printsection/__init__.py +1 -1
  5. {printsection-0.3.0 → printsection-0.5.0}/src/printsection/_trace.py +339 -261
  6. {printsection-0.3.0 → printsection-0.5.0}/tests/test_trace.py +184 -101
  7. {printsection-0.3.0 → printsection-0.5.0}/LICENSE +0 -0
  8. {printsection-0.3.0 → printsection-0.5.0}/tests/test_printsection.py +0 -0
  9. {printsection-0.3.0 → printsection-0.5.0}/uv.lock +0 -0
{printsection-0.3.0 → printsection-0.5.0}/PKG-INFO RENAMED
@@ -1,6 +1,6 @@
1
1
  Metadata-Version: 2.5
2
2
  Name: printsection
3
- Version: 0.3.0
3
+ Version: 0.5.0
4
4
  Summary: 출력 구간을 나누는 가운데 정렬 구분선 + 라이브러리 호출 흐름 추적 출력
5
5
  License-Expression: MIT
6
6
  License-File: LICENSE
@@ -85,7 +85,8 @@ s = format_section("실습 결과") # 출력하지 않고 문자열 반환
85
85
  ## 라이브러리 호출 추적: `print_trace_start` / `print_trace_end`
86
86
 
87
87
  두 함수 사이에서 실행된 **라이브러리 내부 호출**을 순서대로 보여줍니다.
88
- **메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 끝나면 파일·메소드별로 묶은 요약을 출력합니다.
88
+ `print_trace_end()`를 호출하면 **메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 이어서 파일·메소드별로 묶은 요약을 출력합니다.
89
+ (같은 호출 반복을 접으려면 끝까지 모아야 해서, 트리는 추적이 끝날 때 한꺼번에 나옵니다.)
89
90
  라이브러리가 내부에서 어떤 순서로 무엇을 호출하는지 공부할 때 쓰면 좋습니다.
90
91
 
91
92
  ```python
@@ -106,6 +107,10 @@ print_trace_end()
106
107
  │ │ ├ Tokenizer.__init__ · _tokenizer.py:105 · packaging
107
108
  │ │ ├ _parse_requirement · _parser.py:110 · packaging
108
109
  │ │ │ ├ Tokenizer.consume · _tokenizer.py:116 · packaging
110
+ │ │ │ │ ├ Tokenizer.check · _tokenizer.py:121 · packaging
111
+ │ │ │ ├ Tokenizer.expect · _tokenizer.py:142 · packaging
112
+ │ │ │ │ ├ Tokenizer.check · _tokenizer.py:121 · packaging
113
+ │ │ │ │ ├ Tokenizer.read · _tokenizer.py:151 · packaging
109
114
  ...
110
115
 
111
116
  --------------------TRACE END---------------------
@@ -123,6 +128,30 @@ packaging/_tokenizer.py
123
128
 
124
129
  기본으로는 `site-packages`에 설치된 라이브러리만 보여줍니다. 내가 작성한 코드와 파이썬 표준 라이브러리는 빠집니다.
125
130
 
131
+ ### 출력이 너무 많을 때
132
+
133
+ LangChain 같은 큰 라이브러리는 한 번 호출에도 수백~수천 줄이 나옵니다. 아래 순서대로 좁혀 보세요.
134
+
135
+ ```python
136
+ print_trace_start(
137
+ ["langchain_core"], # 1. 공부할 패키지만 (pydantic, httpx 등 제외)
138
+ hide_private=True, # 2. _로 시작하는 내부 함수 숨기기
139
+ unique=True, # 3. 같은 메소드는 처음 한 번만
140
+ max_depth=3, # 4. 깊이 제한
141
+ )
142
+ ```
143
+
144
+ `langchain-core`의 `prompt | RunnableLambda(...)` 체인 `invoke` 한 번 기준:
145
+
146
+ | 설정 | 줄 수 |
147
+ |---|---|
148
+ | 접기 없음 (`collapse=False`) | 231 |
149
+ | 기본값 (연속 반복 접기) | 193 |
150
+ | `+ hide_private=True` | 153 |
151
+ | `+ unique=True` | 48 |
152
+ | `+ ["langchain_core"]` | 38 |
153
+ | `+ max_depth=3` | 29 |
154
+
126
155
  ### 추적 옵션
127
156
 
128
157
  ```python
@@ -130,6 +159,9 @@ print_trace_start(["langchain_core", "openai"]) # 이 패키지들만 보기
130
159
  print_trace_start(max_depth=2) # 3단계 깊이까지만
131
160
  print_trace_start(user=True) # 내 코드 호출도 함께
132
161
  print_trace_start(file="trace.log") # 화면 대신 파일로 저장
162
+ print_trace_start(hide_private=True) # _로 시작하는 내부 함수 숨기기
163
+ print_trace_start(unique=True) # 메소드마다 처음 호출만
164
+ print_trace_start(collapse=False) # 반복 호출도 접지 않고 전부
133
165
  ```
134
166
 
135
167
  | 옵션 | 기본값 | 설명 |
@@ -141,6 +173,9 @@ print_trace_start(file="trace.log") # 화면 대신 파일로 저
141
173
  | `max_lines` | `2000` | 최대 출력 줄 수. 넘으면 생략하고 개수만 알려줌 (`None`이면 무제한) |
142
174
  | `file` | 화면 | 파일 객체 또는 파일 경로 |
143
175
  | `show_line` | `True` | 파일 이름 뒤에 함수 정의 줄 번호 표시 |
176
+ | `hide_private` | `False` | `_parse`, `_Foo.run`처럼 `_`로 시작하는 내부 함수·클래스 숨김 (`__init__` 같은 특수 메소드는 표시) |
177
+ | `collapse` | `True` | 같은 메소드가 연달아 호출되면 `Foo.bar ×3` 한 줄로 접음 (하위 호출은 첫 번째 것만 표시) |
178
+ | `unique` | `False` | 메소드마다 처음 호출만 표시. 이후 같은 메소드는 줄을 생략하고, 그 안에서 처음 등장하는 메소드만 위 단계에 붙여 표시 |
144
179
  | `threads` | `False` | 이후 새로 시작되는 스레드도 추적 |
145
180
  | `header` | `True` | 시작/종료 구분선 출력 |
146
181
 
@@ -158,6 +193,7 @@ with trace(["langchain_core"], max_depth=3):
158
193
 
159
194
  ### 참고
160
195
 
161
- - LangChain 같은 큰 라이브러리는 호출이 수천 개 나올 수 있습니다. `packages`나 `max_depth`로 범위를 좁혀 쓰세요.
196
+ - `hide_private`나 `unique`로 숨긴 호출 안에서 불린 새 함수는 그대로 보이고, 가장 가까운 상위 호출 아래에 붙습니다.
197
+ - 요약의 호출 횟수·시간에는 접히거나 생략된 호출까지 모두 포함됩니다 (`hide_private`로 숨긴 함수는 제외).
162
198
  - 제너레이터/코루틴(스트리밍, async)은 처음 호출될 때 한 번만 표시합니다.
163
199
  - 추적하는 동안에는 코드가 느려집니다. 공부하거나 디버깅할 때만 쓰세요.
{printsection-0.3.0 → printsection-0.5.0}/README.md RENAMED
@@ -1,150 +1,186 @@
1
- # printsection
2
-
3
- `print("\n", "실습 결과".center(50, "-"), end="\n\n")` 를 한 줄로.
4
- 출력 결과를 구간별로 나눠 보기 좋게 구분해 줍니다.
5
-
6
- ```bash
7
- pip install printsection
8
- # uv 사용 시: uv add printsection
9
- ```
10
-
11
- ```python
12
- from printsection import print_section
13
-
14
- print_section("실습 1")
15
- print("...")
16
- print_section("실습 2")
17
- ```
18
-
19
- ```
20
-
21
- ----------------------실습 1----------------------
22
-
23
- ...
24
-
25
- ----------------------실습 2----------------------
26
-
27
- ```
28
-
29
- 위아래 빈 줄과 가운데 정렬이 기본입니다. 한글처럼 화면에서 2칸을 차지하는 글자도 폭을 계산해서 실제 화면 기준으로 가운데에 맞춥니다.
30
-
31
- ## 옵션
32
-
33
- 호출할 때 원하는 값만 바꾸면 됩니다.
34
-
35
- ```python
36
- print_section("실습 결과", width=60, fillchar="=")
37
- print_section("왼쪽 정렬", align="left") # "center" / "left" / "right"
38
- print_section("빈 줄 조절", top=2, bottom=0)
39
- print_section("str.center처럼", wide=False) # 글자 수 기준으로 계산
40
- print_section() # 글자 없이 구분선만
41
- ```
42
-
43
- | 옵션 | 기본값 | 설명 |
44
- |---|---|---|
45
- | `width` | `50` | 전체 너비 |
46
- | `fillchar` | `"-"` | 채움 문자 (한 글자) |
47
- | `align` | `"center"` | `"center"`, `"left"`, `"right"` |
48
- | `top` | `1` | 위쪽 빈 줄 수 |
49
- | `bottom` | `1` | 아래쪽 빈 줄 수 |
50
- | `wide` | `True` | 한글 등 전각 문자를 2칸으로 계산 |
51
- | `file` | `sys.stdout` | 출력 대상 |
52
-
53
- ## 기본값 한 번에 바꾸기
54
-
55
- ```python
56
- from printsection import print_section, set_defaults, reset_defaults
57
-
58
- set_defaults(width=70, fillchar="*")
59
- print_section("1번 문제")
60
- print_section("2번 문제")
61
- reset_defaults()
62
- ```
63
-
64
- ## 문자열만 받기
65
-
66
- ```python
67
- from printsection import format_section
68
-
69
- s = format_section("실습 결과") # 출력하지 않고 문자열 반환
70
- ```
71
-
72
- ## 라이브러리 호출 추적: `print_trace_start` / `print_trace_end`
73
-
74
- 두 함수 사이에서 실행된 **라이브러리 내부 호출**을 순서대로 보여줍니다.
75
- **메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 끝나면 파일·메소드별로 묶은 요약을 출력합니다.
76
- 라이브러리가 내부에서 어떤 순서로 무엇을 호출하는지 공부할 때 쓰면 좋습니다.
77
-
78
- ```python
79
- from printsection import print_trace_start, print_trace_end
80
- from packaging.requirements import Requirement
81
-
82
- print_trace_start()
83
- Requirement("requests>=2.0; python_version>'3.8'")
84
- print_trace_end()
85
- ```
86
-
87
- ```
88
- -------------------TRACE START--------------------
89
-
90
- 메소드 · 파일:줄 · 경로
91
- ├ Requirement.__init__ · requirements.py:82 · packaging
92
- │ ├ parse_requirement · _parser.py:106 · packaging
93
- │ │ ├ Tokenizer.__init__ · _tokenizer.py:105 · packaging
94
- │ │ ├ _parse_requirement · _parser.py:110 · packaging
95
- │ │ │ ├ Tokenizer.consume · _tokenizer.py:116 · packaging
96
- ...
97
-
98
- --------------------TRACE END---------------------
99
-
100
- [요약] 호출 87회 · 메소드 29개 · 파일 6개 · 전체 0.008초
101
-
102
- packaging/requirements.py
103
- 1회 6.3ms Requirement.__init__
104
-
105
- packaging/_tokenizer.py
106
- 14회 0.2ms Tokenizer.consume
107
- 33회 0.1ms Tokenizer.check
108
- ...
109
- ```
110
-
111
- 기본으로는 `site-packages`에 설치된 라이브러리만 보여줍니다. 내가 작성한 코드와 파이썬 표준 라이브러리는 빠집니다.
112
-
113
- ### 추적 옵션
114
-
115
- ```python
116
- print_trace_start(["langchain_core", "openai"]) # 이 패키지들만 보기
117
- print_trace_start(max_depth=2) # 3단계 깊이까지만
118
- print_trace_start(user=True) # 내 코드 호출도 함께
119
- print_trace_start(file="trace.log") # 화면 대신 파일로 저장
120
- ```
121
-
122
- | 옵션 | 기본값 | 설명 |
123
- |---|---|---|
124
- | `packages` | `None` | 추적할 패키지 이름 목록. 지정하면 위치와 상관없이 이 패키지만 출력 |
125
- | `stdlib` | `False` | 파이썬 표준 라이브러리 호출도 출력 |
126
- | `user` | `False` | 내가 작성한 프로젝트 코드 호출도 출력 |
127
- | `max_depth` | `None` | 이 깊이보다 깊은 호출은 생략 (0부터 시작) |
128
- | `max_lines` | `2000` | 최대 출력 줄 수. 넘으면 생략하고 개수만 알려줌 (`None`이면 무제한) |
129
- | `file` | 화면 | 파일 객체 또는 파일 경로 |
130
- | `show_line` | `True` | 파일 이름 뒤에 함수 정의 줄 번호 표시 |
131
- | `threads` | `False` | 이후 새로 시작되는 스레드도 추적 |
132
- | `header` | `True` | 시작/종료 구분선 출력 |
133
-
134
- `print_trace_end(summary=False)`로 요약 출력을 끌 수 있습니다.
135
- 반환값은 호출 목록입니다: `[{"depth", "method", "file", "line", "path"}, ...]`.
136
-
137
- `with` 문으로도 쓸 수 있습니다.
138
-
139
- ```python
140
- from printsection import trace
141
-
142
- with trace(["langchain_core"], max_depth=3):
143
- chain.invoke({"question": "안녕"})
144
- ```
145
-
146
- ### 참고
147
-
148
- - LangChain 같은 큰 라이브러리는 호출이 수천 개 나올 수 있습니다. `packages`나 `max_depth`로 범위를 좁혀 쓰세요.
149
- - 제너레이터/코루틴(스트리밍, async)은 처음 호출될 때 한 번만 표시합니다.
150
- - 추적하는 동안에는 코드가 느려집니다. 공부하거나 디버깅할 때만 쓰세요.
1
+ # printsection
2
+
3
+ `print("\n", "실습 결과".center(50, "-"), end="\n\n")` 를 한 줄로.
4
+ 출력 결과를 구간별로 나눠 보기 좋게 구분해 줍니다.
5
+
6
+ ```bash
7
+ pip install printsection
8
+ # uv 사용 시: uv add printsection
9
+ ```
10
+
11
+ ```python
12
+ from printsection import print_section
13
+
14
+ print_section("실습 1")
15
+ print("...")
16
+ print_section("실습 2")
17
+ ```
18
+
19
+ ```
20
+
21
+ ----------------------실습 1----------------------
22
+
23
+ ...
24
+
25
+ ----------------------실습 2----------------------
26
+
27
+ ```
28
+
29
+ 위아래 빈 줄과 가운데 정렬이 기본입니다. 한글처럼 화면에서 2칸을 차지하는 글자도 폭을 계산해서 실제 화면 기준으로 가운데에 맞춥니다.
30
+
31
+ ## 옵션
32
+
33
+ 호출할 때 원하는 값만 바꾸면 됩니다.
34
+
35
+ ```python
36
+ print_section("실습 결과", width=60, fillchar="=")
37
+ print_section("왼쪽 정렬", align="left") # "center" / "left" / "right"
38
+ print_section("빈 줄 조절", top=2, bottom=0)
39
+ print_section("str.center처럼", wide=False) # 글자 수 기준으로 계산
40
+ print_section() # 글자 없이 구분선만
41
+ ```
42
+
43
+ | 옵션 | 기본값 | 설명 |
44
+ |---|---|---|
45
+ | `width` | `50` | 전체 너비 |
46
+ | `fillchar` | `"-"` | 채움 문자 (한 글자) |
47
+ | `align` | `"center"` | `"center"`, `"left"`, `"right"` |
48
+ | `top` | `1` | 위쪽 빈 줄 수 |
49
+ | `bottom` | `1` | 아래쪽 빈 줄 수 |
50
+ | `wide` | `True` | 한글 등 전각 문자를 2칸으로 계산 |
51
+ | `file` | `sys.stdout` | 출력 대상 |
52
+
53
+ ## 기본값 한 번에 바꾸기
54
+
55
+ ```python
56
+ from printsection import print_section, set_defaults, reset_defaults
57
+
58
+ set_defaults(width=70, fillchar="*")
59
+ print_section("1번 문제")
60
+ print_section("2번 문제")
61
+ reset_defaults()
62
+ ```
63
+
64
+ ## 문자열만 받기
65
+
66
+ ```python
67
+ from printsection import format_section
68
+
69
+ s = format_section("실습 결과") # 출력하지 않고 문자열 반환
70
+ ```
71
+
72
+ ## 라이브러리 호출 추적: `print_trace_start` / `print_trace_end`
73
+
74
+ 두 함수 사이에서 실행된 **라이브러리 내부 호출**을 순서대로 보여줍니다.
75
+ `print_trace_end()`를 호출하면 **메소드 · 파일:줄 · 경로**를 들여쓰기 트리로 출력하고, 이어서 파일·메소드별로 묶은 요약을 출력합니다.
76
+ (같은 호출 반복을 접으려면 끝까지 모아야 해서, 트리는 추적이 끝날 때 한꺼번에 나옵니다.)
77
+ 라이브러리가 내부에서 어떤 순서로 무엇을 호출하는지 공부할 때 쓰면 좋습니다.
78
+
79
+ ```python
80
+ from printsection import print_trace_start, print_trace_end
81
+ from packaging.requirements import Requirement
82
+
83
+ print_trace_start()
84
+ Requirement("requests>=2.0; python_version>'3.8'")
85
+ print_trace_end()
86
+ ```
87
+
88
+ ```
89
+ -------------------TRACE START--------------------
90
+
91
+ 메소드 · 파일:줄 · 경로
92
+ ├ Requirement.__init__ · requirements.py:82 · packaging
93
+ │ ├ parse_requirement · _parser.py:106 · packaging
94
+ │ │ ├ Tokenizer.__init__ · _tokenizer.py:105 · packaging
95
+ │ │ ├ _parse_requirement · _parser.py:110 · packaging
96
+ │ │ │ ├ Tokenizer.consume · _tokenizer.py:116 · packaging
97
+ │ │ │ │ ├ Tokenizer.check · _tokenizer.py:121 · packaging
98
+ │ │ │ ├ Tokenizer.expect · _tokenizer.py:142 · packaging
99
+ │ │ │ │ ├ Tokenizer.check · _tokenizer.py:121 · packaging
100
+ │ │ │ │ ├ Tokenizer.read · _tokenizer.py:151 · packaging
101
+ ...
102
+
103
+ --------------------TRACE END---------------------
104
+
105
+ [요약] 호출 87회 · 메소드 29개 · 파일 6개 · 전체 0.008초
106
+
107
+ packaging/requirements.py
108
+ 1회 6.3ms Requirement.__init__
109
+
110
+ packaging/_tokenizer.py
111
+ 14회 0.2ms Tokenizer.consume
112
+ 33회 0.1ms Tokenizer.check
113
+ ...
114
+ ```
115
+
116
+ 기본으로는 `site-packages`에 설치된 라이브러리만 보여줍니다. 내가 작성한 코드와 파이썬 표준 라이브러리는 빠집니다.
117
+
118
+ ### 출력이 너무 많을 때
119
+
120
+ LangChain 같은 큰 라이브러리는 한 번 호출에도 수백~수천 줄이 나옵니다. 아래 순서대로 좁혀 보세요.
121
+
122
+ ```python
123
+ print_trace_start(
124
+ ["langchain_core"], # 1. 공부할 패키지만 (pydantic, httpx 등 제외)
125
+ hide_private=True, # 2. _로 시작하는 내부 함수 숨기기
126
+ unique=True, # 3. 같은 메소드는 처음 한 번만
127
+ max_depth=3, # 4. 깊이 제한
128
+ )
129
+ ```
130
+
131
+ `langchain-core`의 `prompt | RunnableLambda(...)` 체인 `invoke` 한 번 기준:
132
+
133
+ | 설정 | 줄 수 |
134
+ |---|---|
135
+ | 접기 없음 (`collapse=False`) | 231 |
136
+ | 기본값 (연속 반복 접기) | 193 |
137
+ | `+ hide_private=True` | 153 |
138
+ | `+ unique=True` | 48 |
139
+ | `+ ["langchain_core"]` | 38 |
140
+ | `+ max_depth=3` | 29 |
141
+
142
+ ### 추적 옵션
143
+
144
+ ```python
145
+ print_trace_start(["langchain_core", "openai"]) # 이 패키지들만 보기
146
+ print_trace_start(max_depth=2) # 3단계 깊이까지만
147
+ print_trace_start(user=True) # 내 코드 호출도 함께
148
+ print_trace_start(file="trace.log") # 화면 대신 파일로 저장
149
+ print_trace_start(hide_private=True) # _로 시작하는 내부 함수 숨기기
150
+ print_trace_start(unique=True) # 메소드마다 처음 호출만
151
+ print_trace_start(collapse=False) # 반복 호출도 접지 않고 전부
152
+ ```
153
+
154
+ | 옵션 | 기본값 | 설명 |
155
+ |---|---|---|
156
+ | `packages` | `None` | 추적할 패키지 이름 목록. 지정하면 위치와 상관없이 이 패키지만 출력 |
157
+ | `stdlib` | `False` | 파이썬 표준 라이브러리 호출도 출력 |
158
+ | `user` | `False` | 내가 작성한 프로젝트 코드 호출도 출력 |
159
+ | `max_depth` | `None` | 이 깊이보다 깊은 호출은 생략 (0부터 시작) |
160
+ | `max_lines` | `2000` | 최대 출력 줄 수. 넘으면 생략하고 개수만 알려줌 (`None`이면 무제한) |
161
+ | `file` | 화면 | 파일 객체 또는 파일 경로 |
162
+ | `show_line` | `True` | 파일 이름 뒤에 함수 정의 줄 번호 표시 |
163
+ | `hide_private` | `False` | `_parse`, `_Foo.run`처럼 `_`로 시작하는 내부 함수·클래스 숨김 (`__init__` 같은 특수 메소드는 표시) |
164
+ | `collapse` | `True` | 같은 메소드가 연달아 호출되면 `Foo.bar ×3` 한 줄로 접음 (하위 호출은 첫 번째 것만 표시) |
165
+ | `unique` | `False` | 메소드마다 처음 호출만 표시. 이후 같은 메소드는 줄을 생략하고, 그 안에서 처음 등장하는 메소드만 위 단계에 붙여 표시 |
166
+ | `threads` | `False` | 이후 새로 시작되는 스레드도 추적 |
167
+ | `header` | `True` | 시작/종료 구분선 출력 |
168
+
169
+ `print_trace_end(summary=False)`로 요약 출력을 끌 수 있습니다.
170
+ 반환값은 호출 목록입니다: `[{"depth", "method", "file", "line", "path"}, ...]`.
171
+
172
+ `with` 문으로도 쓸 수 있습니다.
173
+
174
+ ```python
175
+ from printsection import trace
176
+
177
+ with trace(["langchain_core"], max_depth=3):
178
+ chain.invoke({"question": "안녕"})
179
+ ```
180
+
181
+ ### 참고
182
+
183
+ - `hide_private`나 `unique`로 숨긴 호출 안에서 불린 새 함수는 그대로 보이고, 가장 가까운 상위 호출 아래에 붙습니다.
184
+ - 요약의 호출 횟수·시간에는 접히거나 생략된 호출까지 모두 포함됩니다 (`hide_private`로 숨긴 함수는 제외).
185
+ - 제너레이터/코루틴(스트리밍, async)은 처음 호출될 때 한 번만 표시합니다.
186
+ - 추적하는 동안에는 코드가 느려집니다. 공부하거나 디버깅할 때만 쓰세요.
{printsection-0.3.0 → printsection-0.5.0}/pyproject.toml RENAMED
@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
4
4
 
5
5
  [project]
6
6
  name = "printsection"
7
- version = "0.3.0"
7
+ version = "0.5.0"
8
8
  description = "출력 구간을 나누는 가운데 정렬 구분선 + 라이브러리 호출 흐름 추적 출력"
9
9
  readme = "README.md"
10
10
  requires-python = ">=3.8"
{printsection-0.3.0 → printsection-0.5.0}/src/printsection/__init__.py RENAMED
@@ -19,7 +19,7 @@ __all__ = [
19
19
  "print_trace_end",
20
20
  "trace",
21
21
  ]
22
- __version__ = "0.3.0"
22
+ __version__ = "0.5.0"
23
23
 
24
24
  _FACTORY_DEFAULTS = {
25
25
  "width": 50,