nc-py-api 0.20.2__tar.gz → 0.21.1__tar.gz

{nc_py_api-0.20.2 → nc_py_api-0.21.1}/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.21.1 - 2025-08-27]
+
+### Changed
+
+- ExApps: Now exception is raised during model download if there was error to prevent incorrect ExApp installation. #376
+
+### Fixed
+
+- ExApps: Broken models download ue a typo in the previous PRs. #376
+
+## [0.21.0 - 2025-08-26]
+
+### Added
+
+- Added wipe method to UsersAPI. #368 Thanks to @MrAalen
+
+### Changed
+
+- Switch from `httpx` library to the `niquests` library. #375 Thanks to @Ousret
+
 ## [0.20.2 - 2025-05-28]
 
 ### Added

{nc_py_api-0.20.2 → nc_py_api-0.21.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nc-py-api
-Version: 0.20.2
+Version: 0.21.1
 Summary: Nextcloud Python Framework
 Project-URL: Changelog, https://github.com/cloud-py-api/nc_py_api/blob/main/CHANGELOG.md
 Project-URL: Documentation, https://cloud-py-api.github.io/nc_py_api/
@@ -31,10 +31,9 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: fastapi>=0.109.2
-Requires-Dist: httpx>=0.25.2
+Requires-Dist: niquests<4,>=3
 Requires-Dist: pydantic>=2.1.1
 Requires-Dist: python-dotenv>=1
-Requires-Dist: truststore==0.10
 Requires-Dist: xmltodict>=0.13
 Provides-Extra: app
 Requires-Dist: uvicorn[standard]>=0.23.2; extra == 'app'

{nc_py_api-0.20.2 → nc_py_api-0.21.1}/nc_py_api/__init__.py

@@ -2,6 +2,7 @@
 
 from . import ex_app, options
 from ._exceptions import (
+    ModelFetchError,
     NextcloudException,
     NextcloudExceptionNotFound,
     NextcloudMissingCapabilities,

{nc_py_api-0.20.2 → nc_py_api-0.21.1}/nc_py_api/_exceptions.py

@@ -1,6 +1,6 @@
 """Exceptions for the Nextcloud API."""
 
-from httpx import Response, codes
+from niquests import HTTPError, Response
 
 
 class NextcloudException(Exception):
@@ -60,6 +60,12 @@ def check_error(response: Response, info: str = ""):
         else:
             phrase = "Unknown error"
         raise NextcloudException(status_code, reason=phrase, info=info)
-    if not codes.is_error(status_code):
-        return
-    raise NextcloudException(status_code, reason=codes(status_code).phrase, info=info)
+
+    try:
+        response.raise_for_status()
+    except HTTPError as e:
+        raise NextcloudException(status_code, reason=response.reason, info=info) from e
+
+
+class ModelFetchError(Exception):
+    """Exception raised when model fetching fails."""

{nc_py_api-0.20.2 → nc_py_api-0.21.1}/nc_py_api/_session.py

@@ -10,9 +10,11 @@ from dataclasses import dataclass
 from enum import IntEnum
 from json import loads
 from os import environ
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
 
-from httpx import AsyncClient, Client, Headers, Limits, ReadTimeout, Request, Response
-from httpx import __version__ as httpx_version
+from niquests import AsyncSession, ReadTimeout, Request, Response, Session
+from niquests import __version__ as niquests_version
+from niquests.structures import CaseInsensitiveDict
 from starlette.requests import HTTPConnection
 
 from . import options
@@ -49,6 +51,13 @@ class ServerVersion(typing.TypedDict):
     """Indicates if the subscription has extended support"""
 
 
+@dataclass
+class Limits:
+    max_keepalive_connections: int | None = 20
+    max_connections: int | None = 100
+    keepalive_expiry: int | float | None = 5
+
+
 @dataclass
 class RuntimeOptions:
     xdebug_session: str
@@ -134,11 +143,11 @@ class AppConfig(BasicConfig):
 
 
 class NcSessionBase(ABC):
-    adapter: AsyncClient | Client
-    adapter_dav: AsyncClient | Client
+    adapter: AsyncSession | Session
+    adapter_dav: AsyncSession | Session
     cfg: BasicConfig
     custom_headers: dict
-    response_headers: Headers
+    response_headers: CaseInsensitiveDict
     _user: str
     _capabilities: dict
 
@@ -150,7 +159,7 @@ class NcSessionBase(ABC):
         self.limits = Limits(max_keepalive_connections=20, max_connections=20, keepalive_expiry=60.0)
         self.init_adapter()
         self.init_adapter_dav()
-        self.response_headers = Headers()
+        self.response_headers = CaseInsensitiveDict()
         self._ocs_regexp = re.compile(r"/ocs/v[12]\.php/|/apps/groupfolders/")
 
     def init_adapter(self, restart=False) -> None:
@@ -172,7 +181,7 @@ class NcSessionBase(ABC):
                 self.adapter_dav.cookies.set("XDEBUG_SESSION", options.XDEBUG_SESSION)
 
     @abstractmethod
-    def _create_adapter(self, dav: bool = False) -> AsyncClient | Client:
+    def _create_adapter(self, dav: bool = False) -> AsyncSession | Session:
         pass  # pragma: no cover
 
     @property
@@ -187,8 +196,8 @@ class NcSessionBase(ABC):
 
 
 class NcSessionBasic(NcSessionBase, ABC):
-    adapter: Client
-    adapter_dav: Client
+    adapter: Session
+    adapter_dav: Session
 
     def ocs(
         self,
@@ -206,9 +215,7 @@ class NcSessionBasic(NcSessionBase, ABC):
         info = f"request: {method} {path}"
         nested_req = kwargs.pop("nested_req", False)
         try:
-            response = self.adapter.request(
-                method, path, content=content, json=json, params=params, files=files, **kwargs
-            )
+            response = self.adapter.request(method, path, data=content, json=json, params=params, files=files, **kwargs)
         except ReadTimeout:
             raise NextcloudException(408, info=info) from None
 
@@ -281,18 +288,18 @@ class NcSessionBasic(NcSessionBase, ABC):
             return {
                 "base_url": self.cfg.dav_endpoint,
                 "timeout": self.cfg.options.timeout_dav,
-                "event_hooks": {"request": [], "response": [self._response_event]},
+                "event_hooks": {"pre_request": [], "response": [self._response_event]},
             }
         return {
             "base_url": self.cfg.endpoint,
             "timeout": self.cfg.options.timeout,
-            "event_hooks": {"request": [self._request_event_ocs], "response": [self._response_event]},
+            "event_hooks": {"pre_request": [self._request_event_ocs], "response": [self._response_event]},
         }
 
     def _request_event_ocs(self, request: Request) -> None:
         str_url = str(request.url)
         if re.search(self._ocs_regexp, str_url) is not None:  # this is OCS call
-            request.url = request.url.copy_merge_params({"format": "json"})
+            request.url = patch_param(request.url, "format", "json")
             request.headers["Accept"] = "application/json"
 
     def _response_event(self, response: Response) -> None:
@@ -305,15 +312,15 @@ class NcSessionBasic(NcSessionBase, ABC):
 
     def download2fp(self, url_path: str, fp, dav: bool, params=None, **kwargs):
         adapter = self.adapter_dav if dav else self.adapter
-        with adapter.stream("GET", url_path, params=params, headers=kwargs.get("headers")) as response:
+        with adapter.get(url_path, params=params, headers=kwargs.get("headers"), stream=True) as response:
             check_error(response)
-            for data_chunk in response.iter_bytes(chunk_size=kwargs.get("chunk_size", 5 * 1024 * 1024)):
+            for data_chunk in response.iter_raw(chunk_size=kwargs.get("chunk_size", -1)):
                 fp.write(data_chunk)
 
 
 class AsyncNcSessionBasic(NcSessionBase, ABC):
-    adapter: AsyncClient
-    adapter_dav: AsyncClient
+    adapter: AsyncSession
+    adapter_dav: AsyncSession
 
     async def ocs(
         self,
@@ -332,7 +339,7 @@ class AsyncNcSessionBasic(NcSessionBase, ABC):
         nested_req = kwargs.pop("nested_req", False)
         try:
             response = await self.adapter.request(
-                method, path, content=content, json=json, params=params, files=files, **kwargs
+                method, path, data=content, json=json, params=params, files=files, **kwargs
             )
         except ReadTimeout:
             raise NextcloudException(408, info=info) from None
@@ -350,7 +357,7 @@ class AsyncNcSessionBasic(NcSessionBase, ABC):
                 and ocs_meta["statuscode"] == 403
                 and str(ocs_meta["message"]).lower().find("password confirmation is required") != -1
             ):
-                await self.adapter.aclose()
+                await self.adapter.close()
                 self.init_adapter(restart=True)
                 return await self.ocs(
                     method, path, **kwargs, content=content, json=json, params=params, nested_req=True
@@ -408,18 +415,18 @@ class AsyncNcSessionBasic(NcSessionBase, ABC):
             return {
                 "base_url": self.cfg.dav_endpoint,
                 "timeout": self.cfg.options.timeout_dav,
-                "event_hooks": {"request": [], "response": [self._response_event]},
+                "event_hooks": {"pre_request": [], "response": [self._response_event]},
             }
         return {
             "base_url": self.cfg.endpoint,
             "timeout": self.cfg.options.timeout,
-            "event_hooks": {"request": [self._request_event_ocs], "response": [self._response_event]},
+            "event_hooks": {"pre_request": [self._request_event_ocs], "response": [self._response_event]},
         }
 
     async def _request_event_ocs(self, request: Request) -> None:
         str_url = str(request.url)
         if re.search(self._ocs_regexp, str_url) is not None:  # this is OCS call
-            request.url = request.url.copy_merge_params({"format": "json"})
+            request.url = patch_param(request.url, "format", "json")
             request.headers["Accept"] = "application/json"
 
     async def _response_event(self, response: Response) -> None:
@@ -432,10 +439,12 @@ class AsyncNcSessionBasic(NcSessionBase, ABC):
 
     async def download2fp(self, url_path: str, fp, dav: bool, params=None, **kwargs):
         adapter = self.adapter_dav if dav else self.adapter
-        async with adapter.stream("GET", url_path, params=params, headers=kwargs.get("headers")) as response:
-            check_error(response)
-            async for data_chunk in response.aiter_bytes(chunk_size=kwargs.get("chunk_size", 5 * 1024 * 1024)):
-                fp.write(data_chunk)
+        response = await adapter.get(url_path, params=params, headers=kwargs.get("headers"), stream=True)
+
+        check_error(response)
+
+        async for data_chunk in await response.iter_raw(chunk_size=kwargs.get("chunk_size", -1)):
+            fp.write(data_chunk)
 
 
 class NcSession(NcSessionBasic):
@@ -445,15 +454,20 @@ class NcSession(NcSessionBasic):
         self.cfg = Config(**kwargs)
         super().__init__()
 
-    def _create_adapter(self, dav: bool = False) -> AsyncClient | Client:
-        return Client(
-            follow_redirects=True,
-            limits=self.limits,
-            verify=self.cfg.options.nc_cert,
-            **self._get_adapter_kwargs(dav),
-            auth=self.cfg.auth,
+    def _create_adapter(self, dav: bool = False) -> AsyncSession | Session:
+        session_kwargs = self._get_adapter_kwargs(dav)
+        hooks = session_kwargs.pop("event_hooks")
+
+        session = Session(
+            keepalive_delay=self.limits.keepalive_expiry, pool_maxsize=self.limits.max_connections, **session_kwargs
         )
 
+        session.auth = self.cfg.auth
+        session.verify = self.cfg.options.nc_cert
+        session.hooks.update(hooks)
+
+        return session
+
 
 class AsyncNcSession(AsyncNcSessionBasic):
     cfg: Config
@@ -462,21 +476,28 @@ class AsyncNcSession(AsyncNcSessionBasic):
         self.cfg = Config(**kwargs)
         super().__init__()
 
-    def _create_adapter(self, dav: bool = False) -> AsyncClient | Client:
-        return AsyncClient(
-            follow_redirects=True,
-            limits=self.limits,
-            verify=self.cfg.options.nc_cert,
-            **self._get_adapter_kwargs(dav),
-            auth=self.cfg.auth,
+    def _create_adapter(self, dav: bool = False) -> AsyncSession | Session:
+        session_kwargs = self._get_adapter_kwargs(dav)
+        hooks = session_kwargs.pop("event_hooks")
+
+        session = AsyncSession(
+            keepalive_delay=self.limits.keepalive_expiry,
+            pool_maxsize=self.limits.max_connections,
+            **session_kwargs,
         )
 
+        session.verify = self.cfg.options.nc_cert
+        session.auth = self.cfg.auth
+        session.hooks.update(hooks)
+
+        return session
+
 
 class NcSessionAppBasic(ABC):
     cfg: AppConfig
     _user: str
-    adapter: AsyncClient | Client
-    adapter_dav: AsyncClient | Client
+    adapter: AsyncSession | Session
+    adapter_dav: AsyncSession | Session
 
     def __init__(self, **kwargs):
         self.cfg = AppConfig(**kwargs)
@@ -505,22 +526,29 @@ class NcSessionAppBasic(ABC):
 class NcSessionApp(NcSessionAppBasic, NcSessionBasic):
     cfg: AppConfig
 
-    def _create_adapter(self, dav: bool = False) -> AsyncClient | Client:
-        r = self._get_adapter_kwargs(dav)
-        r["event_hooks"]["request"].append(self._add_auth)
-        return Client(
-            follow_redirects=True,
-            limits=self.limits,
-            verify=self.cfg.options.nc_cert,
-            **r,
-            headers={
-                "AA-VERSION": self.cfg.aa_version,
-                "EX-APP-ID": self.cfg.app_name,
-                "EX-APP-VERSION": self.cfg.app_version,
-                "user-agent": f"ExApp/{self.cfg.app_name}/{self.cfg.app_version} (httpx/{httpx_version})",
-            },
+    def _create_adapter(self, dav: bool = False) -> AsyncSession | Session:
+        session_kwargs = self._get_adapter_kwargs(dav)
+        session_kwargs["event_hooks"]["pre_request"].append(self._add_auth)
+
+        hooks = session_kwargs.pop("event_hooks")
+
+        session = Session(
+            keepalive_delay=self.limits.keepalive_expiry,
+            pool_maxsize=self.limits.max_connections,
+            **session_kwargs,
         )
 
+        session.verify = self.cfg.options.nc_cert
+        session.headers = {
+            "AA-VERSION": self.cfg.aa_version,
+            "EX-APP-ID": self.cfg.app_name,
+            "EX-APP-VERSION": self.cfg.app_version,
+            "user-agent": f"ExApp/{self.cfg.app_name}/{self.cfg.app_version} (niquests/{niquests_version})",
+        }
+        session.hooks.update(hooks)
+
+        return session
+
     def _add_auth(self, request: Request):
         request.headers.update(
             {"AUTHORIZATION-APP-API": b64encode(f"{self._user}:{self.cfg.app_secret}".encode("UTF=8"))}
@@ -530,23 +558,39 @@ class NcSessionApp(NcSessionAppBasic, NcSessionBasic):
 class AsyncNcSessionApp(NcSessionAppBasic, AsyncNcSessionBasic):
     cfg: AppConfig
 
-    def _create_adapter(self, dav: bool = False) -> AsyncClient | Client:
-        r = self._get_adapter_kwargs(dav)
-        r["event_hooks"]["request"].append(self._add_auth)
-        return AsyncClient(
-            follow_redirects=True,
-            limits=self.limits,
-            verify=self.cfg.options.nc_cert,
-            **r,
-            headers={
-                "AA-VERSION": self.cfg.aa_version,
-                "EX-APP-ID": self.cfg.app_name,
-                "EX-APP-VERSION": self.cfg.app_version,
-                "User-Agent": f"ExApp/{self.cfg.app_name}/{self.cfg.app_version} (httpx/{httpx_version})",
-            },
+    def _create_adapter(self, dav: bool = False) -> AsyncSession | Session:
+        session_kwargs = self._get_adapter_kwargs(dav)
+        session_kwargs["event_hooks"]["pre_request"].append(self._add_auth)
+
+        hooks = session_kwargs.pop("event_hooks")
+
+        session = AsyncSession(
+            keepalive_delay=self.limits.keepalive_expiry,
+            pool_maxsize=self.limits.max_connections,
+            **session_kwargs,
         )
+        session.verify = self.cfg.options.nc_cert
+        session.headers = {
+            "AA-VERSION": self.cfg.aa_version,
+            "EX-APP-ID": self.cfg.app_name,
+            "EX-APP-VERSION": self.cfg.app_version,
+            "User-Agent": f"ExApp/{self.cfg.app_name}/{self.cfg.app_version} (niquests/{niquests_version})",
+        }
+        session.hooks.update(hooks)
+
+        return session
 
     async def _add_auth(self, request: Request):
         request.headers.update(
             {"AUTHORIZATION-APP-API": b64encode(f"{self._user}:{self.cfg.app_secret}".encode("UTF=8"))}
         )
+
+
+def patch_param(url: str, key: str, value: str) -> str:
+    parts = urlsplit(url)
+    query = dict(parse_qsl(parts.query, keep_blank_values=True))
+    query[key] = value
+
+    new_query = urlencode(query, doseq=True)
+
+    return urlunsplit((parts.scheme, parts.netloc, parts.path, new_query, parts.fragment))

{nc_py_api-0.20.2 → nc_py_api-0.21.1}/nc_py_api/_version.py

@@ -1,3 +1,3 @@
 """Version of nc_py_api."""
 
-__version__ = "0.20.2"
+__version__ = "0.21.1"

{nc_py_api-0.20.2 → nc_py_api-0.21.1}/nc_py_api/calendar_api.py

@@ -23,7 +23,7 @@ try:
             if body:
                 body = body.replace(b"\n", b"\r\n").replace(b"\r\r\n", b"\r\n")
             r = self._session.adapter_dav.request(
-                method, url if isinstance(url, str) else str(url), content=body, headers=headers
+                method, url if isinstance(url, str) else str(url), data=body, headers=headers
             )
             return DAVResponse(r)
 

{nc_py_api-0.20.2 → nc_py_api-0.21.1}/nc_py_api/ex_app/integration_fastapi.py

@@ -7,9 +7,10 @@ import hashlib
 import json
 import os
 import typing
+from traceback import format_exc
 from urllib.parse import urlparse
 
-import httpx
+import niquests
 from fastapi import (
     BackgroundTasks,
     Depends,
@@ -22,10 +23,10 @@ from fastapi.responses import JSONResponse, PlainTextResponse
 from starlette.requests import HTTPConnection, Request
 from starlette.types import ASGIApp, Receive, Scope, Send
 
+from .._exceptions import ModelFetchError
 from .._misc import get_username_secret_from_headers
 from ..nextcloud import AsyncNextcloudApp, NextcloudApp
 from ..talk_bot import TalkBotMessage
-from .defs import LogLvl
 from .misc import persistent_storage
 
 
@@ -70,9 +71,24 @@ def set_handlers(
 
         .. note:: When this parameter is ``False``, the provision of ``models_to_fetch`` is not allowed.
 
-    :param models_to_fetch: Dictionary describing which models should be downloaded during `init`.
+    :param models_to_fetch: Dictionary describing which models should be downloaded during `init` of the form:
+        .. code-block:: python
+            {
+                "model_url_1": {
+                    "save_path": "path_or_filename_to_save_the_model_to",
+                },
+                "huggingface_model_name_1": {
+                    "max_workers": 4,
+                    "cache_dir": "path_to_cache_dir",
+                    "revision": "revision_to_fetch",
+                    ...
+                },
+                ...
+            }
+
 
         .. note:: ``huggingface_hub`` package should be present for automatic models fetching.
+                  All model options are optional and can be left empty.
 
     :param map_app_static: Should be folders ``js``, ``css``, ``l10n``, ``img`` automatically mounted in FastAPI or not.
 
@@ -121,73 +137,98 @@ def __map_app_static_folders(fast_api_app: FastAPI):
 
 
 def fetch_models_task(nc: NextcloudApp, models: dict[str, dict], progress_init_start_value: int) -> None:
-    """Use for cases when you want to define custom `/init` but still need to easy download models."""
+    """Use for cases when you want to define custom `/init` but still need to easy download models.
+
+    :param nc: NextcloudApp instance.
+    :param models_to_fetch: Dictionary describing which models should be downloaded of the form:
+        .. code-block:: python
+            {
+                "model_url_1": {
+                    "save_path": "path_or_filename_to_save_the_model_to",
+                },
+                "huggingface_model_name_1": {
+                    "max_workers": 4,
+                    "cache_dir": "path_to_cache_dir",
+                    "revision": "revision_to_fetch",
+                    ...
+                },
+                ...
+            }
+
+        .. note:: ``huggingface_hub`` package should be present for automatic models fetching.
+                  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.
+
+    :raises ModelFetchError: in case of a model download error.
+    :raises NextcloudException: in case of a network error reaching the Nextcloud server.
+    """
     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:
-            if model.startswith(("http://", "https://")):
-                models[model]["path"] = __fetch_model_as_file(
-                    current_progress, percent_for_each, nc, 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
+            try:
+                if model.startswith(("http://", "https://")):
+                    models[model]["path"] = __fetch_model_as_file(
+                        current_progress, percent_for_each, nc, 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
+            except BaseException as e:  # noqa pylint: disable=broad-exception-caught
+                nc.set_init_status(current_progress, f"Downloading of '{model}' failed: {e}: {format_exc()}")
+                raise ModelFetchError(f"Downloading of '{model}' failed.") from e
     nc.set_init_status(100)
 
 
 def __fetch_model_as_file(
     current_progress: int, progress_for_task: int, nc: NextcloudApp, model_path: str, download_options: dict
-) -> str | None:
+) -> str:
     result_path = download_options.pop("save_path", urlparse(model_path).path.split("/")[-1])
-    try:
-        with httpx.stream("GET", model_path, follow_redirects=True) as response:
-            if not response.is_success:
-                nc.log(LogLvl.ERROR, f"Downloading of '{model_path}' returned {response.status_code} status.")
-                return None
-            downloaded_size = 0
-            linked_etag = ""
-            for each_history in response.history:
-                linked_etag = each_history.headers.get("X-Linked-ETag", "")
-                if linked_etag:
-                    break
-            if not linked_etag:
-                linked_etag = response.headers.get("X-Linked-ETag", response.headers.get("ETag", ""))
-            total_size = int(response.headers.get("Content-Length"))
-            try:
-                existing_size = os.path.getsize(result_path)
-            except OSError:
-                existing_size = 0
-            if linked_etag and total_size == existing_size:
-                with builtins.open(result_path, "rb") as file:
-                    sha256_hash = hashlib.sha256()
-                    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))
-                        return None
-
-            with builtins.open(result_path, "wb") as file:
-                last_progress = current_progress
-                for chunk in response.iter_bytes(5 * 1024 * 1024):
-                    downloaded_size += file.write(chunk)
-                    if total_size:
-                        new_progress = min(current_progress + int(progress_for_task * downloaded_size / total_size), 99)
-                        if new_progress != last_progress:
-                            nc.set_init_status(new_progress)
-                            last_progress = new_progress
-
-        return result_path
-    except Exception as e:  # noqa pylint: disable=broad-exception-caught
-        nc.log(LogLvl.ERROR, f"Downloading of '{model_path}' raised an exception: {e}")
-
-    return None
+    with niquests.get(model_path, stream=True) as response:
+        if not response.ok:
+            raise ModelFetchError(
+                f"Downloading of '{model_path}' failed, returned ({response.status_code}) {response.text}"
+            )
+        downloaded_size = 0
+        linked_etag = ""
+        for each_history in response.history:
+            linked_etag = each_history.headers.get("X-Linked-ETag", "")
+            if linked_etag:
+                break
+        if not linked_etag:
+            linked_etag = response.headers.get("X-Linked-ETag", response.headers.get("ETag", ""))
+        total_size = int(response.headers.get("Content-Length"))
+        try:
+            existing_size = os.path.getsize(result_path)
+        except OSError:
+            existing_size = 0
+        if linked_etag and total_size == existing_size:
+            with builtins.open(result_path, "rb") as file:
+                sha256_hash = hashlib.sha256()
+                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))
+                    return result_path
+
+        with builtins.open(result_path, "wb") as file:
+            last_progress = current_progress
+            for chunk in response.iter_raw(-1):
+                downloaded_size += file.write(chunk)
+                if total_size:
+                    new_progress = min(current_progress + int(progress_for_task * downloaded_size / total_size), 99)
+                    if new_progress != last_progress:
+                        nc.set_init_status(new_progress)
+                        last_progress = new_progress
+
+    return result_path
 
 
 def __fetch_model_as_snapshot(
-    current_progress: int, progress_for_task, nc: NextcloudApp, mode_name: str, download_options: dict
+    current_progress: int, progress_for_task, nc: NextcloudApp, 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
@@ -200,7 +241,7 @@ def __fetch_model_as_snapshot(
     workers = download_options.pop("max_workers", 2)
     cache = download_options.pop("cache_dir", persistent_storage())
     return snapshot_download(
-        mode_name, tqdm_class=TqdmProgress, **download_options, max_workers=workers, cache_dir=cache
+        model_name, tqdm_class=TqdmProgress, **download_options, max_workers=workers, cache_dir=cache
     )
 
 

{nc_py_api-0.20.2 → nc_py_api-0.21.1}/nc_py_api/files/_files.py

@@ -9,7 +9,7 @@ from urllib.parse import unquote
 from xml.etree import ElementTree
 
 import xmltodict
-from httpx import Response
+from niquests import Response
 
 from .._exceptions import NextcloudException, check_error
 from .._misc import check_capabilities, clear_from_params_empty