fix: Reimplemented IO and added examples

Author: tomlin7

.gitignore

@@ -0,0 +1,141 @@
+
+# Created by https://www.gitignore.io/api/vim,python
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+
+### Python Patch ###
+.venv/
+
+### Vim ###
+# Swap
+[._]*.s[a-v][a-z]
+[._]*.sw[a-p]
+[._]s[a-rt-v][a-z]
+[._]ss[a-gi-z]
+[._]sw[a-p]
+
+# Session
+Session.vim
+
+# Temporary
+.netrwhist
+*~
+# Auto-generated tag files
+tags
+# Persistent undo
+[._]*.un~
+
+
+# End of https://www.gitignore.io/api/vim,python
+
+
+# test stuff
+/cov.xml
+/go/
+/tests/langservers/
+
+.vscode

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tomlin7
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,106 @@
+# DAP Client: Debug Adapter Protocol Client for Python
+
+DAP Client is a generic client-side implementation of the [Debug Adapter Protocol (DAP)](https://microsoft.github.io/debug-adapter-protocol/) for Python. It provides a clean, strongly-typed API for interacting with debug adapters but is decoupled from the transport layer (IO), allowing integration into any framework (synchronous, asynchronous, GUI, etc.).
+
+For a comprehensive example of how to build a debugger UI with this client, see [sandbox.py](sandbox/sandbox.py) implementation.
+
+## Key Features
+
+- **Protocol-First**: Implements the DAP state machine and message parsing without forcing a specific IO model.
+- **Strongly Typed**: Uses Pydantic models for request arguments and event bodies.
+- **Easy Integration**: Can be used with `subprocess`, `socket`, `asyncio`, or any other transport mechanism.
+
+## Installation
+
+```bash
+pip install dap-python
+```
+
+If you are developing/contributing to the code, use `pip install -e .` instead. I also support using `poetry`.
+
+## Quick Start
+
+The `DAPClient` requires an IO handler to send and receive bytes from the debug adapter. The library acts as a translation layer:
+- You feed it raw bytes from the adapter -> It yields high-level `Event` objects.
+- You call methods like `client.launch()` -> It buffers raw bytes for you to send to the adapter.
+
+### Example: minimal synchronous runner
+
+This example assumes you have an IO handler similar to `sandbox/dap_io.py`.
+
+```python
+import time
+from dap.client import DAPClient
+from dap.events import InitializedEvent
+
+# Import your IO handler (see sandbox/dap_io.py for a reference implementation)
+from sandbox.dap_io import IO 
+
+# 1. Start the debug adapter (e.g., debugpy)
+adapter_cmd = "python -m debugpy.adapter"
+io = IO(adapter_cmd)
+io.start()
+
+# 2. Initialize the DAP Client
+client = DAPClient(
+    clientID="my-debugger",
+    clientName="My Custom Debugger",
+    locale="en-US",
+    pathFormat="path"
+)
+
+# 3. Send the Initialize Request
+# client.send() returns the raw bytes that need to be sent to the adapter
+io.write(client.send())
+
+# 4. Event Loop
+try:
+    while True:
+        # Read raw data from the adapter's stdout
+        data = io.read()
+        if data:
+            # Feed data to the client to parse events
+            events = client.recv(data)
+            
+            for event in events:
+                print(f"Received: {event}")
+                
+                if isinstance(event, InitializedEvent):
+                    print("Adapter Initialized!")
+                    # Once initialized, we can configure and launch
+                    client.launch(program="script.py", console="internalConsole")
+                    client.configuration_done()
+                    
+                    # Flush requests generated by the above calls
+                    io.write(client.send())
+
+        time.sleep(0.01)
+except KeyboardInterrupt:
+    io.stop()
+```
+
+## Architecture
+
+The library is designed around the `DAPClient` class in `dap.client`.
+
+### Data Flow
+
+```
+[ Debug Adapter ] <== bytes ==> [ IO Handler ] <== bytes ==> [ DAPClient ] <== Objects ==> [ Your Application ]
+```
+
+1. **Send**: You call `client.step_in(threadId=1)`. The client updates its internal state and queues the JSON-RPC message. You call `client.send()` to get the bytes and write them to your transport.
+2. **Receive**: You read bytes from your transport and call `client.recv(bytes)`. The client parses the buffer and yields `Event`, `Response`, or `Request` objects.
+
+## API Reference
+
+### `DAPClient`
+
+The main entry point. Common methods include:
+- `launch(...)` / `attach(...)`
+- `set_breakpoints(...)` / `configuration_done()`
+- `continue_execution(...)` / `step_in(...)` / `next(...)`
+- `stack_trace(...)` / `scopes(...)` / `variables(...)`
+- `disconnect()`
+
+See `dap/client.py` for the full list of supported methods and arguments.

dap/__init__.py

@@ -0,0 +1,10 @@
+"""Client library for managing Debug Adapter Protocol (DAP) requests & responses."""
+
+from dap.client import DAPClient, ClientState
+from dap.protocol import ProtocolMessage, Request, Response, Event, CancelRequest, CancelResponse
+from dap.events import *
+from dap.requests import *
+from dap.types import *
+
+
+__version__ = "1.0.0"