vcdiff-decoder 0.1.0__tar.gz → 0.2.0__tar.gz

{vcdiff_decoder-0.1.0 → vcdiff_decoder-0.2.0}/PKG-INFO

@@ -1,8 +1,7 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: vcdiff-decoder
-Version: 0.1.0
+Version: 0.2.0
 Summary: Python implementation of VCDIFF (RFC 3284) delta compression format
-Home-page: https://ably.com
 License: Apache-2.0
 Author: Ably
 Author-email: support@ably.com
@@ -20,6 +19,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Project-URL: Homepage, https://ably.com
 Project-URL: Repository, https://github.com/ably/vcdiff-python
 Description-Content-Type: text/markdown
 

{vcdiff_decoder-0.1.0 → vcdiff_decoder-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "vcdiff-decoder"
-version = "0.1.0"
+version = "0.2.0"
 description = "Python implementation of VCDIFF (RFC 3284) delta compression format"
 readme = "README.md"
 license = "Apache-2.0"

{vcdiff_decoder-0.1.0 → vcdiff_decoder-0.2.0}/vcdiff_decoder/__init__.py

@@ -28,7 +28,7 @@ from .exceptions import (
 )
 from .types import InstructionType
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"
 __all__ = [
     "Decoder",
     "decode",

{vcdiff_decoder-0.1.0 → vcdiff_decoder-0.2.0}/vcdiff_decoder/addresscache.py

@@ -11,18 +11,19 @@ from .exceptions import VCDIFFError
 class AddressCache:
     """Manages address encoding/decoding for COPY instructions"""
     
-    def __init__(self, near_size: int, same_size: int):
+    def __init__(self, near_size: int, same_blocks: int):
         """Initialize address cache with specified sizes
         
         Args:
-            near_size: Size of the "near" address cache (typically 4)
-            same_size: Size of the "same" address cache (typically 3 * 256)
+            near_size: s_near, the number of slots in the "near" cache (typically 4)
+            same_blocks: s_same, the number of 256-slot blocks in the "same" cache
+                (typically 3, so the cache holds 768 addresses)
         """
         self.near_size = near_size
-        self.same_size = same_size
+        self.same_blocks = same_blocks
         self.near: List[int] = [0] * near_size
         self.next_near_slot = 0
-        self.same: List[int] = [0] * (same_size * 256)
+        self.same: List[int] = [0] * (same_blocks * 256)
         self.address_stream: BinaryIO = io.BytesIO()
     
     def reset(self, addresses: bytes) -> None:
@@ -54,7 +55,7 @@ class AddressCache:
             The decoded address
             
         Raises:
-            VCDIFFError: If the addressing mode is invalid or cache is uninitialized
+            VCDIFFError: If the addressing mode is invalid
         """
         # Validate addressing mode
         if mode > 8:
@@ -72,19 +73,18 @@ class AddressCache:
         else:
             # Near cache or same cache modes
             if mode - 2 < self.near_size:
-                # Near cache
+                # Near cache. Both caches are zero filled at the start of a window
+                # (RFC 3284 section 5.1), so 0 is an ordinary cached address here.
                 cache_index = mode - 2
-                if self.near[cache_index] == 0:
-                    raise VCDIFFError(f"near cache slot {cache_index} is uninitialized")
                 offset = read_varint(self.address_stream)
                 addr = self.near[cache_index] + offset
             else:
                 # Same cache
                 m = mode - (2 + self.near_size)
-                if m >= self.same_size:
+                if m >= self.same_blocks:
                     raise VCDIFFError(
                         f"same cache mode {mode} exceeds available slots "
-                        f"(max {2 + self.near_size + self.same_size - 1})"
+                        f"(max {2 + self.near_size + self.same_blocks - 1})"
                     )
                 
                 byte_data = self.address_stream.read(1)
@@ -107,5 +107,6 @@ class AddressCache:
             self.near[self.next_near_slot] = address
             self.next_near_slot = (self.next_near_slot + 1) % self.near_size
         
-        if self.same_size > 0:
-            self.same[address % (self.same_size * 256)] = address
+        if self.same_blocks > 0:
+            # RFC 3284 section 5.1: the slot with index addr % (s_same * 256)
+            self.same[address % len(self.same)] = address

{vcdiff_decoder-0.1.0 → vcdiff_decoder-0.2.0}/vcdiff_decoder/decoder.py

@@ -8,7 +8,7 @@ from .types import (
     VCDIFF_MAGIC, VCDIFF_VERSION, MINIMUM_FILE_SIZE,
     VCD_DECOMPRESS, VCD_CODETABLE, VCD_APPHEADER,
     VCD_SOURCE, VCD_TARGET, VCD_ADLER32,
-    NEAR_CACHE_SIZE, SAME_CACHE_SIZE
+    NEAR_CACHE_SIZE, SAME_CACHE_BLOCKS
 )
 from .exceptions import (
     VCDIFFError, InvalidMagicError, InvalidVersionError, InvalidFormatError,
@@ -71,7 +71,7 @@ class Decoder:
             VCDIFFError: If the window cannot be decoded
         """
         # Initialize address cache
-        address_cache = AddressCache(NEAR_CACHE_SIZE, SAME_CACHE_SIZE)
+        address_cache = AddressCache(NEAR_CACHE_SIZE, SAME_CACHE_BLOCKS)
         address_cache.reset(window.address_section)
         
         # Create target buffer
@@ -281,7 +281,7 @@ def parse_delta(delta: Union[bytes, bytearray]) -> ParsedDelta:
         parsed.windows.append(window)
         
         # Create address cache for this window
-        address_cache = AddressCache(NEAR_CACHE_SIZE, SAME_CACHE_SIZE)
+        address_cache = AddressCache(NEAR_CACHE_SIZE, SAME_CACHE_BLOCKS)
         address_cache.reset(window.address_section)
         
         # Parse instructions using the instruction section and data section

{vcdiff_decoder-0.1.0 → vcdiff_decoder-0.2.0}/vcdiff_decoder/types.py

@@ -38,9 +38,9 @@ ADD_INSTRUCTION_MAX = 161  # ADD instructions: 18-161
 COPY_INSTRUCTION_MIN = 162 # COPY instructions: 162-255
 COPY_INSTRUCTION_MAX = 255 # COPY instructions: 162-255
 
-# Address cache configuration - RFC 3284 Section 5.3
-NEAR_CACHE_SIZE = 4         # Size of "near" address cache
-SAME_CACHE_SIZE = 3 * 256   # Size of "same" address cache
+# Address cache configuration - RFC 3284 Section 5.1
+NEAR_CACHE_SIZE = 4         # s_near: number of slots in the "near" address cache
+SAME_CACHE_BLOCKS = 3       # s_same: the "same" address cache holds s_same * 256 slots
 INSTRUCTION_TABLE_SIZE = 256 # Size of instruction code table
 
 # File format validation constants