Add an approximate difference method to StateFilters

changelog.d/10825.misc

@@ -0,0 +1 @@
+Add an 'approximate difference' method to `StateFilter`.

synapse/storage/state.py

@@ -356,6 +356,60 @@ def get_member_split(self) -> Tuple["StateFilter", "StateFilter"]:
 
         return member_filter, non_member_filter
 
+    def approx_difference(self, subtrahend: "StateFilter") -> "StateFilter":
+        """
+        Returns a state filter which represents self - subtrahend;
+        if the set of state events given by a state filter F are represented as
+        E(F), then the resultant state filter bears this property:
+
+            E(difference(self, subtrahend)) ⊇ E(self) ∖ E(subtrahend)
+
+        Ideally, this should be the narrowest such state filter, but this
+        function returns an approximation (since, for example, the set of
+        possible state keys is infinite).
+        """
+
+        types = dict(self.types)
+        new_include_others = self.include_others and not subtrahend.include_others
+        # if this is an include_others state filter, then all unmentioned
+        # event types are wildcards; otherwise they're empty.
+        current_default_for_unspecified: Optional[FrozenSet[str]] = (
+            None if self.include_others else frozenset()
+        )
+        new_default_for_unspecified: Optional[FrozenSet[str]] = (
+            None if new_include_others else frozenset()
+        )
+
+        for sub_type, sub_keys in subtrahend.types.items():
+            current: Optional[FrozenSet[str]] = types.get(
+                sub_type, current_default_for_unspecified
+            )
+
+            new: Optional[FrozenSet[str]]
+            if sub_keys is None:
+                # anything minus all is none
+                new = frozenset()
+            elif current is None:
+                # all minus a few specific keys is something we can only
+                # approximate as 'all'
+                new = None
+            else:
+                # a few specific keys minus a few specific keys is just the set
+                # difference of those keys
+                new = current.difference(sub_keys)
+
+            if new == new_default_for_unspecified:
+                # if the result is the same as the default assumption,
+                # don't bother storing it.
+                if sub_type in types:
+                    types.pop(sub_type)
+            else:
+                # this is not the same as the default assumption, so
+                # we store it
+                types[sub_type] = new
+
+        return StateFilter(frozendict(types), include_others=new_include_others)
+
 
 class StateGroupStorage:
     """High level interface to fetching state for event."""

tests/storage/test_state.py

@@ -105,7 +105,6 @@ def test_get_state_groups(self):
         self.assertEqual({ev.event_id for ev in state_list}, {e1.event_id, e2.event_id})
 
     def test_get_state_for_event(self):
-
         # this defaults to a linear DAG as each new injection defaults to whatever
         # forward extremities are currently in the DB for this room.
         e1 = self.inject_state_event(self.room, self.u_alice, EventTypes.Create, "", {})
@@ -483,3 +482,88 @@ def test_get_state_for_event(self):
 
         self.assertEqual(is_all, True)
         self.assertDictEqual({(e5.type, e5.state_key): e5.event_id}, state_dict)
+
+    def test_state_filter_difference(self):
+        def assert_difference(
+            minuend: StateFilter, subtrahend: StateFilter, expected: StateFilter
+        ):
+            self.assertEqual(
+                minuend.approx_difference(subtrahend),
+                expected,
+                f"StateFilter difference not correct:\n\n\t{minuend!r}\nminus\n\t{subtrahend!r}\nwas\n\t{minuend.approx_difference(subtrahend)}\nexpected\n\t{expected}",
+            )
+
+        # it's not possible to subtract individual state keys from
+        # a wildcard
+        assert_difference(
+            StateFilter.all(),
+            StateFilter.from_types(
+                ((EventTypes.Member, "@wombat:hs1"), (EventTypes.Member, "@spqr:hs1"))
+            ),
+            StateFilter.all(),
+        )
+        self.assertEqual(
+            StateFilter.all().approx_difference(
+                StateFilter.from_types(
+                    (
+                        (EventTypes.Member, "@wombat:hs1"),
+                        (EventTypes.Member, "@spqr:hs1"),
+                    )
+                )
+            ),
+            StateFilter.all(),
+        )
+
+        # we can subtract wildcards from wildcards
+        assert_difference(StateFilter.all(), StateFilter.all(), StateFilter.none())
+        assert_difference(
+            StateFilter(
+                types=frozendict(
+                    {
+                        EventTypes.Member: frozenset(),
+                        EventTypes.CanonicalAlias: None,
+                    }
+                ),
+                include_others=True,
+            ),
+            StateFilter(
+                types=frozendict({EventTypes.JoinRules: None}), include_others=False
+            ),
+            StateFilter(
+                types=frozendict(
+                    {EventTypes.Member: frozenset(), EventTypes.JoinRules: frozenset()}
+                ),
+                include_others=True,
+            ),
+        )
+
+        # we can subtract individual state keys, except from wildcards
+        assert_difference(
+            StateFilter(
+                types=frozendict(
+                    {
+                        EventTypes.Member: frozenset({"@wombat:hs1", "@kristina:hs2"}),
+                        EventTypes.CanonicalAlias: None,
+                    }
+                ),
+                include_others=False,
+            ),
+            StateFilter(
+                types=frozendict(
+                    {
+                        EventTypes.Member: frozenset({"@kristina:hs2"}),
+                        EventTypes.CanonicalAlias: frozenset({""}),
+                    }
+                ),
+                include_others=False,
+            ),
+            StateFilter(
+                types=frozendict(
+                    {
+                        EventTypes.Member: frozenset({"@wombat:hs1"}),
+                        EventTypes.CanonicalAlias: None,
+                    }
+                ),
+                include_others=False,
+            ),
+        )