siren-debug 0.5.0__py2.py3-none-any.whl

siren/__init__.py

@@ -0,0 +1,19 @@
+try:
+    import builtins
+except ImportError:  # Python 2
+    import __builtin__ as builtins
+
+from .core import siren, trace, info, set_quiet, set_logfile, set_enabled, get_config, diff, breakpoint_debug
+
+__all__ = ["siren", "trace", "info", "set_quiet", "set_logfile", "set_enabled", "get_config", "diff", "breakpoint_debug"]
+
+builtins.siren = siren
+
+siren.trace = trace
+siren.info = info
+siren.set_quiet = set_quiet
+siren.set_logfile = set_logfile
+siren.set_enabled = set_enabled
+siren.get_config = get_config
+siren.diff = diff
+siren.breakpoint = breakpoint_debug

siren/_output.py

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+import sys
+
+
+def safe_print(text):
+    try:
+        print(text)
+    except UnicodeEncodeError:
+        encoding = getattr(sys.stdout, "encoding", None) or "ascii"
+        print(text.encode(encoding, errors="replace").decode(encoding, errors="replace"))

siren/autoload.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""
+Toggle automatic injection of `siren` into builtins for every Python
+process started from the current environment (venv), by managing a
+.pth file in site-packages.
+
+Usage:
+    siren-autoload on       # enable
+    siren-autoload off      # disable
+    siren-autoload status   # check current state
+"""
+from __future__ import print_function
+
+import io
+import os
+import sys
+import sysconfig
+
+from ._output import safe_print
+
+PTH_FILENAME = "siren-autoload.pth"
+PTH_CONTENT = (
+    'import sys; exec("try:\\n    import siren\\nexcept Exception:\\n    pass")\n'
+)
+
+COLOR = "\033[38;2;255;105;180m"
+RESET = "\033[0m"
+EMOJI = "🧜‍"
+
+
+def _pth_path():
+    return os.path.join(sysconfig.get_path("purelib"), PTH_FILENAME)
+
+
+def enable():
+    path = _pth_path()
+    with io.open(path, "w", encoding="utf-8") as f:
+        f.write(PTH_CONTENT)
+    return path
+
+
+def disable():
+    path = _pth_path()
+    if os.path.exists(path):
+        os.remove(path)
+        return True
+    return False
+
+
+def is_enabled():
+    return os.path.exists(_pth_path())
+
+
+def main():
+    args = sys.argv[1:]
+    command = args[0] if args else "status"
+
+    if command == "on":
+        path = enable()
+        safe_print("{}[{} SIREN AUTOLOAD]{} enabled -> {}".format(COLOR, EMOJI, RESET, path))
+    elif command == "off":
+        removed = disable()
+        message = "disabled" if removed else "was already disabled"
+        safe_print("{}[{} SIREN AUTOLOAD]{} {}".format(COLOR, EMOJI, RESET, message))
+    elif command == "status":
+        state = "enabled" if is_enabled() else "disabled"
+        safe_print("{}[{} SIREN AUTOLOAD]{} {}".format(COLOR, EMOJI, RESET, state))
+    else:
+        print("Usage: siren-autoload [on|off|status]")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

siren/clean.py

@@ -0,0 +1,188 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+
+import io
+import os
+import re
+import sys
+import tokenize
+import traceback
+from datetime import datetime
+
+from ._output import safe_print
+
+TOKEN_NAME = "siren"
+
+IMPORT_RE = re.compile(r"^\s*from\s+siren\s+import\s+siren(?:\s+as\s+\w+)?\s*(?:#.*)?$")
+
+# ANSI para rosa
+COLOR = "\033[38;2;255;105;180m"
+RESET = "\033[0m"
+EMOJI = "🧜‍"
+
+IGNORE_DIRS = {
+    "venv",
+    ".venv",
+    "__pycache__",
+    "doc",
+    "docs",
+    ".git",
+    "node_modules",
+}
+
+
+def _format_timestamp():
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _multiline_string_lines(tokens):
+    """Line numbers that fall entirely inside a multi-line string literal."""
+    lines = set()
+
+    for token in tokens:
+        if token[0] == tokenize.STRING:
+            start_row, end_row = token[2][0], token[3][0]
+            if end_row > start_row:
+                lines.update(range(start_row + 1, end_row + 1))
+
+    return lines
+
+
+def _collect_siren_lines(source):
+    lines = source.splitlines(keepends=True)
+    marked = set()
+
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))
+    except tokenize.TokenError:
+        return marked
+
+    string_lines = _multiline_string_lines(tokens)
+
+    for index, token in enumerate(tokens):
+        toknum, tokval, start, _, _ = token
+
+        if toknum == tokenize.NAME and tokval == TOKEN_NAME:
+            # Skip definitions like `def siren(...)` / `def siren.trace(...)` -
+            # only actual calls should be stripped, not the definition itself.
+            prev = index - 1
+            while prev >= 0 and tokens[prev][0] in (
+                tokenize.NL,
+                tokenize.INDENT,
+                tokenize.DEDENT,
+                tokenize.COMMENT,
+            ):
+                prev -= 1
+
+            if prev >= 0 and tokens[prev][0] == tokenize.NAME and tokens[prev][1] == "def":
+                continue
+
+            j = index + 1
+            while j < len(tokens) and tokens[j][0] in (
+                tokenize.NL,
+                tokenize.NEWLINE,
+                tokenize.INDENT,
+                tokenize.DEDENT,
+                tokenize.ENDMARKER,
+            ):
+                j += 1
+
+            if j < len(tokens) and tokens[j][0] == tokenize.OP and tokens[j][1] == "(":
+                depth = 0
+                k = j
+
+                while k < len(tokens):
+                    toknum2, tokval2, start2, _, _ = tokens[k]
+                    marked.add(start2[0])
+
+                    if toknum2 == tokenize.OP:
+                        if tokval2 == "(":
+                            depth += 1
+                        elif tokval2 == ")":
+                            depth -= 1
+                            if depth == 0:
+                                break
+
+                    k += 1
+
+    for lineno, line in enumerate(lines, 1):
+        if lineno in string_lines:
+            continue
+        if IMPORT_RE.match(line):
+            marked.add(lineno)
+
+    return marked
+
+
+def clean_file(path, dry_run=False):
+    # io.open decodes/encodes explicitly on both Python 2 and 3, unlike the
+    # builtin open() which doesn't accept encoding= on Python 2.
+    with io.open(path, "r", encoding="utf-8") as f:
+        source = f.read()
+
+    lines = source.splitlines(keepends=True)
+
+    try:
+        marked = _collect_siren_lines(source)
+    except Exception as e:
+        raise type(e)("{}\nArquivo: {}".format(e, path))
+
+    if not marked:
+        return 0
+
+    if dry_run:
+        safe_print("✓ {} ({} linhas)".format(path, len(marked)))
+        return len(marked)
+
+    new_lines = [line for lineno, line in enumerate(lines, start=1) if lineno not in marked]
+    new_source = "".join(new_lines)
+
+    try:
+        compile(new_source, path, "exec")
+    except SyntaxError:
+        # Removing these lines would leave invalid Python (e.g. an emptied
+        # block). Leave the file untouched rather than corrupting it.
+        return 0
+
+    with io.open(path, "w", encoding="utf-8") as f:
+        f.write(new_source)
+
+    return len(marked)
+
+
+def clean_directory(root):
+    total_removed = 0
+
+    for base, dirs, files in os.walk(root):
+        # Impede o os.walk de entrar nesses diretórios
+        dirs[:] = [d for d in dirs if d.lower() not in IGNORE_DIRS]
+
+        for name in files:
+            if name.endswith(".py"):
+                path = os.path.join(base, name)
+                total_removed += clean_file(path)
+
+    return total_removed
+
+
+def main():
+    try:
+        target = sys.argv[1] if len(sys.argv) > 1 else "."
+        removed = clean_directory(target)
+        safe_print(
+            "{}[{} SIREN CLEAN {}] {}{} linhas removidas{}".format(
+                COLOR,
+                EMOJI,
+                _format_timestamp(),
+                COLOR,
+                removed,
+                RESET,
+            )
+        )
+    except Exception:
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

siren/core.py

@@ -0,0 +1,589 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function
+
+import io
+import pprint
+import inspect
+import linecache
+import re
+import sys
+import time
+import os
+import tokenize
+from datetime import datetime
+
+from ._output import safe_print
+
+try:
+    text_type = unicode  # Python 2
+except NameError:
+    text_type = str  # Python 3
+
+try:
+    _read_input = raw_input  # Python 2
+except NameError:
+    _read_input = input  # Python 3
+
+# time.perf_counter() doesn't exist on Python 2; time.time() is lower
+# resolution but good enough for a debug timer.
+_perf_counter = getattr(time, "perf_counter", time.time)
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+COLOR = "\033[38;2;255;105;180m"
+RESET = "\033[0m"
+EMOJI = '🧜‍' #"🔱"
+
+PROJECT_MARKERS = [
+    ".git",
+    "pyproject.toml",
+    "setup.py",
+    "requirements.txt",
+    "manage.py",
+]
+
+# Global configuration
+_SIREN_CONFIG = {
+    "quiet": False,
+    "logfile": None,
+    "enabled": True,
+}
+
+def find_project_root(start_path):
+    path = os.path.abspath(start_path)
+
+    while True:
+        for marker in PROJECT_MARKERS:
+            if os.path.exists(os.path.join(path, marker)):
+                return path
+
+        parent = os.path.dirname(path)
+
+        if parent == path:
+            return None
+
+        path = parent
+
+
+def _is_simple(value):
+    return isinstance(value, (int, float, str, bool, type(None)))
+
+
+def _format_timestamp():
+    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _print_output(text):
+    """Handle output according to configuration (stdout or logfile)."""
+    if _SIREN_CONFIG["quiet"]:
+        return
+
+    safe_print(text)
+
+    if _SIREN_CONFIG["logfile"]:
+        try:
+            payload = text + "\n"
+            if not isinstance(payload, text_type):
+                payload = payload.decode("utf-8")
+            with io.open(_SIREN_CONFIG["logfile"], "a", encoding="utf-8") as f:
+                f.write(payload)
+        except Exception:
+            pass  # Silently fail on log write errors
+
+
+def _ensure_text(value):
+    """Decode byte strings to text so tokenize/io.StringIO work on Python 2,
+    where source read from disk isn't decoded automatically."""
+    if isinstance(value, text_type):
+        return value
+    try:
+        return value.decode("utf-8")
+    except UnicodeDecodeError:
+        return value.decode("utf-8", errors="replace")
+
+
+def _get_call_source(frame):
+    filename = frame.f_code.co_filename
+    lineno = frame.f_lineno
+
+    line = linecache.getline(filename, lineno).strip()
+
+    return line
+
+
+def get_rel_path(frame):
+    caminho = frame.f_code.co_filename
+
+    root = find_project_root(caminho)
+
+    if root:
+        return os.path.relpath(caminho, root)
+
+    return caminho
+
+
+def _extract_args(frame):
+    filename = frame.f_code.co_filename
+    lineno = frame.f_lineno
+
+    try:
+        lines = linecache.getlines(filename)
+    except Exception:
+        return []
+
+    if not lines or lineno > len(lines):
+        return []
+
+    start = lineno - 1
+    while start >= 0 and "siren" not in lines[start]:
+        start -= 1
+
+    if start < 0:
+        return []
+
+    source_lines = []
+    paren_depth = 0
+    saw_call = False
+
+    for line in lines[start:]:
+        source_lines.append(line)
+
+        for char in line:
+            if char == "(":
+                paren_depth += 1
+                saw_call = saw_call or "siren" in line
+            elif char == ")":
+                paren_depth -= 1
+
+        if saw_call and paren_depth <= 0:
+            break
+
+    source = _ensure_text("".join(source_lines))
+
+    try:
+        tokens = list(tokenize.generate_tokens(io.StringIO(source).readline))
+    except tokenize.TokenError:
+        return []
+
+    for index, token in enumerate(tokens):
+        toknum, tokval, _, _, _ = token
+        if toknum == tokenize.NAME and tokval == "siren":
+            j = index + 1
+            while j < len(tokens) and tokens[j][0] in (
+                tokenize.NL,
+                tokenize.NEWLINE,
+                tokenize.INDENT,
+                tokenize.DEDENT,
+            ):
+                j += 1
+
+            if j >= len(tokens) or tokens[j][0] != tokenize.OP or tokens[j][1] != "(":
+                continue
+
+            depth = 0
+            current = []
+            parts = []
+            k = j + 1
+
+            while k < len(tokens):
+                tn, tv, _, _, _ = tokens[k]
+
+                if tn == tokenize.OP and tv == "(":
+                    depth += 1
+                    current.append(tv)
+                elif tn == tokenize.OP and tv == ")":
+                    if depth == 0:
+                        break
+                    depth -= 1
+                    current.append(tv)
+                elif tn == tokenize.OP and tv == "," and depth == 0:
+                    parts.append("".join(current).strip())
+                    current = []
+                else:
+                    if tn in (tokenize.NEWLINE, tokenize.NL):
+                        current.append(" ")
+                    elif tn in (tokenize.INDENT, tokenize.DEDENT):
+                        pass
+                    elif tn == tokenize.COMMENT:
+                        pass
+                    else:
+                        current.append(tv)
+                k += 1
+
+            if current:
+                parts.append("".join(current).strip())
+
+            return [p for p in parts if p]
+
+    return []
+
+
+def _prefix(frame, label=None):
+
+    lineno = frame.f_lineno
+
+    base = "{}[{} SIREN {} {}:{}]{}".format(
+        COLOR,
+        EMOJI,
+        _format_timestamp(),
+        get_rel_path(frame),
+        lineno,
+        RESET,
+    )
+
+    if label:
+        base += " {}{}{}".format(COLOR, label, RESET)
+
+    return base
+
+
+def siren(*values, **kwargs):
+    """
+    siren(x)
+    siren(x, y)
+    siren(x, label="BEFORE LOOP")
+    siren(x, timeit=True)
+    siren(x, quiet=True)
+    siren(x, if_equals=5)
+    siren(x, if_len_gt=100)
+    """
+
+    if not _SIREN_CONFIG["enabled"]:
+        if len(values) == 1:
+            return values[0]
+        return values
+
+    # Check conditional filters
+    if_equals = kwargs.get("if_equals")
+    if_len_gt = kwargs.get("if_len_gt")
+    if_len_lt = kwargs.get("if_len_lt")
+    if_true = kwargs.get("if_true")
+    if_false = kwargs.get("if_false")
+
+    # Evaluate conditions
+    if if_equals is not None:
+        if len(values) != 1 or values[0] != if_equals:
+            if len(values) == 1:
+                return values[0]
+            return values
+
+    if if_len_gt is not None:
+        if len(values) != 1 or not hasattr(values[0], "__len__") or len(values[0]) <= if_len_gt:
+            if len(values) == 1:
+                return values[0]
+            return values
+
+    if if_len_lt is not None:
+        if len(values) != 1 or not hasattr(values[0], "__len__") or len(values[0]) >= if_len_lt:
+            if len(values) == 1:
+                return values[0]
+            return values
+
+    if if_true is not None:
+        if not values[0]:
+            if len(values) == 1:
+                return values[0]
+            return values
+
+    if if_false is not None:
+        if values[0]:
+            if len(values) == 1:
+                return values[0]
+            return values
+
+    frame = inspect.currentframe().f_back
+
+    label = kwargs.get("label")
+    timeit = kwargs.get("timeit", False)
+    quiet = kwargs.get("quiet", False)
+
+    start = None
+
+    if timeit:
+        start = time.time()
+
+    args = _extract_args(frame)
+
+    prefix = _prefix(frame, label)
+
+    # Temporarily override quiet setting if specified
+    original_quiet = _SIREN_CONFIG["quiet"]
+    if quiet:
+        _SIREN_CONFIG["quiet"] = True
+
+    try:
+        for i, v in enumerate(values):
+
+            name = args[i] if i < len(args) else "?"
+
+            if _is_simple(v):
+                output = "{} {}{} = {}{}".format(prefix, COLOR, name, v, RESET)
+            else:
+                text = pprint.pformat(v)
+                output = "{} {}{} = {}{}".format(prefix, COLOR, name, text, RESET)
+
+            _print_output(output)
+
+        if timeit:
+            elapsed = time.time() - start
+            timer_output = "{}[{} SIREN TIME {}] {}{:.6f}s{}".format(
+                COLOR,
+                EMOJI,
+                _format_timestamp(),
+                COLOR,
+                elapsed,
+                RESET,
+            )
+            _print_output(timer_output)
+
+        if len(values) == 1:
+            return values[0]
+
+        return values
+    finally:
+        _SIREN_CONFIG["quiet"] = original_quiet
+
+def _truncate_str(text, max_len=80):
+    """Truncate long strings for readable trace output."""
+    if len(text) <= max_len:
+        return text
+    return text[:max_len-3] + "..."
+
+
+def _format_value_for_trace(value, max_len=80):
+    """Format a value for trace output with truncation."""
+    if _is_simple(value):
+        return str(value)
+    text = pprint.pformat(value)
+    return _truncate_str(text, max_len)
+
+
+def _format_trace_args(func, args, kwargs):
+    try:
+        if hasattr(inspect, "signature"):
+            signature = inspect.signature(func)
+            bound = signature.bind_partial(*args, **kwargs)
+            bound.apply_defaults()
+            arguments = bound.arguments.items()
+        else:
+            # Python 2 has no inspect.signature; getcallargs is the closest
+            # equivalent for binding args/kwargs to parameter names.
+            arguments = inspect.getcallargs(func, *args, **kwargs).items()
+
+        parts = []
+
+        for name, value in arguments:
+            formatted = _format_value_for_trace(value, max_len=60)
+            parts.append("{}={}".format(name, formatted))
+
+        return ", ".join(parts)
+    except (TypeError, ValueError):
+        parts = [repr(value) for value in args]
+        parts += ["{}={}".format(name, repr(value)) for name, value in kwargs.items()]
+        return ", ".join(parts)
+
+
+def trace(func=None, **options):
+    """
+    Decorator to display function entry and exit automatically.
+
+    Usage:
+        @siren.trace
+        def foo(...):
+            ...
+
+    Optional configuration:
+        @siren.trace(timeit=True, show_args=False, show_type=True)
+    """
+    timeit = options.get("timeit", True)
+    show_args = options.get("show_args", True)
+    show_return = options.get("show_return", True)
+    show_type = options.get("show_type", True)
+
+    def decorator(target):
+        def wrapper(*args, **kwargs):
+            arg_text = _format_trace_args(target, args, kwargs) if show_args else ""
+            call_label = "Calling {}".format(target.__name__)
+            if arg_text:
+                call_label += "({})".format(arg_text)
+            else:
+                call_label += "()"
+
+            start = _perf_counter() if timeit else None
+            siren.info(call_label)
+
+            result = None
+            exception_occurred = False
+            try:
+                result = target(*args, **kwargs)
+            except Exception as e:
+                exception_occurred = True
+                exc_type = type(e).__name__
+                exc_msg = str(e)
+                siren.info("Exception in {} -> {}: {}".format(target.__name__, exc_type, exc_msg))
+                raise
+            finally:
+                if not exception_occurred:
+                    elapsed_text = ""
+                    if timeit:
+                        elapsed = _perf_counter() - start
+                        elapsed_text = " ({:.6f}s)".format(elapsed)
+
+                    if show_return and result is not None:
+                        result_text = _format_value_for_trace(result, max_len=100)
+                        type_text = " [{}]".format(type(result).__name__) if show_type else ""
+                        siren.info(
+                            "Returned from {} -> {}{}{}".format(
+                                target.__name__, result_text, type_text, elapsed_text
+                            )
+                        )
+                    elif show_return and result is None and timeit:
+                        siren.info(
+                            "Completed {} (None){}".format(
+                                target.__name__, elapsed_text
+                            )
+                        )
+
+            return result
+
+        return wrapper
+
+    if func is None:
+        return decorator
+
+    return decorator(func)
+
+
+def info(*args, **kwargs):
+    """
+    Siren info message
+    """
+    siren(*args, **kwargs)
+
+
+def set_quiet(enabled=True):
+    """Enable or disable output (quiet mode)."""
+    _SIREN_CONFIG["quiet"] = enabled
+
+
+def set_logfile(filepath):
+    """Set a file to log all siren output to."""
+    _SIREN_CONFIG["logfile"] = filepath
+
+
+def set_enabled(enabled=True):
+    """Enable or disable siren completely."""
+    _SIREN_CONFIG["enabled"] = enabled
+
+
+def get_config():
+    """Get current siren configuration."""
+    return _SIREN_CONFIG.copy()
+
+
+def diff(obj1, obj2, label="DIFF"):
+    """
+    Compare two objects and display differences.
+    
+    Usage:
+        before = {"name": "Alice", "age": 30}
+        after = {"name": "Alice", "age": 31, "city": "NYC"}
+        siren.diff(before, after)
+    """
+    frame = inspect.currentframe().f_back
+    prefix = _prefix(frame, label)
+
+    if type(obj1) != type(obj2):
+        _print_output("{} {}Type mismatch: {} vs {}{}".format(
+            prefix, COLOR, type(obj1).__name__, type(obj2).__name__, RESET
+        ))
+        return
+
+    if isinstance(obj1, dict) and isinstance(obj2, dict):
+        all_keys = set(obj1.keys()) | set(obj2.keys())
+
+        for key in sorted(all_keys):
+            if key not in obj1:
+                _print_output("{} {}[+] {}: {} (new){}".format(
+                    prefix, COLOR, key, pprint.pformat(obj2[key]), RESET
+                ))
+            elif key not in obj2:
+                _print_output("{} {}[-] {}: {} (removed){}".format(
+                    prefix, COLOR, key, pprint.pformat(obj1[key]), RESET
+                ))
+            elif obj1[key] != obj2[key]:
+                _print_output(
+                    "{} {}[~] {}: {} → {} (changed){}".format(
+                        prefix, COLOR, key, pprint.pformat(obj1[key]), pprint.pformat(obj2[key]), RESET
+                    )
+                )
+
+    elif isinstance(obj1, (list, tuple)) and isinstance(obj2, (list, tuple)):
+        max_len = max(len(obj1), len(obj2))
+
+        for i in range(max_len):
+            if i >= len(obj1):
+                _print_output("{} {}[+] [{}]: {} (new){}".format(
+                    prefix, COLOR, i, pprint.pformat(obj2[i]), RESET
+                ))
+            elif i >= len(obj2):
+                _print_output("{} {}[-] [{}]: {} (removed){}".format(
+                    prefix, COLOR, i, pprint.pformat(obj1[i]), RESET
+                ))
+            elif obj1[i] != obj2[i]:
+                _print_output(
+                    "{} {}[~] [{}]: {} → {} (changed){}".format(
+                        prefix, COLOR, i, pprint.pformat(obj1[i]), pprint.pformat(obj2[i]), RESET
+                    )
+                )
+
+    else:
+        if obj1 == obj2:
+            _print_output("{} {}No differences{}".format(prefix, COLOR, RESET))
+        else:
+            _print_output("{} {}Before: {}{}".format(prefix, COLOR, pprint.pformat(obj1), RESET))
+            _print_output("{} {}After: {}{}".format(prefix, COLOR, pprint.pformat(obj2), RESET))
+
+
+def breakpoint_debug():
+    """
+    Interactive debugger with siren context.
+    Pauses execution and allows inspection.
+    
+    Usage:
+        x = 42
+        siren.breakpoint()  # Pauses here
+    """
+    frame = inspect.currentframe().f_back
+    prefix = _prefix(frame, "BREAKPOINT")
+
+    local_vars = frame.f_locals
+    _print_output("{} {}=== BREAKPOINT ==={}".format(prefix, COLOR, RESET))
+    _print_output("{} {}Locals:{}".format(prefix, COLOR, RESET))
+
+    for name, value in sorted(local_vars.items()):
+        if not name.startswith("_"):
+            formatted = _format_value_for_trace(value, max_len=80)
+            _print_output("{} {}  {} = {}{}".format(prefix, COLOR, name, formatted, RESET))
+
+    _print_output("{} {}Press Ctrl+C to continue or 'd' for debugger...{}".format(prefix, COLOR, RESET))
+
+    try:
+        if sys.stdin.isatty():
+            response = _read_input(">>> ").strip()
+            if response.lower() == "d":
+                import pdb
+                pdb.set_trace()
+    except (EOFError, KeyboardInterrupt):
+        pass
+
+    _print_output("{} {}Continuing execution...{}".format(prefix, COLOR, RESET))
+
+
+siren.trace = trace
+siren.set_quiet = set_quiet
+siren.set_logfile = set_logfile
+siren.set_enabled = set_enabled
+siren.get_config = get_config
+siren.diff = diff
+siren.breakpoint = breakpoint_debug
+siren.info = info

siren_debug-0.5.0.dist-info/METADATA

@@ -0,0 +1,333 @@
+Metadata-Version: 2.4
+Name: siren-debug
+Version: 0.5.0
+Summary: Minimalist debug tool for Python with automatic cleaner
+Author: Alexandra Bona Abreu
+License: MIT
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+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
+Requires-Python: !=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7
+Description-Content-Type: text/markdown
+
+# Siren
+
+Minimal Python debug helper with automatic cleanup.
+
+> A tiny debugging utility for Python that prints variables with file/line context, traces function calls, measures execution time, and safely removes debug calls from your code.
+
+[![PyPI - Version](https://img.shields.io/pypi/v/siren-debug?label=PyPI&color=blue)](https://pypi.org/project/siren-debug/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/siren-debug?label=Python)](https://pypi.org/project/siren-debug/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+---
+
+## Install
+
+```bash
+pip install siren-debug
+```
+
+The package also installs two commands: `siren-clean` (remove debug calls) and `siren-autoload` (use `siren` without importing it).
+
+---
+
+## Quick Start
+
+```python
+from siren import siren
+
+x = 10
+user = {"name": "Alex", "items": [1, 2, 3]}
+
+siren(x)
+siren(user)
+```
+
+```text
+[🧜‍ SIREN core.py:10] x = 10
+[🧜‍ SIREN core.py:11] user = {'name': 'Alex', 'items': [1, 2, 3]}
+```
+
+Siren automatically uses `pprint` for complex objects, and picks up the file/line it was called from.
+
+---
+
+## Features
+
+- Works with Python 2.7 and 3.6+
+- Zero external dependencies
+- Prints values with file and line number
+- Uses `pprint` automatically for complex data
+- Function tracing with `@siren.trace`, object diffing with `siren.diff`, and an interactive `siren.breakpoint()`
+- Quiet mode, conditional logging, and file logging
+- Removes `siren(...)` calls automatically with `siren-clean`
+- Use `siren` anywhere without importing it via `siren-autoload`
+- Works in scripts, CLI tools, Django, Flask, FastAPI, and more
+- Colored output with emoji for easy visual scanning
+
+---
+
+## Usage
+
+Call `siren(...)` with one or more values. It returns them unchanged, so it can be inlined:
+
+```python
+from siren import siren
+
+siren(x, data, user)
+result = siren(compute())  # still returns compute()'s value
+```
+
+**Label** — tag a call for easier scanning:
+
+```python
+siren(value, label="BEFORE SAVE")
+```
+
+**Timer** — measure execution time for a call:
+
+```python
+siren(x, timeit=True)
+# [🧜‍ SIREN core.py:10] x = 10
+# [🧜‍ SIREN TIME] 0.000123s
+```
+
+**Quiet mode** — suppress output without removing the call:
+
+```python
+siren(x, quiet=True)      # this call only, still returns x
+siren.set_quiet(True)     # every call, until set_quiet(False)
+```
+
+**Conditional logging** — only print when a condition holds:
+
+```python
+siren(x, if_equals=5)        # only if x == 5
+siren(items, if_len_gt=100)  # only if len(items) > 100
+siren(items, if_len_lt=5)    # only if len(items) < 5
+siren(result, if_true=True)  # only if result is truthy
+siren(error, if_false=True)  # only if error is falsy
+```
+
+**Logging to file** — mirror output to a file:
+
+```python
+siren.set_logfile("debug.log")
+siren(x)  # prints to stdout AND writes to debug.log
+```
+
+**Inspect configuration**:
+
+```python
+config = siren.get_config()
+print(config)  # {"quiet": False, "logfile": None, "enabled": True}
+```
+
+---
+
+## Function tracing
+
+`@siren.trace` logs a function's calls, arguments, return value, execution time, and exceptions automatically:
+
+```python
+from siren import trace
+
+@siren.trace
+def add(a, b):
+    return a + b
+
+add(2, 3)
+```
+
+```text
+[🧜‍ SIREN core.py:10] Calling add(a=2, b=3)
+[🧜‍ SIREN core.py:11] Returned from add -> 5 [int] (0.000123s)
+```
+
+Configuration options (all default to `True`):
+
+| Option | Effect |
+|---|---|
+| `timeit` | Show execution time |
+| `show_args` | Show function arguments |
+| `show_return` | Show return value |
+| `show_type` | Show return type in brackets |
+
+```python
+@siren.trace(timeit=True, show_args=False, show_type=False)
+def multiply(a, b):
+    return a * b
+```
+
+Exceptions are logged before being re-raised, so `@siren.trace` never swallows an error:
+
+```python
+@siren.trace
+def divide(a, b):
+    return a / b
+
+divide(5, 0)  # Logs exception before raising
+```
+
+---
+
+## Diff and breakpoint
+
+**`siren.diff`** compares two dicts, lists, tuples, or any comparable objects:
+
+```python
+before = {"name": "Alice", "age": 30}
+after = {"name": "Alice", "age": 31, "city": "NYC"}
+
+siren.diff(before, after)
+```
+
+```text
+[🧜‍ SIREN test.py:10] DIFF
+[🧜‍ SIREN test.py:11] [~] age: 30 → 31 (changed)
+[🧜‍ SIREN test.py:12] [+] city: NYC (new)
+```
+
+**`siren.breakpoint()`** pauses execution and prints local variables:
+
+```python
+x = 42
+data = {"items": [1, 2, 3]}
+
+siren.breakpoint()  # Pauses and displays all locals
+# Press Ctrl+C to continue, or type 'd' to drop into pdb
+```
+
+---
+
+## Cleaning debug calls
+
+Run `siren-clean` in a project folder to remove all `siren(...)` calls and their import lines — comments and string literals are left untouched:
+
+```bash
+siren-clean
+```
+
+Before:
+
+```python
+from siren import siren
+siren(x)
+print("hello")
+siren(data)
+```
+
+After:
+
+```python
+print("hello")
+```
+
+---
+
+## Autoload (no per-file imports)
+
+By default you still need `from siren import siren` in every file that uses it. If you'd rather call `siren(x)` anywhere in a project without importing it each time, enable autoload once per environment (virtualenv, Docker image, CI job, etc.):
+
+```bash
+siren-autoload on
+siren-autoload status   # check whether it's enabled
+siren-autoload off      # disable again
+```
+
+This writes a `.pth` file into the current environment's `site-packages`, injecting `siren` into Python's builtins as soon as any interpreter starts in that environment — no import needed anywhere, including in Django apps, Flask views, scripts, or the shell. It's opt-in per environment, so it won't silently affect environments where you didn't run `on`.
+
+---
+
+## Framework examples
+
+<details>
+<summary>Django</summary>
+
+```python
+from django.http import JsonResponse
+from siren import siren
+
+def my_view(request):
+    user_data = request.GET.dict()
+    siren(user_data, label="REQUEST_PARAMS")
+
+    result = process_data(user_data)
+    siren(result)
+
+    return JsonResponse(result)
+```
+</details>
+
+<details>
+<summary>Flask</summary>
+
+```python
+from flask import Flask, request
+from siren import siren, trace
+
+app = Flask(__name__)
+
+@app.route("/api/users")
+def get_users():
+    query = request.args.get("q")
+    siren(query, label="SEARCH_QUERY")
+
+    users = search_users(query)
+    return {"users": users}
+
+@siren.trace
+def search_users(query):
+    # Function entry/exit will be logged automatically
+    return [{"id": 1, "name": "Alice"}]
+```
+</details>
+
+<details>
+<summary>FastAPI</summary>
+
+```python
+from fastapi import FastAPI
+from siren import siren, trace
+
+app = FastAPI()
+
+@app.get("/items/{item_id}")
+async def get_item(item_id: int, q: str = None):
+    siren({"item_id": item_id, "q": q}, label="QUERY_PARAMS")
+
+    item = await fetch_item(item_id)
+    return item
+
+@siren.trace(timeit=True)
+async def fetch_item(item_id: int):
+    # Execution time and arguments will be logged
+    return {"id": item_id, "name": "Item"}
+```
+</details>
+
+---
+
+## Why use Siren?
+
+Debug prints are easy to add, but hard to remove later. Siren gives you a fast debug workflow and a safe cleanup step so your temporary debug code does not stay in production.
+
+---
+
+## Project
+
+- Package name: `siren-debug`
+- Python versions: `2.7`, `3.6+`
+- License: MIT
+- PyPI: https://pypi.org/project/siren-debug/
+
+## License
+
+MIT

siren_debug-0.5.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+siren/__init__.py,sha256=vuXREwdjPxpco1D2AaStAeLrO4bD3YC5xenGpRcpPQ4,564
+siren/_output.py,sha256=Y36TtCSa7u0BEpVNPWBuK5aGm6JbbE5nRZC63ehGSK8,277
+siren/autoload.py,sha256=suDpdqJu1wNSnJpiwLFT2v8yD9CwY84XMwRz6h6B-5o,1801
+siren/clean.py,sha256=ki9wdutmkyOGF13Z_9L1P63UVjnlUZR0OJPkwbnSAdE,5003
+siren/core.py,sha256=EGwh4oWXN_vufnjvsPtvk1gdwwqrtEOY-V5pNo-sy4c,16706
+siren_debug-0.5.0.dist-info/METADATA,sha256=IaJFn-qbh2H05g6GBA-u7Ha_l_d_dbxpea1wlovVwi0,8025
+siren_debug-0.5.0.dist-info/WHEEL,sha256=4YBfCYNH4wlLpv3pzq1hbEuIlXA4WJabKLFurZ7eTL0,109
+siren_debug-0.5.0.dist-info/entry_points.txt,sha256=XOCO_18z7SHeGfIk3OnDpkeqftqrvoqVuyz0fmEnMCk,86
+siren_debug-0.5.0.dist-info/top_level.txt,sha256=VZWFA13ISiEdxbjPFWQnhSO2GH9ngjRjxTui7VTMXOE,6
+siren_debug-0.5.0.dist-info/RECORD,,

siren_debug-0.5.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

siren_debug-0.5.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+siren-autoload = siren.autoload:main
+siren-clean = siren.clean:main

siren_debug-0.5.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+siren