Ordered dict with predicate filtering

subordereddict.py

from collections import OrderedDict
from enum import Enum

from typing import Any, Callable, Dict, Optional


class SubOrderedDict(dict):

    def __init__(self, original_dict: OrderedDict, predicate: Optional[Callable[[Any], bool]] = None):
        self._dict = original_dict
        self._predicate = predicate or (lambda _: True)

    def __iter__(self):
        # iterator over keys
        for key, value in self._dict.items():
            if self._predicate(value):
                yield key

    def items(self):
        for key, value in self._dict.items():
            if self._predicate(value):
                yield key, value

    def __and__(self, other):
        # insersection
        return SubOrderedDict(
            self._dict,
            lambda value: self._predicate(value) and other._predicate(value))

    def __or__(self, other):
        # union
        return SubOrderedDict(
            self._dict,
            lambda value: self._predicate(value) or other._predicate(value))

    def __sub__(self, other):
        # difference
        return SubOrderedDict(
            self._dict,
            lambda value: self._predicate(value) and not other._predicate(value))


class FieldType(Enum):
    TECHNICAL = 0
    VIRTUAL = 1
    REGULAR = 2


d = OrderedDict()
d["a"] = ("A", FieldType.TECHNICAL)
d["b"] = ("B", FieldType.TECHNICAL)
d["b2"] = ("B2", FieldType.REGULAR)
d["c"] = ("C", FieldType.VIRTUAL)
d["d"] = ("D", FieldType.TECHNICAL)


technicals = SubOrderedDict(d, lambda v: v[1] == FieldType.TECHNICAL)
virtuals = SubOrderedDict(d, lambda v: v[1] == FieldType.VIRTUAL)

all = SubOrderedDict(d)

sub1 = technicals | virtuals

regulars = all - technicals - virtuals

for n, o in [("technicals", technicals), ("virtuals", virtuals), ("sub1", sub1), ("regulars", regulars)]:
    print("=={}==".format(n))
    for k, v in o.items():
        print(k, v)