serverish 1.4.2__tar.gz → 1.5.0__tar.gz

{serverish-1.4.2 → serverish-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: serverish
-Version: 1.4.2
+Version: 1.5.0
 Summary: helpers for server alike projects
 Home-page: https://github.com/AkondLab/serverish
 Author: Mikołaj Kałuszyński
@@ -26,6 +26,7 @@ Description-Content-Type: text/markdown
 * Singletons
 * Connections management and diagnostics
 * NATS based Messenger
+* Live documents - auto-updating configuration from NATS
 
 See [`doc` directory](doc/) for more documentation.
 
@@ -47,6 +48,7 @@ this will install `nats-py` package.
 - Pytest fixtures for NATS on CI
 
 ## Changes
+* 1.5 Introduces live documents (`LiveDocument`, `get_documentreader()`, `get_live_document()`) for auto-updating configuration from NATS.
 * 1.4 Contains improvements to the network problems recovery and connection tracking.
 * 1.1 Switches to `param` 2.* nad `py-nats` 1.7.*. Also, publisher may reraise exceptions or ignore them.
 * 1.0  Changes NATS subscriptions to pull only

{serverish-1.4.2 → serverish-1.5.0}/README.md

@@ -6,6 +6,7 @@
 * Singletons
 * Connections management and diagnostics
 * NATS based Messenger
+* Live documents - auto-updating configuration from NATS
 
 See [`doc` directory](doc/) for more documentation.
 
@@ -27,6 +28,7 @@ this will install `nats-py` package.
 - Pytest fixtures for NATS on CI
 
 ## Changes
+* 1.5 Introduces live documents (`LiveDocument`, `get_documentreader()`, `get_live_document()`) for auto-updating configuration from NATS.
 * 1.4 Contains improvements to the network problems recovery and connection tracking.
 * 1.1 Switches to `param` 2.* nad `py-nats` 1.7.*. Also, publisher may reraise exceptions or ignore them.
 * 1.0  Changes NATS subscriptions to pull only

{serverish-1.4.2 → serverish-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "serverish"
-version = "1.4.2"
+version = "1.5.0"
 description = "helpers for server alike projects"
 authors = ["Mikołaj Kałuszyński", "MMME team"]
 readme = "README.md"

{serverish-1.4.2 → serverish-1.5.0}/serverish/messenger/__init__.py

@@ -11,4 +11,6 @@ from .msg_progress_pub import get_progresspublisher, ProgressTask
 from .msg_progress_read import get_progressreader
 from .msg_journal_pub import get_journalpublisher, JournalEntry
 from .msg_journal_read import get_journalreader
+from .msg_document_read import get_documentreader, get_live_document, MsgDocumentReader
+from .live_document import LiveDocument
 from .logging import NatsJournalLoggingHandler

serverish-1.5.0/serverish/messenger/live_document.py

@@ -0,0 +1,300 @@
+"""Live document that auto-updates when underlying data changes.
+
+This module provides LiveDocument, a dict-like object that can be updated
+asynchronously and propagates changes through a hierarchical tree structure.
+"""
+
+import asyncio
+import copy
+import logging
+from collections.abc import Mapping
+from typing import Any, Callable, Iterator
+
+log = logging.getLogger(__name__)
+
+
+class LiveDocument(Mapping):
+    """A dict-like object that auto-updates when the underlying document changes.
+
+    Implements collections.abc.Mapping protocol for full dict compatibility.
+    Supports both dictionary-style and namespace-style access:
+        - doc['database']['host']  # dict-style
+        - doc.database.host         # namespace-style
+
+    LiveDocument creates cached subtrees for nested dicts, ensuring that
+    when the root document updates, all subtrees also update automatically.
+
+    Attributes:
+        _data: The underlying dictionary data (private)
+        _parent: Parent LiveDocument (None for root, private)
+        _path: Dot-separated path from root (e.g., "database.connection")
+        _children: Cached LiveDocument instances for dict values (private)
+        _callbacks: List of (callback, deep) tuples for change notifications (private)
+        _lock: Async lock for thread-safe updates (private)
+        _version: Incremented on each update (access as attribute, not property)
+        _reader: Reference to MsgDocumentReader for lifecycle management (private, root only)
+
+    Example:
+        >>> doc = LiveDocument({'database': {'host': 'localhost', 'port': 5432}})
+        >>> db = doc['database']  # Returns cached LiveDocument
+        >>> db.host  # Returns 'localhost'
+        >>> await doc._update({'database': {'host': 'newhost', 'port': 5432}})
+        >>> db.host  # Returns 'newhost' - subtree was updated!
+    """
+
+    def __init__(
+        self,
+        data: dict,
+        parent: 'LiveDocument | None' = None,
+        path: str = ''
+    ):
+        """Initialize a LiveDocument.
+
+        Args:
+            data: Dictionary data to wrap
+            parent: Parent LiveDocument if this is a subtree
+            path: Dot-separated path from root (e.g., "database.connection")
+        """
+        self._data = data
+        self._parent = parent
+        self._path = path
+        self._children: dict[str, LiveDocument] = {}
+        self._callbacks: list[tuple[Callable, bool]] = []
+        self._lock = asyncio.Lock()
+        self._version = 0
+        self._reader = None  # Will be set by get_live_document() for root document
+
+    # Mapping protocol implementation (required methods)
+
+    def __getitem__(self, key: str) -> Any:
+        """Get item - returns LiveDocument for dicts, raw value otherwise.
+
+        Args:
+            key: Dictionary key to retrieve
+
+        Returns:
+            LiveDocument for nested dicts, raw value otherwise
+
+        Raises:
+            KeyError: If key does not exist
+        """
+        value = self._data[key]
+        if isinstance(value, dict):
+            # Return CACHED LiveDocument - same instance every time
+            if key not in self._children:
+                new_path = f'{self._path}.{key}' if self._path else key
+                self._children[key] = LiveDocument(value, parent=self, path=new_path)
+            return self._children[key]
+        return value
+
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over keys.
+
+        Returns:
+            Iterator over dictionary keys
+        """
+        return iter(self._data)
+
+    def __len__(self) -> int:
+        """Number of keys.
+
+        Returns:
+            Number of keys in the document
+        """
+        return len(self._data)
+
+    # Additional dict-like methods (Mapping provides defaults, but we optimize)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get with default value.
+
+        Args:
+            key: Dictionary key to retrieve
+            default: Default value if key not found
+
+        Returns:
+            Value for key, or default if not found
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def __contains__(self, key: object) -> bool:
+        """Check if key exists.
+
+        Args:
+            key: Key to check
+
+        Returns:
+            True if key exists in the document
+        """
+        return key in self._data
+
+    # Namespace-like access
+
+    def __getattr__(self, key: str) -> Any:
+        """Enable doc.database.host syntax.
+
+        Args:
+            key: Attribute name to retrieve
+
+        Returns:
+            Value for the attribute
+
+        Raises:
+            AttributeError: If attribute does not exist
+        """
+        if key.startswith('_'):
+            # Private attributes - use normal lookup
+            return object.__getattribute__(self, key)
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{key}'"
+            ) from None
+
+    def __dir__(self):
+        """Return list of attributes for autocomplete/introspection.
+
+        Returns:
+            List of keys plus standard attributes
+        """
+        # Include both dict keys and standard attributes
+        return list(self._data.keys()) + [
+            attr for attr in object.__dir__(self)
+            if not attr.startswith('_')
+        ]
+
+    # Update mechanism
+
+    async def _update(self, new_data: dict):
+        """Update the document data and propagate to children.
+
+        This method is called internally when the document changes.
+        It updates the local data, propagates changes to all cached
+        children, and triggers any registered callbacks.
+
+        Args:
+            new_data: New dictionary data to replace current data
+        """
+        async with self._lock:
+            old_data = copy.deepcopy(self._data)
+            self._data = copy.deepcopy(new_data)
+            self._version += 1
+
+            # Update all cached children recursively
+            for key, child in list(self._children.items()):
+                if key in new_data and isinstance(new_data[key], dict):
+                    # Key still exists and is still a dict - update it
+                    await child._update(new_data[key])
+                elif key in new_data:
+                    # Key exists but is no longer a dict - remove from children
+                    # It will be recreated as needed
+                    del self._children[key]
+                else:
+                    # Key was removed - update child to empty dict
+                    await child._update({})
+
+            # Trigger callbacks
+            await self._trigger_callbacks(old_data, new_data)
+
+    # Callback support
+
+    def on_change(
+        self,
+        callback: Callable[[dict, dict], Any],
+        deep: bool = True
+    ) -> Callable:
+        """Register callback for changes in this subtree.
+
+        Args:
+            callback: Async function(old_value, new_value) -> None
+            deep: If True, trigger on any nested change; if False, only direct changes
+
+        Returns:
+            The callback (allows use as decorator)
+
+        Example:
+            >>> async def on_db_change(old, new):
+            ...     print(f"Database config changed: {old} -> {new}")
+            >>> doc.database.on_change(on_db_change)
+
+            Or as a decorator:
+            >>> @doc.database.on_change
+            ... async def on_db_change(old, new):
+            ...     print(f"Database config changed: {old} -> {new}")
+        """
+        self._callbacks.append((callback, deep))
+        return callback
+
+    def remove_callback(self, callback: Callable):
+        """Remove a registered callback.
+
+        Args:
+            callback: The callback function to remove
+        """
+        self._callbacks = [
+            (cb, deep) for cb, deep in self._callbacks
+            if cb != callback
+        ]
+
+    async def _trigger_callbacks(self, old_data: dict, new_data: dict):
+        """Trigger all registered callbacks.
+
+        Args:
+            old_data: Previous data value
+            new_data: New data value
+        """
+        for callback, deep in self._callbacks:
+            try:
+                # Check if callback is async
+                if asyncio.iscoroutinefunction(callback):
+                    await callback(old_data, new_data)
+                else:
+                    callback(old_data, new_data)
+            except Exception as e:
+                log.error(
+                    f"Callback error in {self._path or 'root'}: {e}",
+                    exc_info=True
+                )
+
+    # Utility methods
+
+    def to_dict(self) -> dict:
+        """Convert to a plain dictionary (deep copy).
+
+        Returns:
+            Deep copy of the underlying data
+        """
+        return copy.deepcopy(self._data)
+
+    def snapshot(self) -> 'LiveDocument':
+        """Create a point-in-time snapshot (not live).
+
+        Returns:
+            New LiveDocument with copied data, no parent/children links
+        """
+        return LiveDocument(copy.deepcopy(self._data))
+
+
+    # Representation
+
+    def __repr__(self) -> str:
+        """String representation.
+
+        Returns:
+            String representation of the document
+        """
+        if self._path:
+            return f"LiveDocument(path='{self._path}', data={self._data!r})"
+        return f"LiveDocument({self._data!r})"
+
+    def __str__(self) -> str:
+        """User-friendly string representation.
+
+        Returns:
+            String representation of the underlying data
+        """
+        return str(self._data)

{serverish-1.4.2 → serverish-1.5.0}/serverish/messenger/messenger.py

@@ -340,21 +340,36 @@ class Messenger(Singleton):
             deliver_policy (str): deliver policy, one of 'all', 'last', 'new', 'by_start_time', will be passed to consumer config
             opt_start_time (datetime): start time for 'by_start_time' deliver policy, will be passed to consumer config, must carry TZ info
             kwargs: additional arguments to pass to the reader and underlying NATS consumer config
+                    MsgReader-specific params (nowait, error_behavior, on_missed_messages) are extracted
+                    and passed directly to MsgReader; remaining params go to consumer_cfg
 
         Returns:
             MsgReader: message subscriber
 
         Usage:
-            reader = Messenger.get_reader('subject'):
+            reader = Messenger.get_reader('subject', nowait=True):
             async for msg in reader:
                 print(msg)
         """
         from serverish.messenger.msg_reader import MsgReader
+
+        # Extract MsgReader-specific parameters
+        reader_params = {}
+        consumer_cfg = {}
+        reader_param_names = {'nowait', 'error_behavior', 'on_missed_messages'}
+
+        for key, value in kwargs.items():
+            if key in reader_param_names:
+                reader_params[key] = value
+            else:
+                consumer_cfg[key] = value
+
         return MsgReader(subject=subject,
                          parent=Messenger(),
                          deliver_policy=deliver_policy,
                          opt_start_time=opt_start_time,
-                         consumer_cfg=kwargs)
+                         consumer_cfg=consumer_cfg,
+                         **reader_params)
 
     @staticmethod
     def get_singlepublisher(subject):
@@ -510,6 +525,37 @@ class Messenger(Singleton):
                                     deliver_policy=deliver_policy,
                                     **kwargs)
 
+    @staticmethod
+    def get_documentreader(subject: str,
+                          initial_wait: float = 5.0,
+                          **kwargs) -> 'MsgDocumentReader':
+        """Returns a document reader for a given subject
+
+        The document reader maintains a live document that auto-updates when
+        new versions are published to the subject. It reads the initial document
+        on open() and subscribes to updates in the background.
+
+        Args:
+            subject (str): subject to read from
+            initial_wait (float): timeout in seconds for initial document read
+            **kwargs: additional arguments to pass to the reader and underlying NATS consumer config
+
+        Returns:
+            MsgDocumentReader: a document reader for the given subject
+
+        Example:
+            reader = Messenger.get_documentreader('app.config')
+            await reader.open()
+            host = reader.document.database.host
+            await reader.close()
+
+        """
+        from serverish.messenger.msg_document_read import MsgDocumentReader
+        return MsgDocumentReader(subject=subject,
+                                parent=Messenger(),
+                                initial_wait=initial_wait,
+                                **kwargs)
+
 
 class MsgDriver(Manageable):
     subject: str = param.String(default=None, allow_None=True, doc="User subject to publish to, prefix may be added")

serverish-1.5.0/serverish/messenger/msg_document_read.py

@@ -0,0 +1,282 @@
+"""Document reader for live configuration documents.
+
+This module provides MsgDocumentReader, a specialized MsgReader that
+maintains a live document that auto-updates when new versions are published
+to NATS.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING
+
+import param
+
+from serverish.base import create_task
+from serverish.messenger.live_document import LiveDocument
+from serverish.messenger.msg_reader import MsgReader, MessengerReaderStopped
+
+if TYPE_CHECKING:
+    from serverish.base import Task
+    from serverish.base.manageable import Manageable
+
+log = logging.getLogger(__name__.rsplit('.')[-1])
+
+
+class MsgDocumentReader(MsgReader):
+    """Reads a document from NATS and keeps it updated.
+
+    This class extends MsgReader to provide a live document that automatically
+    updates when new versions are published to the NATS subject. It reads the
+    initial document on open() and then subscribes to updates in the background.
+
+    The document is exposed as a LiveDocument instance, supporting both
+    dict-style and namespace-style access.
+
+    Supports both explicit open/close and async context manager patterns.
+    Integrates with Manageable tree for automatic lifecycle management.
+
+    Attributes:
+        document: LiveDocument instance containing the current document state
+        initial_wait: Timeout (in seconds) for initial document read
+
+    Example:
+        # Explicit open/close
+        reader = get_documentreader('app.config')
+        await reader.open()
+        host = reader.document.database.host
+        await reader.close()
+
+        # Context manager
+        async with get_documentreader('app.config') as reader:
+            host = reader.document.database.host
+
+        # With parent for automatic lifecycle management
+        class MyService(Manageable):
+            async def open(self):
+                self.config_reader = await get_live_document('app.config', parent=self)
+                # Auto-closes when MyService closes
+    """
+
+    initial_wait = param.Number(
+        default=5.0,
+        bounds=(0, None),
+        doc="Timeout in seconds for initial document read on open()"
+    )
+
+    def __init__(
+        self,
+        subject: str,
+        parent: Manageable | None = None,
+        initial_wait: float = 5.0,
+        **kwargs
+    ):
+        """Initialize a document reader.
+
+        Args:
+            subject: NATS subject to read from
+            parent: Parent Manageable for lifecycle management
+            initial_wait: Timeout for initial document read (seconds)
+            **kwargs: Additional MsgReader options
+        """
+        # Force deliver_policy='last' to always get the most recent document
+        kwargs['deliver_policy'] = 'last'
+
+        super().__init__(subject=subject, parent=parent, **kwargs)
+
+        self.initial_wait = initial_wait
+        self.document = LiveDocument({})
+        self._update_task: Task | None = None
+        self._seq: int | None = None
+
+    async def open(self) -> None:
+        """Opens connection, reads initial document, starts update loop.
+
+        This method:
+        1. Opens the NATS subscription (via super().open())
+        2. Reads the initial document (with timeout)
+        3. Starts a background task that listens for updates
+
+        The background task is managed by the task manager and will
+        automatically be cancelled when this reader is closed or when
+        the parent Manageable is closed.
+
+        Raises:
+            asyncio.TimeoutError: If no initial document is available within initial_wait
+                Note: The error is logged but not raised; continues with empty document
+        """
+        await super().open()
+
+        # Initial read - wait for first document
+        try:
+            data, meta = await asyncio.wait_for(
+                self.read_next(),
+                timeout=self.initial_wait
+            )
+            await self.document._update(data)
+            self._seq = meta['nats']['seq']
+            log.info(f"Document loaded from {self.subject}: seq={self._seq}")
+        except asyncio.TimeoutError:
+            log.warning(
+                f"No initial document found on {self.subject} "
+                f"after {self.initial_wait}s, starting with empty document"
+            )
+            # Continue with empty document - updates will populate it later
+
+        # Start background update loop via task manager
+        # Task is tracked by TaskManager and can be cancelled via close()
+        self._update_task = await create_task(
+            self._update_loop(),
+            name=f"doc_update_{self.subject}"
+        )
+
+    async def _update_loop(self):
+        """Background task that listens for document updates.
+
+        This async task runs in the background after open() and continuously
+        listens for new document versions published to the NATS subject.
+
+        It handles:
+        - Reading new messages as they arrive
+        - Deduplication via sequence numbers
+        - Propagating updates to the LiveDocument
+        - Graceful shutdown on cancellation or stop signal
+        """
+        try:
+            async for data, meta in self:
+                new_seq = meta['nats']['seq']
+
+                # Skip duplicates or old versions
+                if self._seq and new_seq <= self._seq:
+                    log.debug(
+                        f"Skipping duplicate/old document: "
+                        f"current seq={self._seq}, received seq={new_seq}"
+                    )
+                    continue
+
+                log.info(
+                    f"Document updated on {self.subject}: "
+                    f"{self._seq} -> {new_seq}"
+                )
+                await self.document._update(data)
+                self._seq = new_seq
+
+        except MessengerReaderStopped:
+            log.info(f"Document reader stopped for {self.subject}")
+        except asyncio.CancelledError:
+            log.info(f"Document reader cancelled for {self.subject}")
+            raise  # Re-raise for task manager
+        except Exception as e:
+            log.error(
+                f"Document update loop error for {self.subject}: {e}",
+                exc_info=True
+            )
+
+    async def close(self):
+        """Stops update loop and closes connection.
+
+        Task manager handles cancellation automatically, but we clean up
+        explicitly to ensure proper shutdown order.
+        """
+        if self._update_task and not self._update_task.done():
+            self._update_task.cancel()
+            try:
+                await self._update_task
+            except asyncio.CancelledError:
+                pass
+
+        await super().close()
+
+    # Async context manager support
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.open()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.close()
+        return False
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return (
+            f"MsgDocumentReader(subject='{self.subject}', "
+            f"seq={self._seq}, version={self.document._version})"
+        )
+
+
+def get_documentreader(
+    subject: str,
+    initial_wait: float = 5.0,
+    **kwargs
+) -> MsgDocumentReader:
+    """Returns a document reader for the given subject.
+
+    This is a convenience function that creates a MsgDocumentReader instance.
+    The reader must be explicitly opened before use.
+
+    Args:
+        subject: NATS subject to read from
+        initial_wait: Timeout for initial document read (seconds)
+        **kwargs: Additional MsgReader options
+
+    Returns:
+        MsgDocumentReader: A document reader (not yet opened)
+
+    Example:
+        reader = get_documentreader('app.config')
+        await reader.open()
+        host = reader.document.database.host
+        await reader.close()
+    """
+    from serverish.messenger import Messenger
+
+    return Messenger.get_documentreader(
+        subject=subject,
+        initial_wait=initial_wait,
+        **kwargs
+    )
+
+
+async def get_live_document(
+    subject: str,
+    wait: float = 5.0,
+    **kwargs
+) -> LiveDocument:
+    """Get a live document (already opened and auto-updating).
+
+    This is a convenience function similar to single_read() but for live documents.
+    It creates and opens a MsgDocumentReader, then returns the LiveDocument itself.
+    The reader is attached to the document for lifecycle management (garbage collection).
+
+    The reader's lifecycle is managed by serverish task manager. When the document
+    is garbage collected, the reader will be cleaned up automatically.
+
+    Args:
+        subject: NATS subject to read from
+        wait: Timeout for initial document read (seconds)
+        **kwargs: Additional MsgReader options
+
+    Returns:
+        LiveDocument: The live document (dict-like, auto-updates)
+
+    Example:
+        # Simple usage - similar to single_read()
+        config = await get_live_document('app.config')
+        host = config.database.host  # Auto-updates when republished!
+
+        # Access the reader if needed (for explicit close)
+        config = await get_live_document('app.config')
+        # ... use config ...
+        await config._reader.close()  # Explicit cleanup if needed
+    """
+    reader = get_documentreader(subject, initial_wait=wait, **kwargs)
+    await reader.open()
+
+    # Attach reader to document for lifecycle management
+    reader.document._reader = reader
+
+    return reader.document

{serverish-1.4.2 → serverish-1.5.0}/serverish/messenger/msg_reader.py

@@ -76,7 +76,6 @@ class MsgReader(MsgDriver):
                  deliver_policy = 'all',
                  opt_start_time = None,
                  consumer_cfg=None,
-                 nowait: bool = False,
                  **kwargs) -> None:
         if parent is None:
             parent = Messenger()
@@ -245,30 +244,32 @@ class MsgReader(MsgDriver):
             @async_shield
             async def read_batch(self) -> None:
                 if len(self.reader.messages) == 0:
-                    timeout = 100.0 # min(0.1 + self.n/10.0, 5.0)
-                    # batch = 1 if self.error is not None else 100 # recover slowly
-                    log.debug(self.fmt(f"Pulling {self.reader.batch} messages with timeout {timeout}s"))
-                    new_msgs = await self.reader.fetch_available(batch=self.reader.batch, timeout=timeout)
+                    # For fetch_available, timeout is network latency budget (not message wait time)
+                    # Server responds immediately with no_wait=True, we just account for slow networks
+                    fetch_timeout = 2.0  # Reduced - should be quick with no_wait
+                    log.debug(self.fmt(f"Pulling {self.reader.batch} messages with timeout {fetch_timeout}s"))
+                    new_msgs = await self.reader.fetch_available(batch=self.reader.batch, timeout=fetch_timeout)
                     log.debug(self.fmt(f"Pulled {len(new_msgs)} messages"))
 
-                    # If no messages were available immediately, switch to blocking mode
-                    # to wait for at least one message more efficiently
+                    # If no messages were available (got 404 from server or timeout), decide what to do
                     if len(new_msgs) == 0:
                         if self.reader.nowait:
-                            log.debug(self.fmt(f"No new messages found, finishing due to nowait"))
+                            # Server confirmed no messages - finish iteration
+                            log.debug(self.fmt(f"No messages available, finishing due to nowait"))
                             raise self.EndIterationException('nowait')
 
-                        log.debug(self.fmt(f"No messages available immediately, waiting for at least one message with timeout {timeout:0.1f}s"))
+                        # Non-nowait mode: wait for NEW messages to arrive
+                        blocking_timeout = 100.0
+                        log.debug(self.fmt(f"No messages currently available, waiting for new messages (timeout {blocking_timeout}s)"))
 
-                        # Use the regular fetch operation from nats (which blocks)
+                        # Use the regular fetch operation which waits for messages to arrive
                         try:
-                            new_msgs = await self.reader.pull_subscription.fetch(1, timeout=timeout)
-                            log.debug(self.fmt(f"Received {len(new_msgs)} message while blocking waiting"))
+                            new_msgs = await self.reader.pull_subscription.fetch(1, timeout=blocking_timeout)
+                            log.debug(self.fmt(f"Received {len(new_msgs)} new message(s)"))
                         except asyncio.TimeoutError:
-                            log.debug(self.fmt(f"No meesge before timeout"))
+                            log.debug(self.fmt(f"No new messages arrived within {blocking_timeout}s"))
                         except Exception as e:
                             log.warning(self.fmt(f"Error waiting for messages: {e}"))
-                    # fi : no messages available immediately
 
                     self.reader.messages.extend(new_msgs)
 
@@ -346,21 +347,30 @@ class MsgReader(MsgDriver):
         # end while
 
 
-    async def fetch_available(self, batch=10, timeout = 0.1):
-        """[NATS fix] Fetch only immediately available messages without blocking
+    async def fetch_available(self, batch=10, timeout=2.0):
+        """[NATS fix] Fetch only immediately available messages without blocking for new messages
 
-        Path on lack of functionality of JetStreamContext.PullSubscription.fetch
-        By default uses only very short timeout to account for network latency
+        Uses no_wait=True protocol:
+        - Server sends available messages immediately
+        - Server sends 404 status if no messages exist
+        - We wait for server response (network latency) but not for new messages to arrive
+
+        Args:
+            batch: Maximum number of messages to fetch
+            timeout: Network latency budget (default 2s for local/fast networks)
+                     NOT a "wait for messages" timeout - server won't wait
+
+        Returns:
+            List of messages that were immediately available on server
         """
         import json
 
         pull_subscription = self.pull_subscription
-        # Get from internal queue first
         msgs = []
         needed = batch
         queue = pull_subscription._sub._pending_queue
 
-        # First get messages from the internal queue
+        # First, drain messages already in local queue
         while not queue.empty() and needed > 0:
             try:
                 msg = queue.get_nowait()
@@ -369,14 +379,15 @@ class MsgReader(MsgDriver):
                 if not status:  # Skip status messages
                     msgs.append(msg)
                     needed -= 1
+                queue.task_done()
             except Exception:
                 pass
 
-        # If we already have enough messages, return early
+        # If we got enough from queue, return immediately
         if needed == 0:
             return msgs
 
-        # Make one no_wait request to get immediately available messages
+        # Send pull request: no_wait=True means server responds immediately
         next_req = {"batch": needed, "no_wait": True}
         await pull_subscription._nc.publish(
             pull_subscription._nms,
@@ -384,26 +395,74 @@ class MsgReader(MsgDriver):
             pull_subscription._deliver,
         )
 
+        # Wait for server response (messages and/or 404 status)
+        # The server will respond quickly because no_wait=True
+        # We just need to account for network latency
         start_time = time.monotonic()
+        got_404_status = False
+        got_any_message = False
 
-        # Process the response with a very short timeout
-        while needed > 0:
+        while not got_404_status:
             deadline = timeout - (time.monotonic() - start_time)
             if deadline <= 0:
+                # Timeout - if we got some messages, that's OK (server might not send 404 after exact batch)
+                # If we got nothing, this is a network problem
+                if not got_any_message and len(msgs) == 0:
+                    log.warning(f"{self} Timeout after {timeout}s waiting for server response (network issue?)")
+                else:
+                    log.debug(f"{self} Timeout after getting {len(msgs)} messages (no 404 received)")
                 break
 
             try:
-                msg = await self.next_msg(timeout=0.0) # nonblocking here
+                # Wait for server to respond (messages or 404)
+                msg = await asyncio.wait_for(queue.get(), timeout=deadline)
+                pull_subscription._sub._pending_size -= len(msg.data)
+                queue.task_done()
+
                 status = JetStreamContext.is_status_msg(msg)
-                if not status:
+
+                if status == "404":
+                    # Server says: no (more) messages available
+                    # This is the definitive "done" signal
+                    log.debug(f"{self} Server confirmed no more messages (404 status)")
+                    got_404_status = True
+                    break
+                elif status == "408":
+                    # Request Timeout - server gave us what it had but couldn't fill batch
+                    # This is effectively "no more messages available right now"
+                    log.debug(f"{self} Server returned partial batch (408 status - request timeout)")
+                    got_404_status = True  # Treat same as 404 - no more messages available
+                    break
+                elif status:
+                    # Other status message (shouldn't happen with pull, but handle it)
+                    log.debug(f"{self} Received status: {status}")
+                    continue
+                else:
+                    # Real message
                     msgs.append(msg)
+                    got_any_message = True
                     needed -= 1
-                elif status == "404":  # NO_MESSAGES
-                    break
+
+                    # If we got all requested messages, give server very short time to send 404
+                    # but don't wait long - likely there are more messages
+                    if needed == 0:
+                        # Very short grace period for 404 status (100ms)
+                        # If 404 doesn't arrive, we'll just fetch again on next iteration
+                        remaining_time = timeout - (time.monotonic() - start_time)
+                        if remaining_time > 0.1:
+                            deadline = 0.1
+                            timeout = time.monotonic() - start_time + 0.1  # Update timeout to exit on next deadline check
+
             except asyncio.TimeoutError:
+                # Timeout after getting messages is OK - server might not send 404 if we got exact batch
+                if got_any_message or len(msgs) > 0:
+                    log.debug(f"{self} Got {len(msgs)} messages, no 404 status (normal for exact batch)")
+                else:
+                    # No messages at all - this could be empty subject or network problem
+                    log.debug(f"{self} No messages or 404 within {timeout}s")
                 break
-            except asyncio.QueueEmpty:
-                log.debug(f"{self} Queue is empty")
+            except Exception as e:
+                log.warning(f"{self} Error in fetch_available: {e}")
                 break
 
         return msgs
@@ -540,6 +599,13 @@ class MsgReader(MsgDriver):
 
     async def _create_consumer_cfg(self) -> ConsumerConfig:
         cfg = self.consumer_cfg.copy()
+
+        # Remove MsgReader-specific parameters that are not part of ConsumerConfig
+        # These are handled by MsgReader itself, not passed to NATS
+        reader_params = ['nowait', 'error_behavior', 'on_missed_messages']
+        for param in reader_params:
+            cfg.pop(param, None)
+
         # Convert the delivery policy from a string to the appropriate DeliverPolicy enum
         if self.deliver_policy is not None:
             cfg['deliver_policy'] = DeliverPolicy(self.deliver_policy)