fix(ex_app): bridge sync logger and model-fetch task to async NextcloudApp

After Phase 2 made ``NextcloudApp.log`` and ``NextcloudApp.set_init_status`` async,
two ExApp helpers kept calling them as if they were sync — silently producing
``RuntimeWarning: coroutine '...' was never awaited`` and dropping the operation
entirely. ``setup_nextcloud_logging`` is supposed to stream every Python log
record into ``nextcloud.log``, and ``fetch_models_task`` is the default ``/init``
handler that reports model-download progress back to AppAPI; both were no-ops.

logger.py
  * Capture the running event loop at ``setup_nextcloud_logging`` time and stash
    it on the handler. ``logging.Handler.emit`` is sync and can be called from
    any thread, so each record is dispatched to the captured loop with
    ``asyncio.run_coroutine_threadsafe``. Fire-and-forget, since logging must
    not block the caller. If the function is invoked outside a running loop
    (no-async setup), an inert handler is installed.

integration_fastapi.py
  * ``fetch_models_task`` gains an optional ``loop`` parameter and is wrapped
    by a small ``_ProgressReporter`` that schedules ``set_init_status`` on the
    captured loop and waits with a 30s timeout for ordered progress updates.
  * The ``/init`` handler now captures ``asyncio.get_running_loop()`` and
    forwards it to the BackgroundTasks worker thread, where there is no loop
    of its own.
  * Inner ``__fetch_model_as_file`` / ``__fetch_model_as_snapshot`` accept the
    reporter callable in place of the bare ``NextcloudApp`` and use it for
    every progress tick.

Bumps the version to 0.31.0.dev0 and adds a CHANGELOG entry covering the breaking
sync removal, these regressions, and the conftest event-loop reset.

Author: Review

CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.31.0 - Unreleased]
+
+### Removed (BREAKING)
+
+- All synchronous API classes: `Nextcloud`, `NextcloudApp`, `TalkBot`, `nc_app`, `talk_bot_msg`, sync `enabled_handler`/`trigger_handler` in `set_handlers`, and the `FilesAPI`/`_TalkAPI`/etc. sync counterparts. The async classes (`AsyncNextcloud`, `AsyncNextcloudApp`, `AsyncTalkBot`, `anc_app`, `atalk_bot_msg`, …) are now the only implementation and have been renamed to drop the `Async` prefix; their sync namesakes were deprecated in v0.30.0 and have now been deleted. Backward-compat aliases (`AsyncNextcloud = Nextcloud`, etc.) are still exported and will be removed in v1.0.0.
+- The `caldav` integration is no longer reachable through `Nextcloud.cal` / `NextcloudApp.cal`; the underlying library is sync-only.
+
+### Fixed
+
+- ExApp logger handler (`setup_nextcloud_logging`) now actually delivers records to Nextcloud: the sync `logging.Handler.emit` schedules the now-async `NextcloudApp.log` on the captured event loop via `asyncio.run_coroutine_threadsafe`. Without this fix the coroutine was never awaited and log records were silently dropped.
+- `fetch_models_task` (used by the default `/init` handler) no longer leaves `NextcloudApp.set_init_status` coroutines unawaited; progress updates are dispatched onto the main event loop from the `BackgroundTasks` worker thread.
+- Test conftest resets `niquests` session adapters after the import-time capability/version probe so pytest-asyncio's loop populates fresh connection pools, preventing `RuntimeError: got Future <Future pending> attached to a different loop` on the first request.
+
 ## [0.30.1 - 2026-04-26]
 
 ### Added

nc_py_api/_version.py

@@ -1,3 +1,3 @@
 """Version of nc_py_api."""
 
-__version__ = "0.30.1"
+__version__ = "0.31.0.dev0"

nc_py_api/ex_app/integration_fastapi.py

@@ -1,5 +1,6 @@
 """FastAPI directly related stuff."""
 
+import asyncio
 import builtins
 import fnmatch
 import hashlib
@@ -108,7 +109,8 @@ async def heartbeat_callback():
 
         @fast_api_app.post("/init")
         async def init_callback(b_tasks: BackgroundTasks, nc: typing.Annotated[NextcloudApp, Depends(nc_app)]):
-            b_tasks.add_task(fetch_models_task, nc, models_to_fetch if models_to_fetch else {}, 0)
+            loop = asyncio.get_running_loop()
+            b_tasks.add_task(fetch_models_task, nc, models_to_fetch if models_to_fetch else {}, 0, loop)
             return JSONResponse(content={})
 
     if map_app_static:
@@ -132,7 +134,12 @@ def __map_app_static_folders(fast_api_app: FastAPI):
             fast_api_app.mount(f"/{mnt_dir}", staticfiles.StaticFiles(directory=mnt_dir_path), name=mnt_dir)
 
 
-def fetch_models_task(nc: NextcloudApp, models: dict[str, dict], progress_init_start_value: int) -> None:
+def fetch_models_task(
+    nc: NextcloudApp,
+    models: dict[str, dict],
+    progress_init_start_value: int,
+    loop: asyncio.AbstractEventLoop | None = None,
+) -> None:
     """Use for cases when you want to define custom `/init` but still need to easy download models.
 
     :param nc: NextcloudApp instance.
@@ -155,32 +162,69 @@ def fetch_models_task(nc: NextcloudApp, models: dict[str, dict], progress_init_s
                   All model options are optional and can be left empty.
 
     :param progress_init_start_value: Integer value defining from which percent the progress should start.
+    :param loop: Optional asyncio event loop used to dispatch progress updates. When this function
+        runs as a FastAPI ``BackgroundTasks`` task it is invoked from a worker thread that has no
+        loop of its own, so the caller must pass the main loop in. Defaults to
+        :func:`asyncio.get_running_loop` if one is active in the current thread.
 
     :raises ModelFetchError: in case of a model download error.
     :raises NextcloudException: in case of a network error reaching the Nextcloud server.
     """
+    if loop is None:
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+    progress = _ProgressReporter(nc, loop)
     if models:
         current_progress = progress_init_start_value
         percent_for_each = min(int((100 - progress_init_start_value) / len(models)), 99)
         for model in models:
             try:
                 if model.startswith(("http://", "https://")):
                     models[model]["path"] = __fetch_model_as_file(
-                        current_progress, percent_for_each, nc, model, models[model]
+                        current_progress, percent_for_each, progress, model, models[model]
                     )
                 else:
                     models[model]["path"] = __fetch_model_as_snapshot(
-                        current_progress, percent_for_each, nc, model, models[model]
+                        current_progress, percent_for_each, progress, model, models[model]
                     )
                 current_progress += percent_for_each
             except BaseException as e:  # noqa pylint: disable=broad-exception-caught
-                nc.set_init_status(current_progress, f"Downloading of '{model}' failed: {e}: {format_exc()}")
+                progress(current_progress, f"Downloading of '{model}' failed: {e}: {format_exc()}")
                 raise ModelFetchError(f"Downloading of '{model}' failed.") from e
-    nc.set_init_status(100)
+    progress(100)
+
+
+class _ProgressReporter:
+    """Bridges sync model-fetch code to the async :py:meth:`NextcloudApp.set_init_status`.
+
+    ``fetch_models_task`` runs in a FastAPI ``BackgroundTasks`` worker thread when the caller
+    is sync, so we cannot ``await`` here. Each call schedules a coroutine on the captured main
+    event loop and waits for the result to keep progress reporting linearizable; if no loop
+    is available the call is silently dropped so model downloads still proceed.
+    """
+
+    def __init__(self, nc: NextcloudApp, loop: asyncio.AbstractEventLoop | None):
+        self._nc = nc
+        self._loop = loop
+
+    def __call__(self, progress: int, error: str = "") -> None:
+        if self._loop is None or self._loop.is_closed():
+            return
+        future = asyncio.run_coroutine_threadsafe(self._nc.set_init_status(progress, error), self._loop)
+        try:
+            future.result(timeout=30)
+        except Exception:  # noqa pylint: disable=broad-exception-caught
+            future.cancel()
 
 
 def __fetch_model_as_file(
-    current_progress: int, progress_for_task: int, nc: NextcloudApp, model_path: str, download_options: dict
+    current_progress: int,
+    progress_for_task: int,
+    progress: _ProgressReporter,
+    model_path: str,
+    download_options: dict,
 ) -> str:
     result_path = download_options.pop("save_path", urlparse(model_path).path.split("/")[-1])
     tmp_path = result_path + ".tmp"
@@ -209,7 +253,7 @@ def __fetch_model_as_file(
                     for byte_block in iter(lambda: file.read(4096), b""):
                         sha256_hash.update(byte_block)
                     if f'"{sha256_hash.hexdigest()}"' == linked_etag:
-                        nc.set_init_status(min(current_progress + progress_for_task, 99))
+                        progress(min(current_progress + progress_for_task, 99))
                         return result_path
 
             try:
@@ -222,7 +266,7 @@ def __fetch_model_as_file(
                                 current_progress + int(progress_for_task * downloaded_size / total_size), 99
                             )
                             if new_progress != last_progress:
-                                nc.set_init_status(new_progress)
+                                progress(new_progress)
                                 last_progress = new_progress
                 os.replace(tmp_path, result_path)
             except BaseException:
@@ -238,7 +282,11 @@ def __fetch_model_as_file(
 
 
 def __fetch_model_as_snapshot(
-    current_progress: int, progress_for_task, nc: NextcloudApp, model_name: str, download_options: dict
+    current_progress: int,
+    progress_for_task,
+    progress: _ProgressReporter,
+    model_name: str,
+    download_options: dict,
 ) -> str:
     from huggingface_hub import snapshot_download  # noqa isort:skip pylint: disable=C0415 disable=E0401
     from tqdm import tqdm  # noqa isort:skip pylint: disable=C0415 disable=E0401
@@ -252,7 +300,7 @@ def __init__(self, *args, **kwargs):
 
         def display(self, msg=None, pos=None):
             if self.total:
-                nc.set_init_status(min(current_progress + int(progress_for_task * self.n / self.total), 99))
+                progress(min(current_progress + int(progress_for_task * self.n / self.total), 99))
             return super().display(msg, pos)
 
     workers = download_options.pop("max_workers", 2)

nc_py_api/ex_app/logger.py

@@ -1,5 +1,6 @@
 """Transparent logging support to store logs in the nextcloud.log."""
 
+import asyncio
 import logging
 import threading
 
@@ -19,28 +20,54 @@
 
 
 class _NextcloudLogsHandler(logging.Handler):
-    def __init__(self):
+    """Forwards Python ``logging`` records to ``nextcloud.log`` via :py:meth:`NextcloudApp.log`.
+
+    Python's logging API is synchronous but ``NextcloudApp.log`` is a coroutine, so each
+    record is dispatched to a captured event loop with :func:`asyncio.run_coroutine_threadsafe`.
+    The dispatch is fire-and-forget so emitters never block. If no loop was captured (for
+    example, ``setup_nextcloud_logging`` was called outside of a running loop), records are
+    silently dropped to avoid deadlocking caller threads.
+    """
+
+    def __init__(self, loop: asyncio.AbstractEventLoop | None = None):
         super().__init__()
+        self._loop = loop
 
     def emit(self, record):
+        loop = self._loop
+        if loop is None or loop.is_closed():
+            return
         if THREAD_LOCAL.__dict__.get("nc_py_api.loghandler", False):
             return
 
         try:
             THREAD_LOCAL.__dict__["nc_py_api.loghandler"] = True
             log_entry = self.format(record)
             log_level = record.levelno
-            NextcloudApp().log(LOGLVL_MAP.get(log_level, LogLvl.FATAL), log_entry, fast_send=True)
+            asyncio.run_coroutine_threadsafe(
+                NextcloudApp().log(LOGLVL_MAP.get(log_level, LogLvl.FATAL), log_entry, fast_send=True),
+                loop,
+            )
         except Exception:  # noqa pylint: disable=broad-exception-caught
             self.handleError(record)
         finally:
             THREAD_LOCAL.__dict__["nc_py_api.loghandler"] = False
 
 
 def setup_nextcloud_logging(logger_name: str | None = None, logging_level: int = logging.DEBUG):
-    """Function to easily send all or selected log entries to Nextcloud."""
+    """Attach a handler that streams Python logging records to the Nextcloud log file.
+
+    Must be called from a context with a running asyncio event loop (typically your
+    FastAPI ``lifespan`` or any async startup hook). The captured loop is used to
+    schedule the async :py:meth:`NextcloudApp.log` calls from sync ``emit``. Calling
+    this from sync code installs an inert handler that drops records.
+    """
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        loop = None
     logger = logging.getLogger(logger_name)
-    nextcloud_handler = _NextcloudLogsHandler()
+    nextcloud_handler = _NextcloudLogsHandler(loop)
     nextcloud_handler.setLevel(logging_level)
     logger.addHandler(nextcloud_handler)
     return nextcloud_handler