Merge pull request #92 from testing-cabal/python3.14

Drop Python 3.9 support/add Python 3.14 support

Author: jelmer

.github/workflows/main.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        python-version: ["3.9", "3.10", "3.11", "3.12", "pypy3.9", '3.13']
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14", "pypy3.10"]
         os: ["ubuntu-latest"]
     steps:
     - uses: actions/checkout@v5

configure.ac

@@ -24,7 +24,7 @@ AM_PROG_CC_C_O
 AC_PROG_INSTALL
 AC_PROG_LN_S
 AC_PROG_LIBTOOL
-AM_PATH_PYTHON([3.6])
+AM_PATH_PYTHON([3.10])
 
 AS_IF([test "$GCC" = "yes"],
       [

pyproject.toml

@@ -15,8 +15,8 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
     "Programming Language :: Python",
     "Topic :: Software Development :: Testing",
 ]
@@ -27,7 +27,7 @@ keywords = ["python", "streaming", "test"]
 license = { text = "Apache-2.0 or BSD" }
 name = "python-subunit"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 
 [project.urls]
 "Bug Tracker" = "https://bugs.launchpad.net/subunit"

python/subunit/__init__.py

@@ -123,7 +123,6 @@ def test_script_two(self):
 import iso8601
 
 from testtools import ExtendedToOriginalDecorator, content, content_type
-from testtools.compat import _b, _u
 from testtools.content import TracebackContent
 
 from testtools.testresult.real import _StringException as RemoteException
@@ -218,27 +217,27 @@ def write(self, bytes):
         pass
 
     def read(self, len=0):
-        return _b("")
+        return b""
 
 
 class _ParserState(object):
     """State for the subunit parser."""
 
     def __init__(self, parser):
         self.parser = parser
-        self._test_sym = (_b("test"), _b("testing"))
-        self._colon_sym = _b(":")
-        self._error_sym = (_b("error"),)
-        self._failure_sym = (_b("failure"),)
-        self._progress_sym = (_b("progress"),)
-        self._skip_sym = _b("skip")
-        self._success_sym = (_b("success"), _b("successful"))
-        self._tags_sym = (_b("tags"),)
-        self._time_sym = (_b("time"),)
-        self._xfail_sym = (_b("xfail"),)
-        self._uxsuccess_sym = (_b("uxsuccess"),)
-        self._start_simple = _u(" [")
-        self._start_multipart = _u(" [ multipart")
+        self._test_sym = (b"test", b"testing")
+        self._colon_sym = b":"
+        self._error_sym = (b"error",)
+        self._failure_sym = (b"failure",)
+        self._progress_sym = (b"progress",)
+        self._skip_sym = b"skip"
+        self._success_sym = (b"success", b"successful")
+        self._tags_sym = (b"tags",)
+        self._time_sym = (b"time",)
+        self._xfail_sym = (b"xfail",)
+        self._uxsuccess_sym = (b"uxsuccess",)
+        self._start_simple = " ["
+        self._start_multipart = " [ multipart"
 
     def addError(self, offset, line):
         """An 'error:' directive has been read."""
@@ -296,7 +295,7 @@ def lineReceived(self, line):
 
     def lostConnection(self):
         """Connection lost."""
-        self.parser._lostConnectionInTest(_u("unknown state of "))
+        self.parser._lostConnectionInTest("unknown state of ")
 
     def startTest(self, offset, line):
         """A test start command received."""
@@ -376,7 +375,7 @@ def addSuccess(self, offset, line):
 
     def lostConnection(self):
         """Connection lost."""
-        self.parser._lostConnectionInTest(_u(""))
+        self.parser._lostConnectionInTest("")
 
 
 class _OutSideTest(_ParserState):
@@ -412,7 +411,7 @@ def lineReceived(self, line):
 
     def lostConnection(self):
         """Connection lost."""
-        self.parser._lostConnectionInTest(_u("%s report of ") % self._outcome_label())
+        self.parser._lostConnectionInTest("%s report of " % self._outcome_label())
 
     def _outcome_label(self):
         """The label to describe this outcome."""
@@ -523,9 +522,9 @@ def __init__(self, client, stream=None, forward_stream=None):
         # start with outside test.
         self._state = self._outside_test
         # Avoid casts on every call
-        self._plusminus = _b("+-")
-        self._push_sym = _b("push")
-        self._pop_sym = _b("pop")
+        self._plusminus = b"+-"
+        self._push_sym = b"push"
+        self._pop_sym = b"pop"
 
     def _handleProgress(self, offset, line):
         """Process a progress directive."""
@@ -555,15 +554,15 @@ def _handleTime(self, offset, line):
         try:
             event_time = iso8601.parse_date(line[offset:-1].decode())
         except TypeError:
-            raise TypeError(_u("Failed to parse %r, got %r") % (line, sys.exc_info()[1]))
+            raise TypeError("Failed to parse %r, got %r" % (line, sys.exc_info()[1]))
         self.client.time(event_time)
 
     def lineReceived(self, line):
         """Call the appropriate local method for the received line."""
         self._state.lineReceived(line)
 
     def _lostConnectionInTest(self, state_string):
-        error_string = _u("lost connection during %stest '%s'") % (state_string, self.current_test_description)
+        error_string = "lost connection during %stest '%s'" % (state_string, self.current_test_description)
         self.client.addError(self._current_test, RemoteError(error_string))
         self.client.stopTest(self._current_test)
 
@@ -615,14 +614,14 @@ def __init__(self, stream):
         testresult.TestResult.__init__(self)
         stream = make_stream_binary(stream)
         self._stream = stream
-        self._progress_fmt = _b("progress: ")
-        self._bytes_eol = _b("\n")
-        self._progress_plus = _b("+")
-        self._progress_push = _b("push")
-        self._progress_pop = _b("pop")
-        self._empty_bytes = _b("")
-        self._start_simple = _b(" [\n")
-        self._end_simple = _b("]\n")
+        self._progress_fmt = b"progress: "
+        self._bytes_eol = b"\n"
+        self._progress_plus = b"+"
+        self._progress_push = b"push"
+        self._progress_pop = b"pop"
+        self._empty_bytes = b""
+        self._start_simple = b" [\n"
+        self._end_simple = b"]\n"
 
     def addError(self, test, error=None, details=None):
         """Report an error in test test.
@@ -690,7 +689,7 @@ def _addOutcome(self, outcome, test, error=None, details=None, error_permitted=T
         :param error_permitted: If True then one and only one of error or
             details must be supplied. If False then error must not be supplied
             and details is still optional."""
-        self._stream.write(_b("%s: " % outcome) + self._test_id(test))
+        self._stream.write(("%s: " % outcome).encode() + self._test_id(test))
         if error_permitted:
             if error is None and details is None:
                 raise ValueError
@@ -705,7 +704,7 @@ def _addOutcome(self, outcome, test, error=None, details=None, error_permitted=T
         elif details is not None:
             self._write_details(details)
         else:
-            self._stream.write(_b("\n"))
+            self._stream.write(b"\n")
         if details is not None or error is not None:
             self._stream.write(self._end_simple)
 
@@ -714,8 +713,8 @@ def addSkip(self, test, reason=None, details=None):
         if reason is None:
             self._addOutcome("skip", test, error=None, details=details)
         else:
-            self._stream.write(_b("skip: %s [\n" % test.id()))
-            self._stream.write(_b("%s\n" % reason))
+            self._stream.write(("skip: %s [\n" % test.id()).encode())
+            self._stream.write(("%s\n" % reason).encode())
             self._stream.write(self._end_simple)
 
     def addSuccess(self, test, details=None):
@@ -746,7 +745,7 @@ def _test_id(self, test):
     def startTest(self, test):
         """Mark a test as starting its test run."""
         super(TestProtocolClient, self).startTest(test)
-        self._stream.write(_b("test: ") + self._test_id(test) + _b("\n"))
+        self._stream.write(b"test: " + self._test_id(test) + b"\n")
         self._stream.flush()
 
     def stopTest(self, test):
@@ -765,7 +764,7 @@ def progress(self, offset, whence):
         """
         if whence == PROGRESS_CUR and offset > -1:
             prefix = self._progress_plus
-            offset = _b(str(offset))
+            offset = str(offset).encode()
         elif whence == PROGRESS_PUSH:
             prefix = self._empty_bytes
             offset = self._progress_push
@@ -774,16 +773,16 @@ def progress(self, offset, whence):
             offset = self._progress_pop
         else:
             prefix = self._empty_bytes
-            offset = _b(str(offset))
+            offset = str(offset).encode()
         self._stream.write(self._progress_fmt + prefix + offset + self._bytes_eol)
 
     def tags(self, new_tags, gone_tags):
         """Inform the client about tags added/removed from the stream."""
         if not new_tags and not gone_tags:
             return
         tags = set([tag.encode("utf8") for tag in new_tags])
-        tags.update([_b("-") + tag.encode("utf8") for tag in gone_tags])
-        tag_line = _b("tags: ") + _b(" ").join(tags) + _b("\n")
+        tags.update([b"-" + tag.encode("utf8") for tag in gone_tags])
+        tag_line = b"tags: " + b" ".join(tags) + b"\n"
         self._stream.write(tag_line)
 
     def time(self, a_datetime):
@@ -793,28 +792,28 @@ def time(self, a_datetime):
         """
         time = a_datetime.astimezone(iso8601.UTC)
         self._stream.write(
-            _b(
-                "time: %04d-%02d-%02d %02d:%02d:%02d.%06dZ\n"
-                % (time.year, time.month, time.day, time.hour, time.minute, time.second, time.microsecond)
-            )
+            b"time: %04d-%02d-%02d %02d:%02d:%02d.%06dZ\n"
+            % (time.year, time.month, time.day, time.hour, time.minute, time.second, time.microsecond)
         )
 
     def _write_details(self, details):
         """Output details to the stream.
 
         :param details: An extended details dict for a test outcome.
         """
-        self._stream.write(_b(" [ multipart\n"))
+        self._stream.write(b" [ multipart\n")
         for name, content in sorted(details.items()):  # noqa: F402
-            self._stream.write(_b("Content-Type: %s/%s" % (content.content_type.type, content.content_type.subtype)))
+            self._stream.write(
+                ("Content-Type: %s/%s" % (content.content_type.type, content.content_type.subtype)).encode()
+            )
             parameters = content.content_type.parameters
             if parameters:
-                self._stream.write(_b(";"))
+                self._stream.write(b";")
                 param_strs = []
                 for param, value in sorted(parameters.items()):
                     param_strs.append("%s=%s" % (param, value))
-                self._stream.write(_b(",".join(param_strs)))
-            self._stream.write(_b("\n%s\n" % name))
+                self._stream.write(",".join(param_strs).encode())
+            self._stream.write(b"\n" + name.encode() + b"\n")
             encoder = chunked.Encoder(self._stream)
             list(map(encoder.write, content.iter_bytes()))
             encoder.close()
@@ -831,7 +830,7 @@ def addDuration(self, test, duration):
         pass
 
 
-def RemoteError(description=_u("")):
+def RemoteError(description=""):
     return (RemoteException, RemoteException(description), None)
 
 
@@ -880,7 +879,7 @@ def run(self, result=None):
         if result is None:
             result = self.defaultTestResult()
         result.startTest(self)
-        result.addError(self, RemoteError(_u("Cannot run RemotedTestCases.\n")))
+        result.addError(self, RemoteError("Cannot run RemotedTestCases.\n"))
         result.stopTest(self)
 
     def _strclass(self):
@@ -1323,7 +1322,7 @@ def _unwrap_text(stream):
     except exceptions:
         # Cannot read from the stream: try via writes
         try:
-            stream.write(_b(""))
+            stream.write(b"")
         except TypeError:
             return stream.buffer
     return stream

python/subunit/chunked.py

@@ -17,9 +17,7 @@
 
 """Encoder/decoder for http style chunked encoding."""
 
-from testtools.compat import _b
-
-empty = _b("")
+empty = b""
 
 
 class Decoder(object):
@@ -47,11 +45,11 @@ def __init__(self, output, strict=True):
         self.state = self._read_length
         self.body_length = 0
         self.strict = strict
-        self._match_chars = _b("0123456789abcdefABCDEF\r\n")
-        self._slash_n = _b("\n")
-        self._slash_r = _b("\r")
-        self._slash_rn = _b("\r\n")
-        self._slash_nr = _b("\n\r")
+        self._match_chars = b"0123456789abcdefABCDEF\r\n"
+        self._slash_n = b"\n"
+        self._slash_r = b"\r"
+        self._slash_rn = b"\r\n"
+        self._slash_nr = b"\n\r"
 
     def close(self):
         """Close the decoder.
@@ -164,7 +162,7 @@ def flush(self, extra_len=0):
         buffer_size = self.buffer_size
         self.buffered_bytes = []
         self.buffer_size = 0
-        self.output.write(_b("%X\r\n" % (buffer_size + extra_len)))
+        self.output.write(b"%X\r\n" % (buffer_size + extra_len))
         if buffer_size:
             self.output.write(empty.join(buffered_bytes))
         return True
@@ -182,4 +180,4 @@ def write(self, bytes):
     def close(self):
         """Finish the stream. This does not close the output stream."""
         self.flush()
-        self.output.write(_b("0\r\n"))
+        self.output.write(b"0\r\n")

python/subunit/details.py

@@ -19,13 +19,12 @@
 from io import BytesIO
 
 from testtools import content, content_type
-from testtools.compat import _b
 
 from subunit import chunked
 
-end_marker = _b("]\n")
-quoted_marker = _b(" ]")
-empty = _b("")
+end_marker = b"]\n"
+quoted_marker = b" ]"
+empty = b""
 
 
 class DetailsParser(object):
@@ -36,7 +35,7 @@ class SimpleDetailsParser(DetailsParser):
     """Parser for single-part [] delimited details."""
 
     def __init__(self, state):
-        self._message = _b("")
+        self._message = b""
         self._state = state
 
     def lineReceived(self, line):