How to properly override method keys() while extending dict (in python3)

Question

EDIT: I added the class and some info, see the new post.

I have created a class that extends dict and set (more exactly, I extended collections.abc.MutableMapping and MutableSet). Now I want to properly override the method keys().

This class represents a set of other objects, called Measurand:

class Measurands(MutableSet, MutableMapping):
    @property
    def measurands(self):
        return self._measurands
    
    
    @measurands.setter
    def measurands(self, val):
        self._measurands = []
        
        for el in val:
            self.add(el)
    
    
    def __init__(self, arg=None):
        if arg is None:
            self.measurands = []
        else:
            try:
                measurands = arg.measurands
            except AttributeError:
                if isinstance(arg, Iterable):
                    measurands = list(arg)
                else:
                    measurands = [arg]
            
            self.measurands = measurands
            
    
    def __iter__(self):
        return iter(self.measurands)
    
    
    def __getitem__(self, key):
        for m in self:
            if m.id == key:
                return m
    
        raise KeyError(key)
    
    
    def __contains__(self, el_x):
        is_in = False
        
        for el in self:
            if el_x.id == el.id:
                is_in = True
                break
        
        return is_in
    
    
    def add(self, el):
        try:
            self[el.id].session_ids |= el.session_ids
        except KeyError:
            self[el.id] = Measurand(el)
    
    
    def _discard(self, key):
        res = False
        
        for i, m in enumerate(self):
            if m.id == key:
                del self.measurands[i]
                res = True
                break
        
        return res
    
    
    def __delitem__(self, key):
        res = self._discard(self, key)
        
        if not res:
            raise KeyError(key)
    
    def discard(self, key):
        self._discard(self, key)
    
    
    def remove(self, key):
        self.__delitem__(self, key)
    
    
    def __len__(self):
        return len(self.measurands)
    
    
    def __setitem__(self, key, value):
        res = False
        value_true = Measurand(value)
        
        for i, m in enumerate(self):
            if m.id == key:
                res = True
                
                if value.id == key:
                    self.measurands[i] = value_true
                else:
                    raise KeyError(key)
                
                break
        
        if not res:
            self.measurands.append(value_true)
    
    
    def __str__(self):
        string = "Measurands({"
        
        for m in self:
            string += str(m)
            string += ", "
        
        if string:
            string = string[:-2]
        
        string += "})"
        
        return string

The problem is the default method keys returns a "list" of Measurand objects. This is not what I want. The keys should be the property id of the Measurand objects.

For now I'm returning a simple list, but I would return a dict_keys or a collection.abc.KeysView object. Unluckily, dict_keys is not a global name.

1. Where is dict_keys?
2. Is this the correct/pythonic way to do it?

Answer 1

I haven't been able to find any way to cast something to the dict_keys type, but after reading the PEP that introduced the new way to access keys and values (PEP 3106), it looks like dict_keys was introduced to

return a set-like or unordered container object whose contents are derived from the underlying dictionary rather than a list which is a copy of the keys, etc.

Taking this into account, it looks like you could get away with returning a generator object with your keys() method instead of a list.

Here is the pseudo-code from the PEP:

class dict:

    # Omitting all other dict methods for brevity.

    def keys(self):
        return d_keys(self)

class d_keys:

    def __init__(self, d):
        self.__d = d

    def __len__(self):
        return len(self.__d)

    def __contains__(self, key):
        return key in self.__d

    def __iter__(self):
        for key in self.__d:
            yield key

Answer 2

The Python3 documentation says that dict.keys() return value type (i.e. a view) is "set-like", so your return value should be "set-like" as well.

The objects returned by dict.keys(), dict.values() and dict.items() are view objects. They provide a dynamic view on the dictionary’s entries, which means that when the dictionary changes, the view reflects these changes.

Dictionary views can be iterated over to yield their respective data, and support membership tests:

....

Keys views are set-like since their entries are unique and hashable. If all values are hashable, so that (key, value) pairs are unique and hashable, then the items view is also set-like. (Values views are not treated as set-like since the entries are generally not unique.) For set-like views, all of the operations defined for the abstract base class collections.abc.Set are available (for example, ==, <, or ^).

Full text here: https://docs.python.org/3/library/stdtypes.html#dict-views

Answer 3

This is already handled for you! collections.abc.MutableMapping includes a reasonable default implementation of keys that provides the same interface as dict.keys.

Simply delete your keys method, and you'll be using the inherited implementation.