Python 3.12 is released

Start testing with Python 3.13

.github/workflows/pybuilder.yml

@@ -14,7 +14,7 @@ jobs:
         os:
           - ubuntu-latest
         python-version:
-          - '3.12-dev'
+          - '3.12'
           - '3.11'
           - '3.10'
           - '3.9'
@@ -49,6 +49,7 @@ jobs:
           - macos-11
           - macos-12
         python-version:
+          - '3.12'
           - '3.11'
           - '3.10'
           - '3.9'
@@ -98,6 +99,7 @@ jobs:
           - macos-11
           - macos-12
         python-version:
+          - '3.13-dev'
           - 'pypy-3.7'
           - 'pypy-3.8'
           - 'pypy-3.9'

build.py

@@ -106,8 +106,9 @@ def initialize(project):
                                                 "setuptools>=45.0.0",
                                                 "virtualenv>=20.0.0",
                                                 "importlib-resources>=1.0",
-                                                "importlib-metadata>=0.12,<5.0",
-                                                "typing-extensions",
+                                                "importlib-metadata>=0.12,<6.8.0",
+                                                "zipp<3.16.0",
+                                                "typing-extensions<4.8.0",
                                                 "colorama~=0.4.3"
                                                 ])
     project.set_property("vendorize_cleanup_globs", ["bin",

src/main/python/pybuilder/_vendor/distlib/__init__.py

@@ -6,7 +6,7 @@
 #
 import logging
 
-__version__ = '0.3.6'
+__version__ = '0.3.7'
 
 class DistlibException(Exception):
     pass

src/main/python/pybuilder/_vendor/distlib/database.py

@@ -903,15 +903,18 @@ def parse_requires_data(data):
             lines = data.splitlines()
             for line in lines:
                 line = line.strip()
-                if line.startswith('['):
+                # sectioned files have bare newlines (separating sections)
+                if not line:  # pragma: no cover
+                    continue
+                if line.startswith('['):  # pragma: no cover
                     logger.warning('Unexpected line: quitting requirement scan: %r',
                                    line)
                     break
                 r = parse_requirement(line)
-                if not r:
+                if not r:  # pragma: no cover
                     logger.warning('Not recognised as a requirement: %r', line)
                     continue
-                if r.extras:
+                if r.extras:  # pragma: no cover
                     logger.warning('extra requirements in requires.txt are '
                                    'not supported')
                 if not r.constraints:

src/main/python/pybuilder/_vendor/distlib/manifest.py

@@ -35,8 +35,9 @@
 _PYTHON_VERSION = sys.version_info[:2]
 
 class Manifest(object):
-    """A list of files built by on exploring the filesystem and filtered by
-    applying various patterns to what we find there.
+    """
+    A list of files built by exploring the filesystem and filtered by applying various
+    patterns to what we find there.
     """
 
     def __init__(self, base=None):

src/main/python/pybuilder/_vendor/distlib/markers.py

@@ -24,21 +24,22 @@
 __all__ = ['interpret']
 
 _VERSION_PATTERN = re.compile(r'((\d+(\.\d+)*\w*)|\'(\d+(\.\d+)*\w*)\'|\"(\d+(\.\d+)*\w*)\")')
+_VERSION_MARKERS = {'python_version', 'python_full_version'}
+
+def _is_version_marker(s):
+    return isinstance(s, string_types) and s in _VERSION_MARKERS
 
 def _is_literal(o):
     if not isinstance(o, string_types) or not o:
         return False
     return o[0] in '\'"'
 
 def _get_versions(s):
-    result = []
-    for m in _VERSION_PATTERN.finditer(s):
-        result.append(NV(m.groups()[0]))
-    return set(result)
+    return {NV(m.groups()[0]) for m in _VERSION_PATTERN.finditer(s)}
 
 class Evaluator(object):
     """
-    This class is used to evaluate marker expessions.
+    This class is used to evaluate marker expressions.
     """
 
     operations = {
@@ -80,11 +81,11 @@ def evaluate(self, expr, context):
 
             lhs = self.evaluate(elhs, context)
             rhs = self.evaluate(erhs, context)
-            if ((elhs == 'python_version' or erhs == 'python_version') and
+            if ((_is_version_marker(elhs) or _is_version_marker(erhs)) and
                 op in ('<', '<=', '>', '>=', '===', '==', '!=', '~=')):
                 lhs = NV(lhs)
                 rhs = NV(rhs)
-            elif elhs == 'python_version' and op in ('in', 'not in'):
+            elif _is_version_marker(elhs) and op in ('in', 'not in'):
                 lhs = NV(lhs)
                 rhs = _get_versions(rhs)
             result = self.operations[op](lhs, rhs)

src/main/python/pybuilder/_vendor/distlib/metadata.py

@@ -136,17 +136,9 @@ def _version2fieldlist(version):
 def _best_version(fields):
     """Detect the best version depending on the fields used."""
     def _has_marker(keys, markers):
-        for marker in markers:
-            if marker in keys:
-                return True
-        return False
-
-    keys = []
-    for key, value in fields.items():
-        if value in ([], 'UNKNOWN', None):
-            continue
-        keys.append(key)
+        return any(marker in keys for marker in markers)
 
+    keys = [key for key, value in fields.items() if value not in ([], 'UNKNOWN', None)]
     possible_versions = ['1.0', '1.1', '1.2', '1.3', '2.1', '2.2']  # 2.0 removed
 
     # first let's try to see if a field is not part of one of the version

src/main/python/pybuilder/_vendor/distlib/scripts.py

@@ -168,15 +168,16 @@ def _get_shebang(self, encoding, post_interp=b'', options=None):
             executable = os.path.join(sysconfig.get_path('scripts'),
                             'python%s' % sysconfig.get_config_var('EXE'))
         else:  # pragma: no cover
-            executable = os.path.join(
-                sysconfig.get_config_var('BINDIR'),
-               'python%s%s' % (sysconfig.get_config_var('VERSION'),
-                               sysconfig.get_config_var('EXE')))
-            if not os.path.isfile(executable):
+            if os.name == 'nt':
                 # for Python builds from source on Windows, no Python executables with
                 # a version suffix are created, so we use python.exe
                 executable = os.path.join(sysconfig.get_config_var('BINDIR'),
                                 'python%s' % (sysconfig.get_config_var('EXE')))
+            else:
+                executable = os.path.join(
+                    sysconfig.get_config_var('BINDIR'),
+                   'python%s%s' % (sysconfig.get_config_var('VERSION'),
+                                   sysconfig.get_config_var('EXE')))
         if options:
             executable = self._get_alternate_executable(executable, options)
 

src/main/python/pybuilder/_vendor/distlib/util.py

@@ -707,7 +707,7 @@ def __eq__(self, other):
     __hash__ = object.__hash__
 
 
-ENTRY_RE = re.compile(r'''(?P<name>(\w|[-.+])+)
+ENTRY_RE = re.compile(r'''(?P<name>([^\[]\S*))
                       \s*=\s*(?P<callable>(\w+)([:\.]\w+)*)
                       \s*(\[\s*(?P<flags>[\w-]+(=\w+)?(,\s*\w+(=\w+)?)*)\s*\])?
                       ''', re.VERBOSE)
@@ -1249,6 +1249,19 @@ def check_path(path):
             for tarinfo in archive.getmembers():
                 if not isinstance(tarinfo.name, text_type):
                     tarinfo.name = tarinfo.name.decode('utf-8')
+
+        # Limit extraction of dangerous items, if this Python
+        # allows it easily. If not, just trust the input.
+        # See: https://docs.python.org/3/library/tarfile.html#extraction-filters
+        def extraction_filter(member, path):
+            """Run tarfile.tar_filter, but raise the expected ValueError"""
+            # This is only called if the current Python has tarfile filters
+            try:
+                return tarfile.tar_filter(member, path)
+            except tarfile.FilterError as exc:
+                raise ValueError(str(exc))
+        archive.extraction_filter = extraction_filter
+
         archive.extractall(dest_dir)
 
     finally:
@@ -1435,7 +1448,7 @@ def connect(self):
             context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
             if hasattr(ssl, 'OP_NO_SSLv2'):
                 context.options |= ssl.OP_NO_SSLv2
-            if self.cert_file:
+            if getattr(self, 'cert_file', None):
                 context.load_cert_chain(self.cert_file, self.key_file)
             kwargs = {}
             if self.ca_certs:
@@ -1908,9 +1921,13 @@ def get_host_platform():
         if m:
             release = m.group()
     elif osname[:6] == 'darwin':
-        import _osx_support, distutils.sysconfig
+        import _osx_support
+        try:
+            from distutils import sysconfig
+        except ImportError:
+            import sysconfig
         osname, release, machine = _osx_support.get_platform_osx(
-                                        distutils.sysconfig.get_config_vars(),
+                                        sysconfig.get_config_vars(),
                                         osname, release, machine)
 
     return '%s-%s-%s' % (osname, release, machine)

src/main/python/pybuilder/_vendor/distlib/version.py

@@ -176,9 +176,9 @@ def __str__(self):
         return self._string
 
 
-PEP440_VERSION_RE = re.compile(r'^v?(\d+!)?(\d+(\.\d+)*)((a|b|c|rc)(\d+))?'
-                               r'(\.(post)(\d+))?(\.(dev)(\d+))?'
-                               r'(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$')
+PEP440_VERSION_RE = re.compile(r'^v?(\d+!)?(\d+(\.\d+)*)((a|alpha|b|beta|c|rc|pre|preview)(\d+)?)?'
+                               r'(\.(post|r|rev)(\d+)?)?([._-]?(dev)(\d+)?)?'
+                               r'(\+([a-zA-Z\d]+(\.[a-zA-Z\d]+)?))?$', re.I)
 
 
 def _pep_440_key(s):
@@ -202,15 +202,24 @@ def _pep_440_key(s):
     if pre == (None, None):
         pre = ()
     else:
-        pre = pre[0], int(pre[1])
+        if pre[1] is None:
+            pre = pre[0], 0
+        else:
+            pre = pre[0], int(pre[1])
     if post == (None, None):
         post = ()
     else:
-        post = post[0], int(post[1])
+        if post[1] is None:
+            post = post[0], 0
+        else:
+            post = post[0], int(post[1])
     if dev == (None, None):
         dev = ()
     else:
-        dev = dev[0], int(dev[1])
+        if dev[1] is None:
+            dev = dev[0], 0
+        else:
+            dev = dev[0], int(dev[1])
     if local is None:
         local = ()
     else:

src/main/python/pybuilder/_vendor/filelock/__init__.py

@@ -24,8 +24,8 @@
 
 if sys.platform == "win32":  # pragma: win32 cover
     _FileLock: type[BaseFileLock] = WindowsFileLock
-else:  # pragma: win32 no cover
-    if has_fcntl:  # noqa: PLR5501
+else:  # pragma: win32 no cover # noqa: PLR5501
+    if has_fcntl:
         _FileLock: type[BaseFileLock] = UnixFileLock
     else:
         _FileLock = SoftFileLock

src/main/python/pybuilder/_vendor/filelock/_api.py

@@ -13,8 +13,15 @@
 from ._error import Timeout
 
 if TYPE_CHECKING:
+    import sys
     from types import TracebackType
 
+    if sys.version_info >= (3, 11):  # pragma: no cover (py311+)
+        from typing import Self
+    else:  # pragma: no cover (<py311)
+        from typing_extensions import Self
+
+
 _LOGGER = logging.getLogger("filelock")
 
 
@@ -71,7 +78,7 @@ class BaseFileLock(ABC, contextlib.ContextDecorator):
 
     def __init__(
         self,
-        lock_file: str | os.PathLike[Any],
+        lock_file: str | os.PathLike[str],
         timeout: float = -1,
         mode: int = 0o644,
         thread_local: bool = True,  # noqa: FBT001, FBT002
@@ -246,7 +253,7 @@ def release(self, force: bool = False) -> None:  # noqa: FBT001, FBT002
                 self._context.lock_counter = 0
                 _LOGGER.debug("Lock %s released on %s", lock_id, lock_filename)
 
-    def __enter__(self) -> BaseFileLock:
+    def __enter__(self) -> Self:
         """
         Acquire the lock.
 

src/main/python/pybuilder/_vendor/filelock/_soft.py

@@ -7,14 +7,15 @@
 from pathlib import Path
 
 from ._api import BaseFileLock
-from ._util import raise_on_not_writable_file
+from ._util import ensure_directory_exists, raise_on_not_writable_file
 
 
 class SoftFileLock(BaseFileLock):
     """Simply watches the existence of the lock file."""
 
     def _acquire(self) -> None:
         raise_on_not_writable_file(self.lock_file)
+        ensure_directory_exists(self.lock_file)
         # first check for exists and read-only mode as the open will mask this case as EEXIST
         flags = (
             os.O_WRONLY  # open for writing only

src/main/python/pybuilder/_vendor/filelock/_unix.py

@@ -7,6 +7,7 @@
 from typing import cast
 
 from ._api import BaseFileLock
+from ._util import ensure_directory_exists
 
 #: a flag to indicate if the fcntl API is available
 has_fcntl = False
@@ -33,6 +34,7 @@ class UnixFileLock(BaseFileLock):
         """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
 
         def _acquire(self) -> None:
+            ensure_directory_exists(self.lock_file)
             open_flags = os.O_RDWR | os.O_CREAT | os.O_TRUNC
             fd = os.open(self.lock_file, open_flags, self._context.mode)
             with suppress(PermissionError):  # This locked is not owned by this UID

src/main/python/pybuilder/_vendor/filelock/_util.py

@@ -4,6 +4,7 @@
 import stat
 import sys
 from errno import EACCES, EISDIR
+from pathlib import Path
 
 
 def raise_on_not_writable_file(filename: str) -> None:
@@ -32,6 +33,15 @@ def raise_on_not_writable_file(filename: str) -> None:
                 raise IsADirectoryError(EISDIR, "Is a directory", filename)
 
 
+def ensure_directory_exists(filename: Path | str) -> None:
+    """
+    Ensure the directory containing the file exists (create it if necessary)
+    :param filename: file.
+    """
+    Path(filename).parent.mkdir(parents=True, exist_ok=True)
+
+
 __all__ = [
     "raise_on_not_writable_file",
+    "ensure_directory_exists",
 ]

src/main/python/pybuilder/_vendor/filelock/_windows.py

@@ -8,7 +8,7 @@
 from typing import cast
 
 from ._api import BaseFileLock
-from ._util import raise_on_not_writable_file
+from ._util import ensure_directory_exists, raise_on_not_writable_file
 
 if sys.platform == "win32":  # pragma: win32 cover
     import msvcrt
@@ -18,6 +18,7 @@ class WindowsFileLock(BaseFileLock):
 
         def _acquire(self) -> None:
             raise_on_not_writable_file(self.lock_file)
+            ensure_directory_exists(self.lock_file)
             flags = (
                 os.O_RDWR  # open for read and write
                 | os.O_CREAT  # create file if not exists

src/main/python/pybuilder/_vendor/filelock/version.py

@@ -1,4 +1,4 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-__version__ = version = '3.12.2'
-__version_tuple__ = version_tuple = (3, 12, 2)
+__version__ = version = '3.12.4'
+__version_tuple__ = version_tuple = (3, 12, 4)