debug-dojo 0.3.2__tar.gz → 0.4.0__tar.gz

{debug_dojo-0.3.2 → debug_dojo-0.4.0}/.gitignore

@@ -205,3 +205,4 @@ __marimo__/
 # IDE specific files
 .idea/
 .vscode/
+.DS_Store

{debug_dojo-0.3.2 → debug_dojo-0.4.0}/HISTORY.md

@@ -1,38 +1,37 @@
-## v0.3.0 (2025-07-28)
+## v0.4.0 (2025-08-10)
 
-*release tag*: [v0.3.2]
+*release tag*: [v0.4.0]
+
+- New configuration model `DebugDojoConfig` for better structure.
+- Added support for `debugger` configuration in `dojo.toml`.
+- Updated `dojo` command to include debugger type in command call.
+- Configuration versioning allows for in-flight migration of old configurations.
+- Improved error handling in configuration loading.
+- Improved catching errors from target execution.
 
-### What's Changed
+## v0.3.2 (2025-07-28)
+
+*release tag*: [v0.3.2]
 
 - New logo for the project.
 - Typer used for CLI implementation.
 - Dojo is configured via `dojo.toml` or `pyproject.toml`.
 - Support for `debugpy` and `ipdb` for debugging.
-
-#### Fixes
-
 - Fixed documentation and history.
 
 ## v0.2.0 (2025-07-20)
 
 *release tag*: [v0.2.0]
 
-### What's Changed
-
 - Added `dojo` command for easy debugging setup.
 - Added `p()` function for rich printing.
 - Added history file for tracking changes.
 - Moved to `hatch` for building and packaging.
-
-#### Fixes
-
 - Fixed `pyproject.toml` to point to GitHub repository as the homepage.
 
 ## v0.1.0 (2025-07-19)
 
 *release tag*: [v0.1.0]
 
-### What's Changed
-
 - Initial module to install debugging tools.
 - Debug mode utilities for PuDB, rich tracebacks, and object inspection.

{debug_dojo-0.3.2 → debug_dojo-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: debug-dojo
-Version: 0.3.2
+Version: 0.4.0
 Summary: Debbugging dojo for Python developers
 Project-URL: Homepage, https://github.com/bwrob/debug-dojo
 Project-URL: Documentation, https://github.com/bwrob/debug-dojo/blob/main/README.md
@@ -48,7 +48,7 @@ It leverages [`rich`](https://github.com/Textualize/rich) for beautiful output a
 
 - **Convenient CLI** Quickly run your code with debugging tools enabled.
 - **Simple API:** Install all tools or only what you need.
-- **Debugger integration:** Quickly enable Debugpy, PuDB, PDB, or IPDB as your default debugger.
+- **Debugger integration:** Quickly enable Debugpy, PuDB, PDB, or IPDB as your default pre-configured debugger.
 - **Rich tracebacks:** Get readable, colorized tracebacks for easier debugging.
 - **Side-by-side object inspection:** Visually compare Python objects, their attributes, and methods in the terminal.
 - **Configuration:** Easily configure the debugging tools using `dojo.toml` or `pyproject.toml`.
@@ -63,10 +63,10 @@ Run your Python script with debugging tools enabled using the `debug-dojo` comma
 dojo my_script.py
 ```
 
-You can optionally set configuration file and verbose mode:
+You can optionally set configuration, verbose mode, and specify the debugger type. Both script files and modules are supported:
 
 ```console
-dojo --config dojo.toml --verbose my_script.py
+dojo --debugger ipdb --config dojo.toml --verbose --module my_module
 ```
 
 ### From the code
@@ -74,19 +74,18 @@ dojo --config dojo.toml --verbose my_script.py
 In the `PuDB` style, you can install all debugging tools and enter the debugging mode with a single command:
 
 ```python
-import debug_dojo.install; b()
-
 object_1 = {"foo": 1, "bar": 2}
 object_2 = [1, 2, 3]
 
+import debug_dojo.install; b()
 p(object_1)  # Pretty print an object with Rich
-i(object_1)  # Inspect an object
-c(object_1, object_2)  # Compare two objects side-by-side
 ```
 
-Where:
+### Features in debugging mode
 
-- `b()` is a builtin-injected function that sets a breakpoint using PuDB's `set_trace()`.
+The following functions are available in the debugging mode, injected into builtins:
+
+- `b()` is a hook that sets a breakpoint using the configured debugger.
 - `p(object_1)` is pretty printing of an object using Rich.
 - `i(object_1)` to inspect an object using Rich.
 - `c(object_1, object_2)` to compare two objects side-by-side.
@@ -98,12 +97,23 @@ You can configure the debugging tools using a `dojo.toml` or `pyproject.toml` fi
 **Example `dojo.toml`:**
 
 ```toml
-debugger = "ipdb"
+[debuggers]
+    default = "ipdb"
+
+    debugpy = { port = 1992 }
+    ipdb    = { context_lines = 20 }
+
+[exceptions]
+    locals_in_traceback = false
+    post_mortem         = true
+    rich_traceback      = true
 
 [features]
-  rich_inspect = true
-  rich_print = true
-  comparer = false
+    breakpoint   = "b"
+    # Empty string means disable the feature
+    comparer     = ""
+    rich_inspect = "i"
+    rich_print   = "p"
 ```
 
 ## Installation
@@ -133,46 +143,50 @@ Note that dojo most likely will not work when installed via `pipx` or `uvx`, as
 ```console
 ruff check src/debug_dojo --fix
 basedpyright src/debug_dojo
+
+poe code-quality
 ```
 
+### Tests
+
+TBA
 
 ## Changelog
 
-## v0.3.0 (2025-07-28)
+## v0.4.0 (2025-08-10)
 
-*release tag*: [v0.3.2]
+*release tag*: [v0.4.0]
 
-### What's Changed
+- New configuration model `DebugDojoConfig` for better structure.
+- Added support for `debugger` configuration in `dojo.toml`.
+- Updated `dojo` command to include debugger type in command call.
+- Configuration versioning allows for in-flight migration of old configurations.
+- Improved error handling in configuration loading.
+- Improved catching errors from target execution.
+
+## v0.3.2 (2025-07-28)
+
+*release tag*: [v0.3.2]
 
 - New logo for the project.
 - Typer used for CLI implementation.
 - Dojo is configured via `dojo.toml` or `pyproject.toml`.
 - Support for `debugpy` and `ipdb` for debugging.
-
-#### Fixes
-
 - Fixed documentation and history.
 
 ## v0.2.0 (2025-07-20)
 
 *release tag*: [v0.2.0]
 
-### What's Changed
-
 - Added `dojo` command for easy debugging setup.
 - Added `p()` function for rich printing.
 - Added history file for tracking changes.
 - Moved to `hatch` for building and packaging.
-
-#### Fixes
-
 - Fixed `pyproject.toml` to point to GitHub repository as the homepage.
 
 ## v0.1.0 (2025-07-19)
 
 *release tag*: [v0.1.0]
 
-### What's Changed
-
 - Initial module to install debugging tools.
 - Debug mode utilities for PuDB, rich tracebacks, and object inspection.

{debug_dojo-0.3.2 → debug_dojo-0.4.0}/README.md

@@ -16,7 +16,7 @@ It leverages [`rich`](https://github.com/Textualize/rich) for beautiful output a
 
 - **Convenient CLI** Quickly run your code with debugging tools enabled.
 - **Simple API:** Install all tools or only what you need.
-- **Debugger integration:** Quickly enable Debugpy, PuDB, PDB, or IPDB as your default debugger.
+- **Debugger integration:** Quickly enable Debugpy, PuDB, PDB, or IPDB as your default pre-configured debugger.
 - **Rich tracebacks:** Get readable, colorized tracebacks for easier debugging.
 - **Side-by-side object inspection:** Visually compare Python objects, their attributes, and methods in the terminal.
 - **Configuration:** Easily configure the debugging tools using `dojo.toml` or `pyproject.toml`.
@@ -31,10 +31,10 @@ Run your Python script with debugging tools enabled using the `debug-dojo` comma
 dojo my_script.py
 ```
 
-You can optionally set configuration file and verbose mode:
+You can optionally set configuration, verbose mode, and specify the debugger type. Both script files and modules are supported:
 
 ```console
-dojo --config dojo.toml --verbose my_script.py
+dojo --debugger ipdb --config dojo.toml --verbose --module my_module
 ```
 
 ### From the code
@@ -42,19 +42,18 @@ dojo --config dojo.toml --verbose my_script.py
 In the `PuDB` style, you can install all debugging tools and enter the debugging mode with a single command:
 
 ```python
-import debug_dojo.install; b()
-
 object_1 = {"foo": 1, "bar": 2}
 object_2 = [1, 2, 3]
 
+import debug_dojo.install; b()
 p(object_1)  # Pretty print an object with Rich
-i(object_1)  # Inspect an object
-c(object_1, object_2)  # Compare two objects side-by-side
 ```
 
-Where:
+### Features in debugging mode
 
-- `b()` is a builtin-injected function that sets a breakpoint using PuDB's `set_trace()`.
+The following functions are available in the debugging mode, injected into builtins:
+
+- `b()` is a hook that sets a breakpoint using the configured debugger.
 - `p(object_1)` is pretty printing of an object using Rich.
 - `i(object_1)` to inspect an object using Rich.
 - `c(object_1, object_2)` to compare two objects side-by-side.
@@ -66,12 +65,23 @@ You can configure the debugging tools using a `dojo.toml` or `pyproject.toml` fi
 **Example `dojo.toml`:**
 
 ```toml
-debugger = "ipdb"
+[debuggers]
+    default = "ipdb"
+
+    debugpy = { port = 1992 }
+    ipdb    = { context_lines = 20 }
+
+[exceptions]
+    locals_in_traceback = false
+    post_mortem         = true
+    rich_traceback      = true
 
 [features]
-  rich_inspect = true
-  rich_print = true
-  comparer = false
+    breakpoint   = "b"
+    # Empty string means disable the feature
+    comparer     = ""
+    rich_inspect = "i"
+    rich_print   = "p"
 ```
 
 ## Installation
@@ -101,4 +111,10 @@ Note that dojo most likely will not work when installed via `pipx` or `uvx`, as
 ```console
 ruff check src/debug_dojo --fix
 basedpyright src/debug_dojo
+
+poe code-quality
 ```
+
+### Tests
+
+TBA

{debug_dojo-0.3.2 → debug_dojo-0.4.0}/pyproject.toml

@@ -13,7 +13,7 @@
         "rich>=12.0.0",
         "tomlkit>=0.13.3",
         "typer>=0.15.0",
-]
+    ]
     license = 'MIT'
     license-files = ['LICENSE']
     keywords = [
@@ -36,7 +36,7 @@
         "Topic :: Software Development :: Debuggers",
         "Topic :: Software Development :: Libraries :: Python Modules",
     ]
-version = "0.3.2"
+    version = "0.4.0"
     dynamic = ['readme']
 
     [project.urls]
@@ -46,8 +46,6 @@ version = "0.3.2"
         Changelog     = "https://github.com/bwrob/debug-dojo/blob/main/HISTORY.md"
 
     [project.scripts]
-        # This defines your command-line script!
-        # It points to the 'main' function in your 'cli' module.
         "dojo" = "debug_dojo._cli:main"
 
 [dependency-groups]
@@ -56,7 +54,7 @@ version = "0.3.2"
         "jupyter>=1.1.1",
         "poethepoet>=0.36.0",
         "ruff>=0.12.4",
-]
+    ]
 
 [build-system]
     requires = [
@@ -86,22 +84,19 @@ version = "0.3.2"
     ]
 
 [tool.basedpyright]
-    typeCheckingMode = "all"
+    typeCheckingMode = "basic"
     pythonVersion    = "3.10"
     strict           = ["src/debug_dojo/*"]
     ignore           = ["examples"]
 
 [tool.poe.tasks]
-    # Define your tasks here
     lint = "ruff check --fix src"
     format = "ruff format src"
-    type-check = "basedpyright"
+    type-check = "basedpyright --project pyproject.toml src/debug_dojo"
     code-quality = ["format", "lint", "type-check"]
     publish = [
-        "format",
-        "lint",
-        "type-check",
-        {cmd="rm -rf dist"},
-        {cmd="uv build"},
-        {cmd="uv publish"},
+        "code-quality",
+        { cmd = "rm -rf dist" },
+        { cmd = "uv build" },
+        { cmd = "uv publish" },
     ]

{debug_dojo-0.3.2 → debug_dojo-0.4.0}/src/debug_dojo/_cli.py

@@ -2,7 +2,6 @@
 
 from __future__ import annotations
 
-import os
 import runpy
 import sys
 from bdb import BdbQuit
@@ -10,10 +9,9 @@ from pathlib import Path
 from typing import Annotated
 
 import typer
-from pydantic import ValidationError
 from rich import print as rich_print
 
-from ._config import DebugDojoConfig, load_config
+from ._config import DebugDojoConfig, DebuggerType, load_config
 from ._installers import install_by_config
 
 cli = typer.Typer(
@@ -23,11 +21,13 @@ cli = typer.Typer(
 )
 
 
-def execute_with_debug(
+def execute_with_debug(  # noqa: C901
     target_name: str,
     target_args: list[str],
     *,
+    target_is_module: bool,
     verbose: bool,
+    config: DebugDojoConfig,
 ) -> None:
     """Execute a target script or module with installation of debugging tools."""
     sys.argv = [target_name, *target_args]
@@ -36,21 +36,37 @@ def execute_with_debug(
         rich_print(f"[blue]Installing debugging tools for {target_name}.[/blue]")
         rich_print(f"[blue]Arguments for target: {target_args}[/blue]")
 
-    config = load_config()
     install_by_config(config)
 
-    if (
-        Path(target_name).exists()
-        or target_name.endswith(".py")
-        or os.sep in target_name
-    ):
+    if target_is_module:
+        runner = runpy.run_module
+    else:
         if not Path(target_name).exists():
             sys.exit(1)
         runner = runpy.run_path
-    else:
-        runner = runpy.run_module
 
-    _ = runner(target_name, run_name="__main__")
+    try:
+        _ = runner(target_name, run_name="__main__")
+    except ImportError as e:
+        rich_print(f"[red]Error importing {target_name}:[/red]\n{e}")
+        sys.exit(1)
+    except BdbQuit:
+        rich_print("[red]Debugging session terminated by user.[/red]")
+        sys.exit(0)
+    except KeyboardInterrupt:
+        rich_print("[red]Execution interrupted by user.[/red]")
+        sys.exit(0)
+    except SystemExit as e:
+        if e.code:
+            rich_print(f"[red]Script exited with code {e.code}.[/red]")
+    except Exception as e:  # noqa: BLE001
+        rich_print(f"[red]Error while running {target_name}:[/red]\n{e}")
+        if config.exceptions.post_mortem:
+            import pdb  # noqa: PLC0415, T100
+
+            rich_print("[blue]Entering post-mortem debugging session...[/blue]")
+            pdb.post_mortem(e.__traceback__)
+        sys.exit(1)
 
 
 def display_config(config: DebugDojoConfig) -> None:
@@ -64,36 +80,42 @@ def display_config(config: DebugDojoConfig) -> None:
     no_args_is_help=True,
     context_settings={"allow_extra_args": True, "ignore_unknown_options": True},
 )
-def run_debug(
+def run_debug(  # noqa: PLR0913
     ctx: typer.Context,
     target_name: Annotated[
         str | None, typer.Argument(help="The target script or module to debug.")
     ] = None,
+    *,
     config_path: Annotated[
         Path | None, typer.Option("--config", "-c", help="Show configuration")
     ] = None,
-    *,
+    debugger: Annotated[
+        DebuggerType | None,
+        typer.Option("--debugger", "-d", help="Specify the debugger to use"),
+    ] = None,
     verbose: Annotated[
         bool,
         typer.Option("--verbose", "-v", is_flag=True, help="Enable verbose output"),
     ] = False,
+    module: Annotated[
+        bool,
+        typer.Option("--module", "-m", is_flag=True, help="Run as a module"),
+    ] = False,
 ) -> None:
     """Run the command-line interface."""
-    try:
-        config = load_config(config_path, verbose=verbose)
-    except ValidationError as e:
-        rich_print(f"[red]Configuration error:\n{e}[/red]")
-        sys.exit(1)
+    config = load_config(config_path, verbose=verbose, debugger=debugger)
 
     if verbose:
         display_config(config)
 
     if target_name:
-        try:
-            execute_with_debug(target_name, ctx.args, verbose=verbose)
-        except BdbQuit:
-            rich_print("[red]Debugging session terminated by user.[/red]")
-            sys.exit(0)
+        execute_with_debug(
+            target_name=target_name,
+            target_is_module=module,
+            target_args=ctx.args,
+            verbose=verbose,
+            config=config,
+        )
 
 
 def main() -> None:

debug_dojo-0.4.0/src/debug_dojo/_config.py

@@ -0,0 +1,136 @@
+"""Debug Dojo configuration module.
+
+It includes configurations for different debuggers, exception handling,
+and features that can be enabled or disabled.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any, cast
+
+from pydantic import ValidationError
+from rich import print as rich_print
+from tomlkit import parse
+from tomlkit.exceptions import TOMLKitError
+
+from ._config_models import (
+    DebugDojoConfig,
+    DebugDojoConfigV1,
+    DebugDojoConfigV2,
+    DebuggerType,
+)
+
+
+def __filter_pydantic_error_msg(error: ValidationError) -> str:
+    """Filter out specific lines from a Pydantic validation error."""
+    return "\n".join(
+        line
+        for line in str(error).splitlines()
+        if not line.startswith("For further information visit")
+    )
+
+
+def resolve_config_path(config_path: Path | None) -> Path | None:
+    """Resolve the configuration path, returning a default if none is provided."""
+    if config_path:
+        if not config_path.exists():
+            msg = f"Configuration file not found:\n{config_path.resolve()}"
+            raise FileNotFoundError(msg)
+        return config_path.resolve()
+
+    # Default configuration path
+    for path in (Path("dojo.toml"), Path("pyproject.toml")):
+        if path.exists():
+            return path.resolve()
+    return None
+
+
+def load_raw_config(
+    config_path: Path,
+) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
+    """Load the Debug Dojo configuration from a file.
+
+    Currently supports 'dojo.toml' or 'pyproject.toml'.
+    If no path is provided, it checks the current directory for these files.
+    """
+    config_str = config_path.read_text(encoding="utf-8")
+
+    try:
+        config_data = parse(config_str).unwrap()
+    except TOMLKitError as e:
+        msg = f"Error parsing configuration file {config_path.resolve()}."
+        raise ValueError(msg) from e
+
+    # If config is in [tool.debug_dojo] (pyproject.toml), extract it.
+    if config_path.name == "pyproject.toml":
+        try:
+            dojo_config = cast("dict[str, Any]", config_data["tool"]["debug_dojo"])
+        except KeyError:
+            return {}
+        else:
+            return dojo_config
+
+    return config_data
+
+
+def load_config(  # noqa: C901
+    config_path: Path | None = None,
+    *,
+    verbose: bool = False,
+    debugger: DebuggerType | None = None,
+) -> DebugDojoConfig:
+    """Load the Debug Dojo configuration and return a DebugDojoConfig instance."""
+    resolved_path = resolve_config_path(config_path)
+
+    if verbose:
+        if resolved_path:
+            msg = f"Using configuration file: {resolved_path}."
+        else:
+            msg = "No configuration file found, using default settings."
+        rich_print(f"[blue]{msg}[/blue]")
+
+    if not resolved_path:
+        return DebugDojoConfig()
+
+    raw_config = load_raw_config(resolved_path)
+
+    config = None
+    for model in (DebugDojoConfigV2, DebugDojoConfigV1):
+        model_name = model.__name__
+        try:
+            config = model.model_validate(raw_config)
+        except ValidationError as e:
+            if verbose:
+                msg = (
+                    f"[yellow]Configuration validation error for {model_name}:\n"
+                    f"{__filter_pydantic_error_msg(e)}\n\n"
+                    f"Please check your configuration file {resolved_path}.[/yellow]"
+                )
+                rich_print(msg)
+        else:
+            if verbose or model_name != DebugDojoConfig.__name__:
+                msg = (
+                    f"[blue]Using configuration model: {model_name}.\n"
+                    f"Current configuration model {DebugDojoConfig.__name__}. [/blue]"
+                )
+                rich_print(msg)
+            break
+
+    if not config:
+        msg = (
+            f"[red]Unsupported configuration version in {resolved_path.resolve()}.\n"
+            "Please update your configuration file.[/red]"
+        )
+        rich_print(msg)
+        sys.exit(1)
+
+    while not isinstance(config, DebugDojoConfig):
+        config = config.update()
+
+    # If a debugger is specified, update the config.
+    if debugger:
+        config.debuggers.default = debugger
+
+    return config

debug_dojo-0.4.0/src/debug_dojo/_config_models.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import BaseModel, ConfigDict
+
+
+class BaseConfig(BaseModel):
+    """Base configuration class with extra fields forbidden."""
+
+    model_config = ConfigDict(extra="forbid", validate_assignment=True)
+
+
+class DebuggerType(Enum):
+    """Enum for different types of debuggers."""
+
+    PDB = "pdb"
+    PUDB = "pudb"
+    IPDB = "ipdb"
+    DEBUGPY = "debugpy"
+
+
+class Features(BaseModel):
+    """Configuration for installing debug features."""
+
+    model_config = ConfigDict(extra="forbid")  # pyright: ignore[reportUnannotatedClassAttribute]
+
+    rich_inspect: bool = True
+    """Install rich inspect as 'i' for enhanced object inspection."""
+    rich_print: bool = True
+    """Install rich print as 'p' for enhanced printing."""
+    rich_traceback: bool = True
+    """Install rich traceback for better error reporting."""
+    comparer: bool = True
+    """Install comparer as 'c' for side-by-side object comparison."""
+    breakpoint: bool = True
+    """Install breakpoint as 'b' for setting breakpoints in code."""
+
+
+class DebugpyConfig(BaseConfig):
+    """Configuration for debugpy debugger."""
+
+    port: int = 1992
+    """Port for debugpy debugger."""
+    host: str = "localhost"
+    """Host for debugpy debugger."""
+    wait_for_client: bool = True
+    """Whether to wait for the client to connect before starting debugging."""
+    log_to_file: bool = False
+    """Whether to log debugpy output to a file."""
+
+
+class IpdbConfig(BaseConfig):
+    """Configuration for ipdb debugger."""
+
+    context_lines: int = 20
+    """Number of context lines to show in ipdb."""
+
+
+class DebuggersConfig(BaseConfig):
+    """Configuration for debuggers."""
+
+    default: DebuggerType = DebuggerType.IPDB
+    """Default debugger to use."""
+    prompt_name: str = "debug-dojo> "
+    """Prompt name for the debugger, used in the REPL."""
+    debugpy: DebugpyConfig = DebugpyConfig()
+    """Configuration for debugpy debugger."""
+    ipdb: IpdbConfig = IpdbConfig()
+    """Configuration for ipdb debugger."""
+
+
+class ExceptionsConfig(BaseConfig):
+    """Configuration for exceptions handling."""
+
+    rich_traceback: bool = True
+    """Enable rich traceback for better error reporting."""
+    locals_in_traceback: bool = False
+    """Include local variables in traceback."""
+    post_mortem: bool = True
+    """Enable post-mortem debugging after an exception."""
+
+
+class FeaturesConfig(BaseConfig):
+    """Configuration for installing debug features."""
+
+    rich_inspect: str = "i"
+    """Install rich inspect as 'i' for enhanced object inspection."""
+    rich_print: str = "p"
+    """Install rich print as 'p' for enhanced printing."""
+    comparer: str = "c"
+    """Install comparer as 'c' for side-by-side object comparison."""
+    breakpoint: str = "b"
+    """Install breakpoint as 'b' for setting breakpoints in code."""
+
+
+class DebugDojoConfigV1(BaseModel):
+    """Configuration for Debug Dojo."""
+
+    model_config = ConfigDict(extra="forbid")  # pyright: ignore[reportUnannotatedClassAttribute]
+
+    debugger: DebuggerType = DebuggerType.PUDB
+    """The type of debugger to use."""
+    features: Features = Features()
+    """Features to install for debugging."""
+
+    def update(self) -> DebugDojoConfigV2:
+        """Update the configuration to the latest version."""
+        v2_exceptions = ExceptionsConfig(
+            rich_traceback=self.features.rich_traceback,
+        )
+        v2_debuggers = DebuggersConfig(default=self.debugger)
+        v2_features = FeaturesConfig(
+            rich_inspect="i" if self.features.rich_inspect else "",
+            rich_print="p" if self.features.rich_print else "",
+            comparer="c" if self.features.comparer else "",
+            breakpoint="b" if self.features.breakpoint else "",
+        )
+        return DebugDojoConfigV2(
+            exceptions=v2_exceptions,
+            debuggers=v2_debuggers,
+            features=v2_features,
+        )
+
+
+class DebugDojoConfigV2(BaseModel):
+    """Configuration for Debug Dojo."""
+
+    model_config = ConfigDict(extra="forbid")  # pyright: ignore[reportUnannotatedClassAttribute]
+
+    exceptions: ExceptionsConfig = ExceptionsConfig()
+    debuggers: DebuggersConfig = DebuggersConfig()
+    """Default debugger and configs."""
+    features: FeaturesConfig = FeaturesConfig()
+    """Features mnemonics ."""
+
+
+DebugDojoConfig = DebugDojoConfigV2

{debug_dojo-0.3.2 → debug_dojo-0.4.0}/src/debug_dojo/_installers.py

@@ -14,7 +14,13 @@ import sys
 from rich import print as rich_print
 
 from ._compareres import inspect_objects_side_by_side
-from ._config import DebugDojoConfig, DebuggerType, Features
+from ._config_models import (
+    DebugDojoConfig,
+    DebuggersConfig,
+    DebuggerType,
+    ExceptionsConfig,
+    FeaturesConfig,
+)
 
 BREAKPOINT_ENV_VAR = "PYTHONBREAKPOINT"
 
@@ -69,11 +75,11 @@ def _use_debugpy() -> None:
     debugpy.wait_for_client()
 
 
-def _rich_traceback() -> None:
+def _rich_traceback(*, locals_in_traceback: bool) -> None:
     """Check if Rich Traceback is available and set it as the default."""
     from rich import traceback
 
-    _ = traceback.install(show_locals=True)
+    _ = traceback.install(show_locals=locals_in_traceback)
 
 
 def _inspect() -> None:
@@ -106,33 +112,42 @@ def _rich_print() -> None:
     builtins.p = rich_print  # pyright: ignore[reportAttributeAccessIssue]
 
 
-def _install_features(features: Features) -> None:
+def _install_features(features: FeaturesConfig) -> None:
     """Install the specified debugging features."""
     if features.rich_inspect:
         _inspect()
     if features.rich_print:
         _rich_print()
-    if features.rich_traceback:
-        _rich_traceback()
     if features.comparer:
         _compare()
     if features.breakpoint:
         _breakpoint()
 
 
-def _set_debugger(debugger: DebuggerType) -> None:  # noqa: RET503
+def _set_debugger(debugger_config: DebuggersConfig) -> None:
     """Set the debugger based on the configuration."""
+    debugger = debugger_config.default
+
     if debugger == DebuggerType.PDB:
-        return _use_pdb()
+        _use_pdb()
     if debugger == DebuggerType.PUDB:
-        return _use_pudb()
+        _use_pudb()
     if debugger == DebuggerType.IPDB:
-        return _use_ipdb()
+        _use_ipdb()
     if debugger == DebuggerType.DEBUGPY:
-        return _use_debugpy()
+        _use_debugpy()
+
+    sys.ps1 = debugger_config.prompt_name
+
+
+def _set_exceptions(exceptions: ExceptionsConfig) -> None:
+    """Set the exception handling based on the configuration."""
+    if exceptions.rich_traceback:
+        _rich_traceback(locals_in_traceback=exceptions.locals_in_traceback)
 
 
 def install_by_config(config: DebugDojoConfig) -> None:
     """Install debugging tools."""
-    _set_debugger(config.debugger)
+    _set_debugger(config.debuggers)
+    _set_exceptions(config.exceptions)
     _install_features(config.features)

debug_dojo-0.3.2/src/debug_dojo/_config.py

@@ -1,117 +0,0 @@
-from __future__ import annotations
-
-from enum import Enum
-from pathlib import Path
-from typing import Any, cast
-
-import tomlkit
-from pydantic import BaseModel, ConfigDict
-from rich import print as rich_print
-
-
-class DebuggerType(Enum):
-    """Enum for different types of debuggers."""
-
-    PDB = "pdb"
-    PUDB = "pudb"
-    IPDB = "ipdb"
-    DEBUGPY = "debugpy"
-
-
-class Features(BaseModel):
-    """Configuration for installing debug features."""
-
-    model_config = ConfigDict(extra="forbid")  # pyright: ignore[reportUnannotatedClassAttribute]
-
-    rich_inspect: bool = True
-    """Install rich inspect as 'i' for enhanced object inspection."""
-    rich_print: bool = True
-    """Install rich print as 'p' for enhanced printing."""
-    rich_traceback: bool = True
-    """Install rich traceback for better error reporting."""
-    comparer: bool = True
-    """Install comparer as 'c' for side-by-side object comparison."""
-    breakpoint: bool = True
-    """Install breakpoint as 'b' for setting breakpoints in code."""
-
-
-class DebugDojoConfig(BaseModel):
-    """Configuration for Debug Dojo."""
-
-    model_config = ConfigDict(extra="forbid")  # pyright: ignore[reportUnannotatedClassAttribute]
-
-    debugger: DebuggerType = DebuggerType.PUDB
-    """The type of debugger to use."""
-    features: Features = Features()
-    """Features to install for debugging."""
-
-
-def resolve_config_path(config_path: Path | None) -> Path | None:
-    """Resolve the configuration path, returning a default if none is provided."""
-    if config_path:
-        if not config_path.exists():
-            msg = f"Configuration file not found:\n{config_path.resolve()}"
-            raise FileNotFoundError(msg)
-        return config_path
-
-    # Default configuration path
-    for path in (Path("dojo.toml"), Path("pyproject.toml")):
-        if path.exists():
-            return path
-    return None
-
-
-def load_raw_config(
-    config_path: Path,
-) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny]
-    """Load the Debug Dojo configuration from a file.
-
-    Currently supports 'dojo.toml' or 'pyproject.toml'.
-    If no path is provided, it checks the current directory for these files.
-    """
-    with config_path.open("rb") as f:
-        config_data = tomlkit.load(f).unwrap()
-
-    # If config is in [tool.debug_dojo] (pyproject.toml), extract it.
-    if config_path.name == "dojo.toml":
-        return config_data
-
-    if config_path.name == "pyproject.toml":
-        try:
-            dojo_config = cast(
-                "dict[str, Any]",  # pyright: ignore[reportExplicitAny]
-                config_data["tool"]["debug_dojo"],
-            )
-        except KeyError:
-            return {}
-        else:
-            return dojo_config
-
-    # If the file is not recognized, raise an error.
-    msg = (
-        f"Unsupported configuration file: \n{config_path.resolve()}\n"
-        "Expected 'dojo.toml' or 'pyproject.toml'."
-    )
-    raise ValueError(msg)
-
-
-def load_config(
-    config_path: Path | None = None,
-    *,
-    verbose: bool = False,
-) -> DebugDojoConfig:
-    """Load the Debug Dojo configuration and return a DebugDojoConfig instance."""
-    resolved_path = resolve_config_path(config_path)
-
-    if verbose:
-        if resolved_path:
-            msg = f"Using configuration file: {resolved_path.resolve()}."
-        else:
-            msg = "No configuration file found, using default settings."
-        rich_print(f"[blue]{msg}[/blue]")
-
-    if not resolved_path:
-        return DebugDojoConfig()
-
-    raw_config = load_raw_config(resolved_path)
-    return DebugDojoConfig.model_validate(raw_config)