game-learning-runtime 0.1.0__py3-none-any.whl

game_learning_runtime/__init__.py

@@ -0,0 +1,45 @@
+"""Game Learning Runtime public API."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from game_learning_runtime.collector import Policy, SyncCollector
+from game_learning_runtime.contracts import Event, TimeStep, Transition, Unroll
+from game_learning_runtime.environment import ContractEnvironment, GameEnvironment
+from game_learning_runtime.errors import ContractViolation, GLRError, OptionalDependencyError
+from game_learning_runtime.protocol import protocol_path
+from game_learning_runtime.serialization import (
+    JsonlTransitionWriter,
+    read_jsonl_transitions,
+    transition_from_record,
+    transition_to_record,
+)
+from game_learning_runtime.specs import CompositeSpec, EnvironmentSpec, SpaceKind, TensorSpec
+
+try:
+    __version__ = version("game-learning-runtime")
+except PackageNotFoundError:  # pragma: no cover - source tree without installation
+    __version__ = "0.0.0+local"
+
+__all__ = [
+    "CompositeSpec",
+    "ContractEnvironment",
+    "ContractViolation",
+    "EnvironmentSpec",
+    "Event",
+    "GLRError",
+    "GameEnvironment",
+    "JsonlTransitionWriter",
+    "OptionalDependencyError",
+    "Policy",
+    "SpaceKind",
+    "SyncCollector",
+    "TensorSpec",
+    "TimeStep",
+    "Transition",
+    "Unroll",
+    "__version__",
+    "protocol_path",
+    "read_jsonl_transitions",
+    "transition_from_record",
+    "transition_to_record",
+]

game_learning_runtime/collector.py

@@ -0,0 +1,82 @@
+"""Framework-neutral synchronous collection primitives."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from game_learning_runtime.contracts import TensorTree, TimeStep, Transition, Unroll
+from game_learning_runtime.environment import ContractEnvironment, GameEnvironment
+
+
+class Policy(Protocol):
+    """Minimal policy port shared by custom PPO, IMPALA, BC, and evaluation."""
+
+    def __call__(self, timestep: TimeStep) -> TensorTree:
+        """Choose a structured action from a time step."""
+        ...
+
+
+class SyncCollector:
+    """Collect fixed-length unrolls without coupling to a learner framework."""
+
+    def __init__(self, environment: GameEnvironment, *, actor_id: str = "actor-0") -> None:
+        if not actor_id:
+            raise ValueError("actor_id cannot be empty")
+        self._environment = (
+            environment
+            if isinstance(environment, ContractEnvironment)
+            else ContractEnvironment(environment)
+        )
+        self._actor_id = actor_id
+        self._current: TimeStep | None = None
+        self._sequence_id = 0
+
+    def collect(
+        self,
+        policy: Policy,
+        *,
+        steps: int,
+        policy_version: int = 0,
+        seed: int | None = None,
+    ) -> Unroll:
+        if steps <= 0:
+            raise ValueError("steps must be positive")
+        if policy_version < 0:
+            raise ValueError("policy_version cannot be negative")
+        if self._current is None or self._current.done:
+            self._current = self._environment.reset(seed=seed)
+
+        transitions: list[Transition] = []
+        for _ in range(steps):
+            current = self._current
+            action = policy(current)
+            following = self._environment.step(action)
+            transitions.append(
+                Transition(
+                    episode_id=current.episode_id,
+                    step_id=current.step_id,
+                    observation=current.observation,
+                    action=action,
+                    action_mask=current.action_mask,
+                    reward=following.reward,
+                    next_observation=following.observation,
+                    next_action_mask=following.action_mask,
+                    terminated=following.terminated,
+                    truncated=following.truncated,
+                    events=following.events,
+                    info=following.info,
+                    timestamp_ns=following.timestamp_ns,
+                )
+            )
+            self._current = following
+            if following.done and len(transitions) < steps:
+                self._current = self._environment.reset()
+
+        unroll = Unroll(
+            transitions=tuple(transitions),
+            actor_id=self._actor_id,
+            sequence_id=self._sequence_id,
+            policy_version=policy_version,
+        )
+        self._sequence_id += 1
+        return unroll

game_learning_runtime/contracts.py

@@ -0,0 +1,146 @@
+"""Runtime data contracts shared by adapters, collectors, and learners."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from time import time_ns
+from types import MappingProxyType
+from typing import Any, TypeAlias
+from uuid import UUID, uuid4
+
+import numpy as np
+from numpy.typing import NDArray
+
+TensorTree: TypeAlias = Mapping[str, "NDArray[Any] | TensorTree"]
+
+
+def freeze_tree(value: Mapping[str, Any]) -> TensorTree:
+    """Copy a nested tensor mapping and make each array read-only."""
+
+    frozen: dict[str, NDArray[Any] | TensorTree] = {}
+    for key, item in value.items():
+        if isinstance(item, Mapping):
+            frozen[key] = freeze_tree(item)
+        else:
+            array = np.array(item, copy=True)
+            array.flags.writeable = False
+            frozen[key] = array
+    return MappingProxyType(frozen)
+
+
+def freeze_array(value: Any) -> NDArray[Any]:
+    array = np.array(value, copy=True)
+    array.flags.writeable = False
+    return array
+
+
+@dataclass(frozen=True, slots=True)
+class Event:
+    """A timestamped semantic event emitted by a game runtime."""
+
+    name: str
+    payload: Mapping[str, Any] = field(default_factory=dict)
+    timestamp_ns: int = field(default_factory=time_ns)
+
+    def __post_init__(self) -> None:
+        if not self.name:
+            raise ValueError("event name cannot be empty")
+        object.__setattr__(self, "payload", MappingProxyType(dict(self.payload)))
+
+
+@dataclass(frozen=True, slots=True)
+class TimeStep:
+    """Observation and environment signals after reset or an action."""
+
+    observation: TensorTree
+    reward: NDArray[Any]
+    terminated: NDArray[np.bool_]
+    truncated: NDArray[np.bool_]
+    episode_id: UUID = field(default_factory=uuid4)
+    step_id: int = 0
+    action_mask: TensorTree | None = None
+    events: tuple[Event, ...] = ()
+    info: Mapping[str, Any] = field(default_factory=dict)
+    timestamp_ns: int = field(default_factory=time_ns)
+
+    def __post_init__(self) -> None:
+        if self.step_id < 0:
+            raise ValueError("step_id cannot be negative")
+        object.__setattr__(self, "observation", freeze_tree(self.observation))
+        object.__setattr__(self, "reward", freeze_array(self.reward))
+        object.__setattr__(self, "terminated", freeze_array(self.terminated))
+        object.__setattr__(self, "truncated", freeze_array(self.truncated))
+        if self.action_mask is not None:
+            object.__setattr__(self, "action_mask", freeze_tree(self.action_mask))
+        object.__setattr__(self, "events", tuple(self.events))
+        object.__setattr__(self, "info", MappingProxyType(dict(self.info)))
+
+    @property
+    def done(self) -> bool:
+        """Whether every participant represented by the done tensors has ended."""
+
+        return bool(np.all(np.logical_or(self.terminated, self.truncated)))
+
+
+@dataclass(frozen=True, slots=True)
+class Transition:
+    """One learner-neutral transition suitable for RL, BC, or offline data."""
+
+    episode_id: UUID
+    step_id: int
+    observation: TensorTree
+    action: TensorTree
+    reward: NDArray[Any]
+    next_observation: TensorTree
+    terminated: NDArray[np.bool_]
+    truncated: NDArray[np.bool_]
+    action_mask: TensorTree | None = None
+    next_action_mask: TensorTree | None = None
+    events: tuple[Event, ...] = ()
+    info: Mapping[str, Any] = field(default_factory=dict)
+    timestamp_ns: int = field(default_factory=time_ns)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "observation", freeze_tree(self.observation))
+        object.__setattr__(self, "action", freeze_tree(self.action))
+        object.__setattr__(self, "reward", freeze_array(self.reward))
+        object.__setattr__(self, "next_observation", freeze_tree(self.next_observation))
+        object.__setattr__(self, "terminated", freeze_array(self.terminated))
+        object.__setattr__(self, "truncated", freeze_array(self.truncated))
+        if self.action_mask is not None:
+            object.__setattr__(self, "action_mask", freeze_tree(self.action_mask))
+        if self.next_action_mask is not None:
+            object.__setattr__(self, "next_action_mask", freeze_tree(self.next_action_mask))
+        object.__setattr__(self, "events", tuple(self.events))
+        object.__setattr__(self, "info", MappingProxyType(dict(self.info)))
+
+    @property
+    def done(self) -> bool:
+        return bool(np.all(np.logical_or(self.terminated, self.truncated)))
+
+
+@dataclass(frozen=True, slots=True)
+class Unroll:
+    """A fixed-length actor unroll for PPO/IMPALA-style learners."""
+
+    transitions: tuple[Transition, ...]
+    actor_id: str
+    sequence_id: int
+    policy_version: int = 0
+
+    def __post_init__(self) -> None:
+        if not self.transitions:
+            raise ValueError("an unroll requires at least one transition")
+        if not self.actor_id:
+            raise ValueError("actor_id cannot be empty")
+        if self.sequence_id < 0 or self.policy_version < 0:
+            raise ValueError("sequence_id and policy_version cannot be negative")
+        object.__setattr__(self, "transitions", tuple(self.transitions))
+
+    @property
+    def total_reward(self) -> NDArray[Any]:
+        total = np.zeros_like(self.transitions[0].reward)
+        for transition in self.transitions:
+            total = total + transition.reward
+        return total

game_learning_runtime/environment.py

@@ -0,0 +1,118 @@
+"""Environment port and a fail-closed runtime contract wrapper."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Mapping
+from types import TracebackType
+from typing import Any
+from uuid import UUID
+
+from game_learning_runtime.contracts import TensorTree, TimeStep
+from game_learning_runtime.errors import ContractViolation
+from game_learning_runtime.specs import EnvironmentSpec
+
+
+class GameEnvironment(ABC):
+    """Port implemented by in-process, RPC, shared-memory, or replay adapters."""
+
+    @property
+    @abstractmethod
+    def spec(self) -> EnvironmentSpec:
+        """Return the immutable environment contract."""
+
+    @abstractmethod
+    def reset(
+        self, *, seed: int | None = None, options: Mapping[str, Any] | None = None
+    ) -> TimeStep:
+        """Start a new episode and return step zero."""
+
+    @abstractmethod
+    def step(self, action: TensorTree) -> TimeStep:
+        """Apply one structured action and return the resulting time step."""
+
+    def close(self) -> None:
+        """Release runtime resources. Implementations may override this method."""
+        return None
+
+    def __enter__(self) -> GameEnvironment:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.close()
+
+
+class ContractEnvironment(GameEnvironment):
+    """Validates an adapter at every state transition and fails closed."""
+
+    def __init__(self, environment: GameEnvironment) -> None:
+        self._environment = environment
+        self._current: TimeStep | None = None
+        self._previous_episode_id: UUID | None = None
+        self._closed = False
+
+    @property
+    def spec(self) -> EnvironmentSpec:
+        return self._environment.spec
+
+    def reset(
+        self, *, seed: int | None = None, options: Mapping[str, Any] | None = None
+    ) -> TimeStep:
+        self._ensure_open()
+        timestep = self._environment.reset(seed=seed, options=options)
+        self._validate_timestep(timestep)
+        if timestep.step_id != 0:
+            raise ContractViolation(f"reset returned step_id={timestep.step_id}; expected 0")
+        if timestep.done:
+            raise ContractViolation("reset returned a terminal time step")
+        if self._previous_episode_id == timestep.episode_id:
+            raise ContractViolation("reset reused the previous episode_id")
+        self._current = timestep
+        self._previous_episode_id = timestep.episode_id
+        return timestep
+
+    def step(self, action: TensorTree) -> TimeStep:
+        self._ensure_open()
+        if self._current is None:
+            raise ContractViolation("step requires reset first")
+        if self._current.done:
+            raise ContractViolation("step cannot follow a terminal time step; reset first")
+        self.spec.action.validate(action, path="action")
+        timestep = self._environment.step(action)
+        self._validate_timestep(timestep)
+        if timestep.episode_id != self._current.episode_id:
+            raise ContractViolation("step changed episode_id without reset")
+        expected_step_id = self._current.step_id + 1
+        if timestep.step_id != expected_step_id:
+            raise ContractViolation(
+                f"step returned step_id={timestep.step_id}; expected {expected_step_id}"
+            )
+        self._current = timestep
+        return timestep
+
+    def close(self) -> None:
+        if not self._closed:
+            self._environment.close()
+            self._closed = True
+
+    def _validate_timestep(self, timestep: TimeStep) -> None:
+        self.spec.observation.validate(timestep.observation, path="observation")
+        self.spec.reward.validate(timestep.reward, path="reward")
+        self.spec.done.validate(timestep.terminated, path="terminated")
+        self.spec.done.validate(timestep.truncated, path="truncated")
+        if self.spec.action_mask is None:
+            if timestep.action_mask is not None:
+                raise ContractViolation("adapter returned an undeclared action_mask")
+        elif timestep.action_mask is None:
+            raise ContractViolation("adapter omitted the declared action_mask")
+        else:
+            self.spec.action_mask.validate(timestep.action_mask, path="action_mask")
+
+    def _ensure_open(self) -> None:
+        if self._closed:
+            raise ContractViolation("environment is closed")

game_learning_runtime/errors.py

@@ -0,0 +1,13 @@
+"""Exception hierarchy for Game Learning Runtime."""
+
+
+class GLRError(Exception):
+    """Base class for all GLR errors."""
+
+
+class ContractViolation(GLRError, ValueError):
+    """Raised when an environment violates its declared contract."""
+
+
+class OptionalDependencyError(GLRError, ImportError):
+    """Raised when an optional integration is used without its dependencies."""

game_learning_runtime/examples/__init__.py

@@ -0,0 +1,9 @@
+"""Executable reference environments."""
+
+from game_learning_runtime.examples.counter import (
+    CounterEnvironment,
+    always_increment,
+    make_environment,
+)
+
+__all__ = ["CounterEnvironment", "always_increment", "make_environment"]

game_learning_runtime/examples/counter.py

@@ -0,0 +1,94 @@
+"""Small complete GLR environment used by the getting-started guide."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+from uuid import uuid4
+
+import numpy as np
+
+from game_learning_runtime.contracts import TensorTree, TimeStep
+from game_learning_runtime.environment import GameEnvironment
+from game_learning_runtime.specs import CompositeSpec, EnvironmentSpec, SpaceKind, TensorSpec
+
+
+class CounterEnvironment(GameEnvironment):
+    """Increment a counter until it reaches a target value."""
+
+    def __init__(self, *, target: int = 3, max_steps: int = 5) -> None:
+        self._target = target
+        self._max_steps = max_steps
+        self._position = 0
+        self._step_id = 0
+        self._episode_id = uuid4()
+        self._spec = EnvironmentSpec(
+            environment_id="example.counter-v1",
+            observation=CompositeSpec(
+                {"position": TensorSpec((1,), np.int64, minimum=0, maximum=target)}
+            ),
+            action=CompositeSpec(
+                {
+                    "choice": TensorSpec(
+                        (1,),
+                        np.int64,
+                        kind=SpaceKind.DISCRETE,
+                        minimum=0,
+                        maximum=1,
+                        description="0 waits and 1 increments the counter",
+                    )
+                }
+            ),
+            action_mask=CompositeSpec(
+                {"choice": TensorSpec((2,), np.bool_, kind=SpaceKind.BINARY)}
+            ),
+            capabilities=frozenset({"action-mask", "deterministic-reset"}),
+        )
+
+    @property
+    def spec(self) -> EnvironmentSpec:
+        return self._spec
+
+    def reset(
+        self, *, seed: int | None = None, options: Mapping[str, Any] | None = None
+    ) -> TimeStep:
+        del seed, options
+        self._position = 0
+        self._step_id = 0
+        self._episode_id = uuid4()
+        return self._timestep()
+
+    def step(self, action: TensorTree) -> TimeStep:
+        choice_value = action["choice"]
+        if isinstance(choice_value, Mapping):
+            raise TypeError("choice must be a tensor leaf")
+        choice = int(choice_value[0])
+        if choice == 1:
+            self._position = min(self._position + 1, self._target)
+        self._step_id += 1
+        return self._timestep()
+
+    def _timestep(self) -> TimeStep:
+        reached_target = self._position == self._target
+        truncated = not reached_target and self._step_id >= self._max_steps
+        return TimeStep(
+            observation={"position": np.array([self._position], dtype=np.int64)},
+            reward=np.array([1.0 if reached_target else -0.01], dtype=np.float32),
+            terminated=np.array([reached_target], dtype=np.bool_),
+            truncated=np.array([truncated], dtype=np.bool_),
+            action_mask={"choice": np.array([True, not reached_target], dtype=np.bool_)},
+            episode_id=self._episode_id,
+            step_id=self._step_id,
+        )
+
+
+def always_increment(timestep: TimeStep) -> TensorTree:
+    del timestep
+    return {"choice": np.array([1], dtype=np.int64)}
+
+
+def make_environment() -> CounterEnvironment:
+    return CounterEnvironment()
+
+
+__all__ = ["CounterEnvironment", "always_increment", "make_environment"]

game_learning_runtime/integrations/__init__.py

@@ -0,0 +1 @@
+"""Optional learning-framework integrations."""

game_learning_runtime/integrations/torchrl.py

@@ -0,0 +1,153 @@
+"""TorchRL ``EnvBase`` adapter for any GLR game environment."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+import numpy as np
+
+from game_learning_runtime.contracts import TensorTree, TimeStep
+from game_learning_runtime.environment import ContractEnvironment, GameEnvironment
+from game_learning_runtime.errors import OptionalDependencyError
+from game_learning_runtime.specs import CompositeSpec, TensorSpec
+
+try:
+    import torch
+    from tensordict import TensorDict, TensorDictBase
+    from torchrl.data import Bounded, Categorical, Composite, Unbounded
+    from torchrl.envs import EnvBase
+except ImportError as error:  # pragma: no cover - exercised without the optional extra
+    raise OptionalDependencyError(
+        "TorchRL support requires `uv add game-learning-runtime[torchrl]`"
+    ) from error
+
+
+def _torch_dtype(dtype: np.dtype[Any]) -> torch.dtype:
+    return torch.from_numpy(np.empty((), dtype=dtype)).dtype
+
+
+def _leaf_spec(spec: TensorSpec, *, device: torch.device) -> Any:
+    if spec.is_dynamic:
+        raise ValueError("TorchRL EnvBase specs require static shapes")
+    shape = tuple(int(dimension) for dimension in spec.shape if dimension is not None)
+    dtype = _torch_dtype(np.dtype(spec.dtype))
+    if spec.dtype == np.dtype(np.bool_):
+        return Categorical(n=2, shape=shape, dtype=torch.bool, device=device)
+    if spec.minimum is not None and spec.maximum is not None:
+        return Bounded(
+            low=torch.as_tensor(spec.minimum, dtype=dtype, device=device),
+            high=torch.as_tensor(spec.maximum, dtype=dtype, device=device),
+            shape=shape,
+            dtype=dtype,
+            device=device,
+        )
+    return Unbounded(shape=shape, dtype=dtype, device=device)
+
+
+def _composite_spec(spec: CompositeSpec, *, device: torch.device) -> Composite:
+    values = {
+        key: _composite_spec(value, device=device)
+        if isinstance(value, CompositeSpec)
+        else _leaf_spec(value, device=device)
+        for key, value in spec.fields.items()
+    }
+    return Composite(values, shape=(), device=device)
+
+
+def _tree_to_tensordict(tree: TensorTree, *, device: torch.device) -> TensorDict:
+    values = {
+        key: _tree_to_tensordict(value, device=device)
+        if isinstance(value, Mapping)
+        else torch.as_tensor(np.array(value, copy=True), device=device)
+        for key, value in tree.items()
+    }
+    return TensorDict(values, batch_size=(), device=device)
+
+
+def _action_to_tree(tensordict: TensorDictBase, spec: CompositeSpec) -> TensorTree:
+    result: dict[str, Any] = {}
+    for key, child_spec in spec.fields.items():
+        value = tensordict.get(key)
+        if isinstance(child_spec, CompositeSpec):
+            if not isinstance(value, TensorDictBase):
+                raise TypeError(f"TorchRL action field {key!r} must be a TensorDict")
+            result[key] = _action_to_tree(value, child_spec)
+        else:
+            result[key] = value.detach().cpu().numpy()
+    return result
+
+
+class TorchRLEnvironment(EnvBase):  # type: ignore[misc]
+    """Adapt the learner-neutral GLR port to the current TorchRL environment API."""
+
+    batch_locked = True
+
+    def __init__(
+        self,
+        environment: GameEnvironment,
+        *,
+        device: str | torch.device = "cpu",
+        run_type_checks: bool = True,
+    ) -> None:
+        self._glr = (
+            environment
+            if isinstance(environment, ContractEnvironment)
+            else ContractEnvironment(environment)
+        )
+        self._next_seed: int | None = None
+        super().__init__(device=device, batch_size=(), run_type_checks=run_type_checks)
+        torch_device = torch.device(device)
+        observation_values: dict[str, Any] = {
+            "observation": _composite_spec(self._glr.spec.observation, device=torch_device)
+        }
+        if self._glr.spec.action_mask is not None:
+            observation_values["action_mask"] = _composite_spec(
+                self._glr.spec.action_mask, device=torch_device
+            )
+        self.observation_spec = Composite(observation_values, shape=(), device=torch_device)
+        self.action_spec = _composite_spec(self._glr.spec.action, device=torch_device)
+        self.reward_spec = _leaf_spec(self._glr.spec.reward, device=torch_device)
+        done_leaf = _leaf_spec(self._glr.spec.done, device=torch_device)
+        self.done_spec = Composite(
+            done=done_leaf,
+            terminated=done_leaf.clone(),
+            truncated=done_leaf.clone(),
+            shape=(),
+            device=torch_device,
+        )
+
+    def _step(self, tensordict: TensorDictBase) -> TensorDictBase:
+        action = _action_to_tree(tensordict, self._glr.spec.action)
+        return self._from_timestep(self._glr.step(action), include_reward=True)
+
+    def _reset(self, tensordict: TensorDictBase | None = None, **kwargs: Any) -> TensorDictBase:
+        del tensordict, kwargs
+        timestep = self._glr.reset(seed=self._next_seed)
+        self._next_seed = None
+        return self._from_timestep(timestep, include_reward=False)
+
+    def _set_seed(self, seed: int | None) -> None:
+        self._next_seed = seed
+
+    def _close(self) -> None:
+        self._glr.close()
+
+    def _from_timestep(self, timestep: TimeStep, *, include_reward: bool) -> TensorDict:
+        device = self.device or torch.device("cpu")
+        terminated = torch.as_tensor(np.array(timestep.terminated, copy=True), device=device)
+        truncated = torch.as_tensor(np.array(timestep.truncated, copy=True), device=device)
+        values: dict[str, Any] = {
+            "observation": _tree_to_tensordict(timestep.observation, device=device),
+            "done": torch.logical_or(terminated, truncated),
+            "terminated": terminated,
+            "truncated": truncated,
+        }
+        if timestep.action_mask is not None:
+            values["action_mask"] = _tree_to_tensordict(timestep.action_mask, device=device)
+        if include_reward:
+            values["reward"] = torch.as_tensor(np.array(timestep.reward, copy=True), device=device)
+        return TensorDict(values, batch_size=(), device=device)
+
+
+__all__ = ["TorchRLEnvironment"]

game_learning_runtime/protocol/__init__.py

@@ -0,0 +1,15 @@
+"""Access to the packaged GLR protocol definition."""
+
+from collections.abc import Iterator
+from contextlib import contextmanager
+from importlib.resources import as_file, files
+from pathlib import Path
+
+
+@contextmanager
+def protocol_path() -> Iterator[Path]:
+    """Yield a filesystem path to the packaged ``runtime.proto`` schema."""
+
+    resource = files("game_learning_runtime.protocol").joinpath("glr/v1/runtime.proto")
+    with as_file(resource) as path:
+        yield path

game_learning_runtime/protocol/glr/v1/runtime.proto

@@ -0,0 +1,93 @@
+syntax = "proto3";
+
+package glr.v1;
+
+option csharp_namespace = "GameLearningRuntime.Protocol.V1";
+option java_multiple_files = true;
+option java_package = "dev.glr.protocol.v1";
+
+enum DType {
+  DTYPE_UNSPECIFIED = 0;
+  DTYPE_BOOL = 1;
+  DTYPE_UINT8 = 2;
+  DTYPE_INT32 = 3;
+  DTYPE_INT64 = 4;
+  DTYPE_FLOAT32 = 5;
+  DTYPE_FLOAT64 = 6;
+}
+
+enum SpaceKind {
+  SPACE_KIND_UNSPECIFIED = 0;
+  SPACE_KIND_CONTINUOUS = 1;
+  SPACE_KIND_DISCRETE = 2;
+  SPACE_KIND_MULTI_DISCRETE = 3;
+  SPACE_KIND_BINARY = 4;
+}
+
+message TensorSpec {
+  string path = 1;
+  repeated int64 shape = 2; // -1 denotes a dynamic dimension.
+  DType dtype = 3;
+  SpaceKind kind = 4;
+  optional double minimum = 5;
+  optional double maximum = 6;
+  string description = 7;
+}
+
+message Tensor {
+  repeated int64 shape = 1;
+  DType dtype = 2;
+  bytes data = 3;
+}
+
+message EnvironmentDescriptor {
+  string environment_id = 1;
+  string protocol_version = 2;
+  repeated TensorSpec observations = 3;
+  repeated TensorSpec actions = 4;
+  repeated TensorSpec action_masks = 5;
+  TensorSpec reward = 6;
+  TensorSpec done = 7;
+  repeated string capabilities = 8;
+  map<string, string> metadata = 9;
+}
+
+message DescribeRequest {}
+
+message ResetRequest {
+  optional uint64 seed = 1;
+  map<string, string> options = 2;
+}
+
+message StepRequest {
+  string episode_id = 1;
+  uint64 expected_step_id = 2;
+  map<string, Tensor> action = 3;
+}
+
+message RuntimeEvent {
+  string name = 1;
+  uint64 timestamp_ns = 2;
+  bytes json_payload = 3;
+}
+
+message TimeStep {
+  string episode_id = 1;
+  uint64 step_id = 2;
+  uint64 timestamp_ns = 3;
+  map<string, Tensor> observation = 4;
+  Tensor reward = 5;
+  Tensor terminated = 6;
+  Tensor truncated = 7;
+  map<string, Tensor> action_mask = 8;
+  repeated RuntimeEvent events = 9;
+  bytes json_info = 10;
+}
+
+service GameRuntime {
+  rpc Describe(DescribeRequest) returns (EnvironmentDescriptor);
+  rpc Reset(ResetRequest) returns (TimeStep);
+  rpc Step(StepRequest) returns (TimeStep);
+  rpc Interact(stream StepRequest) returns (stream TimeStep);
+}
+

game_learning_runtime/py.typed

@@ -0,0 +1 @@
+

game_learning_runtime/serialization.py

@@ -0,0 +1,171 @@
+"""Portable JSONL transition records for BC, replay, and offline learning."""
+
+from __future__ import annotations
+
+import base64
+import json
+from collections.abc import Iterator, Mapping
+from pathlib import Path
+from types import TracebackType
+from typing import IO, Any
+from uuid import UUID
+
+import numpy as np
+from numpy.typing import NDArray
+
+from game_learning_runtime.contracts import Event, TensorTree, Transition
+
+RECORD_SCHEMA = "glr.transition.v1"
+
+
+def _encode_array(array: NDArray[Any]) -> dict[str, Any]:
+    contiguous = np.ascontiguousarray(array)
+    return {
+        "dtype": contiguous.dtype.str,
+        "shape": list(contiguous.shape),
+        "data": base64.b64encode(contiguous.tobytes()).decode("ascii"),
+    }
+
+
+def _decode_array(value: Mapping[str, Any]) -> NDArray[Any]:
+    dtype = np.dtype(value["dtype"])
+    shape = tuple(int(dimension) for dimension in value["shape"])
+    raw = base64.b64decode(value["data"], validate=True)
+    expected_size = int(np.prod(shape, dtype=np.int64)) * dtype.itemsize
+    if len(raw) != expected_size:
+        raise ValueError(f"tensor payload has {len(raw)} bytes; expected {expected_size}")
+    return np.frombuffer(raw, dtype=dtype).reshape(shape).copy()
+
+
+def _encode_tree(tree: TensorTree | None) -> dict[str, Any] | None:
+    if tree is None:
+        return None
+    encoded: dict[str, Any] = {}
+    for key, value in tree.items():
+        encoded[key] = (
+            {"tree": _encode_tree(value)}
+            if isinstance(value, Mapping)
+            else {"tensor": _encode_array(value)}
+        )
+    return encoded
+
+
+def _decode_tree(value: Mapping[str, Any] | None) -> TensorTree | None:
+    if value is None:
+        return None
+    decoded: dict[str, Any] = {}
+    for key, item in value.items():
+        if "tree" in item:
+            decoded[key] = _decode_tree(item["tree"])
+        elif "tensor" in item:
+            decoded[key] = _decode_array(item["tensor"])
+        else:
+            raise ValueError(f"tree field {key!r} is missing its value kind")
+    return decoded
+
+
+def transition_to_record(transition: Transition) -> dict[str, Any]:
+    """Convert a transition to a stable, language-neutral JSON value."""
+
+    record = {
+        "schema": RECORD_SCHEMA,
+        "episode_id": str(transition.episode_id),
+        "step_id": transition.step_id,
+        "timestamp_ns": transition.timestamp_ns,
+        "observation": _encode_tree(transition.observation),
+        "action": _encode_tree(transition.action),
+        "action_mask": _encode_tree(transition.action_mask),
+        "reward": _encode_array(transition.reward),
+        "next_observation": _encode_tree(transition.next_observation),
+        "next_action_mask": _encode_tree(transition.next_action_mask),
+        "terminated": _encode_array(transition.terminated),
+        "truncated": _encode_array(transition.truncated),
+        "events": [
+            {
+                "name": event.name,
+                "timestamp_ns": event.timestamp_ns,
+                "payload": dict(event.payload),
+            }
+            for event in transition.events
+        ],
+        "info": dict(transition.info),
+    }
+    json.dumps(record, allow_nan=False)
+    return record
+
+
+def transition_from_record(record: Mapping[str, Any]) -> Transition:
+    """Parse and validate one ``glr.transition.v1`` JSON value."""
+
+    if record.get("schema") != RECORD_SCHEMA:
+        raise ValueError(f"unsupported record schema: {record.get('schema')!r}")
+    observation = _decode_tree(record["observation"])
+    action = _decode_tree(record["action"])
+    next_observation = _decode_tree(record["next_observation"])
+    if observation is None or action is None or next_observation is None:
+        raise ValueError("observation, action, and next_observation are required")
+    return Transition(
+        episode_id=UUID(record["episode_id"]),
+        step_id=int(record["step_id"]),
+        timestamp_ns=int(record["timestamp_ns"]),
+        observation=observation,
+        action=action,
+        action_mask=_decode_tree(record.get("action_mask")),
+        reward=_decode_array(record["reward"]),
+        next_observation=next_observation,
+        next_action_mask=_decode_tree(record.get("next_action_mask")),
+        terminated=_decode_array(record["terminated"]),
+        truncated=_decode_array(record["truncated"]),
+        events=tuple(
+            Event(
+                name=item["name"],
+                timestamp_ns=int(item["timestamp_ns"]),
+                payload=item.get("payload", {}),
+            )
+            for item in record.get("events", [])
+        ),
+        info=record.get("info", {}),
+    )
+
+
+class JsonlTransitionWriter:
+    """Append-only writer for replayable transition datasets."""
+
+    def __init__(self, path: str | Path) -> None:
+        self._path = Path(path)
+        self._stream: IO[str] | None = None
+
+    def __enter__(self) -> JsonlTransitionWriter:
+        self._path.parent.mkdir(parents=True, exist_ok=True)
+        self._stream = self._path.open("a", encoding="utf-8", newline="\n")
+        return self
+
+    def write(self, transition: Transition) -> None:
+        if self._stream is None:
+            raise RuntimeError("writer must be used as a context manager")
+        json.dump(transition_to_record(transition), self._stream, separators=(",", ":"))
+        self._stream.write("\n")
+        self._stream.flush()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        if self._stream is not None:
+            self._stream.close()
+            self._stream = None
+
+
+def read_jsonl_transitions(path: str | Path) -> Iterator[Transition]:
+    """Stream transitions from a GLR JSONL dataset."""
+
+    with Path(path).open(encoding="utf-8") as stream:
+        for line_number, line in enumerate(stream, start=1):
+            if not line.strip():
+                continue
+            try:
+                yield transition_from_record(json.loads(line))
+            except (KeyError, TypeError, ValueError, json.JSONDecodeError) as error:
+                raise ValueError(f"invalid transition record at line {line_number}") from error

game_learning_runtime/specs.py

@@ -0,0 +1,182 @@
+"""Framework-neutral tensor and environment specifications."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from enum import Enum
+from types import MappingProxyType
+from typing import Any, TypeAlias
+
+import numpy as np
+from numpy.typing import NDArray
+
+from game_learning_runtime.errors import ContractViolation
+
+
+class SpaceKind(str, Enum):
+    """Semantic meaning of a tensor leaf in an observation or action tree."""
+
+    CONTINUOUS = "continuous"
+    DISCRETE = "discrete"
+    MULTI_DISCRETE = "multi_discrete"
+    BINARY = "binary"
+
+
+Shape = tuple[int | None, ...]
+Limit: TypeAlias = int | float | NDArray[Any]
+
+
+def _immutable_limit(value: Limit | None) -> Limit | None:
+    if value is None or isinstance(value, (int, float)):
+        return value
+    array = np.array(value, copy=True)
+    array.flags.writeable = False
+    return array
+
+
+@dataclass(frozen=True, slots=True)
+class TensorSpec:
+    """Describes and validates one tensor leaf.
+
+    A ``None`` dimension is dynamic. Composite trees provide hybrid,
+    parameterized, and hierarchical spaces without adding algorithm concepts to
+    the runtime contract.
+    """
+
+    shape: Shape
+    dtype: np.dtype[Any] | str | type[Any]
+    kind: SpaceKind = SpaceKind.CONTINUOUS
+    minimum: Limit | None = None
+    maximum: Limit | None = None
+    description: str = ""
+
+    def __post_init__(self) -> None:
+        normalized_shape = tuple(self.shape)
+        if any(dimension is not None and dimension < 0 for dimension in normalized_shape):
+            raise ValueError("tensor dimensions must be non-negative or None")
+        normalized_dtype = np.dtype(self.dtype)
+        if self.kind in {SpaceKind.DISCRETE, SpaceKind.MULTI_DISCRETE} and not np.issubdtype(
+            normalized_dtype, np.integer
+        ):
+            raise ValueError(f"{self.kind.value} tensors require an integer dtype")
+        if self.kind is SpaceKind.BINARY and normalized_dtype != np.dtype(np.bool_):
+            raise ValueError("binary tensors require the bool dtype")
+        if (
+            self.minimum is not None
+            and self.maximum is not None
+            and np.any(np.asarray(self.minimum) > np.asarray(self.maximum))
+        ):
+            raise ValueError("minimum cannot exceed maximum")
+        object.__setattr__(self, "shape", normalized_shape)
+        object.__setattr__(self, "dtype", normalized_dtype)
+        object.__setattr__(self, "minimum", _immutable_limit(self.minimum))
+        object.__setattr__(self, "maximum", _immutable_limit(self.maximum))
+
+    @property
+    def is_dynamic(self) -> bool:
+        return any(dimension is None for dimension in self.shape)
+
+    def validate(self, value: Any, *, path: str = "tensor") -> NDArray[Any]:
+        array = np.asarray(value)
+        if array.dtype != self.dtype:
+            raise ContractViolation(f"{path} has dtype {array.dtype}; expected {self.dtype}")
+        if array.ndim != len(self.shape):
+            raise ContractViolation(f"{path} has shape {array.shape}; expected {self.shape}")
+        for actual, expected in zip(array.shape, self.shape, strict=True):
+            if expected is not None and actual != expected:
+                raise ContractViolation(f"{path} has shape {array.shape}; expected {self.shape}")
+        if self.minimum is not None and np.any(array < self.minimum):
+            raise ContractViolation(f"{path} contains a value below {self.minimum}")
+        if self.maximum is not None and np.any(array > self.maximum):
+            raise ContractViolation(f"{path} contains a value above {self.maximum}")
+        return array
+
+
+SpecNode: TypeAlias = "TensorSpec | CompositeSpec"
+
+
+@dataclass(frozen=True, slots=True)
+class CompositeSpec:
+    """A recursively nested tensor tree specification."""
+
+    fields: Mapping[str, SpecNode]
+    description: str = ""
+
+    def __post_init__(self) -> None:
+        if not self.fields:
+            raise ValueError("a composite spec requires at least one field")
+        copied: dict[str, SpecNode] = {}
+        for name, spec in self.fields.items():
+            if not name or "." in name:
+                raise ValueError("field names must be non-empty and cannot contain dots")
+            if not isinstance(spec, (TensorSpec, CompositeSpec)):
+                raise TypeError(f"field {name!r} is not a TensorSpec or CompositeSpec")
+            copied[name] = spec
+        object.__setattr__(self, "fields", MappingProxyType(copied))
+
+    @property
+    def is_dynamic(self) -> bool:
+        return any(spec.is_dynamic for spec in self.fields.values())
+
+    def validate(self, value: Mapping[str, Any], *, path: str = "tree") -> None:
+        if not isinstance(value, Mapping):
+            raise ContractViolation(f"{path} must be a mapping")
+        actual_keys = set(value)
+        expected_keys = set(self.fields)
+        if actual_keys != expected_keys:
+            missing = sorted(expected_keys - actual_keys)
+            unexpected = sorted(actual_keys - expected_keys)
+            raise ContractViolation(
+                f"{path} keys differ from the contract; missing={missing}, unexpected={unexpected}"
+            )
+        for name, spec in self.fields.items():
+            child_path = f"{path}.{name}"
+            child = value[name]
+            if isinstance(spec, CompositeSpec):
+                spec.validate(child, path=child_path)
+            else:
+                spec.validate(child, path=child_path)
+
+    def flatten(self, *, prefix: str = "") -> dict[str, TensorSpec]:
+        result: dict[str, TensorSpec] = {}
+        for name, spec in self.fields.items():
+            path = f"{prefix}.{name}" if prefix else name
+            if isinstance(spec, CompositeSpec):
+                result.update(spec.flatten(prefix=path))
+            else:
+                result[path] = spec
+        return result
+
+
+def _default_reward_spec() -> TensorSpec:
+    return TensorSpec(shape=(1,), dtype=np.float32)
+
+
+def _default_done_spec() -> TensorSpec:
+    return TensorSpec(shape=(1,), dtype=np.bool_, kind=SpaceKind.BINARY)
+
+
+@dataclass(frozen=True, slots=True)
+class EnvironmentSpec:
+    """Complete machine-readable contract exposed by a game adapter."""
+
+    environment_id: str
+    observation: CompositeSpec
+    action: CompositeSpec
+    reward: TensorSpec = field(default_factory=_default_reward_spec)
+    done: TensorSpec = field(default_factory=_default_done_spec)
+    action_mask: CompositeSpec | None = None
+    protocol_version: str = "1.0"
+    capabilities: frozenset[str] = frozenset()
+    metadata: Mapping[str, str] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        if not self.environment_id or any(character.isspace() for character in self.environment_id):
+            raise ValueError("environment_id must be non-empty and cannot contain whitespace")
+        if self.reward.kind is not SpaceKind.CONTINUOUS:
+            raise ValueError("reward spec must be continuous")
+        if self.done.kind is not SpaceKind.BINARY:
+            raise ValueError("done spec must be binary")
+        object.__setattr__(self, "capabilities", frozenset(self.capabilities))
+        object.__setattr__(self, "metadata", MappingProxyType(dict(self.metadata)))

game_learning_runtime-0.1.0.dist-info/METADATA

@@ -0,0 +1,165 @@
+Metadata-Version: 2.5
+Name: game-learning-runtime
+Version: 0.1.0
+Summary: A universal runtime for connecting games to learning systems and AI agents.
+Project-URL: Documentation, https://github.com/loonghao/GameLearningRuntime#readme
+Project-URL: Issues, https://github.com/loonghao/GameLearningRuntime/issues
+Project-URL: Repository, https://github.com/loonghao/GameLearningRuntime
+Author-email: loonghao <hal.long@outlook.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: environment,game-ai,imitation-learning,reinforcement-learning,torchrl
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: numpy<2.3,>=1.26
+Provides-Extra: torchrl
+Requires-Dist: torch>=2.8; extra == 'torchrl'
+Requires-Dist: torchrl<0.14,>=0.13; extra == 'torchrl'
+Description-Content-Type: text/markdown
+
+# Game Learning Runtime
+
+[![CI](https://github.com/loonghao/GameLearningRuntime/actions/workflows/ci.yml/badge.svg)](https://github.com/loonghao/GameLearningRuntime/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![Python](https://img.shields.io/badge/Python-3.10--3.13-3776AB.svg)](pyproject.toml)
+
+Game Learning Runtime (GLR) is a framework-neutral contract between game
+runtimes and learning systems. A game adapter describes observations, actions,
+action masks, rewards, events, and episode boundaries once; TorchRL, custom PPO
+or IMPALA learners, behavior cloning, offline datasets, evaluators, and QA tools
+can then consume the same interface.
+
+> A universal runtime for connecting games to learning systems and AI agents.
+
+GLR is intended for games and test environments you own or are authorized to
+instrument. It does not include anti-cheat bypasses, stealth injection, or
+game-specific reverse-engineering code.
+
+## Why this boundary
+
+```text
+Game / simulator
+      │
+      ▼
+Runtime adapter (C#, C++, Rust, Python, official API, ...)
+      │
+      ▼
+GLR protocol + environment contract
+      │
+      ├── TorchRL
+      ├── custom PPO / IMPALA
+      ├── BC / DAgger / offline learning
+      ├── recorder / replay
+      └── evaluation / automated QA
+```
+
+Game adapters never import PPO, IMPALA, BC, or TorchRL. Learning code never
+needs to know whether the game is Unity, Unreal, Source, native, or a test
+simulator. The standardized boundary is the data and lifecycle contract, not a
+single implementation language or transport.
+
+## Implemented in v0.1
+
+- Recursive tensor-tree specs for continuous, discrete, multi-discrete, binary,
+  hybrid, parameterized, and hierarchical data.
+- A `GameEnvironment` port with reset, step, close, action masks, semantic
+  events, terminated/truncated signals, episode IDs, and monotonic step IDs.
+- A fail-closed `ContractEnvironment` wrapper that validates every boundary.
+- Fixed-length actor `Unroll` collection suitable for custom PPO and IMPALA.
+- Versioned `glr.transition.v1` JSONL records for BC, replay, and offline data.
+- A packaged `glr.v1` Protobuf service with unary and bidirectional streaming
+  interaction contracts.
+- An optional TorchRL `EnvBase` adapter tested against TorchRL 0.13.
+
+Game-specific runtime adapters, generated C#/C++/Rust protocol SDKs,
+distributed actor transport, and learner implementations are roadmap items—not
+features claimed by this initial release.
+
+## Install
+
+Until PyPI trusted publishing is enabled, pin a GitHub release tag:
+
+```powershell
+uv add "game-learning-runtime @ git+https://github.com/loonghao/GameLearningRuntime@v0.1.0"
+```
+
+Add the TorchRL integration only where training requires it:
+
+```powershell
+uv add "game-learning-runtime[torchrl] @ git+https://github.com/loonghao/GameLearningRuntime@v0.1.0"
+```
+
+## Minimal environment
+
+```python
+import numpy as np
+
+from game_learning_runtime import ContractEnvironment, SyncCollector
+from game_learning_runtime.examples import CounterEnvironment, always_increment
+
+environment = ContractEnvironment(CounterEnvironment(target=3))
+collector = SyncCollector(environment, actor_id="local-actor")
+unroll = collector.collect(always_increment, steps=16, policy_version=0)
+
+print(len(unroll.transitions), unroll.total_reward)
+```
+
+Run the complete example from a clone:
+
+```powershell
+uv sync --frozen
+uv run python -c "from game_learning_runtime import *; from game_learning_runtime.examples import *; print(SyncCollector(ContractEnvironment(make_environment())).collect(always_increment, steps=4).total_reward)"
+```
+
+For TorchRL:
+
+```python
+from game_learning_runtime.examples import CounterEnvironment
+from game_learning_runtime.integrations.torchrl import TorchRLEnvironment
+
+env = TorchRLEnvironment(CounterEnvironment())
+rollout = env.rollout(max_steps=32)
+```
+
+## Reuse the CI workflow
+
+Any uv-managed Python repository can call the public reusable workflow:
+
+```yaml
+jobs:
+  quality:
+    uses: loonghao/GameLearningRuntime/.github/workflows/reusable-python-ci.yml@v0.1.0
+    with:
+      python-versions: '["3.10", "3.12"]'
+      sync-args: "--frozen --all-groups"
+      lint-command: "uv run ruff check . && uv run mypy"
+      test-command: "uv run pytest"
+```
+
+Pin a release tag or commit SHA in production repositories. The workflow never
+receives deployment secrets and only checks out/tests the calling repository.
+
+## Documentation
+
+- [Getting started](docs/guides/getting-started.md)
+- [Architecture](docs/architecture/overview.md)
+- [Protocol and data flow](docs/architecture/data-flow.md)
+- [Local development](docs/runbooks/local-development.md)
+- [Release runbook](docs/runbooks/release.md)
+- [Roadmap](docs/planning/roadmap.md)
+- [Architecture decisions](docs/decisions/README.md)
+
+## Contributing and security
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for the development contract and
+[SECURITY.md](SECURITY.md) for private vulnerability reporting. GLR is licensed
+under the [MIT License](LICENSE).

game_learning_runtime-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+game_learning_runtime/__init__.py,sha256=yV_oNHz0vzMaRRgfq-040jTaqMmkQJmLe1ZDlCabZFQ,1380
+game_learning_runtime/collector.py,sha256=BSK2gkYO-Zr0Y1OQp1s1aNh07faQt2CcaUV26JxShsI,2911
+game_learning_runtime/contracts.py,sha256=UpOoU3TreFn7CFR-J3w1VQCpI_cz4pG4a_fAY3rrF00,5412
+game_learning_runtime/environment.py,sha256=QOgt_txru1uG5ODPo7ybDjmnQKlrsNwRTQuGEVn061k,4491
+game_learning_runtime/errors.py,sha256=jP1rHrllJba2Wy5Ya1bb1SXID9ho93guYTQLL_YV83Y,377
+game_learning_runtime/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+game_learning_runtime/serialization.py,sha256=DfefIIna9CMtCPLQLb7qFsDYkpZ5QF6Gcn-bQ3dqffw,6225
+game_learning_runtime/specs.py,sha256=3SDFf0a7YqqjGw1dho0nXD2nUnZ03KjnluEvsxpC2fU,7263
+game_learning_runtime/examples/__init__.py,sha256=znOFyaBrWhhqxu1H7wuqbddf6rhWSuwXhbbutGC0pNI,239
+game_learning_runtime/examples/counter.py,sha256=dx9vUf0XcBFiKKg9Qq-YwWhGOFX35hBjBg9SA4D0zg4,3297
+game_learning_runtime/integrations/__init__.py,sha256=kM3rSYjiDEZPoNjxe77V8qNbpcGLdBUDKWK8bw04tW0,48
+game_learning_runtime/integrations/torchrl.py,sha256=xfmSew2Qn1FoBs6sTooGFbJYSymOHXZXD-gBsweqk94,6211
+game_learning_runtime/protocol/__init__.py,sha256=6Hxr7MS2dzPkEUaYLLMCEDdnghlwpfajhbjhu1nZL2Q,479
+game_learning_runtime/protocol/glr/v1/runtime.proto,sha256=gDt2A2ho9-Wc207SW3O2VJfVTkebz72lQ94btu_YfYE,2027
+game_learning_runtime-0.1.0.dist-info/METADATA,sha256=ooMXrkIjkK7HztV-KF1YpXXOV9qdtB9ggFiS0DCusEI,6350
+game_learning_runtime-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+game_learning_runtime-0.1.0.dist-info/licenses/LICENSE,sha256=tI9ZnJarjIkjC-Mje0HidFJgMMAhrK9qV-JdFSshBZw,1066
+game_learning_runtime-0.1.0.dist-info/RECORD,,

game_learning_runtime-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

game_learning_runtime-0.1.0.dist-info/licenses/LICENSE

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