Merge remote-tracking branch 'origin/master' into 4150.ci-for-debian-trixie

newsfragments/4158.minor

@@ -0,0 +1 @@
+Fixed a couple of SyntaxWarnings from invalid escape sequences (shown under Python 3.12 and 3.13).

src/allmydata/hashtree.py

@@ -70,7 +70,7 @@ def roundup_pow2(x):
 
 
 class CompleteBinaryTreeMixin:
-    """
+    r"""
     Adds convenience methods to a complete binary tree.
 
     Assumes the total number of elements in the binary tree may be
@@ -179,7 +179,7 @@ def pair_hash(a, b):
     return tagged_pair_hash(b'Merkle tree internal node', a, b)
 
 class HashTree(CompleteBinaryTreeMixin, list):
-    """
+    r"""
     Compute Merkle hashes at any node in a complete binary tree.
 
     Tree is indexed like so::

src/allmydata/interfaces.py

@@ -406,7 +406,7 @@ class IStorageBucketWriter(Interface):
         """
 
     def put_uri_extension(data):
-        """This block of data contains integrity-checking information (hashes
+        r"""This block of data contains integrity-checking information (hashes
         of plaintext, crypttext, and shares), as well as encoding parameters
         that are necessary to recover the data. This is a serialized dict
         mapping strings to other strings. The hash of this data is kept in

src/allmydata/node.py

@@ -90,7 +90,7 @@ def _common_valid_config():
     })
 
 # group 1 will be addr (dotted quad string), group 3 if any will be portnum (string)
-ADDR_RE = re.compile("^([1-9][0-9]*\.[1-9][0-9]*\.[1-9][0-9]*\.[1-9][0-9]*)(:([1-9][0-9]*))?$")
+ADDR_RE = re.compile(r"^([1-9][0-9]*\.[1-9][0-9]*\.[1-9][0-9]*\.[1-9][0-9]*)(:([1-9][0-9]*))?$")
 
 # this is put into README in new node-directories (for client and introducers)
 PRIV_README = """

src/allmydata/test/cli/test_backup.py

@@ -36,9 +36,9 @@ class Backup(GridTestMixin, CLITestMixin, StallMixin, unittest.TestCase):
 
     def count_output(self, out):
         mo = re.search(r"(\d)+ files uploaded \((\d+) reused\), "
-                        "(\d)+ files skipped, "
-                        "(\d+) directories created \((\d+) reused\), "
-                        "(\d+) directories skipped", out)
+                        r"(\d)+ files skipped, "
+                        r"(\d+) directories created \((\d+) reused\), "
+                        r"(\d+) directories skipped", out)
         return [int(s) for s in mo.groups()]
 
     def count_output2(self, out):

src/allmydata/test/cli/test_cli.py

@@ -764,7 +764,7 @@ class Errors(GridTestMixin, CLITestMixin, unittest.TestCase):
         # enough shares. The one remaining share might be in either the
         # COMPLETE or the PENDING state.
         in_complete_msg = "ran out of shares: complete=sh0 pending= overdue= unused= need 3"
-        in_pending_msg_regex = "ran out of shares: complete= pending=Share\(.+\) overdue= unused= need 3"
+        in_pending_msg_regex = r"ran out of shares: complete= pending=Share\(.+\) overdue= unused= need 3"
 
         d.addCallback(lambda ign: self.do_cli("get", self.uri_1share))
         def _check1(args):

src/allmydata/test/test_runner.py

@@ -254,7 +254,7 @@ class CreateNode(unittest.TestCase):
         # Fail if there is a non-empty line that doesn't end with a
         # punctuation mark.
         for line in err.splitlines():
-            self.failIf(re.search("[\S][^\.!?]$", line), (line,))
+            self.failIf(re.search(r"[\S][^\.!?]$", line), (line,))
 
         # test that the non --basedir form works too
         n2 = os.path.join(basedir, command + "-n2")

src/allmydata/test/test_time_format.py

@@ -81,22 +81,42 @@ class TimeFormat(unittest.TestCase, TimezoneMixin):
         DAY = 24*60*60
         MONTH = 31*DAY
         YEAR = 365*DAY
+
+        # seconds
+        self.failUnlessEqual(p("1s"), 1)
+        self.failUnlessEqual(p("12 s"), 12)
+        self.failUnlessEqual(p("333second"), 333)
+        self.failUnlessEqual(p(" 333 second "), 333)
+        self.failUnlessEqual(p("5 seconds"), 5)
+        self.failUnlessEqual(p("60 SECONDS"), 60)
+        self.failUnlessEqual(p("86400s"), DAY)
+
+        # days
         self.failUnlessEqual(p("1 day"), DAY)
         self.failUnlessEqual(p("2 days"), 2*DAY)
-        self.failUnlessEqual(p("3 months"), 3*MONTH)
-        self.failUnlessEqual(p("4 mo"), 4*MONTH)
-        self.failUnlessEqual(p("5 years"), 5*YEAR)
-        e = self.failUnlessRaises(ValueError, p, "123")
-        self.failUnlessIn("no unit (like day, month, or year) in '123'",
-                          str(e))
+        self.failUnlessEqual(p("5days"), 5*DAY)
         self.failUnlessEqual(p("7days"), 7*DAY)
         self.failUnlessEqual(p("31day"), 31*DAY)
         self.failUnlessEqual(p("60 days"), 60*DAY)
+        self.failUnlessEqual(p("70 DAYS"), 70*DAY)
+
+        # months
+        self.failUnlessEqual(p("4 mo"), 4*MONTH)
         self.failUnlessEqual(p("2mo"), 2*MONTH)
         self.failUnlessEqual(p("3 month"), 3*MONTH)
+        self.failUnlessEqual(p("3 months"), 3*MONTH)
+
+        # years
+        self.failUnlessEqual(p("5 years"), 5*YEAR)
+        self.failUnlessEqual(p("8 year"), 8*YEAR)
         self.failUnlessEqual(p("2years"), 2*YEAR)
+        self.failUnlessEqual(p("11YEARS"), 11*YEAR)
+
+        # errors
+        e = self.failUnlessRaises(ValueError, p, "123")
+        self.failUnlessIn("No valid unit in",str(e))
         e = self.failUnlessRaises(ValueError, p, "2kumquats")
-        self.failUnlessIn("no unit (like day, month, or year) in '2kumquats'", str(e))
+        self.failUnlessIn("No valid unit in", str(e))
 
     def test_parse_date(self):
         p = time_format.parse_date

src/allmydata/test/web/test_web.py

@@ -1968,7 +1968,7 @@ class Web(WebMixin, WebErrorMixin, testutil.StallMixin, testutil.ReallyEqualMixi
     def test_CSS_FILE(self):
         d = self.GET("/tahoe.css", followRedirect=True)
         def _check(res):
-            CSS_STYLE=re.compile(b'toolbar\s{.+text-align:\scenter.+toolbar-item.+display:\sinline',re.DOTALL)
+            CSS_STYLE=re.compile(b'toolbar\\s{.+text-align:\\scenter.+toolbar-item.+display:\\sinline',re.DOTALL)
             self.failUnless(CSS_STYLE.search(res), res)
         d.addCallback(_check)
         return d

src/allmydata/util/i2p_provider.py

@@ -189,7 +189,7 @@ class _Provider(service.MultiService):
         privkeyfile = self._get_i2p_config("dest.private_key_file")
         external_port = self._get_i2p_config("dest.port")
         sam_port = self._get_i2p_config("sam.port")
-        escaped_sam_port = sam_port.replace(':', '\:')
+        escaped_sam_port = sam_port.replace(':', r'\:')
         # for now, this returns a string, which then gets passed to
         # endpoints.serverFromString . But it can also return an Endpoint
         # directly, which means we don't need to encode all these options

src/allmydata/util/time_format.py

@@ -6,8 +6,26 @@ http://www.cl.cam.ac.uk/~mgk25/iso-time.html
 """
 
 import calendar, datetime, re, time
-
 from typing import Optional
+from enum import Enum
+
+
+class ParseDurationUnitFormat(str, Enum):
+    SECONDS0 = "s"
+    SECONDS1 = "second"
+    SECONDS2 = "seconds"
+    DAYS0 = "day"
+    DAYS1 = "days"
+    MONTHS0 = "mo"
+    MONTHS1 = "month"
+    MONTHS2 = "months"
+    YEARS0 = "year"
+    YEARS1 = "years"
+
+    @classmethod
+    def list_values(cls):
+        return list(map(lambda c: c.value, cls))
+
 
 def format_time(t):
     return time.strftime("%Y-%m-%d %H:%M:%S", t)
@@ -50,30 +68,53 @@ def iso_utc_time_to_seconds(isotime, _conversion_re=re.compile(r"(?P<year>\d{4})
 
     return calendar.timegm( (year, month, day, hour, minute, second, 0, 1, 0) ) + subsecfloat
 
+
 def parse_duration(s):
-    orig = s
-    unit = None
+    """
+    Parses a duration string and converts it to seconds. The unit format is case insensitive
+
+    Args:
+        s (str): The duration string to parse. Expected format: `<number><unit>`
+                 where `unit` can be one of the values defined in `ParseDurationUnitFormat`.
+
+    Returns:
+        int: The duration in seconds.
+
+    Raises:
+        ValueError: If the input string does not match the expected format or contains invalid units.
+    """
+    SECOND = 1
     DAY = 24*60*60
     MONTH = 31*DAY
     YEAR = 365*DAY
-    if s.endswith("s"):
-        s = s[:-1]
-    if s.endswith("day"):
-        unit = DAY
-        s = s[:-len("day")]
-    elif s.endswith("month"):
-        unit = MONTH
-        s = s[:-len("month")]
-    elif s.endswith("mo"):
-        unit = MONTH
-        s = s[:-len("mo")]
-    elif s.endswith("year"):
-        unit = YEAR
-        s = s[:-len("YEAR")]
-    else:
-        raise ValueError("no unit (like day, month, or year) in '%s'" % orig)
-    s = s.strip()
-    return int(s) * unit
+    time_map = {
+        ParseDurationUnitFormat.SECONDS0: SECOND,
+        ParseDurationUnitFormat.SECONDS1: SECOND,
+        ParseDurationUnitFormat.SECONDS2: SECOND,
+        ParseDurationUnitFormat.DAYS0: DAY,
+        ParseDurationUnitFormat.DAYS1: DAY,
+        ParseDurationUnitFormat.MONTHS0: MONTH,
+        ParseDurationUnitFormat.MONTHS1: MONTH,
+        ParseDurationUnitFormat.MONTHS2: MONTH,
+        ParseDurationUnitFormat.YEARS0: YEAR,
+        ParseDurationUnitFormat.YEARS1: YEAR,
+    }
+
+    # Build a regex pattern dynamically from the list of valid values
+    unit_pattern = "|".join(re.escape(unit) for unit in ParseDurationUnitFormat.list_values())
+    pattern = rf"^\s*(\d+)\s*({unit_pattern})\s*$"
+
+    # case-insensitive regex matching
+    match = re.match(pattern, s, re.IGNORECASE)
+    if not match:
+        # Generate dynamic error message
+        valid_units = ", ".join(f"'{value}'" for value in ParseDurationUnitFormat.list_values())
+        raise ValueError(f"No valid unit in '{s}'. Expected one of: ({valid_units})")
+
+    number = int(match.group(1))  # Extract the numeric value
+    unit = match.group(2).lower()  # Extract the unit & normalize the unit to lowercase
+
+    return number * time_map[unit]
 
 def parse_date(s):
     # return seconds-since-epoch for the UTC midnight that starts the given

src/allmydata/web/status.py

@@ -1556,8 +1556,8 @@ class Statistics(MultiFormatResource):
 
         def mangle_name(name):
             return re.sub(
-                u"_(\d\d)_(\d)_percentile",
-                u'{quantile="0.\g<1>\g<2>"}',
+                r"_(\d\d)_(\d)_percentile",
+                r'{quantile="0.\g<1>\g<2>"}',
                 name.replace(u".", u"_")
             )