divi 0.0.1b0__py3-none-any.whl

divi/services/datapark/datapark.py

@@ -0,0 +1,91 @@
+from typing import Any, Dict
+
+from google.protobuf.json_format import MessageToDict
+from openai import NotGiven
+from openai.types.chat import ChatCompletion
+from pydantic import UUID4
+from typing_extensions import List, Mapping
+
+import divi
+from divi.evaluation.evaluator import EvaluationScore
+from divi.proto.trace.v1.trace_pb2 import ScopeSpans
+from divi.services.service import Service
+from divi.session.session import SessionSignal
+from divi.signals.trace import TraceSignal
+
+
+class DataPark(Service):
+    def __init__(self, host="localhost", port=3001):
+        super().__init__(host, port)
+        if not divi._auth:
+            raise ValueError("No auth service")
+        self.token = divi._auth.token
+
+    @property
+    def headers(self) -> Dict[str, str]:
+        return {"Authorization": f"Bearer {self.token}"}
+
+    @staticmethod
+    def strip_not_given(obj: object | None) -> object:
+        """Remove all top-level keys where their values are instances of `NotGiven`"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, Mapping):
+            return obj
+
+        return {
+            key: value
+            for key, value in obj.items()
+            if not isinstance(value, NotGiven)
+        }
+
+    def create_session(self, session: SessionSignal) -> None:
+        self.post("/api/session/", payload=session)
+
+    def upsert_traces(
+        self, session_id: UUID4, traces: list[TraceSignal]
+    ) -> None:
+        self.post(f"/api/session/{session_id}/traces", payload=traces)
+
+    def create_spans(self, trace_id: UUID4, spans: ScopeSpans) -> None:
+        self.post(f"/api/trace/{trace_id}/spans", payload=MessageToDict(spans))
+
+    def create_chat_completion(
+        self,
+        span_id: bytes,
+        trace_id: UUID4,
+        inputs: Dict[str, Any],
+        completion: ChatCompletion,
+    ) -> None:
+        hex_span_id = span_id.hex()
+        str_trace_id = str(trace_id)
+
+        self.post_concurrent(
+            {
+                "/api/v1/chat/completions/input": {
+                    "span_id": hex_span_id,
+                    "data": self.strip_not_given(inputs),
+                },
+                "/api/v1/chat/completions": {
+                    "span_id": hex_span_id,
+                    "trace_id": str_trace_id,
+                    "data": completion.model_dump(),
+                },
+            }
+        )
+
+    def create_scores(
+        self,
+        span_id: bytes,
+        trace_id: UUID4,
+        scores: List[EvaluationScore],
+    ) -> None:
+        self.post(
+            "/api/v1/chat/completions/scores",
+            payload={
+                "span_id": span_id.hex(),
+                "trace_id": str(trace_id),
+                "data": [score.model_dump() for score in scores],
+            },
+        )

divi/services/datapark/init.py

@@ -0,0 +1,21 @@
+import os
+
+from typing_extensions import Optional
+
+from divi.services.datapark import DataPark
+
+DIVI_DATAPARK_HOST = "DIVI_DATAPARK_HOST"
+DIVI_DATAPARK_PORT = "DIVI_DATAPARK_PORT"
+
+
+def init_datapark(
+    host: Optional[str] = None, port: Optional[int] = None
+) -> DataPark:
+    host = (
+        host
+        if host
+        else os.getenv(DIVI_DATAPARK_HOST, "datapark.divine-agent.com")
+    )
+    port = port if port else int(os.getenv(DIVI_DATAPARK_PORT, 80))
+
+    return DataPark(host=host, port=port)

divi/services/finish.py

@@ -0,0 +1,9 @@
+import divi
+from divi.services.core import finish as clean_up_core
+
+
+def finish():
+    clean_up_core()
+    divi._auth = None
+    divi._core = None
+    divi._datapark = None

divi/services/init.py

@@ -0,0 +1,10 @@
+import divi
+from divi.services.auth import init_auth
+from divi.services.datapark import init_datapark
+
+
+def init_services():
+    if not divi._auth:
+        divi._auth = init_auth()
+    if not divi._datapark:
+        divi._datapark = init_datapark()

divi/services/service.py

@@ -0,0 +1,54 @@
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, Mapping, Sequence
+
+import requests
+
+
+class Service:
+    """Service management class."""
+
+    def __init__(self, host: str, port: int):
+        self.host = host
+        self.port = port
+
+    @property
+    def target(self) -> str:
+        """Return the target string: host:port."""
+        return f"{self.host}:{self.port}"
+
+    @property
+    def headers(self) -> Dict[str, str]:
+        """Override to provide default headers."""
+        return {}
+
+    def post(
+        self,
+        path: str,
+        payload: Mapping[str, Any] | Sequence[Mapping[str, Any]],
+    ) -> Any:
+        response = requests.post(
+            f"http://{self.target}{path}",
+            json=payload,
+            headers=self.headers,
+        )
+        if not 200 <= response.status_code < 300:
+            raise ValueError(
+                f"{path} failed: {response.json().get('message', 'Unknown error')}"
+            )
+        return response.json().get("data", response.json())
+
+    def post_concurrent(
+        self,
+        calls: Dict[str, Mapping[str, Any] | Sequence[Mapping[str, Any]]],
+    ) -> None:
+        with ThreadPoolExecutor(max_workers=len(calls)) as executor:
+            futures = [
+                executor.submit(
+                    self.post,
+                    path,
+                    payload,
+                )
+                for path, payload in calls.items()
+            ]
+            for future in futures:
+                future.result()

divi/session/__init__.py

@@ -0,0 +1,3 @@
+from .session import Session, SessionExtra
+
+__all__ = ["Session", "SessionExtra"]

divi/session/session.py

@@ -0,0 +1,40 @@
+from typing import Optional, TypedDict
+from uuid import uuid4
+
+from divi.signals.trace import Trace
+
+
+class SessionExtra(TypedDict, total=False):
+    """Extra information for Session"""
+
+    session_name: Optional[str]
+    """Name of the session"""
+    trace: Trace
+    """Trace in session"""
+    parent_span_id: Optional[bytes]
+    """Parent Span ID fixed string(8)"""
+
+
+class SessionSignal(TypedDict):
+    """Session request"""
+
+    id: str
+    """Session ID UUID4"""
+    name: Optional[str]
+    """Session name"""
+
+
+class Session:
+    def __init__(
+        self,
+        name: Optional[str] = None,
+    ):
+        self.id = uuid4()
+        self.name = name
+
+    @property
+    def signal(self) -> SessionSignal:
+        return SessionSignal(
+            id=str(self.id),
+            name=self.name,
+        )

divi/session/setup.py

@@ -0,0 +1,48 @@
+from typing_extensions import Optional
+
+import divi
+from divi.services import init_services
+from divi.session import Session, SessionExtra
+from divi.signals.span import Span
+from divi.signals.trace import Trace
+
+
+def init_session(name: Optional[str] = None) -> Session:
+    """init initializes the services and the Run"""
+    init_services()
+    session = Session(name=name)
+    if divi._datapark:
+        divi._datapark.create_session(session.signal)
+    return session
+
+
+def setup(
+    span: Span,
+    session_extra: SessionExtra | None,
+):
+    """setup trace
+
+    Args:
+        span (Span): Span instance
+        session_extra (SessionExtra | None): Extra information from user input
+    """
+    session_extra = session_extra or SessionExtra()
+
+    # init the session if not already initialized
+    if not divi._session:
+        divi._session = init_session(
+            name=session_extra.get("session_name") or span.name
+        )
+
+    # setup trace
+    trace = session_extra.get("trace") or Trace(divi._session.id, span.name)
+    parent_span_id = session_extra.get("parent_span_id")
+    span._add_node(trace.trace_id, parent_span_id)
+
+    # update the session_extra with the current trace and span
+    return SessionExtra(
+        session_name=divi._session.name,
+        trace=trace,
+        # set the parent_span_id to the current span_id
+        parent_span_id=span.span_id,
+    )

divi/session/teardown.py

@@ -0,0 +1,7 @@
+import divi
+from divi.services import finish as clean_up_services
+
+
+def teardown():
+    clean_up_services()
+    divi._session = None

divi/signals/__init__.py

@@ -0,0 +1,3 @@
+from .span import Kind
+
+__all__ = ["Kind"]

divi/signals/span.py

@@ -0,0 +1,83 @@
+import os
+import time
+from enum import Enum
+from typing import Any, Mapping, Optional
+
+from pydantic import UUID4
+
+import divi
+from divi.proto.common.v1.common_pb2 import KeyValue
+from divi.proto.trace.v1.trace_pb2 import ScopeSpans
+from divi.proto.trace.v1.trace_pb2 import Span as SpanProto
+
+
+class Kind(int, Enum):
+    """Enum for the kind of span."""
+
+    function = SpanProto.SpanKind.SPAN_KIND_FUNCTION
+    llm = SpanProto.SpanKind.SPAN_KIND_LLM
+    evaluation = SpanProto.SpanKind.SPAN_KIND_EVALUATION
+
+
+class Span:
+    def __init__(
+        self,
+        kind: Kind = Kind.function,
+        name: Optional[str] = None,
+        metadata: Optional[Mapping[str, Any]] = None,
+    ):
+        # span_id is a FixedString(8)
+        self.span_id: bytes = self._generate_span_id()
+        self.name = name
+        self.kind = kind
+        self.metadata = metadata
+        self.start_time_unix_nano: int | None = None
+        self.end_time_unix_nano: int | None = None
+
+        self.trace_id: UUID4 | None = None
+        self.parent_span_id: bytes | None = None
+
+    @property
+    def signal(self) -> SpanProto:
+        signal: SpanProto = SpanProto(
+            name=self.name,
+            span_id=self.span_id,
+            kind=SpanProto.SpanKind.Name(self.kind),
+            start_time_unix_nano=self.start_time_unix_nano,
+            end_time_unix_nano=self.end_time_unix_nano,
+            trace_id=self.trace_id.bytes if self.trace_id else None,
+            parent_span_id=self.parent_span_id,
+        )
+        signal.metadata.extend(
+            KeyValue(key=k, value=v)
+            for k, v in (self.metadata or dict()).items()
+        )
+        return signal
+
+    @classmethod
+    def _generate_span_id(cls) -> bytes:
+        return os.urandom(8)
+
+    def start(self):
+        """Start the span by recording the current time in nanoseconds."""
+        self.start_time_unix_nano = time.time_ns()
+        self.upsert_span()
+
+    def end(self):
+        """End the span by recording the end time in nanoseconds."""
+        if self.start_time_unix_nano is None:
+            raise ValueError("Span must be started before ending.")
+        self.end_time_unix_nano = time.time_ns()
+        self.upsert_span()
+
+    def _add_node(self, trace_id: UUID4, parent_id: Optional[bytes] = None):
+        """Add node for obs tree."""
+        self.trace_id = trace_id
+        self.parent_span_id = parent_id
+
+    def upsert_span(self):
+        """Upsert span with datapark."""
+        if divi._datapark and self.trace_id:
+            divi._datapark.create_spans(
+                self.trace_id, ScopeSpans(spans=[self.signal])
+            )

divi/signals/trace.py

@@ -0,0 +1,79 @@
+from datetime import UTC, datetime
+from typing import Optional
+from uuid import uuid4
+
+from pydantic import UUID4
+from typing_extensions import TypedDict
+
+import divi
+
+
+class NullTime(TypedDict, total=False):
+    """Null time"""
+
+    Time: str
+    """Time in iso format"""
+    Valid: bool
+    """Valid"""
+
+
+class TraceSignal(TypedDict, total=False):
+    """Trace request"""
+
+    id: str
+    """Trace ID UUID4"""
+    start_time: str
+    """Start time in iso format"""
+    end_time: NullTime
+    """End time in iso format"""
+    name: Optional[str]
+
+
+class Trace:
+    def __init__(self, session_id: UUID4, name: Optional[str] = None):
+        self.trace_id: UUID4 = uuid4()
+        self.start_time: str | None = None
+        self.end_time: str | None = None
+        self.name: Optional[str] = name
+        self.session_id: UUID4 = session_id
+
+        self.start()
+
+    @property
+    def signal(self) -> TraceSignal:
+        if self.start_time is None:
+            raise ValueError("Trace must be started.")
+        signal = TraceSignal(
+            id=str(self.trace_id),
+            start_time=self.start_time,
+            name=self.name,
+        )
+        if self.end_time is not None:
+            signal["end_time"] = NullTime(
+                Time=self.end_time,
+                Valid=True,
+            )
+        return signal
+
+    @staticmethod
+    def unix_nano_to_iso(unix_nano: int) -> str:
+        return datetime.utcfromtimestamp(unix_nano / 1e9).isoformat()
+
+    def start(self):
+        """Start the trace by recording the current time in nanoseconds."""
+        self.start_time = datetime.now(UTC).isoformat()
+        self.upsert_trace()
+
+    def end(self):
+        """End the trace by recording the end time in nanoseconds."""
+        if self.start_time is None:
+            raise ValueError("Span must be started before ending.")
+        self.end_time = datetime.now(UTC).isoformat()
+        self.upsert_trace()
+
+    def upsert_trace(self):
+        """Upsert trace with datapark."""
+        if divi._datapark:
+            divi._datapark.upsert_traces(
+                session_id=self.session_id, traces=[self.signal]
+            )

divi/utils.py

@@ -0,0 +1,49 @@
+import inspect
+import pathlib
+from typing import Any, Callable, Dict
+
+
+def extract_flattened_inputs(
+    func: Callable, *args: Any, **kwargs: Any
+) -> Dict[str, Any]:
+    """
+    Extracts a flat dictionary of parameter names and values from a function call.
+    Handles default values, removes 'self' and 'cls', and flattens **kwargs.
+    """
+    signature = inspect.signature(func)
+    bound_args = signature.bind_partial(*args, **kwargs)
+    bound_args.apply_defaults()
+
+    arguments = dict(bound_args.arguments)
+    arguments.pop("self", None)
+    arguments.pop("cls", None)
+
+    for param_name, param in signature.parameters.items():
+        if (
+            param.kind == inspect.Parameter.VAR_KEYWORD
+            and param_name in arguments
+        ):
+            kwarg_dict = arguments.pop(param_name)
+            if isinstance(kwarg_dict, dict):
+                arguments.update(kwarg_dict)
+
+    return arguments
+
+
+def get_server_path() -> str:
+    """Get the path to the server binary."""
+    path = pathlib.Path(__file__).parent / "bin" / "core"
+    if not path.exists():
+        raise FileNotFoundError(f"Server binary not found: {path}")
+
+    return str(path)
+
+
+def is_async(func: Callable) -> bool:
+    """Inspect function or wrapped function to see if it is async."""
+    unwrapped_func = inspect.unwrap(func)
+    return inspect.iscoroutinefunction(unwrapped_func)
+
+
+if __name__ == "__main__":
+    print(get_server_path())

divi-0.0.1b0.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: divi
+Version: 0.0.1b0
+Summary: The Agent Platform for Observability & Evaluation
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: grpcio>=1.71.0
+Requires-Dist: openai>=1.65.2
+Requires-Dist: protobuf<6.0.dev0,>=5.26.1
+Requires-Dist: pyjwt>=2.10.1
+Requires-Dist: requests>=2.32.3
+Description-Content-Type: text/markdown
+
+# Divine Agent
+
+Agent Platform for Observability • Evaluation • Playground
+
+> The project is still in the development stage. 😇

divi-0.0.1b0.dist-info/RECORD

@@ -0,0 +1,51 @@
+divi/__init__.py,sha256=Mxu0UYIKgegwUU7gTe5jMHYZ0wf3rzwtiHfHyLcTysA,486
+divi/utils.py,sha256=fXkjoyo_Lh8AZliKICOP460m0czUcNQjcEcceJbaOVA,1439
+divi/decorators/__init__.py,sha256=HkyWdC1ctTsVFucCWCkj57JB4NmwONus1d2S2dUbvs4,110
+divi/decorators/collect.py,sha256=5iUxAnbHYx4ISkFg64IK_4miGdrWgbOXLJxKz8lGIv8,1074
+divi/decorators/obs_openai.py,sha256=ouw3GYDFg6S27tcUzY0dIqz8JX_JM8IOXttzo7HK7nk,1359
+divi/decorators/observable.py,sha256=isUS3P_07wbZBj2UcRAoYNDceQTIn6zdein3-PWVsi8,2289
+divi/decorators/observe.py,sha256=I2RVsp2WQep6iTLSxkAlMP8wiRsSYiiYrxR2hJzPxcI,1211
+divi/evaluation/__init__.py,sha256=3qMHWu_zBh6FJa6-1dZZEWiAblQZurn5doa0OjGvDGs,93
+divi/evaluation/evaluate.py,sha256=lVMCw5vHGa5sJvUyhVDZ9m3Sgl4baCjWhw2OKazhvgM,1861
+divi/evaluation/evaluator.py,sha256=ulTyfSg2JXxzCCL7hRsn-EBb9UKcpQFA6rVT42mouVQ,5819
+divi/evaluation/prompts.py,sha256=4oL8K8X2-zdmTDuAetc53o7Ys_vph-eWYhPmvRKYAng,960
+divi/evaluation/scores.py,sha256=ZgSxfve-ZivX3WU4TGcgPOSpUQVMbG5a15IQNPeq_bQ,173
+divi/proto/common/v1/common.proto,sha256=Rx8wr0_tOtQ1NseTMnsav4ApD1MDALzQDBA2IvLRTU0,1775
+divi/proto/common/v1/common_pb2.py,sha256=br61OHQVAi6SI3baFcb5xJv2Xd-AZ04A19xeSjLNMXo,2442
+divi/proto/common/v1/common_pb2.pyi,sha256=LmTpFFLxHg2a_qPIdNXXwGEMkbiDcTJdarR9eC-6Fq8,2133
+divi/proto/core/health/v1/health_service.proto,sha256=y39MNiwYiSqxb_JPQI7AmPfNNtP6pbX-WKTseMkjWUM,369
+divi/proto/core/health/v1/health_service_pb2.py,sha256=PKAxy_z7lU1HrwDNIa7AFHha9i8gICCVrcEhpOM79E0,1999
+divi/proto/core/health/v1/health_service_pb2.pyi,sha256=VbYHHTcp3epUVg0lTSxo3xpG52ZGhA7KKMRL5LR5e1c,691
+divi/proto/core/health/v1/health_service_pb2_grpc.py,sha256=YmlO94d-G71YBW1XZDSbYkwnHEUe6Z7R3_KAmoDWyA0,3953
+divi/proto/metric/v1/metric.proto,sha256=YHRMLUW-MtakHuibR3PJ0s2w5KgV12kc4737iHw0DTk,585
+divi/proto/metric/v1/metric_pb2.py,sha256=uvBhyy8QpaES3Jl82yVfsGazW5654XpRnsdGlpVgIRE,1974
+divi/proto/metric/v1/metric_pb2.pyi,sha256=S7ipsojkD7QZAYefDE4b3PO99Yzc6mOdtSLxH3-b67A,1304
+divi/proto/trace/v1/trace.proto,sha256=tPRIgBZB5KOKj7AoD3NoDZvLwoiJkbLiLqW53Ah-2-0,1367
+divi/proto/trace/v1/trace_pb2.py,sha256=zMuQO5mN2xl11USHkhi0lLwBAPlYXRU_UG1r0Uu3mJg,2369
+divi/proto/trace/v1/trace_pb2.pyi,sha256=k4dHYKAusH4I-XSW9KP3maogSWdRL7hVy8HCHhqFWzM,2231
+divi/services/__init__.py,sha256=AuFqnDAhi_ZGIhEVMvTu5cUmw1tEzjQSjP6m9uB3df4,203
+divi/services/finish.py,sha256=XKPKGJ5cWd5H95G_VpIOlOZOLrcf9StoTs7ayRic2jY,173
+divi/services/init.py,sha256=uJi6Mma8XQgShwWB5HyoFXaeIw8iQy9TCMQ40vuARbk,249
+divi/services/service.py,sha256=539MhcYfMvsVGjDdu0UtYSZnL2cloaPeYeOSMl2eUy8,1532
+divi/services/auth/__init__.py,sha256=vZkOIozH_TB6CGV3IOt9NYCuj5KNHO5tfpL4YqAnZ-Y,84
+divi/services/auth/auth.py,sha256=eRcE6Kq8jbBr6YL93HCGDIoga90SoZf3ogOAKeza9WY,445
+divi/services/auth/init.py,sha256=ydwR70ue-0S5C5e3mhc8eeHzS8zphUkHGfvRGdEi-cI,624
+divi/services/auth/tokman.py,sha256=V03wcV6TEy1k9o55teDVB9JZ3Ve2cJdwzWstQhWx4BQ,1070
+divi/services/core/__init__.py,sha256=y0GAqZyYz1YuZY2PVbU3O34nldeCcZeSlkgAOUlWwGs,121
+divi/services/core/core.py,sha256=PRwPtLgrgmCrejUfKf7HJNrAhGS0paFNZ7JwDToEUAk,1264
+divi/services/core/finish.py,sha256=dIGQpVXcJY4-tKe7A1_VV3yoSHNCDPfOlUltvzvk6VI,231
+divi/services/core/init.py,sha256=s8ZnQDu4leP8XaarpXpDttnOp7bseAJCgIPRYjj8zag,1931
+divi/services/datapark/__init__.py,sha256=xDkN0GPVhVuhwMenzVnkz5qguhQIyOpbFAkS1GUe-EM,104
+divi/services/datapark/datapark.py,sha256=f-qE2kmkLAniIj9mOP3nCbI3A3qkfIUnoVekwQ5w0QE,2781
+divi/services/datapark/init.py,sha256=XcqVPQn5PytQo8b9fgLUQdRSFHug0ZQiiL56cn4fBus,506
+divi/session/__init__.py,sha256=6lYemv21VQCIHx-xIdi7BxXcPNxVdvE60--8ArReUew,82
+divi/session/session.py,sha256=QxtEezI447PbtKG2U6cxL1ACae55e8nFfTufAY8pEYI,811
+divi/session/setup.py,sha256=rC1QdCxpdCOaRXmcLEQs4Yuu5UC_aRzKSaqWRPJN4Og,1390
+divi/session/teardown.py,sha256=YiBz_3yCiljMFEofZ60VmRL5sb8WA5GT7EYF8nFznZ4,133
+divi/signals/__init__.py,sha256=wfSkkCwkRsFP4aLj8aGHk_k6Y50P5yN44WWlO3XyW18,43
+divi/signals/span.py,sha256=FQWql6ivAeXGk1HPZCsCjL5mXW6S6Nn9SmOiKH4aXik,2629
+divi/signals/trace.py,sha256=IoYeTfd6x_Xmxcp4HbFSEne0d48hol4ng2Mb_AO8hZw,2144
+divi-0.0.1b0.dist-info/METADATA,sha256=BW1GBcbxovWLvVJGoDylvomnBVaApGtJkTSgHIRBtuw,493
+divi-0.0.1b0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+divi-0.0.1b0.dist-info/licenses/LICENSE,sha256=5OJuZ4wMMEV0DgF0tofhAlS_KLkaUsZwwwDS2U_GwQ0,1063
+divi-0.0.1b0.dist-info/RECORD,,

divi-0.0.1b0.dist-info/WHEEL

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

divi-0.0.1b0.dist-info/licenses/LICENSE

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