reg: retype AppType.proto to its own transport, and give register_apptype varargs instead of a proto kwarg

[JarryShaw]

Is this a bug or a feature request? A breaking design change, ruled on in #801.

Step 1 of #801's three. The maintainer's ruling, verbatim:

I feel like now that we're already using transport specific enums, we should avoid ambiguity from the enums in all sense. so... yes, go with your recommendation.

What changes

1. AppType.proto becomes the single transport of the registry the member lives in, not the whole IANA set. TCP['http'].proto goes tcp|udp|sctp → tcp.
2. register_apptype takes varargs instead of a proto kwarg, per the maintainer: "keeping everything singular and explicit".

def register_apptype(code: 'int | Enum_AppType', module: 'str | ModuleDescriptor[ProtocolBase] | Type[ProtocolBase]',
                     *transport: 'TransportProtocol', class_: 'str' = NULL) -> 'None':

class_ becomes keyword-only — that is deliberate and is the one divergence from the sibling register_* functions. Do NOT put *transport after class_: class_ is positional with a default, so a third positional argument binds to it and the transport is silently eaten. Measured:

(code, module, class_=NULL, *transport):  f(member, Unit, TP.udp) -> class_='TP.udp', transport=()
(code, module, *transport, class_=NULL):  f(member, Unit, TP.udp) -> transport=('TP.udp',)

Ruled sub-case: an Enum_AppType member with no explicit *transport uses the member's own proto — single-bit after this change, so it names exactly one registry. A bare int with no *transport stays an error.

Why the two are one issue: retyping removes the multi-bit value that protocols.py:833's proto = code.proto default relies on to fan out across {tcp, udp} at :846. Landing either alone leaves the other broken.

Expected behavior

Every member's proto names exactly its own registry; register_apptype requires transports to be named one at a time; no code path constructs or consumes a composite TransportProtocol.

Additional context

This is breaking for 10,625 of 12,391 members, because proto.name is folded into the member's underlying str value, not merely its display — pcapkit/vendor/reg/apptype/apptype.py:250 (temp = '%s [%d - %s]' % (name, value, proto.name), assigned to obj._value_), with __repr__ at :270 and __str__ at :273. So TCP['http'].value goes 'http [80 - tcp|udp|sctp]' → 'http [80 - tcp]'. _value_ is the live lookup key in _value2member_map_, so this must happen at generation time, never at runtime. Identity survives pickle, copy and deepcopy either way.

Verified migration surface, line numbers re-read against main (477ed00c4) — earlier citations in this thread were wrong, so trust these and re-derive rather than copying older comments:

• pcapkit/vendor/reg/apptype/apptype.py:250 __new__, :270 __repr__, :273 __str__, :473 the docstring promising "the whole transport protocol set", :752 the emit condition if self.TRANSPORT not in record.protos.
• The same three format strings generated into pcapkit/const/reg/apptype/apptype.py, plus the docstring duplicated into all four of const/reg/apptype/{tcp,udp,sctp,dccp}.py:21.
• tests/const/test_const_apptype_split_unit.py:80 — assertEqual(TCP.http.proto, UDP.http.proto), which this change falsifies by design. That file is 415 lines with 15 test methods; ignore any citation above 415.
• tests/foundation/registry/test_protocols.py:476, :484, :493, :499 — the only four register_apptype calls in the repo. :493 is the three-positional one.

Do not regenerate to verify. AppType.LINK fetches IANA's live CSV, so a regeneration is not reproducible. Hand-edit the generator and its output, then prove equivalence by rendering BASE(...) and diffing — 0 diff lines outside the intended region. BASE is a lambda returning an f-string, so braces in emitted code must be doubled.

Measurements that justify this, so they need not be redone: the multi-bit value is fully derivable — 7,054 (svc, port) groups, 0 disagreements, and 0 single-registry groups carrying a multi-bit proto. Per-registry: TCP 6147 / UDP 6143 / SCTP 91 / DCCP 10. register_apptype(TCP.http, Dummy) today displaces httpv1.HTTP from TCP and http.HTTP from UDP in one call.

Related: #801, #732, #759, #775, #804.

[JarryShaw]

Checkable blocker: #803 merged.

gh pr view 803 -R JarryShaw/PyPCAPKit --json state,mergedAt

#803 is rewriting both files this change must edit — pcapkit/vendor/reg/apptype/apptype.py and pcapkit/const/reg/apptype/apptype.py, the latter +772/-772 of a 4,839-line generated file. Landing this first means one of the two rewrites silently discards the other's edits, with no conflict marker. #803 is green and awaiting its cross-review verdict, so the hold should be short.

Chain in this tree, longest first: #803 → #798, and separately #803 → #796 → #775, #803 → #804, and #803 → this issue → #807/#808. #803 is the bottleneck for five items, which is worth knowing when deciding what to merge first.

[JarryShaw]

Correcting this issue's migration surface — my line numbers were read from a stale checkout and the list was incomplete. Everything below is from origin/main at 477ed00c4, read with git show origin/main:<path>.

body says	actually
vendor/reg/apptype/apptype.py:250 __new__	:251
:270 __repr__	:271
:273 __str__	:274
:473 docstring	:523
:752 emit condition	:802
"test_const_apptype_split_unit.py is 415 lines / 15 methods; ignore citations above 415"	863 lines, 19 methods — that instruction was wrong, delete it

Four more test sites this change must handle, all real and none previously listed here:

• test_const_apptype_split_unit.py:709-836 — test_no_lookup_call_site_in_the_library_builds_a_composite_proto. It hard-asserts the literal source strings 'proto = code.proto' (:835) and 'if test not in proto:' (:836) inside pcapkit/foundation/registry/protocols.py. The signature change breaks this by design; it must be rewritten to match the new body, not deleted.
• :497-629 — test_every_multi_transport_member_refuses_its_own_proto, with self.assertEqual(swept, 10625) at :578. That count goes to 0 after retyping, so the test's premise disappears.
• :390-496 — test_a_proto_naming_two_transports_is_refused_rather_than_resolved. Constructs every multi-bit composite over the four bits and asserts all three entry points reject them. Entirely built on composites being constructible.
• :630-658 — test_one_transport_protocol_still_resolves_every_port_it_resolved_before, whose docstring pins the 10,625 / 1,766 populations at :643.

Also worth knowing before this starts: #803's cross-review found that pcapkit/const/reg/apptype/{tcp,udp,sctp,dccp}.py each still carry a consider-using-f-string disable with zero % sites, sourced from the fifth template — TRANSPORT at vendor/reg/apptype/apptype.py:504 — which #803's "four bespoke templates" scope excluded. Filing that separately; it touches the same files, so whoever takes this should expect to meet it.

Apologies for the churn on these numbers. The rule I broke and am now applying: read origin/main explicitly, never a relative path in the checkout — local main here is at fe80b8525, 62 lines shorter in this very file.

[JarryShaw]

Unblocked — #803 merged at 21:44:59Z as 4530424df. main is now 4530424df, so pcapkit/vendor/reg/apptype/apptype.py and pcapkit/const/reg/apptype/apptype.py are free.

Dispatching a worker. Re-derive every line number against origin/main — #803 rewrote both files (+772/−772 in the const one), so every citation in this thread predates it, including the corrected set I posted earlier.

The design is settled and recorded in #801: proto becomes the registry's own single transport, and

def register_apptype(code, module, *transport: 'TransportProtocol', class_: 'str' = NULL) -> 'None':

with class_ keyword-only — do not put *transport after a positional-with-default class_, which silently eats the transport. An Enum_AppType member with no explicit *transport uses its own proto, now single-bit; a bare int with none stays an error.

#809 is now blocked on this issue (same four const registries), and #807/#808 remain blocked on it as before.