py-understat 0.1.0__py3-none-any.whl

py_understat/__init__.py

@@ -0,0 +1,36 @@
+"""An asynchronous, typed client for Understat football statistics."""
+
+from .client import League, RetryPolicy, Season, UnderstatClient
+from .exceptions import (
+    InvalidIdentifierError,
+    PayloadValidationError,
+    RateLimitError,
+    ResourceNotFoundError,
+    UnderstatError,
+    UpstreamError,
+)
+from .models import (
+    LeagueSnapshot,
+    MatchSnapshot,
+    PlayerSnapshot,
+    TeamSnapshot,
+)
+
+__all__ = [
+    "InvalidIdentifierError",
+    "League",
+    "LeagueSnapshot",
+    "MatchSnapshot",
+    "PayloadValidationError",
+    "PlayerSnapshot",
+    "RateLimitError",
+    "ResourceNotFoundError",
+    "RetryPolicy",
+    "Season",
+    "TeamSnapshot",
+    "UnderstatClient",
+    "UnderstatError",
+    "UpstreamError",
+]
+
+__version__ = "0.1.0"

py_understat/client.py

@@ -0,0 +1,327 @@
+"""The asynchronous client and resource query API."""
+
+from __future__ import annotations
+
+import asyncio
+import re
+from dataclasses import dataclass
+from datetime import UTC, datetime
+from email.utils import parsedate_to_datetime
+from enum import StrEnum
+from importlib.metadata import PackageNotFoundError, version
+from typing import Any, Self, TypeVar
+from urllib.parse import quote
+
+import httpx
+from pydantic import ValidationError
+
+from .exceptions import (
+    InvalidIdentifierError,
+    PayloadValidationError,
+    RateLimitError,
+    ResourceNotFoundError,
+    UpstreamError,
+)
+from .models import LeagueSnapshot, MatchSnapshot, PlayerSnapshot, TeamSnapshot
+
+_BASE_URL = "https://understat.com/"
+_AJAX_HEADERS = {
+    "Accept": "application/json, text/javascript, */*; q=0.01",
+    "X-Requested-With": "XMLHttpRequest",
+}
+_SEASON_PATTERN = re.compile(r"(?P<start>\d{4})/(?P<end>\d{4})")
+_Snapshot = TypeVar(
+    "_Snapshot", LeagueSnapshot, TeamSnapshot, PlayerSnapshot, MatchSnapshot
+)
+
+
+def _package_version() -> str:
+    try:
+        return version("py-understat")
+    except PackageNotFoundError:
+        return "0.1.0"
+
+
+class League(StrEnum):
+    """The competitions available through Understat."""
+
+    EPL = "EPL"
+    LA_LIGA = "La_Liga"
+    BUNDESLIGA = "Bundesliga"
+    SERIE_A = "Serie_A"
+    LIGUE_1 = "Ligue_1"
+    RFPL = "RFPL"
+
+
+@dataclass(frozen=True, slots=True, init=False)
+class Season:
+    """A competition season represented as ``YYYY/YYYY+1``."""
+
+    start_year: int
+
+    def __init__(self, value: str) -> None:
+        match = _SEASON_PATTERN.fullmatch(value)
+        if match is None:
+            raise InvalidIdentifierError("season must use the YYYY/YYYY+1 format")
+
+        start_year = int(match["start"])
+        if int(match["end"]) != start_year + 1:
+            raise InvalidIdentifierError("season must end in the year after it starts")
+        if start_year < 2014:
+            raise InvalidIdentifierError(
+                "Understat data starts with the 2014/2015 season"
+            )
+        object.__setattr__(self, "start_year", start_year)
+
+    @property
+    def label(self) -> str:
+        """The public season label."""
+        return f"{self.start_year}/{self.start_year + 1}"
+
+    def __str__(self) -> str:
+        return self.label
+
+
+@dataclass(frozen=True, slots=True)
+class RetryPolicy:
+    """Retry configuration for transient, idempotent GET requests."""
+
+    max_attempts: int = 3
+    initial_delay: float = 0.25
+    max_delay: float = 4.0
+
+    def __post_init__(self) -> None:
+        if self.max_attempts < 1:
+            raise ValueError("max_attempts must be at least one")
+        if self.initial_delay < 0 or self.max_delay < 0:
+            raise ValueError("retry delays cannot be negative")
+
+
+_DEFAULT_RETRY_POLICY = RetryPolicy()
+
+
+class UnderstatClient:
+    """Own an asynchronous HTTP client for querying Understat data.
+
+    Use as an async context manager to deterministically release HTTP resources.
+    """
+
+    def __init__(
+        self,
+        *,
+        timeout: float | httpx.Timeout | None = 20.0,
+        retry_policy: RetryPolicy | None = None,
+        transport: httpx.AsyncBaseTransport | None = None,
+    ) -> None:
+        self._retry_policy = retry_policy or _DEFAULT_RETRY_POLICY
+        self._http = httpx.AsyncClient(
+            base_url=_BASE_URL,
+            follow_redirects=True,
+            headers={
+                **_AJAX_HEADERS,
+                "User-Agent": f"py-understat/{_package_version()} (+https://github.com/sercan/py-understat)",
+            },
+            timeout=timeout,
+            transport=transport,
+        )
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(self, *_: object) -> None:
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        """Close the underlying :class:`httpx.AsyncClient`."""
+        await self._http.aclose()
+
+    def league(self, league: League) -> _LeagueResource:
+        """Select a League resource."""
+        if not isinstance(league, League):
+            raise InvalidIdentifierError("league must be a League enum member")
+        return _LeagueResource(self, league)
+
+    def team(self, handle: str) -> _TeamResource:
+        """Select a Team resource by its exact Understat handle."""
+        _validate_team_handle(handle)
+        return _TeamResource(self, handle)
+
+    def player(self, player_id: int) -> _PlayerResource:
+        """Select a Player resource by its positive Understat ID."""
+        return _PlayerResource(self, _validate_id(player_id, "player_id"))
+
+    def match(self, match_id: int) -> _MatchResource:
+        """Select a Match resource by its positive Understat ID."""
+        return _MatchResource(self, _validate_id(match_id, "match_id"))
+
+    async def _get_snapshot(self, path: str, model: type[_Snapshot]) -> _Snapshot:
+        payload = await self._get_json(path)
+        try:
+            return model.model_validate(payload)
+        except ValidationError as error:
+            raise PayloadValidationError(
+                f"Understat returned an incompatible {model.__name__} payload"
+            ) from error
+
+    async def _get_json(self, path: str) -> dict[str, Any]:
+        response: httpx.Response | None = None
+        last_error: Exception | None = None
+
+        for attempt in range(self._retry_policy.max_attempts):
+            try:
+                response = await self._http.get(path)
+            except httpx.RequestError as error:
+                last_error = error
+                if attempt + 1 == self._retry_policy.max_attempts:
+                    break
+                await asyncio.sleep(self._backoff_delay(attempt))
+                continue
+
+            if response.status_code == 404:
+                raise ResourceNotFoundError(
+                    f"Understat has no resource at {response.request.url}"
+                )
+            if response.status_code == 429:
+                last_error = _response_error(response)
+                if attempt + 1 < self._retry_policy.max_attempts:
+                    await asyncio.sleep(self._retry_delay(response, attempt))
+                    continue
+                raise RateLimitError(
+                    "Understat rate-limited the request after retries"
+                ) from last_error
+            if response.status_code >= 500:
+                last_error = _response_error(response)
+                if attempt + 1 < self._retry_policy.max_attempts:
+                    await asyncio.sleep(self._retry_delay(response, attempt))
+                    continue
+                break
+            if response.is_error:
+                raise UpstreamError(
+                    f"Understat returned HTTP {response.status_code}"
+                ) from _response_error(response)
+
+            try:
+                payload = response.json()
+            except ValueError as error:
+                raise PayloadValidationError(
+                    "Understat returned a non-JSON response"
+                ) from error
+            if not isinstance(payload, dict):
+                raise PayloadValidationError(
+                    "Understat returned a JSON payload other than an object"
+                )
+            return payload
+
+        raise UpstreamError(
+            "Understat could not fulfill the request after retries"
+        ) from last_error
+
+    def _backoff_delay(self, attempt: int) -> float:
+        return min(
+            self._retry_policy.initial_delay * (2**attempt),
+            self._retry_policy.max_delay,
+        )
+
+    def _retry_delay(self, response: httpx.Response, attempt: int) -> float:
+        retry_after = response.headers.get("Retry-After")
+        if retry_after is None:
+            return self._backoff_delay(attempt)
+        try:
+            return min(float(retry_after), self._retry_policy.max_delay)
+        except ValueError:
+            try:
+                retry_at = parsedate_to_datetime(retry_after)
+            except TypeError, ValueError:
+                return self._backoff_delay(attempt)
+            if retry_at.tzinfo is None:
+                retry_at = retry_at.replace(tzinfo=UTC)
+            return min(
+                max(0.0, (retry_at - datetime.now(UTC)).total_seconds()),
+                self._retry_policy.max_delay,
+            )
+
+
+@dataclass(frozen=True, slots=True)
+class _LeagueResource:
+    client: UnderstatClient
+    league: League
+
+    async def get(self, season: Season | str) -> LeagueSnapshot:
+        """Retrieve the League snapshot for ``season``."""
+        normalized_season = _as_season(season)
+        return await self.client._get_snapshot(
+            f"getLeagueData/{quote(self.league.value, safe='_')}/{normalized_season.start_year}",
+            LeagueSnapshot,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class _TeamResource:
+    client: UnderstatClient
+    handle: str
+
+    async def get(self, season: Season | str) -> TeamSnapshot:
+        """Retrieve the Team snapshot for ``season``."""
+        normalized_season = _as_season(season)
+        return await self.client._get_snapshot(
+            f"getTeamData/{quote(self.handle, safe='_')}/{normalized_season.start_year}",
+            TeamSnapshot,
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class _PlayerResource:
+    client: UnderstatClient
+    player_id: int
+
+    async def get(self) -> PlayerSnapshot:
+        """Retrieve the Player snapshot."""
+        return await self.client._get_snapshot(
+            f"getPlayerData/{self.player_id}", PlayerSnapshot
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class _MatchResource:
+    client: UnderstatClient
+    match_id: int
+
+    async def get(self) -> MatchSnapshot:
+        """Retrieve the Match snapshot."""
+        return await self.client._get_snapshot(
+            f"getMatchData/{self.match_id}", MatchSnapshot
+        )
+
+
+def _as_season(value: Season | str) -> Season:
+    if isinstance(value, Season):
+        return value
+    if isinstance(value, str):
+        return Season(value)
+    raise InvalidIdentifierError("season must be a Season or YYYY/YYYY+1 string")
+
+
+def _validate_team_handle(handle: str) -> None:
+    if (
+        not isinstance(handle, str)
+        or not handle
+        or handle != handle.strip()
+        or "/" in handle
+    ):
+        raise InvalidIdentifierError(
+            "team handle must be a non-empty, exact Understat URL handle"
+        )
+
+
+def _validate_id(value: int, name: str) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or value <= 0:
+        raise InvalidIdentifierError(f"{name} must be a positive integer")
+    return value
+
+
+def _response_error(response: httpx.Response) -> httpx.HTTPStatusError:
+    try:
+        response.raise_for_status()
+    except httpx.HTTPStatusError as error:
+        return error
+    raise RuntimeError("response was expected to be an error")

py_understat/exceptions.py

@@ -0,0 +1,27 @@
+"""Exceptions raised by :mod:`py_understat`."""
+
+from __future__ import annotations
+
+
+class UnderstatError(Exception):
+    """Base class for all package-level failures."""
+
+
+class InvalidIdentifierError(UnderstatError, ValueError):
+    """A resource identifier or competition season is invalid locally."""
+
+
+class ResourceNotFoundError(UnderstatError):
+    """Understat has no resource for the requested identifier."""
+
+
+class RateLimitError(UnderstatError):
+    """Understat kept rate-limiting a request after retries."""
+
+
+class UpstreamError(UnderstatError):
+    """Understat or the network could not fulfill a request."""
+
+
+class PayloadValidationError(UnderstatError):
+    """Understat returned a payload incompatible with the public models."""

py_understat/models.py

@@ -0,0 +1,228 @@
+"""Immutable models for data published by Understat."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import date, datetime
+from types import MappingProxyType
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class SourceModel(BaseModel):
+    """Base model retaining fields added by Understat after this release."""
+
+    model_config = ConfigDict(extra="allow", frozen=True, populate_by_name=True)
+
+    @property
+    def extra(self) -> Mapping[str, Any]:
+        """Source fields not represented by a named model attribute."""
+        return MappingProxyType(self.model_extra or {})
+
+
+class TeamReference(SourceModel):
+    """A team referenced from a match."""
+
+    id: int
+    title: str
+    short_title: str | None = None
+
+
+class Score(SourceModel):
+    """A value split by home and away team."""
+
+    home: int = Field(alias="h")
+    away: int = Field(alias="a")
+
+
+class ExpectedGoals(SourceModel):
+    """Expected goals split by home and away team."""
+
+    home: float = Field(alias="h")
+    away: float = Field(alias="a")
+
+
+class Forecast(SourceModel):
+    """Pre-match home win, draw, and away win probabilities."""
+
+    home_win: float = Field(alias="w")
+    draw: float = Field(alias="d")
+    away_win: float = Field(alias="l")
+
+
+class MatchRecord(SourceModel):
+    """A match listed in a League or Team snapshot."""
+
+    id: int
+    is_result: bool = Field(alias="isResult")
+    home: TeamReference = Field(alias="h")
+    away: TeamReference = Field(alias="a")
+    goals: Score
+    expected_goals: ExpectedGoals = Field(alias="xG")
+    played_at: datetime = Field(alias="datetime")
+    forecast: Forecast
+    side: str | None = None
+    result: str | None = None
+
+
+class PlayerStatistic(SourceModel):
+    """A player's aggregate statistics for one source view."""
+
+    position: str
+    games: int
+    goals: int
+    shots: int
+    minutes: int = Field(alias="time")
+    expected_goals: float = Field(alias="xG")
+    assists: int
+    expected_assists: float = Field(alias="xA")
+    key_passes: int
+    non_penalty_goals: int = Field(alias="npg")
+    non_penalty_expected_goals: float = Field(alias="npxG")
+    expected_goals_chain: float = Field(alias="xGChain")
+    expected_goals_buildup: float = Field(alias="xGBuildup")
+    id: int | None = None
+    player_name: str | None = None
+    team_title: str | None = None
+    season: int | None = None
+    team: str | None = None
+    yellow_cards: int | None = None
+    red_cards: int | None = None
+
+
+class PlayerMatch(SourceModel):
+    """A player's statistics from one match."""
+
+    id: int
+    season: int
+    date: date
+    position: str
+    goals: int
+    shots: int
+    minutes: int = Field(alias="time")
+    expected_goals: float = Field(alias="xG")
+    assists: int
+    expected_assists: float = Field(alias="xA")
+    key_passes: int
+    non_penalty_goals: int = Field(alias="npg")
+    non_penalty_expected_goals: float = Field(alias="npxG")
+    expected_goals_chain: float = Field(alias="xGChain")
+    expected_goals_buildup: float = Field(alias="xGBuildup")
+    home_team: str = Field(alias="h_team")
+    away_team: str = Field(alias="a_team")
+
+
+class TeamHistoryRecord(SourceModel):
+    """One historical team performance used in a League snapshot."""
+
+    date: datetime
+    home_or_away: str = Field(alias="h_a")
+    result: str
+    scored: int
+    missed: int
+    expected_goals: float = Field(alias="xG")
+    expected_goals_against: float = Field(alias="xGA")
+
+
+class TeamSeason(SourceModel):
+    """A team's season data inside a League snapshot."""
+
+    id: int
+    title: str
+    history: tuple[TeamHistoryRecord, ...]
+
+
+class AgainstStatistics(SourceModel):
+    """The opponent side of one team statistic category."""
+
+    shots: int
+    goals: int
+    expected_goals: float = Field(alias="xG")
+
+
+class TeamStatistics(SourceModel):
+    """One Team statistic category, such as ``OpenPlay``."""
+
+    shots: int
+    goals: int
+    expected_goals: float = Field(alias="xG")
+    against: AgainstStatistics
+
+
+class PlayerProfile(SourceModel):
+    """The identity information Understat publishes for a player."""
+
+    id: int
+    name: str
+    favorite_position: str | None = None
+
+
+class Shot(SourceModel):
+    """One shot event."""
+
+    id: int
+    minute: int
+    result: str
+    x: float = Field(alias="X")
+    y: float = Field(alias="Y")
+    expected_goals: float = Field(alias="xG")
+    player: str
+    home_or_away: str = Field(alias="h_a")
+    player_id: int
+    situation: str
+    season: int
+    shot_type: str = Field(alias="shotType")
+    match_id: int
+    home_team: str = Field(alias="h_team")
+    away_team: str = Field(alias="a_team")
+    date: datetime
+
+
+class RosterEntry(SourceModel):
+    """A player's appearance record in a Match snapshot."""
+
+    id: int
+    player_id: int
+    team_id: int
+    player: str
+    position: str
+    minutes: int = Field(alias="time")
+    goals: int
+    expected_goals: float = Field(alias="xG")
+    assists: int
+    expected_assists: float = Field(alias="xA")
+
+
+class LeagueSnapshot(SourceModel):
+    """The complete League resource snapshot for one competition season."""
+
+    teams: Mapping[int, TeamSeason]
+    players: tuple[PlayerStatistic, ...]
+    matches: tuple[MatchRecord, ...] = Field(alias="dates")
+
+
+class TeamSnapshot(SourceModel):
+    """The complete Team resource snapshot for one competition season."""
+
+    players: tuple[PlayerStatistic, ...]
+    matches: tuple[MatchRecord, ...] = Field(alias="dates")
+    statistics: Mapping[str, Mapping[str, TeamStatistics]]
+
+
+class PlayerSnapshot(SourceModel):
+    """The complete Player resource snapshot."""
+
+    player: PlayerProfile
+    matches: tuple[PlayerMatch, ...]
+    groups: Mapping[str, Any]
+    shots: tuple[Shot, ...]
+    positions: tuple[str, ...] = Field(default=(), alias="positionsList")
+
+
+class MatchSnapshot(SourceModel):
+    """The complete Match resource snapshot."""
+
+    rosters: Mapping[str, Mapping[int, RosterEntry]]
+    shots: Mapping[str, tuple[Shot, ...]]
+    template: Mapping[str, Any] = Field(alias="tmpl")

py_understat-0.1.0.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.5
+Name: py-understat
+Version: 0.1.0
+Summary: An asynchronous client for Understat football statistics
+License-File: LICENSE
+Requires-Python: >=3.14
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.13.5
+Description-Content-Type: text/markdown
+
+# py-understat
+
+An asynchronous, typed client for football statistics published by [Understat](https://understat.com/). This is an unofficial client and is not affiliated with Understat.
+
+## Install
+
+```bash
+uv add py-understat
+```
+
+From a checkout, install the package and its development tools with:
+
+```bash
+uv sync --all-groups
+```
+
+## Query data
+
+`UnderstatClient` owns its HTTP resources. Use it as an async context manager.
+
+```python
+import asyncio
+
+from py_understat import League, UnderstatClient
+
+
+async def main() -> None:
+    async with UnderstatClient() as client:
+        premier_league = await client.league(League.EPL).get("2025/2026")
+
+    top_scorer = max(premier_league.players, key=lambda player: player.goals)
+    print(top_scorer.player_name, top_scorer.goals)
+
+
+asyncio.run(main())
+```
+
+Each `get()` call returns the complete snapshot Understat supplies for that resource:
+
+```python
+async with UnderstatClient() as client:
+    league = await client.league(League.BUNDESLIGA).get("2025/2026")
+    team = await client.team("Bayern_Munich").get("2025/2026")
+    player = await client.player(8260).get()
+    match = await client.match(28778).get()
+
+league.players  # PlayerStatistic records
+league.matches  # MatchRecord records
+league.teams  # TeamSeason records keyed by Understat team ID
+team.statistics  # Typed team statistic categories
+player.matches  # PlayerMatch records
+player.shots  # Shot records
+match.rosters  # RosterEntry records grouped by home/away side
+match.shots  # Shot records grouped by home/away side
+```
+
+## Identifiers
+
+- `League` is an enum containing Understat's six supported competitions.
+- Team queries take the exact Understat team handle, such as `"Manchester_United"`.
+- Player and Match queries take a positive Understat integer ID.
+- League and Team queries take a competition season written as `"YYYY/YYYY+1"`, for example `"2025/2026"`. `Season("2025/2026")` is available when a reusable value is useful.
+
+Invalid identifiers fail locally with `InvalidIdentifierError` before making a request.
+
+## Data and failures
+
+Known fields are normalized to native Python values: IDs and counts become `int`, expected-goal values become `float`, and source timestamps become `datetime`. Models are frozen, and source fields that the package does not yet name are available through each model's read-only `extra` mapping.
+
+The client retries temporary transport failures, `429`, and `5xx` responses with bounded exponential backoff. It honors `Retry-After` up to the configured maximum delay. Catch package-level errors rather than HTTPX implementation errors:
+
+```python
+from py_understat import RateLimitError, ResourceNotFoundError, UnderstatError
+
+try:
+    async with UnderstatClient() as client:
+        snapshot = await client.player(8260).get()
+except ResourceNotFoundError:
+    print("Unknown Understat player")
+except RateLimitError:
+    print("Understat still rate-limited the request after retries")
+except UnderstatError as error:
+    print(f"Understat is unavailable: {error}")
+```
+
+The client sends an identifying user agent. It intentionally has no automatic cache or global rate limiter; callers needing either should apply them around immutable snapshots.

py_understat-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+py_understat/__init__.py,sha256=vPYyx4R1qk_Jf_rEOZ7EoOToWFRMA5eX7X8516-0nd4,755
+py_understat/client.py,sha256=5wuLQlJeBCbU1bkEFqE6ObuLMl0zobTohA93cMCct9U,10851
+py_understat/exceptions.py,sha256=4fvkFU1kB8P21AOPpRE-v17f_-CVsk3G0cDIFO8KMeE,750
+py_understat/models.py,sha256=zRtKWBqDYWoKs5M1Ml6hKAf0rb2TtIp6lWugXmuL_fk,6084
+py_understat-0.1.0.dist-info/METADATA,sha256=RtE4GVH6kMMH7anI31b5TasoulNtqSR_v20yvpSdAHI,3492
+py_understat-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+py_understat-0.1.0.dist-info/licenses/LICENSE,sha256=-Ye8EqYK9M6k8m0N23dg1NA_6jO0_Wb1RhaYmHTvhDY,1069
+py_understat-0.1.0.dist-info/RECORD,,

py_understat-0.1.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

py_understat-0.1.0.dist-info/licenses/LICENSE

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