anyshell 0.1.0__py3-none-any.whl

anyshell/pager.py

@@ -0,0 +1,203 @@
+"""Read-only paging inside the Shell widget, without a terminal subprocess."""
+
+import re
+
+import anyio
+from anytext import on
+from anytext.app import ComposeResult
+from anytext.binding import Binding
+from anytext.containers import Horizontal, Vertical
+from anytext.reactive import var
+from anytext.widgets import Input, RichLog, Static
+from rich.text import Text
+
+from .engine import PageRequest
+
+
+class PagerLog(RichLog, can_focus=False):
+    """Keep keyboard focus on the pager and expose mouse scrolling."""
+
+
+class PagerSearchInput(Input):
+    """A temporary regex search field, separate from the shell command input."""
+
+
+class Pager(Vertical, can_focus=True):
+    BINDINGS = [
+        Binding("space,pagedown", "next_page", "Next page", priority=True),
+        Binding("b,pageup", "previous_page", "Previous page", priority=True),
+        Binding("enter,down", "next_line", show=False, priority=True),
+        Binding("up", "previous_line", show=False, priority=True),
+        Binding("home,g", "first_page", show=False, priority=True),
+        Binding("end,G", "last_page", show=False, priority=True),
+        Binding("q,escape", "close_pager", show=False, priority=True),
+        Binding("ctrl+q", "force_close", "Close", priority=True),
+        Binding("slash", "search_forward", "Search", priority=True),
+        Binding("question_mark", "search_backward", show=False, priority=True),
+        Binding("n", "next_match", "Next match", priority=True),
+        Binding("N", "previous_match", show=False, priority=True),
+        Binding("escape", "cancel_search", "Cancel search", priority=True),
+    ]
+    _searching = var(False, bindings=True)
+
+    DEFAULT_CSS = """
+    Pager { width: 1fr; height: 1fr; background: $surface; }
+    Pager #pager-title { height: 1; padding: 0 1; }
+    Pager #pager-search-row { display: none; height: 1; }
+    Pager #pager-search-direction { width: 1; }
+    Pager PagerSearchInput, Pager PagerSearchInput:focus {
+        width: 1fr; height: 1; border: none; padding: 0;
+    }
+    Pager PagerLog {
+        height: 1fr; min-height: 0; padding: 0 1; overflow: auto auto;
+    }
+    """
+
+    def __init__(self, request: PageRequest) -> None:
+        super().__init__()
+        self.request = request
+        self.closed = anyio.Event()
+        self.loaded = False
+        self.error: Exception | None = None
+        self._pattern: re.Pattern[str] | None = None
+        self._direction = 1
+        self._match_line: int | None = None
+
+    def compose(self) -> ComposeResult:
+        yield Static(Text(self.request.title), id="pager-title")
+        yield PagerLog(wrap=True, markup=False, min_width=1, auto_scroll=False)
+        with Horizontal(id="pager-search-row"):
+            yield Static("/", id="pager-search-direction")
+            yield PagerSearchInput()
+
+    def on_mount(self) -> None:
+        self.focus()
+
+    async def load(self) -> None:
+        log = self.query_one(PagerLog)
+        try:
+            async for line in self.request.lines:
+                log.write(Text(line), scroll_end=False)
+                await anyio.lowlevel.checkpoint()
+        except Exception as error:
+            self.error = error
+            self.closed.set()
+        else:
+            self.loaded = True
+
+    def action_next_page(self) -> None:
+        self._match_line = None
+        self.query_one(PagerLog).scroll_page_down(animate=False)
+
+    def action_previous_page(self) -> None:
+        self._match_line = None
+        self.query_one(PagerLog).scroll_page_up(animate=False)
+
+    def action_next_line(self) -> None:
+        self._match_line = None
+        log = self.query_one(PagerLog)
+        log.scroll_to(y=log.scroll_y + 1, animate=False, immediate=True)
+
+    def action_previous_line(self) -> None:
+        self._match_line = None
+        log = self.query_one(PagerLog)
+        log.scroll_to(y=log.scroll_y - 1, animate=False, immediate=True)
+
+    def action_first_page(self) -> None:
+        self._match_line = None
+        self.query_one(PagerLog).scroll_home(animate=False)
+
+    def action_last_page(self) -> None:
+        self._match_line = None
+        self.query_one(PagerLog).scroll_end(animate=False)
+
+    def action_close_pager(self) -> None:
+        self.closed.set()
+
+    def action_force_close(self) -> None:
+        self.closed.set()
+
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> bool | None:
+        if action == "cancel_search":
+            return self._searching
+        if action in {
+            "search_forward",
+            "search_backward",
+            "next_match",
+            "previous_match",
+        }:
+            return self.request.searchable and not self._searching
+        if action != "force_close":
+            return not self._searching
+        return True
+
+    def _start_search(self, direction: int) -> None:
+        self._direction = direction
+        self._searching = True
+        self.query_one("#pager-search-direction", Static).update(
+            "/" if direction > 0 else "?"
+        )
+        self.query_one("#pager-search-row").display = True
+        field = self.query_one(PagerSearchInput)
+        field.value = ""
+        field.focus()
+
+    def action_search_forward(self) -> None:
+        self._start_search(1)
+
+    def action_search_backward(self) -> None:
+        self._start_search(-1)
+
+    def action_cancel_search(self) -> None:
+        self._searching = False
+        self.query_one("#pager-search-row").display = False
+        self.focus()
+
+    @on(Input.Changed)
+    def search_changed(self, event: Input.Changed) -> None:
+        event.stop()
+
+    @on(Input.Submitted)
+    def search_submitted(self, event: Input.Submitted) -> None:
+        event.stop()
+        if event.value:
+            try:
+                self._pattern = re.compile(event.value)
+            except re.error as error:
+                self.app.notify(
+                    str(error), title="Invalid search", severity="error", markup=False
+                )
+                return
+        self._match_line = None
+        self.action_cancel_search()
+        if self._pattern is not None:
+            self._find_match(self._direction, include_current=True)
+
+    def _find_match(self, direction: int, *, include_current: bool = False) -> None:
+        if self._pattern is None:
+            return
+        log = self.query_one(PagerLog)
+        count = len(log.lines)
+        if count:
+            start = (
+                self._match_line if self._match_line is not None else int(log.scroll_y)
+            )
+            first = 0 if include_current else 1
+            for step in range(first, count + first):
+                index = (start + direction * step) % count
+                if self._pattern.search(log.lines[index].text):
+                    self._match_line = index
+                    log.scroll_to(y=index, animate=False, immediate=True)
+                    self.query_one("#pager-title", Static).update(
+                        Text(
+                            f"{self.request.title} · {self._pattern.pattern} · line {index + 1}"
+                        )
+                    )
+                    return
+        self.app.notify("Pattern not found", title="Search", markup=False)
+
+    def action_next_match(self) -> None:
+        self._find_match(self._direction)
+
+    def action_previous_match(self) -> None:
+        self._find_match(-self._direction)

anyshell/presentation.py

@@ -0,0 +1,55 @@
+"""Human-readable output formatting, separate from pipeline values."""
+
+from datetime import datetime, timezone
+
+from .commands import render
+
+LONG_FILE_HEADERS = ("Type", "Bytes", "Modified (UTC)", "Name")
+
+
+def is_file_record(value) -> bool:
+    return (
+        isinstance(value, dict)
+        and isinstance(value.get("name"), str)
+        and value.get("type") in ("file", "directory", "symlink")
+    )
+
+
+def is_long_file_record(value) -> bool:
+    return is_file_record(value) and "size" in value and "modified" in value
+
+
+def file_name(value) -> str:
+    return value.get("path", value["name"]) + (
+        "/" if value["type"] == "directory" else ""
+    )
+
+
+def long_file_cells(value) -> tuple[str, str, str, str]:
+    modified = value["modified"]
+    if isinstance(modified, (int, float)):
+        try:
+            modified = datetime.fromtimestamp(modified, timezone.utc).strftime(
+                "%Y-%m-%d %H:%M:%S"
+            )
+        except (OSError, OverflowError, ValueError):
+            modified = "?"
+    return (
+        {"directory": "dir", "symlink": "link", "file": "file"}[value["type"]],
+        str(value["size"]) if value["size"] is not None else "-",
+        str(modified) if modified is not None else "-",
+        file_name(value),
+    )
+
+
+def format_long_line(cells) -> str:
+    kind, size, modified, name = cells
+    return f"{kind:4} {size:>10} {modified:19} {name}"
+
+
+def format_value(value) -> str:
+    if is_long_file_record(value):
+        return format_long_line(long_file_cells(value))
+    if is_file_record(value):
+        return file_name(value)
+    return render(value)

anyshell-0.1.0.dist-info/METADATA

@@ -0,0 +1,337 @@
+Metadata-Version: 2.4
+Name: anyshell
+Version: 0.1.0
+Summary: An async Python command shell with an optional Anytext frontend
+Author: David Brochart
+Author-email: David Brochart <david.brochart@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: anyio>=4.11,<5
+Requires-Dist: cyclopts>=5.4,<6
+Requires-Dist: anytext>=9.1,<10 ; extra == 'anytext'
+Requires-Dist: trio>=0.31 ; extra == 'trio'
+Requires-Python: >=3.11
+Provides-Extra: anytext
+Provides-Extra: trio
+Description-Content-Type: text/markdown
+
+# Anyshell
+
+An async shell whose commands are Python functions. The engine is independent of
+its optional Anytext widget: both can run locally on the desktop or in Pyodide.
+No shell command starts an OS process or needs a worker thread.
+
+## Run it
+
+```sh
+uv sync --extra anytext --extra trio
+uv run --extra anytext anyshell
+uv run --extra anytext --extra trio anyshell --backend trio
+uv run anyshell -c 'ls | where type file | select name | sort'
+```
+
+`/` maps to the selected workspace directory, which defaults to your current
+working directory. Use `--root /path/to/workspace` to choose another directory.
+The session never changes Python's process working directory. Paths use `/` on
+all platforms. Local symlinks must resolve inside the workspace; this is a path
+boundary, not a sandbox for arbitrary Python commands or untrusted code.
+
+The prompt is inline by default: it follows the latest output in a shared scrollback
+area. Typing or completing a command brings it back into view. For a fixed bottom
+editor, run `uv run --extra anytext anyshell --prompt-position bottom` or construct
+`Shell(session, prompt_position="bottom")`. Both `Shell` and `ShellApp` accept
+`prompt_position="inline"` or `prompt_position="bottom"`.
+
+The widget provides a scrollable transcript, Up/Down history, Tab completion for
+command names, options, and unquoted paths, Ctrl+C cancellation, and Ctrl+Q to quit the demo.
+Tab first extends the shared prefix when several completions match. If no more
+characters can be filled in, Tab opens a menu beside the cursor. Use Up/Down or
+Tab to select, Enter to insert, and Escape to dismiss; typing also dismisses it.
+Long choices remain on one line and can be read using the horizontal scrollbar.
+
+## Multiline commands
+
+Shift+Enter inserts a newline without running the command. Enter submits a
+complete command, or inserts a continuation line when a quote is still open or
+the command ends with a pipe or backslash. Ctrl+O also inserts a newline on
+terminals that cannot distinguish Shift+Enter. Ctrl+Enter forces submission,
+including syntax errors. The editor grows up to eight rows, then scrolls.
+
+```sh
+echo 'hello
+world'
+cat notes.txt |
+    grep Python |
+    count
+```
+
+Unquoted newlines separate commands, which execute in order. A backslash followed
+by a newline joins lines without inserting a character. Newlines inside quotes
+remain part of the argument. All commands are parsed and validated before any
+runs; a runtime failure does not prevent later commands from running, and the
+final status is that of the last command. Ctrl+C cancels the active sequence or
+clears unfinished input. History keeps a multiline submission as one entry.
+Up/Down moves within a multiline editor; Alt+Up/Down navigates command history.
+The same syntax works through `Session.execute()` and headless `-c` execution.
+
+## Commands and pipelines
+
+```sh
+help
+ls
+ls -la
+help ls
+ls | where type file | select name | sort
+cat README.md | grep Python | count
+echo 'a quoted | character'
+mkdir notes
+touch empty.txt
+rmdir notes
+mkdir notes
+cd notes
+write hello.txt 'Hello from Python'
+cat hello.txt
+edit hello.txt
+cp hello.txt backup.txt
+mv backup.txt renamed.txt
+rm hello.txt
+cd /
+sleep 30
+clear
+```
+
+Pipelines exchange Python values through bounded AnyIO streams. `ls` emits
+records, displayed as names in columns in the widget (directories have a trailing
+`/` and blue styling). Headless output lists one name per line. Pipeline values
+remain records; `select` extracts fields; `count` emits an integer. `cat` and `grep`
+stream text lines. `sort` buffers its input. A failure in any stage fails the
+pipeline. Filesystem mutations, `cd`, and `clear` run outside pipelines.
+
+`ls -l` (`--long`) displays type, byte size, modification time in UTC, and name.
+Its pipeline records include `size` and `modified` (Unix seconds); directory size
+is `None`. `ls -a` (`--all`) includes hidden entries, and flags combine as `-la`.
+`grep -i` ignores case and `sort -r` reverses the order.
+`touch PATH...` creates missing files or updates modification times without
+changing existing contents. Existing directories can also be touched.
+`rm PATH...` removes files, continuing with remaining paths if one fails.
+`rmdir DIRECTORY...` removes empty directories and rejects files and nonempty
+directories; its completion suggests only directories.
+
+This is an initial shell language: quoting, multiline commands, and pipes are supported. Bash scripts,
+redirection, environment expansion, glob expansion, process execution, job
+control, and persistent history are not implemented. Commands are trusted Python
+code, not a sandbox. Browser filesystem changes are in-memory and reset on reload.
+
+## Find files
+
+```sh
+find
+find docs -name '*.txt'
+find . -iname '*.py' -type f
+find . -type d -maxdepth 2
+find docs other-directory -type f | select path
+find . -type f | count
+```
+
+`find [PATH...]` walks starting paths recursively, including the starting entries
+and hidden names. It defaults to `.`. `-name`/`--name` matches a basename using
+shell-style wildcard patterns; `-iname`/`--iname` ignores letter case.
+`-type`/`--type` accepts `f` (file), `d` (directory), or `l` (symbolic link).
+`-maxdepth`/`--max-depth` limits traversal, with starting paths at depth zero.
+Filters combine with AND. Quote wildcard patterns to pass them unchanged.
+
+Output records contain `name` (basename), `path` (relative to the current working
+directory, or absolute when the starting path is absolute), and `type` (`file`,
+`directory`, or `symlink`). The UI displays paths with the usual directory suffix;
+`select path` extracts plain paths. Symbolic links, including starting paths,
+are listed without following them. Errors are reported while traversal continues
+with other entries and starting paths; any error makes the command fail.
+Custom filesystem implementations provide `entry_type()` without following the
+final symbolic link, alongside the existing directory-listing methods.
+
+## Move and copy files
+
+```sh
+mv old.txt new.txt
+mv notes archive
+cp file.txt backup.txt
+cp file.txt existing-directory/
+cp -r notes notes-backup
+```
+
+`mv SOURCE DESTINATION` moves or renames a file or a whole directory.
+`cp SOURCE DESTINATION` copies a file; `cp -r` (or `--recursive`) also copies
+whole directory trees, including hidden entries. If the destination is an
+existing directory, the source keeps its name inside it. Existing files are
+replaced; existing directory trees are not merged or replaced. Contents and
+modification times are preserved. Both commands accept one source and one
+destination and run outside pipelines. Moving the current directory or one of
+its ancestors updates the session's working path.
+
+## Page through text
+
+```sh
+more README.md
+more first.txt second.txt
+cat notes.txt | grep Python | more
+ls -l | more
+```
+
+`more` fills the Shell widget with a read-only, scrollable view, then restores the
+transcript and prompt when closed. Space/Page Down moves forward a page;
+`b`/Page Up moves back. Enter/Down advances one line, Up moves back one line,
+and Home/End jumps to the beginning/end. `q`, Ctrl+Q, or Escape closes the pager.
+Mouse scrolling also works. Shortcuts appear in the footer.
+
+The pager accepts files or pipeline input, formatting Python values for display.
+It streams input into scrollback; closing it stops consuming the pipeline.
+Headless execution reports that an interactive frontend is required. Other
+frontends can handle the `page` event's `PageRequest`, consume its `lines`, mark
+it `handled`, and return when their pager closes.
+
+## Search with less
+
+```sh
+less README.md
+less first.txt second.txt
+cat notes.txt | grep Python | less
+```
+
+`less` uses the same in-shell pager and navigation shortcuts as `more`, adding
+Python regex search. Press `/` to search forward or `?` to search backward,
+then enter a pattern and press Enter. `n` finds the next match in that direction;
+Shift+N finds the previous one. Searches wrap around the text. An empty search
+reuses the last pattern, and Escape cancels the search field. Invalid patterns
+and missing matches appear as notifications. The title shows the matching line.
+The search field disappears after submission, leaving no permanent bottom line.
+
+## Edit files
+
+`edit PATH` opens a plain text editor that fills the Shell widget, restoring the
+transcript and prompt when closed. It loads an
+existing UTF-8 file or starts empty for a new file. Ctrl+S saves without closing;
+Ctrl+Q closes the editor and returns to the shell. Modified files show `*` beside the path. Closing with unsaved
+changes updates the footer shortcuts: a second Ctrl+Q discards and closes (Ctrl+D
+also works), Ctrl+S saves,
+and Escape keeps editing. Save errors appear as notifications and leave the
+editor and its text open. The title marks unsaved edits with `*`; shortcuts appear
+in the app footer. The editor has no bottom status line or button rows. When embedding in
+another Anytext app, give its app-wide Ctrl+Q quit binding `priority=False` so
+the focused editor can handle that key first, as `ShellApp` does.
+
+The editor uses the session filesystem on desktop and in the thread-free browser.
+New files are created when saved. Browser files remain in memory until reload.
+Headless `-c` execution reports that an interactive frontend is required; `edit`
+cannot run in a pipeline. Other frontends can handle the `edit` event's
+`EditRequest`, mark it `handled`, and return after their editor closes.
+
+## Use the engine
+
+```python
+import anyio
+from anyshell import Event, MemoryFileSystem, Session
+
+session = Session(MemoryFileSystem({"hello.txt": "hello\nworld\n"}))
+
+
+async def receive(event: Event):
+    if event.kind == "output":
+        print(event.value)
+
+
+async def main():
+    await session.execute("cat hello.txt | count", receive)
+
+
+anyio.run(main)
+```
+
+Commands use Cyclopts to parse typed Python parameters. `--help` (or `-h`)
+and `help COMMAND` write help to the transcript. Invalid arguments produce shell
+errors without exiting the app. All pipeline arguments are validated before any
+stage starts. Use `--` before a filename beginning with a dash.
+
+Register a `Command` with a synchronous or asynchronous function. Parameters
+named `ctx` (or `context`), `stdin`, and `stdout` are injected by the engine and
+must be keyword-only. Other parameters become command arguments and options.
+Input and output are AnyIO object streams; a returned value is also emitted as
+one pipeline value. Command functions should stay cooperative for cancellation.
+`Session.cancel()` must be called from the session's event loop.
+
+```python
+from typing import Annotated
+
+from cyclopts import Parameter
+from anyshell import Command
+
+
+async def upper(
+    *,
+    prefix: Annotated[str, Parameter(name=["--prefix", "-p"])] = "",
+    stdin,
+    stdout,
+):
+    async for value in stdin:
+        await stdout.send(prefix + str(value).upper())
+
+
+session.register(Command("upper", "Uppercase input values", upper))
+# Now: echo hello | upper -p '> '
+```
+
+`ctx.fs` exposes the filesystem and `ctx.emit` emits frontend events. Parsing
+and help never expose the injected parameters as command options.
+
+For the frontend, import `Shell` from `anyshell.frontend` and yield
+`Shell(session)` in any Anytext app. History and working directory live in the
+session, so the engine and UI can evolve independently.
+
+## Browser demo
+
+```sh
+uv run python tools/build_browser.py
+uv run python -m http.server --directory .cache/browser-site 8000
+```
+
+Open http://localhost:8000. The Prompt selector switches between inline and bottom
+layouts by reloading the demo (`?prompt=inline` or `?prompt=bottom`). The demo downloads Pyodide and Anytext from public
+package servers and installs this checkout's Anyshell wheel. It uses an in-memory
+workspace and disables threads. Internet access is needed on first load.
+
+## Development
+
+```sh
+uv run pytest
+uv run ruff check .
+uv run ruff format --check .
+uv build
+```
+
+For the real browser regression test:
+
+```sh
+uv run python tools/build_browser.py
+npm ci --prefix tests/browser
+cd tests/browser
+npx playwright install chromium
+npm test
+```
+
+Async engine and widget tests run on both asyncio and Trio. The engine depends
+on AnyIO and Cyclopts; install `anyshell[anytext]` for the UI and `anyshell[trio]` for Trio.
+
+The browser terminal scaffolding is adapted from Anytext's MIT-licensed browser demo.
+
+## Releasing
+
+Set `project.version` in `pyproject.toml`, update the lockfile with `uv lock`, and
+commit the release changes. Push a matching version tag, without a `v` prefix:
+
+```sh
+git tag 0.1.0
+git push origin 0.1.0
+```
+
+The `release.yml` workflow checks that the tag matches the package version,
+builds and validates the wheel and source distribution, then publishes them to
+PyPI using the configured trusted publisher. No PyPI API token is needed.

anyshell-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+anyshell/__init__.py,sha256=CIZ0v1RIag9mrRlZ8TlGV7ST5AVZDF9XhJ8u2bErfJI,495
+anyshell/__main__.py,sha256=-X2c7AX_IcWRPssvGYdUaLkIdxsBRTXPhu04BOJQm84,2373
+anyshell/commands.py,sha256=8lGngwOusBaFGYSwD_-ttXdXjtst3ekK4aZhNIAOBSA,13069
+anyshell/editor.py,sha256=tQzhH-ga4ARCROw_oo9pBjGXGemeDLbrwhIWgF5OHMk,4409
+anyshell/engine.py,sha256=TFQcB20hRDoo27HaP1Rfi0Dda6Ixp24XyHmOdzZLtQQ,14302
+anyshell/filesystem.py,sha256=URYcsa7AMeqAHutf9uU2TfGN3-EVpS0ojVtzq3rrMQk,13515
+anyshell/frontend.py,sha256=T4Kwc0TUAgNCB70LXWHSpk4tqEUlG0m3Q88Uba4UWwQ,19490
+anyshell/pager.py,sha256=THE4hkj4MxlxAFXcaiRhB5DZ7urj4QqvcA8x49F-3nI,7373
+anyshell/presentation.py,sha256=eBnqJXbbeckeiYzUBq9Gx8F9_aAnOUmYjKUz1aeJZX8,1613
+anyshell/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyshell-0.1.0.dist-info/licenses/LICENSE,sha256=l2NKIx1csL2iTBGQFGrbwo0WbAJ4BtZMpt2pzvx47TQ,1071
+anyshell-0.1.0.dist-info/WHEEL,sha256=si2p8vW03RnhyBnhWl4tj-ObJa78SpE-c9HsEtblGR0,80
+anyshell-0.1.0.dist-info/entry_points.txt,sha256=kfGUbNkzxk_GQmo6pSFlo_y-_b3x_hQk055621wHReU,53
+anyshell-0.1.0.dist-info/METADATA,sha256=l-6xiIzsMfIpjPjRoERWfpBNZThuaQTF8FEX9ka-WhI,13330
+anyshell-0.1.0.dist-info/RECORD,,

anyshell-0.1.0.dist-info/WHEEL

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

anyshell-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+anyshell = anyshell.__main__:main
+

anyshell-0.1.0.dist-info/licenses/LICENSE

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