pyPhotonRealtime 0.0.1__tar.gz

pyphotonrealtime-0.0.1/.gitattributes

@@ -0,0 +1,2 @@
+* text=auto eol=lf
+*.png binary

pyphotonrealtime-0.0.1/.github/workflows/ci.yml

@@ -0,0 +1,57 @@
+name: CI
+
+on:
+  push:
+    branches: ["master"]
+  pull_request:
+    branches: ["master"]
+  workflow_dispatch:
+  schedule:
+    - cron: "17 4 * * *" # nightly e2e against Photon Cloud
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - name: Install pinned ruff, mypy and test deps
+        run: python -m pip install -e ".[lint,test]"
+      - name: Ruff check
+        run: python -m ruff check .
+      - name: Ruff format check
+        run: python -m ruff format --check .
+      - name: Mypy (strict)
+        run: python -m mypy
+
+  test:
+    needs: lint
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python -m pip install -e ".[test]"
+      - run: python -m pytest -q
+
+  e2e:
+    # Live servers: nightly and on demand only, never on PRs (forks have no secret).
+    if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
+        with:
+          python-version: "3.12"
+      - run: python -m pip install -e ".[test]"
+      - name: Run e2e tests
+        env:
+          PHOTON_APP_ID: ${{ secrets.PHOTON_APP_ID }}
+        run: python -m pytest -m e2e -rxs

pyphotonrealtime-0.0.1/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+.vscode/PythonImportHelper-v2-Completion.json
+venv/
+venv2/
+.env
+.venv/
+.venv*/

pyphotonrealtime-0.0.1/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.5
+Name: pyPhotonRealtime
+Version: 0.0.1
+Summary: Pure-Python client for games running on Photon Realtime
+Author: Michael K. Steinberg
+Requires-Python: >=3.12
+Requires-Dist: pycryptodome>=3.20
+Provides-Extra: lint
+Requires-Dist: mypy==2.4.0; extra == 'lint'
+Requires-Dist: ruff==0.16.10; extra == 'lint'
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# pyPhotonRealtime
+
+A pure-Python client for games running on [Photon Realtime](https://doc.photonengine.com/realtime-core/v6/getting-started/realtime-intro).
+Connect, matchmake, join rooms, raise events and track properties and players,
+all from Python.
+
+> **Status: pre-alpha.** The wire layer works (it came from
+> [prison-architect-server](https://github.com/Michael-K-Stein/prison-architect-server)).
+> The client workflow is still scaffolding. See [ROADMAP.md](ROADMAP.md).
+
+## Install
+
+```bash
+pip install -e ".[test,lint]"   # from a checkout; not on PyPI yet
+```
+
+Requires Python 3.12+. Fully type-annotated (`py.typed`), checked with `mypy --strict`.
+
+## Intended usage
+
+```python
+import time
+from pyphotonrealtime import AppSettings, RealtimeClient
+from pyphotonrealtime.realtime import (
+    ConnectionCallbacks,
+    MatchmakingCallbacks,
+    EnterRoomParams,
+)
+
+
+class Bot(ConnectionCallbacks, MatchmakingCallbacks):
+    def __init__(self, client):
+        self.client = client
+
+    def on_connected_to_master(self):
+        self.client.op_join_or_create_room(EnterRoomParams(room_name="lobby-1"))
+
+    def on_joined_room(self):
+        self.client.op_raise_event(1, {"hello": "world"})
+
+
+client = RealtimeClient()
+client.add_callback_target(Bot(client))
+client.connect_using_settings(
+    AppSettings(app_id_realtime="<your app id>", fixed_region="eu")
+)
+
+while True:
+    client.service()  # nothing happens on the wire without this
+    time.sleep(1 / 30)
+```
+
+## Layout
+
+| Package | Role |
+|---|---|
+| `pyphotonrealtime.protocol` | Wire format: typed parameters, packet framing, DH/AES |
+| `pyphotonrealtime.transport` | Byte transports (TCP; UDP/WebSocket planned) |
+| `pyphotonrealtime.peer` | `PhotonPeer`: one connection, the service loop, keep-alive, encryption |
+| `pyphotonrealtime.realtime` | `RealtimeClient`: Name/Master/Game server workflow, rooms, players, callbacks |
+
+## Development
+
+```bash
+python -m ruff --version          # must match the pin in pyproject.toml
+python -m ruff check .            # select = ["ALL"], see ruff.toml
+python -m ruff format --check .
+python -m mypy                    # strict
+python -m pytest -q               # unit tests (e2e excluded)
+PHOTON_APP_ID=... python -m pytest -m e2e   # live Photon Cloud, opt-in
+```
+
+## Testing
+
+Unit tests check that the protocol layer agrees with itself (round trips, framing).
+That doesn't prove it agrees with Photon. The `e2e` tests in `tests/e2e/` do that
+against the real Photon Cloud. They need a Realtime app id in `PHOTON_APP_ID`, and
+CI runs them nightly and on manual dispatch, never on PRs.
+```

pyphotonrealtime-0.0.1/README.md

@@ -0,0 +1,79 @@
+# pyPhotonRealtime
+
+A pure-Python client for games running on [Photon Realtime](https://doc.photonengine.com/realtime-core/v6/getting-started/realtime-intro).
+Connect, matchmake, join rooms, raise events and track properties and players,
+all from Python.
+
+> **Status: pre-alpha.** The wire layer works (it came from
+> [prison-architect-server](https://github.com/Michael-K-Stein/prison-architect-server)).
+> The client workflow is still scaffolding. See [ROADMAP.md](ROADMAP.md).
+
+## Install
+
+```bash
+pip install -e ".[test,lint]"   # from a checkout; not on PyPI yet
+```
+
+Requires Python 3.12+. Fully type-annotated (`py.typed`), checked with `mypy --strict`.
+
+## Intended usage
+
+```python
+import time
+from pyphotonrealtime import AppSettings, RealtimeClient
+from pyphotonrealtime.realtime import (
+    ConnectionCallbacks,
+    MatchmakingCallbacks,
+    EnterRoomParams,
+)
+
+
+class Bot(ConnectionCallbacks, MatchmakingCallbacks):
+    def __init__(self, client):
+        self.client = client
+
+    def on_connected_to_master(self):
+        self.client.op_join_or_create_room(EnterRoomParams(room_name="lobby-1"))
+
+    def on_joined_room(self):
+        self.client.op_raise_event(1, {"hello": "world"})
+
+
+client = RealtimeClient()
+client.add_callback_target(Bot(client))
+client.connect_using_settings(
+    AppSettings(app_id_realtime="<your app id>", fixed_region="eu")
+)
+
+while True:
+    client.service()  # nothing happens on the wire without this
+    time.sleep(1 / 30)
+```
+
+## Layout
+
+| Package | Role |
+|---|---|
+| `pyphotonrealtime.protocol` | Wire format: typed parameters, packet framing, DH/AES |
+| `pyphotonrealtime.transport` | Byte transports (TCP; UDP/WebSocket planned) |
+| `pyphotonrealtime.peer` | `PhotonPeer`: one connection, the service loop, keep-alive, encryption |
+| `pyphotonrealtime.realtime` | `RealtimeClient`: Name/Master/Game server workflow, rooms, players, callbacks |
+
+## Development
+
+```bash
+python -m ruff --version          # must match the pin in pyproject.toml
+python -m ruff check .            # select = ["ALL"], see ruff.toml
+python -m ruff format --check .
+python -m mypy                    # strict
+python -m pytest -q               # unit tests (e2e excluded)
+PHOTON_APP_ID=... python -m pytest -m e2e   # live Photon Cloud, opt-in
+```
+
+## Testing
+
+Unit tests check that the protocol layer agrees with itself (round trips, framing).
+That doesn't prove it agrees with Photon. The `e2e` tests in `tests/e2e/` do that
+against the real Photon Cloud. They need a Realtime app id in `PHOTON_APP_ID`, and
+CI runs them nightly and on manual dispatch, never on PRs.
+```

pyphotonrealtime-0.0.1/ROADMAP.md

@@ -0,0 +1,103 @@
+# Roadmap
+
+Goal: be able to do from Python everything a Photon Realtime game does, so a
+game client (or a bot, test harness or proxy) can be written against it. Once it's stable,
+`prison-architect-server` replaces its inline `server/photon` with this package.
+
+## Architecture
+
+The layers follow the official SDKs, so their docs stay usable:
+
+```
+RealtimeClient    (realtime/)   state machine, NS -> MS -> GS hops, rooms, callbacks
+    |
+PhotonPeer        (peer.py)     service loop, op/event queues, keep-alive, timeouts, crypto
+    |
+Transport         (transport/)  TCP | UDP (ENet-style reliability) | WebSocket(s)
+    |
+protocol/                       Protocol16/18 types, framing, DH key exchange, AES
+```
+
+Threading model: like the SDKs, the client is single-threaded and driven by `service()`.
+Every callback runs inside `service()`. An `asyncio` wrapper comes later as a
+separate layer and doesn't change the core.
+
+## Milestones
+
+### M0: Fork and scaffold (done)
+- [x] Extract `server/photon` (history preserved) into `pyphotonrealtime.protocol`
+- [x] Decouple from server-only code (`GamesManager`, logging, settings, queue)
+- [x] Skeletons: `Transport`, `PhotonPeer`, `RealtimeClient`, callbacks, options, Room/Player
+- [x] Packaging (`pyproject.toml`, src layout, `py.typed`), Python 3.12+
+- [x] CI: ruff `ALL` (pinned), `mypy --strict`, pytest on 3.12-3.14, nightly e2e job
+
+### M1: PhotonPeer over TCP
+- [ ] `connect`: send `InitRequest`, handle `InitResponse`, status callbacks
+- [ ] `send_operation` / `dispatch_incoming_commands` into `OperationResponse` / `EventData`
+- [ ] Keep-alive (client-initiated pings) and disconnect timeout
+- [ ] `establish_encryption` (DH via `photon_enc`), encrypted ops (AES-CBC)
+- [ ] Traffic stats and round-trip time
+- [ ] Tests against a fake in-process server (reuse PA server's server-side code as a fixture)
+- [ ] First e2e test passing: TCP connect + Init to `ns.photonengine.io`
+- [ ] Buffer partial TCP writes (`TcpTransport.send` currently blocks)
+
+### M2: RealtimeClient connection workflow
+- [ ] Name Server: `OpGetRegions`, `OpAuthenticate` / `AuthOnce`, region pinging
+- [ ] Master Server hop with token; direct-master mode (`use_name_server=False`)
+- [ ] Disconnect causes, `reconnect_and_rejoin`
+- [ ] Custom authentication (`AuthenticationValues`)
+- [ ] e2e: Name Server -> Master Server against Photon Cloud (`tests/e2e`, currently xfail)
+
+### M3: Matchmaking and lobbies
+- [ ] Join/leave lobby, room list and `GameListUpdate` events, lobby stats
+- [ ] Create / Join / JoinOrCreate / JoinRandom / Rejoin, then the Game Server hop
+- [ ] `OpFindFriends`, expected users, SQL lobby filters
+
+### M4: In-room
+- [ ] Join/Leave/PropertiesChanged events, then update `Room`/`Player` and fire callbacks
+- [ ] `op_raise_event` (receivers, target actors, caching, interest groups)
+- [ ] Set room/actor properties, with expected-properties CAS
+- [ ] Master client switching; `op_custom` escape hatch
+- [ ] e2e: two clients in one room exchange events and properties
+
+### M5: Protocol completeness
+- [ ] Protocol 1.8 (`SerializationProtocol.V18`), the default in v5+ SDKs; audit what's implemented today
+- [ ] Custom types registry (`PhotonPeer.RegisterType` equivalent) as a public API
+- [ ] UDP transport with reliable/unreliable channels and fragmentation
+- [ ] WebSocket(s) transport
+
+### M6: Ergonomics and release
+- [ ] `asyncio` facade (`AsyncRealtimeClient`: awaitable connect/join, async event iterator)
+- [ ] Plain Python values in the public API (`dict`/`int`/`str`) instead of `*Parameter` wrappers;
+      automatic conversion at the peer boundary
+- [ ] Docs site, examples (bot, room browser, packet sniffer)
+- [ ] Publish `pyPhotonRealtime` to PyPI (trusted publishing on tag)
+- [ ] Migrate prison-architect-server onto it
+
+## Clean-up inherited from the fork
+- `protocol/event_code.py` has `PrisonArchitectEventCode`. It's game-specific and should move back
+  to the PA repo before 1.0.
+- `OperationCode` mixes client ops with internal aliases (`Authenticate`/`GameList` share 230);
+  split into `OperationCode` / `EventCode` / `ParameterCode` the way the SDK does.
+- `protocol/` is exempt from the missing-docstring rules (D100-D107) in `ruff.toml`. Document it
+  and drop the exemption. Every other rule, and `mypy --strict`, already applies to it.
+- `PacketFactory.event` casts a `PhotonOperationPacket` to `PhotonEventPacket`. Construct the real type.
+
+## Decision: dataclasses vs. pydantic v2
+
+User-facing config (`AppSettings`, `RoomOptions`, `EnterRoomParams`, ...) uses stdlib
+`dataclasses` for now.
+
+| | pydantic v2 | dataclasses |
+|---|---|---|
+| Validation (types, ranges such as `max_players` 0-255) | built in | manual `__post_init__` |
+| Load settings from env / JSON / `.env` (`pydantic-settings`) | yes | manual |
+| JSON schema / serialization of config | yes | manual |
+| Dependency weight | `pydantic-core` Rust wheel (~2 MB); no wheels on some niche platforms/PyPy versions | none |
+| Hot-path cost (per event/packet) | model construction is slower | negligible |
+| Version conflicts for users embedding the lib | possible (v1/v2 pin clashes) | none |
+
+Conclusion: the wire and peer layers (packets, `EventData`, `OperationResponse`) never use pydantic,
+because they're per-packet hot paths. For config, the validation benefit is real but small,
+and a hard dependency costs every user. If validation gets painful, add an optional
+`pyPhotonRealtime[pydantic]` extra with validated config models, or switch only `AppSettings`.

pyphotonrealtime-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pyPhotonRealtime"
+version = "0.0.1"
+description = "Pure-Python client for games running on Photon Realtime"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [{ name = "Michael K. Steinberg" }]
+dependencies = [
+    "pycryptodome>=3.20", # AES for encrypted operations / DH key exchange
+]
+
+[project.optional-dependencies]
+lint = ["ruff==0.16.10", "mypy==2.4.0"]
+test = ["pytest>=8"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/pyphotonrealtime"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = ["-m", "not e2e", "--strict-markers"]
+markers = ["e2e: talks to the real Photon Cloud (needs PHOTON_APP_ID)"]
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+files = ["src", "tests"]

pyphotonrealtime-0.0.1/ruff.toml

@@ -0,0 +1,41 @@
+# Strict: every rule is on. Keep the ruff pin in pyproject.toml (`lint` extra)
+# in sync with CI. Opt out per line with `# noqa: XXX` plus a reason, not here.
+target-version = "py312"
+line-length = 88
+src = ["src", "tests"]
+
+[lint]
+select = ["ALL"]
+ignore = [
+    # Conflict with the formatter (https://docs.astral.sh/ruff/formatter/#conflicting-lint-rules).
+    "COM812",
+    "ISC001",
+    # Mutually exclusive docstring styles; we use D211 + D212.
+    "D203",
+    "D213",
+    # No per-file copyright headers.
+    "CPY001",
+]
+
+# Lets TC00x move typing-only imports under TYPE_CHECKING by adding
+# `from __future__ import annotations` (3.12/3.13 evaluate annotations eagerly).
+future-annotations = true
+
+[lint.per-file-ignores]
+# Inherited from prison-architect-server and not yet documented; see ROADMAP.md.
+"src/pyphotonrealtime/protocol/**" = ["D100", "D101", "D102", "D103", "D104", "D105", "D107"]
+"tests/**" = [
+    "S101",    # assert is how pytest works
+    "D",       # test names are the documentation
+    "PLR2004", # magic values are fine in assertions
+    "SLF001",  # tests may poke private members
+]
+
+[lint.pydocstyle]
+convention = "google"
+
+[lint.flake8-type-checking]
+strict = true
+
+[format]
+docstring-code-format = true

pyphotonrealtime-0.0.1/src/pyphotonrealtime/__init__.py

@@ -0,0 +1,30 @@
+"""Pure-Python client for games running on Photon Realtime.
+
+Layers, bottom to top:
+
+* :mod:`pyphotonrealtime.protocol`  -- wire format: parameter (de)serialization,
+  packet framing, encryption primitives.
+* :mod:`pyphotonrealtime.transport` -- byte transports (TCP now; UDP/WebSocket later).
+* :mod:`pyphotonrealtime.peer`      -- ``PhotonPeer``: one connection to one server,
+  operation/event/response queues, keep-alive, timeouts, encryption.
+* :mod:`pyphotonrealtime.realtime`  -- ``RealtimeClient``: Name Server -> Master
+  Server -> Game Server workflow, matchmaking, rooms, players, callbacks.
+"""
+
+from pyphotonrealtime.peer import PeerState, PhotonPeer
+from pyphotonrealtime.realtime import (
+    AppSettings,
+    ClientState,
+    RealtimeClient,
+)
+
+__version__ = "0.0.1"
+
+__all__ = [
+    "AppSettings",
+    "ClientState",
+    "PeerState",
+    "PhotonPeer",
+    "RealtimeClient",
+    "__version__",
+]

pyphotonrealtime-0.0.1/src/pyphotonrealtime/peer.py

@@ -0,0 +1,192 @@
+"""``PhotonPeer``: a single connection to a single Photon server.
+
+Mirrors the official SDKs' service loop: nothing happens on the network unless
+the application calls :meth:`PhotonPeer.service` (or the two halves,
+:meth:`PhotonPeer.dispatch_incoming_commands` and
+:meth:`PhotonPeer.send_outgoing_commands`) regularly, typically 10-50 times per
+second, from a single thread.
+
+Callbacks to the :class:`PeerListener` are only ever invoked from inside
+``dispatch_incoming_commands``, i.e. on the thread that calls ``service``.
+"""
+
+from __future__ import annotations
+
+import time
+from collections import deque
+from dataclasses import dataclass, field
+from enum import Enum, auto
+from typing import TYPE_CHECKING, Any, Protocol
+
+from pyphotonrealtime.protocol.packet.packet_stream import PhotonStreamParser
+from pyphotonrealtime.transport import TcpTransport
+
+if TYPE_CHECKING:
+    from pyphotonrealtime.protocol.packet.base import PhotonPacket
+    from pyphotonrealtime.protocol.param.base import ParameterBase
+    from pyphotonrealtime.transport import Transport
+
+type Parameters = dict[int, ParameterBase[Any]]
+
+
+class PeerState(Enum):
+    """Connection state of a :class:`PhotonPeer`."""
+
+    Disconnected = auto()
+    Connecting = auto()
+    Connected = auto()
+    Disconnecting = auto()
+
+
+class StatusCode(Enum):
+    """Peer status changes reported to :meth:`PeerListener.on_status_changed`."""
+
+    Connect = auto()
+    Disconnect = auto()
+    ExceptionOnConnect = auto()
+    Exception = auto()
+    TimeoutDisconnect = auto()
+    DisconnectByServer = auto()
+    EncryptionEstablished = auto()
+    EncryptionFailedToEstablish = auto()
+
+
+@dataclass(frozen=True, slots=True)
+class OperationResponse:
+    """The server's answer to an operation sent with ``send_operation``."""
+
+    operation_code: int
+    return_code: int
+    debug_message: str | None
+    parameters: Parameters = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class EventData:
+    """A server- or player-originated event."""
+
+    code: int
+    parameters: Parameters = field(default_factory=dict)
+
+
+class PeerListener(Protocol):
+    """Receives everything a peer dispatches (``IPhotonPeerListener``)."""
+
+    def on_status_changed(self, status: StatusCode) -> None:
+        """Handle a connection status change."""
+
+    def on_operation_response(self, response: OperationResponse) -> None:
+        """Handle the response to an operation."""
+
+    def on_event(self, event: EventData) -> None:
+        """Handle an incoming event."""
+
+
+class PhotonPeer:
+    """One connection to one Photon server, driven by :meth:`service`."""
+
+    def __init__(
+        self,
+        listener: PeerListener,
+        transport: Transport | None = None,
+        *,
+        disconnect_timeout: float = 10.0,
+        keep_alive_interval: float = 2.0,
+    ) -> None:
+        """Create a disconnected peer.
+
+        Args:
+            listener: Receives status changes, responses and events.
+            transport: Byte transport to use; defaults to TCP.
+            disconnect_timeout: Seconds without traffic before giving up.
+            keep_alive_interval: Seconds of idle sending before a ping.
+        """
+        self.listener = listener
+        self.transport = transport if transport is not None else TcpTransport()
+        self.disconnect_timeout = disconnect_timeout
+        self.keep_alive_interval = keep_alive_interval
+
+        self.state = PeerState.Disconnected
+        self.server_address: str | None = None
+        self.app_id: str | None = None
+
+        self._parser = PhotonStreamParser()
+        self._outgoing: deque[PhotonPacket] = deque()
+        self._incoming: deque[PhotonPacket] = deque()
+        self._aes_key: bytes | None = None
+        self._last_receive = 0.0
+        self._last_send = 0.0
+
+    # -- connection -------------------------------------------------------
+
+    def connect(self, server_address: str, app_id: str) -> bool:
+        """Start connecting to ``host:port``; the result arrives as a status.
+
+        Returns:
+            Whether the connection attempt was started.
+        """
+        # M1: send InitRequestPacket(app id, protocol version), move to
+        # Connected on InitResponse.
+        raise NotImplementedError
+
+    def disconnect(self) -> None:
+        """Send a disconnect message, then close the transport."""
+        raise NotImplementedError
+
+    def establish_encryption(self) -> bool:
+        """Start a Diffie-Hellman key exchange (``InitEncryptionRequest``).
+
+        Returns:
+            Whether the exchange was started.
+        """
+        raise NotImplementedError
+
+    @property
+    def is_encryption_available(self) -> bool:
+        """Whether a shared AES key has been negotiated."""
+        return self._aes_key is not None
+
+    # -- service loop -----------------------------------------------------
+
+    def service(self) -> None:
+        """Dispatch everything received, then send everything queued."""
+        while self.dispatch_incoming_commands():
+            pass
+        while self.send_outgoing_commands():
+            pass
+
+    def dispatch_incoming_commands(self) -> bool:
+        """Read from the transport and dispatch at most one command.
+
+        Returns:
+            Whether there may be more to dispatch.
+        """
+        # M1: map parsed packets to OperationResponse/EventData, answer
+        # keep-alives, detect timeouts (disconnect_timeout).
+        raise NotImplementedError
+
+    def send_outgoing_commands(self) -> bool:
+        """Flush queued commands to the transport.
+
+        Returns:
+            Whether more remain to be sent.
+        """
+        # M1: also emit a keep-alive when idle for keep_alive_interval.
+        raise NotImplementedError
+
+    # -- operations -------------------------------------------------------
+
+    def send_operation(
+        self, operation_code: int, parameters: Parameters, *, encrypt: bool = False
+    ) -> bool:
+        """Queue an operation; it goes out on the next ``send_outgoing_commands``.
+
+        Returns:
+            Whether the operation was queued.
+        """
+        # M1: build via PacketFactory.operation (encrypted when requested).
+        raise NotImplementedError
+
+    @staticmethod
+    def _now() -> float:
+        return time.monotonic()

pyphotonrealtime-0.0.1/src/pyphotonrealtime/protocol/__init__.py

@@ -0,0 +1 @@
+__all__ = []

pyphotonrealtime-0.0.1/src/pyphotonrealtime/protocol/command_code.py

@@ -0,0 +1,32 @@
+from enum import IntEnum
+
+
+class CommandCode(IntEnum):
+    Init = 0
+    InitResponse = 1
+
+    Operation = 2
+    OperationResponse = 3
+
+    Event = 4
+    DisconnectMessage = 5
+
+    KeyExchangeRequest = 6
+    KeyExchangeResponse = 7
+
+    Message = 8
+    RawMessage = 9
+
+    EncryptedOperation = 0x82
+    EncryptedOperationResponse = 0x83
+
+    EncryptedEvent = 0x84
+
+    Unknown = 0xFF
+
+
+ENCRYPTED_FLAG = 0x80
+
+
+def is_encrypted(command_code: CommandCode) -> bool:
+    return command_code.value > ENCRYPTED_FLAG