webchanges 3.23.0__tar.gz → 3.24.1__tar.gz

{webchanges-3.23.0/webchanges.egg-info → webchanges-3.24.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webchanges
-Version: 3.23.0
+Version: 3.24.1
 Summary: Check web (or command output) for changes since last run and notify. Anonymously alerts you of web changes, with
 Author-email: Mike Borsetti <mike+webchanges@borsetti.com>
 Maintainer-email: Mike Borsetti <mike+webchanges@borsetti.com>

{webchanges-3.23.0 → webchanges-3.24.1}/webchanges/__init__.py

@@ -22,7 +22,7 @@ __project_name__ = __package__
 # * MINOR version when you add functionality in a backwards compatible manner, and
 # * MICRO or PATCH version when you make backwards compatible bug fixes. We no longer use '0'
 # If unsure on increments, use pkg_resources.parse_version to parse
-__version__ = '3.23.0'
+__version__ = '3.24.1'
 __description__ = (
     'Check web (or command output) for changes since last run and notify.\n'
     '\n'

{webchanges-3.23.0 → webchanges-3.24.1}/webchanges/config.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 import argparse
+import os
 import textwrap
 
 # import os
@@ -53,7 +54,7 @@ class CommandConfig(BaseConfig):
     max_snapshots: int
     max_workers: Optional[int]
     no_headless: bool
-    rollback_database: Optional[int]
+    rollback_database: Optional[str]
     smtp_login: bool
     telegram_chats: bool
     test_differ: Optional[list[str]]
@@ -84,6 +85,17 @@ class CommandConfig(BaseConfig):
         self.jobs_files = [jobs_def_file]
         self.parse_args(args)
 
+    class CustomHelpFormatter(argparse.RawDescriptionHelpFormatter):
+        def __init__(self, prog: str) -> None:
+            """Initialize the help formatter.
+
+            :param prog: The program name.
+            """
+            if os.getenv('WEBCHANGES_BUILD_CLI_HELP.RST'):  # called by pre-commit
+                super().__init__(prog, width=104)
+            else:
+                super().__init__(prog)
+
     def parse_args(self, cmdline_args: list[str]) -> argparse.ArgumentParser:
         """Set up the Python arguments parser and stores the arguments in the class's variables.
 
@@ -97,7 +109,7 @@ class CommandConfig(BaseConfig):
             prog=__project_name__,
             description=description,
             epilog=f'Full documentation is at {__docs_url__}\n',
-            formatter_class=argparse.RawDescriptionHelpFormatter,
+            formatter_class=self.CustomHelpFormatter,
         )
         parser.add_argument(
             'joblist',
@@ -270,7 +282,7 @@ class CommandConfig(BaseConfig):
         group.add_argument(
             '--rollback-database',
             '--rollback-cache',
-            type=int,
+            type=str,
             help='delete changed snapshots added since TIMESTAMP (backup the database before using!)',
             metavar='TIMESTAMP',
         )

{webchanges-3.23.0 → webchanges-3.24.1}/webchanges/differs.py

@@ -565,7 +565,6 @@ class CommandDiffer(DifferBase):
                     f'Using differ "{directives}"',
                     f'--- @ {self.make_timestamp(self.state.old_timestamp, tz)}',
                     f'+++ @ {self.make_timestamp(self.state.new_timestamp, tz)}',
-                    '—' * 37,
                 ]
             )
             diff = proc.stdout
@@ -579,7 +578,7 @@ class CommandDiffer(DifferBase):
                     if any(x in line for x in {'{+', '+}', '[-', '-]'}):
                         keeplines.append(line)
                 diff = ''.join(keeplines)
-            diff = head + diff
+            diff = f'{head}\n{diff}'
             out_diff.update(
                 {
                     'text': diff,
@@ -812,15 +811,12 @@ class DeepdiffDiffer(DifferBase):
             return {'text': '', 'markdown': '', 'html': ''}
 
         self.job.set_to_monospace()
-
         if report_kind == 'html':
             html_diff = (
                 f'<span style="font-family:monospace;white-space:pre-wrap;">\n'
                 f'Differ: {self.__kind__} for {data_type}\n'
                 f'<span style="color:darkred;">--- @ {self.make_timestamp(self.state.old_timestamp, tz)}</span>\n'
                 f'<span style="color:darkgreen;">+++ @ {self.make_timestamp(self.state.new_timestamp, tz)}</span>\n'
-                + '—' * 37
-                + '\n'
                 + diff_text[:-1]
                 + '</span>'
             )
@@ -829,7 +825,8 @@ class DeepdiffDiffer(DifferBase):
             text_diff = (
                 f'Differ: {self.__kind__} for {data_type}\n'
                 f'--- @ {self.make_timestamp(self.state.old_timestamp, tz)}\n'
-                f'+++ @ {self.make_timestamp(self.state.new_timestamp, tz)}\n' + '—' * 37 + '\n' + diff_text
+                f'+++ @ {self.make_timestamp(self.state.new_timestamp, tz)}\n'
+                f'{diff_text}'
             )
             return {'text': text_diff, 'markdown': text_diff}
 
@@ -1008,13 +1005,11 @@ class ImageDiffer(DifferBase):
         encoded_new = b64encode(output_stream.getvalue()).decode()
 
         # Prepare HTML output
-        new_timestamp = self.make_timestamp(self.state.new_timestamp, tz)
-        old_timestamp = self.make_timestamp(self.state.old_timestamp, tz)
         htm = [
             f'<span style="font-family:monospace">Differ: {self.__kind__} for {data_type}',
-            f'<span style="color:darkred;">--- @ {old_timestamp}{old_data}</span>',
-            f'<span style="color:darkgreen;">+++ @ {new_timestamp}{new_data}' f'</span>',
-            ('—' * 37 + '</span>'),
+            f'<span style="color:darkred;">--- @ {self.make_timestamp(self.state.old_timestamp, tz)}{old_data}</span>',
+            f'<span style="color:darkgreen;">+++ @ {self.make_timestamp(self.state.new_timestamp, tz)}{new_data}'
+            f'</span>',
             'New image:',
             f'<img src="data:image/{new_image.format.lower()};base64,{encoded_new}">',
             'Differences from old (in yellow):',
@@ -1040,8 +1035,11 @@ class AIGoogleDiffer(DifferBase):
     __kind__ = 'ai_google'
 
     __supported_directives__ = {
-        'model': 'model name from https://ai.google.dev/gemini-api/docs/models/gemini (default: gemini-1.5-flash)',
+        'model': (
+            'model name from https://ai.google.dev/gemini-api/docs/models/gemini (default: gemini-1.5-flash-latest)'
+        ),
         'prompt': 'a custom prompt - {unified_diff}, {old_data} and {new_data} will be replaced; ask for markdown',
+        'system_instructions': 'Optional tone and style instructions for the model (default: Respond in Markdown)',
         'prompt_ud_context_lines': 'the number of context lines for {unified_diff} (default: 9999)',
         'timeout': 'the number of seconds before timing out the API call (default: 300)',
         'max_output_tokens': "the maximum number of tokens returned by the model (default: None, i.e. model's default)",
@@ -1069,7 +1067,7 @@ class AIGoogleDiffer(DifferBase):
             RuntimeWarning,
         )
 
-        def get_ai_summary(prompt: str) -> str:
+        def get_ai_summary(prompt: str, system_instructions: str) -> str:
             """Generate AI summary from unified diff, or an error message"""
             GOOGLE_AI_API_KEY = os.environ.get('GOOGLE_AI_API_KEY', '').rstrip()
             if len(GOOGLE_AI_API_KEY) != 39:
@@ -1083,15 +1081,14 @@ class AIGoogleDiffer(DifferBase):
                     f'{len(GOOGLE_AI_API_KEY)}.\n'
                 )
 
-            api_version = '1beta'
             _models_token_limits = {  # from https://ai.google.dev/gemini-api/docs/models/gemini
+                'gemini-1.5-pro-2m': 2097152,
                 'gemini-1.5': 1048576,
-                '  gemini-1.0': 30720,
+                'gemini-1.0': 30720,
                 'gemini-pro': 30720,  # legacy
             }
-
             if 'model' not in directives:
-                directives['model'] = 'gemini-1.5-flash'  # also for footer
+                directives['model'] = 'gemini-1.5-flash-latest'  # also for footer
             model = directives['model']
             token_limit = directives.get('token_limit')
             if not token_limit:
@@ -1126,14 +1123,15 @@ class AIGoogleDiffer(DifferBase):
             else:
                 unified_diff = ''
 
-            def _send_to_model(model_prompt: str) -> str:
+            def _send_to_model(model_prompt: str, system_instructions: str) -> str:
                 """Creates the summary request to the model"""
+                api_version = '1beta'
                 max_output_tokens = directives.get('max_output_tokens')
                 temperature = directives.get('temperature', 0.0)
                 top_p = directives.get('top_p')
                 top_k = directives.get('top_k')
                 data = {
-                    'system_instruction': {'parts': [{'text': 'Respond in Markdown'}]},
+                    'system_instruction': {'parts': [{'text': system_instructions}]},
                     'contents': [{'parts': [{'text': model_prompt}]}],
                     'generation_config': {
                         'max_output_tokens': max_output_tokens,
@@ -1180,12 +1178,16 @@ class AIGoogleDiffer(DifferBase):
 
                 return summary
 
+            # check if data is different (for testing)
+            if '{old_data}' in prompt and '{new_data}' in prompt and self.state.old_data == self.state.new_data:
+                return ''
+
             model_prompt = prompt.format(
                 unified_diff=unified_diff, old_data=self.state.old_data, new_data=self.state.new_data
             )
 
             if len(model_prompt) / 4 < token_limit:
-                summary = _send_to_model(model_prompt)
+                summary = _send_to_model(model_prompt, system_instructions)
             elif '{unified_diff}' in prompt:
                 logger.info(
                     f'Job {self.job.index_number}: Model prompt with full diff is too long: '
@@ -1206,7 +1208,7 @@ class AIGoogleDiffer(DifferBase):
                     unified_diff=unified_diff, old_data=self.state.old_data, new_data=self.state.new_data
                 )
                 if len(model_prompt) / 4 < token_limit:
-                    summary = _send_to_model(model_prompt)
+                    summary = _send_to_model(model_prompt, system_instructions)
                 else:
                     summary = (
                         f'AI summary unavailable (model prompt with unified diff is too long: '
@@ -1217,18 +1219,25 @@ class AIGoogleDiffer(DifferBase):
                     f'The model prompt may be too long: {len(model_prompt) / 4:,.0f} est. tokens exceeds '
                     f'limit of {token_limit:,.0f} tokens'
                 )
-                summary = _send_to_model(model_prompt)
+                summary = _send_to_model(model_prompt, system_instructions)
             return summary
 
         prompt = directives.get(
             'prompt',
-            'Analyze this unified diff and create a summary listing only the changes:\n\n{unified_diff}',
-        )
-        summary = get_ai_summary(prompt)
+            'Identify the changes between the old document (enclosed by an <old> tag) and the new document ('
+            'enclosed by a <new> tag) and output a summary of such changes:\n\n<old>\n{old_data}\n</old>\n\n<new>\n'
+            '{new_data}\n</new>',
+        ).replace('\\n', '\n')
+        system_instructions = directives.get('system_instructions', 'Respond in Markdown')
+        summary = get_ai_summary(prompt, system_instructions)
         if not summary:
             self.state.verb = 'changed,no_report'
             return {'text': '', 'markdown': '', 'html': ''}
-        directives_text = ', '.join(f'{key}={value}' for key, value in directives.items()) or 'None'
+        newline = '\n'  # For Python < 3.12 f-string compatibility
+        back_n = '\\n'  # For Python < 3.12 f-string compatibility
+        directives_text = (
+            ', '.join(f'{key}={str(value).replace(newline, back_n)}' for key, value in directives.items()) or 'None'
+        )
         footer = f'Summary generated by Google Generative AI (differ directive(s): {directives_text})'
         temp_unfiltered_diff: dict[Literal['text', 'markdown', 'html'], str] = {}
         for rep_kind in ['text', 'html']:  # markdown is same as text
@@ -1301,21 +1310,19 @@ class WdiffDiffer(DifferBase):
         rem_html = '<span style="background-color:#fff0f0;color:#9c1c1c;text-decoration:line-through;">'
 
         head_text = (
-            'Differ: wdiff\n'
-            f'\033[91m--- @ {self.make_timestamp(self.state.old_timestamp, tz)}\033[0m\n'
-            f'\033[92m+++ @ {self.make_timestamp(self.state.new_timestamp, tz)}\033[0m\n' + '—' * 37 + '\n'
+            f'Differ: wdiff\n\033[91m--- @ {self.make_timestamp(self.state.old_timestamp, tz)}\033[0m\n'
+            f'\033[92m+++ @ {self.make_timestamp(self.state.new_timestamp, tz)}\033[0m\n'
         )
         head_html = '<br>\n'.join(
             [
                 '<span style="font-family:monospace;">Differ: wdiff',
                 f'<span style="color:darkred;">--- @ {self.make_timestamp(self.state.old_timestamp, tz)}</span>',
                 f'<span style="color:darkgreen;">+++ @ {self.make_timestamp(self.state.new_timestamp, tz)}</span>',
-                '—' * 37 + '</span>',
                 '',
             ]
         )
         # Process the diff output to make it more wdiff-like
-        result = []
+        result_text = []
         result_html = []
         prev_word_text = ''
         prev_word_html = ''
@@ -1323,11 +1330,8 @@ class WdiffDiffer(DifferBase):
         next_html = ''
         add = False
         rem = False
-        for word_text in diff:
-            if len(word_text) < 3:
-                continue
-            if word_text[0] == '?':
-                continue
+
+        for word_text in diff + ['  ']:
             word_html = word_text
             pre_text = [next_text] if next_text else []
             pre_html = [next_html] if next_html else []
@@ -1367,24 +1371,26 @@ class WdiffDiffer(DifferBase):
                 rem = False
             elif word_text[2:] == '<\\n>':  # New line
                 if add:
-                    word_html = f'  </span><\\n> {add_html}'
+                    word_text = '  \033[0m<\\n>'
+                    word_html = '  </span><\\n>'
+                    add = False
                 elif rem:
-                    word_html = f'  </span><\\n> {rem_html}'
+                    word_text = '  \033[0m<\\n>'
+                    word_html = '  </span><\\n>'
+                    rem = False
 
-            result.append(prev_word_text)
+            result_text.append(prev_word_text)
             result_html.append(prev_word_html)
             pre_text.append(word_text[2:])
             pre_html.append(word_html[2:])
             prev_word_text = ''.join(pre_text)
             prev_word_html = ''.join(pre_html)
-        result.append(prev_word_text)
-        result_html.append(prev_word_html)
         if add or rem:
-            result[-1] += '\033[0m'
+            result_text[-1] += '\033[0m'
             result_html[-1] += '</span>'
 
         # rebuild the text from words, replacing the newline token
-        diff_text = ' '.join(result[1:]).replace('<\\n> ', '\n').replace('<\\n>', '\n')
+        diff_text = ' '.join(result_text[1:]).replace('<\\n> ', '\n').replace('<\\n>', '\n')
         diff_html = ' '.join(result_html[1:]).replace('<\\n> ', '\n').replace('<\\n>', '\n')
 
         # build contextlines

{webchanges-3.23.0 → webchanges-3.24.1}/webchanges/filters.py

@@ -156,7 +156,7 @@ class FilterBase(metaclass=TrackSubClasses):
     @classmethod
     def normalize_filter_list(
         cls,
-        filter_spec: Union[str, list[Union[str, dict[str, Any]]]],
+        filter_spec: Union[str, list[Union[str, dict[str, Any]]], None],
         job_index_number: Optional[int] = None,
     ) -> Iterator[tuple[str, dict[str, Any]]]:
         """Generates a list of filters that has been checked for its validity.
@@ -195,7 +195,7 @@ class FilterBase(metaclass=TrackSubClasses):
     @classmethod
     def _internal_normalize_filter_list(
         cls,
-        filter_spec: Union[str, list[Union[str, dict[str, Any]]]],
+        filter_spec: Union[str, list[Union[str, dict[str, Any]]], None],
         job_index_number: Optional[int] = None,
     ) -> Iterator[tuple[str, dict[str, Any]]]:
         """Generates a list of filters with its default subfilter if not supplied.
@@ -265,7 +265,7 @@ class FilterBase(metaclass=TrackSubClasses):
             return data, mime_type
 
     @classmethod
-    def filter_chain_needs_bytes(cls, filter_name: Union[str, list[Union[str, dict[str, Any]]]]) -> bool:
+    def filter_chain_needs_bytes(cls, filter_name: Union[str, list[Union[str, dict[str, Any]]], None]) -> bool:
         """Checks whether the first filter requires data in bytes (not Unicode).
 
         :param filter_name: The filter.

{webchanges-3.23.0 → webchanges-3.24.1}/webchanges/jobs.py

@@ -132,15 +132,15 @@ class JobBase(metaclass=TrackSubClasses):
     compared_versions: Optional[int] = None
     contextlines: Optional[int] = None
     cookies: Optional[dict[str, str]] = None
-    data: Union[str, dict[str, str]] = None  # type: ignore[assignment]
+    data: Optional[Union[str, list, dict]] = None
     data_as_json: Optional[bool] = None
     deletions_only: Optional[bool] = None
     differ: Optional[dict[str, Any]] = None  # added in 3.21
-    diff_filter: Union[str, list[Union[str, dict[str, Any]]]] = None  # type: ignore[assignment]
+    diff_filter: Optional[Union[str, list[Union[str, dict[str, Any]]]]] = None
     diff_tool: Optional[str] = None  # deprecated in 3.21
     enabled: Optional[bool] = None
     encoding: Optional[str] = None
-    filter: Union[str, list[Union[str, dict[str, Any]]]] = None  # type: ignore[assignment]
+    filter: Optional[Union[str, list[Union[str, dict[str, Any]]]]] = None
     headers: Optional[Union[dict, CaseInsensitiveDict]] = None
     http_client: Optional[Literal['httpx', 'requests']] = None
     http_proxy: Optional[str] = None
@@ -958,15 +958,15 @@ class UrlJob(UrlJobBase):
                     headers['Content-Type'] = 'application/json'
                 else:
                     headers['Content-Type'] = 'application/x-www-form-urlencoded'
-            if isinstance(self.data, dict):
+            if isinstance(self.data, (dict, list)):
                 if self.data_as_json:
                     self.data = jsonlib.dumps(self.data, ensure_ascii=False)
                 else:
                     self.data = urlencode(self.data)
             elif not isinstance(self.data, str):
                 raise TypeError(
-                    f"Job {job_state.job.index_number}: Directive 'data' needs to be a string or a dictionary; found a "
-                    f'{type(self.data).__name__} ( {self.get_indexed_location()} ).'
+                    f"Job {job_state.job.index_number}: Directive 'data' needs to be a string, dictionary or list; "
+                    f'found a {type(self.data).__name__} ( {self.get_indexed_location()} ).'
                 )
 
         else:
@@ -1393,9 +1393,9 @@ class BrowserJob(UrlJobBase):
             page = context.new_page()
             # the below to bypass detection; from https://intoli.com/blog/not-possible-to-block-chrome-headless/
             page.add_init_script(
-                "Object.defineProperty(navigator, 'webdriver', {get: () => false,});"
+                "Object.defineProperty(navigator, 'webdriver', {get: () => undefined });"
                 'window.chrome = {runtime: {},};'  # This is abbreviated: entire content is huge!!
-                "Object.defineProperty(navigator, 'plugins', {get: () => [1, 2, 3, 4, 5],});"
+                "Object.defineProperty(navigator, 'plugins', {get: () => [1, 2, 3, 4, 5] });"
             )
 
             url = self.url
@@ -1444,7 +1444,7 @@ class BrowserJob(UrlJobBase):
                         headers['Content-Type'] = 'application/json'
                     else:
                         headers['Content-Type'] = 'application/x-www-form-urlencoded'
-                if isinstance(self.data, dict):
+                if isinstance(self.data, (dict, list)):
                     if self.data_as_json:
                         data = jsonlib.dumps(self.data, ensure_ascii=False)
                     else:
@@ -1453,8 +1453,8 @@ class BrowserJob(UrlJobBase):
                     data = quote(self.data)
                 else:
                     raise ValueError(
-                        f"Job {job_state.job.index_number}: Directive 'data' requires a dictionary or a string; found "
-                        f'a {type(self.data).__name__} ( {self.get_indexed_location()} ).'
+                        f"Job {job_state.job.index_number}: Directive 'data' needs to be a string, dictionary or list; "
+                        f'found a {type(self.data).__name__} ( {self.get_indexed_location()} ).'
                     )
 
             if self.method and self.method != 'GET':

{webchanges-3.23.0 → webchanges-3.24.1}/webchanges/reporters.py

@@ -369,7 +369,7 @@ class HtmlReporter(ReporterBase):
                 yield '<hr>'
 
         # HTML footer
-        yield '<div style="font-style:italic">'
+        yield '<span style="font-style:italic">'
         if self.report.config['footnote']:
             yield f"{self.report.config['footnote']}\n"
         if cfg['footer']:
@@ -389,7 +389,7 @@ class HtmlReporter(ReporterBase):
                 f'<b>New release version {self.report.new_release_future.result()} is available; we recommend '
                 f'updating.</b>'
             )
-        yield '</div>\n</body>\n</html>\n'
+        yield '</span>\n</body>\n</html>\n'
 
     @staticmethod
     def _format_content(

{webchanges-3.23.0 → webchanges-3.24.1}/webchanges/storage.py

@@ -18,7 +18,7 @@ import warnings
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from dataclasses import dataclass
-from datetime import datetime, timezone  # py311 use UTC instead of timezone.utc
+from datetime import datetime, timezone, tzinfo  # py311 use UTC instead of timezone.utc
 from pathlib import Path
 from typing import Any, Iterable, Iterator, Literal, Optional, TextIO, TypedDict, Union
 from zoneinfo import ZoneInfo
@@ -44,6 +44,11 @@ try:
 except ImportError as e:  # pragma: no cover
     redis = e.msg  # type: ignore[assignment]
 
+try:
+    from dateutil import parser as dateutil_parser  # type: ignore[import-untyped]
+except ImportError:  # pragma: no cover
+    dateutil_parser = None  # type: ignore[assignment]
+
 logger = logging.getLogger(__name__)
 
 _ConfigDisplay = TypedDict(
@@ -838,11 +843,11 @@ class YamlJobsStorage(BaseYamlFileStorage, JobsBaseFileStorage):
                 job = JobBase.unserialize(job_data, filenames)
                 # TODO: implement 100% validation and remove it from jobs.py
                 # TODO: try using pydantic to do this.
-                if not isinstance(job.data, (NoneType, str, dict)):
+                if not isinstance(job.data, (NoneType, str, dict, list)):
                     raise ValueError(
                         '\n   '.join(
                             [
-                                f"The 'data' key needs to contain a string or a dictionary; found a"
+                                f"The 'data' key needs to contain a string, a dictionary or a list; found a"
                                 f' {type(job.data).__name__} ',
                                 f'in {job.get_indexed_location()}',
                             ]
@@ -1065,15 +1070,26 @@ class SsdbStorage(BaseFileStorage, ABC):
                 if count:
                     print(f'Deleted {count} old snapshots of {guid}')
 
-    def rollback_cache(self, timestamp: float, tz: Optional[str] = None) -> None:
+    @staticmethod
+    def _convert_to_datetime(timespec: str, tz: Union[ZoneInfo, tzinfo, None]) -> datetime:
+        try:
+            timestamp = float(timespec)
+            return datetime.fromtimestamp(timestamp, tz)
+        except ValueError:
+            if dateutil_parser is not None:
+                return dateutil_parser.parse(timespec)
+            else:
+                return datetime.fromisoformat(timespec)
+
+    def rollback_cache(self, timespec: str, tz_str: Optional[str] = None) -> None:
         """Issues a warning, calls rollback() and prints out the result.
 
-        :param timestamp: The timestamp
+        :param timestamp: A timespec that if numeric is interpreted as a Unix timestamp otherwise it's passed to
+          dateutil.parser (if datetime is installed) or datetime.fromisoformat to be converted into a date.
         :param tz: The IANA tz name to use for the prompts and confirmation dialogs.
         """
-
-        tzinfo = ZoneInfo(tz) if tz else datetime.now().astimezone().tzinfo  # from machine
-        dt = datetime.fromtimestamp(timestamp, tzinfo)
+        tz = ZoneInfo(tz_str) if tz_str else datetime.now().astimezone().tzinfo  # from machine
+        dt = self._convert_to_datetime(timespec, tz)
         timestamp_date = email.utils.format_datetime(dt)
         print(f'Rolling back database to {timestamp_date}')
         if sys.__stdin__.isatty():
@@ -1083,7 +1099,7 @@ class SsdbStorage(BaseFileStorage, ABC):
             if not resp.upper().startswith('Y'):
                 print('Quitting rollback. No snapshots have been deleted.')
                 sys.exit(1)
-        count = self.rollback(timestamp)
+        count = self.rollback(dt.timestamp())
         if count:
             print(f'Deleted {count} snapshots taken after {timestamp_date}')
         else:

{webchanges-3.23.0 → webchanges-3.24.1/webchanges.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: webchanges
-Version: 3.23.0
+Version: 3.24.1
 Summary: Check web (or command output) for changes since last run and notify. Anonymously alerts you of web changes, with
 Author-email: Mike Borsetti <mike+webchanges@borsetti.com>
 Maintainer-email: Mike Borsetti <mike+webchanges@borsetti.com>