Merge branch 'main' into pathlib_abc

Lib/pathlib/_abc.py

@@ -165,12 +165,11 @@ def split(self, path):
         """
         self._unsupported('split()')
 
-    def splitroot(self, path):
-        """Split the pathname path into a 3-item tuple (drive, root, tail),
-        where *drive* is a device name or mount point, *root* is a string of
-        separators after the drive, and *tail* is everything after the root.
-        Any part may be empty."""
-        self._unsupported('splitroot()')
+    def splitdrive(self, path):
+        """Split the path into a 2-item tuple (drive, tail), where *drive* is
+        a device name or mount point, and *tail* is everything after the
+        drive. Either part may be empty."""
+        self._unsupported('splitdrive()')
 
     def normcase(self, path):
         """Normalize the case of the path."""
@@ -227,18 +226,17 @@ def as_posix(self):
     @property
     def drive(self):
         """The drive prefix (letter or UNC path), if any."""
-        return self.pathmod.splitroot(self._raw_path)[0]
+        return self.pathmod.splitdrive(self.anchor)[0]
 
     @property
     def root(self):
         """The root of the path, if any."""
-        return self.pathmod.splitroot(self._raw_path)[1]
+        return self.pathmod.splitdrive(self.anchor)[1]
 
     @property
     def anchor(self):
         """The concatenation of the drive and root, or ''."""
-        drive, root, _ =  self.pathmod.splitroot(self._raw_path)
-        return drive + root
+        return self._stack[0]
 
     @property
     def name(self):

Lib/test/test_pathlib/test_pathlib_abc.py

@@ -27,7 +27,7 @@ def test_unsupported_operation(self):
             m.sep
         self.assertRaises(e, m.join, 'foo')
         self.assertRaises(e, m.split, 'foo')
-        self.assertRaises(e, m.splitroot, 'foo')
+        self.assertRaises(e, m.splitdrive, 'foo')
         self.assertRaises(e, m.normcase, 'foo')
         self.assertRaises(e, m.isabs, 'foo')
 

Tools/clinic/clinic.py

@@ -23,7 +23,6 @@
 import pprint
 import re
 import shlex
-import string
 import sys
 import textwrap
 
@@ -270,24 +269,6 @@ def __init__(self) -> None:
         self.unlock: list[str] = []
 
 
-class FormatCounterFormatter(string.Formatter):
-    """
-    This counts how many instances of each formatter
-    "replacement string" appear in the format string.
-
-    e.g. after evaluating "string {a}, {b}, {c}, {a}"
-         the counts dict would now look like
-         {'a': 2, 'b': 1, 'c': 1}
-    """
-    def __init__(self) -> None:
-        self.counts = collections.Counter[str]()
-
-    def get_value(
-        self, key: str, args: object, kwargs: object  # type: ignore[override]
-    ) -> Literal['']:
-        self.counts[key] += 1
-        return ''
-
 class Language(metaclass=abc.ABCMeta):
 
     start_line = ""
@@ -341,7 +322,7 @@ def assert_only_one(
             fields = ['dsl_name']
             fields.extend(additional_fields)
             line: str = getattr(self, attr)
-            fcf = FormatCounterFormatter()
+            fcf = libclinic.FormatCounterFormatter()
             fcf.format(line)
             def local_fail(should_be_there_but_isnt: bool) -> None:
                 if should_be_there_but_isnt:

Tools/clinic/libclinic/__init__.py

@@ -16,8 +16,9 @@
     wrapped_c_string_literal,
 )
 from .utils import (
-    create_regex,
+    FormatCounterFormatter,
     compute_checksum,
+    create_regex,
     write_file,
 )
 
@@ -39,8 +40,9 @@
     "wrapped_c_string_literal",
 
     # Utility functions
-    "create_regex",
+    "FormatCounterFormatter",
     "compute_checksum",
+    "create_regex",
     "write_file",
 ]
 

Tools/clinic/libclinic/utils.py

@@ -1,6 +1,9 @@
+import collections
 import hashlib
-import re
 import os
+import re
+import string
+from typing import Literal
 
 
 def write_file(filename: str, new_contents: str) -> None:
@@ -39,7 +42,27 @@ def create_regex(
     group_re = r"\w+" if word else ".+"
     before = re.escape(before)
     after = re.escape(after)
-    pattern = fr"{before}({group_re}){after}"
+    pattern = rf"{before}({group_re}){after}"
     if whole_line:
-        pattern = fr"^{pattern}$"
+        pattern = rf"^{pattern}$"
     return re.compile(pattern)
+
+
+class FormatCounterFormatter(string.Formatter):
+    """
+    This counts how many instances of each formatter
+    "replacement string" appear in the format string.
+
+    e.g. after evaluating "string {a}, {b}, {c}, {a}"
+         the counts dict would now look like
+         {'a': 2, 'b': 1, 'c': 1}
+    """
+
+    def __init__(self) -> None:
+        self.counts = collections.Counter[str]()
+
+    def get_value(
+        self, key: str, args: object, kwargs: object  # type: ignore[override]
+    ) -> Literal[""]:
+        self.counts[key] += 1
+        return ""