plesty-bench 0.2.0__py3-none-any.whl

plesty/bench/__init__.py

@@ -0,0 +1,45 @@
+# SPDX-FileCopyrightText: 2026 Yunshuang Yuan
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+"""``plesty.bench`` — talk to a bench running ``plesty-server`` from another machine.
+
+This is the *client* half of plesty-server and the only part published to
+PyPI (distribution ``plesty-bench``). It depends on ``pyzmq`` and ``click``
+and imports nothing from ``plesty.server``: the developer machine that runs
+the remote field-test loop, or a script on the experiment PC, installs this
+and nothing of the bench application.
+
+The contract is deliberately thin — *the CLI is the API*: the bench agent
+accepts a ``plesty-server`` argument list, runs it, and returns the exit
+code and the output. Anything the command line can do is remote, with no
+second schema to keep in step.
+
+.. code-block:: python
+
+    from plesty.bench import BenchClient
+
+    with BenchClient("tcp://lab-bench-03:5550", token="…") as bench:
+        print(bench.describe()["result"]["version"])
+        result = bench.exec(["status", "--json"])
+        job = bench.exec(["field-test", "pm100d", "--no-wait"]).stdout.strip()
+        bench.follow(job, print)                         # tails the job log until it ends
+        data = bench.fetch("repos/plesty-pm100d/exp/reports/pm100d-s120c/field-test.json")
+
+Or from a shell: ``plesty-bench -b lab-bench-03 -- status``.
+"""
+
+from plesty.bench.client import (
+    DEFAULT_PORT,
+    BenchClient,
+    BenchClientError,
+    ExecResult,
+    parse_address,
+)
+
+__all__ = [
+    "DEFAULT_PORT",
+    "BenchClient",
+    "BenchClientError",
+    "ExecResult",
+    "parse_address",
+]

plesty/bench/cli.py

@@ -0,0 +1,111 @@
+# SPDX-FileCopyrightText: 2026 Yunshuang Yuan
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+"""``plesty-bench`` — run ``plesty-server`` commands on a remote bench.
+
+.. code-block:: bash
+
+    plesty-bench -b lab-bench-03 status
+    plesty-bench -b lab-bench-03 field-test pm100d --address mock        # follows the job
+    plesty-bench -b lab-bench-03 fetch repos/plesty-pm100d/exp/reports/<slug>/field-test.json -o .
+    plesty-bench -b lab-bench-03 ping
+
+``-b`` (or ``PLESTY_BENCH``) names the bench, ``--token`` (or
+``PLESTY_BENCH_TOKEN``) the shared secret. Everything else is handed to the
+bench's ``plesty-server`` unchanged (put ``--`` first when the remote
+arguments start with a dash). Two words are the client's own: ``ping`` and
+``fetch PATH [-o OUT]``. When the remote command is one that starts a job
+(``install``, ``update``, ``field-test``) it is started ``--no-wait`` on the
+bench and its log is followed here until it ends.
+"""
+
+from __future__ import annotations
+
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+import click
+
+from plesty.bench.client import ADDRESS_ENV, TOKEN_ENV, BenchClient, BenchClientError
+
+#: Remote commands that start a job; the client adds ``--no-wait`` and follows.
+JOB_COMMANDS = ("install", "update", "field-test")
+
+
+@click.command("plesty-bench", context_settings={"ignore_unknown_options": True})
+@click.option("-b", "--bench", "address", envvar=ADDRESS_ENV, default=None, metavar="HOST[:PORT]")
+@click.option("--token", envvar=TOKEN_ENV, default=None, help="Shared secret of the agent.")
+@click.option("--timeout", type=float, default=60.0, show_default=True, help="Reply timeout (s).")
+@click.argument("argv", nargs=-1, type=click.UNPROCESSED)
+def app(address: str | None, token: str | None, timeout: float, argv: tuple[str, ...]) -> None:
+    """Run `plesty-server ARGV` on the bench at -b; `ping` and `fetch PATH [-o OUT]` are local."""
+    client = BenchClient(address, token, timeout_ms=int(timeout * 1000))
+    args = [a for a in argv if a != "--"]
+    if not args:
+        click.echo(click.get_current_context().get_help())
+        return
+    try:
+        if args[0] == "ping":
+            info = client.describe(timeout_ms=3000)
+            kind, version, home = info.get("kind"), info.get("version"), info.get("home")
+            click.echo(f"{client.address}: {kind} {version} home={home}")
+            return
+        if args[0] == "fetch":
+            _fetch(client, args[1:])
+            return
+        raise click.exceptions.Exit(run_remote(client, args))
+    except BenchClientError as exc:
+        raise click.ClickException(str(exc)) from exc
+
+
+def run_remote(client: BenchClient, args: Sequence[str]) -> int:
+    """Run *args* on the bench; follow the job when it starts one. Returns the exit code."""
+    argv = list(args)
+    follow = argv[0] in JOB_COMMANDS and "--no-wait" not in argv
+    if follow:
+        argv.append("--no-wait")
+    result = client.exec(argv)
+    if result.stderr:
+        click.echo(result.stderr, err=True, nl=False)
+    lines = result.stdout.strip().splitlines()
+    if not follow or not result.ok or not lines:
+        click.echo(result.stdout, nl=False)
+        return result.code
+    job_id = lines[-1]
+    click.echo(f"job {job_id}", err=True)
+    return client.follow(job_id, lambda text: click.echo(text, nl=False))
+
+
+def _fetch(client: BenchClient, args: Sequence[str]) -> None:
+    rest = list(args)
+    out: str | None = None
+    for flag in ("-o", "--out"):
+        if flag in rest:
+            i = rest.index(flag)
+            if i + 1 >= len(rest):
+                raise click.ClickException(f"{flag} needs a path")
+            out = rest[i + 1]
+            del rest[i : i + 2]
+    if len(rest) != 1:
+        raise click.ClickException("fetch PATH [-o OUT]")
+    data = client.fetch(rest[0])
+    if out is None:
+        sys.stdout.buffer.write(data)
+        sys.stdout.flush()
+        return
+    target = Path(out)
+    if target.is_dir():
+        target = target / Path(rest[0]).name
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_bytes(data)
+    click.echo(f"wrote {target} ({len(data)} bytes)")
+
+
+def main() -> None:
+    """Console-script entry point."""
+    app(prog_name="plesty-bench")
+
+
+if __name__ == "__main__":  # pragma: no cover
+    main()

plesty/bench/client.py

@@ -0,0 +1,242 @@
+# SPDX-FileCopyrightText: 2026 Yunshuang Yuan
+# SPDX-License-Identifier: LGPL-3.0-or-later
+
+"""The bench client: one ZMQ DEALER socket, three request types.
+
+The wire is the plesty-lib device-server wire — JSON frames, ``status: ok``
+or ``status: error`` replies — so a :func:`plesty.lib.service.build_client`
+or a ``describe`` probe understands the agent too. Requests:
+
+``{"type": "describe"}``
+    → ``{"status": "ok", "result": {"kind": "plesty-server-agent", "version": …,
+    "home": …, "commands": [...]}}``
+``{"type": "exec", "argv": [...], "token": "…"}``
+    → ``{"status": "ok", "result": {"code": 0, "stdout": "…", "stderr": "…"}}``
+``{"type": "fetch", "path": "relative/to/home", "token": "…"}``
+    → ``{"status": "ok", "result": {"path": …, "size": n, "data": "<base64>"}}``
+
+Everything long-running is already a job on the bench: ask for it with
+``--no-wait``, then :meth:`BenchClient.follow` the job log.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import os
+import time
+from collections.abc import Callable, Sequence
+from dataclasses import dataclass
+from typing import Any
+
+import zmq
+
+#: The agent's port; device servers are given 5551 upwards.
+DEFAULT_PORT = 5550
+
+#: Environment variables the client reads when no address/token is given.
+ADDRESS_ENV = "PLESTY_BENCH"
+TOKEN_ENV = "PLESTY_BENCH_TOKEN"
+
+
+class BenchClientError(RuntimeError):
+    """The bench did not answer, refused the request, or the command failed to run."""
+
+
+@dataclass(frozen=True)
+class ExecResult:
+    """What one remote ``plesty-server`` invocation produced.
+
+    Attributes:
+        argv: The arguments that were run.
+        code: Exit code.
+        stdout: Captured standard output.
+        stderr: Captured standard error (progress lines).
+    """
+
+    argv: tuple[str, ...]
+    code: int
+    stdout: str
+    stderr: str
+
+    @property
+    def ok(self) -> bool:
+        """Whether the command exited 0."""
+        return self.code == 0
+
+    def json(self) -> Any:
+        """Parse stdout as JSON (for commands run with ``--json``)."""
+        return json.loads(self.stdout)
+
+
+def parse_address(value: str | None) -> str:
+    """Turn ``host``, ``host:port`` or ``tcp://host:port`` into a ZMQ endpoint.
+
+    Args:
+        value: The address; ``None`` reads ``PLESTY_BENCH``, else ``localhost``.
+    """
+    raw = (value or os.environ.get(ADDRESS_ENV) or "localhost").strip()
+    if "://" in raw:
+        return raw
+    host, _, port = raw.rpartition(":")
+    if not host:
+        host, port = raw, str(DEFAULT_PORT)
+    return f"tcp://{host}:{port or DEFAULT_PORT}"
+
+
+class BenchClient:
+    """A connection to one bench agent."""
+
+    def __init__(
+        self,
+        address: str | None = None,
+        token: str | None = None,
+        timeout_ms: int = 10000,
+        context: zmq.Context[Any] | None = None,
+    ) -> None:
+        """Connect lazily to *address*.
+
+        Args:
+            address: ``host``, ``host:port`` or ``tcp://host:port``; ``None``
+                reads ``PLESTY_BENCH``.
+            token: Shared secret the agent was started with; ``None`` reads
+                ``PLESTY_BENCH_TOKEN``.
+            timeout_ms: Default reply timeout for :meth:`request`.
+            context: ZMQ context to use; the global instance by default.
+        """
+        self.address = parse_address(address)
+        self.token = token if token is not None else os.environ.get(TOKEN_ENV)
+        self.timeout_ms = timeout_ms
+        self._context = context or zmq.Context.instance()
+        self._socket: zmq.Socket[Any] | None = None
+
+    # ── lifecycle ────────────────────────────────────────────────────────
+
+    def __enter__(self) -> BenchClient:
+        """Open the socket."""
+        self._connect()
+        return self
+
+    def __exit__(self, *_exc: object) -> None:
+        """Close the socket."""
+        self.close()
+
+    def close(self) -> None:
+        """Close the socket (a later request reconnects)."""
+        if self._socket is not None:
+            self._socket.close(linger=0)
+            self._socket = None
+
+    def _connect(self) -> zmq.Socket[Any]:
+        if self._socket is None:
+            sock = self._context.socket(zmq.DEALER)
+            sock.setsockopt(zmq.LINGER, 0)
+            sock.connect(self.address)
+            self._socket = sock
+        return self._socket
+
+    # ── wire ─────────────────────────────────────────────────────────────
+
+    def request(self, message: dict[str, Any], timeout_ms: int | None = None) -> dict[str, Any]:
+        """Send one request and return the ``result`` of an ``ok`` reply.
+
+        Raises:
+            BenchClientError: On no reply in time, a malformed reply, or an
+                ``error`` reply (its message is the exception text).
+        """
+        sock = self._connect()
+        payload = dict(message)
+        if self.token and "token" not in payload:
+            payload["token"] = self.token
+        wait = self.timeout_ms if timeout_ms is None else timeout_ms
+        try:
+            sock.send(json.dumps(payload).encode())
+            if not sock.poll(wait, zmq.POLLIN):
+                # A DEALER keeps the unanswered frame queued; drop the socket so a
+                # retry is not answered by the stale request's reply.
+                self.close()
+                raise BenchClientError(f"no reply from {self.address} in {wait} ms")
+            reply = json.loads(sock.recv().decode("utf-8", errors="replace"))
+        except zmq.ZMQError as exc:
+            self.close()
+            raise BenchClientError(f"{self.address}: {exc}") from exc
+        except ValueError as exc:
+            raise BenchClientError(f"{self.address}: reply was not JSON ({exc})") from exc
+        if not isinstance(reply, dict):
+            raise BenchClientError(f"{self.address}: reply was not a JSON object")
+        if reply.get("status") != "ok":
+            raise BenchClientError(str(reply.get("error") or reply))
+        result = reply.get("result")
+        return result if isinstance(result, dict) else {"value": result}
+
+    # ── the three requests ───────────────────────────────────────────────
+
+    def describe(self, timeout_ms: int | None = None) -> dict[str, Any]:
+        """The agent's self-description (kind, version, home, commands)."""
+        return self.request({"type": "describe"}, timeout_ms)
+
+    def ping(self, timeout_ms: int = 2000) -> bool:
+        """Whether a bench agent answers at the address."""
+        try:
+            return self.describe(timeout_ms).get("kind") == "plesty-server-agent"
+        except BenchClientError:
+            return False
+
+    def exec(self, argv: Sequence[str], timeout_ms: int | None = None) -> ExecResult:
+        """Run ``plesty-server <argv>`` on the bench and return what it produced.
+
+        The result carries the exit code; it does not raise on a non-zero
+        exit, only when the agent could not run the command at all.
+        """
+        result = self.request(
+            {"type": "exec", "argv": [str(a) for a in argv]},
+            self.timeout_ms if timeout_ms is None else timeout_ms,
+        )
+        return ExecResult(
+            argv=tuple(str(a) for a in argv),
+            code=int(result.get("code", -1)),
+            stdout=str(result.get("stdout", "")),
+            stderr=str(result.get("stderr", "")),
+        )
+
+    def fetch(self, path: str, timeout_ms: int | None = None) -> bytes:
+        """Download a file from the bench home (``path`` relative to it)."""
+        result = self.request({"type": "fetch", "path": path}, timeout_ms)
+        return base64.b64decode(str(result.get("data", "")))
+
+    # ── conveniences ─────────────────────────────────────────────────────
+
+    def follow(
+        self,
+        job_id: str,
+        sink: Callable[[str], None],
+        poll_s: float = 0.5,
+        timeout_s: float | None = None,
+    ) -> int:
+        """Stream the log of *job_id* to *sink* until the job ends; returns its exit code.
+
+        Uses ``jobs log <id> --offset N --json`` on the bench, so nothing is
+        held open between polls and a lost connection just resumes.
+
+        Raises:
+            BenchClientError: When the job is unknown or the bench stops answering.
+        """
+        offset = 0
+        deadline = None if timeout_s is None else time.monotonic() + timeout_s
+        while True:
+            result = self.exec(["jobs", "log", job_id, "--offset", str(offset), "--json"])
+            if not result.ok:
+                raise BenchClientError(
+                    result.stderr.strip() or result.stdout.strip() or "jobs log failed"
+                )
+            chunk = result.json()
+            text = str(chunk.get("text", ""))
+            if text:
+                sink(text)
+            offset = int(chunk.get("offset", offset))
+            if not chunk.get("running", False):
+                code = chunk.get("returncode")
+                return int(code) if code is not None else -1
+            if deadline is not None and time.monotonic() >= deadline:
+                raise BenchClientError(f"{job_id}: still running after {timeout_s} s")
+            time.sleep(poll_s)

plesty_bench-0.2.0.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.5
+Name: plesty-bench
+Version: 0.2.0
+Summary: Client for a PLESTY bench running plesty-server: run its commands and fetch its reports from another machine.
+Author-email: Yunshuang Yuan <yuanyunshuang@gmail.com>
+Maintainer-email: Plesty Development Team <plesty.dev@example.com>
+License-Expression: LGPL-3.0-or-later
+License-File: LICENSE
+License-File: LICENSES/LGPL-3.0-or-later.txt
+Requires-Python: >=3.12
+Requires-Dist: click>=8.1
+Requires-Dist: pyzmq>=26
+Provides-Extra: gui
+Requires-Dist: plesty-lib>=0.3.3; extra == 'gui'
+Requires-Dist: plesty-lib[gui]>=0.3.3; extra == 'gui'
+Requires-Dist: pyyaml>=6.0; extra == 'gui'
+Provides-Extra: server
+Requires-Dist: plesty-lib>=0.3.3; extra == 'server'
+Requires-Dist: pyyaml>=6.0; extra == 'server'
+Description-Content-Type: text/markdown
+
+# plesty-server
+
+The bench PC's own console for the PLESTY platform: installs hub device
+modules (several versions side by side), launches and supervises their device
+servers, runs field tests against the instruments, and keeps the logs — so
+running the platform on a lab bench is no longer hand work.
+
+Two deliverables from one repository:
+
+- **`plesty.server`** — the bench application (CLI `plesty-server`, Qt
+  console `plesty-server-gui`, agent), on PyPI as **`plesty-server`**:
+  `uv tool install "plesty-server[gui]"` — or the light installers from the
+  [releases](https://gitlab.com/plesty/core/plesty-bench/-/releases) (Windows
+  `setup.exe`; `install.sh` for macOS/Linux), which do exactly that plus the
+  Start-menu / Launchpad entry.
+- **`plesty.bench`** — the remote client, on PyPI as **`plesty-bench`**
+  (`uv tool install plesty-bench`). The CLI is the API:
+  `plesty-bench -b lab-bench-03 field-test pm100d` runs it on the bench and
+  follows the job.
+
+Built as model – services – presenter – view, with one module (`host`) for
+everything that differs between Windows and POSIX. See `docs/` for the
+architecture, the process-management and cross-platform primers, the console
+and the remote loop.

plesty_bench-0.2.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+plesty/bench/__init__.py,sha256=43t_V0pMSf-5-7zhG1kUmQ1K0i98TEATYpmAEcHk0iU,1589
+plesty/bench/cli.py,sha256=zs6D4TAyqSJX-JKXhvYZG7q0mfjPU0PcHXdZYToKvyM,4308
+plesty/bench/client.py,sha256=S4DSKRhPDMD5TqnNmAdDMQ_TtIjQMICgaAJiviesntw,9581
+plesty_bench-0.2.0.dist-info/METADATA,sha256=v8Qx2DyxGt_gQUHjdrkfr6_jtRn_AbfBDqS-6_T99CU,2034
+plesty_bench-0.2.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+plesty_bench-0.2.0.dist-info/entry_points.txt,sha256=TmywRL2LSZ0Z8RvgjKdUmugtRIIqYRgPUdq5yrU6gq8,55
+plesty_bench-0.2.0.dist-info/licenses/LICENSE,sha256=u-tB81VfiXPInSOlocR38N9_gBIK-bBsjXpgh3sWMvc,8434
+plesty_bench-0.2.0.dist-info/licenses/LICENSES/LGPL-3.0-or-later.txt,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+plesty_bench-0.2.0.dist-info/RECORD,,

plesty_bench-0.2.0.dist-info/WHEEL

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

plesty_bench-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+plesty-bench = plesty.bench.cli:main

plesty_bench-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,184 @@
+Copyright (C) 2026 Plesty Development Team
+
+This file is part of Plesty.
+
+Plesty is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+Plesty is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with Plesty. If not, see <https://www.gnu.org/licenses/> or the copy below.
+
+#########################################################################
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

plesty_bench-0.2.0.dist-info/licenses/LICENSES/LGPL-3.0-or-later.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.