From b382181afd539bed0007a908f047829a99d1dbb0 Mon Sep 17 00:00:00 2001 From: Anuraag Agrawal Date: Mon, 16 Nov 2026 15:46:55 +0900 Subject: [PATCH] Optimize memory usage for unknown enums --- src/protobuf/_enum.py | 31 +++++++++++++++++++++++++------ tests/test_enum.py | 10 ++++++++++ 2 files changed, 35 insertions(+), 6 deletions(-) diff --git a/src/protobuf/_enum.py b/src/protobuf/_enum.py index 79baffe..921933e 100644 --- a/src/protobuf/_enum.py +++ b/src/protobuf/_enum.py @@ -14,12 +14,25 @@ from __future__ import annotations from enum import IntEnum -from typing import TYPE_CHECKING, cast +from typing import TYPE_CHECKING, Any, cast if TYPE_CHECKING: from ._descriptors import DescEnum +class _UnknownValue: + """The `_value_` of an enum value that is not a member, which is the int itself. + + A member has its own `_value_`, which takes precedence over this. + """ + + def __get__(self, obj: int | None, owner: type | None = None) -> object: + return self if obj is None else int(obj) + + +_UNKNOWN_VALUE = _UnknownValue() + + class Enum(IntEnum): """Base class for protobuf enumeration types. @@ -64,6 +77,15 @@ class Color(Enum): if TYPE_CHECKING: _desc: DescEnum + def __init_subclass__(cls, **kwargs: Any) -> None: + super().__init_subclass__(**kwargs) + # We avoid setting name and value onto unknown enum instances + # by setting them directly on subclasses. This prevents adding + # __dict__ to them, increasing memory usage significantly for + # no reason. + cls._name_ = cast("str", None) + cls._value_ = cast("int", _UNKNOWN_VALUE) + @classmethod def _missing_(cls, value: object) -> Enum: """Handle unknown enum values. @@ -88,11 +110,8 @@ def _missing_(cls, value: object) -> Enum: msg = f"`{value}` is not a valid {cls.__name__}" raise ValueError(msg) - # Create a pseudo-member for unknown values - pseudo_member = int.__new__(cls, value) - pseudo_member._name_ = cast("str", None) # type: ignore[attr-defined] - pseudo_member._value_ = value # type: ignore[attr-defined] - return pseudo_member # type: ignore[return-value] + # Create a pseudo-member for unknown values. + return int.__new__(cls, value) def __str__(self) -> str: """Return a string representation of the enum value. diff --git a/tests/test_enum.py b/tests/test_enum.py index d4cbafe..ba5dc90 100644 --- a/tests/test_enum.py +++ b/tests/test_enum.py @@ -140,6 +140,16 @@ def test_enum_closed() -> None: ClosedColor(123) +def test_unknown_value_holds_no_attributes() -> None: + unknown = Color(99) + assert vars(unknown) == {} + assert unknown.name is None + assert unknown.value == 99 + + # Members still hold their own value. + assert vars(Color.RED)["_value_"] == 1 + + def test_enum_is_unknown() -> None: # Known enum values should not be unknown assert not enum_is_unknown(Color.UNSPECIFIED)