refactor Filter class and add Filter test suite (#33)

Author: kdmukai

.gitignore

@@ -2,4 +2,5 @@ venv/
 __pycache__/
 nostr.egg-info/
 dist/
-nostr/_version.py
+nostr/_version.py
+.DS_Store

nostr/event.py

@@ -28,7 +28,7 @@ def __init__(
             signature: str=None) -> None:
         if not isinstance(content, str):
             raise TypeError("Argument 'content' must be of type str")
-        
+
         self.public_key = public_key
         self.content = content
         self.created_at = created_at or int(time.time())

nostr/filter.py

@@ -1,68 +1,121 @@
 from collections import UserList
-from .event import Event
+from typing import List
+
+from .event import Event, EventKind
+
+
 
 class Filter:
+    """
+    NIP-01 filtering.
+
+    Explicitly supports "#e" and "#p" tag filters via `event_refs` and `pubkey_refs`.
+
+    Arbitrary NIP-12 single-letter tag filters are also supported via `add_arbitrary_tag`.
+    If a particular single-letter tag gains prominence, explicit support should be
+    added. For example:
+        # arbitrary tag
+        filter.add_arbitrary_tag('t', [hashtags])
+    
+        # promoted to explicit support
+        Filter(hashtag_refs=[hashtags])
+    """
     def __init__(
             self, 
-            ids: "list[str]"=None, 
-            kinds: "list[int]"=None, 
-            authors: "list[str]"=None, 
-            since: int=None, 
-            until: int=None, 
-            tags: "dict[str, list[str]]"=None,
-            limit: int=None) -> None:
-        self.IDs = ids
+            event_ids: List[str] = None, 
+            kinds: List[EventKind] = None, 
+            authors: List[str] = None, 
+            since: int = None, 
+            until: int = None, 
+            event_refs: List[str] = None,       # the "#e" attr; list of event ids referenced in an "e" tag
+            pubkey_refs: List[str] = None,      # The "#p" attr; list of pubkeys referenced in a "p" tag
+            limit: int = None) -> None:
+        self.event_ids = event_ids
         self.kinds = kinds
         self.authors = authors
         self.since = since
         self.until = until
-        self.tags = tags
+        self.event_refs = event_refs
+        self.pubkey_refs = pubkey_refs
         self.limit = limit
 
+        self.tags = {}
+        if self.event_refs:
+            self.add_arbitrary_tag('e', self.event_refs)
+        if self.pubkey_refs:
+            self.add_arbitrary_tag('p', self.pubkey_refs)
+
+
+    def add_arbitrary_tag(self, tag: str, values: list):
+        """
+            Filter on any arbitrary tag with explicit handling for NIP-01 and NIP-12
+            single-letter tags.
+        """
+         # NIP-01 'e' and 'p' tags and any NIP-12 single-letter tags must be prefixed with "#"
+        tag_key = tag if len(tag) > 1 else f"#{tag}"
+        self.tags[tag_key] = values
+
+
     def matches(self, event: Event) -> bool:
-        if self.IDs != None and event.id not in self.IDs:
+        if self.event_ids is not None and event.id not in self.event_ids:
             return False
-        if self.kinds != None and event.kind not in self.kinds:
+        if self.kinds is not None and event.kind not in self.kinds:
             return False
-        if self.authors != None and event.public_key not in self.authors:
+        if self.authors is not None and event.public_key not in self.authors:
             return False
-        if self.since != None and event.created_at < self.since:
+        if self.since is not None and event.created_at < self.since:
             return False
-        if self.until != None and event.created_at > self.until:
+        if self.until is not None and event.created_at > self.until:
             return False
-        if self.tags != None and len(event.tags) == 0:
+        if (self.event_refs is not None or self.pubkey_refs is not None) and len(event.tags) == 0:
             return False
-        if self.tags != None:
-            e_tag_identifiers = [e_tag[0] for e_tag in event.tags] 
+
+        if self.tags:
+            e_tag_identifiers = set([e_tag[0] for e_tag in event.tags])
             for f_tag, f_tag_values in self.tags.items():
-                if f_tag[1:] not in e_tag_identifiers:
+                # Omit any NIP-01 or NIP-12 "#" chars on single-letter tags
+                f_tag = f_tag.replace("#", "")
+
+                if f_tag not in e_tag_identifiers:
+                    # Event is missing a tag type that we're looking for
                     return False
+                
+                # Multiple values within f_tag_values are treated as OR search; an Event
+                # needs to match only one.
+                # Note: an Event could have multiple entries of the same tag type
+                # (e.g. a reply to multiple people) so we have to check all of them.
+                match_found = False
                 for e_tag in event.tags:
-                    if e_tag[1] not in f_tag_values:
-                        return False
-        
+                    if e_tag[0] == f_tag and e_tag[1] in f_tag_values:
+                        match_found = True
+                        break
+                if not match_found:
+                    return False
+
         return True
 
+
     def to_json_object(self) -> dict:
         res = {}
-        if self.IDs != None:
-            res["ids"] = self.IDs
-        if self.kinds != None:   
+        if self.event_ids is not None:
+            res["ids"] = self.event_ids
+        if self.kinds is not None:   
             res["kinds"] = self.kinds
-        if self.authors != None:
+        if self.authors is not None:
             res["authors"] = self.authors
-        if self.since != None:
+        if self.since is not None:
             res["since"] = self.since
-        if self.until != None:
+        if self.until is not None:
             res["until"] = self.until
-        if self.tags != None:
-            for tag, values in self.tags.items():
-                res[tag] = values
-        if self.limit != None:
+        if self.limit is not None:
             res["limit"] = self.limit
+        if self.tags:
+            res.update(self.tags)
 
         return res
-                
+
+
+
 class Filters(UserList):
     def __init__(self, initlist: "list[Filter]"=[]) -> None:
         super().__init__(initlist)
@@ -75,5 +128,4 @@ def match(self, event: Event):
         return False
 
     def to_json_array(self) -> list:
-        return [filter.to_json_object() for filter in self.data]
-        
+        return [filter.to_json_object() for filter in self.data]