How to "remove" class attribute using type hints (Python)

[cofiprofim]

Body

By saying type hints i mean to remove this attribute only visibly

For example, to "add" class attribute using type hints u could use typing.Union:

from typing import Union, TypeVar


class _IdAttr:
    id: int


T = TypeVar("T")
R = TypeVar("R")


def add_id_attribute(cls: T) -> Union[T, _IdAttr]:
    pass


@add_id_attribute
class CoolClass:
    a: str = "smth"


# Here IDLE will provide you both a and id options
CoolClass.

So how i could remove some class attribute?

Guidelines

• I have read and understood this category's guidelines before making this post.

[chogalesoham]

Hi @cofiprofim,
Great question — type hints in Python can add to type visibility (like your Union example), but removing or hiding an attribute from type checkers is trickier because Python’s type system is additive by nature.

❓ Goal Recap:
You want something like a decorator or wrapper that will visibly remove a class attribute (e.g., make an attribute like id not appear in tools like IDLE, linters, or type checkers), similar to how you're adding one with Union[T, _IdAttr].

🧠 Why It’s Hard:
Type hints (via typing) cannot remove attributes from the perspective of type checkers. They’re structural — meaning you can declare more, but you can’t “negate” existing attributes.

[amitsuthram1]

You can't actually remove class attributes using type hints, but you can hide them from static tools like IDEs by narrowing the type. For example, you can define a Protocol or a simplified class that only includes the attributes you want to expose, and then use cast() to tell the type checker to treat an object as that narrower type. This way, the attribute still exists at runtime but won't show up in autocompletion or type checks.

[ghost]

You can't really remove a class attribute using type hints — the typing module is meant for adding type information, not hiding or deleting it. When you use Union like in your example, you're telling static analyzers (like MyPy or your IDE) that a class might have certain attributes. But there's no type-hint-only way to exclude or hide an attribute from autocomplete suggestions.

If your goal is to hide an attribute like id from showing up in IDE autocomplete or dir(), you'd have to do it at runtime by overriding the dir method. For example:

class HideIdMixin:
def dir(self):
return [attr for attr in super().dir() if attr != "id"]

class _IdAttr:
id: int = 123

class CoolClass(HideIdMixin, _IdAttr):
a: str = "something"

obj = CoolClass()
print(dir(obj)) # 'id' won't show up here

But again — that’s not done through type hints. There’s currently no way in typing to subtract or hide attributes like you're asking.

[NiteshBhardwaj171]

Hey! So, in Python, you can't actually remove a class attribute using type hints — type hints are only used to help tools like mypy or IDEs understand what types your variables or attributes should be. They don’t affect the actual behavior of the code when it runs.

1. If you’re trying to show that a class attribute no longer exists or is being removed, there are a few ways to handle that:

   Mark it as optional:
   You can set the attribute to None and use Optional in the type hint, like this:

   from typing import Optional

   class MyClass:
   my_attr: Optional[str] = "something"

Then later, if you delete it (del my_obj.my_attr), Python will let you do that, but the type checker will still expect that it might exist.

2. Just delete it at runtime:
   If you don’t want the attribute anymore, you can delete it like this:
   del my_obj.my_attr

But type checkers won’t really understand that it’s gone — you’ll have to manually ignore any warnings (# type: ignore) if needed.

3. Hide it with a property:
   If you want to block access to the attribute in a cleaner way, you can override it using a property:

   class MyClass:
   @Property
   def old_attr(self):
   raise AttributeError("This attribute has been removed.")

That way, if anyone tries to use it, they’ll get a clear error.

In short: type hints are just hints — they help tools, but they don't add or remove anything by themselves. If you're removing a class attribute, you’re doing that with normal Python code, and type hints can only describe that state, not enforce it.

[0xp3p3x0]

Hello

from typing import ClassVar, TypeVar


T = TypeVar("T")


def remove_id_attribute(cls: T) -> T:
    return cls


class _IdAttr:
    id: int


@remove_id_attribute
class CoolClass:
    a: str = "smth"
    id: ClassVar[int]  # This is a class attribute, not an instance attribute.


class NoIdClass(CoolClass):
    pass  # id won't appear in type hints for NoIdClass.


print(CoolClass)  # <class '__main__.CoolClass'>
print(NoIdClass)  # <class '__main__.NoIdClass'>

In this solution, id will not appear in the type hints of NoIdClass