drb 2.6.2__tar.gz → 2.7.0__tar.gz

{drb-2.6.2/drb.egg-info → drb-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drb
-Version: 2.6.2
+Version: 2.7.0
 Summary: Data Request Broker
 Author: GAEL Systems
 Author-email: drb-python@gael.fr

{drb-2.6.2 → drb-2.7.0}/drb/core/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2026-07-04T01:16:50+0000",
+ "date": "2026-07-04T08:23:09+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "922738f837cc758574aea56aa913ef07bc4b45fa",
- "version": "2.6.2"
+ "full-revisionid": "41b7207a532b8d24d4a0edac7129dff08e02d789",
+ "version": "2.7.0"
 }
 '''  # END VERSION_JSON
 

drb-2.7.0/drb/utils/io.py

@@ -0,0 +1,206 @@
+"""Generic, dependency-light seekable-stream helpers for lazy partial reads.
+
+These are DRB-model-free: they operate on plain binary streams so any driver
+can compose them without importing driver types.
+"""
+import io
+from collections import OrderedDict
+from typing import Callable, Tuple
+
+
+class SeekableWindow(io.RawIOBase):
+    """A read-only seekable view over a byte range of a parent seekable stream.
+
+    Exposes ``parent[offset:offset + length]`` as a standalone stream
+    positioned at 0. ``parent`` must be seekable. By default closing the window
+    closes ``parent`` too (set ``close_parent=False`` to keep it open).
+    """
+
+    def __init__(self, parent, offset: int, length: int,
+                 close_parent: bool = True):
+        super().__init__()
+        self._parent = parent
+        self._offset = offset
+        self._length = length
+        self._pos = 0
+        self._close_parent = close_parent
+
+    def readable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return True
+
+    def seek(self, pos: int, whence: int = io.SEEK_SET) -> int:
+        if whence == io.SEEK_SET:
+            new = pos
+        elif whence == io.SEEK_CUR:
+            new = self._pos + pos
+        elif whence == io.SEEK_END:
+            new = self._length + pos
+        else:
+            raise ValueError(f'invalid whence: {whence}')
+        if new < 0:
+            raise OSError('negative seek position')
+        self._pos = new
+        return self._pos
+
+    def tell(self) -> int:
+        return self._pos
+
+    def read(self, size: int = -1) -> bytes:
+        remaining = self._length - self._pos
+        if remaining <= 0:
+            return b''
+        if size is None or size < 0:
+            size = remaining
+        size = min(size, remaining)
+        if size == 0:
+            return b''
+        self._parent.seek(self._offset + self._pos)
+        data = self._parent.read(size)
+        self._pos += len(data)
+        return data
+
+    def readinto(self, b: bytearray) -> int:
+        data = self.read(len(b))
+        n = len(data)
+        b[:n] = data
+        return n
+
+    def close(self) -> None:
+        if not self.closed and self._close_parent:
+            self._parent.close()
+        super().close()
+
+
+class BlockCache:
+    """A bounded LRU cache of fixed-size byte blocks, shared across streams.
+
+    Blocks are keyed by ``(source_id, index)`` and are ``block_size`` bytes
+    each (the last block of a source may be shorter). Total residency is
+    bounded by ``max_bytes``; least-recently-used blocks are evicted first.
+    """
+
+    def __init__(self, block_size: int = 1 << 20,
+                 max_bytes: int = 64 << 20):
+        self.block_size = block_size
+        self.max_bytes = max_bytes
+        self._blocks: 'OrderedDict[Tuple[str, int], bytes]' = OrderedDict()
+        self._total = 0
+
+    def total_bytes(self) -> int:
+        return self._total
+
+    def get_block(self, source_id: str, index: int,
+                  fetch: Callable[[int, int], bytes]) -> bytes:
+        key = (source_id, index)
+        block = self._blocks.get(key)
+        if block is not None:
+            self._blocks.move_to_end(key)
+            return block
+        block = fetch(index * self.block_size, self.block_size)
+        self._blocks[key] = block
+        self._total += len(block)
+        self._evict()
+        return block
+
+    def _evict(self) -> None:
+        while self._total > self.max_bytes and len(self._blocks) > 1:
+            _, block = self._blocks.popitem(last=False)
+            self._total -= len(block)
+
+
+class BlockCacheStream(io.RawIOBase):
+    """A seekable read-only stream serving ``parent`` through a ``BlockCache``.
+
+    ``parent`` must be seekable; ``size`` is its total byte length. Reads are
+    assembled from fixed-size blocks fetched (once) from ``parent`` and cached
+    in the shared ``cache`` under ``source_id``.
+    """
+
+    def __init__(self, parent, source_id: str, size: int,
+                 cache: BlockCache):
+        super().__init__()
+        self._parent = parent
+        self._sid = source_id
+        self._size = size
+        self._cache = cache
+        self._pos = 0
+
+    def readable(self) -> bool:
+        return True
+
+    def seekable(self) -> bool:
+        return True
+
+    def seek(self, pos: int, whence: int = io.SEEK_SET) -> int:
+        if whence == io.SEEK_SET:
+            new = pos
+        elif whence == io.SEEK_CUR:
+            new = self._pos + pos
+        elif whence == io.SEEK_END:
+            new = self._size + pos
+        else:
+            raise ValueError(f'invalid whence: {whence}')
+        if new < 0:
+            raise OSError('negative seek position')
+        self._pos = new
+        return self._pos
+
+    def tell(self) -> int:
+        return self._pos
+
+    def _fetch(self, offset: int, length: int) -> bytes:
+        self._parent.seek(offset)
+        return self._parent.read(length)
+
+    def read(self, size: int = -1) -> bytes:
+        remaining = self._size - self._pos
+        if remaining <= 0:
+            return b''
+        if size is None or size < 0:
+            size = remaining
+        size = min(size, remaining)
+        out = bytearray()
+        bs = self._cache.block_size
+        while size > 0:
+            index = self._pos // bs
+            block = self._cache.get_block(self._sid, index, self._fetch)
+            start = self._pos - index * bs
+            piece = block[start:start + size]
+            if not piece:
+                break
+            out += piece
+            self._pos += len(piece)
+            size -= len(piece)
+        return bytes(out)
+
+    def readinto(self, b: bytearray) -> int:
+        data = self.read(len(b))
+        n = len(data)
+        b[:n] = data
+        return n
+
+    def close(self) -> None:
+        if not self.closed:
+            self._parent.close()
+        super().close()
+
+
+def get_shared_cache(context: 'Context') -> BlockCache:
+    """Return the ``BlockCache`` stored in ``context``'s ``'cache'`` bucket,
+    creating it on first access.
+
+    This function is not resolver-specific: it merely gets-or-creates the
+    cache on whatever ``Context`` object is passed in. The actual sharing
+    scope is determined entirely by the caller — e.g. passing the same
+    archive node's context for every member of an archive shares one cache
+    across them.
+    """
+    bucket = context['cache']
+    cache = bucket.get('blocks')
+    if cache is None:
+        cache = BlockCache()
+        bucket['blocks'] = cache
+    return cache

{drb-2.6.2 → drb-2.7.0/drb.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drb
-Version: 2.6.2
+Version: 2.7.0
 Summary: Data Request Broker
 Author: GAEL Systems
 Author-email: drb-python@gael.fr

{drb-2.6.2 → drb-2.7.0}/drb.egg-info/SOURCES.txt

@@ -59,6 +59,7 @@ drb/topics/xml/__init__.py
 drb/topics/xml/cortex.ttl
 drb/utils/__init__.py
 drb/utils/drb_python_script.py
+drb/utils/io.py
 drb/utils/plugins.py
 drb/utils/url_security.py
 drb/utils/utils.py