squoredata 0.1.0__py3-none-any.whl

squoredata/__init__.py

@@ -0,0 +1,72 @@
+"""Self-contained Squore data structures.
+
+This package encapsulates the data structures that a Squore tablet uses, as
+opposed to the surrounding server logic in the ``tcboard`` project.
+"""
+
+from .devinfo import BatteryStatus, DeviceInfo, SquoreDeviceInfo
+from .game import Game, Result, ScoresType, ScoreType
+from .livedata import (
+    InconsistentStateError,
+    LockStateType,
+    ServerType,
+    SquoreMatchLiveData,
+    TimerInfo,
+    Timing,
+    When,
+)
+from .livestatus import LiveStatus
+from .match import (
+    Clubs,
+    Colors,
+    Countries,
+    Event,
+    Format,
+    Metadata,
+    Players,
+    PlayersProps,
+    SquoreMatch,
+    Wifi,
+)
+from .point import (
+    AppealType,
+    PlayerIndex,
+    PlayerLetter,
+    Point,
+    ServerSide,
+    make_point_from_squore_line,
+)
+
+__all__ = [
+    "AppealType",
+    "BatteryStatus",
+    "Clubs",
+    "Colors",
+    "Countries",
+    "DeviceInfo",
+    "Event",
+    "Format",
+    "Game",
+    "InconsistentStateError",
+    "LiveStatus",
+    "LockStateType",
+    "Metadata",
+    "PlayerIndex",
+    "PlayerLetter",
+    "Players",
+    "PlayersProps",
+    "Point",
+    "Result",
+    "ScoreType",
+    "ScoresType",
+    "ServerSide",
+    "ServerType",
+    "SquoreDeviceInfo",
+    "SquoreMatch",
+    "SquoreMatchLiveData",
+    "TimerInfo",
+    "Timing",
+    "When",
+    "Wifi",
+    "make_point_from_squore_line",
+]

squoredata/devinfo.py

@@ -0,0 +1,68 @@
+# needed < 3.14 so that annotations aren't evaluated
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, model_validator
+
+
+class BatteryStatus(BaseModel):
+    """The battery status of a device."""
+
+    percentage: int
+    charging: bool
+
+
+class DeviceInfo(BaseModel):
+    """Base information about a device."""
+
+    deviceid: str | None = None
+    timestamp: datetime | None = None
+
+    def model_post_init(self, ctx: Any) -> None:
+        if self.timestamp is None:
+            self.timestamp = (ctx or {}).get("timestamp") or datetime.now()
+
+    @property
+    def device(self) -> str | None:
+        return self.deviceid
+
+    @property
+    def batterystatus(self) -> BatteryStatus | None:
+        return None
+
+    def debug_repr(self) -> str:
+        return str(self)
+
+    def __str__(self) -> str:
+        return self.device or "(no device ID)"
+
+    def __hash__(self) -> int:
+        return hash(self.device)
+
+
+_NONEXISTENT = object()
+
+
+class SquoreDeviceInfo(DeviceInfo):
+    """Device information as reported by a Squore tablet."""
+
+    batteryCharging: bool
+    batteryPercentage: int
+
+    @model_validator(mode="before")
+    @classmethod
+    def _rename_device(cls, data: Any) -> Any:
+        if (
+            isinstance(data, dict)
+            and (dev := data.get("device", _NONEXISTENT)) is not _NONEXISTENT
+        ):
+            data = {k: v for k, v in data.items() if k != "device"} | {"deviceid": dev}
+        return data
+
+    @property
+    def batterystatus(self) -> BatteryStatus:
+        return BatteryStatus(
+            percentage=self.batteryPercentage, charging=self.batteryCharging
+        )

squoredata/game.py

@@ -0,0 +1,39 @@
+"""Game-level data as used by Squore."""
+
+from datetime import datetime
+
+from pydantic import BaseModel, field_serializer
+
+from .point import Point
+
+type ScoreType = tuple[int, int]
+type ScoresType = list[ScoreType]
+
+# type Result = tuple[int, int]
+type Result = list[int]
+
+
+class Game(BaseModel):
+    """A single game within a match."""
+
+    score: ScoreType
+    starttime: datetime | None = None
+    endtime: datetime | None = None
+    winner: int | None = None
+    # Winner seems a redundant field, but it is not. A game could be live, i.e. ongoing,
+    # and then None means there is no winner. We could of course compute this too, but
+    # then we'd need to know the match format here. Let's keep it simple for now.
+    scoreline: list[Point] = []
+
+    @field_serializer("score", mode="plain")
+    def _score_as_list(self, value: ScoreType) -> Result:
+        # Convert the tuple to a list because otherwise json2ts generates:
+        #
+        # /**
+        #  * @minItems 2
+        #  * @maxItems 2
+        #  */
+        # export type Result = [unknown, unknown];
+        #
+        # and thus loses the typing.
+        return list(value)

squoredata/livedata.py

@@ -0,0 +1,233 @@
+"""Live match data as reported by a Squore tablet."""
+
+import itertools
+from datetime import datetime
+from typing import Any, Literal, Never
+
+from pydantic import (
+    BaseModel,
+    Field,
+    computed_field,
+    field_serializer,
+    field_validator,
+)
+
+from .game import Game, ScoresType
+from .livestatus import LiveStatus
+from .match import SquoreMatch
+from .point import PlayerLetter, Point, ServerSide, make_point_from_squore_line
+
+type ServerType = PlayerLetter
+type LockStateType = (  # src/com/doubleyellow/scoreboard/model/LockState.java
+    Literal["Unlocked"]
+    | Literal["UnlockedManual"]
+    | Literal["UnlockedEndOfFinalGame"]
+    | Literal["LockedManual"]
+    | Literal["LockedManualGUI"]
+    | Literal["LockedEndOfMatch"]
+    | Literal["LockedIdleTime"]
+    | Literal["SharedEndedMatch"]
+    | Literal["LockedEndOfMatchRetired"]
+    | Literal["LockedEndOfMatchConduct"]
+    | Literal["LockedEndOfMatchTimeBased"]
+    | None
+)
+
+
+class InconsistentStateError(Exception):
+    """The Squore state is internally inconsistent."""
+
+    def __init__(self, matchid: str, deviceid: str) -> None:
+        super().__init__(
+            f"Inconsistent Squore state (bug #120), matchid={matchid}, "
+            f"deviceid={deviceid}"
+        )
+        self.matchid = matchid
+        self.deviceid = deviceid
+
+
+class When(BaseModel, extra="forbid"):
+    """The date and time a match is scheduled for."""
+
+    date: str
+    time: str
+
+
+class Timing(BaseModel, extra="forbid"):
+    """Timing information for one game."""
+
+    start: str
+    end: str
+    offsets: list[int] | None = None
+
+
+class TimerInfo(BaseModel, extra="forbid"):
+    """Information about a running countdown timer."""
+
+    type: (
+        Literal["Warmup"]
+        | Literal["UntilStartOfFirstGame"]
+        | Literal["UntilStartOfNextGame"]
+    )
+    totalSeconds: int
+
+
+class SquoreMatchLiveData(SquoreMatch, extra="forbid"):
+    """A Squore match together with the live data reported by the tablet."""
+
+    appName: Literal["Squore"]
+    appPackage: Literal["com.doubleyellow.scoreboard"]
+    court: int | None
+    timestamp: datetime | None = None
+    customData: dict[str, Any] | None = None
+    gamescores: str | None = None
+    isGameBall: bool
+    isHandOut: bool
+    isMatchBall: bool
+    isVictoryFor: PlayerLetter | None = None
+    isUndo: bool = False
+    lastCall: str | None = None
+    lastScorer: PlayerLetter | None = None
+    liveScoreDeviceId: str
+    lockState: LockStateType = None
+    maxNrOfPowerPlays: int | None = None
+    result: str
+    score: list[list[str]] = Field(default_factory=list[list[str]])
+    server: ServerType
+    serveSide: ServerSide
+    start: str
+    timerInfo: TimerInfo | None = None
+    timing: list[Timing] = Field(default_factory=list[Timing])
+    when: When
+
+    def model_post_init(self, ctx: Any) -> None:
+        if self.timestamp is None:
+            self.timestamp = (ctx or {}).get("timestamp") or datetime.now()
+
+    @property
+    def matchid(self) -> str:
+        return self.metadata.sourceID
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def status(self) -> LiveStatus:
+        if self.timerInfo:
+            if self.timerInfo.type == "Warmup":
+                return LiveStatus.WARMUP
+
+            if self.timerInfo.type == "UntilStartOfFirstGame":
+                return LiveStatus.PREPARE
+
+            elif self.timerInfo.totalSeconds == 15:
+                return LiveStatus.FIFTEENSECONDS
+
+            return LiveStatus.BETWEENGAMES
+
+        elif self.score:
+            if self.isMatchBall:
+                return LiveStatus.MATCHBALL
+
+            elif self.isGameBall:
+                return LiveStatus.GAMEBALL
+
+            elif self.isVictoryFor:
+                return LiveStatus.FINISHED
+
+            return LiveStatus.ONGOING
+
+        return LiveStatus.READY
+
+    def nr_games_played(self) -> int:
+        return sum(int(x) for x in self.result.split("-"))
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def scores(self) -> ScoresType:
+        if self.gamescores is None:
+            return []
+
+        ret = []
+        for gscore in self.gamescores.split(","):
+            ret.append((int((s := gscore.split("-"))[0]), int(s[1])))
+        return ret
+
+    @field_serializer("scores", mode="plain")
+    def _scores_as_lists(self, value: ScoresType) -> list[list[int]]:
+        # Convert the tuples to lists for the schema, because otherwise json2ts
+        # loses the element typing and emits [unknown, unknown].
+        return [list(game) for game in value]
+
+    def _get_scoreline(
+        self, scores: list[str], offsets: list[int] | None
+    ) -> list[Point]:
+        ret: list[Point] = []
+
+        prev_offset = 0
+        for point, offset in itertools.zip_longest(scores, offsets or []):
+            ret.append(
+                make_point_from_squore_line(point, duration=offset - prev_offset)
+            )
+            prev_offset = offset
+
+        return ret
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def games(self) -> list[Game]:
+        nr_games_played = self.nr_games_played()
+        ret = []
+
+        is_cur = False
+        for i, ((a, b), points, timings) in enumerate(
+            zip(
+                self.scores,
+                self.score,
+                [t for t in self.timing if t.offsets is not None],
+                strict=True,
+            )
+        ):
+            scoreline = self._get_scoreline(points, timings.offsets)
+
+            is_cur = i == nr_games_played
+            ret.append(
+                Game(
+                    score=(a, b),
+                    starttime=datetime.fromisoformat(timings.start),
+                    endtime=None if is_cur else datetime.fromisoformat(timings.end),
+                    winner=None if is_cur else int(a < b),
+                    scoreline=scoreline,
+                )
+            )
+
+        if (
+            not is_cur
+            and self.status >= LiveStatus.READY
+            and self.status < LiveStatus.FINISHED
+        ) or (
+            len(self.timing) == 1
+            and self.timing[0].offsets is None
+            and self.score == []
+        ):
+            ret.append(Game(score=(0, 0)))
+        return ret
+
+    @computed_field  # type: ignore[prop-decorator]
+    @property
+    def winner(self) -> int | None:
+        if self.isVictoryFor is None:
+            return None
+        return {"A": 0, "B": 1}[self.isVictoryFor]
+
+    def validate_livedata(self) -> Never | None:
+        if len([t for t in self.timing if t.offsets is not None]) != len(self.scores):
+            raise InconsistentStateError(
+                matchid=self.matchid, deviceid=self.liveScoreDeviceId
+            )
+        return None
+
+    @field_validator("court", mode="before")
+    @classmethod
+    def handle_no_court_as_string(
+        cls, data: Literal["null"] | int | None
+    ) -> int | None:
+        return None if data == "null" else data

squoredata/livestatus.py

@@ -0,0 +1,63 @@
+# needed < 3.14 so that annotations aren't evaluated
+from __future__ import annotations
+
+from enum import IntEnum, auto
+
+
+class LiveStatus(IntEnum):
+    """The status of a live match, derived from the Squore live data."""
+
+    UNKNOWN = 0
+    WARMUP = auto()
+    PREPARE = auto()
+    FIFTEENSECONDS = auto()
+    READY = auto()
+    ONGOING = auto()
+    GAMEBALL = auto()
+    BETWEENGAMES = auto()
+    MATCHBALL = auto()
+    FINISHED = auto()
+    EXTERNAL = auto()
+
+    def __str__(self) -> str:
+        return self.name
+
+    @property
+    def short(self) -> str:
+        return {
+            self.UNKNOWN: "???",
+            self.WARMUP: "WUP",
+            self.PREPARE: "PRE",
+            self.READY: "RDY",
+            self.ONGOING: "ONG",
+            self.GAMEBALL: "GBL",
+            self.BETWEENGAMES: "PAU",
+            self.FIFTEENSECONDS: "15s",
+            self.MATCHBALL: "MBL",
+            self.FINISHED: "FIN",
+            self.EXTERNAL: "EXT",
+        }[self]
+
+    def can_come_after(self, other: LiveStatus) -> bool:
+        if self == self.UNKNOWN:
+            return False
+
+        elif other < self.ONGOING:
+            return True
+
+        elif self == self.ONGOING and other in (
+            self.BETWEENGAMES,
+            self.FIFTEENSECONDS,
+            self.GAMEBALL,
+            self.MATCHBALL,
+        ):
+            return True
+
+        elif self == self.FIFTEENSECONDS and other in (
+            self.GAMEBALL,
+            self.BETWEENGAMES,
+            self.PREPARE,
+        ):
+            return True
+
+        return self >= other

squoredata/match.py

@@ -0,0 +1,84 @@
+"""The static Squore match description, i.e. a match without live data."""
+
+from typing import Literal
+
+from pydantic import BaseModel
+
+from .devinfo import SquoreDeviceInfo
+
+
+class Players(BaseModel, extra="forbid"):
+    """The names of the two players."""
+
+    A: str
+    B: str
+
+
+class PlayersProps(BaseModel, extra="forbid"):
+    """A per-player attribute, one value for each player."""
+
+    A: str | None = None
+    B: str | None = None
+
+
+class Colors(PlayersProps): ...
+
+
+class Countries(PlayersProps): ...
+
+
+class Clubs(PlayersProps): ...
+
+
+class Event(BaseModel, extra="forbid"):
+    """The event a match belongs to."""
+
+    name: str
+    division: str
+
+
+class Format(BaseModel, extra="forbid"):
+    """The scoring format of a match."""
+
+    numberOfPointsToWinGame: int = 11
+    numberOfGamesToWinMatch: int = 3
+    useHandInHandOutScoring: bool = False
+
+
+class Wifi(BaseModel, extra="forbid"):
+    """The WiFi details a device is connected to."""
+
+    ipaddress: str | None = None
+    ssid: str | None = None
+
+
+class Metadata(BaseModel, extra="forbid"):
+    """Metadata a Squore tablet attaches to a match."""
+
+    sourceID: str
+    device: SquoreDeviceInfo | None = None
+    source: str | None = None
+    version: int | None = None
+    language: str | None = None
+    wifi: Wifi | None = None
+    shareURL: str | None = None
+    sourceFeedbackState: (
+        Literal["SourceAcceptedFinalResult"] | Literal["SourceRejectedResult"] | None
+    ) = None
+    sourcePostResultUrl: str | None = None
+
+
+class SquoreMatch(BaseModel, extra="forbid"):
+    """A match as used by Squore, without any live information."""
+
+    players: Players
+    clubs: Clubs | None = None
+    colors: Colors | None = None
+    countries: Countries | None = None
+    event: Event
+    format: Format
+    metadata: Metadata
+
+    @property
+    def matchid(self) -> str:
+        return self.metadata.sourceID

squoredata/point.py

@@ -0,0 +1,109 @@
+"""Point-level data as used by Squore.
+
+The types and the parser are ported from the ``tcboard`` project so that the
+Squore data structures are self-contained.
+"""
+
+import re
+from typing import Literal
+
+from pydantic import BaseModel, TypeAdapter, ValidationError
+
+__all__ = [
+    "AppealType",
+    "PlayerIndex",
+    "PlayerLetter",
+    "Point",
+    "ServerSide",
+    "make_point_from_squore_line",
+]
+
+type PlayerLetter = Literal["A"] | Literal["B"]
+type PlayerIndex = Literal[0] | Literal[1]
+type ServerSide = Literal["L"] | Literal["R"]
+type AppealType = Literal["S"] | Literal["L"] | Literal["N"]
+
+
+class Point(BaseModel):
+    """A single point in a game."""
+
+    server: PlayerIndex | None
+    serveside: ServerSide | None
+    player: PlayerIndex
+    data: int | AppealType
+    duration: int | None = None
+
+
+PATTERN = re.compile(
+    r"(?P<AX>(?P<AS>[-RL])(?P<AP>\d+|-)|ST|[YN]L)"
+    r"(?P<BX>(?P<BS>[-RL])(?P<BP>\d+|-)|ST|[YN]L)",
+)
+
+type PointDataType = AppealType | int
+PointDataTypeValidator: TypeAdapter[PointDataType] = TypeAdapter(PointDataType)
+PlayerIndexValidator: TypeAdapter[PlayerIndex] = TypeAdapter(PlayerIndex)
+PlayerLetterValidator: TypeAdapter[PlayerLetter] = TypeAdapter(PlayerLetter)
+ServerSideValidator: TypeAdapter[ServerSide] = TypeAdapter(ServerSide)
+
+
+def make_point_from_squore_line(
+    squore: str | None, *, duration: int | None = None
+) -> Point:
+    """Parse a Squore line representation into a :class:`Point`.
+
+    Args:
+        squore: The Squore line representation, e.g. ``"R1--"``.
+        duration: The optional duration of the point in seconds.
+
+    Returns:
+        The parsed point.
+
+    Raises:
+        ValueError: If the line cannot be parsed.
+    """
+    m = None
+    if squore is not None:
+        m = re.fullmatch(PATTERN, squore)
+
+    if m is None:
+        raise ValueError(f"Not a Squore line I can parse: {squore}")
+
+    d = m.groupdict()
+
+    winner = int((a := d["AX"]) == "--")  # bool to int: True→1, False→0
+    server, side = None, None
+    data: PointDataType
+    match a, d["BX"]:
+        case ("ST", _) | (_, "ST"):
+            data = "S"
+        case ("YL", _) | (_, "YL"):
+            data = "L"
+        case ("NL", _) | (_, "NL"):
+            data = "N"
+        case _:
+            try:
+                winner = PlayerIndexValidator.validate_python(
+                    # bool to int: True→1, False→0
+                    int(d["AP"] == "-")
+                )
+                server = PlayerIndexValidator.validate_python(
+                    # bool to int: True→1, False→0
+                    int(d["AS"] == "-")
+                )
+                side = ServerSideValidator.validate_python(
+                    a if (a := d["AS"]) != "-" else d["BS"]
+                )
+                data = PointDataTypeValidator.validate_python(
+                    a if (a := d["AP"]) != "-" else d["BP"]
+                )
+
+            except ValidationError as err:
+                raise ValueError(f"Not a Squore line I can parse: {squore}") from err
+
+    return Point(
+        server=server,
+        serveside=side,
+        data=data,
+        player=1 if winner else 0,
+        duration=duration,
+    )

squoredata-0.1.0.dist-info/METADATA

@@ -0,0 +1,92 @@
+Metadata-Version: 2.5
+Name: squoredata
+Version: 0.1.0
+Summary: Self-contained Pydantic data structures used by Squore tablets
+Author-email: "martin f. krafft" <squoredata@pobox.madduck.net>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.13
+Requires-Dist: pydantic
+Provides-Extra: dev
+Requires-Dist: coverage; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest-cov; extra == 'dev'
+Requires-Dist: pytest-mock; extra == 'dev'
+Requires-Dist: pytest-ruff; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# squoredata
+
+Self-contained [Pydantic](https://docs.pydantic.dev) v2 data structures used by
+[Squore](https://github.com/obbimi/Squore) scoreboard tablets.
+
+The package was extracted from [`tcboard`](https://github.com/madduck/tcboard).
+It contains only the data models, not the surrounding server logic. TypeScript
+bindings are generated from the models so that a JavaScript or TypeScript
+project can consume the same shape.
+
+## Models
+
+- `SquoreMatch` — a match as used by Squore, without any live information.
+- `SquoreMatchLiveData` — a `SquoreMatch` together with the live data a tablet
+  reports. It adds the `court` and `timestamp` fields.
+
+Supporting models: `Players`, `Colors`, `Countries`, `Clubs`, `Event`, `Format`,
+`Wifi`, `Metadata`, `SquoreDeviceInfo`, `TimerInfo`, `Timing`, `When`, `Point`,
+`Game`, and the `LiveStatus` enum.
+
+## Install
+
+```sh
+pip install squoredata
+```
+
+## TypeScript bindings
+
+`scripts/generate_ts.py` renders the JSON Schema of each model and converts it
+to TypeScript with
+[`json-schema-to-typescript`](https://www.npmjs.com/package/json-schema-to-typescript).
+The output lives in `typescript/` and is committed:
+
+- `SquoreMatch.d.ts`, `SquoreMatchLiveData.d.ts` — the interfaces
+- `SquoreMatch.schema.json`, `SquoreMatchLiveData.schema.json` — the schemata
+- `index.d.ts` — re-exports
+
+The Hatch build hook (`hatch_build.py`) runs the generator before a wheel is
+built, so a release can never carry stale bindings.
+
+Install the generated bindings into another project from the `typescript/`
+directory, or from a published `squoredata-types` package:
+
+```sh
+npm install /path/to/squoredata/typescript
+```
+
+## Golden tests
+
+The files in `golden/` are the shared contract between the two sides:
+
+- `tests/test_golden.py` serialises and re-validates the models against the
+  golden JSON.
+- `typescript/tests/golden.ts` assigns the same JSON to the generated
+  interfaces, so `tsc --noEmit` fails when the two sides diverge.
+
+Regenerate the golden files with `python scripts/make_golden.py` after a model
+change.
+
+## Development
+
+```sh
+pip install -e .[dev]
+ruff check .
+pytest
+mypy --strict .
+
+npm install
+node_modules/.bin/tsc --noEmit -p tsconfig.json
+```

squoredata-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+squoredata/__init__.py,sha256=V2-mhv1O2mLD4AD74TF4BAIHfRqWxLdKPaTDDXMSbQ4,1359
+squoredata/devinfo.py,sha256=N5KfBVzQvdWVKo90ulCkSsZHx4F0oU8JoXivv7S1X_k,1686
+squoredata/game.py,sha256=cou5uHA5Tje2g2Ppu9fHhCP9pIaYpFRbemDmNdFHTgY,1146
+squoredata/livedata.py,sha256=R6Nj4Bs9T14f4om4XHDU48MhCQRbKTQx8kxEqTnN_1Q,6933
+squoredata/livestatus.py,sha256=8bWQoZBBftSPuDyb0fDlBaXVQkysvliKfvwnkA7Y12k,1558
+squoredata/match.py,sha256=OLCQZ52WNoOOIGmharNOnbkyyLXLcKDHwh1dwR7VgHE,1887
+squoredata/point.py,sha256=-s9EwOHy_G9X91pV-D4yY6SYkPvdLkFW2VQ-NKReU1A,3171
+squoredata/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+squoredata-0.1.0.dist-info/METADATA,sha256=lAgmvWSLTU4aPXS1tEy5ZzsTLwfpKn8h-J2eGJSnFjE,2997
+squoredata-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+squoredata-0.1.0.dist-info/licenses/LICENSE,sha256=7fO2Xb6dFmiG-ouqDpqSjikytIJF-y2An2ga8jVGLb4,1073
+squoredata-0.1.0.dist-info/RECORD,,

squoredata-0.1.0.dist-info/WHEEL

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

squoredata-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 martin f. krafft
+
+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.