.github/workflows/python-lint.yml

@@ -1,24 +0,0 @@
-name: Python lint
-
-on: [push, pull_request]
-
-jobs:
-  lint:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v4
-      with:
-        python-version: "3.11"
-    - uses: isort/isort-action@master
-      with:
-        sortPaths: "./reactbot"
-    - uses: psf/black@stable
-      with:
-        src: "./reactbot"
-    - name: pre-commit
-      run: |
-        pip install pre-commit
-        pre-commit run -av trailing-whitespace
-        pre-commit run -av end-of-file-fixer
-        pre-commit run -av check-added-large-files

.gitlab-ci.yml

@@ -1,3 +0,0 @@
-include:
-- project: 'maubot/maubot'
-  file: '/.gitlab-ci-plugin.yml'

.pre-commit-config.yaml

@@ -1,19 +0,0 @@
-repos:
-  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
-    hooks:
-      - id: trailing-whitespace
-        exclude_types: [markdown]
-      - id: end-of-file-fixer
-      - id: check-added-large-files
-  - repo: https://github.com/psf/black
-    rev: 23.9.1
-    hooks:
-      - id: black
-        language_version: python3
-        files: ^reactbot/.*\.pyi?$
-  - repo: https://github.com/PyCQA/isort
-    rev: 5.12.0
-    hooks:
-      - id: isort
-        files: ^reactbot/.*\.pyi?$

README.md

@@ -7,11 +7,6 @@ A [maubot](https://github.com/maubot/maubot) that responds to messages that matc
   and an image response for "alot".
 * [samples/jesari.yaml](samples/jesari.yaml) contains a replacement for [jesaribot](https://github.com/maubot/jesaribot).
 * [samples/stallman.yaml](samples/stallman.yaml) contains a Stallman interject bot.
-* [samples/random-reaction.yaml](samples/random-reaction.yaml) has an example of
-  a randomized reaction to matching messages.
-* [samples/nitter.yaml](samples/nitter.yaml) has an example of matching tweet links
-  and responding with a corresponding nitter.net link.
-* [samples/thread.yaml](samples/thread.yaml) has an example of replying in a thread.
 
 ## Config format
 ### Templates
@@ -20,10 +15,7 @@ Templates contain the actual event type and content to be sent.
 * `content` - The event content. Either an object or jinja2 template that produces JSON.
 * `variables` - A key-value map of variables.
 
-Variables that start with `{{` are parsed as jinja2 templates and get the
+Variables are parsed as jinja2 templates and get the maubot event object in `event`.
-maubot event object in `event`. As of v3, variables are parsed using jinja2's
-[native types mode](https://jinja.palletsprojects.com/en/3.1.x/nativetypes/),
-which means the output can be a non-string type.
 
 If the content is a string, it'll be parsed as a jinja2 template and the output
 will be parsed as JSON. The content jinja2 template will get `event` just like

maubot.yaml

@@ -1,6 +1,6 @@
 maubot: 0.1.0
 id: xyz.maubot.reactbot
-version: 2.2.0
+version: 2.0.0
 license: AGPL-3.0-or-later
 modules:
 - reactbot

pyproject.toml

@@ -1,11 +0,0 @@
-[tool.isort]
-profile = "black"
-force_to_top = "typing"
-from_first = true
-combine_as_imports = true
-known_first_party = ["mautrix", "maubot"]
-line_length = 99
-
-[tool.black]
-line-length = 99
-target-version = ["py38"]

reactbot/bot.py

@@ -13,16 +13,18 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Dict, Tuple, Type
+from typing import Type, Tuple, Dict
+from itertools import chain
 import time
 
 from attr import dataclass
 
-from maubot import MessageEvent, Plugin
+from mautrix.types import EventType, MessageType, UserID, RoomID
-from maubot.handlers import event
-from mautrix.types import EventType, MessageType, RoomID, UserID
 from mautrix.util.config import BaseProxyConfig
 
+from maubot import Plugin, MessageEvent
+from maubot.handlers import event
+
 from .config import Config, ConfigError
 
 
@@ -65,22 +67,19 @@ class ReactBot(Plugin):
             self.config.parse_data()
         except ConfigError:
             self.log.exception("Failed to load config")
-        for fi in self.user_flood.values():
+        for fi in self.user_flood.items():
             fi.max = self.config["antispam.user.max"]
             fi.delay = self.config["antispam.user.delay"]
-        for fi in self.room_flood.values():
+        for fi in self.room_flood.items():
             fi.max = self.config["antispam.room.max"]
             fi.delay = self.config["antispam.room.delay"]
 
-    def _make_flood_info(self, for_type: str) -> "FloodInfo":
+    def _make_flood_info(self, for_type: str) -> 'FloodInfo':
-        return FloodInfo(
+        return FloodInfo(max=self.config[f"antispam.{for_type}.max"],
-            max=self.config[f"antispam.{for_type}.max"],
                          delay=self.config[f"antispam.{for_type}.delay"],
-            count=0,
+                         count=0, last_message=0)
-            last_message=0,
-        )
 
-    def _get_flood_info(self, flood_map: dict, key: str, for_type: str) -> "FloodInfo":
+    def _get_flood_info(self, flood_map: dict, key: str, for_type: str) -> 'FloodInfo':
         try:
             return flood_map[key]
         except KeyError:
@@ -88,10 +87,8 @@ class ReactBot(Plugin):
             return fi
 
     def is_flood(self, evt: MessageEvent) -> bool:
-        return (
+        return (self._get_flood_info(self.user_flood, evt.sender, "user").bump()
-            self._get_flood_info(self.user_flood, evt.sender, "user").bump()
+                or self._get_flood_info(self.room_flood, evt.room_id, "room").bump())
-            or self._get_flood_info(self.room_flood, evt.room_id, "room").bump()
-        )
 
     @event.on(EventType.ROOM_MESSAGE)
     async def event_handler(self, evt: MessageEvent) -> None:
@@ -105,5 +102,5 @@ class ReactBot(Plugin):
                 try:
                     await rule.execute(evt, match)
                 except Exception:
-                    self.log.exception(f"Failed to execute {name} in {evt.room_id}")
+                    self.log.exception(f"Failed to execute {name}")
                 return

reactbot/config.py

@@ -13,18 +13,17 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Any, Dict, List, Union
+from typing import List, Union, Dict, Any
 import re
 
-from jinja2 import Template as JinjaStringTemplate
+from jinja2 import Template as JinjaTemplate
-from jinja2.nativetypes import NativeTemplate as JinjaNativeTemplate
 
-from mautrix.types import EventType
 from mautrix.util.config import BaseProxyConfig, ConfigUpdateHelper
+from mautrix.types import EventType
 
-from .rule import RPattern, Rule
 from .simplepattern import SimplePattern
 from .template import Template
+from .rule import Rule, RPattern
 
 InputPattern = Union[str, Dict[str, str]]
 
@@ -45,36 +44,28 @@ class Config(BaseProxyConfig):
 
     def parse_data(self) -> None:
         self.default_flags = re.RegexFlag(0)
-        self.templates = {}
-        self.rules = {}
-
         self.default_flags = self._get_flags(self["default_flags"])
-        self.templates = {
+        self.templates = {name: self._make_template(name, tpl)
-            name: self._make_template(name, tpl) for name, tpl in self["templates"].items()
+                          for name, tpl in self["templates"].items()}
-        }
+        self.rules = {name: self._make_rule(name, rule)
-        self.rules = {name: self._make_rule(name, rule) for name, rule in self["rules"].items()}
+                      for name, rule in self["rules"].items()}
 
     def _make_rule(self, name: str, rule: Dict[str, Any]) -> Rule:
         try:
-            return Rule(
+            return Rule(rooms=set(rule.get("rooms", [])),
-                rooms=set(rule.get("rooms", [])),
-                not_rooms=set(rule.get("not_rooms", [])),
                         matches=self._compile_all(rule["matches"]),
                         not_matches=self._compile_all(rule.get("not_matches", [])),
                         type=EventType.find(rule["type"]) if "type" in rule else None,
                         template=self.templates[rule["template"]],
-                variables=self._parse_variables(rule),
+                        variables=self._parse_variables(rule))
-            )
         except Exception as e:
             raise ConfigError(f"Failed to load {name}") from e
 
     def _make_template(self, name: str, tpl: Dict[str, Any]) -> Template:
         try:
-            return Template(
+            return Template(type=EventType.find(tpl.get("type", "m.room.message")),
-                type=EventType.find(tpl.get("type", "m.room.message")),
                             variables=self._parse_variables(tpl),
-                content=self._parse_content(tpl.get("content", None)),
+                            content=self._parse_content(tpl.get("content", None))).init()
-            ).init()
         except Exception as e:
             raise ConfigError(f"Failed to load {name}") from e
 
@@ -96,24 +87,16 @@ class Config(BaseProxyConfig):
         return re.compile(pattern, flags=flags)
 
     @staticmethod
-    def _parse_variables(data: Dict[str, Any]) -> Dict[str, Any]:
+    def _parse_variables(data: Dict[str, Any]) -> Dict[str, JinjaTemplate]:
-        return {
+        return {name: JinjaTemplate(var_tpl) for name, var_tpl
-            name: (
+                in data.get("variables", {}).items()}
-                JinjaNativeTemplate(var_tpl)
-                if isinstance(var_tpl, str) and var_tpl.startswith("{{")
-                else var_tpl
-            )
-            for name, var_tpl in data.get("variables", {}).items()
-        }
 
     @staticmethod
-    def _parse_content(
+    def _parse_content(content: Union[Dict[str, Any], str]) -> Union[Dict[str, Any], JinjaTemplate]:
-        content: Union[Dict[str, Any], str]
-    ) -> Union[Dict[str, Any], JinjaStringTemplate]:
         if not content:
             return {}
         elif isinstance(content, str):
-            return JinjaStringTemplate(content)
+            return JinjaTemplate(content)
         return content
 
     @staticmethod

reactbot/rule.py

@@ -13,15 +13,17 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Any, Dict, List, Match, Optional, Pattern, Set, Union
+from typing import Optional, Match, Dict, List, Set, Union, Pattern
 
 from attr import dataclass
+from jinja2 import Template as JinjaTemplate
+
+from mautrix.types import RoomID, EventType
 
 from maubot import MessageEvent
-from mautrix.types import EventType, RoomID
 
+from .template import Template
 from .simplepattern import SimplePattern
-from .template import OmitValue, Template
 
 RPattern = Union[Pattern, SimplePattern]
 
@@ -29,12 +31,11 @@ RPattern = Union[Pattern, SimplePattern]
 @dataclass
 class Rule:
     rooms: Set[RoomID]
-    not_rooms: Set[RoomID]
     matches: List[RPattern]
     not_matches: List[RPattern]
     template: Template
     type: Optional[EventType]
-    variables: Dict[str, Any]
+    variables: Dict[str, JinjaTemplate]
 
     def _check_not_match(self, body: str) -> bool:
         for pattern in self.not_matches:
@@ -45,8 +46,6 @@ class Rule:
     def match(self, evt: MessageEvent) -> Optional[Match]:
         if len(self.rooms) > 0 and evt.room_id not in self.rooms:
             return None
-        elif evt.room_id in self.not_rooms:
-            return None
         for pattern in self.matches:
             match = pattern.search(evt.content.body)
             if match:
@@ -56,10 +55,7 @@ class Rule:
         return None
 
     async def execute(self, evt: MessageEvent, match: Match) -> None:
-        extra_vars = {
+        content = self.template.execute(evt=evt, rule_vars=self.variables,
-            "0": match.group(0),
+                                        extra_vars={str(i): val for i, val in
-            **{str(i + 1): val for i, val in enumerate(match.groups())},
+                                                    enumerate(match.groups())})
-            **match.groupdict(),
-        }
-        content = self.template.execute(evt=evt, rule_vars=self.variables, extra_vars=extra_vars)
         await evt.client.send_message_event(evt.room_id, self.type or self.template.type, content)

reactbot/simplepattern.py

@@ -1,5 +1,5 @@
 # reminder - A maubot plugin that reacts to messages that match predefined rules.
-# Copyright (C) 2021 Tulir Asokan
+# Copyright (C) 2019 Tulir Asokan
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
@@ -13,82 +13,50 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Callable, Dict, List, NamedTuple, Optional
+from typing import Callable, List, Optional
 import re
 
 
-class SimpleMatch(NamedTuple):
+class BlankMatch:
-    value: str
+    @staticmethod
-
+    def groups() -> List[str]:
-    def groups(self) -> List[str]:
+        return []
-        return [self.value]
-
-    def group(self, group: int) -> Optional[str]:
-        if group == 0:
-            return self.value
-        return None
-
-    def groupdict(self) -> Dict[str, str]:
-        return {}
-
-
-def matcher_equals(val: str, pattern: str) -> bool:
-    return val == pattern
-
-
-def matcher_startswith(val: str, pattern: str) -> bool:
-    return val.startswith(pattern)
-
-
-def matcher_endswith(val: str, pattern: str) -> bool:
-    return val.endswith(pattern)
-
-
-def matcher_contains(val: str, pattern: str) -> bool:
-    return pattern in val
-
-
-SimpleMatcherFunc = Callable[[str, str], bool]
 
 
 class SimplePattern:
-    matcher: SimpleMatcherFunc
+    _ptm = BlankMatch()
-    pattern: str
+
+    matcher: Callable[[str], bool]
     ignorecase: bool
 
-    def __init__(self, matcher: SimpleMatcherFunc, pattern: str, ignorecase: bool) -> None:
+    def __init__(self, matcher: Callable[[str], bool], ignorecase: bool) -> None:
         self.matcher = matcher
-        self.pattern = pattern
         self.ignorecase = ignorecase
 
-    def search(self, val: str) -> SimpleMatch:
+    def search(self, val: str) -> BlankMatch:
         if self.ignorecase:
             val = val.lower()
-        if self.matcher(val, self.pattern):
+        if self.matcher(val):
-            return SimpleMatch(self.pattern)
+            return self._ptm
 
     @staticmethod
-    def compile(
+    def compile(pattern: str, flags: re.RegexFlag = re.RegexFlag(0), force_raw: bool = False
-        pattern: str, flags: re.RegexFlag = re.RegexFlag(0), force_raw: bool = False
+                ) -> Optional['SimplePattern']:
-    ) -> Optional["SimplePattern"]:
         ignorecase = flags == re.IGNORECASE
         s_pattern = pattern.lower() if ignorecase else pattern
         esc = ""
         if not force_raw:
             esc = re.escape(pattern)
         first, last = pattern[0], pattern[-1]
-        if first == "^" and last == "$" and (force_raw or esc == f"\\^{pattern[1:-1]}\\$"):
+        if first == '^' and last == '$' and (force_raw or esc == f"\\^{pattern[1:-1]}\\$"):
             s_pattern = s_pattern[1:-1]
-            func = matcher_equals
+            return SimplePattern(lambda val: val == s_pattern, ignorecase=ignorecase)
-        elif first == "^" and (force_raw or esc == f"\\^{pattern[1:]}"):
+        elif first == '^' and (force_raw or esc == f"\\^{pattern[1:]}"):
             s_pattern = s_pattern[1:]
-            func = matcher_startswith
+            return SimplePattern(lambda val: val.startswith(s_pattern), ignorecase=ignorecase)
-        elif last == "$" and (force_raw or esc == f"{pattern[:-1]}\\$"):
+        elif last == '$' and (force_raw or esc == f"{pattern[:-1]}\\$"):
             s_pattern = s_pattern[:-1]
-            func = matcher_endswith
+            return SimplePattern(lambda val: val.endswith(s_pattern), ignorecase=ignorecase)
         elif force_raw or esc == pattern:
-            func = matcher_contains
+            return SimplePattern(lambda val: s_pattern in val, ignorecase=ignorecase)
-        else:
-            # Not a simple pattern
         return None
-        return SimplePattern(matcher=func, pattern=s_pattern, ignorecase=ignorecase)

reactbot/template.py

@@ -1,5 +1,5 @@
 # reminder - A maubot plugin that reacts to messages that match predefined rules.
-# Copyright (C) 2021 Tulir Asokan
+# Copyright (C) 2019 Tulir Asokan
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License as published by
@@ -13,17 +13,16 @@
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
-from typing import Any, Dict, List, Tuple, Union
+from typing import Union, Dict, List, Tuple, Any
 from itertools import chain
-import copy
 import json
+import copy
 import re
 
 from attr import dataclass
-from jinja2 import Template as JinjaStringTemplate
+from jinja2 import Template as JinjaTemplate
-from jinja2.nativetypes import Template as JinjaNativeTemplate
 
-from mautrix.types import Event, EventType
+from mautrix.types import EventType, Event
 
 
 class Key(str):
@@ -31,11 +30,6 @@ class Key(str):
 
 
 variable_regex = re.compile(r"\$\${([0-9A-Za-z-_]+)}")
-OmitValue = object()
-
-global_vars = {
-    "omit": OmitValue,
-}
 
 Index = Union[str, int, Key]
 
@@ -43,12 +37,12 @@ Index = Union[str, int, Key]
 @dataclass
 class Template:
     type: EventType
-    variables: Dict[str, Any]
+    variables: Dict[str, JinjaTemplate]
-    content: Union[Dict[str, Any], JinjaStringTemplate]
+    content: Union[Dict[str, Any], JinjaTemplate]
 
     _variable_locations: List[Tuple[Index, ...]] = None
 
-    def init(self) -> "Template":
+    def init(self) -> 'Template':
         self._variable_locations = []
         self._map_variable_locations((), self.content)
         return self
@@ -59,11 +53,11 @@ class Template:
                 self._map_variable_locations((*path, i), v)
         elif isinstance(data, dict):
             for k, v in data.items():
-                if variable_regex.search(k):
+                if variable_regex.match(k):
                     self._variable_locations.append((*path, Key(k)))
                 self._map_variable_locations((*path, k), v)
         elif isinstance(data, str):
-            if variable_regex.search(data):
+            if variable_regex.match(data):
                 self._variable_locations.append(path)
 
     @classmethod
@@ -74,29 +68,20 @@ class Template:
 
     @staticmethod
     def _replace_variables(tpl: str, variables: Dict[str, Any]) -> str:
-        full_var_match = variable_regex.fullmatch(tpl)
+        for match in variable_regex.finditer(tpl):
-        if full_var_match:
+            val = variables[match.group(1)]
+            if match.start() == 0 and match.end() == len(tpl):
                 # Whole field is a single variable, just return the value to allow non-string types.
-            return variables[full_var_match.group(1)]
+                return val
-        return variable_regex.sub(lambda match: str(variables[match.group(1)]), tpl)
+            tpl = tpl[:match.start()] + val + tpl[match.end():]
+        return tpl
 
-    def execute(
+    def execute(self, evt: Event, rule_vars: Dict[str, JinjaTemplate], extra_vars: Dict[str, str]
-        self, evt: Event, rule_vars: Dict[str, Any], extra_vars: Dict[str, str]
                 ) -> Dict[str, Any]:
-        variables = extra_vars
+        variables = {**{name: template.render(event=evt)
-        for name, template in chain(rule_vars.items(), self.variables.items()):
+                        for name, template in chain(self.variables.items(), rule_vars.items())},
-            if isinstance(template, JinjaNativeTemplate):
+                     **extra_vars}
-                rendered_var = template.render(event=evt, variables=variables, **global_vars)
+        if isinstance(self.content, JinjaTemplate):
-                if (
-                    not isinstance(rendered_var, (str, int, list, tuple, dict, bool))
-                    and rendered_var is not None
-                    and rendered_var is not OmitValue
-                ):
-                    rendered_var = str(rendered_var)
-                variables[name] = rendered_var
-            else:
-                variables[name] = template
-        if isinstance(self.content, JinjaStringTemplate):
             raw_json = self.content.render(event=evt, **variables)
             return json.loads(raw_json)
         content = copy.deepcopy(self.content)
@@ -107,9 +92,5 @@ class Template:
                 key = str(key)
                 data[self._replace_variables(key, variables)] = data.pop(key)
             else:
-                replaced_data = self._replace_variables(data[key], variables)
+                data[key] = self._replace_variables(data[key], variables)
-                if replaced_data is OmitValue:
-                    del data[key]
-                else:
-                    data[key] = replaced_data
         return content

samples/nitter.yaml

@@ -1,15 +0,0 @@
-templates:
-    nitter:
-        type: m.room.message
-        content:
-            msgtype: m.text
-            body: https://nitter.net/$${1}/status/$${2}
-
-default_flags:
-- ignorecase
-
-rules:
-    twitter:
-        matches:
-        - https://twitter.com/(.+?)/status/(\d+)
-        template: nitter

samples/random-reaction.yaml

@@ -1,25 +0,0 @@
-templates:
-    random_reaction:
-        type: m.reaction
-        variables:
-            react_to_event: '{{event.event_id}}'
-            reaction: '{{ variables.reaction_choices | random }}'
-        content:
-            m.relates_to:
-                rel_type: m.annotation
-                event_id: $${react_to_event}
-                key: $${reaction}
-
-default_flags:
-- ignorecase
-
-rules:
-    random:
-        matches:
-        - hmm
-        template: random_reaction
-        variables:
-            reaction_choices:
-            - 🤔
-            - 🧐
-            - 🤨

samples/stallman.yaml

@@ -10,20 +10,16 @@ templates:
 default_flags:
 - ignorecase
 
-antispam:
-    room:
-        max: 1
-        delay: 60
-    user:
-        max: 2
-        delay: 60
-
 rules:
     linux:
         matches:
         - linux
         not_matches:
-        - gnu
+        - pattern: gnu+linux
+          raw: true
+        - pattern: gnu/linux
+          raw: true
+        - gnu plus linux
         - kernel
         template: plaintext_notice
         variables:
@@ -147,7 +143,7 @@ rules:
                 To avoid spreading unnecessary bias and confusion, it is best to adopt a firm policy not to speak or even think in terms of "intellectual property".
                 The hypocrisy of calling these powers "rights" is starting to make the World "Intellectual Property" Organization embarrassed.
     lamp:
-        matches: [(\s|^)lamp(\s|$)]
+        matches: [(\s|^)lamp]
         template: plaintext_notice
         variables:
             message: |
@@ -180,7 +176,7 @@ rules:
             message: |
                 I'd just like to interject for one moment. Please avoid using the term "open" or "open source" as a substitute for "free software". Those terms refer to a different position based on different values. Free software is a political movement; open source is a development model. When referring to the open source position, using its name is appropriate; but please do not use it to label us or our work--that leads people to think we share those views.
     pc:
-        matches: [(\s|^)pcs?(\s|$)]
+        matches: [(\s|^)pcs?]
         template: plaintext_notice
         variables:
             message: |
@@ -200,7 +196,7 @@ rules:
                 I'd just like to interject for one moment. Publishers often refer to copying they don't approve of as "piracy." In this way, they imply that it is ethically equivalent to attacking ships on the high seas, kidnapping and murdering the people on them. Based on such propaganda, they have procured laws in most of the world to forbid copying in most (or sometimes all) circumstances. (They are still pressuring to make these prohibitions more complete.)
                 If you don't believe that copying not approved by the publisher is just like kidnapping and murder, you might prefer not to use the word "piracy" to describe it. Neutral terms such as "unauthorized copying" (or "prohibited copying" for the situation where it is illegal) are available for use instead. Some of us might even prefer to use a positive term such as "sharing information with your neighbor."
     powerpoint:
-        matches: [powerpoint, \sppt(\s|$)]
+        matches: [powerpoint, \sppt]
         template: plaintext_notice
         variables:
             message: |
@@ -240,7 +236,7 @@ rules:
             message: |
                 I'd just like to interject for one moment. Please don't use the term "vendor" to refer generally to anyone that develops or packages software. Many programs are developed in order to sell copies, and their developers are therefore their vendors; this even includes some free software packages. However, many programs are developed by volunteers or organizations which do not intend to sell copies. These developers are not vendors. Likewise, only some of the packagers of GNU/Linux distributions are vendors. We recommend the general term "supplier" instead.
     arch:
-        matches: (^|\s)arch($|\s)
+        matches: [(^|\s)arch]
         template: plaintext_notice
         variables:
             message: |
@@ -329,7 +325,7 @@ rules:
                 I'd just like to interject for one moment. To speak of “compensation for authors” in connection with copyright carries the assumptions that (1) copyright exists for the sake of authors and (2) whenever we read something, we take on a debt to the author which we must then repay. The first assumption is simply false, and the second is outrageous.
                 “Compensating the rights-holders” adds a further swindle: you're supposed to imagine that means paying the authors, and occasionally it does, but most of the time it means a subsidy for the same publishing companies that are pushing unjust laws on us.
     consume:
-        matches: [(^|\s)consume(\s|$)]
+        matches: [consume\s]
         template: plaintext_notice
         variables:
             message: |
@@ -379,7 +375,7 @@ rules:
             message: |
                 I'd just like to interject for one moment. Don't use “freely available software” as a synonym for “free software.” The terms are not equivalent. Software is “freely available” if anyone can easily get a copy. “Free software” is defined in terms of the freedom of users that have a copy of it. These are answers to different questions.
     google:
-        matches: [(^|\s)google(\s|$)]
+        matches: [google\\s]
         template: plaintext_notice
         variables:
             message: |
@@ -419,3 +415,4 @@ rules:
                 Under the US legal system, copyright infringement is not theft. Laws about theft are not applicable to copyright infringement. The supporters of repressive copyright are making an appeal to authority—and misrepresenting what authority says.
                 Unauthorized copying is forbidden by copyright law in many circumstances (not all!), but being forbidden doesn't make it wrong. In general, laws don't define right and wrong. Laws, at their best, attempt to implement justice. If the laws (the implementation) don't fit our ideas of right and wrong (the spec), the laws are what should change.
                 In addition, a US judge, presiding over a trial for copyright infringement, recognized that “piracy” and “theft” are smear-words.
+

samples/thread.yaml

@@ -1,50 +0,0 @@
-templates:
-    always_in_thread:
-        type: m.room.message
-        variables:
-            thread_parent: '{{event.content.get_thread_parent() or event.event_id}}'
-            event_id: '{{event.event_id}}'
-        content:
-            msgtype: m.text
-            body: $${text}
-            m.relates_to:
-                rel_type: m.thread
-                event_id: $${thread_parent}
-                is_falling_back: true
-                m.in_reply_to:
-                    event_id: $${event_id}
-    # Reply in thread if the message is already in a thread, otherwise use a normal reply.
-    # This currently requires using a jinja template as the content instead of a normal yaml map.
-    thread_or_reply:
-        type: m.room.message
-        variables:
-            relates_to: |
-                {{
-                    {"rel_type": "m.thread", "event_id": event.content.get_thread_parent(), "is_falling_back": True, "m.in_reply_to": {"event_id": event.event_id}}
-                    if event.content.get_thread_parent()
-                    else {"m.in_reply_to": {"event_id": event.event_id}}
-                }}
-        content:
-            msgtype: m.text
-            body: $${text}
-            m.relates_to: $${relates_to}
-
-antispam:
-  room:
-    max: 60
-    delay: 60
-  user:
-    max: 60
-    delay: 60
-
-rules:
-    thread:
-        matches: [^!thread$]
-        template: always_in_thread
-        variables:
-            text: meow 3:<
-    maybe_thread:
-        matches: [^!thread --maybe$]
-        template: thread_or_reply
-        variables:
-            text: meow >:3