Adds fuzzy prune intervals and comprehensive interval test

Author: Goddesen

src/borg/archiver/prune_cmd.py

@@ -10,7 +10,7 @@
 from ..archive import Archive
 from ..cache import Cache
 from ..constants import *  # NOQA
-from ..helpers import interval, int_or_interval, sig_int, archivename_validator
+from ..helpers import interval, int_or_flexibledelta, sig_int, archivename_validator
 from ..helpers import ArchiveFormatter, ProgressIndicatorPercent, CommandError, Error
 from ..manifest import Manifest
 
@@ -105,11 +105,11 @@ def quarterly_3monthly_period_func(a):
 DATETIME_MIN_WITH_ZONE = datetime.min.replace(tzinfo=timezone.utc)
 
 
-def prune_split(archives, rule, n_or_interval, base_timestamp, kept_because={}):
-    if isinstance(n_or_interval, int):
-        n, earliest_timestamp = n_or_interval, None
+def prune_split(archives, rule, n_or_flexibledelta, base_timestamp, kept_because={}):
+    if isinstance(n_or_flexibledelta, int):
+        n, earliest_timestamp = n_or_flexibledelta, None
     else:
-        n, earliest_timestamp = None, base_timestamp - n_or_interval
+        n, earliest_timestamp = None, n_or_flexibledelta.subtract_from(base_timestamp, calendar=True)
 
     def can_retain(a, keep):
         if n is not None:
@@ -194,9 +194,9 @@ def do_prune(self, args, repository, manifest):
         base_timestamp = datetime.now().astimezone()
         # find archives which need to be kept because of the various time period rules
         for rule in PRUNING_PATTERNS.keys():
-            num_or_interval = getattr(args, rule, None)
-            if num_or_interval is not None:
-                keep += prune_split(archives, rule, num_or_interval, base_timestamp, kept_because)
+            n_or_flexibledelta = getattr(args, rule, None)
+            if n_or_flexibledelta is not None:
+                keep += prune_split(archives, rule, n_or_flexibledelta, base_timestamp, kept_because)
 
         to_delete = set(archives) - set(keep)
         with Cache(repository, manifest, iec=args.iec) as cache:
@@ -346,74 +346,74 @@ def build_parser_prune(self, subparsers, common_parser, mid_common_parser):
         subparser.add_argument(
             "--keep",
             dest="keep",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             action=Highlander,
             help="number or time interval of archives to keep",
         )
         subparser.add_argument(
             "--keep-secondly",
             dest="secondly",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             action=Highlander,
             help="number or time interval of secondly archives to keep",
         )
         subparser.add_argument(
             "--keep-minutely",
             dest="minutely",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             action=Highlander,
             help="number or time interval of minutely archives to keep",
         )
         subparser.add_argument(
             "-H",
             "--keep-hourly",
             dest="hourly",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             action=Highlander,
             help="number or time interval of hourly archives to keep",
         )
         subparser.add_argument(
             "-d",
             "--keep-daily",
             dest="daily",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             action=Highlander,
             help="number or time interval of daily archives to keep",
         )
         subparser.add_argument(
             "-w",
             "--keep-weekly",
             dest="weekly",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             action=Highlander,
             help="number or time interval of weekly archives to keep",
         )
         subparser.add_argument(
             "-m",
             "--keep-monthly",
             dest="monthly",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             action=Highlander,
             help="number or time interval of monthly archives to keep",
         )
         quarterly_group = subparser.add_mutually_exclusive_group()
         quarterly_group.add_argument(
             "--keep-13weekly",
             dest="quarterly_13weekly",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             help="number or time interval of quarterly archives to keep (13 week strategy)",
         )
         quarterly_group.add_argument(
             "--keep-3monthly",
             dest="quarterly_3monthly",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             help="number or time interval of quarterly archives to keep (3 month strategy)",
         )
         subparser.add_argument(
             "-y",
             "--keep-yearly",
             dest="yearly",
-            type=int_or_interval,
+            type=int_or_flexibledelta,
             action=Highlander,
             help="number or time interval of yearly archives to keep",
         )

src/borg/helpers/__init__.py

@@ -27,7 +27,7 @@
 from .misc import ChunkIteratorFileWrapper, open_item, chunkit, iter_separated, ErrorIgnoringTextIOWrapper
 from .parseformat import bin_to_hex, hex_to_bin, safe_encode, safe_decode
 from .parseformat import text_to_json, binary_to_json, remove_surrogates, join_cmd
-from .parseformat import eval_escapes, decode_dict, positive_int_validator, interval, int_or_interval
+from .parseformat import eval_escapes, decode_dict, positive_int_validator, interval, int_or_flexibledelta
 from .parseformat import PathSpec, SortBySpec, ChunkerParams, FilesCacheMode, partial_format, DatetimeWrapper
 from .parseformat import format_file_size, parse_file_size, FileSize
 from .parseformat import sizeof_fmt, sizeof_fmt_iec, sizeof_fmt_decimal, Location, text_validator
@@ -43,7 +43,7 @@
 from .process import popen_with_error_handling, is_terminal, prepare_subprocess_env, create_filter_process
 from .progress import ProgressIndicatorPercent, ProgressIndicatorMessage
 from .time import parse_timestamp, timestamp, safe_timestamp, safe_s, safe_ns, MAX_S, SUPPORT_32BIT_PLATFORMS
-from .time import format_time, format_timedelta, OutputTimestamp, archive_ts_now
+from .time import format_time, format_timedelta, OutputTimestamp, archive_ts_now, FlexibleDelta
 from .yes_no import yes, TRUISH, FALSISH, DEFAULTISH
 
 from .msgpack import is_slow_msgpack, is_supported_msgpack, get_limited_unpacker

src/borg/helpers/parseformat.py

@@ -13,7 +13,7 @@
 from pathlib import Path
 from typing import ClassVar, Any, TYPE_CHECKING, Literal
 from collections import OrderedDict
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timezone
 from functools import partial
 from string import Formatter
 
@@ -24,7 +24,7 @@
 from .errors import Error
 from .fs import get_keys_dir, make_path_safe
 from .msgpack import Timestamp
-from .time import OutputTimestamp, format_time, safe_timestamp
+from .time import OutputTimestamp, format_time, safe_timestamp, FlexibleDelta
 from .. import __version__ as borg_version
 from .. import __version_tuple__ as borg_version_tuple
 from ..constants import *  # NOQA
@@ -161,15 +161,15 @@ def interval(s):
     return seconds
 
 
-def int_or_interval(s):
+def int_or_flexibledelta(s):
     try:
         return int(s)
     except ValueError:
         pass
 
     try:
-        return timedelta(seconds=interval(s))
-    except argparse.ArgumentTypeError as e:
+        return FlexibleDelta.parse(s, fuzzyable=True)
+    except ValueError as e:
         raise argparse.ArgumentTypeError(f"Value is neither an integer nor an interval: {e}")
 
 

src/borg/helpers/time.py

@@ -165,12 +165,21 @@ def __init__(self, count, unit, fuzzy):
     def __repr__(self):
         return f'{self.__class__.__name__}(count={self.count}, unit="{self.unit}", fuzzy={self.fuzzy})'
 
+    def __eq__(self, other):
+        if not isinstance(other, FlexibleDelta):
+            return NotImplemented
+        return (self.count, self.unit, self.fuzzy) == (other.count, other.unit, other.fuzzy)
+
     _interval_regex = re.compile(r"^(?P<count>\d+)(?P<unit>[ymwdHMS])(?P<fuzzy>z)?$")
 
     @classmethod
     def parse(cls, interval_string, fuzzyable=False):
         """
-        Parse interval string into
+        Parse interval string into FlexibleDelta on a form like "1w", "25d", or "6Hz" where the unit is one of "y"
+        (years), "m" (months), "w" (weeks), "d" (days), "H" (hours), "M" (minutes), "S" (seconds). A trailing "z"
+        indicates a fuzzy delta (if fuzzyable is True) which is calculated as "apply delta and then take either the
+        start or end of the current unit's interval" -- subtracting "1dz" means subtracting 1 day and then adjusting to
+        the start of that day.
         """
         match = cls._interval_regex.search(interval_string)