steplot 0.1.0__py3-none-any.whl

steplot/__init__.py

@@ -0,0 +1,20 @@
+"""steplot — lightweight agent step tracker with decorator and logging support."""
+
+from .display import display_run
+from .storage import load_run, save_run
+from .tracker import get_current_run, get_current_step, log_event, reset, run_context, step_context, track
+
+__all__ = [
+    "track",
+    "run_context",
+    "step_context",
+    "log_event",
+    "get_current_run",
+    "get_current_step",
+    "reset",
+    "display_run",
+    "save_run",
+    "load_run",
+]
+
+__version__ = "0.1.0"

steplot/display.py

@@ -0,0 +1,71 @@
+"""Terminal display for steplot runs — renders the run tree to stdout."""
+
+from __future__ import annotations
+
+from .models import Event, Run, Step, StepStatus
+
+
+def _status_annotation(step: Step) -> str:
+    """Return a short status suffix for a step when it isn't a clean success."""
+    if step.status == StepStatus.FAILED:
+        return "  ✗"
+    if step.status == StepStatus.RUNNING:
+        return "  ..."
+    return ""
+
+
+def _format_duration(seconds: float | None) -> str:
+    return f"[{seconds:.2f}s]" if seconds is not None else ""
+
+
+def _render_step(step: Step, prefix: str, is_last: bool, lines: list[str]) -> None:
+    """Recursively append a step and its events/children to ``lines``."""
+    branch = "└─ " if is_last else "├─ "
+    line = f"{prefix}{branch}{step.name}  {_format_duration(step.duration)}{_status_annotation(step)}"
+    lines.append(line)
+
+    # Continuation prefix for events and children beneath this branch.
+    child_prefix = prefix + ("   " if is_last else "│  ")
+
+    for event in step.events:
+        _render_event(event, child_prefix, lines)
+
+    for i, child in enumerate(step.children):
+        _render_step(child, child_prefix, i == len(step.children) - 1, lines)
+
+    if step.error:
+        lines.append(f"{child_prefix}  error: {step.error}")
+
+
+def _render_event(event: Event, prefix: str, lines: list[str]) -> None:
+    lines.append(f"{prefix}  • {event.message}")
+
+
+def display_run(run: Run) -> None:
+    """Pretty-print a Run tree to stdout.
+
+    Renders the run name, total duration, and each step (including nested
+    children and structured events) as a boxed tree.
+    """
+    title = f"Run: {run.name}"
+    duration = _format_duration(run.duration)
+    if duration:
+        title += f"  {duration}"
+
+    lines: list[str] = []
+
+    for i, step in enumerate(run.steps):
+        _render_step(step, "  ", i == len(run.steps) - 1, lines)
+
+    for event in run.events:
+        lines.append(f"  • {event.message}")
+
+    top = f"╔══ {title} ═══"
+    width = max([len(line) for line in lines] + [len(top) - 2])
+    bottom = "╚" + "═" * width + "╝"
+
+    print(top)
+    print("║")
+    for line in lines:
+        print(f"║{line}")
+    print(bottom)

steplot/models.py

@@ -0,0 +1,213 @@
+"""Data models for steplot — Event, Step, Run, and supporting types."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any
+from uuid import uuid4
+
+
+class StepStatus(Enum):
+    """Lifecycle status of a Step."""
+
+    RUNNING = "running"
+    SUCCESS = "success"
+    FAILED = "failed"
+
+    def __str__(self) -> str:
+        return self.value
+
+
+@dataclass
+class Event:
+    """A structured event emitted into a Step or Run.
+
+    Attributes:
+        level: Logging level (see Python's ``logging`` module).
+        message: Human-readable message for the event.
+        data: Arbitrary structured key/value payload attached to the event.
+        timestamp: Wall-clock time the event was emitted.
+        id: Stable identifier for the event.
+    """
+
+    level: int
+    message: str
+    data: dict[str, Any] = field(default_factory=dict)
+    timestamp: datetime = field(default_factory=datetime.now)
+    id: str = field(default_factory=lambda: uuid4().hex)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "level": self.level,
+            "message": self.message,
+            "data": self.data,
+            "timestamp": self.timestamp.isoformat() if self.timestamp else None,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Event:
+        return cls(
+            id=data.get("id", uuid4().hex),
+            level=data.get("level", 20),
+            message=data["message"],
+            data=data.get("data", {}),
+            timestamp=datetime.fromisoformat(data["timestamp"]) if data.get("timestamp") else datetime.now(),
+        )
+
+
+@dataclass
+class Step:
+    """A named, timed unit of work within a Run.
+
+    Steps form a tree: each step may contain nested ``children`` steps as well as
+    structured ``events``.
+
+    Attributes:
+        name: Human-readable step name (often the function name).
+        status: Current lifecycle status.
+        input: Optional input value passed to the step.
+        output: Optional output value produced by the step.
+        error: Error message if the step failed.
+        started_at: Wall-clock time the step started.
+        ended_at: Wall-clock time the step finished (None while running).
+        children: Nested child steps.
+        events: Structured events emitted while the step ran.
+    """
+
+    name: str
+    status: StepStatus = StepStatus.RUNNING
+    input: Any = None
+    output: Any = None
+    error: str | None = None
+    started_at: datetime = field(default_factory=datetime.now)
+    ended_at: datetime | None = None
+    id: str = field(default_factory=lambda: uuid4().hex)
+    children: list[Step] = field(default_factory=list)
+    events: list[Event] = field(default_factory=list)
+
+    @property
+    def duration(self) -> float | None:
+        """Duration in seconds, or None while still running."""
+        if self.ended_at is None:
+            return None
+        return (self.ended_at - self.started_at).total_seconds()
+
+    def finish(self, status: StepStatus | None = None, **kwargs: Any) -> None:
+        """Mark the step as finished with the given status and optional fields."""
+        if self.ended_at is None:
+            self.ended_at = datetime.now()
+        if status is not None:
+            self.status = status
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+    def succeed(self, output: Any = None) -> None:
+        self.finish(status=StepStatus.SUCCESS, output=output)
+
+    def fail(self, error: str) -> None:
+        self.finish(status=StepStatus.FAILED, error=error)
+
+    def add_child(self, name: str, **kwargs: Any) -> Step:
+        """Create and register a nested child step."""
+        child = Step(name=name, **kwargs)
+        self.children.append(child)
+        return child
+
+    def add_event(self, level: int, message: str, **data: Any) -> Event:
+        """Record a structured event on this step."""
+        event = Event(level=level, message=message, data=data)
+        self.events.append(event)
+        return event
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "status": self.status.value,
+            "input": self.input,
+            "output": self.output,
+            "error": self.error,
+            "started_at": self.started_at.isoformat() if self.started_at else None,
+            "ended_at": self.ended_at.isoformat() if self.ended_at else None,
+            "children": [c.to_dict() for c in self.children],
+            "events": [e.to_dict() for e in self.events],
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Step:
+        return cls(
+            id=data.get("id", uuid4().hex),
+            name=data["name"],
+            status=StepStatus(data.get("status", StepStatus.RUNNING.value)),
+            input=data.get("input"),
+            output=data.get("output"),
+            error=data.get("error"),
+            started_at=datetime.fromisoformat(data["started_at"])
+            if data.get("started_at")
+            else datetime.now(),
+            ended_at=datetime.fromisoformat(data["ended_at"]) if data.get("ended_at") else None,
+            children=[Step.from_dict(c) for c in data.get("children", [])],
+            events=[Event.from_dict(e) for e in data.get("events", [])],
+        )
+
+
+@dataclass
+class Run:
+    """Top-level container for a tracked execution."""
+
+    id: str = field(default_factory=lambda: uuid4().hex)
+    name: str = "run"
+    started_at: datetime = field(default_factory=datetime.now)
+    ended_at: datetime | None = None
+    steps: list[Step] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+    events: list[Event] = field(default_factory=list)
+
+    @property
+    def duration(self) -> float | None:
+        if self.ended_at is None:
+            return None
+        return (self.ended_at - self.started_at).total_seconds()
+
+    def add_step(self, name: str, **kwargs: Any) -> Step:
+        step = Step(name=name, **kwargs)
+        self.steps.append(step)
+        return step
+
+    def add_event(self, level: int, message: str, **data: Any) -> Event:
+        """Record a run-level structured event (not attached to any step)."""
+        event = Event(level=level, message=message, data=data)
+        self.events.append(event)
+        return event
+
+    def finish(self) -> None:
+        if self.ended_at is None:
+            self.ended_at = datetime.now()
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "name": self.name,
+            "started_at": self.started_at.isoformat() if self.started_at else None,
+            "ended_at": self.ended_at.isoformat() if self.ended_at else None,
+            "steps": [s.to_dict() for s in self.steps],
+            "metadata": self.metadata,
+            "events": [e.to_dict() for e in self.events],
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Run:
+        return cls(
+            id=data.get("id", uuid4().hex),
+            name=data.get("name", "run"),
+            started_at=datetime.fromisoformat(data["started_at"])
+            if data.get("started_at")
+            else datetime.now(),
+            ended_at=datetime.fromisoformat(data["ended_at"]) if data.get("ended_at") else None,
+            steps=[Step.from_dict(s) for s in data.get("steps", [])],
+            metadata=data.get("metadata", {}),
+            events=[Event.from_dict(e) for e in data.get("events", [])],
+        )

steplot/storage.py

@@ -0,0 +1,51 @@
+"""Storage for steplot runs — JSON-based."""
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+from .models import Run, StepStatus
+
+
+def _serialize(obj):
+    """JSON default serializer for values not natively JSON-serializable."""
+    if isinstance(obj, datetime):
+        return obj.isoformat()
+    if isinstance(obj, StepStatus):
+        return obj.value
+    return str(obj)
+
+
+def save_run(run: Run, path: str = ".steplot") -> str:
+    """Save a Run to a JSON file.
+
+    The target is interpreted as a file path when it has a file suffix (for
+    example ``runs/run-1.json``), and as a directory otherwise. In the
+    directory case the file is written as ``{run.id}.json`` inside it. Parent
+    directories are created as needed.
+
+    Args:
+        run: The Run to persist.
+        path: Destination file path (with suffix) or directory.
+
+    Returns:
+        The absolute path of the file that was written.
+    """
+    target = Path(path)
+    if target.suffix:
+        # Treat as an explicit file path (e.g. "runs/run-1.json").
+        target.parent.mkdir(parents=True, exist_ok=True)
+        file = target
+    else:
+        # Treat as a directory; write {run.id}.json inside it.
+        target.mkdir(parents=True, exist_ok=True)
+        file = target / f"{run.id}.json"
+
+    file.write_text(json.dumps(run.to_dict(), default=_serialize, indent=2))
+    return str(file)
+
+
+def load_run(path: str) -> Run:
+    """Load a Run from a JSON file path."""
+    data = json.loads(Path(path).read_text())
+    return Run.from_dict(data)

steplot/tracker.py

@@ -0,0 +1,268 @@
+"""Core tracking logic — @track, run_context/step_context, and log_event."""
+
+from __future__ import annotations
+
+import functools
+import inspect
+import logging
+from collections.abc import Callable, Iterator
+from contextlib import contextmanager
+from contextvars import ContextVar
+from datetime import datetime
+from typing import Any
+
+from steplot.models import Event, Run, Step, StepStatus
+
+# Module-level current run and current step, stored in ContextVars for async-safety
+_current_run: ContextVar[Run | None] = ContextVar("current_run", default=None)
+_current_step: ContextVar[Step | None] = ContextVar("current_step", default=None)
+
+# Logger integration
+_logger = logging.getLogger("steplot")
+
+
+def get_current_run() -> Run | None:
+    """Return the active Run, or None if no run is active."""
+    return _current_run.get()
+
+
+def get_current_step() -> Step | None:
+    """Return the active Step, or None if no step context is active."""
+    return _current_step.get()
+
+
+def reset() -> None:
+    """Reset the global tracking state (useful between tests or runs)."""
+    _current_run.set(None)
+    _current_step.set(None)
+
+
+@contextmanager
+def run_context(name: str = "run", **metadata: Any) -> Iterator[Run]:
+    """Context manager that creates and finishes a Run.
+
+    The run is exposed via the ``run`` returned by the context; it is also made
+    the current run so that ``@track`` and ``log_event`` calls inside the block
+    are recorded on it.
+
+    Args:
+        name: Human-readable name for the run.
+        **metadata: Arbitrary key/value metadata attached to the run.
+
+    Example:
+        with run_context("my-agent", agent="research") as run:
+            do_work()
+        display_run(run)
+    """
+    previous_run = _current_run.get()
+    previous_step = _current_step.get()
+    run = Run(name=name, metadata=metadata)
+    run_token = _current_run.set(run)
+    step_token = _current_step.set(None)
+    try:
+        yield run
+    finally:
+        run.finish()
+        _current_run.reset(run_token)
+        _current_run.set(previous_run)
+        _current_step.reset(step_token)
+        _current_step.set(previous_step)
+
+
+@contextmanager
+def step_context(name: str) -> Iterator[Step]:
+    """Context manager that creates and finishes a Step, nesting automatically.
+
+    When used inside another step (either via ``@track`` or a parent
+    ``step_context``), the new step becomes a child of the current step.
+
+    Args:
+        name: Human-readable name for the step.
+
+    Example:
+        with run_context("pipeline") as run:
+            with step_context("fetch"):
+                ...
+            with step_context("process"):
+                with step_context("validate"):
+                    ...
+    """
+    run, run_token = _ensure_run()
+    step = Step(name=name)
+
+    parent = _current_step.get()
+    if parent is not None:
+        parent.children.append(step)
+    else:
+        run.steps.append(step)
+
+    previous_step = _current_step.get()
+    step_token = _current_step.set(step)
+    try:
+        yield step
+    except Exception as exc:  # noqa: BLE001 - always record and re-raise
+        step.fail(repr(exc))
+        raise
+    finally:
+        if step.ended_at is None:
+            step.succeed()
+        _current_step.reset(step_token)
+        _current_step.set(previous_step)
+        if run_token is not None:
+            run.finish()
+            _current_run.reset(run_token)
+
+
+def log_event(level: int, message: str, **data: Any) -> Event | None:
+    """Emit a structured event into the current step.
+
+    If a step context is active the event is stored on that step; otherwise it
+    is stored on the current run. When no run exists at all the event is only
+    passed through to the ``steplot`` logger.
+
+    Example:
+        import logging
+        log_event(logging.INFO, "processing item", item_id=42)
+
+    Returns:
+        The created :class:`~steplot.models.Event`, or None if no run existed.
+    """
+    run = _current_run.get()
+    step = _current_step.get()
+    _logger.log(level, message)
+    if step is not None:
+        return step.add_event(level, message, **data)
+    if run is not None:
+        return run.add_event(level, message, **data)
+    return None
+
+
+def track(
+    func: Callable | None = None,
+    *,
+    step_name: str | None = None,
+    capture_args: bool = True,
+) -> Callable:
+    """Decorator that wraps a function in a Step and records its execution.
+
+    Works with both sync and async functions.
+
+    Args:
+        step_name: Override the step name (defaults to the function's __name__).
+        capture_args: When True (default), record the positional and keyword
+            arguments as the step's input. Set to False to skip capturing.
+
+    Usage:
+        @track
+        def my_step():
+            ...
+
+        @track(step_name="custom")
+        async def another_step(x, y):
+            ...
+
+        @track(capture_args=False)
+        def secret_step(x):
+            ...
+    """
+
+    def decorator(fn: Callable) -> Callable:
+        name = step_name or fn.__name__
+
+        if inspect.iscoroutinefunction(fn):
+
+            @functools.wraps(fn)
+            async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+                return await _run_tracked_async(fn, name, args, kwargs, capture_args)
+
+            return async_wrapper
+
+        @functools.wraps(fn)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            return _run_tracked_sync(fn, name, args, kwargs, capture_args)
+
+        return sync_wrapper
+
+    if func is not None and callable(func):
+        # Used as @track without arguments
+        return decorator(func)
+    return decorator
+
+
+def _ensure_run() -> tuple[Run, Any | None]:
+    """Return the current run, creating one if needed.
+
+    Returns (run, token) where token is non-None if a run was created here.
+    """
+    run = _current_run.get()
+    if run is None:
+        run = Run()
+        token = _current_run.set(run)
+        return run, token
+    return run, None
+
+
+def _append_step(step: Step) -> None:
+    """Attach a step to the current run, nesting it under the active step if any."""
+    parent = _current_step.get()
+    if parent is not None:
+        parent.children.append(step)
+    else:
+        run = _current_run.get()
+        if run is not None:
+            run.steps.append(step)
+
+
+def _run_tracked_sync(fn: Callable, name: str, args: tuple, kwargs: dict, capture_args: bool) -> Any:
+    run, token = _ensure_run()
+    step = Step(
+        name=name,
+        input={"args": list(args), "kwargs": kwargs} if capture_args else None,
+    )
+    _append_step(step)
+    _emit(logging.INFO, f"→ start: {name}")
+    try:
+        result = fn(*args, **kwargs)
+        step.succeed(output=result)
+        _emit(logging.INFO, f"✓ done: {name}")
+        return result
+    except Exception as exc:
+        step.fail(repr(exc))
+        _emit(logging.ERROR, f"✗ error: {name} — {exc!r}")
+        if token is not None:
+            _current_run.reset(token)
+        raise
+    finally:
+        step.ended_at = datetime.now()
+        if token is not None and step.status == StepStatus.SUCCESS:
+            _current_run.reset(token)
+
+
+async def _run_tracked_async(fn: Callable, name: str, args: tuple, kwargs: dict, capture_args: bool) -> Any:
+    run, token = _ensure_run()
+    step = Step(
+        name=name,
+        input={"args": list(args), "kwargs": kwargs} if capture_args else None,
+    )
+    _append_step(step)
+    _emit(logging.INFO, f"→ start: {name}")
+    try:
+        result = await fn(*args, **kwargs)
+        step.succeed(output=result)
+        _emit(logging.INFO, f"✓ done: {name}")
+        return result
+    except Exception as exc:
+        step.fail(repr(exc))
+        _emit(logging.ERROR, f"✗ error: {name} — {exc!r}")
+        if token is not None:
+            _current_run.reset(token)
+        raise
+    finally:
+        step.ended_at = datetime.now()
+        if token is not None and step.status == StepStatus.SUCCESS:
+            _current_run.reset(token)
+
+
+def _emit(level: int, message: str) -> None:
+    """Internal helper to log without raising if no run exists."""
+    _logger.log(level, message)

steplot-0.1.0.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.5
+Name: steplot
+Version: 0.1.0
+Summary: Lightweight observability for AI agents
+Project-URL: Homepage, https://github.com/MohammadaminAlbooyeh/steplot
+Project-URL: Repository, https://github.com/MohammadaminAlbooyeh/steplot
+Project-URL: Issues, https://github.com/MohammadaminAlbooyeh/steplot/issues
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# steplot
+
+Lightweight agent step tracker with decorator and logging support.
+
+`steplot` helps you visualize and persist the execution flow of your AI agents,
+scripts, or any multi-step pipeline. Wrap functions with `@track`, emit log
+events with `log_event`, and render a tree of steps to the terminal or to a
+JSON file.
+
+## Features
+
+- `@track` decorator -- wraps any function in a timed `Step`.
+- `run_context` / `step_context` -- context managers for nesting.
+- `log_event` -- emit structured events into the current step.
+- `display_run` -- pretty-print a run tree to the terminal.
+- `save_run` / `load_run` -- persist runs as JSON.
+
+## Installation
+
+```bash
+pip install -e .
+```
+
+## Quick start
+
+```python
+from steplot import track, run_context, display_run
+
+@track
+def research(topic: str) -> str:
+    return f"papers about {topic}"
+
+@track
+def summarize(papers: str) -> str:
+    return papers.upper()
+
+with run_context("my-agent") as run:
+    papers = research("transformers")
+    summary = summarize(papers)
+
+display_run(run)
+```
+
+Output:
+
+```
+╔══ Run: my-agent  [0.02s] ═══
+║
+║  ├─ research  [0.01s]
+║  └─ summarize  [0.00s]
+╚════════════════════════════╝
+```
+
+## Nested steps
+
+```python
+from steplot import run_context, step_context
+
+with run_context("pipeline") as run:
+    with step_context("fetch"):
+        ...
+    with step_context("process"):
+        with step_context("validate"):
+            with step_context("score"):
+                ...
+```
+
+## Persisting runs
+
+```python
+from steplot import save_run, load_run
+
+save_run(run, "steplot/runs/run-1.json")
+loaded = load_run("steplot/runs/run-1.json")
+```
+
+## API reference
+
+### `track`
+
+```python
+@track
+def my_step(): ...
+
+@track(step_name="custom", capture_args=True)
+def another_step(x, y): ...
+```
+
+### `run_context`, `step_context`
+
+Context managers that create and automatically finish a `Run` or `Step`.
+
+### `log_event`
+
+```python
+import logging
+from steplot import log_event
+
+log_event(logging.INFO, "processing item", item_id=42)
+```
+
+### `display_run`
+
+Prints a tree of steps and events to stdout.
+
+## License
+
+MIT

steplot-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+steplot/__init__.py,sha256=jlcRqt0ZGEn20a_GMvy2XQr6S28J2BJBy9IMqoZDGMo,484
+steplot/display.py,sha256=7PKyKEsRP5R2yqUjmtLTOQEvXM_2qO6dRO_Vl8uVWzU,2230
+steplot/models.py,sha256=ufilJevaYsUTpevi1X0ge3teDjyon3we7xWmnOWiLyo,7599
+steplot/storage.py,sha256=DMVtEn-fJnC07LnQrui_9pqoYqY8FGDRNZ8ceppSqlQ,1550
+steplot/tracker.py,sha256=AUmd0e8HJANeUfxeu4zYfmm2wcemG6O2ii7i2NHOXEE,8145
+steplot/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+steplot-0.1.0.dist-info/METADATA,sha256=arlWVxWxULznCWpYLYpwa87HxJ7PLsZy_VMtZuHnWv8,2746
+steplot-0.1.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+steplot-0.1.0.dist-info/licenses/LICENSE,sha256=mgNwCgyMtHiCT4FEnUAFizIETCFVyhI7szPUujHYM_Y,1077
+steplot-0.1.0.dist-info/RECORD,,

steplot-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.3
+Root-Is-Purelib: true
+Tag: py3-none-any

steplot-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mohammadamin Albooyeh
+
+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.