Notification - Adding tokens {{diff_changed_from}} and {{diff_changed_to}} #3818

changedetectionio/blueprint/tags/__init__.py

@@ -22,12 +22,10 @@ def construct_blueprint(datastore: ChangeDetectionStore):
 
         tag_count = Counter(tag for watch in datastore.data['watching'].values() if watch.get('tags') for tag in watch['tags'])
 
-        from changedetectionio import processors
         output = render_template("groups-overview.html",
                                  app_rss_token=datastore.data['settings']['application'].get('rss_access_token'),
                                  available_tags=sorted_tags,
                                  form=add_form,
-                                 generate_tag_colors=processors.generate_processor_badge_colors,
                                  tag_count=tag_count,
                                  )
 
@@ -210,17 +208,9 @@ def construct_blueprint(datastore: ChangeDetectionStore):
             template = env.from_string(template_str)
             included_content = template.render(**template_args)
 
-        # Watches whose URL currently matches this tag's pattern
-        matching_watches = {
-            w_uuid: watch
-            for w_uuid, watch in datastore.data['watching'].items()
-            if default.matches_url(watch.get('url', ''))
-        }
-
         output = render_template("edit-tag.html",
                                  extra_form_content=included_content,
                                  extra_tab_content=form.extra_tab_content() if form.extra_tab_content() else None,
-                                 matching_watches=matching_watches,
                                  settings_application=datastore.data['settings']['application'],
                                  **template_args
                                  )

changedetectionio/blueprint/tags/form.py

@@ -10,8 +10,6 @@ from changedetectionio.processors.restock_diff.forms import processor_settings_f
 
 class group_restock_settings_form(restock_settings_form):
     overrides_watch = BooleanField('Activate for individual watches in this tag/group?', default=False)
-    url_match_pattern = StringField('Auto-apply to watches with URLs matching',
-                                    render_kw={"placeholder": "e.g. *://example.com/* or github.com/myorg"})
 
 class SingleTag(Form):
 

changedetectionio/blueprint/tags/templates/edit-tag.html

@@ -43,20 +43,6 @@
                     <div class="pure-control-group">
                         {{ render_field(form.title, placeholder="https://...", required=true, class="m-d") }}
                     </div>
-                    <div class="pure-control-group">
-                        {{ render_field(form.url_match_pattern, class="m-d") }}
-                        <span class="pure-form-message-inline">{{ _('Automatically applies this tag to any watch whose URL matches. Supports wildcards: <code>*example.com*</code> or plain substring: <code>github.com/myorg</code>')|safe }}</span>
-                    </div>
-                    {% if matching_watches %}
-                    <div class="pure-control-group">
-                        <label>{{ _('Currently matching watches') }} ({{ matching_watches|length }})</label>
-                        <ul class="tag-url-match-list">
-                            {% for w_uuid, w in matching_watches.items() %}
-                            <li><a href="{{ url_for('ui.ui_edit.edit_page', uuid=w_uuid) }}">{{ w.label }}</a></li>
-                            {% endfor %}
-                        </ul>
-                    </div>
-                    {% endif %}
                 </fieldset>
             </div>
 

changedetectionio/blueprint/tags/templates/groups-overview.html

@@ -3,22 +3,6 @@
 {% from '_helpers.html' import render_simple_field, render_field %}
 <script src="{{url_for('static_content', group='js', filename='jquery-3.6.0.min.js')}}"></script>
 <script src="{{url_for('static_content', group='js', filename='modal.js')}}"></script>
-<style>
-{%- for uuid, tag in available_tags -%}
-{%- if tag and tag.title -%}
-{%- set class_name = tag.title|sanitize_tag_class -%}
-{%- set colors = generate_tag_colors(tag.title) -%}
-.watch-tag-list.tag-{{ class_name }} {
-  background-color: {{ colors['light']['bg'] }};
-  color: {{ colors['light']['color'] }};
-}
-html[data-darkmode="true"] .watch-tag-list.tag-{{ class_name }} {
-  background-color: {{ colors['dark']['bg'] }};
-  color: {{ colors['dark']['color'] }};
-}
-{%- endif -%}
-{%- endfor -%}
-</style>
 
 <div class="box">
     <form class="pure-form" action="{{ url_for('tags.form_tag_add') }}" method="POST" id="new-watch-form">
@@ -64,7 +48,7 @@ html[data-darkmode="true"] .watch-tag-list.tag-{{ class_name }} {
                     <a class="link-mute state-{{'on' if tag.notification_muted else 'off'}}" href="{{url_for('tags.mute', uuid=tag.uuid)}}"><img src="{{url_for('static_content', group='images', filename='bell-off.svg')}}" alt="Mute notifications" title="Mute notifications" class="icon icon-mute" ></a>
                 </td>
                 <td>{{ "{:,}".format(tag_count[uuid]) if uuid in tag_count else 0 }}</td>
-                <td class="title-col inline"> <a href="{{url_for('watchlist.index', tag=uuid) }}" class="watch-tag-list tag-{{ tag.title|sanitize_tag_class }}">{{ tag.title }}</a></td>
+                <td class="title-col inline"> <a href="{{url_for('watchlist.index', tag=uuid) }}">{{ tag.title }}</a></td>
                 <td>
                     <a class="pure-button pure-button-primary" href="{{ url_for('tags.form_tag_edit', uuid=uuid) }}">{{ _('Edit') }}</a>
                     <a href="{{ url_for('ui.form_watch_checknow', tag=uuid) }}" class="pure-button pure-button-primary" >{{ _('Recheck') }}</a>

changedetectionio/blueprint/ui/edit.py

@@ -320,12 +320,7 @@ def construct_blueprint(datastore: ChangeDetectionStore, update_q, queuedWatchMe
                 'using_global_webdriver_wait': not default['webdriver_delay'],
                 'uuid': uuid,
                 'watch': watch,
-                'capabilities': capabilities,
-                'auto_applied_tags': {
-                    tag_uuid: tag
-                    for tag_uuid, tag in datastore.data['settings']['application']['tags'].items()
-                    if tag_uuid not in watch.get('tags', []) and tag.matches_url(watch.get('url', ''))
-                },
+                'capabilities': capabilities
             }
 
             included_content = None

changedetectionio/blueprint/ui/templates/edit.html

@@ -81,14 +81,6 @@
                     <div class="pure-control-group">
                         {{ render_field(form.tags) }}
                         <span class="pure-form-message-inline">{{ _('Organisational tag/group name used in the main listing page') }}</span>
-                        {% if auto_applied_tags %}
-                        <span class="pure-form-message-inline">
-                            {{ _('Also automatically applied by URL pattern:') }}
-                            {% for tag_uuid, tag in auto_applied_tags.items() %}
-                            <a href="{{ url_for('tags.form_tag_edit', uuid=tag_uuid) }}" class="watch-tag-list tag-{{ tag.title|sanitize_tag_class }}">{{ tag.title }}</a>
-                            {% endfor %}
-                        </span>
-                        {% endif %}
                     </div>
                     <div class="pure-control-group inline-radio">
                         {{ render_field(form.processor) }}

changedetectionio/content_fetchers/playwright.py

@@ -49,9 +49,6 @@ async def capture_full_page_async(page, screenshot_format='JPEG', watch_uuid=Non
     if page_height > page.viewport_size['height']:
         if page_height < step_size:
             step_size = page_height # Incase page is bigger than default viewport but smaller than proposed step size
-        # Never set viewport taller than our max capture height - otherwise one screenshot chunk
-        # captures the whole (e.g. 8098px) page even when SCREENSHOT_MAX_HEIGHT=1000
-        step_size = min(step_size, SCREENSHOT_MAX_TOTAL_HEIGHT)
         viewport_start = time.time()
         logger.debug(f"{watch_info}Setting bigger viewport to step through large page width W{page.viewport_size['width']}xH{step_size} because page_height > viewport_size")
         # Set viewport to a larger size to capture more content at once

changedetectionio/content_fetchers/puppeteer.py

@@ -75,9 +75,6 @@ async def capture_full_page(page, screenshot_format='JPEG', watch_uuid=None, loc
     if page_height > page.viewport['height']:
         if page_height < step_size:
             step_size = page_height # Incase page is bigger than default viewport but smaller than proposed step size
-        # Never set viewport taller than our max capture height - otherwise one screenshot chunk
-        # captures the whole page even when SCREENSHOT_MAX_HEIGHT is set smaller
-        step_size = min(step_size, SCREENSHOT_MAX_TOTAL_HEIGHT)
         viewport_start = time.time()
         await page.setViewport({'width': page.viewport['width'], 'height': step_size})
         viewport_time = time.time() - viewport_start

changedetectionio/content_fetchers/screenshot_handler.py

@@ -56,10 +56,6 @@ def stitch_images_worker_raw_bytes(pipe_conn, original_page_height, capture_heig
             im.close()
         del images
 
-        # Clip stitched image to capture_height (chunks may overshoot by up to step_size-1 px)
-        if total_height > capture_height:
-            stitched = stitched.crop((0, 0, max_width, capture_height))
-
         # Draw caption only if page was trimmed
         if original_page_height > capture_height:
             draw = ImageDraw.Draw(stitched)

changedetectionio/diff/__init__.py

@@ -76,7 +76,7 @@ def extract_changed_to(raw_diff: str) -> str:
     return '\n'.join(m.group(1) or m.group(2) for m in _EXTRACT_ADDED_RE.finditer(raw_diff))
 
 
-def render_inline_word_diff(before_line: str, after_line: str, ignore_junk: bool = False, markdown_style: str = None, tokenizer: str = 'words_and_html', include_change_type_prefix: bool = True) -> tuple[str, bool]:
+def render_inline_word_diff(before_line: str, after_line: str, ignore_junk: bool = False, markdown_style: str = None, tokenizer: str = 'words_and_html') -> tuple[str, bool]:
     """
     Render word-level differences between two lines inline using diff-match-patch library.
 
@@ -163,20 +163,14 @@ def render_inline_word_diff(before_line: str, after_line: str, ignore_junk: bool
         if removed_tokens:
             removed_full = ''.join(removed_tokens).rstrip()
             trailing_removed = ''.join(removed_tokens)[len(removed_full):] if len(''.join(removed_tokens)) > len(removed_full) else ''
-            if include_change_type_prefix:
-                result_parts.append(f'{CHANGED_PLACEMARKER_OPEN}{removed_full}{CHANGED_PLACEMARKER_CLOSED}{trailing_removed}')
-            else:
-                result_parts.append(f'{removed_full}{trailing_removed}')
+            result_parts.append(f'{CHANGED_PLACEMARKER_OPEN}{removed_full}{CHANGED_PLACEMARKER_CLOSED}{trailing_removed}')
 
         if added_tokens:
             if result_parts:  # Add newline between removed and added
                 result_parts.append('\n')
             added_full = ''.join(added_tokens).rstrip()
             trailing_added = ''.join(added_tokens)[len(added_full):] if len(''.join(added_tokens)) > len(added_full) else ''
-            if include_change_type_prefix:
-                result_parts.append(f'{CHANGED_INTO_PLACEMARKER_OPEN}{added_full}{CHANGED_INTO_PLACEMARKER_CLOSED}{trailing_added}')
-            else:
-                result_parts.append(f'{added_full}{trailing_added}')
+            result_parts.append(f'{CHANGED_INTO_PLACEMARKER_OPEN}{added_full}{CHANGED_INTO_PLACEMARKER_CLOSED}{trailing_added}')
 
         return ''.join(result_parts), has_changes
     else:
@@ -186,27 +180,21 @@ def render_inline_word_diff(before_line: str, after_line: str, ignore_junk: bool
             if op == 0:  # Equal
                 result_parts.append(text)
             elif op == 1:  # Insertion
-                if not include_change_type_prefix:
-                    result_parts.append(text)
+                # Don't wrap empty content (e.g., whitespace-only tokens after rstrip)
+                content = text.rstrip()
+                trailing = text[len(content):] if len(text) > len(content) else ''
+                if content:
+                    result_parts.append(f'{ADDED_PLACEMARKER_OPEN}{content}{ADDED_PLACEMARKER_CLOSED}{trailing}')
                 else:
-                    # Don't wrap empty content (e.g., whitespace-only tokens after rstrip)
-                    content = text.rstrip()
-                    trailing = text[len(content):] if len(text) > len(content) else ''
-                    if content:
-                        result_parts.append(f'{ADDED_PLACEMARKER_OPEN}{content}{ADDED_PLACEMARKER_CLOSED}{trailing}')
-                    else:
-                        result_parts.append(trailing)
+                    result_parts.append(trailing)
             elif op == -1:  # Deletion
-                if not include_change_type_prefix:
-                    result_parts.append(text)
+                # Don't wrap empty content (e.g., whitespace-only tokens after rstrip)
+                content = text.rstrip()
+                trailing = text[len(content):] if len(text) > len(content) else ''
+                if content:
+                    result_parts.append(f'{REMOVED_PLACEMARKER_OPEN}{content}{REMOVED_PLACEMARKER_CLOSED}{trailing}')
                 else:
-                    # Don't wrap empty content (e.g., whitespace-only tokens after rstrip)
-                    content = text.rstrip()
-                    trailing = text[len(content):] if len(text) > len(content) else ''
-                    if content:
-                        result_parts.append(f'{REMOVED_PLACEMARKER_OPEN}{content}{REMOVED_PLACEMARKER_CLOSED}{trailing}')
-                    else:
-                        result_parts.append(trailing)
+                    result_parts.append(trailing)
 
         return ''.join(result_parts), has_changes
 
@@ -402,7 +390,7 @@ def customSequenceMatcher(
 
             # Use inline word-level diff for single line replacements when word_diff is enabled
             if word_diff and len(before_lines) == 1 and len(after_lines) == 1:
-                inline_diff, has_changes = render_inline_word_diff(before_lines[0], after_lines[0], ignore_junk=ignore_junk, tokenizer=tokenizer, include_change_type_prefix=include_change_type_prefix)
+                inline_diff, has_changes = render_inline_word_diff(before_lines[0], after_lines[0], ignore_junk=ignore_junk, tokenizer=tokenizer)
                 # Check if there are any actual changes (not just whitespace when ignore_junk is enabled)
                 if ignore_junk and not has_changes:
                     # No real changes, skip this line

changedetectionio/languages.py

@@ -28,20 +28,19 @@ def get_timeago_locale(flask_locale):
         str: timeago library locale code (e.g., 'en', 'zh_CN', 'pt_PT')
     """
     locale_map = {
-        'zh': 'zh_CN',          # Chinese Simplified
+        'zh': 'zh_CN',      # Chinese Simplified
         # timeago library just hasn't been updated to use the more modern locale naming convention, before BCP 47 / RFC 5646.
-        'zh_TW': 'zh_TW',       # Chinese Traditional (timeago uses zh_TW)
+        'zh_TW': 'zh_TW',   # Chinese Traditional (timeago uses zh_TW)
         'zh_Hant_TW': 'zh_TW',  # Flask-Babel normalizes zh_TW to zh_Hant_TW, map back to timeago's zh_TW
-        'pt': 'pt_PT',          # Portuguese (Portugal)
-        'pt_BR': 'pt_BR',       # Portuguese (Brasil)
-        'sv': 'sv_SE',          # Swedish
-        'no': 'nb_NO',          # Norwegian Bokmål
-        'hi': 'in_HI',          # Hindi
-        'cs': 'en',             # Czech not supported by timeago, fallback to English
-        'ja': 'ja',             # Japanese
-        'uk': 'uk',             # Ukrainian
-        'en_GB': 'en',          # British English - timeago uses 'en'
-        'en_US': 'en',          # American English - timeago uses 'en'
+        'pt': 'pt_PT',      # Portuguese (Portugal)
+        'sv': 'sv_SE',      # Swedish
+        'no': 'nb_NO',      # Norwegian Bokmål
+        'hi': 'in_HI',      # Hindi
+        'cs': 'en',         # Czech not supported by timeago, fallback to English
+        'ja': 'ja',         # Japanese
+        'uk': 'uk',         # Ukrainian
+        'en_GB': 'en',      # British English - timeago uses 'en'
+        'en_US': 'en',      # American English - timeago uses 'en'
     }
     return locale_map.get(flask_locale, flask_locale)
 
@@ -55,8 +54,7 @@ LANGUAGE_DATA = {
     'ko': {'flag': 'fi fi-kr fis', 'name': '한국어'},
     'cs': {'flag': 'fi fi-cz fis', 'name': 'Čeština'},
     'es': {'flag': 'fi fi-es fis', 'name': 'Español'},
-    'pt': {'flag': 'fi fi-pt fis', 'name': 'Português (Portugal)'},
-    'pt_BR': {'flag': 'fi fi-br fis', 'name': 'Português (Brasil)'},
+    'pt': {'flag': 'fi fi-pt fis', 'name': 'Português'},
     'it': {'flag': 'fi fi-it fis', 'name': 'Italiano'},
     'ja': {'flag': 'fi fi-jp fis', 'name': '日本語'},
     'zh': {'flag': 'fi fi-cn fis', 'name': '中文 (简体)'},

changedetectionio/model/Tag.py

@@ -46,26 +46,11 @@ class model(EntityPersistenceMixin, watch_base):
         super(model, self).__init__(*arg, **kw)
 
         self['overrides_watch'] = kw.get('default', {}).get('overrides_watch')
-        self['url_match_pattern'] = kw.get('default', {}).get('url_match_pattern', '')
 
         if kw.get('default'):
             self.update(kw['default'])
             del kw['default']
 
-    def matches_url(self, url: str) -> bool:
-        """Return True if this tag should be auto-applied to the given watch URL.
-
-        Wildcard patterns (*,?,[ ) use fnmatch; anything else is a case-insensitive
-        substring match. Returns False if no pattern is configured.
-        """
-        import fnmatch
-        pattern = self.get('url_match_pattern', '').strip()
-        if not pattern or not url:
-            return False
-        if any(c in pattern for c in ('*', '?', '[')):
-            return fnmatch.fnmatch(url.lower(), pattern.lower())
-        return pattern.lower() in url.lower()
-
     # _save_to_disk() method provided by EntityPersistenceMixin
     # commit() and _get_commit_data() methods inherited from watch_base
     # Tag uses default _get_commit_data() (includes all keys)

changedetectionio/store/__init__.py

@@ -980,20 +980,12 @@ class ChangeDetectionStore(DatastoreUpdatesMixin, FileSavingDataStore):
     def get_all_tags_for_watch(self, uuid):
         """This should be in Watch model but Watch doesn't have access to datastore, not sure how to solve that yet"""
         watch = self.data['watching'].get(uuid)
-        if not watch:
-            return {}
 
-        # Start with manually assigned tags
-        result = dictfilt(self.__data['settings']['application']['tags'], watch.get('tags', []))
+        # Should return a dict of full tag info linked by UUID
+        if watch:
+            return dictfilt(self.__data['settings']['application']['tags'], watch.get('tags', []))
 
-        # Additionally include any tag whose url_match_pattern matches this watch's URL
-        watch_url = watch.get('url', '')
-        if watch_url:
-            for tag_uuid, tag in self.__data['settings']['application']['tags'].items():
-                if tag_uuid not in result and tag.matches_url(watch_url):
-                    result[tag_uuid] = tag
-
-        return result
+        return {}
 
     @property
     def extra_browsers(self):

changedetectionio/templates/_common_fields.html

@@ -100,11 +100,11 @@
             </tr>
             <tr>
                 <td><code>{{ '{{diff_changed_from}}' }}</code></td>
-                <td>{{ _('Only the changed words/values from the previous version — e.g. the old price. Best when a single value changes per line; multiple changed fragments are joined by newline.') }}</td>
+                <td>{{ _('Only the changed fragments from the previous version — e.g. the old price. Multiple changes joined by newline.') }}</td>
             </tr>
             <tr>
                 <td><code>{{ '{{diff_changed_to}}' }}</code></td>
-                <td>{{ _('Only the changed words/values from the new version — e.g. the new price. Best when a single value changes per line; multiple changed fragments are joined by newline.') }}</td>
+                <td>{{ _('Only the changed fragments from the new version — e.g. the new price. Multiple changes joined by newline.') }}</td>
             </tr>
             <tr>
                 <td><code>{{ '{{current_snapshot}}' }}</code></td>

changedetectionio/tests/test_tag_url_match.py

@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-"""
-Integration tests for auto-applying tags to watches by URL pattern matching.
-
-Verifies:
- - A tag with url_match_pattern shows on the watch overview list (via get_all_tags_for_watch)
- - The auto-applied tag appears on the watch edit page
- - A watch whose URL does NOT match the pattern does not get the tag
-"""
-
-import json
-from flask import url_for
-from .util import set_original_response, live_server_setup
-
-
-def test_tag_url_pattern_shows_in_overview(client, live_server, measure_memory_usage, datastore_path):
-    """Tag with a matching url_match_pattern must appear in the watch overview row."""
-    set_original_response(datastore_path=datastore_path)
-
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # Create a tag with a URL match pattern
-    res = client.post(
-        url_for("tag"),
-        data=json.dumps({"title": "Auto GitHub", "url_match_pattern": "*github.com*"}),
-        headers={'content-type': 'application/json', 'x-api-key': api_key},
-    )
-    assert res.status_code == 201, res.data
-    tag_uuid = res.json['uuid']
-
-    # Add a watch that matches the pattern
-    res = client.post(
-        url_for("createwatch"),
-        data=json.dumps({"url": "https://github.com/someuser/repo"}),
-        headers={'content-type': 'application/json', 'x-api-key': api_key},
-    )
-    assert res.status_code == 201, res.data
-    matching_watch_uuid = res.json['uuid']
-
-    # Add a watch that does NOT match
-    res = client.post(
-        url_for("createwatch"),
-        data=json.dumps({"url": "https://example.com/page"}),
-        headers={'content-type': 'application/json', 'x-api-key': api_key},
-    )
-    assert res.status_code == 201, res.data
-    non_matching_watch_uuid = res.json['uuid']
-
-    # Watch overview — the tag label must appear in the matching watch's row
-    res = client.get(url_for("watchlist.index"))
-    assert res.status_code == 200
-    html = res.get_data(as_text=True)
-
-    # The tag title should appear somewhere on the page (it's rendered per-watch via get_all_tags_for_watch)
-    assert "Auto GitHub" in html, "Auto-matched tag title must appear in watch overview"
-
-    # Verify via the datastore directly that get_all_tags_for_watch returns the pattern-matched tag
-    datastore = live_server.app.config['DATASTORE']
-
-    matching_tags = datastore.get_all_tags_for_watch(matching_watch_uuid)
-    assert tag_uuid in matching_tags, "Pattern-matched tag must be returned for matching watch"
-
-    non_matching_tags = datastore.get_all_tags_for_watch(non_matching_watch_uuid)
-    assert tag_uuid not in non_matching_tags, "Pattern-matched tag must NOT appear for non-matching watch"
-
-
-def test_auto_applied_tag_shows_on_watch_edit(client, live_server, measure_memory_usage, datastore_path):
-    """The watch edit page must show auto-applied tags (from URL pattern) separately."""
-    set_original_response(datastore_path=datastore_path)
-
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    res = client.post(
-        url_for("tag"),
-        data=json.dumps({"title": "Auto Docs", "url_match_pattern": "*docs.example.com*"}),
-        headers={'content-type': 'application/json', 'x-api-key': api_key},
-    )
-    assert res.status_code == 201, res.data
-
-    res = client.post(
-        url_for("createwatch"),
-        data=json.dumps({"url": "https://docs.example.com/guide"}),
-        headers={'content-type': 'application/json', 'x-api-key': api_key},
-    )
-    assert res.status_code == 201, res.data
-    watch_uuid = res.json['uuid']
-
-    # Watch edit page must mention the auto-applied tag
-    res = client.get(url_for("ui.ui_edit.edit_page", uuid=watch_uuid))
-    assert res.status_code == 200
-    html = res.get_data(as_text=True)
-
-    assert "Auto Docs" in html, "Auto-applied tag name must appear on watch edit page"
-    assert "automatically applied" in html.lower() or "auto" in html.lower(), \
-        "Watch edit page must indicate the tag is auto-applied by pattern"
-
-
-def test_multiple_pattern_tags_all_applied(client, live_server, measure_memory_usage, datastore_path):
-    """A watch matching multiple tag patterns must receive all of them, not just the first."""
-    set_original_response(datastore_path=datastore_path)
-
-    api_key = live_server.app.config['DATASTORE'].data['settings']['application'].get('api_access_token')
-
-    # Two tags with different patterns that both match the same URL
-    res = client.post(
-        url_for("tag"),
-        data=json.dumps({"title": "Org Docs", "url_match_pattern": "*docs.*"}),
-        headers={'content-type': 'application/json', 'x-api-key': api_key},
-    )
-    assert res.status_code == 201, res.data
-    tag_docs_uuid = res.json['uuid']
-
-    res = client.post(
-        url_for("tag"),
-        data=json.dumps({"title": "Org Python", "url_match_pattern": "*python*"}),
-        headers={'content-type': 'application/json', 'x-api-key': api_key},
-    )
-    assert res.status_code == 201, res.data
-    tag_python_uuid = res.json['uuid']
-
-    # A third tag whose pattern does NOT match
-    res = client.post(
-        url_for("tag"),
-        data=json.dumps({"title": "Org Rust", "url_match_pattern": "*rust-lang*"}),
-        headers={'content-type': 'application/json', 'x-api-key': api_key},
-    )
-    assert res.status_code == 201, res.data
-    tag_rust_uuid = res.json['uuid']
-
-    # Watch URL matches both "docs" and "python" patterns but not "rust"
-    res = client.post(
-        url_for("createwatch"),
-        data=json.dumps({"url": "https://docs.python.org/3/library/fnmatch.html"}),
-        headers={'content-type': 'application/json', 'x-api-key': api_key},
-    )
-    assert res.status_code == 201, res.data
-    watch_uuid = res.json['uuid']
-
-    datastore = live_server.app.config['DATASTORE']
-    resolved = datastore.get_all_tags_for_watch(watch_uuid)
-
-    assert tag_docs_uuid in resolved, "First matching tag must be included"
-    assert tag_python_uuid in resolved, "Second matching tag must be included"
-    assert tag_rust_uuid not in resolved, "Non-matching tag must NOT be included"

changedetectionio/tests/unit/test_notification_diff.py

@@ -440,18 +440,6 @@ Line 3 with tabs and spaces"""
         self.assertEqual(extract_changed_from(raw), "$99")
         self.assertEqual(extract_changed_to(raw),   "$109")
 
-    def test_diff_changed_from_to_multiple_words_same_line(self):
-        """When multiple words change on the same line all fragments are joined with newline.
-        'quick brown fox jumps' -> 'slow brown fox hops' gives 'quick\njumps' / 'slow\nhops'.
-        These tokens work best when a single value changes per line."""
-        before = "quick brown fox jumps"
-        after  = "slow brown fox hops"
-
-        raw = diff.render_diff(before, after, word_diff=True)
-
-        self.assertEqual(extract_changed_from(raw), "quick\njumps")
-        self.assertEqual(extract_changed_to(raw),   "slow\nhops")
-
     def test_diff_changed_from_to_no_change(self):
         """No changes → empty string"""
         content = "nothing changed here"
@@ -462,61 +450,5 @@ Line 3 with tabs and spaces"""
         self.assertEqual(extract_changed_to(raw),   "")
 
 
-    def test_word_diff_no_prefix_whole_line_replaced(self):
-        """When include_change_type_prefix=False, word-level diffs for whole-line
-        replacements must not include placemarkers (issue #3816)."""
-        before = "73"
-        after = "100"
-
-        raw = diff.render_diff(before, after, word_diff=True, include_change_type_prefix=False)
-
-        self.assertNotIn('PLACEMARKER', raw)
-        # Should contain just the raw values separated by newline
-        self.assertIn('73', raw)
-        self.assertIn('100', raw)
-
-    def test_word_diff_no_prefix_inline_changes(self):
-        """When include_change_type_prefix=False, inline word-level diffs
-        must not include placemarkers (issue #3816)."""
-        before = "the price is 50 dollars"
-        after = "the price is 75 dollars"
-
-        raw = diff.render_diff(before, after, word_diff=True, include_change_type_prefix=False)
-
-        self.assertNotIn('PLACEMARKER', raw)
-        self.assertIn('50', raw)
-        self.assertIn('75', raw)
-
-    def test_word_diff_with_prefix_still_wraps(self):
-        """Default include_change_type_prefix=True must still wrap tokens."""
-        before = "73"
-        after = "100"
-
-        raw = diff.render_diff(before, after, word_diff=True, include_change_type_prefix=True)
-
-        self.assertIn('PLACEMARKER', raw)
-
-    def test_word_diff_no_prefix_exact_output(self):
-        """Pin exact output for include_change_type_prefix=False to catch regressions.
-
-        Whole-line replacement: old and new values separated by newline, no markers.
-        Inline partial replacement: equal tokens kept, changed tokens (both old and new)
-        appended without markers — this means old+new are concatenated in place.
-        """
-        # Whole-line replaced: both values on separate lines, clean
-        raw = diff.render_diff('73', '100', word_diff=True, include_change_type_prefix=False)
-        self.assertEqual(raw, '73\n100')
-
-        # Inline word replacement: equal context preserved, old+new token concatenated in-place
-        raw = diff.render_diff('the price is 50 dollars', 'the price is 75 dollars',
-                               word_diff=True, include_change_type_prefix=False)
-        self.assertEqual(raw, 'the price is 5075 dollars')
-
-        # Sanity: with prefix the whole-line case is fully wrapped
-        raw = diff.render_diff('73', '100', word_diff=True, include_change_type_prefix=True)
-        self.assertEqual(raw, '@changed_PLACEMARKER_OPEN73@changed_PLACEMARKER_CLOSED\n'
-                               '@changed_into_PLACEMARKER_OPEN100@changed_into_PLACEMARKER_CLOSED')
-
-
 if __name__ == '__main__':
     unittest.main()

changedetectionio/tests/unit/test_tag_url_match.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-
-# run from dir above changedetectionio/ dir
-# python3 -m unittest changedetectionio.tests.unit.test_tag_url_match
-
-import unittest
-from changedetectionio.model.Tag import model as TagModel
-
-
-def make_tag(pattern):
-    """Minimal Tag instance for testing matches_url — skips datastore wiring."""
-    tag = TagModel.__new__(TagModel)
-    dict.__init__(tag)
-    tag['url_match_pattern'] = pattern
-    return tag
-
-
-class TestTagUrlMatch(unittest.TestCase):
-
-    def test_wildcard_matches(self):
-        tag = make_tag('*example.com*')
-        self.assertTrue(tag.matches_url('https://example.com/page'))
-        self.assertTrue(tag.matches_url('https://www.example.com/shop/item'))
-        self.assertFalse(tag.matches_url('https://other.com/page'))
-
-    def test_wildcard_case_insensitive(self):
-        tag = make_tag('*EXAMPLE.COM*')
-        self.assertTrue(tag.matches_url('https://example.com/page'))
-
-    def test_substring_match(self):
-        tag = make_tag('github.com/myorg')
-        self.assertTrue(tag.matches_url('https://github.com/myorg/repo'))
-        self.assertFalse(tag.matches_url('https://github.com/otherorg/repo'))
-
-    def test_substring_case_insensitive(self):
-        tag = make_tag('GitHub.com/MyOrg')
-        self.assertTrue(tag.matches_url('https://github.com/myorg/repo'))
-
-    def test_empty_pattern_never_matches(self):
-        tag = make_tag('')
-        self.assertFalse(tag.matches_url('https://example.com'))
-
-    def test_empty_url_never_matches(self):
-        tag = make_tag('*example.com*')
-        self.assertFalse(tag.matches_url(''))
-
-    def test_question_mark_wildcard(self):
-        tag = make_tag('https://example.com/item-?')
-        self.assertTrue(tag.matches_url('https://example.com/item-1'))
-        self.assertFalse(tag.matches_url('https://example.com/item-12'))
-
-    def test_substring_is_broad(self):
-        """Plain substring matching is intentionally broad — 'evil.com' matches anywhere
-        in the URL string, including 'notevil.com'. Users who need precise domain matching
-        should use a wildcard pattern like '*://evil.com/*' instead."""
-        tag = make_tag('evil.com')
-        self.assertTrue(tag.matches_url('https://evil.com/page'))
-        self.assertTrue(tag.matches_url('https://notevil.com'))  # substring match — expected
-
-    def test_precise_domain_match_with_wildcard(self):
-        """Use wildcard pattern for precise domain matching to avoid substring surprises."""
-        tag = make_tag('*://evil.com/*')
-        self.assertTrue(tag.matches_url('https://evil.com/page'))
-        self.assertFalse(tag.matches_url('https://notevil.com/page'))
-
-
-if __name__ == '__main__':
-    unittest.main()

changedetectionio/translations/README.md

@@ -78,7 +78,6 @@ These commands read settings from `../../setup.cfg` automatically.
 - `it` - Italian (Italiano)
 - `ja` - Japanese (日本語)
 - `ko` - Korean (한국어)
-- `pt_BR` - Portuguese (Brasil)
 - `zh` - Chinese Simplified (中文简体)
 - `zh_Hant_TW` - Chinese Traditional (繁體中文)
 

docs/api-spec.yaml

@@ -725,13 +725,6 @@ components:
                 - true: Tag settings override watch settings
                 - false: Tag settings do not override (watches use their own settings)
                 - null: Not decided yet / inherit default behavior
-            url_match_pattern:
-              type: string
-              description: |
-                Automatically apply this tag to any watch whose URL matches this pattern.
-                Supports fnmatch wildcards (* and ?): e.g. *://example.com/* or github.com/myorg.
-                Plain strings are matched as case-insensitive substrings.
-                Leave empty to disable auto-matching.
             # Future: Aggregated statistics from all watches with this tag
             # check_count:
             #   type: integer