tracecomparekit 0.1.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.
@@ -0,0 +1,225 @@
1
+ # Byte-compiled / optimized / DLL files
2
+ __pycache__/
3
+ *.py[codz]
4
+ *$py.class
5
+
6
+ # C extensions
7
+ *.so
8
+
9
+ # Distribution / packaging
10
+ .Python
11
+ build/
12
+ develop-eggs/
13
+ dist/
14
+ downloads/
15
+ eggs/
16
+ .eggs/
17
+ lib/
18
+ lib64/
19
+ parts/
20
+ sdist/
21
+ var/
22
+ wheels/
23
+ share/python-wheels/
24
+ *.egg-info/
25
+ .installed.cfg
26
+ *.egg
27
+ MANIFEST
28
+
29
+ # PyInstaller
30
+ # Usually these files are written by a python script from a template
31
+ # before PyInstaller builds the exe, so as to inject date/other infos into it.
32
+ *.manifest
33
+ *.spec
34
+
35
+ # Installer logs
36
+ pip-log.txt
37
+ pip-delete-this-directory.txt
38
+
39
+ # Unit test / coverage reports
40
+ htmlcov/
41
+ .tox/
42
+ .nox/
43
+ .coverage
44
+ .coverage.*
45
+ .cache
46
+ nosetests.xml
47
+ coverage.xml
48
+ *.cover
49
+ *.py.cover
50
+ *.lcov
51
+ .hypothesis/
52
+ .pytest_cache/
53
+ cover/
54
+
55
+ # Translations
56
+ *.mo
57
+ *.pot
58
+
59
+ # Django stuff:
60
+ *.log
61
+ local_settings.py
62
+ db.sqlite3
63
+ db.sqlite3-journal
64
+
65
+ # Flask stuff:
66
+ instance/
67
+ .webassets-cache
68
+
69
+ # Scrapy stuff:
70
+ .scrapy
71
+
72
+ # Sphinx documentation
73
+ docs/_build/
74
+
75
+ # PyBuilder
76
+ .pybuilder/
77
+ target/
78
+
79
+ # Jupyter Notebook
80
+ .ipynb_checkpoints
81
+
82
+ # IPython
83
+ profile_default/
84
+ ipython_config.py
85
+
86
+ # pyenv
87
+ # For a library or package, you might want to ignore these files since the code is
88
+ # intended to run in multiple environments; otherwise, check them in:
89
+ # .python-version
90
+
91
+ # pipenv
92
+ # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
93
+ # However, in case of collaboration, if having platform-specific dependencies or dependencies
94
+ # having no cross-platform support, pipenv may install dependencies that don't work, or not
95
+ # install all needed dependencies.
96
+ # Pipfile.lock
97
+
98
+ # uv
99
+ # Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
100
+ # This is especially recommended for binary packages to ensure reproducibility, and is more
101
+ # commonly ignored for libraries.
102
+ # uv.lock
103
+
104
+ # poetry
105
+ # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
106
+ # This is especially recommended for binary packages to ensure reproducibility, and is more
107
+ # commonly ignored for libraries.
108
+ # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
109
+ # poetry.lock
110
+ # poetry.toml
111
+
112
+ # pdm
113
+ # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
114
+ # pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
115
+ # https://pdm-project.org/en/latest/usage/project/#working-with-version-control
116
+ # pdm.lock
117
+ # pdm.toml
118
+ .pdm-python
119
+ .pdm-build/
120
+
121
+ # pixi
122
+ # Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
123
+ # pixi.lock
124
+ # Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
125
+ # in the .venv directory. It is recommended not to include this directory in version control.
126
+ .pixi/*
127
+ !.pixi/config.toml
128
+
129
+ # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
130
+ __pypackages__/
131
+
132
+ # Celery stuff
133
+ celerybeat-schedule*
134
+ celerybeat.pid
135
+
136
+ # Redis
137
+ *.rdb
138
+ *.aof
139
+ *.pid
140
+
141
+ # RabbitMQ
142
+ mnesia/
143
+ rabbitmq/
144
+ rabbitmq-data/
145
+
146
+ # ActiveMQ
147
+ activemq-data/
148
+
149
+ # SageMath parsed files
150
+ *.sage.py
151
+
152
+ # Environments
153
+ .env
154
+ .envrc
155
+ .venv
156
+ env/
157
+ venv/
158
+ ENV/
159
+ env.bak/
160
+ venv.bak/
161
+
162
+ # Spyder project settings
163
+ .spyderproject
164
+ .spyproject
165
+
166
+ # Rope project settings
167
+ .ropeproject
168
+
169
+ # mkdocs/Zensical documentation
170
+ /site
171
+
172
+ # mypy
173
+ .mypy_cache/
174
+ .dmypy.json
175
+ dmypy.json
176
+
177
+ # Pyre type checker
178
+ .pyre/
179
+
180
+ # pytype static type analyzer
181
+ .pytype/
182
+
183
+ # Cython debug symbols
184
+ cython_debug/
185
+
186
+ # PyCharm
187
+ # JetBrains specific template is maintained in a separate JetBrains.gitignore that can
188
+ # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
189
+ # and can be added to the global gitignore or merged into this file. For a more nuclear
190
+ # option (not recommended) you can uncomment the following to ignore the entire idea folder.
191
+ .idea/
192
+
193
+ # macOS archive metadata
194
+ .DS_Store
195
+ __MACOSX/
196
+ ._*
197
+
198
+ # Abstra
199
+ # Abstra is an AI-powered process automation framework.
200
+ # Ignore directories containing user credentials, local state, and settings.
201
+ # Learn more at https://abstra.io/docs
202
+ .abstra/
203
+
204
+ # Visual Studio Code
205
+ # Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore that
206
+ # can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
207
+ # and can be added to the global gitignore or merged into this file. However, if you prefer, you
208
+ # could uncomment the following to ignore the entire vscode folder
209
+ # .vscode/
210
+ # Temporary file for partial code execution
211
+ tempCodeRunnerFile.py
212
+
213
+ # Ruff stuff:
214
+ .ruff_cache/
215
+
216
+ # PyPI configuration file
217
+ .pypirc
218
+
219
+ # Marimo
220
+ marimo/_static/
221
+ marimo/_lsp/
222
+ __marimo__/
223
+
224
+ # Streamlit
225
+ .streamlit/secrets.toml
@@ -0,0 +1,23 @@
1
+ MIT License
2
+
3
+ Copyright (c) 2026 Clement
4
+ Copyright (c) 2026 Iko
5
+ Copyright (c) 2026 James
6
+
7
+ Permission is hereby granted, free of charge, to any person obtaining a copy
8
+ of this software and associated documentation files (the "Software"), to deal
9
+ in the Software without restriction, including without limitation the rights
10
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11
+ copies of the Software, and to permit persons to whom the Software is
12
+ furnished to do so, subject to the following conditions:
13
+
14
+ The above copyright notice and this permission notice shall be included in all
15
+ copies or substantial portions of the Software.
16
+
17
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
23
+ SOFTWARE.
@@ -0,0 +1,189 @@
1
+ Metadata-Version: 2.5
2
+ Name: tracecomparekit
3
+ Version: 0.1.0
4
+ Summary: Check a Python function against a reference solution and see exactly how they differ.
5
+ Project-URL: Homepage, https://github.com/clemonl/DiffFinder
6
+ Project-URL: Repository, https://github.com/clemonl/DiffFinder
7
+ Project-URL: Documentation, https://github.com/clemonl/DiffFinder#readme
8
+ Author: Clement Leung, Iko Yeung, James
9
+ License-Expression: MIT
10
+ License-File: LICENSE
11
+ Requires-Python: >=3.9
12
+ Provides-Extra: dev
13
+ Requires-Dist: pytest; extra == 'dev'
14
+ Provides-Extra: hermes
15
+ Requires-Dist: hermes-acp-sdk; extra == 'hermes'
16
+ Requires-Dist: hermes-agent[acp]; extra == 'hermes'
17
+ Description-Content-Type: text/markdown
18
+
19
+ # DiffFinder
20
+
21
+ **Check a Python function against a reference solution and see exactly how they differ.**
22
+
23
+ Give DiffFinder your function and a known-good one. It runs both on the same input and tells you whether they
24
+ behave the same, and if not, what is different: the result, an exception, or a change to the input.
25
+
26
+ ```text
27
+ pip install tracecomparekit
28
+ ```
29
+
30
+ ## Motivation
31
+
32
+ When a program gives the wrong answer, a beginner often cannot tell *what* is wrong, only that something is.
33
+ But frequently a correct solution already exists (the lecturer's, a textbook's, a classmate's). Then the useful
34
+ question is not "what does my code do?" but **"how does my code's behaviour differ from the right one?"**
35
+
36
+ ## What makes it different
37
+
38
+ - **You supply a reference function, not hand-written expected values.** There is nothing to calculate by hand,
39
+ and the reference can be written in any style.
40
+ - **It compares behaviour, not source code.** A loop and a formula that give the same answers are reported as the
41
+ same. A text diff of the two would be useless.
42
+ - **It catches what a printed return value hides:** a function that crashes where the reference does not, or one
43
+ that changes its input list in place when the reference leaves it alone.
44
+ - **No dependencies**, so it installs next to anything, including on a shared notebook server.
45
+
46
+ ## Quick start
47
+
48
+ ```python
49
+ from difffinder import compare
50
+
51
+ def count_to(n): # your version
52
+ total = 0
53
+ for i in range(n):
54
+ total += i
55
+ return total
56
+
57
+ def count_to_ref(n): # the reference
58
+ total = 0
59
+ for i in range(n + 1):
60
+ total += i
61
+ return total
62
+
63
+ compare(count_to, count_to_ref, args=(4,))
64
+ ```
65
+
66
+ ```text
67
+ DIFFERENT: count_to and count_to_ref behave differently on (n=4).
68
+ result: yours returned 6, the reference returned 10.
69
+ ```
70
+
71
+ Different algorithms with the same behaviour are reported as the same:
72
+
73
+ ```python
74
+ def formula(n):
75
+ return n * (n + 1) // 2
76
+
77
+ compare(count_to_ref, formula, args=(4,))
78
+ ```
79
+
80
+ ```text
81
+ SAME: count_to_ref and formula behave the same on (n=4).
82
+ ```
83
+
84
+ Crashes and changes to the input are shown too:
85
+
86
+ ```python
87
+ def sort_in_place(items):
88
+ items.sort()
89
+ return items
90
+
91
+ def sorted_copy(items):
92
+ return sorted(items)
93
+
94
+ compare(sort_in_place, sorted_copy, args=([3, 1, 2],))
95
+ ```
96
+
97
+ ```text
98
+ DIFFERENT: sort_in_place and sorted_copy behave differently on (items=[3, 1, 2]).
99
+ argument 'items' afterwards: yours [1, 2, 3], the reference [3, 1, 2].
100
+ ```
101
+
102
+ ```python
103
+ def first_item(items):
104
+ return items[0]
105
+
106
+ def first_or_none(items):
107
+ return items[0] if items else None
108
+
109
+ compare(first_item, first_or_none, args=([],))
110
+ ```
111
+
112
+ ```text
113
+ DIFFERENT: first_item and first_or_none behave differently on (items=[]).
114
+ result: yours raised IndexError: list index out of range, the reference returned None.
115
+ ```
116
+
117
+ ## Usage
118
+
119
+ ```python
120
+ compare(candidate, reference, args=(), kwargs=None)
121
+ ```
122
+
123
+ | Part | Meaning |
124
+ | --- | --- |
125
+ | `candidate` | your function (the one you want to check) |
126
+ | `reference` | the known-good function |
127
+ | `args` | a tuple of positional arguments, for example `(4,)` or `([3, 1, 2], 5)` (note the comma in a one-item tuple) |
128
+ | `kwargs` | a dict of keyword arguments, for example `{"reverse": True}` |
129
+
130
+ It returns a `Comparison` with `.same` (`True` or `False`), `.differences` (a list), and `.candidate` /
131
+ `.reference`, which hold what each function did. `run(func, args)` runs a single function and records the same
132
+ information.
133
+
134
+ ### When are two functions "the same"?
135
+
136
+ On the input you give, they must have:
137
+
138
+ 1. the same return value (compared with `==`), or both raise the same kind of exception, and
139
+ 2. the same final state of every argument they received.
140
+
141
+ Each function runs on its own deep copy of your arguments, so your data is never changed.
142
+
143
+ ## Limitations
144
+
145
+ - It checks **one input per call**. A function can match on your input and still be wrong on another, so try
146
+ several (such as an empty list, zero, or a negative number).
147
+ - The functions must finish. It cannot yet stop an endless loop.
148
+ - Anything a function does besides returning or changing its arguments (printing, files, network) happens once
149
+ per function.
150
+ - Parameters are matched by position, so the two functions may use different parameter names.
151
+
152
+ ## Trace a difference
153
+
154
+ `compare_traces()` records changes to local variables and shows where the two runs first
155
+ diverge. The report displays as text in the terminal and as a table in Jupyter.
156
+
157
+ ```python
158
+ from difffinder import compare_traces, find_difference
159
+
160
+ report = compare_traces(count_to, count_to_ref, args=(4,), probe=False)
161
+ print(report)
162
+
163
+ first = find_difference(count_to, count_to_ref, [0, 1, 4])
164
+ print(first.args) # (1,)
165
+ ```
166
+
167
+ By default, `compare_traces()` also runs the functions on variations of the positional inputs
168
+ and tries to shrink a failing example. Use `probe=False` to run each function once.
169
+ Pass `watch=["total"]` to compare a particular variable. Offline hints appear in the report.
170
+ For an optional model-generated hint, pass `ai=your_callable`. The callable receives a prompt
171
+ containing the functions' source, input, and comparison report.
172
+
173
+ ## Sorting visualizer
174
+
175
+ With Tkinter installed, run `python -m difffinder.sorting_visualizer`. Choose two sorting
176
+ functions, enter a list, and click **Compare & Record** to step through their changes side by side.
177
+ For a terminal example, run `python -m difffinder.demo --console`.
178
+
179
+ ## Development
180
+
181
+ ```text
182
+ git clone https://github.com/clemonl/DiffFinder
183
+ cd difffinder
184
+ pip install -e ".[dev]"
185
+ pytest
186
+ ```
187
+
188
+ Requirements are listed in [SPEC.md](SPEC.md) and the division of work in [TEAM.md](TEAM.md).
189
+ Released under the MIT license.
@@ -0,0 +1,171 @@
1
+ # DiffFinder
2
+
3
+ **Check a Python function against a reference solution and see exactly how they differ.**
4
+
5
+ Give DiffFinder your function and a known-good one. It runs both on the same input and tells you whether they
6
+ behave the same, and if not, what is different: the result, an exception, or a change to the input.
7
+
8
+ ```text
9
+ pip install tracecomparekit
10
+ ```
11
+
12
+ ## Motivation
13
+
14
+ When a program gives the wrong answer, a beginner often cannot tell *what* is wrong, only that something is.
15
+ But frequently a correct solution already exists (the lecturer's, a textbook's, a classmate's). Then the useful
16
+ question is not "what does my code do?" but **"how does my code's behaviour differ from the right one?"**
17
+
18
+ ## What makes it different
19
+
20
+ - **You supply a reference function, not hand-written expected values.** There is nothing to calculate by hand,
21
+ and the reference can be written in any style.
22
+ - **It compares behaviour, not source code.** A loop and a formula that give the same answers are reported as the
23
+ same. A text diff of the two would be useless.
24
+ - **It catches what a printed return value hides:** a function that crashes where the reference does not, or one
25
+ that changes its input list in place when the reference leaves it alone.
26
+ - **No dependencies**, so it installs next to anything, including on a shared notebook server.
27
+
28
+ ## Quick start
29
+
30
+ ```python
31
+ from difffinder import compare
32
+
33
+ def count_to(n): # your version
34
+ total = 0
35
+ for i in range(n):
36
+ total += i
37
+ return total
38
+
39
+ def count_to_ref(n): # the reference
40
+ total = 0
41
+ for i in range(n + 1):
42
+ total += i
43
+ return total
44
+
45
+ compare(count_to, count_to_ref, args=(4,))
46
+ ```
47
+
48
+ ```text
49
+ DIFFERENT: count_to and count_to_ref behave differently on (n=4).
50
+ result: yours returned 6, the reference returned 10.
51
+ ```
52
+
53
+ Different algorithms with the same behaviour are reported as the same:
54
+
55
+ ```python
56
+ def formula(n):
57
+ return n * (n + 1) // 2
58
+
59
+ compare(count_to_ref, formula, args=(4,))
60
+ ```
61
+
62
+ ```text
63
+ SAME: count_to_ref and formula behave the same on (n=4).
64
+ ```
65
+
66
+ Crashes and changes to the input are shown too:
67
+
68
+ ```python
69
+ def sort_in_place(items):
70
+ items.sort()
71
+ return items
72
+
73
+ def sorted_copy(items):
74
+ return sorted(items)
75
+
76
+ compare(sort_in_place, sorted_copy, args=([3, 1, 2],))
77
+ ```
78
+
79
+ ```text
80
+ DIFFERENT: sort_in_place and sorted_copy behave differently on (items=[3, 1, 2]).
81
+ argument 'items' afterwards: yours [1, 2, 3], the reference [3, 1, 2].
82
+ ```
83
+
84
+ ```python
85
+ def first_item(items):
86
+ return items[0]
87
+
88
+ def first_or_none(items):
89
+ return items[0] if items else None
90
+
91
+ compare(first_item, first_or_none, args=([],))
92
+ ```
93
+
94
+ ```text
95
+ DIFFERENT: first_item and first_or_none behave differently on (items=[]).
96
+ result: yours raised IndexError: list index out of range, the reference returned None.
97
+ ```
98
+
99
+ ## Usage
100
+
101
+ ```python
102
+ compare(candidate, reference, args=(), kwargs=None)
103
+ ```
104
+
105
+ | Part | Meaning |
106
+ | --- | --- |
107
+ | `candidate` | your function (the one you want to check) |
108
+ | `reference` | the known-good function |
109
+ | `args` | a tuple of positional arguments, for example `(4,)` or `([3, 1, 2], 5)` (note the comma in a one-item tuple) |
110
+ | `kwargs` | a dict of keyword arguments, for example `{"reverse": True}` |
111
+
112
+ It returns a `Comparison` with `.same` (`True` or `False`), `.differences` (a list), and `.candidate` /
113
+ `.reference`, which hold what each function did. `run(func, args)` runs a single function and records the same
114
+ information.
115
+
116
+ ### When are two functions "the same"?
117
+
118
+ On the input you give, they must have:
119
+
120
+ 1. the same return value (compared with `==`), or both raise the same kind of exception, and
121
+ 2. the same final state of every argument they received.
122
+
123
+ Each function runs on its own deep copy of your arguments, so your data is never changed.
124
+
125
+ ## Limitations
126
+
127
+ - It checks **one input per call**. A function can match on your input and still be wrong on another, so try
128
+ several (such as an empty list, zero, or a negative number).
129
+ - The functions must finish. It cannot yet stop an endless loop.
130
+ - Anything a function does besides returning or changing its arguments (printing, files, network) happens once
131
+ per function.
132
+ - Parameters are matched by position, so the two functions may use different parameter names.
133
+
134
+ ## Trace a difference
135
+
136
+ `compare_traces()` records changes to local variables and shows where the two runs first
137
+ diverge. The report displays as text in the terminal and as a table in Jupyter.
138
+
139
+ ```python
140
+ from difffinder import compare_traces, find_difference
141
+
142
+ report = compare_traces(count_to, count_to_ref, args=(4,), probe=False)
143
+ print(report)
144
+
145
+ first = find_difference(count_to, count_to_ref, [0, 1, 4])
146
+ print(first.args) # (1,)
147
+ ```
148
+
149
+ By default, `compare_traces()` also runs the functions on variations of the positional inputs
150
+ and tries to shrink a failing example. Use `probe=False` to run each function once.
151
+ Pass `watch=["total"]` to compare a particular variable. Offline hints appear in the report.
152
+ For an optional model-generated hint, pass `ai=your_callable`. The callable receives a prompt
153
+ containing the functions' source, input, and comparison report.
154
+
155
+ ## Sorting visualizer
156
+
157
+ With Tkinter installed, run `python -m difffinder.sorting_visualizer`. Choose two sorting
158
+ functions, enter a list, and click **Compare & Record** to step through their changes side by side.
159
+ For a terminal example, run `python -m difffinder.demo --console`.
160
+
161
+ ## Development
162
+
163
+ ```text
164
+ git clone https://github.com/clemonl/DiffFinder
165
+ cd difffinder
166
+ pip install -e ".[dev]"
167
+ pytest
168
+ ```
169
+
170
+ Requirements are listed in [SPEC.md](SPEC.md) and the division of work in [TEAM.md](TEAM.md).
171
+ Released under the MIT license.
@@ -0,0 +1,32 @@
1
+ [build-system]
2
+ requires = ["hatchling"]
3
+ build-backend = "hatchling.build"
4
+
5
+ [project]
6
+ name = "tracecomparekit"
7
+ version = "0.1.0"
8
+ description = "Check a Python function against a reference solution and see exactly how they differ."
9
+ readme = "README.md"
10
+ requires-python = ">=3.9"
11
+ license = "MIT"
12
+ authors = [
13
+ { name = "Clement Leung" },
14
+ { name = "Iko Yeung" },
15
+ { name = "James" }
16
+ ]
17
+ dependencies = []
18
+
19
+ [project.optional-dependencies]
20
+ dev = ["pytest"]
21
+ hermes = [
22
+ "hermes-acp-sdk",
23
+ "hermes-agent[acp]"
24
+ ]
25
+
26
+ [project.urls]
27
+ Homepage = "https://github.com/clemonl/DiffFinder"
28
+ Repository = "https://github.com/clemonl/DiffFinder"
29
+ Documentation = "https://github.com/clemonl/DiffFinder#readme"
30
+
31
+ [tool.hatch.build.targets.wheel]
32
+ packages = ["src/difffinder"]
@@ -0,0 +1,21 @@
1
+ """DiffFinder: check a Python function against a reference solution and see how they differ.
2
+
3
+ >>> from difffinder import compare
4
+ >>> compare(my_function, reference_function, args=(4,))
5
+ """
6
+
7
+ from .comparison import Comparison, Difference, compare
8
+ from .ai import explain, hermes_llm, openai_compatible
9
+ from .diff import Divergence, TraceComparison, compare_traces, find_difference, find_divergence
10
+ from .outcome import Outcome, run
11
+ from .selfcheck import selfcheck
12
+ from .tracer import RAISE, RETURN, Event, StepLimitExceeded, Trace, record
13
+
14
+ __version__ = "0.1.0"
15
+
16
+ __all__ = [
17
+ "compare", "run", "Comparison", "Difference", "Outcome",
18
+ "compare_traces", "TraceComparison", "Divergence", "find_difference", "find_divergence",
19
+ "record", "Trace", "Event", "StepLimitExceeded", "RETURN", "RAISE",
20
+ "explain", "openai_compatible", "hermes_llm", "selfcheck", "__version__",
21
+ ]
@@ -0,0 +1,3 @@
1
+ from .selfcheck import selfcheck
2
+
3
+ raise SystemExit(0 if selfcheck() else 1)