iperf3-lib 0.1.0__py3-none-any.whl

iperf3_lib/__init__.py

@@ -0,0 +1,8 @@
+"""Top-level package for iperf3-lib: modern Python wrapper for iperf3 using cffi."""
+
+from .config import ClientConfig, Protocol
+from .iperf_client import Client
+from .iperf_server import Server
+from .result import Result
+
+__all__ = ["Client", "ClientConfig", "Protocol", "Result", "Server"]

iperf3_lib/capabilities.py

@@ -0,0 +1,28 @@
+"""Feature detection for optional libiperf capabilities."""
+
+from __future__ import annotations
+
+from .ffi import api
+
+
+def has_symbol(name: str) -> bool:
+    """Check if the loaded libiperf exposes a given symbol.
+
+    Args:
+        name: The symbol name to check.
+
+    Returns:
+        True if the symbol exists, False otherwise.
+    """
+    try:
+        return hasattr(api.lib, name)
+    except Exception:
+        return False
+
+
+# Common optional features
+HAS_BIDIR = has_symbol("iperf_set_test_bidirectional")
+HAS_MPTCP = has_symbol("iperf_set_test_mptcp")
+HAS_JSON_OUTPUT = has_symbol("iperf_set_test_json_output")
+
+__all__ = ["has_symbol", "HAS_BIDIR", "HAS_MPTCP", "HAS_JSON_OUTPUT"]

iperf3_lib/config.py

@@ -0,0 +1,33 @@
+"""Configuration models and enums for iperf3 client and server."""
+
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import BaseModel, Field, IPvAnyAddress, NonNegativeInt, PositiveInt
+
+
+class Protocol(str, Enum):
+    """Supported protocols for iperf3 tests."""
+
+    TCP = "tcp"
+    UDP = "udp"
+    SCTP = "sctp"  # requires kernel+lib support
+
+
+class ClientConfig(BaseModel):
+    """Configuration for an iperf3 client run."""
+
+    server: str | IPvAnyAddress
+    port: PositiveInt = 5201
+    protocol: Protocol = Protocol.TCP
+    duration: PositiveInt = 10
+    parallel: PositiveInt = 1
+    omit: NonNegativeInt = 0
+    reverse: bool = False
+    bidirectional: bool = False  # --bidir (>= 3.7)
+    mptcp: bool = False  # (>= 3.19, Linux)
+    blksize: PositiveInt | None = None  # --blksize
+    rate: int | None = None  # numeric rate alias (bits/sec) - canonical for lib API
+    tos: int | None = Field(default=None, ge=0, le=255)
+    json_stream: bool = False  # if lib supports streaming JSON chunks

iperf3_lib/exceptions.py

@@ -0,0 +1,13 @@
+"""Custom exceptions for iperf3-lib errors and unsupported features."""
+
+
+class IperfError(RuntimeError):
+    """libiperf reported a runtime error (i_errno/iperf_strerror)."""
+
+
+class IperfLibraryError(RuntimeError):
+    """Failed to create or use libiperf objects (allocation/dlopen issues)."""
+
+
+class UnsupportedFeatureError(RuntimeError):
+    """Requested feature is not supported by the loaded libiperf."""

iperf3_lib/ffi/__init__.py

@@ -0,0 +1 @@
+"""FFI subpackage for low-level libiperf bindings."""

iperf3_lib/ffi/api.py

@@ -0,0 +1,38 @@
+"""FFI bindings and dynamic loading for libiperf."""
+
+from __future__ import annotations
+
+import os
+from typing import Final
+
+from cffi import FFI
+
+from .symbols import CDEF
+
+POSSIBLE_NAMES: Final[tuple[str, ...]] = (
+    "libiperf.so",
+    "libiperf.so.0",  # Linux common soname
+    "libiperf.dylib",  # macOS
+    "iperf3.dll",
+    "libiperf.dll",  # Windows (if available)
+)
+
+ffi = FFI()
+ffi.cdef(CDEF)
+
+
+def _dlopen():
+    # Prefer a clearer env var key for package consumers
+    path = os.getenv("IPERF3_LIB")
+    if path:
+        return ffi.dlopen(path)
+    last_err: Exception | None = None
+    for name in POSSIBLE_NAMES:
+        try:
+            return ffi.dlopen(name)
+        except OSError as e:  # noqa: PERF203 - ok in a tiny loop
+            last_err = e
+    raise OSError(f"Could not load libiperf. Tried {POSSIBLE_NAMES}. Last error: {last_err}")
+
+
+lib = _dlopen()

iperf3_lib/ffi/symbols.py

@@ -0,0 +1,38 @@
+"""CFFI symbol definitions for libiperf API."""
+
+CDEF = r"""
+typedef struct iperf_test iperf_test;
+
+/* lifecycle */
+iperf_test *iperf_new_test(void);
+int iperf_defaults(iperf_test *t);
+void iperf_free_test(iperf_test *t);
+
+/* params */
+void iperf_set_test_role(iperf_test *t, char role); /* 'c' or 's' */
+void iperf_set_test_server_hostname(iperf_test *t, char *server_host);
+void iperf_set_test_server_port(iperf_test *t, int port);
+void iperf_set_test_duration(iperf_test *t, int seconds);
+void iperf_set_test_num_streams(iperf_test *t, int n);
+void iperf_set_test_blksize(iperf_test *t, int bytes);
+void iperf_set_test_tos(iperf_test *t, int tos);
+void iperf_set_test_omit(iperf_test *t, int seconds);
+void iperf_set_test_reverse(iperf_test *t, int on);
+
+/* optional / feature gated (may not exist on older libs) */
+void iperf_set_test_json_output(iperf_test *t, int on);
+void iperf_set_test_json_stream(iperf_test *t, int on);
+void iperf_set_test_bidirectional(iperf_test *t, int on);
+void iperf_set_test_json_stream_full_output(iperf_test *t, int on);
+void iperf_set_test_rate(iperf_test *t, unsigned long long rate);
+
+/* run/reset */
+int iperf_run_client(iperf_test *t);
+int iperf_run_server(iperf_test *t);
+void iperf_reset_test(iperf_test *t);
+
+/* output / errors */
+char *iperf_get_test_json_output_string(iperf_test *t);
+extern int i_errno;
+char *iperf_strerror(int);
+"""

iperf3_lib/iperf_client.py

@@ -0,0 +1,148 @@
+"""Client wrapper and helpers for running iperf3 client tests."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import Callable
+from functools import partial
+
+from .config import ClientConfig, Protocol
+from .exceptions import IperfError, IperfLibraryError, UnsupportedFeatureError
+from .ffi.api import ffi, lib
+from .result import EndStats, Result, SumStats
+
+
+def _check(ret: int) -> None:
+    """Raise IperfError if the return code is negative."""
+    if ret < 0:
+        err = lib.iperf_strerror(lib.i_errno)
+        msg = ffi.string(err).decode() if err != ffi.NULL else "unknown libiperf error"
+        raise IperfError(msg)
+
+
+def _set_str(setter: Callable, t, s: str) -> None:
+    """Call a CFFI string setter with a Python string argument."""
+    setter(t, ffi.new("char[]", s.encode()))
+
+
+def _try_set(sym: str) -> Callable | None:
+    """Return a lib function if it exists, else None."""
+    try:
+        return getattr(lib, sym)
+    except AttributeError:
+        return None
+
+
+def _maybe_set(setter_name: str, t, value: int) -> bool:
+    """Try to set a value using a setter if available; return True if set."""
+    fn = _try_set(setter_name)
+    if fn:
+        fn(t, int(value))
+        return True
+    return False
+
+
+class Client:
+    """Client for running iperf3 tests using the provided configuration."""
+
+    def __init__(self, cfg: ClientConfig):
+        """Initialize the client with a configuration object."""
+        self.cfg = cfg
+
+    def run(self) -> Result:
+        """Run the iperf3 test synchronously and return the result."""
+        t = lib.iperf_new_test()
+        if t == ffi.NULL:
+            raise IperfLibraryError("iperf_new_test failed")
+        try:
+            _check(lib.iperf_defaults(t))
+            lib.iperf_set_test_role(t, b"c")
+            _set_str(lib.iperf_set_test_server_hostname, t, str(self.cfg.server))
+            lib.iperf_set_test_server_port(t, int(self.cfg.port))
+            lib.iperf_set_test_duration(t, int(self.cfg.duration))
+            if self.cfg.omit:
+                lib.iperf_set_test_omit(t, int(self.cfg.omit))
+            if self.cfg.parallel and self.cfg.parallel > 1:
+                lib.iperf_set_test_num_streams(t, int(self.cfg.parallel))
+            if self.cfg.blksize:
+                lib.iperf_set_test_blksize(t, int(self.cfg.blksize))
+            if self.cfg.tos is not None:
+                lib.iperf_set_test_tos(t, int(self.cfg.tos))
+
+            # reverse / bidirectional
+            if self.cfg.reverse:
+                lib.iperf_set_test_reverse(t, 1)
+            if self.cfg.bidirectional:
+                if not _maybe_set("iperf_set_test_bidirectional", t, 1):
+                    raise UnsupportedFeatureError("Bidirectional not supported by this libiperf")
+
+            # mptcp
+            if self.cfg.mptcp:
+                if not _maybe_set("iperf_set_test_mptcp", t, 1):
+                    raise UnsupportedFeatureError("MPTCP not supported by this libiperf")
+
+            # protocol-specific (UDP bitrate is optional setter name)
+            if self.cfg.protocol == Protocol.UDP:
+                # Numeric `rate` (bits per second) is the canonical lib API.
+                # Only support numeric rate in the lib backend; tests and
+                # callers should provide `rate: int`. If rate is absent,
+                # do not attempt to set bitrate on the lib path.
+                rate = getattr(self.cfg, "rate", None)
+                if rate is not None:
+                    try:
+                        rate_bps = int(rate)
+                    except (TypeError, ValueError) as exc:
+                        raise IperfError(f"invalid rate value: {rate}") from exc
+
+                    # some libs expose iperf_set_test_bitrate, others expose
+                    # a more generic iperf_set_test_rate; accept either.
+                    fn = _try_set("iperf_set_test_bitrate") or _try_set("iperf_set_test_rate")
+                    if fn is None:
+                        raise UnsupportedFeatureError(
+                            "This lib lacks 'iperf_set_test_bitrate' or 'iperf_set_test_rate'"
+                        )
+                    # pass integer value to the C API
+                    fn(t, rate_bps)
+
+            # ensure JSON output
+            if not _maybe_set("iperf_set_test_json_output", t, 1):
+                # some extremely old libs may lack JSON setter; we rely on JSON for parsing
+                raise UnsupportedFeatureError("This libiperf lacks JSON output support")
+
+            _check(lib.iperf_run_client(t))
+            cjson = lib.iperf_get_test_json_output_string(t)
+            if cjson != ffi.NULL:
+                raw = json.loads(ffi.string(cjson).decode())
+                end = raw.get("end", {})
+
+                # minimal typed mapping into Result
+                def _sum(d) -> SumStats | None:
+                    if not d:
+                        return None
+                    return SumStats.model_validate(
+                        {
+                            "bits_per_second": d.get("bits_per_second", 0.0),
+                            "retransmits": d.get("retransmits"),
+                            "lost_percent": d.get("lost_percent"),
+                            "jitter_ms": d.get("jitter_ms"),
+                        }
+                    )
+
+                end_model = EndStats(
+                    sum_sent=_sum(end.get("sum_sent")),
+                    sum_received=_sum(end.get("sum_received")),
+                )
+                return Result(ok=True, raw=raw, end=end_model)
+            return Result(ok=False, error="No JSON returned by libiperf")
+        except IperfError as e:
+            return Result(ok=False, error=str(e))
+        finally:
+            lib.iperf_free_test(t)
+
+    async def arun(self) -> Result:
+        """Run the iperf3 test asynchronously and return the result."""
+        loop = asyncio.get_running_loop()
+        # use functools.partial to provide a zero-arg callable so static analyzers
+        # don't complain about unfilled *args parameter on run_in_executor
+        return await loop.run_in_executor(None, partial(self.run))

iperf3_lib/iperf_server.py

@@ -0,0 +1,100 @@
+"""Server wrapper and helpers for running iperf3 server tests."""
+
+from __future__ import annotations
+
+import asyncio
+import threading
+from collections.abc import Callable
+from functools import partial
+from typing import Any
+
+from .exceptions import IperfError, IperfLibraryError
+from .ffi.api import ffi, lib
+
+
+def _check(ret: int) -> None:
+    """Raise IperfError if the return code is negative."""
+    if ret < 0:
+        err = lib.iperf_strerror(lib.i_errno)
+        msg = ffi.string(err).decode() if err != ffi.NULL else "unknown libiperf error"
+        raise IperfError(msg)
+
+
+def _set_str(setter: Callable[..., Any], t: Any, s: str) -> None:
+    """Call a CFFI string setter with a Python string argument."""
+    setter(t, ffi.new("char[]", s.encode()))
+
+
+class Server:
+    """Minimal server wrapper. By default, it runs a single test, then returns.
+
+    For a persistent loop, call serve_forever().
+    """
+
+    def __init__(self, port: int = 5201, bind_host: str | None = None):
+        """Initialize the server with a port and optional bind host."""
+        self.port = port
+        self.bind_host = bind_host
+        # event used to cooperatively stop the serve_forever loop
+        self._stop_event = threading.Event()
+
+    def _run_iteration(self, t: Any) -> None:
+        """Run a single server iteration against an existing iperf_test `t`.
+
+        Extracted from the loop in `serve_forever` to make testing easier.
+        """
+        _check(lib.iperf_run_server(t))
+        lib.iperf_reset_test(t)
+
+    def run_once(self) -> None:
+        """Run the server for a single test and return."""
+        t = lib.iperf_new_test()
+        if t == ffi.NULL:
+            raise IperfLibraryError("iperf_new_test failed")
+        try:
+            _check(lib.iperf_defaults(t))
+            lib.iperf_set_test_role(t, b"s")
+            lib.iperf_set_test_server_port(t, int(self.port))
+            if self.bind_host:
+                _set_str(lib.iperf_set_test_server_hostname, t, self.bind_host)
+            # single iteration
+            self._run_iteration(t)
+        finally:
+            lib.iperf_free_test(t)
+
+    def serve_forever(self) -> None:
+        """Run the server loop until `stop()` is called.
+
+        This method creates a single iperf_test and reuses it across iterations.
+        The loop checks a threading.Event to allow cooperative shutdown.
+        """
+        t = lib.iperf_new_test()
+        if t == ffi.NULL:
+            raise IperfLibraryError("iperf_new_test failed")
+        try:
+            _check(lib.iperf_defaults(t))
+            lib.iperf_set_test_role(t, b"s")
+            lib.iperf_set_test_server_port(t, int(self.port))
+            if self.bind_host:
+                _set_str(lib.iperf_set_test_server_hostname, t, self.bind_host)
+            while not self._stop_event.is_set():
+                try:
+                    self._run_iteration(t)
+                except IperfError:
+                    # If stop() has been requested, suppress errors caused by
+                    # the socket being closed during shutdown. Otherwise
+                    # re-raise to surface unexpected server errors.
+                    if self._stop_event.is_set():
+                        break
+                    raise
+        finally:
+            lib.iperf_free_test(t)
+
+    async def aserve_once(self) -> None:
+        """Run the server for a single test asynchronously."""
+        loop = asyncio.get_running_loop()
+        await loop.run_in_executor(None, partial(self.run_once))
+
+    def stop(self) -> None:
+        """Signal the serve_forever loop to stop."""
+        self._stop_event.set()

iperf3_lib/result.py

@@ -0,0 +1,42 @@
+"""Result and statistics models for iperf3 test runs."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class SumStats(BaseModel):
+    """Summary statistics for a test direction (sent/received)."""
+
+    bits_per_second: float = Field(0, alias="bits_per_second")
+    retransmits: int | None = None
+    lost_percent: float | None = None
+    jitter_ms: float | None = None
+
+
+class EndStats(BaseModel):
+    """End-of-test statistics for both directions."""
+
+    sum_sent: SumStats | None = None
+    sum_received: SumStats | None = None
+
+
+class Result(BaseModel):
+    """Top-level result object for an iperf3 test run."""
+
+    ok: bool
+    error: str | None = None
+    raw: dict[str, Any] = {}
+    end: EndStats | None = None
+
+    @property
+    def summary_mbps(self) -> float:
+        """Return the summary throughput in Mbps, or 0.0 if unavailable."""
+        if not self.end:
+            return 0.0
+        for part in (self.end.sum_sent, self.end.sum_received):
+            if part and part.bits_per_second:
+                return part.bits_per_second / 1_000_000.0
+        return 0.0

iperf3_lib-0.1.0.dist-info/METADATA

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: iperf3-lib
+Version: 0.1.0
+Summary: Modern Python wrapper for iperf3 using cffi (libiperf), with async support.
+Project-URL: Homepage, https://github.com/dariuszpanas/iperf3-lib
+Project-URL: Documentation, https://github.com/dariuszpanas/iperf3-lib/tree/main/docs
+Project-URL: Repository, https://github.com/dariuszpanas/iperf3-lib
+Project-URL: Issues, https://github.com/dariuszpanas/iperf3-lib/issues
+Author: Dariusz Panas
+License-Expression: MIT
+License-File: LICENSE
+Keywords: MPTCP,SCTP,async,benchmark,cffi,iperf3,network,throughput
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: System :: Benchmark
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.12
+Requires-Dist: cffi>=1.16
+Requires-Dist: pydantic>=2.8
+Description-Content-Type: text/markdown
+
+# iperf3-lib
+
+Modern Python wrapper for **iperf3** using **cffi** against **libiperf**.  
+- Typed configs/results (Pydantic)
+- Sync + Async APIs
+- Feature detection for SCTP / bidirectional / MPTCP (when lib supports it)
+- Ready for `uv` workflows, ruff/ty/pytest
+
+## Quickstart
+
+```bash
+# create env & install
+uv venv
+source .venv/bin/activate
+uv pip install -e ".[dev]"
+```
+
+You need a system libiperf (install iperf3 via your package manager).
+To point to a non-standard library path:
+
+```bash
+export IPERF3_LIB=/usr/local/lib/libiperf.so
+```
+
+```python
+from iperf3_lib.config import ClientConfig, Protocol
+from iperf3_lib.iperf_client import Client
+
+cfg = ClientConfig(server="127.0.0.1", duration=2, protocol=Protocol.TCP, parallel=2)
+res = Client(cfg).run()
+print("OK:", res.ok, "Mbps:", f"{res.summary_mbps:.2f}", "err:", res.error)
+```
+Notes
+* Full features require a recent libiperf (iperf3 ≥ 3.19.x recommended).
+* Some symbols may not exist on older builds; we detect and degrade gracefully.
+* Integration tests are marked with @pytest.mark.integration.
+
+---
+
+## Running tests
+
+- Run tests locally with Docker (recommended for Windows):
+
+```bash
+# build the test image (pick python base and iperf version if needed)
+docker build --build-arg PYTHON_BASE=python:3.12-slim --build-arg IPERF3_VERSION=3.20 -t py-iperf3-test .
+
+# run the full test suite inside the container (mounted volume allows editing without rebuilding)
+docker run --rm -v "$(pwd):/app" py-iperf3-test bash -c "pytest -vv --cov=src --cov-report=term-missing"
+```
+
+- Quick single-test run (example):
+
+```bash
+docker run --rm -v "$(pwd):/app" py-iperf3-test bash -c "pytest -q tests/test_client_integration_configs.py::test_client_various_configs\[udp_rate\] -vv"
+```
+
+Notes about optional features
+- MPTCP and some other features are optional and require the libiperf to be built with kernel/header support. Tests that exercise optional features will be skipped or xfailed depending on whether the built shared object exports the required symbol.
+
+CI
+- This repository includes a GitHub Actions workflow that builds and runs the tests inside the Docker image for a matrix of Python base images and iperf versions (see `.github/workflows/ci.yml`).
+
+---
+
+```markdown
+# Changelog
+
+## 0.1.0
+- Initial release: cffi (ABI) wrapper of libiperf (client & server),
+  Pydantic models, async support, ruff/ty/pytest, CI with uv.
+
+```

iperf3_lib-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+iperf3_lib/__init__.py,sha256=2Bldlyrdgv8BTFE-CDtpaZTNcUpccuzalF-5yGj5IO0,292
+iperf3_lib/capabilities.py,sha256=U-RvwOJZ7fxbJbKwbpSgI2uqazR2xMwLW0p-rOzuCZs,691
+iperf3_lib/config.py,sha256=DA0_5BKsCncXIrUTqR8zImFehO71zlBW-6aMKxDFX2A,1027
+iperf3_lib/exceptions.py,sha256=4DL__8I-6JQAEFE3vQQ7nqLvuvZwIU-ld5w5Lp6tFzc,412
+iperf3_lib/iperf_client.py,sha256=pp-pMTGnKMD6phfAJoRaM4nQO9imVspEkhwkNsKGUp8,6166
+iperf3_lib/iperf_server.py,sha256=EOg2h0zYlWTKFZGDkTfVdAE9XkgCZ5OLnrA22ReDdRw,3623
+iperf3_lib/result.py,sha256=oqx6dvJRMWuzLl8byFuWHZoa2tJl3WjI_fvuNdRZdig,1138
+iperf3_lib/ffi/__init__.py,sha256=XoSMHMQjmAG3jWmwrX_nr9dWqJ_uwGGaSTNp_3onHpw,54
+iperf3_lib/ffi/api.py,sha256=vgEP9zXjOT-k1X1LCd9tQjcyZZ7WSEdwj5vsIQ8imDw,882
+iperf3_lib/ffi/symbols.py,sha256=Nj7EJHzYQsvpArPGyh_ATcNS4euYWaOdHIDS0JgMrJY,1382
+iperf3_lib-0.1.0.dist-info/METADATA,sha256=sTtrXoVuXYZibHZuyN9gXHAOEumkEvpIs2sg3muA7qQ,3669
+iperf3_lib-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+iperf3_lib-0.1.0.dist-info/licenses/LICENSE,sha256=QeJgmhetzHVJfZZkd6GkMm1jtRiX2P_GaeEKC_3b4bo,1070
+iperf3_lib-0.1.0.dist-info/RECORD,,

iperf3_lib-0.1.0.dist-info/WHEEL

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

iperf3_lib-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dariusz Panas
+
+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.