PyPtt 2.2.6__tar.gz → 2.2.7__tar.gz

{pyptt-2.2.6 → pyptt-2.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPtt
-Version: 2.2.6
+Version: 2.2.7
 Summary: PyPtt github: https://github.com/PyPtt/PyPtt
 Author-email: CodingMan <pttcodingman@gmail.com>
 License: GNU Lesser General Public License v3 (LGPLv3)

{pyptt-2.2.6 → pyptt-2.2.7}/PyPtt/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '2.2.6'
+__version__ = '2.2.7'
 __author__ = 'CodingMan'
 __email__ = 'pttcodingman@gmail.com'
 

{pyptt-2.2.6 → pyptt-2.2.7}/PyPtt/_uao/__init__.py

@@ -1,10 +1,16 @@
 """Vendored Big5-UAO codec.
 
-Vendored (unmodified) from PttCodingMan/pyUAO, a fork of eight04/pyUAO,
-to drop the external `uao` PyPI dependency (unmaintained upstream) and
-pick up this fork's correctness fixes and incremental/stream codec
-support. Vendoring is for dependency control, not performance: PyPtt is
-I/O bound, so codec speed is not the point here.
+Vendored from PttCodingMan/pyUAO, a fork of eight04/pyUAO, to drop the
+external `uao` PyPI dependency (unmaintained upstream) and pick up this
+fork's correctness fixes and incremental/stream codec support.
+
+Locally modified: `_decode` batches ASCII runs with a single C-level decode
+instead of one chr()/append per byte. PTT screens are ~70% ASCII bytes even
+in Big5, so this speeds up the receive path measurably while producing
+byte-identical output (the byte→unicode table is unchanged). Python's stdlib
+`big5` codec is *not* a usable fast path — it disagrees with the UAO table on
+~260 sequences (e.g. 0xa1 0x45 → '•' vs '‧') and can't decode UAO's
+extensions at all.
 
 Source:  https://github.com/PttCodingMan/pyUAO
 Commit:  9d9a8bf59dbe60800d214b66ce972bc2ddf8da89 (v0.3.0)
@@ -89,8 +95,14 @@ def _decode(input, errors, final):
     while i < n:
         c = input[i]
         if c < 0x80:
-            append(chr(c))
-            i += 1
+            # At a character boundary every byte < 0x80 is a standalone ASCII
+            # char, so decode the whole run at once. latin-1 maps 0x00-0x7f
+            # identically to ASCII and never raises.
+            j = i + 1
+            while j < n and input[j] < 0x80:
+                j += 1
+            append(input[i:j].decode('latin-1'))
+            i = j
             continue
         if i + 1 < n:
             u = _b2u_get(c * 0x100 + input[i + 1])

{pyptt-2.2.6 → pyptt-2.2.7}/PyPtt/connect_core.py

@@ -350,11 +350,11 @@ class API(object):
                 return -1
 
             msg = ''
-            receive_data_buffer = bytes()
             # Fresh incremental parsers for this screen sequence. Each arriving
             # chunk is fed once (per encoding) instead of re-parsing the whole
             # accumulated buffer every time — turning the receive loop from
-            # O(N²) into O(N).
+            # O(N²) into O(N). The parsers also hold the rendered screen, so no
+            # separate raw byte buffer is accumulated.
             self._stream_parsers = {}
             start_time = time.time()
             find_target = False
@@ -372,7 +372,6 @@ class API(object):
 
                         if isinstance(data_chunk, str):
                             data_chunk = data_chunk.encode('utf-8')
-                        receive_data_buffer += data_chunk
 
                         screen = self._stream_screen(self.current_encoding, data_chunk)
                         screen, find_target, is_secret, break_detect_after_send, use_too_many_res, msg, target_index = \
@@ -396,10 +395,17 @@ class API(object):
                         if find_target:
                             break
             except TimeoutError:
-                if len(receive_data_buffer) > 0:
-                    vt100_p = screens.VT100Parser(receive_data_buffer, self.current_encoding, self.config.screen_height)
-                    screens.show(self.config, vt100_p.screen)
-                    self._RDQ.add(vt100_p.screen)
+                # The incremental parser for the current encoding already holds
+                # the fully-rendered screen for every byte received this round
+                # (byte-identical to a fresh VT100Parser over the whole buffer —
+                # see tests/test_incremental_parity.py), so reuse it instead of
+                # re-decoding and re-parsing the entire buffer from scratch.
+                parser = self._stream_parsers.get(self.current_encoding)
+                if parser is not None:
+                    screen = parser.screen
+                    if len(screen) > 0:
+                        screens.show(self.config, screen)
+                        self._RDQ.add(screen)
                 if use_too_many_res:
                     raise exceptions.UseTooManyResources()
                 return -1
@@ -450,7 +456,6 @@ class API(object):
                 if break_detect_after_send:
                     return -1
                 msg = ''
-                receive_data_buffer = bytes()
                 self._stream_parsers = {}
                 start_time = time.time()
                 mid_time = time.time()
@@ -459,7 +464,6 @@ class API(object):
                         data = self._core.read_very_eager()
                     except EOFError:
                         return -1
-                    receive_data_buffer += data
                     screen = self._stream_screen(self.current_encoding, data)
                     screen, find_target, is_secret, break_detect_after_send, use_too_many_res, msg, target_index = \
                         self._decode_screen(screen, start_time, target_list, is_secret, refresh, msg)

{pyptt-2.2.6 → pyptt-2.2.7}/PyPtt/screens.py

@@ -26,6 +26,8 @@ def _cell_width(ch: str) -> int:
     Ambiguous includes glyphs like ※, ←, →, ◎ that PTT's protocol treats
     as full-width when positioning the cursor.
     """
+    if ch.isascii():        # every ASCII char is a single narrow cell
+        return 1
     w = _cell_width_cache.get(ch)
     if w is None:
         w = 2 if unicodedata.east_asian_width(ch) in ('W', 'F', 'A') else 1
@@ -34,6 +36,11 @@ def _cell_width(ch: str) -> int:
 
 
 def _cell_len(text: str) -> int:
+    # PTT screens are mostly ASCII, and an all-ASCII string is exactly one cell
+    # per character — str.isascii() (a fast C scan) lets whole segments skip the
+    # per-character loop.
+    if text.isascii():
+        return len(text)
     return sum(_cell_width(c) for c in text)
 
 
@@ -45,6 +52,8 @@ def _str_pos_at_cells(line: str, cells: int) -> int:
     """
     if cells <= 0:
         return 0
+    if line.isascii():      # 1 cell per char → cell offset == string index
+        return min(cells, len(line))
     consumed = 0
     for i, ch in enumerate(line):
         if consumed >= cells:

{pyptt-2.2.6 → pyptt-2.2.7}/PyPtt.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPtt
-Version: 2.2.6
+Version: 2.2.7
 Summary: PyPtt github: https://github.com/PyPtt/PyPtt
 Author-email: CodingMan <pttcodingman@gmail.com>
 License: GNU Lesser General Public License v3 (LGPLv3)

{pyptt-2.2.6 → pyptt-2.2.7}/PyPtt.egg-info/SOURCES.txt

@@ -95,4 +95,5 @@ tests/test_search_user.py
 tests/test_service.py
 tests/test_set_board_title.py
 tests/test_set_signature_file.py
+tests/test_uao_codec.py
 tests/test_vt100_parser.py

pyptt-2.2.7/tests/test_uao_codec.py

@@ -0,0 +1,93 @@
+"""
+Regression tests for the vendored Big5-UAO codec (PyPtt/_uao).
+
+`_decode` batches ASCII runs (one C-level decode instead of a chr()/append per
+byte). These tests pin the invariant that the batched path produces exactly the
+same output as a naive byte-by-byte decode, across ASCII runs, character
+boundaries, incremental feeding and UAO-specific characters that stdlib `big5`
+gets wrong or cannot represent.
+"""
+
+import codecs
+
+import pytest
+
+import PyPtt.screens  # noqa: F401 — importing registers the big5uao codec
+
+
+def naive_decode(data: bytes, errors: str = 'replace') -> str:
+    """Reference: decode one unit at a time, no ASCII batching."""
+    from PyPtt._uao.b2u import b2u_table
+    get = b2u_table.get
+    out = []
+    i, n = 0, len(data)
+    while i < n:
+        c = data[i]
+        if c < 0x80:
+            out.append(chr(c))
+            i += 1
+            continue
+        pair = get(c * 0x100 + data[i + 1]) if i + 1 < n else None
+        if pair is not None:
+            out.append(pair)
+            i += 2
+            continue
+        single = get(c)
+        if single is not None:
+            out.append(single)
+            i += 1
+            continue
+        out.append('�')  # errors='replace'
+        i += 1
+    return ''.join(out)
+
+
+ASCII_CASES = [
+    b'',
+    b'hello world 12345',
+    b'   leading and trailing spaces   ',
+    b'[Ctrl-P] [d]delete [z]digest (100%)',
+]
+
+
+@pytest.mark.parametrize('data', ASCII_CASES)
+def test_ascii_runs_decode_verbatim(data):
+    assert data.decode('big5uao') == data.decode('ascii')
+
+
+def test_mixed_ascii_and_cjk():
+    s = '  9439   3 1/10 littrabble   ◎ [問題] 測試中文標題 discussion'
+    assert s.encode('big5uao').decode('big5uao') == s
+
+
+def test_uao_specific_characters_round_trip():
+    # Characters where stdlib big5 disagrees with UAO or can't encode them.
+    for s in ['‧', '～', '￥', '￠', '﹨', '⊕', '◎', '※', '←', '→', '─']:
+        assert s.encode('big5uao').decode('big5uao') == s
+
+
+@pytest.mark.parametrize('errors', ['replace', 'ignore', 'strict'])
+def test_batched_matches_naive_on_valid_content(errors):
+    s = '看板《Python》 test 混合 content 123 ‧～ ◎[軟工] tail'
+    data = s.encode('big5uao')
+    assert data.decode('big5uao', errors) == naive_decode(data)
+
+
+def test_incremental_byte_by_byte_matches_batch():
+    s = '批踢踢 Python 測試 ‧～￥ ◎[軟工] 12345'
+    data = s.encode('big5uao')
+    dec = codecs.getincrementaldecoder('big5uao')('replace')
+    out = ''.join(dec.decode(bytes([b])) for b in data) + dec.decode(b'', final=True)
+    assert out == data.decode('big5uao') == s
+
+
+def test_incremental_splits_multibyte_across_chunks():
+    data = '中文'.encode('big5uao')
+    dec = codecs.getincrementaldecoder('big5uao')('replace')
+    # Split inside the first character's byte pair.
+    out = dec.decode(data[:1]) + dec.decode(data[1:], final=True)
+    assert out == '中文'
+
+
+def test_lone_0xff_maps_to_uao_private_use():
+    assert b'\xff'.decode('big5uao') == ''