crowdypy 0.9.0.dev1__tar.gz → 0.9.1.dev1__tar.gz

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/MIGRATION.md

@@ -3,6 +3,17 @@
 CrowdyPy is pre-1.0. Within a minor line, patch releases keep source compatibility; each
 new minor may change the API. Read the section for every minor you skip.
 
+## 0.9.1
+
+A patch release with the same API as 0.9.0, the same CrowdyJS (18.8.0) and CrowdyCPP (0.61.0) pins.
+
+- **`client.input_log` sends a session filter's `userId` as a string**, the decimal string every
+  id is on the wire. An `int` used to go out as a JSON number.
+- **Its docstrings say when a read is retryable.** From the Game API release after v2.40.2,
+  `InputLogAPI.messages` answers `INPUT_LOG_TEMPORARILY_UNAVAILABLE` when the log cannot be read
+  right now and `INPUT_LOG_RATE_LIMITED` while another read of yours is running; both carry
+  `extensions.retryable`, so retry with the same cursor after a short back-off.
+
 ## 0.9.0
 
 CrowdyJS 18.8.0 and CrowdyCPP 0.61.0. Additive, with one floor: the build documents select

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crowdypy
-Version: 0.9.0.dev1
+Version: 0.9.1.dev1
 Summary: Official Python SDK for Crowded Kingdoms: typed GraphQL clients and a native UDP replication core
 Keywords: crowded-kingdoms,multiplayer,replication,graphql,sdk,udp
 Author: Crowded Kingdoms
@@ -51,8 +51,8 @@ CrowdyPy follows the [CrowdyJS](https://github.com/CrowdedKingdoms/CrowdyJS) API
 client, bound with [nanobind](https://github.com/wjakob/nanobind) and shipped inside the
 wheel. Python never touches a datagram.
 
-**v0.9.0: builds report the SDK they compiled against (CrowdyJS 18.8.0, CrowdyCPP 0.61.0).** See the 0.9.0
-bullet below.
+**v0.9.1: the input log's session filter sends `userId` as a string, and its reads document when
+to retry.** See the 0.9.1 bullet below; 0.9.0 added the SDK a build compiled against.
 
 **v0.8.0: voice, channel audio, wide voxels, and pause and access refusals (CrowdyJS 18.7.0, CrowdyCPP 0.60.0).**
 - Voice: `crowdypy.media`'s voice helpers (an optional 10-byte header per codec frame,

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/README.md

@@ -11,8 +11,8 @@ CrowdyPy follows the [CrowdyJS](https://github.com/CrowdedKingdoms/CrowdyJS) API
 client, bound with [nanobind](https://github.com/wjakob/nanobind) and shipped inside the
 wheel. Python never touches a datagram.
 
-**v0.9.0: builds report the SDK they compiled against (CrowdyJS 18.8.0, CrowdyCPP 0.61.0).** See the 0.9.0
-bullet below.
+**v0.9.1: the input log's session filter sends `userId` as a string, and its reads document when
+to retry.** See the 0.9.1 bullet below; 0.9.0 added the SDK a build compiled against.
 
 **v0.8.0: voice, channel audio, wide voxels, and pause and access refusals (CrowdyJS 18.7.0, CrowdyCPP 0.60.0).**
 - Voice: `crowdypy.media`'s voice helpers (an optional 10-byte header per codec frame,

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/docs/compatibility.md

@@ -5,7 +5,7 @@ are in `pyproject.toml` (`[project].version`, `[tool.crowdypy.crowdyjs]`,
 `[tool.crowdypy.crowdycpp]`); `tests/unit/test_release_versions.py` refuses this page when
 its version disagrees.
 
-- CrowdyPy `0.9.0`
+- CrowdyPy `0.9.1`
 - API surface: CrowdyJS (the pinned version and commit in `pyproject.toml`); the generated
   `docs/parity-matrix.md` lists every covered method, every native equivalent and every
   browser exclusion with its reason. The gate is strict: there are no portable gaps, and a
@@ -41,6 +41,10 @@ requirement names one exactly, the same way a caret never matches an npm prerele
 - `auth.record_player_consents` and `auth.player_legal_acceptance` need ck-api v2.35.0; an
   older API answers them with a GraphQL validation error. From v2.35.0 a gameplay token
   waits for both consents (`LEGAL_ACCEPTANCE_REQUIRED`).
+- The input log (`client.input_log`, 0.7.0) needs ck-api v2.39.0 or later: every app read selects
+  `replayLoggingEnabled`, which an older API refuses with a GraphQL validation error. The retryable
+  `INPUT_LOG_TEMPORARILY_UNAVAILABLE` / `INPUT_LOG_RATE_LIMITED` and the `logging_off` / `shutdown`
+  end reasons come with the ck-api release after v2.40.2.
 - `udp.send_ranged_channel_message` needs a replication server that serves message type 32
   (CHANNEL_MESSAGE_RANGED_REQUEST); one that does not delivers nothing.
 - 0.8.0 selects `runtimeGate` on every token mutation (`portal.mint_app_token`,

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "crowdypy"
-version = "0.9.0.dev1"
+version = "0.9.1.dev1"
 description = "Official Python SDK for Crowded Kingdoms: typed GraphQL clients and a native UDP replication core"
 readme = "README.md"
 license = "MIT AND Apache-2.0"

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/scripts/ci/check_content_policy.py

@@ -41,7 +41,6 @@ DENYLIST = (
     "dev-run-buddy",
 )
 SKIP_DIRS = {
-    ".git": "object store; holds every historical revision by construction",
     ".venv": "the developer's virtualenv; third-party code",
     "build": "CMake build trees, regenerated per build",
     "node_modules": "third-party dependencies",
@@ -76,6 +75,11 @@ def tree() -> Iterator[tuple[str, bytes]]:
         current = stack.pop()
         for entry in sorted(current.iterdir()):
             rel = entry.relative_to(ROOT).as_posix()
+            if entry.name == ".git":
+                # A clone's object store, which holds every historical revision by
+                # construction, or a worktree's pointer file, which names the checkout's own
+                # path. Neither is ever packaged.
+                continue
             if entry.is_dir():
                 if entry.name not in SKIP_DIRS:
                     stack.append(entry)

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/scripts/ci/check_pin_tiers.py

@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-"""Both pins name commits promoted to THIS branch's tier of their repositories.
+"""Both pins name published releases, promoted to THIS branch's tier of their repositories.
 
     python scripts/ci/check_pin_tiers.py --crowdyjs <checkout> --crowdycpp <checkout> --tier dev
     python scripts/ci/check_pin_tiers.py --crowdyjs <checkout> --crowdycpp <checkout> --from-ref
@@ -10,6 +10,11 @@ CrowdyPy's ``dev`` may pin only CrowdyJS and CrowdyCPP commits reachable from th
 branch head: a promotion merges forward, so one commit satisfies every tier once it has
 travelled the ladder, and pinning a head would make an unrelated landing turn this red.
 The checkouts need full history (``fetch-depth: 0``).
+
+And released: each pinned commit must be the target of a ``<tier>/v<version>`` tag of its
+repository for the pinned version (any tier's, for the same ladder reason). Reachability
+alone let 0.7.0 pin CrowdyJS ``ca9fbb5`` as 18.6.0 while ``dev/v18.6.0`` is ``7662d0b0``.
+That half needs no tier, so it runs on every ref.
 """
 
 from __future__ import annotations
@@ -43,6 +48,55 @@ def _from_ref() -> str | None:
     return _tier_of(branch) if branch and branch != "HEAD" else None
 
 
+def parse_tag_refs(text: str) -> dict[str, str]:
+    """``git ls-remote --tags`` output: tag name -> the commit it points at (an annotated tag's
+    peeled ``^{}`` line wins over the tag object's own sha)."""
+    out: dict[str, str] = {}
+    for line in text.splitlines():
+        parts = line.strip().split()
+        if len(parts) != 2 or len(parts[0]) != 40 or not parts[1].startswith("refs/tags/"):
+            continue
+        sha, ref = parts
+        name = ref.removeprefix("refs/tags/")
+        if name.endswith("^{}"):
+            out[name.removesuffix("^{}")] = sha
+        else:
+            out.setdefault(name, sha)
+    return out
+
+
+def tag_verdict(commit: str, version: str, tags: dict[str, str]) -> tuple[bool, str]:
+    """Whether ``commit`` is a published ``version``: the target of a ``<tier>/v<version>`` tag."""
+    named = [f"{tier}/v{version}" for tier in TIERS]
+    matching = [name for name in named if tags.get(name) == commit]
+    if matching:
+        return True, f"{commit[:12]} is {', '.join(matching)}"
+    elsewhere = [f"{name} is {tags[name][:12]}" for name in named if name in tags]
+    if elsewhere:
+        return False, f"{commit[:12]} is not a published {version}: {', '.join(elsewhere)}"
+    return False, f"{commit[:12]} is not a published {version}: no {' / '.join(named)} tag exists"
+
+
+def tagged(repo: Path, commit: str, version: str) -> tuple[bool, str]:
+    listed = subprocess.run(
+        [
+            "git",
+            "-C",
+            str(repo),
+            "ls-remote",
+            "--tags",
+            "origin",
+            *[f"refs/tags/{tier}/v{version}*" for tier in TIERS],
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if listed.returncode != 0:
+        return False, f"cannot list the tags of {repo}: {listed.stderr.strip()[:200]}"
+    return tag_verdict(commit, version, parse_tag_refs(listed.stdout))
+
+
 def reachable(repo: Path, commit: str, tier: str) -> tuple[bool, str]:
     fetched = subprocess.run(
         [
@@ -93,23 +147,38 @@ def main(argv: list[str] | None = None) -> int:
     group.add_argument("--from-ref", action="store_true")
     args = parser.parse_args(argv)
     tier = args.tier or _from_ref()
-    if tier is None:
-        print(
-            "check_pin_tiers: this ref carries no tier, so the comparison was SKIPPED (a PR into dev/test/prod is judged by that base)"
-        )
-        return 0
     pins = tomllib.loads((ROOT / "pyproject.toml").read_text(encoding="utf-8"))["tool"]["crowdypy"]
     failed = False
+    unreleased = False
     for name, repo, pin in (
         ("CrowdyJS", args.crowdyjs, pins["crowdyjs"]),
         ("CrowdyCPP", args.crowdycpp, pins["crowdycpp"]),
     ):
+        ok, detail = tagged(repo, pin["commit"], pin["version"])
+        unreleased |= not ok
+        print(
+            f"check_pin_tiers: {name} {pin['version']}: {detail}",
+            file=sys.stdout if ok else sys.stderr,
+        )
+        if tier is None:
+            continue
         ok, detail = reachable(repo, pin["commit"], tier)
         failed |= not ok
         print(
             f"check_pin_tiers: {name} {pin['version']}: {detail}",
             file=sys.stdout if ok else sys.stderr,
         )
+    if unreleased:
+        print(
+            "check_pin_tiers: pin the commit a release tag points at (CrowdyJS's, then CrowdyCPP's).",
+            file=sys.stderr,
+        )
+        return 1
+    if tier is None:
+        print(
+            "check_pin_tiers: this ref carries no tier, so the reachability comparison was SKIPPED (a PR into dev/test/prod is judged by that base)"
+        )
+        return 0
     if failed:
         print(
             f"check_pin_tiers: a CrowdyPy {tier} branch may pin only commits promoted to {tier}. "

crowdypy-0.9.1.dev1/src/crowdypy/_sync/domains/input_log.py

@@ -0,0 +1,113 @@
+# GENERATED by scripts/unasync.py from src/crowdypy/domains/input_log.py. Do not edit.
+"""The input log (``client.input_log``): recorded client inputs of an app with replay logging on.
+
+An app with replay logging on (``App.replayLoggingEnabled``, set with ``client.apps.update``)
+has every client input the realtime servers accept recorded. These calls read them back on
+the app-scoped client for the app; an identity session token is refused. A player reads only
+the sessions and inputs they sent; a holder of ``manage_apps`` on the app reads every session.
+Inputs are kept for the input log's published retention (up to about an hour longer), so an old
+session can still be listed after its inputs are gone. Both answer ``INPUT_LOG_UNAVAILABLE`` on a
+deployment without input logging. From the Game API release after v2.40.2,
+:meth:`InputLogAPI.messages` answers ``INPUT_LOG_TEMPORARILY_UNAVAILABLE`` when the log cannot be
+read right now and ``INPUT_LOG_RATE_LIMITED`` while another read of yours is running (one per user,
+two per app): both carry ``extensions.retryable``, so retry with the same cursor after a short
+back-off. Earlier Game APIs answer ``INPUT_LOG_UNAVAILABLE``, or an empty page, instead.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import msgspec
+
+from crowdypy._generated import inputs
+from crowdypy._generated import operations as ops
+from crowdypy._sync.domains._base import Domain, omit_none
+from crowdypy.utils import bigint
+
+__all__ = ["InputLogAPI"]
+
+
+def _session_filter(
+    filter: inputs.InputLogSessionFilter | Mapping[str, Any] | None,
+) -> inputs.InputLogSessionFilter | Mapping[str, Any] | None:
+    """``userId`` as the decimal string every id is on the wire: an int went out as a JSON
+    number, safe at today's ids and unlike every other id the SDK sends."""
+    if isinstance(filter, inputs.InputLogSessionFilter):
+        # Typed str, so an int here is a caller past the type hints: exactly the case to mend.
+        user_id: Any = filter.user_id
+        if isinstance(user_id, int) and not isinstance(user_id, bool):
+            return msgspec.structs.replace(filter, user_id=bigint(user_id))
+        return filter
+    if isinstance(filter, Mapping) and isinstance(filter.get("userId"), int):
+        return {**filter, "userId": bigint(filter["userId"])}
+    return filter
+
+
+class InputLogAPI(Domain):
+    def sessions(
+        self,
+        app_id: str | int,
+        *,
+        first: int | None = None,
+        after: str | None = None,
+        filter: inputs.InputLogSessionFilter | Mapping[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """An app's recorded sessions, newest first: ``edges { cursor node }``, ``pageInfo``,
+        ``totalCount``. A session is one game token's inputs.
+
+        ``filter`` takes ``userId`` (another user's needs ``manage_apps``, else ``FORBIDDEN``;
+        an int is sent as its decimal string), ``from`` / ``to`` and ``messageType``. Page with
+        ``first`` (default 50, max 200) and the previous page's ``pageInfo.endCursor`` as
+        ``after``. A node's ``endReason`` is ``expired``, ``revoked``, ``reconnect`` or
+        ``released`` as the client saw it, ``logging_off`` or ``shutdown`` from the Game API
+        release after v2.40.2, ``unrecorded``, or null while the session may still run.
+        """
+        result: dict[str, Any] = self._request(
+            ops.INPUT_LOG_SESSIONS,
+            omit_none(
+                {
+                    "appId": bigint(app_id),
+                    "first": first,
+                    "after": after,
+                    "filter": _session_filter(filter),
+                }
+            ),
+        )
+        return result
+
+    def messages(
+        self,
+        app_id: str | int,
+        game_token_id: str | int,
+        *,
+        first: int | None = None,
+        after: str | None = None,
+        filter: inputs.InputLogMessageFilter | Mapping[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """One session's recorded inputs (``game_token_id`` from :meth:`sessions`), oldest first.
+
+        ``body`` is the client message in base64 (``decode_base64`` gives the bytes), from its
+        type byte up to its authentication tail, which is not recorded; ``sizeBytes`` is what
+        stored input logs are billed on. Spatial inputs carry their chunk and actor, channel
+        inputs their channel. **Keep paging while ``pageInfo.hasNextPage`` is true**, not while
+        ``endCursor`` is set: a page can be short, or empty, when it reached the server's time or
+        scan limit; keep the previous cursor if one comes back null. ``filter`` takes ``from`` /
+        ``to`` and ``messageTypes`` (at most 64). Another user's session answers ``NOT_FOUND``
+        without ``manage_apps``; a malformed cursor, or (from the Game API release after v2.40.2)
+        one from another session, ``BAD_USER_INPUT``.
+        """
+        result: dict[str, Any] = self._request(
+            ops.INPUT_LOG_MESSAGES,
+            omit_none(
+                {
+                    "appId": bigint(app_id),
+                    "gameTokenId": bigint(game_token_id),
+                    "first": first,
+                    "after": after,
+                    "filter": filter,
+                }
+            ),
+        )
+        return result

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/src/crowdypy/_version.py

@@ -1,3 +1,3 @@
 """The CrowdyPy release this source tree builds."""
 
-__version__ = "0.9.0"
+__version__ = "0.9.1"

crowdypy-0.9.1.dev1/src/crowdypy/domains/input_log.py

@@ -0,0 +1,112 @@
+"""The input log (``client.input_log``): recorded client inputs of an app with replay logging on.
+
+An app with replay logging on (``App.replayLoggingEnabled``, set with ``client.apps.update``)
+has every client input the realtime servers accept recorded. These calls read them back on
+the app-scoped client for the app; an identity session token is refused. A player reads only
+the sessions and inputs they sent; a holder of ``manage_apps`` on the app reads every session.
+Inputs are kept for the input log's published retention (up to about an hour longer), so an old
+session can still be listed after its inputs are gone. Both answer ``INPUT_LOG_UNAVAILABLE`` on a
+deployment without input logging. From the Game API release after v2.40.2,
+:meth:`InputLogAPI.messages` answers ``INPUT_LOG_TEMPORARILY_UNAVAILABLE`` when the log cannot be
+read right now and ``INPUT_LOG_RATE_LIMITED`` while another read of yours is running (one per user,
+two per app): both carry ``extensions.retryable``, so retry with the same cursor after a short
+back-off. Earlier Game APIs answer ``INPUT_LOG_UNAVAILABLE``, or an empty page, instead.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import msgspec
+
+from crowdypy._generated import inputs
+from crowdypy._generated import operations as ops
+from crowdypy.domains._base import Domain, omit_none
+from crowdypy.utils import bigint
+
+__all__ = ["InputLogAPI"]
+
+
+def _session_filter(
+    filter: inputs.InputLogSessionFilter | Mapping[str, Any] | None,
+) -> inputs.InputLogSessionFilter | Mapping[str, Any] | None:
+    """``userId`` as the decimal string every id is on the wire: an int went out as a JSON
+    number, safe at today's ids and unlike every other id the SDK sends."""
+    if isinstance(filter, inputs.InputLogSessionFilter):
+        # Typed str, so an int here is a caller past the type hints: exactly the case to mend.
+        user_id: Any = filter.user_id
+        if isinstance(user_id, int) and not isinstance(user_id, bool):
+            return msgspec.structs.replace(filter, user_id=bigint(user_id))
+        return filter
+    if isinstance(filter, Mapping) and isinstance(filter.get("userId"), int):
+        return {**filter, "userId": bigint(filter["userId"])}
+    return filter
+
+
+class InputLogAPI(Domain):
+    async def sessions(
+        self,
+        app_id: str | int,
+        *,
+        first: int | None = None,
+        after: str | None = None,
+        filter: inputs.InputLogSessionFilter | Mapping[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """An app's recorded sessions, newest first: ``edges { cursor node }``, ``pageInfo``,
+        ``totalCount``. A session is one game token's inputs.
+
+        ``filter`` takes ``userId`` (another user's needs ``manage_apps``, else ``FORBIDDEN``;
+        an int is sent as its decimal string), ``from`` / ``to`` and ``messageType``. Page with
+        ``first`` (default 50, max 200) and the previous page's ``pageInfo.endCursor`` as
+        ``after``. A node's ``endReason`` is ``expired``, ``revoked``, ``reconnect`` or
+        ``released`` as the client saw it, ``logging_off`` or ``shutdown`` from the Game API
+        release after v2.40.2, ``unrecorded``, or null while the session may still run.
+        """
+        result: dict[str, Any] = await self._request(
+            ops.INPUT_LOG_SESSIONS,
+            omit_none(
+                {
+                    "appId": bigint(app_id),
+                    "first": first,
+                    "after": after,
+                    "filter": _session_filter(filter),
+                }
+            ),
+        )
+        return result
+
+    async def messages(
+        self,
+        app_id: str | int,
+        game_token_id: str | int,
+        *,
+        first: int | None = None,
+        after: str | None = None,
+        filter: inputs.InputLogMessageFilter | Mapping[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        """One session's recorded inputs (``game_token_id`` from :meth:`sessions`), oldest first.
+
+        ``body`` is the client message in base64 (``decode_base64`` gives the bytes), from its
+        type byte up to its authentication tail, which is not recorded; ``sizeBytes`` is what
+        stored input logs are billed on. Spatial inputs carry their chunk and actor, channel
+        inputs their channel. **Keep paging while ``pageInfo.hasNextPage`` is true**, not while
+        ``endCursor`` is set: a page can be short, or empty, when it reached the server's time or
+        scan limit; keep the previous cursor if one comes back null. ``filter`` takes ``from`` /
+        ``to`` and ``messageTypes`` (at most 64). Another user's session answers ``NOT_FOUND``
+        without ``manage_apps``; a malformed cursor, or (from the Game API release after v2.40.2)
+        one from another session, ``BAD_USER_INPUT``.
+        """
+        result: dict[str, Any] = await self._request(
+            ops.INPUT_LOG_MESSAGES,
+            omit_none(
+                {
+                    "appId": bigint(app_id),
+                    "gameTokenId": bigint(game_token_id),
+                    "first": first,
+                    "after": after,
+                    "filter": filter,
+                }
+            ),
+        )
+        return result

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/tests/unit/domains/test_world_domains.py

@@ -135,6 +135,25 @@ CASES = [
         kwargs={"first": 20, "after": "c1", "filter": {"userId": "7", "messageType": 129}},
         label="filtered",
     ),
+    # a userId given as an int goes out as the decimal string every id is on the wire
+    case(
+        InputLogAPI,
+        "sessions",
+        (42,),
+        "InputLogSessions",
+        {"appId": "42", "filter": {"userId": "9007199254740993"}},
+        kwargs={"filter": {"userId": 9007199254740993}},
+        label="int user id, mapping",
+    ),
+    case(
+        InputLogAPI,
+        "sessions",
+        (42,),
+        "InputLogSessions",
+        {"appId": "42", "filter": {"userId": "7"}},
+        kwargs={"filter": inputs.InputLogSessionFilter(user_id=7)},  # type: ignore[arg-type]
+        label="int user id, struct",
+    ),
     case(
         InputLogAPI,
         "messages",

crowdypy-0.9.1.dev1/tests/unit/test_check_pin_tiers.py

@@ -0,0 +1,59 @@
+"""scripts/ci/check_pin_tiers.py: a pin must be a published release, not just a promoted commit."""
+
+from __future__ import annotations
+
+import importlib.util
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[2]
+SCRIPT = ROOT / "scripts" / "ci" / "check_pin_tiers.py"
+if not SCRIPT.exists():
+    # The wheel builds run tests/unit from a copy that carries no scripts/.
+    pytest.skip("scripts/ci is not in this test tree", allow_module_level=True)
+_spec = importlib.util.spec_from_file_location("check_pin_tiers", SCRIPT)
+assert _spec
+assert _spec.loader
+check = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(check)
+
+RELEASED = "7662d0b0" + "a" * 32
+UNRELEASED = "ca9fbb50" + "b" * 32
+TAG_OBJECT = "f00dfeed" + "c" * 32
+
+
+def test_parses_lightweight_and_annotated_tags_the_peeled_commit_winning() -> None:
+    tags = check.parse_tag_refs(
+        "\n".join(
+            [
+                f"{RELEASED}\trefs/tags/dev/v18.6.0",
+                f"{TAG_OBJECT}\trefs/tags/test/v18.6.0",
+                f"{RELEASED}\trefs/tags/test/v18.6.0^{{}}",
+            ]
+        )
+    )
+    assert tags == {"dev/v18.6.0": RELEASED, "test/v18.6.0": RELEASED}
+
+
+def test_a_pin_on_a_tagged_release_passes_whichever_tier_tagged_it() -> None:
+    ok, detail = check.tag_verdict(RELEASED, "18.6.0", {"dev/v18.6.0": RELEASED})
+    assert ok
+    assert "dev/v18.6.0" in detail
+
+
+def test_refuses_0_7_0s_pin_reachable_but_not_the_released_commit() -> None:
+    ok, detail = check.tag_verdict(UNRELEASED, "18.6.0", {"dev/v18.6.0": RELEASED})
+    assert not ok
+    assert "not a published 18.6.0: dev/v18.6.0 is 7662d0b0aaaa" in detail
+
+
+def test_refuses_a_version_no_tier_has_tagged() -> None:
+    ok, detail = check.tag_verdict(RELEASED, "18.9.0", {})
+    assert not ok
+    assert "no dev/v18.9.0 / test/v18.9.0 / prod/v18.9.0 tag exists" in detail
+
+
+def test_another_versions_tag_at_the_same_commit_does_not_count() -> None:
+    ok, _ = check.tag_verdict(RELEASED, "18.6.0", {"dev/v18.6.1": RELEASED})
+    assert not ok

{crowdypy-0.9.0.dev1 → crowdypy-0.9.1.dev1}/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 3
+revision = 5
 requires-python = ">=3.12"
 resolution-markers = [
     "python_full_version >= '3.15'",
@@ -103,7 +103,7 @@ wheels = [
 
 [[package]]
 name = "crowdypy"
-version = "0.9.0"
+version = "0.9.1"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },

crowdypy-0.9.0.dev1/src/crowdypy/_sync/domains/input_log.py

@@ -1,80 +0,0 @@
-# GENERATED by scripts/unasync.py from src/crowdypy/domains/input_log.py. Do not edit.
-"""The input log (``client.input_log``): recorded client inputs of an app with replay logging on.
-
-An app with replay logging on (``App.replayLoggingEnabled``, set with ``client.apps.update``)
-has every client input the realtime servers accept recorded. These calls read them back on
-the app-scoped client for the app; an identity session token is refused. A player reads only
-the sessions and inputs they sent; a holder of ``manage_apps`` on the app reads every session.
-Inputs are kept for the input log's published retention, so an old session can still be listed
-after its inputs are gone. Both answer ``INPUT_LOG_UNAVAILABLE`` on a deployment without input
-logging, and :meth:`InputLogAPI.messages` also answers it, retryable with the same cursor, when the
-log cannot be read right now.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-from typing import Any
-
-from crowdypy._generated import inputs
-from crowdypy._generated import operations as ops
-from crowdypy._sync.domains._base import Domain, omit_none
-from crowdypy.utils import bigint
-
-__all__ = ["InputLogAPI"]
-
-
-class InputLogAPI(Domain):
-    def sessions(
-        self,
-        app_id: str | int,
-        *,
-        first: int | None = None,
-        after: str | None = None,
-        filter: inputs.InputLogSessionFilter | Mapping[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """An app's recorded sessions, newest first: ``edges { cursor node }``, ``pageInfo``,
-        ``totalCount``. A session is one game token's inputs.
-
-        ``filter`` takes ``userId`` (another user's needs ``manage_apps``, else ``FORBIDDEN``),
-        ``from`` / ``to`` and ``messageType``. Page with ``first`` (default 50, max 200) and the
-        previous page's ``pageInfo.endCursor`` as ``after``.
-        """
-        result: dict[str, Any] = self._request(
-            ops.INPUT_LOG_SESSIONS,
-            omit_none({"appId": bigint(app_id), "first": first, "after": after, "filter": filter}),
-        )
-        return result
-
-    def messages(
-        self,
-        app_id: str | int,
-        game_token_id: str | int,
-        *,
-        first: int | None = None,
-        after: str | None = None,
-        filter: inputs.InputLogMessageFilter | Mapping[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        """One session's recorded inputs (``game_token_id`` from :meth:`sessions`), oldest first.
-
-        ``body`` is the client message in base64 (``decode_base64`` gives the bytes), from its
-        type byte up to its authentication tail, which is not recorded; ``sizeBytes`` is what
-        stored input logs are billed on. Spatial inputs carry their chunk and actor, channel
-        inputs their channel. **Keep paging while ``pageInfo.hasNextPage`` is true**: a page can
-        be short, or empty, when it reached the server's time or scan limit. ``filter`` takes
-        ``from`` / ``to`` and ``messageTypes`` (at most 64). Another user's session answers
-        ``NOT_FOUND`` without ``manage_apps``.
-        """
-        result: dict[str, Any] = self._request(
-            ops.INPUT_LOG_MESSAGES,
-            omit_none(
-                {
-                    "appId": bigint(app_id),
-                    "gameTokenId": bigint(game_token_id),
-                    "first": first,
-                    "after": after,
-                    "filter": filter,
-                }
-            ),
-        )
-        return result