varview 0.1.0__tar.gz

varview-0.1.0/.ipynb_checkpoints/Readme-checkpoint.md

@@ -0,0 +1,144 @@
+# varview
+
+A tiny, zero-dependency debug-printing helper for people who check their work, for clean automation.
+
+```python
+from varview import debug
+
+count = 42
+total = 137
+status = "active"
+
+debug(["count", "total", "status"])
+```
+
+```
+count: 42
+
+total: 137
+
+status: active
+```
+
+## Why this exists
+
+Most debugging habits start the same way: `print(f"count: {count}")`,
+scattered through a script, forgotten about, and left in, or worse,
+silently shaping a result nobody meant to ship.
+
+`varview` was built out of a data analyst's day-to-day discipline: **if
+you can't see your intermediate values clearly, you can't trust your
+final ones.** Threshold sweeps, fold splits, feature combos, backtest
+tables: every step that touches a metric is a step where leakage,
+silent type coercion, or an off-by-one slice can quietly corrupt a
+result. The habit that catches this isn't a debugger or a notebook
+full of stray `print()` calls, it's making every checkpoint visible,
+on purpose, every time, with a single flip to turn it all off before
+anything ships.
+
+That's the whole philosophy behind this package:
+
+- **See it before you trust it.** Print the name *and* the value,
+  side by side, with no risk of the label drifting out of sync with
+  what it's labeling.
+- **Validate loudly, not quietly.** Every parameter is checked up
+  front; bad input fails fast with a clear error instead of
+  producing a confusing result three functions later.
+- **Make leakage a choice, not an accident.** One global switch
+  silences every debug call in a file at once, so nothing you used to
+  sanity-check a fold split or a train/test boundary can slip into
+  a shared notebook or a production run by accident.
+
+## Install
+
+```bash
+pip install varview
+```
+
+## Usage
+
+### Basic
+
+```python
+from varview import debug
+
+count = 42
+debug(["count"])       # list of names
+debug("count")          # a single string also works, no need to wrap it
+```
+
+### Color-code by what the value means to you
+
+```python
+debug(["count"], color="green")   # default, all good
+debug(["count"], color="yellow")  # worth a second look
+debug(["count"], color="red")     # flag it
+```
+
+### Lay it out the way you're scanning
+
+```python
+debug(["count", "total", "status"])                     # vertical (default)
+debug(["count", "total", "status"], orientation="horizontal")  # count: 42, total: 137, status: active
+```
+
+### Turn one call off without deleting it
+
+```python
+debug(["count"], display=False)
+```
+
+### Turn every call off at once, before you share or ship
+
+```python
+from varview import debug_off, debug_on
+
+debug_off()   # every debug() call in the process goes silent, even display=True ones
+# ... run the rest of your pipeline, notebook export, whatever needs to be clean ...
+debug_on()    # back to normal for your next debugging session
+```
+
+`debug_off()` is the one-line answer to "did I leave a debug print
+in this notebook before I sent it to someone." Flip it at the top of
+a cell, or right before a scheduled job runs, and every `debug()`
+call downstream goes quiet, no hunting through the file for calls
+you forgot about.
+
+### Typos don't kill the whole block
+
+```python
+debug(["count", "totall", "status"])
+# count: 42
+# totall: <not found>
+# status: active
+```
+
+One bad name prints `<not found>` in place instead of raising and
+losing every other value you wanted to see.
+
+## API
+
+### `debug(names, color="green", display=True, orientation="vertical")`
+
+| Param | Type | Default | Notes |
+|---|---|---|---|
+| `names` | `str` or `list`/`tuple` of `str` | (required) | Variable names to look up in the *caller's* local scope |
+| `color` | `"green"`, `"red"`, `"yellow"` | `"green"` | Label color only; values always print in black |
+| `display` | `bool` | `True` | Silences this one call when `False` |
+| `orientation` | `"vertical"`, `"horizontal"` | `"vertical"` | Layout of the printed pairs |
+
+All four parameters are validated on every call: an invalid `color`
+or `orientation` raises `ValueError`, an invalid `display` type raises
+`TypeError`, and `names` must be a string or a list/tuple of strings
+or it raises `TypeError`. Nothing gets a chance to fail silently or
+print something misleading.
+
+### `debug_off()` / `debug_on()`
+
+Module-level switch. `debug_off()` silences every `debug()` call in
+the running process, regardless of that call's own `display` value.
+`debug_on()` restores normal behavior.
+
+## License
+
+MIT

varview-0.1.0/.ipynb_checkpoints/pyproject-checkpoint.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "varview"
+version = "0.1.0"
+description = "A tiny debug-printing helper that prints name: value pairs from the caller's scope, with a one-line kill switch to prevent leaked debug output."
+readme = "README.md"
+requires-python = ">=3.7"
+authors = [
+    { name = "Henry", email = "osas2henry@gmail.com" }
+]
+keywords = ["debug", "debugging", "print", "variables", "logging", "data-validation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Debuggers",
+    "Topic :: Utilities",
+]

varview-0.1.0/.ipynb_checkpoints/setup-checkpoint.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="varview",
+    version="0.1.0",
+    description="A tiny debug-printing helper that prints name: value pairs from the caller's scope, with a one-line kill switch to prevent leaked debug output.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Henry",
+    author_email="osas2henry@gmail.com",
+    packages=find_packages(),
+    keywords=["debug", "debugging", "print", "variables", "logging", "data-validation"],
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Software Development :: Debuggers",
+        "Topic :: Utilities",
+    ],
+    python_requires=">=3.7",
+)

varview-0.1.0/PKG-INFO

@@ -0,0 +1,164 @@
+Metadata-Version: 2.5
+Name: varview
+Version: 0.1.0
+Summary: A tiny debug-printing helper that prints name: value pairs from the caller's scope, with a one-line kill switch to prevent leaked debug output.
+Author-email: Henry <osas2henry@gmail.com>
+Keywords: data-validation,debug,debugging,logging,print,variables
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Software Development :: Debuggers
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# varview
+
+A tiny, zero-dependency debug-printing helper for people who check their work, for clean automation.
+
+```python
+from varview import debug
+
+count = 42
+total = 137
+status = "active"
+
+debug(["count", "total", "status"])
+```
+
+```
+count: 42
+
+total: 137
+
+status: active
+```
+
+## Why this exists
+
+Most debugging habits start the same way: `print(f"count: {count}")`,
+scattered through a script, forgotten about, and left in, or worse,
+silently shaping a result nobody meant to ship.
+
+`varview` was built out of a data analyst's day-to-day discipline: **if
+you can't see your intermediate values clearly, you can't trust your
+final ones.** Threshold sweeps, fold splits, feature combos, backtest
+tables: every step that touches a metric is a step where leakage,
+silent type coercion, or an off-by-one slice can quietly corrupt a
+result. The habit that catches this isn't a debugger or a notebook
+full of stray `print()` calls, it's making every checkpoint visible,
+on purpose, every time, with a single flip to turn it all off before
+anything ships.
+
+That's the whole philosophy behind this package:
+
+- **See it before you trust it.** Print the name *and* the value,
+  side by side, with no risk of the label drifting out of sync with
+  what it's labeling.
+- **Validate loudly, not quietly.** Every parameter is checked up
+  front; bad input fails fast with a clear error instead of
+  producing a confusing result three functions later.
+- **Make leakage a choice, not an accident.** One global switch
+  silences every debug call in a file at once, so nothing you used to
+  sanity-check a fold split or a train/test boundary can slip into
+  a shared notebook or a production run by accident.
+
+## Install
+
+```bash
+pip install varview
+```
+
+## Usage
+
+### Basic
+
+```python
+from varview import debug
+
+count = 42
+debug(["count"])       # list of names
+debug("count")          # a single string also works, no need to wrap it
+```
+
+### Color-code by what the value means to you
+
+```python
+debug(["count"], color="green")   # default, all good
+debug(["count"], color="yellow")  # worth a second look
+debug(["count"], color="red")     # flag it
+```
+
+### Lay it out the way you're scanning
+
+```python
+debug(["count", "total", "status"])                     # vertical (default)
+debug(["count", "total", "status"], orientation="horizontal")  # count: 42, total: 137, status: active
+```
+
+### Turn one call off without deleting it
+
+```python
+debug(["count"], display=False)
+```
+
+### Turn every call off at once, before you share or ship
+
+```python
+from varview import debug_off, debug_on
+
+debug_off()   # every debug() call in the process goes silent, even display=True ones
+# ... run the rest of your pipeline, notebook export, whatever needs to be clean ...
+debug_on()    # back to normal for your next debugging session
+```
+
+`debug_off()` is the one-line answer to "did I leave a debug print
+in this notebook before I sent it to someone." Flip it at the top of
+a cell, or right before a scheduled job runs, and every `debug()`
+call downstream goes quiet, no hunting through the file for calls
+you forgot about.
+
+### Typos don't kill the whole block
+
+```python
+debug(["count", "totall", "status"])
+# count: 42
+# totall: <not found>
+# status: active
+```
+
+One bad name prints `<not found>` in place instead of raising and
+losing every other value you wanted to see.
+
+## API
+
+### `debug(names, color="green", display=True, orientation="vertical")`
+
+| Param | Type | Default | Notes |
+|---|---|---|---|
+| `names` | `str` or `list`/`tuple` of `str` | (required) | Variable names to look up in the *caller's* local scope |
+| `color` | `"green"`, `"red"`, `"yellow"` | `"green"` | Label color only; values always print in black |
+| `display` | `bool` | `True` | Silences this one call when `False` |
+| `orientation` | `"vertical"`, `"horizontal"` | `"vertical"` | Layout of the printed pairs |
+
+All four parameters are validated on every call: an invalid `color`
+or `orientation` raises `ValueError`, an invalid `display` type raises
+`TypeError`, and `names` must be a string or a list/tuple of strings
+or it raises `TypeError`. Nothing gets a chance to fail silently or
+print something misleading.
+
+### `debug_off()` / `debug_on()`
+
+Module-level switch. `debug_off()` silences every `debug()` call in
+the running process, regardless of that call's own `display` value.
+`debug_on()` restores normal behavior.
+
+## License
+
+MIT

varview-0.1.0/README.md

@@ -0,0 +1,144 @@
+# varview
+
+A tiny, zero-dependency debug-printing helper for people who check their work, for clean automation.
+
+```python
+from varview import debug
+
+count = 42
+total = 137
+status = "active"
+
+debug(["count", "total", "status"])
+```
+
+```
+count: 42
+
+total: 137
+
+status: active
+```
+
+## Why this exists
+
+Most debugging habits start the same way: `print(f"count: {count}")`,
+scattered through a script, forgotten about, and left in, or worse,
+silently shaping a result nobody meant to ship.
+
+`varview` was built out of a data analyst's day-to-day discipline: **if
+you can't see your intermediate values clearly, you can't trust your
+final ones.** Threshold sweeps, fold splits, feature combos, backtest
+tables: every step that touches a metric is a step where leakage,
+silent type coercion, or an off-by-one slice can quietly corrupt a
+result. The habit that catches this isn't a debugger or a notebook
+full of stray `print()` calls, it's making every checkpoint visible,
+on purpose, every time, with a single flip to turn it all off before
+anything ships.
+
+That's the whole philosophy behind this package:
+
+- **See it before you trust it.** Print the name *and* the value,
+  side by side, with no risk of the label drifting out of sync with
+  what it's labeling.
+- **Validate loudly, not quietly.** Every parameter is checked up
+  front; bad input fails fast with a clear error instead of
+  producing a confusing result three functions later.
+- **Make leakage a choice, not an accident.** One global switch
+  silences every debug call in a file at once, so nothing you used to
+  sanity-check a fold split or a train/test boundary can slip into
+  a shared notebook or a production run by accident.
+
+## Install
+
+```bash
+pip install varview
+```
+
+## Usage
+
+### Basic
+
+```python
+from varview import debug
+
+count = 42
+debug(["count"])       # list of names
+debug("count")          # a single string also works, no need to wrap it
+```
+
+### Color-code by what the value means to you
+
+```python
+debug(["count"], color="green")   # default, all good
+debug(["count"], color="yellow")  # worth a second look
+debug(["count"], color="red")     # flag it
+```
+
+### Lay it out the way you're scanning
+
+```python
+debug(["count", "total", "status"])                     # vertical (default)
+debug(["count", "total", "status"], orientation="horizontal")  # count: 42, total: 137, status: active
+```
+
+### Turn one call off without deleting it
+
+```python
+debug(["count"], display=False)
+```
+
+### Turn every call off at once, before you share or ship
+
+```python
+from varview import debug_off, debug_on
+
+debug_off()   # every debug() call in the process goes silent, even display=True ones
+# ... run the rest of your pipeline, notebook export, whatever needs to be clean ...
+debug_on()    # back to normal for your next debugging session
+```
+
+`debug_off()` is the one-line answer to "did I leave a debug print
+in this notebook before I sent it to someone." Flip it at the top of
+a cell, or right before a scheduled job runs, and every `debug()`
+call downstream goes quiet, no hunting through the file for calls
+you forgot about.
+
+### Typos don't kill the whole block
+
+```python
+debug(["count", "totall", "status"])
+# count: 42
+# totall: <not found>
+# status: active
+```
+
+One bad name prints `<not found>` in place instead of raising and
+losing every other value you wanted to see.
+
+## API
+
+### `debug(names, color="green", display=True, orientation="vertical")`
+
+| Param | Type | Default | Notes |
+|---|---|---|---|
+| `names` | `str` or `list`/`tuple` of `str` | (required) | Variable names to look up in the *caller's* local scope |
+| `color` | `"green"`, `"red"`, `"yellow"` | `"green"` | Label color only; values always print in black |
+| `display` | `bool` | `True` | Silences this one call when `False` |
+| `orientation` | `"vertical"`, `"horizontal"` | `"vertical"` | Layout of the printed pairs |
+
+All four parameters are validated on every call: an invalid `color`
+or `orientation` raises `ValueError`, an invalid `display` type raises
+`TypeError`, and `names` must be a string or a list/tuple of strings
+or it raises `TypeError`. Nothing gets a chance to fail silently or
+print something misleading.
+
+### `debug_off()` / `debug_on()`
+
+Module-level switch. `debug_off()` silences every `debug()` call in
+the running process, regardless of that call's own `display` value.
+`debug_on()` restores normal behavior.
+
+## License
+
+MIT

varview-0.1.0/Readme.md

@@ -0,0 +1,144 @@
+# varview
+
+A tiny, zero-dependency debug-printing helper for people who check their work, for clean automation.
+
+```python
+from varview import debug
+
+count = 42
+total = 137
+status = "active"
+
+debug(["count", "total", "status"])
+```
+
+```
+count: 42
+
+total: 137
+
+status: active
+```
+
+## Why this exists
+
+Most debugging habits start the same way: `print(f"count: {count}")`,
+scattered through a script, forgotten about, and left in, or worse,
+silently shaping a result nobody meant to ship.
+
+`varview` was built out of a data analyst's day-to-day discipline: **if
+you can't see your intermediate values clearly, you can't trust your
+final ones.** Threshold sweeps, fold splits, feature combos, backtest
+tables: every step that touches a metric is a step where leakage,
+silent type coercion, or an off-by-one slice can quietly corrupt a
+result. The habit that catches this isn't a debugger or a notebook
+full of stray `print()` calls, it's making every checkpoint visible,
+on purpose, every time, with a single flip to turn it all off before
+anything ships.
+
+That's the whole philosophy behind this package:
+
+- **See it before you trust it.** Print the name *and* the value,
+  side by side, with no risk of the label drifting out of sync with
+  what it's labeling.
+- **Validate loudly, not quietly.** Every parameter is checked up
+  front; bad input fails fast with a clear error instead of
+  producing a confusing result three functions later.
+- **Make leakage a choice, not an accident.** One global switch
+  silences every debug call in a file at once, so nothing you used to
+  sanity-check a fold split or a train/test boundary can slip into
+  a shared notebook or a production run by accident.
+
+## Install
+
+```bash
+pip install varview
+```
+
+## Usage
+
+### Basic
+
+```python
+from varview import debug
+
+count = 42
+debug(["count"])       # list of names
+debug("count")          # a single string also works, no need to wrap it
+```
+
+### Color-code by what the value means to you
+
+```python
+debug(["count"], color="green")   # default, all good
+debug(["count"], color="yellow")  # worth a second look
+debug(["count"], color="red")     # flag it
+```
+
+### Lay it out the way you're scanning
+
+```python
+debug(["count", "total", "status"])                     # vertical (default)
+debug(["count", "total", "status"], orientation="horizontal")  # count: 42, total: 137, status: active
+```
+
+### Turn one call off without deleting it
+
+```python
+debug(["count"], display=False)
+```
+
+### Turn every call off at once, before you share or ship
+
+```python
+from varview import debug_off, debug_on
+
+debug_off()   # every debug() call in the process goes silent, even display=True ones
+# ... run the rest of your pipeline, notebook export, whatever needs to be clean ...
+debug_on()    # back to normal for your next debugging session
+```
+
+`debug_off()` is the one-line answer to "did I leave a debug print
+in this notebook before I sent it to someone." Flip it at the top of
+a cell, or right before a scheduled job runs, and every `debug()`
+call downstream goes quiet, no hunting through the file for calls
+you forgot about.
+
+### Typos don't kill the whole block
+
+```python
+debug(["count", "totall", "status"])
+# count: 42
+# totall: <not found>
+# status: active
+```
+
+One bad name prints `<not found>` in place instead of raising and
+losing every other value you wanted to see.
+
+## API
+
+### `debug(names, color="green", display=True, orientation="vertical")`
+
+| Param | Type | Default | Notes |
+|---|---|---|---|
+| `names` | `str` or `list`/`tuple` of `str` | (required) | Variable names to look up in the *caller's* local scope |
+| `color` | `"green"`, `"red"`, `"yellow"` | `"green"` | Label color only; values always print in black |
+| `display` | `bool` | `True` | Silences this one call when `False` |
+| `orientation` | `"vertical"`, `"horizontal"` | `"vertical"` | Layout of the printed pairs |
+
+All four parameters are validated on every call: an invalid `color`
+or `orientation` raises `ValueError`, an invalid `display` type raises
+`TypeError`, and `names` must be a string or a list/tuple of strings
+or it raises `TypeError`. Nothing gets a chance to fail silently or
+print something misleading.
+
+### `debug_off()` / `debug_on()`
+
+Module-level switch. `debug_off()` silences every `debug()` call in
+the running process, regardless of that call's own `display` value.
+`debug_on()` restores normal behavior.
+
+## License
+
+MIT

varview-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "varview"
+version = "0.1.0"
+description = "A tiny debug-printing helper that prints name: value pairs from the caller's scope, with a one-line kill switch to prevent leaked debug output."
+readme = "README.md"
+requires-python = ">=3.7"
+authors = [
+    { name = "Henry", email = "osas2henry@gmail.com" }
+]
+keywords = ["debug", "debugging", "print", "variables", "logging", "data-validation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Debuggers",
+    "Topic :: Utilities",
+]

varview-0.1.0/setup.py

@@ -0,0 +1,30 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="varview",
+    version="0.1.0",
+    description="A tiny debug-printing helper that prints name: value pairs from the caller's scope, with a one-line kill switch to prevent leaked debug output.",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Henry",
+    author_email="osas2henry@gmail.com",
+    packages=find_packages(),
+    keywords=["debug", "debugging", "print", "variables", "logging", "data-validation"],
+    classifiers=[
+        "Development Status :: 4 - Beta",
+        "Intended Audience :: Developers",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Topic :: Software Development :: Debuggers",
+        "Topic :: Utilities",
+    ],
+    python_requires=">=3.7",
+)

varview-0.1.0/varview/.ipynb_checkpoints/__init__-checkpoint.py

@@ -0,0 +1,192 @@
+"""
+varview
+~~~~~~~
+
+A tiny debug-printing helper: pass variable names as strings and it
+prints "name: value" pairs pulled straight from the caller's local
+scope — no need to write out f"{name}: {value}" by hand.
+
+Basic usage:
+    from varview import debug
+
+    count = 42
+    debug(["count"])          # green label, black value
+    debug("count")             # single string also works
+    debug(["count"], color="red")
+    debug(["count"], orientation="horizontal")
+
+Global kill switch (silence every debug() call in one line, e.g.
+before sharing a notebook or shipping to prod):
+    from varview import debug_off, debug_on
+    debug_off()
+    debug_on()
+"""
+
+import inspect
+
+__all__ = ["debug", "debug_off", "debug_on"]
+__version__ = "0.1.0"
+
+_DEBUG_GLOBAL_ENABLED = True  # flip via debug_off()/debug_on() to silence ALL debug() calls at once
+
+
+def debug(names, color="green", display=True, orientation="vertical"):
+    """
+    Pass a list of variable name strings, or a single name as a plain
+    string, and this prints each one as "name: value" (name bolded in
+    the chosen color, value always black).
+
+    e.g. debug(["count", "total", "status"])
+         debug("count")   <- single string also works, auto-wrapped
+                              into a one-item list so it isn't split
+                              into characters.
+
+    `color` picks the name/label color: "green", "red", or "yellow".
+    Defaults to "green". Raises ValueError if anything else is passed.
+
+    `display` toggles THIS SPECIFIC call. Defaults to True. Must be a
+    bool, or TypeError is raised.
+
+    Printing only happens if BOTH `display=True` for this call AND the
+    module-level global switch is enabled. Call `debug_off()` to
+    silence every debug() call in the file at once (e.g. before
+    sharing a notebook, to eliminate leakage), and `debug_on()` to
+    restore them — no need to touch individual call sites.
+
+    `orientation` picks the layout: "vertical" (default) prints one
+    "name: value" pair per line with a blank line between each pair.
+    "horizontal" prints all pairs on a single line, separated by ", ".
+    Raises ValueError if anything else is passed.
+
+    Looks up each name in the CALLER's local variables (via inspect) —
+    you don't need to pass the values yourself, just the names as
+    strings, in the order you want them printed.
+    `names` must be a string or a list/tuple of strings, or TypeError
+    is raised.
+    A name not found in the caller's locals prints as
+    "name: <not found>" (label still in the chosen color) instead of
+    raising, so one typo doesn't kill the whole debug block.
+    """
+    VALID_COLORS = {"green", "red", "yellow"}
+    VALID_ORIENTATIONS = {"vertical", "horizontal"}
+
+    if not isinstance(display, bool):
+        raise TypeError(f"display must be a bool, got {type(display).__name__}")
+
+    if color not in VALID_COLORS:
+        raise ValueError(f"color must be one of {sorted(VALID_COLORS)}, got {color!r}")
+
+    if orientation not in VALID_ORIENTATIONS:
+        raise ValueError(f"orientation must be one of {sorted(VALID_ORIENTATIONS)}, got {orientation!r}")
+
+    if isinstance(names, str):
+        names = [names]
+    elif isinstance(names, (list, tuple)):
+        if not all(isinstance(n, str) for n in names):
+            raise TypeError("all items in names must be strings")
+    else:
+        raise TypeError(f"names must be a str or list/tuple of str, got {type(names).__name__}")
+
+    if not display or not _DEBUG_GLOBAL_ENABLED:
+        return
+
+    COLORS = {
+        "green": "\033[1;32m",
+        "red": "\033[1;91m",     # bright red
+        "yellow": "\033[1;93m",  # bright yellow
+    }
+    NAME_COLOR = COLORS[color]
+    BLACK = "\033[30m"
+    RESET = "\033[0m"
+
+    caller_locals = inspect.currentframe().f_back.f_locals
+    lines = []
+    for name in names:
+        if name in caller_locals:
+            value = caller_locals[name]
+            lines.append(f"{NAME_COLOR}{name}{RESET}: {BLACK}{value}{RESET}")
+        else:
+            lines.append(f"{NAME_COLOR}{name}{RESET}: {BLACK}<not found>{RESET}")
+
+    if orientation == "horizontal":
+        print(", ".join(lines))
+    else:
+        print("\n\n".join(lines))
+
+
+def debug_off():
+    """Silence ALL debug() calls in this module (global kill switch)."""
+    global _DEBUG_GLOBAL_ENABLED
+    _DEBUG_GLOBAL_ENABLED = False
+
+
+def debug_on():
+    """Re-enable debug() calls after debug_off()."""
+    global _DEBUG_GLOBAL_ENABLED
+    _DEBUG_GLOBAL_ENABLED = True
+
+
+"""
+if __name__ == "__main__":
+    count = 42
+    total = 137
+    status = "active"
+
+    print("--- default (vertical, green, display=True) ---")
+    debug(["count", "total", "status"])
+
+    print("\n--- single string, not a list ---")
+    debug("count")
+
+    print("\n--- color='red' ---")
+    debug(["count", "total"], color="red")
+
+    print("\n--- color='yellow' ---")
+    debug(["count", "total"], color="yellow")
+
+    print("\n--- orientation='horizontal' (comma-separated) ---")
+    debug(["count", "total", "status"], orientation="horizontal")
+
+    print("\n--- horizontal + color='red' ---")
+    debug(["count", "total", "status"], color="red", orientation="horizontal")
+
+    print("\n--- missing variable (typo) ---")
+    debug(["count", "totall", "status"])
+
+    print("\n--- display=False (should print nothing below this line) ---")
+    debug(["count", "total"], display=False)
+    print("(nothing printed above if display=False worked)")
+
+    print("\n--- global debug_off() silences everything, even display=True ---")
+    debug_off()
+    debug(["count", "total", "status"])
+    print("(nothing printed above if debug_off() worked)")
+
+    print("\n--- debug_on() restores normal behavior ---")
+    debug_on()
+    debug(["count", "total", "status"])
+
+    print("\n--- invalid color raises ValueError ---")
+    try:
+        debug(["count"], color="purple")
+    except ValueError as e:
+        print(f"Caught: {e}")
+
+    print("\n--- invalid orientation raises ValueError ---")
+    try:
+        debug(["count"], orientation="diagonal")
+    except ValueError as e:
+        print(f"Caught: {e}")
+
+    print("\n--- invalid display type raises TypeError ---")
+    try:
+        debug(["count"], display="yes")
+    except TypeError as e:
+        print(f"Caught: {e}")
+
+    print("\n--- invalid names type raises TypeError ---")
+    try:
+        debug(123)
+"""
+    except TypeError as e:
+        print(f"Caught: {e}")

varview-0.1.0/varview/__init__.py

@@ -0,0 +1,192 @@
+"""
+varview
+~~~~~~~
+
+A tiny debug-printing helper: pass variable names as strings and it
+prints "name: value" pairs pulled straight from the caller's local
+scope — no need to write out f"{name}: {value}" by hand.
+
+Basic usage:
+    from varview import debug
+
+    count = 42
+    debug(["count"])          # green label, black value
+    debug("count")             # single string also works
+    debug(["count"], color="red")
+    debug(["count"], orientation="horizontal")
+
+Global kill switch (silence every debug() call in one line, e.g.
+before sharing a notebook or shipping to prod):
+    from varview import debug_off, debug_on
+    debug_off()
+    debug_on()
+"""
+
+import inspect
+
+__all__ = ["debug", "debug_off", "debug_on"]
+__version__ = "0.1.0"
+
+_DEBUG_GLOBAL_ENABLED = True  # flip via debug_off()/debug_on() to silence ALL debug() calls at once
+
+
+def debug(names, color="green", display=True, orientation="vertical"):
+    """
+    Pass a list of variable name strings, or a single name as a plain
+    string, and this prints each one as "name: value" (name bolded in
+    the chosen color, value always black).
+
+    e.g. debug(["count", "total", "status"])
+         debug("count")   <- single string also works, auto-wrapped
+                              into a one-item list so it isn't split
+                              into characters.
+
+    `color` picks the name/label color: "green", "red", or "yellow".
+    Defaults to "green". Raises ValueError if anything else is passed.
+
+    `display` toggles THIS SPECIFIC call. Defaults to True. Must be a
+    bool, or TypeError is raised.
+
+    Printing only happens if BOTH `display=True` for this call AND the
+    module-level global switch is enabled. Call `debug_off()` to
+    silence every debug() call in the file at once (e.g. before
+    sharing a notebook, to eliminate leakage), and `debug_on()` to
+    restore them — no need to touch individual call sites.
+
+    `orientation` picks the layout: "vertical" (default) prints one
+    "name: value" pair per line with a blank line between each pair.
+    "horizontal" prints all pairs on a single line, separated by ", ".
+    Raises ValueError if anything else is passed.
+
+    Looks up each name in the CALLER's local variables (via inspect) —
+    you don't need to pass the values yourself, just the names as
+    strings, in the order you want them printed.
+    `names` must be a string or a list/tuple of strings, or TypeError
+    is raised.
+    A name not found in the caller's locals prints as
+    "name: <not found>" (label still in the chosen color) instead of
+    raising, so one typo doesn't kill the whole debug block.
+    """
+    VALID_COLORS = {"green", "red", "yellow"}
+    VALID_ORIENTATIONS = {"vertical", "horizontal"}
+
+    if not isinstance(display, bool):
+        raise TypeError(f"display must be a bool, got {type(display).__name__}")
+
+    if color not in VALID_COLORS:
+        raise ValueError(f"color must be one of {sorted(VALID_COLORS)}, got {color!r}")
+
+    if orientation not in VALID_ORIENTATIONS:
+        raise ValueError(f"orientation must be one of {sorted(VALID_ORIENTATIONS)}, got {orientation!r}")
+
+    if isinstance(names, str):
+        names = [names]
+    elif isinstance(names, (list, tuple)):
+        if not all(isinstance(n, str) for n in names):
+            raise TypeError("all items in names must be strings")
+    else:
+        raise TypeError(f"names must be a str or list/tuple of str, got {type(names).__name__}")
+
+    if not display or not _DEBUG_GLOBAL_ENABLED:
+        return
+
+    COLORS = {
+        "green": "\033[1;32m",
+        "red": "\033[1;91m",     # bright red
+        "yellow": "\033[1;93m",  # bright yellow
+    }
+    NAME_COLOR = COLORS[color]
+    BLACK = "\033[30m"
+    RESET = "\033[0m"
+
+    caller_locals = inspect.currentframe().f_back.f_locals
+    lines = []
+    for name in names:
+        if name in caller_locals:
+            value = caller_locals[name]
+            lines.append(f"{NAME_COLOR}{name}{RESET}: {BLACK}{value}{RESET}")
+        else:
+            lines.append(f"{NAME_COLOR}{name}{RESET}: {BLACK}<not found>{RESET}")
+
+    if orientation == "horizontal":
+        print(", ".join(lines))
+    else:
+        print("\n\n".join(lines))
+
+
+def debug_off():
+    """Silence ALL debug() calls in this module (global kill switch)."""
+    global _DEBUG_GLOBAL_ENABLED
+    _DEBUG_GLOBAL_ENABLED = False
+
+
+def debug_on():
+    """Re-enable debug() calls after debug_off()."""
+    global _DEBUG_GLOBAL_ENABLED
+    _DEBUG_GLOBAL_ENABLED = True
+
+
+"""
+if __name__ == "__main__":
+    count = 42
+    total = 137
+    status = "active"
+
+    print("--- default (vertical, green, display=True) ---")
+    debug(["count", "total", "status"])
+
+    print("\n--- single string, not a list ---")
+    debug("count")
+
+    print("\n--- color='red' ---")
+    debug(["count", "total"], color="red")
+
+    print("\n--- color='yellow' ---")
+    debug(["count", "total"], color="yellow")
+
+    print("\n--- orientation='horizontal' (comma-separated) ---")
+    debug(["count", "total", "status"], orientation="horizontal")
+
+    print("\n--- horizontal + color='red' ---")
+    debug(["count", "total", "status"], color="red", orientation="horizontal")
+
+    print("\n--- missing variable (typo) ---")
+    debug(["count", "totall", "status"])
+
+    print("\n--- display=False (should print nothing below this line) ---")
+    debug(["count", "total"], display=False)
+    print("(nothing printed above if display=False worked)")
+
+    print("\n--- global debug_off() silences everything, even display=True ---")
+    debug_off()
+    debug(["count", "total", "status"])
+    print("(nothing printed above if debug_off() worked)")
+
+    print("\n--- debug_on() restores normal behavior ---")
+    debug_on()
+    debug(["count", "total", "status"])
+
+    print("\n--- invalid color raises ValueError ---")
+    try:
+        debug(["count"], color="purple")
+    except ValueError as e:
+        print(f"Caught: {e}")
+
+    print("\n--- invalid orientation raises ValueError ---")
+    try:
+        debug(["count"], orientation="diagonal")
+    except ValueError as e:
+        print(f"Caught: {e}")
+
+    print("\n--- invalid display type raises TypeError ---")
+    try:
+        debug(["count"], display="yes")
+    except TypeError as e:
+        print(f"Caught: {e}")
+
+    print("\n--- invalid names type raises TypeError ---")
+    try:
+        debug(123)
+"""
+    except TypeError as e:
+        print(f"Caught: {e}")