tamp 2.2.2__tar.gz → 2.2.4__tar.gz

{tamp-2.2.2 → tamp-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tamp
-Version: 2.2.2
+Version: 2.2.4
 Summary: 
 Home-page: https://github.com/BrianPugh/tamp
 License: Apache-2.0

{tamp-2.2.2 → tamp-2.2.4}/pyproject.toml

@@ -9,7 +9,7 @@ style = "semver"
 
 [tool.poetry]
 name = "tamp"
-version = "2.2.2"  # Do not change, let poetry-dynamic-versioning handle it.
+version = "2.2.4"  # Do not change, let poetry-dynamic-versioning handle it.
 homepage = "https://github.com/BrianPugh/tamp"
 repository = "https://github.com/BrianPugh/tamp"
 license = "Apache-2.0"
@@ -44,7 +44,7 @@ cli = ["cyclopts", "rich"]
 [tool.poetry.group.docs.dependencies]
 sphinx = ">=4.5.0"
 sphinx_rtd_theme = ">=3.0.0"
-gitpython = ">=3.1.49"
+gitpython = ">=3.1.50"
 sphinx-copybutton = ">=0.5.2"
 myst-parser = {extras = ["linkify"], version = "^3.0.1"}
 
@@ -61,7 +61,7 @@ matplotlib = ">=3.7.4"
 ipdb = ">=0.13.13"
 packaging = ">=26.1"
 mpremote = ">=1.20.0"
-cython = ">=0.29.34"
+cython = ">=3.2.5"
 pytest-subtests = ">=0.10.0"
 numpy = ">=1.24"
 pyelftools = "^0.32"

{tamp-2.2.2 → tamp-2.2.4}/tamp/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.2.2"
+__version__ = "2.2.4"
 
 
 class ExcessBitsError(Exception):

{tamp-2.2.2 → tamp-2.2.4}/tamp/_c_src/tamp/compressor.c

@@ -208,6 +208,9 @@ TAMP_OPTIMIZE_SIZE tamp_res tamp_compressor_init(TampCompressor* compressor, con
         // previous stream's trailing FLUSH, this triggers a dictionary reset.
         write_to_bit_buffer(compressor, FLUSH_CODE, 9);
         compressor->bit_buffer_pos = 16;
+        // This FLUSH is the most recently emitted token; mark it so an immediate
+        // redundant flush() doesn't append a second FLUSH and over-signal a reset.
+        compressor->last_was_flush = 1;
     } else {
         // Header byte 1: [window:3][literal:2][use_custom_dictionary:1][extended:1][more_headers:1]
         uint8_t header = ((conf->window - 8) << 5) | ((conf->literal - 5) << 3) | (conf->use_custom_dictionary << 2) |
@@ -491,6 +494,10 @@ TAMP_NOINLINE tamp_res tamp_compressor_poll(TampCompressor* compressor, unsigned
 
     if (TAMP_UNLIKELY(compressor->input_size == 0)) return TAMP_OK;
 
+    // Real data is being processed: any pending RLE/extended state drained by a
+    // later flush() was also created here, so the next FLUSH won't be "consecutive".
+    compressor->last_was_flush = 0;
+
     // Make sure there's enough room in the bit buffer.
     res = partial_flush(compressor, &output, &output_size, output_written_size);
     if (TAMP_UNLIKELY(res != TAMP_OK)) return res;
@@ -711,7 +718,14 @@ flush_check:
 flush_done:
     // At this point, up to 7 bits may remain in the compressor->bit_buffer
     // The output buffer may have 0 bytes remaining.
-    if (write_token && (compressor->bit_buffer_pos || compressor->conf.dictionary_reset)) {
+    // Suppress a redundant second consecutive FLUSH. Two FLUSH tokens with no data
+    // between them are the double-FLUSH dictionary-reset signal: a decompressor on a
+    // dictionary_reset stream would re-initialize its window, but THIS compressor's
+    // window is not reset here, desyncing the two and corrupting all later output.
+    // The sanctioned reset path, tamp_compressor_reset_dictionary(), clears
+    // last_was_flush before each flush so it can still emit the real double-FLUSH.
+    if (write_token && !compressor->last_was_flush &&
+        (compressor->bit_buffer_pos || compressor->conf.dictionary_reset)) {
         // We don't want to write the FLUSH token to the bit_buffer unless
         // we are confident that it'll wind up in the output buffer
         // in THIS function call.
@@ -719,6 +733,7 @@ flush_done:
         // end up accidentally writing multiple FLUSH tokens.
         if (TAMP_UNLIKELY(output_size < 2)) return TAMP_OUTPUT_FULL;
         write_to_bit_buffer(compressor, FLUSH_CODE, 9);
+        compressor->last_was_flush = 1;
     }
 
     // At this point, up to 16 bits may remain in the compressor->bit_buffer
@@ -787,6 +802,9 @@ TAMP_OPTIMIZE_SIZE tamp_res tamp_compressor_reset_dictionary(TampCompressor* com
     // FLUSH token even when bit_buffer_pos is 0.
     for (uint8_t i = 0; i < 2; i++) {
         size_t flush_written_size;
+        // Bypass the double-FLUSH suppression in flush(): here we *intend* to emit
+        // two consecutive FLUSH tokens, paired with the dictionary re-init below.
+        compressor->last_was_flush = 0;
         res = tamp_compressor_flush(compressor, output, output_size, &flush_written_size, true);
         *output_written_size += flush_written_size;
         if (TAMP_UNLIKELY(res != TAMP_OK)) return res;

{tamp-2.2.2 → tamp-2.2.4}/tamp/_c_src/tamp/compressor.h

@@ -23,6 +23,8 @@ typedef struct TampCompressor {
 
     /* WARM: read frequently, often cached in locals */
     uint8_t min_pattern_size;  // Minimum pattern size (2 bits used; 2 or 3)
+    uint8_t last_was_flush;    // 1 if the most recently emitted token was a FLUSH (no data since).
+                               // Suppresses an accidental double-FLUSH (a dictionary-reset signal).
     TampConf conf;
 #else   // Use bitfields for reduced memory-usage
     /* HOT: accessed every iteration of the compression loop */
@@ -53,6 +55,14 @@ typedef struct TampCompressor {
     uint8_t rle_count;             // Current RLE run length (max 241)
     uint8_t extended_match_count;  // Current extended match size (max ~134)
 #endif
+#if !TAMP_ESP32
+    // 1 if the most recently emitted token was a FLUSH (no data since); suppresses an
+    // accidental double-FLUSH (a dictionary-reset signal). Placed at the struct tail (in
+    // existing padding) so it does NOT shift the trailing fields above to higher offsets,
+    // which would push them out of Cortex-M0+ small load/store immediate range and bloat
+    // unrelated functions. The ESP32 variant keeps it inline (free in WARM-section padding).
+    uint8_t last_was_flush;
+#endif
 } TampCompressor;
 
 /**

{tamp-2.2.2 → tamp-2.2.4}/tamp/compressor.py

@@ -237,6 +237,9 @@ class Compressor:
             # trailing FLUSH, this triggers a dictionary reset in the decompressor.
             self._bit_writer.write(_FLUSH_CODE, 9, flush=False)
             self._bit_writer.bit_pos = 16  # Pad to 2 bytes (bits are already zero)
+            # This FLUSH is the most recently emitted token; mark it so an immediate
+            # redundant flush() doesn't append a second FLUSH and over-signal a reset.
+            self._last_was_flush = True
         else:
             # Write header
             self._bit_writer.write(window - 8, 3, flush=False)
@@ -265,6 +268,9 @@ class Compressor:
         self._extended_match_position = 0
         self._cached_match_index = -1
         self._cached_match_size = 0
+        # True if the most recently emitted token was a FLUSH with no data since.
+        # Suppresses an accidental double-FLUSH (a dictionary-reset signal).
+        self._last_was_flush = False
 
     def _validate_no_match_overlap(self, write_pos, match_index, match_size):
         """Check if writing a single byte will overlap with a future match section."""
@@ -276,6 +282,10 @@ class Compressor:
         if not self._input_buffer:
             return bytes_written
 
+        # Real data is being processed: any pending RLE/extended state drained by a
+        # later flush() was also created here, so the next FLUSH won't be "consecutive".
+        self._last_was_flush = False
+
         if self._extended_match_count:
             while self._input_buffer:
                 if (self._extended_match_position + self._extended_match_count) >= self._window_buffer.size:
@@ -567,8 +577,15 @@ class Compressor:
             self._cached_match_index = -1
             self._cached_match_size = 0
 
-        bytes_written_flush = self._bit_writer.flush(write_token=write_token, force_token=self.dictionary_reset)
-        bytes_written += bytes_written_flush
+        # Suppress a redundant second consecutive FLUSH. Two FLUSH tokens with no
+        # data between them are the double-FLUSH dictionary-reset signal: a
+        # decompressor on a dictionary_reset stream would re-initialize its window,
+        # but this compressor's window is not reset here, desyncing the two. The
+        # sanctioned reset path, reset_dictionary(), emits its FLUSH tokens directly.
+        emit_token = write_token and not self._last_was_flush
+        bytes_written += self._bit_writer.flush(write_token=emit_token, force_token=self.dictionary_reset)
+        if self._bit_writer._flush_token_written:
+            self._last_was_flush = True
         return bytes_written
 
     def reset_dictionary(self) -> int:
@@ -593,21 +610,15 @@ class Compressor:
 
         bytes_written = 0
 
-        # Flush all pending data with write_token=True.
-        bytes_written += self.flush(write_token=True)
-
-        # We need exactly 2 consecutive FLUSHes in the stream.
-        # If flush already wrote one, we need 1 more; otherwise 2.
-        flushes_needed = 1 if self._bit_writer._flush_token_written else 2
-        for _ in range(flushes_needed):
-            bytes_written += self._bit_writer.write(_FLUSH_CODE, 9)
-            # Pad to byte boundary
-            if self._bit_writer.bit_pos > 0:
-                byte = (self._bit_writer.buffer >> 24) & 0xFF
-                self._bit_writer.f.write(byte.to_bytes(1, "big"))
-                self._bit_writer.bit_pos = 0
-                self._bit_writer.buffer = 0
-                bytes_written += 1
+        # Write 2 FLUSH tokens for the double-FLUSH reset signal. The first drains
+        # any pending data. dictionary_reset being set guarantees flush() writes a
+        # FLUSH token even when the bit buffer is empty. Clearing _last_was_flush
+        # before each flush bypasses the double-FLUSH suppression in flush(): here
+        # we *intend* to emit two consecutive FLUSH tokens, paired with the
+        # dictionary re-init below. Mirrors tamp_compressor_reset_dictionary in C.
+        for _ in range(2):
+            self._last_was_flush = False
+            bytes_written += self.flush(write_token=True)
 
         # Re-initialize dictionary with default and reset all mutable state,
         # matching what the decompressor does on a double-FLUSH reset