Typing for a MutableMapping that contains specific key-value pairs

[dmi-dmi-dmi]

I have a mutable mapping in my code that is being processed in different functions.

Said mapping has some @propertyies and can hold quite a lot of different key-value pairs but it is guaranteed that it will contain some specific key-value pairs.

These specific key-value pairs are given special treatment in processing functions so I would really like to find a way to type it to ensure at least code handling specific key-value pair is correct

In short code looks like this

from typing import MutableMapping

class InternalStructure(MutableMapping[str, Any]):
    ...

def init_internal_structure() -> MutableMapping[str, Any]:
    internal_structure = InternalStructure()
    # some init code
    internal_structure['fixed-key'] = 10
    internal_structure['another-fixed-key'] = [11, 12, 13] 
    return internal_structure
    
def process(input: MutableMapping[str, Any]) -> None:
    internal_structure['another-fixed-key'] = map(lambda x: 2*x, internal_structure['another-fixed-key'])

and I want to make sure mypy understands that internal_structure['another-fixed-key'] will be an int list giving me warnings if the code in process function treats it as a list of strings, for example.

[JelleZijlstra]

This sounds like a use case for TypedDict.

[dmi-dmi-dmi]

Unfortunately TypedDict does not allow adding extra keys. I am required to list all keys upon class definition but it is not possible in my case :-(

[dmi-dmi-dmi]

As of now I use @overload for __getitem__ (as well as for __setitem__ and __delitem__) and it works fine but this is really hard to scale so I was wondering what approaches one could use here.

class InternalStructure(MutableMapping[str, Any]):
    @overload
    def __getitem__(self, key: Literal['another-fixed-key']) -> List[int]:
        ...

    @overload
    def __getitem__(self, key: Literal['fixed-key']) -> int:
        ...