Merge pull request #94 from marier-nico/feat/dyn-filter-modifies-event

feat: support modifying events in dyn filters

.github/workflows/build.yaml

@@ -8,7 +8,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [3.7, 3.8, 3.9]
+        python-version: ["3.7", "3.8", "3.9", "3.10", "3.11"]
 
     steps:
     - uses: actions/checkout@v2
@@ -27,11 +27,14 @@ jobs:
     - name: Install dependencies
       run: pip install -r requirements.txt
     - name: Run tox
-      run: tox -e py
+      run: tox -ve py
     - name: Upload coverage to Codecov
       uses: codecov/codecov-action@v1
       with:
         token: ${{ secrets.CODECOV_TOKEN }}
         fail_ci_if_error: true
     - name: Package
-      run: inv build -d package check-package
+      run: |
+        python setup.py sdist bdist_wheel
+        sphinx-build docs docs/_build
+        twine check --strict dist/*

docs/content/filters.rst

@@ -222,6 +222,25 @@ be valid for a dependency (see :ref:`Dependencies` for details). For example :
     True
     False
 
+Since the Dyn filter is basically a way to do anything you can't do with static filters, it also allows modifying the
+event before it gets passed to a processor function. For example :
+
+.. testcode::
+
+    from event_processor import Depends, Event
+    from event_processor.filters import Dyn
+
+    my_event = {"a": "b"}
+    a_filter = Dyn(lambda e: "value", inject_as="modified-key")
+
+    a_filter.matches(my_event)
+
+    print(my_event)
+
+.. testoutput::
+
+    {'a': 'b', 'modified-key': 'value'}
+
 And
 ---
 

requirements.txt

@@ -1,6 +1,8 @@
 black
 invoke
+mypy
 pydantic ~= 1.10.2
+pylama
 pytest
 pytest-cov
 requests

setup.py

@@ -30,6 +30,8 @@
         "Programming Language :: Python :: 3.7",
         "Programming Language :: Python :: 3.8",
         "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
     ],
     keywords="event decorators development",
 

src/event_processor/filters.py

@@ -1,6 +1,6 @@
 """Contains many different filters to conveniently filter through events."""
 from abc import ABC, abstractmethod
-from typing import Any, Union, Callable
+from typing import Any, Union, Callable, Optional
 
 from .dependencies import call_with_injection, Event
 from .exceptions import FilterError, NoValueError
@@ -197,6 +197,9 @@ def _compare(event_value: float, target_value: float) -> bool:
 class Dyn(Filter):
     """Accept events based on a dynamic condition which is resolved by a callable.
 
+    This filter also allows dynamically changing the event by adding the returned value of the resolver to the event
+    under a user-supplied key. This will overwrite a previously existing key.
+
     Note that the equality check with this filter is a bit special. The filter will only be equal if the resolver is
     the same (two functions with the same code are not equal, they need to be the same object in memory).
 
@@ -205,17 +208,23 @@ class Dyn(Filter):
     strategies.
     """
 
-    def __init__(self, resolver: Callable):
+    def __init__(self, resolver: Callable, inject_as: Optional[str] = None):
         if not callable(resolver):
             raise FilterError("The resolver for a dyn filter must be callable")
 
         self.resolver = resolver
+        self.inject_as = inject_as
 
     def matches(self, event: dict) -> bool:
         if hasattr(self.resolver, "__name__") and self.resolver.__name__ == "<lambda>":
-            return bool(self.resolver(event))
+            result = self.resolver(event)
+        else:
+            result = call_with_injection(self.resolver, event=Event(event), cache={})
+
+        if self.inject_as:
+            event[self.inject_as] = result
 
-        return bool(call_with_injection(self.resolver, event=Event(event), cache={}))
+        return bool(result)
 
     def __hash__(self):
         return hash(self.resolver)

src/tests/test_filters.py

@@ -476,6 +476,15 @@ def dyn_filter():
     assert hash(filter_) == hash(dyn_filter)
 
 
+def test_dyn_filter_updates_event_when_inject_as_is_specified():
+    mock_event = {}
+    filter_ = Dyn(lambda e: "my-value", inject_as="my-key")
+
+    filter_.matches(mock_event)
+
+    assert mock_event["my-key"] == "my-value"
+
+
 def test_eq_filter_matches_when_resolvers_are_equal():
     mock_resolver = Mock()
 

tasks.py

@@ -29,7 +29,7 @@ def build(c, docs=False):
 @task
 def test(c):
     c.run("pytest -v --cov=src/event_processor/ --cov-fail-under=100 --cov-report html src/tests")
-    c.run("cd docs && make doctest && cd ..")
+    c.run("make -C docs doctest")
 
 
 @task

tox.ini

@@ -1,18 +1,13 @@
 [tox]
-envlist = py{37,38,39}
+envlist = py{37,38,39,310,3.11}
 skip_missing_interpreters = true
 
 [testenv]
-deps =
-    black
-    invoke
-    mypy
-    pydantic
-    pylama
-    pytest
-    pytest-cov
+allowlist_externals=make
+deps = -r requirements.txt
 commands =
     black -l 120 --check src/
     mypy --ignore-missing-imports src/event_processor/
     pylama src/event_processor/
-    inv test
+    pytest -v --cov=src/event_processor/ --cov-fail-under=100 --cov-report html src/tests
+    make -C docs doctest