docs: retarget Protocol/ProtocolBase cross-references to match the #1103 display rule (#2422)

Applying the #1103 ruling to the member references #2420 left behind: a
`ProtocolBase.<member>` cross-reference now reads `Protocol.<member>`, for one
consistent public vocabulary, and links there too.

Both halves move, because on the rendered page that is where the documentation
is. `protocol.rst` documents the members with nested
`autoproperty`/`automethod` directives under `.. autoclass:: ...Protocol`, so
`Protocol.<member>` carries the signature and the docstring; the `ProtocolBase`
block is `:no-members:` plus grouped `:no-index-entry:` stubs whose body only
links back to the `Protocol.*` entries, and the general index lists `Protocol.*`
alone. Measured on the pinned docs toolchain (`Sphinx==9.2.0`).

* 46 sites in `pcapkit/` and `docs/source/`. 37 move display *and* target to
  `Protocol.<member>`; the other 9 already targeted `Protocol` and only needed
  the display text. The explicit target is the fully-qualified spelling the
  house style asks for -- the form 124 existing references already use.
* `from_data` is consistent again: `internet.py` and `application.py` pointed
  at `ProtocolBase.from_data` where `link.py` and `transport.py` pointed at
  `Protocol.from_data` for the same kind of reference. All four now read alike.
* `__init_subclass__` keeps `ProtocolBase` (6 sites), since `Protocol`
  overrides it and naming `Protocol` would name a different method. So do
  `schema.py` and `protocol-layer-placement.rst`, whose adjacent prose would
  otherwise contradict itself, and `register`'s `Raises:` clause, which names
  the class the guard's `issubclass` tests (#2316/#1016).
* `changelog/1.5.0.rst` keeps its five `ProtocolBase.<member>` references.
  Each names the class a *built-in* protocol inherits the member from -- the
  built-ins derive from `ProtocolBase`, not `Protocol` -- and `CHANGELOG.md` is
  generated from that file by `util/changelog_md.py`, where a role flattens to
  a code span with no link, so moving them would rewrite release-note prose
  rather than an href.
* `tests/` and `examples/` are untouched (28 sites): their docstrings are not
  part of the Sphinx render.

Hrefs only. A role-canonicalisation guard reports no role and no display-text
change beyond the above, and an AST-structure guard (`ast.dump` with docstrings
stripped) is identical for every touched `.py` file.

Author: JarryShaw

docs/source/ext.rst

@@ -241,14 +241,14 @@ The following code snippet shows how to create a new protocol class:
    silently wrong field. The accepted set is read from :func:`inspect.signature` -- the union of every
    keyword-taking parameter of ``make``, ``read``, ``pack``, ``unpack``,
    ``__post_init__`` and ``__init__`` anywhere in the class's MRO -- which is
-   wider than ``make`` alone because :meth:`ProtocolBase.__post_init__
-   <pcapkit.protocols.protocol.ProtocolBase.__post_init__>` hands the same
+   wider than ``make`` alone because :meth:`Protocol.__post_init__
+   <pcapkit.protocols.protocol.Protocol.__post_init__>` hands the same
    ``**kwargs`` to the construction and to the parse, so a keyword only ``read``
    declares still travels through ``make``.
 
    Shapes a signature cannot express are declared on the class instead, via
-   :attr:`ProtocolBase.__keywords__
-   <pcapkit.protocols.protocol.ProtocolBase.__keywords__>`:
+   :attr:`Protocol.__keywords__
+   <pcapkit.protocols.protocol.Protocol.__keywords__>`:
 
    .. code-block:: python
 
@@ -271,8 +271,8 @@ The following code snippet shows how to create a new protocol class:
    subclass of a dispatcher is checked normally. Prefer a declared parameter to
    either: it is also what documents the keyword to your callers.
 
-   Parsing is unaffected. :meth:`ProtocolBase.from_data
-   <pcapkit.protocols.protocol.ProtocolBase.from_data>` checks the keywords its
+   Parsing is unaffected. :meth:`Protocol.from_data
+   <pcapkit.protocols.protocol.Protocol.from_data>` checks the keywords its
    caller passes just as strictly, raising
    :exc:`~pcapkit.utilities.exceptions.UnsupportedCall`, but only warns with
    :exc:`~pcapkit.utilities.warnings.UnknownFieldWarning` for a key that comes
@@ -281,8 +281,8 @@ The following code snippet shows how to create a new protocol class:
 
    .. warning::
 
-      The check lives in :meth:`ProtocolBase.__init__
-      <pcapkit.protocols.protocol.ProtocolBase.__init__>`, where every producer's
+      The check lives in :meth:`Protocol.__init__
+      <pcapkit.protocols.protocol.Protocol.__init__>`, where every producer's
       keywords converge, so it covers ``SomeProtocol(...)`` and the ``pack`` it
       leads to -- but **not** a direct ``SomeProtocol.make(...)`` call, which still
       discards an undeclared keyword in silence. ``object.__new__(cls).make(...)``

docs/source/pcapkit/protocols/internet/ipv6_ext.rst

@@ -141,7 +141,7 @@ This class is reached in these ways:
    ``IPv6-Route``, ``IPv6-Opts``, ``MH``, ``HIP``, ``IPv6-Frag`` and ``AH`` all
    have dedicated classes. When one of *those* raises,
    :func:`~pcapkit.corekit.decorators.beholder`
-   (:meth:`ProtocolBase._import_next_layer <pcapkit.protocols.protocol.ProtocolBase._import_next_layer>`)
+   (:meth:`Protocol._import_next_layer <pcapkit.protocols.protocol.Protocol._import_next_layer>`)
    would substitute plain :class:`~pcapkit.protocols.misc.raw.Raw`, which loses
    ``next`` and crashes the walk as in path 1.
    :meth:`IPv6._import_next_layer <pcapkit.protocols.internet.ipv6.IPv6._import_next_layer>` catches

docs/source/pcapkit/utilities/chardet.rst

@@ -7,7 +7,7 @@ Character Set Detection
 turning the bytes of a text field into a :obj:`str`. It is shared by
 :meth:`StringField.post_process
 <pcapkit.corekit.fields.strings.StringField.post_process>` and
-:meth:`ProtocolBase.decode <pcapkit.protocols.protocol.Protocol.decode>`,
+:meth:`Protocol.decode <pcapkit.protocols.protocol.Protocol.decode>`,
 which is why it lives here rather than beside either of them.
 
 .. autofunction:: pcapkit.utilities.chardet.detect

pcapkit/corekit/decorators.py

@@ -56,8 +56,8 @@
 
 #: contextvars.ContextVar[bool]: Whether a call :func:`beholder` wraps is under
 #: way, so that an :exc:`Exception` raised inside it ends with the layer that
-#: raised replaced; see :meth:`ProtocolBase._parse_next_layer
-#: <pcapkit.protocols.protocol.ProtocolBase._parse_next_layer>` (:issue:`2308`).
+#: raised replaced; see :meth:`Protocol._parse_next_layer
+#: <pcapkit.protocols.protocol.Protocol._parse_next_layer>` (:issue:`2308`).
 _beholding = contextvars.ContextVar('_beholding', default=False)
 
 
@@ -116,8 +116,8 @@ def beholder(
     :class:`~pcapkit.protocols.misc.null.NoPayload`, if the error is an
     end-of-file :exc:`~pcapkit.utilities.exceptions.StructError`.
 
-    When :meth:`ProtocolBase._parse_next_layer
-    <pcapkit.protocols.protocol.ProtocolBase._parse_next_layer>` held the
+    When :meth:`Protocol._parse_next_layer
+    <pcapkit.protocols.protocol.Protocol._parse_next_layer>` held the
     warnings of the layer that raised, they are dropped with it: they describe a
     layer the result does not have, and the replacement's ``error`` reports the
     failure (:issue:`2308`).

pcapkit/corekit/fields/numbers.py

@@ -730,8 +730,8 @@ def post_process(self, value: 'int | bytes', packet: 'dict[str, Any]') -> 'Stdli
             the registry with ``aenum.extend_enum``, for two reasons: a
             capture carrying many distinct unassigned codes would otherwise grow
             a process-global registry without bound, which is the growth
-            :meth:`ProtocolBase._lookup_registry
-            <pcapkit.protocols.protocol.ProtocolBase._lookup_registry>` exists
+            :meth:`Protocol._lookup_registry
+            <pcapkit.protocols.protocol.Protocol._lookup_registry>` exists
             to avoid; and a stdlib :class:`enum.IntEnum` registry is then
             handled exactly like an ``aenum.IntEnum`` one.
 

pcapkit/corekit/module.py

@@ -60,8 +60,8 @@ def klass(self) -> 'Type[_T]':
             The module is read from :data:`sys.modules` first, and
             :func:`importlib.import_module` is entered only when it is not
             loaded yet. That matters because this property is on a *per-frame*
-            dispatch path: :meth:`ProtocolBase._lookup_next_layer
-            <pcapkit.protocols.protocol.ProtocolBase._lookup_next_layer>`
+            dispatch path: :meth:`Protocol._lookup_next_layer
+            <pcapkit.protocols.protocol.Protocol._lookup_next_layer>`
             deliberately writes no resolved class back, so every next layer
             lookup resolves its descriptor again -- the one registered for the
             code, or the fallback for :class:`~pcapkit.protocols.misc.raw.Raw`

pcapkit/corekit/sentinels.py

@@ -571,8 +571,8 @@ def __bool__(self) -> 'Literal[False]':
 #: own ``__keywords__`` out of its :attr:`~object.__dict__`, where
 #: :obj:`None` is itself a meaningful value -- the opt-out that says the
 #: class cannot enumerate its keywords, cf.
-#: :attr:`ProtocolBase.__keywords__
-#: <pcapkit.protocols.protocol.ProtocolBase.__keywords__>`. Never leaves
+#: :attr:`Protocol.__keywords__
+#: <pcapkit.protocols.protocol.Protocol.__keywords__>`. Never leaves
 #: :mod:`pcapkit.protocols.protocol`, which imports it from here for exactly
 #: that one read. Private by documentation rather than by a
 #: leading underscore -- see :class:`AbsentType`'s own docstring.

pcapkit/foundation/engines/dpkt.py

@@ -551,8 +551,8 @@ def read_frame(self) -> 'DPKTPacket':
         try:
             packet = protocol(pkt)  # type: DPKTPacket
         except Exception as exc:  # pylint: disable=broad-except
-            # NOTE: Caught broadly, as :meth:`ProtocolBase.analyze
-            # <pcapkit.protocols.protocol.ProtocolBase.analyze>` does: dpkt raises
+            # NOTE: Caught broadly, as :meth:`Protocol.analyze
+            # <pcapkit.protocols.protocol.Protocol.analyze>` does: dpkt raises
             # more than its own ``UnpackError`` while parsing -- dpkt 1.9.8 reads
             # ``frag_off`` from whatever header follows an IPv6 Fragment header,
             # so a Fragment header followed by ESP or Destination Options raises

pcapkit/protocols/application/application.py

@@ -121,8 +121,8 @@ def from_data(cls, data: '_PT | dict[str, Any]', **kwargs: 'Any') -> 'Self':
 
         Args:
             data: Protocol data.
-            **kwargs: Construction keywords, as for :meth:`ProtocolBase.from_data
-                <pcapkit.protocols.protocol.ProtocolBase.from_data>`.
+            **kwargs: Construction keywords, as for :meth:`Protocol.from_data
+                <pcapkit.protocols.protocol.Protocol.from_data>`.
 
         Returns:
             Protocol instance, cut back to what was captured when the header

pcapkit/protocols/application/http.py

@@ -404,8 +404,8 @@ def from_data(cls, data: '_PT | dict[str, Any]', **kwargs: 'Any') -> 'Self':
                 into the versioned data model its keys belong to -- ``receipt``
                 is HTTP/1.*'s and ``sid`` HTTP/2's -- since this class's own data
                 model carries no version.
-            **kwargs: As :meth:`ProtocolBase.from_data
-                <pcapkit.protocols.protocol.ProtocolBase.from_data>`.
+            **kwargs: As :meth:`Protocol.from_data
+                <pcapkit.protocols.protocol.Protocol.from_data>`.
 
         Returns:
             Protocol instance.