nc-py-api 0.10.0__py3-none-any.whl → 0.18.1__py3-none-any.whl

nc_py_api/loginflow_v2.py

@@ -0,0 +1,161 @@
+"""Login flow v2 API wrapper."""
+
+import asyncio
+import json
+import time
+from dataclasses import dataclass
+
+import httpx
+
+from ._exceptions import check_error
+from ._session import AsyncNcSession, NcSession
+
+MAX_TIMEOUT = 60 * 20
+
+
+@dataclass
+class LoginFlow:
+    """The Nextcloud Login flow v2 initialization response representation."""
+
+    def __init__(self, raw_data: dict) -> None:
+        self.raw_data = raw_data
+
+    @property
+    def login(self) -> str:
+        """The URL for user authorization.
+
+        Should be opened by the user in the default browser to authorize in Nextcloud.
+        """
+        return self.raw_data["login"]
+
+    @property
+    def token(self) -> str:
+        """Token for a polling for confirmation of user authorization."""
+        return self.raw_data["poll"]["token"]
+
+    @property
+    def endpoint(self) -> str:
+        """Endpoint for polling."""
+        return self.raw_data["poll"]["endpoint"]
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} login_url={self.login}>"
+
+
+@dataclass
+class Credentials:
+    """The Nextcloud Login flow v2 response with app credentials representation."""
+
+    def __init__(self, raw_data: dict) -> None:
+        self.raw_data = raw_data
+
+    @property
+    def server(self) -> str:
+        """The address of Nextcloud to connect to.
+
+        The server may specify a protocol (http or https). If no protocol is specified https will be used.
+        """
+        return self.raw_data["server"]
+
+    @property
+    def login_name(self) -> str:
+        """The username for authenticating with Nextcloud."""
+        return self.raw_data["loginName"]
+
+    @property
+    def app_password(self) -> str:
+        """The application password generated for authenticating with Nextcloud."""
+        return self.raw_data["appPassword"]
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} login={self.login_name} app_password={self.app_password}>"
+
+
+class _LoginFlowV2API:
+    """Class implementing Nextcloud Login flow v2."""
+
+    _ep_init: str = "/index.php/login/v2"
+    _ep_poll: str = "/index.php/login/v2/poll"
+
+    def __init__(self, session: NcSession) -> None:
+        self._session = session
+
+    def init(self, user_agent: str = "nc_py_api") -> LoginFlow:
+        """Init a Login flow v2.
+
+        :param user_agent: Application name. Application password will be associated with this name.
+        """
+        r = self._session.adapter.post(self._ep_init, headers={"user-agent": user_agent})
+        return LoginFlow(_res_to_json(r))
+
+    def poll(self, token: str, timeout: int = MAX_TIMEOUT, step: int = 1, overwrite_auth: bool = True) -> Credentials:
+        """Poll the Login flow v2 credentials.
+
+        :param token: Token for a polling for confirmation of user authorization.
+        :param timeout: Maximum time to wait for polling in seconds, defaults to MAX_TIMEOUT.
+        :param step: Interval for polling in seconds, defaults to 1.
+        :param overwrite_auth: If True current session will be overwritten with new credentials, defaults to True.
+        :raises ValueError: If timeout more than 20 minutes.
+        """
+        if timeout > MAX_TIMEOUT:
+            msg = "Timeout can't be more than 20 minutes."
+            raise ValueError(msg)
+        for _ in range(timeout // step):
+            r = self._session.adapter.post(self._ep_poll, data={"token": token})
+            if r.status_code == 200:
+                break
+            time.sleep(step)
+        r_model = Credentials(_res_to_json(r))
+        if overwrite_auth:
+            self._session.cfg.auth = (r_model.login_name, r_model.app_password)
+            self._session.init_adapter(restart=True)
+            self._session.init_adapter_dav(restart=True)
+        return r_model
+
+
+class _AsyncLoginFlowV2API:
+    """Class implementing Async Nextcloud Login flow v2."""
+
+    _ep_init: str = "/index.php/login/v2"
+    _ep_poll: str = "/index.php/login/v2/poll"
+
+    def __init__(self, session: AsyncNcSession) -> None:
+        self._session = session
+
+    async def init(self, user_agent: str = "nc_py_api") -> LoginFlow:
+        """Init a Login flow v2.
+
+        :param user_agent: Application name. Application password will be associated with this name.
+        """
+        r = await self._session.adapter.post(self._ep_init, headers={"user-agent": user_agent})
+        return LoginFlow(_res_to_json(r))
+
+    async def poll(
+        self, token: str, timeout: int = MAX_TIMEOUT, step: int = 1, overwrite_auth: bool = True
+    ) -> Credentials:
+        """Poll the Login flow v2 credentials.
+
+        :param token: Token for a polling for confirmation of user authorization.
+        :param timeout: Maximum time to wait for polling in seconds, defaults to MAX_TIMEOUT.
+        :param step: Interval for polling in seconds, defaults to 1.
+        :param overwrite_auth: If True current session will be overwritten with new credentials, defaults to True.
+        :raises ValueError: If timeout more than 20 minutes.
+        """
+        if timeout > MAX_TIMEOUT:
+            raise ValueError("Timeout can't be more than 20 minutes.")
+        for _ in range(timeout // step):
+            r = await self._session.adapter.post(self._ep_poll, data={"token": token})
+            if r.status_code == 200:
+                break
+            await asyncio.sleep(step)
+        r_model = Credentials(_res_to_json(r))
+        if overwrite_auth:
+            self._session.cfg.auth = (r_model.login_name, r_model.app_password)
+            self._session.init_adapter(restart=True)
+            self._session.init_adapter_dav(restart=True)
+        return r_model
+
+
+def _res_to_json(response: httpx.Response) -> dict:
+    check_error(response)
+    return json.loads(response.text)

nc_py_api/nextcloud.py

@@ -1,5 +1,6 @@
 """Nextcloud class providing access to all API endpoints."""
 
+import contextlib
 import typing
 from abc import ABC
 
@@ -30,15 +31,20 @@ from .activity import _ActivityAPI, _AsyncActivityAPI
 from .apps import _AppsAPI, _AsyncAppsAPI
 from .calendar import _CalendarAPI
 from .ex_app.defs import LogLvl
+from .ex_app.events_listener import AsyncEventsListenerAPI, EventsListenerAPI
+from .ex_app.occ_commands import AsyncOccCommandsAPI, OccCommandsAPI
 from .ex_app.providers.providers import AsyncProvidersApi, ProvidersApi
 from .ex_app.ui.ui import AsyncUiApi, UiApi
-from .files.files import AsyncFilesAPI, FilesAPI
+from .files.files import FilesAPI
+from .files.files_async import AsyncFilesAPI
+from .loginflow_v2 import _AsyncLoginFlowV2API, _LoginFlowV2API
 from .notes import _AsyncNotesAPI, _NotesAPI
 from .notifications import _AsyncNotificationsAPI, _NotificationsAPI
 from .user_status import _AsyncUserStatusAPI, _UserStatusAPI
 from .users import _AsyncUsersAPI, _UsersAPI
 from .users_groups import _AsyncUsersGroupsAPI, _UsersGroupsAPI
 from .weather_status import _AsyncWeatherStatusAPI, _WeatherStatusAPI
+from .webhooks import _AsyncWebhooksAPI, _WebhooksAPI
 
 
 class _NextcloudBasic(ABC):  # pylint: disable=too-many-instance-attributes
@@ -66,6 +72,8 @@ class _NextcloudBasic(ABC):  # pylint: disable=too-many-instance-attributes
     """Nextcloud API for managing users statuses"""
     weather_status: _WeatherStatusAPI
     """Nextcloud API for managing user weather statuses"""
+    webhooks: _WebhooksAPI
+    """Nextcloud API for managing webhooks"""
     _session: NcSessionBasic
 
     def __init__(self, session: NcSessionBasic):
@@ -81,6 +89,7 @@ class _NextcloudBasic(ABC):  # pylint: disable=too-many-instance-attributes
         self.users_groups = _UsersGroupsAPI(session)
         self.user_status = _UserStatusAPI(session)
         self.weather_status = _WeatherStatusAPI(session)
+        self.webhooks = _WebhooksAPI(session)
 
     @property
     def capabilities(self) -> dict:
@@ -164,6 +173,8 @@ class _AsyncNextcloudBasic(ABC):  # pylint: disable=too-many-instance-attributes
     """Nextcloud API for managing users statuses"""
     weather_status: _AsyncWeatherStatusAPI
     """Nextcloud API for managing user weather statuses"""
+    webhooks: _AsyncWebhooksAPI
+    """Nextcloud API for managing webhooks"""
     _session: AsyncNcSessionBasic
 
     def __init__(self, session: AsyncNcSessionBasic):
@@ -179,6 +190,7 @@ class _AsyncNextcloudBasic(ABC):  # pylint: disable=too-many-instance-attributes
         self.users_groups = _AsyncUsersGroupsAPI(session)
         self.user_status = _AsyncUserStatusAPI(session)
         self.weather_status = _AsyncWeatherStatusAPI(session)
+        self.webhooks = _AsyncWebhooksAPI(session)
 
     @property
     async def capabilities(self) -> dict:
@@ -244,15 +256,18 @@ class Nextcloud(_NextcloudBasic):
     """
 
     _session: NcSession
+    loginflow_v2: _LoginFlowV2API
+    """Nextcloud Login flow v2."""
 
     def __init__(self, **kwargs):
         """If the parameters are not specified, they will be taken from the environment.
 
         :param nextcloud_url: url of the nextcloud instance.
-        :param nc_auth_user: login username.
-        :param nc_auth_pass: password or app-password for the username.
+        :param nc_auth_user: login username. Optional.
+        :param nc_auth_pass: password or app-password for the username. Optional.
         """
         self._session = NcSession(**kwargs)
+        self.loginflow_v2 = _LoginFlowV2API(self._session)
         super().__init__(self._session)
 
     @property
@@ -268,15 +283,18 @@ class AsyncNextcloud(_AsyncNextcloudBasic):
     """
 
     _session: AsyncNcSession
+    loginflow_v2: _AsyncLoginFlowV2API
+    """Nextcloud Login flow v2."""
 
     def __init__(self, **kwargs):
         """If the parameters are not specified, they will be taken from the environment.
 
         :param nextcloud_url: url of the nextcloud instance.
-        :param nc_auth_user: login username.
-        :param nc_auth_pass: password or app-password for the username.
+        :param nc_auth_user: login username. Optional.
+        :param nc_auth_pass: password or app-password for the username. Optional.
         """
         self._session = AsyncNcSession(**kwargs)
+        self.loginflow_v2 = _AsyncLoginFlowV2API(self._session)
         super().__init__(self._session)
 
     @property
@@ -304,6 +322,10 @@ class NextcloudApp(_NextcloudBasic):
     """Nextcloud UI API for ExApps"""
     providers: ProvidersApi
     """API for registering providers for Nextcloud"""
+    events_listener: EventsListenerAPI
+    """API for registering Events listeners for ExApps"""
+    occ_commands: OccCommandsAPI
+    """API for registering OCC command for ExApps"""
 
     def __init__(self, **kwargs):
         """The parameters will be taken from the environment.
@@ -316,24 +338,38 @@ class NextcloudApp(_NextcloudBasic):
         self.preferences_ex = PreferencesExAPI(self._session)
         self.ui = UiApi(self._session)
         self.providers = ProvidersApi(self._session)
+        self.events_listener = EventsListenerAPI(self._session)
+        self.occ_commands = OccCommandsAPI(self._session)
 
-    def log(self, log_lvl: LogLvl, content: str) -> None:
+    @property
+    def enabled_state(self) -> bool:
+        """Returns ``True`` if ExApp is enabled, ``False`` otherwise."""
+        with contextlib.suppress(Exception):
+            return bool(self._session.ocs("GET", "/ocs/v1.php/apps/app_api/ex-app/state"))
+        return False
+
+    def log(self, log_lvl: LogLvl, content: str, fast_send: bool = False) -> None:
         """Writes log to the Nextcloud log file."""
-        if self.check_capabilities("app_api"):
-            return
-        if int(log_lvl) < self.capabilities["app_api"].get("loglevel", 0):
-            return
-        self._session.ocs("POST", f"{self._session.ae_url}/log", json={"level": int(log_lvl), "message": content})
+        int_log_lvl = int(log_lvl)
+        if int_log_lvl < 0 or int_log_lvl > 4:
+            raise ValueError("Invalid `log_lvl` value")
+        if not fast_send:
+            if self.check_capabilities("app_api"):
+                return
+            if int_log_lvl < self.capabilities["app_api"].get("loglevel", 0):
+                return
+        with contextlib.suppress(Exception):
+            self._session.ocs("POST", f"{self._session.ae_url}/log", json={"level": int_log_lvl, "message": content})
 
     def users_list(self) -> list[str]:
-        """Returns list of users on the Nextcloud instance. **Available** only for ``System`` applications."""
+        """Returns list of users on the Nextcloud instance."""
         return self._session.ocs("GET", f"{self._session.ae_url}/users")
 
     @property
     def user(self) -> str:
         """Property containing the current user ID.
 
-        **System Applications** can change user ID they impersonate with **set_user** method.
+        **ExApps** can change user ID they impersonate with **set_user** method.
         """
         return self._session.user
 
@@ -421,6 +457,10 @@ class AsyncNextcloudApp(_AsyncNextcloudBasic):
     """Nextcloud UI API for ExApps"""
     providers: AsyncProvidersApi
     """API for registering providers for Nextcloud"""
+    events_listener: AsyncEventsListenerAPI
+    """API for registering Events listeners for ExApps"""
+    occ_commands: AsyncOccCommandsAPI
+    """API for registering OCC command for ExApps"""
 
     def __init__(self, **kwargs):
         """The parameters will be taken from the environment.
@@ -433,24 +473,40 @@ class AsyncNextcloudApp(_AsyncNextcloudBasic):
         self.preferences_ex = AsyncPreferencesExAPI(self._session)
         self.ui = AsyncUiApi(self._session)
         self.providers = AsyncProvidersApi(self._session)
+        self.events_listener = AsyncEventsListenerAPI(self._session)
+        self.occ_commands = AsyncOccCommandsAPI(self._session)
+
+    @property
+    async def enabled_state(self) -> bool:
+        """Returns ``True`` if ExApp is enabled, ``False`` otherwise."""
+        with contextlib.suppress(Exception):
+            return bool(await self._session.ocs("GET", "/ocs/v1.php/apps/app_api/ex-app/state"))
+        return False
 
-    async def log(self, log_lvl: LogLvl, content: str) -> None:
+    async def log(self, log_lvl: LogLvl, content: str, fast_send: bool = False) -> None:
         """Writes log to the Nextcloud log file."""
-        if await self.check_capabilities("app_api"):
-            return
-        if int(log_lvl) < (await self.capabilities)["app_api"].get("loglevel", 0):
-            return
-        await self._session.ocs("POST", f"{self._session.ae_url}/log", json={"level": int(log_lvl), "message": content})
+        int_log_lvl = int(log_lvl)
+        if int_log_lvl < 0 or int_log_lvl > 4:
+            raise ValueError("Invalid `log_lvl` value")
+        if not fast_send:
+            if await self.check_capabilities("app_api"):
+                return
+            if int_log_lvl < (await self.capabilities)["app_api"].get("loglevel", 0):
+                return
+        with contextlib.suppress(Exception):
+            await self._session.ocs(
+                "POST", f"{self._session.ae_url}/log", json={"level": int_log_lvl, "message": content}
+            )
 
     async def users_list(self) -> list[str]:
-        """Returns list of users on the Nextcloud instance. **Available** only for ``System`` applications."""
+        """Returns list of users on the Nextcloud instance."""
         return await self._session.ocs("GET", f"{self._session.ae_url}/users")
 
     @property
     async def user(self) -> str:
         """Property containing the current user ID.
 
-        **System Applications** can change user ID they impersonate with **set_user** method.
+        **ExApps** can change user ID they impersonate with **set_user** method.
         """
         return await self._session.user
 

nc_py_api/talk_bot.py

@@ -29,6 +29,11 @@ class TalkBotMessage:
     def __init__(self, raw_data: dict):
         self._raw_data = raw_data
 
+    @property
+    def message_type(self) -> str:
+        """The type of message like Join, Leave, Create, Activity, etc."""
+        return self._raw_data["type"]
+
     @property
     def actor_id(self) -> str:
         """One of the attendee types followed by the ``/`` character and a unique identifier within the given type.

nc_py_api/users.py

@@ -369,8 +369,8 @@ class _AsyncUsersAPI:
 
 
 def _create(user_id: str, display_name: str | None, **kwargs) -> dict[str, typing.Any]:
-    password = kwargs.get("password", None)
-    email = kwargs.get("email", None)
+    password = kwargs.get("password")
+    email = kwargs.get("email")
     if not password and not email:
         raise ValueError("Either password or email must be set")
     data = {"userid": user_id}
@@ -378,5 +378,5 @@ def _create(user_id: str, display_name: str | None, **kwargs) -> dict[str, typin
         if k in kwargs:
             data[k] = kwargs[k]
     if display_name is not None:
-        data["displayname"] = display_name
+        data["displayName"] = display_name
     return data

nc_py_api/webhooks.py

@@ -0,0 +1,224 @@
+"""Nextcloud Webhooks API."""
+
+import dataclasses
+
+from ._misc import clear_from_params_empty  # , require_capabilities
+from ._session import AppConfig, AsyncNcSessionBasic, NcSessionBasic
+
+
+@dataclasses.dataclass
+class WebhookInfo:
+    """Information about the Webhook."""
+
+    def __init__(self, raw_data: dict):
+        self._raw_data = raw_data
+
+    @property
+    def webhook_id(self) -> int:
+        """`ID` of the webhook."""
+        return self._raw_data["id"]
+
+    @property
+    def app_id(self) -> str:
+        """`ID` of the ExApp that registered webhook."""
+        return self._raw_data["appId"] if self._raw_data["appId"] else ""
+
+    @property
+    def user_id(self) -> str:
+        """`UserID` if webhook was registered in user context."""
+        return self._raw_data["userId"] if self._raw_data["userId"] else ""
+
+    @property
+    def http_method(self) -> str:
+        """HTTP method used to call webhook."""
+        return self._raw_data["httpMethod"]
+
+    @property
+    def uri(self) -> str:
+        """URL address that will be called for this webhook."""
+        return self._raw_data["uri"]
+
+    @property
+    def event(self) -> str:
+        """Nextcloud PHP event that triggers this webhook."""
+        return self._raw_data["event"]
+
+    @property
+    def event_filter(self):
+        """Mongo filter to apply to the serialized data to decide if firing."""
+        return self._raw_data["eventFilter"]
+
+    @property
+    def user_id_filter(self) -> str:
+        """Currently unknown."""
+        return self._raw_data["userIdFilter"]
+
+    @property
+    def headers(self) -> dict:
+        """Headers that should be added to request when calling webhook."""
+        return self._raw_data["headers"] if self._raw_data["headers"] else {}
+
+    @property
+    def auth_method(self) -> str:
+        """Currently unknown."""
+        return self._raw_data["authMethod"]
+
+    @property
+    def auth_data(self) -> dict:
+        """Currently unknown."""
+        return self._raw_data["authData"] if self._raw_data["authData"] else {}
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__} id={self.webhook_id}, event={self.event}>"
+
+
+class _WebhooksAPI:
+    """The class provides the application management API on the Nextcloud server."""
+
+    _ep_base: str = "/ocs/v1.php/apps/webhook_listeners/api/v1/webhooks"
+
+    def __init__(self, session: NcSessionBasic):
+        self._session = session
+
+    def get_list(self, uri_filter: str = "") -> list[WebhookInfo]:
+        params = {"uri": uri_filter} if uri_filter else {}
+        return [WebhookInfo(i) for i in self._session.ocs("GET", f"{self._ep_base}", params=params)]
+
+    def get_entry(self, webhook_id: int) -> WebhookInfo:
+        return WebhookInfo(self._session.ocs("GET", f"{self._ep_base}/{webhook_id}"))
+
+    def register(
+        self,
+        http_method: str,
+        uri: str,
+        event: str,
+        event_filter: dict | None = None,
+        user_id_filter: str = "",
+        headers: dict | None = None,
+        auth_method: str = "none",
+        auth_data: dict | None = None,
+    ):
+        params = {
+            "httpMethod": http_method,
+            "uri": uri,
+            "event": event,
+            "eventFilter": event_filter,
+            "userIdFilter": user_id_filter,
+            "headers": headers,
+            "authMethod": auth_method,
+            "authData": auth_data,
+        }
+        clear_from_params_empty(["eventFilter", "userIdFilter", "headers", "authMethod", "authData"], params)
+        return WebhookInfo(self._session.ocs("POST", f"{self._ep_base}", json=params))
+
+    def update(
+        self,
+        webhook_id: int,
+        http_method: str,
+        uri: str,
+        event: str,
+        event_filter: dict | None = None,
+        user_id_filter: str = "",
+        headers: dict | None = None,
+        auth_method: str = "none",
+        auth_data: dict | None = None,
+    ):
+        params = {
+            "id": webhook_id,
+            "httpMethod": http_method,
+            "uri": uri,
+            "event": event,
+            "eventFilter": event_filter,
+            "userIdFilter": user_id_filter,
+            "headers": headers,
+            "authMethod": auth_method,
+            "authData": auth_data,
+        }
+        clear_from_params_empty(["eventFilter", "userIdFilter", "headers", "authMethod", "authData"], params)
+        return WebhookInfo(self._session.ocs("POST", f"{self._ep_base}/{webhook_id}", json=params))
+
+    def unregister(self, webhook_id: int) -> bool:
+        return self._session.ocs("DELETE", f"{self._ep_base}/{webhook_id}")
+
+    def unregister_all(self, appid: str = "") -> int:
+        if not appid and isinstance(self._session.cfg, AppConfig):
+            appid = self._session.cfg.app_name
+        else:
+            raise ValueError("The `appid` parameter cannot be empty for non-ExApp use.")
+        return self._session.ocs("DELETE", f"{self._ep_base}/byappid/{appid}")
+
+
+class _AsyncWebhooksAPI:
+    """The class provides the async application management API on the Nextcloud server."""
+
+    _ep_base: str = "/ocs/v1.php/webhooks"
+
+    def __init__(self, session: AsyncNcSessionBasic):
+        self._session = session
+
+    async def get_list(self, uri_filter: str = "") -> list[WebhookInfo]:
+        params = {"uri": uri_filter} if uri_filter else {}
+        return [WebhookInfo(i) for i in await self._session.ocs("GET", f"{self._ep_base}", params=params)]
+
+    async def get_entry(self, webhook_id: int) -> WebhookInfo:
+        return WebhookInfo(await self._session.ocs("GET", f"{self._ep_base}/{webhook_id}"))
+
+    async def register(
+        self,
+        http_method: str,
+        uri: str,
+        event: str,
+        event_filter: dict | None = None,
+        user_id_filter: str = "",
+        headers: dict | None = None,
+        auth_method: str = "none",
+        auth_data: dict | None = None,
+    ):
+        params = {
+            "httpMethod": http_method,
+            "uri": uri,
+            "event": event,
+            "eventFilter": event_filter,
+            "userIdFilter": user_id_filter,
+            "headers": headers,
+            "authMethod": auth_method,
+            "authData": auth_data,
+        }
+        clear_from_params_empty(["eventFilter", "userIdFilter", "headers", "authMethod", "authData"], params)
+        return WebhookInfo(await self._session.ocs("POST", f"{self._ep_base}", json=params))
+
+    async def update(
+        self,
+        webhook_id: int,
+        http_method: str,
+        uri: str,
+        event: str,
+        event_filter: dict | None = None,
+        user_id_filter: str = "",
+        headers: dict | None = None,
+        auth_method: str = "none",
+        auth_data: dict | None = None,
+    ):
+        params = {
+            "id": webhook_id,
+            "httpMethod": http_method,
+            "uri": uri,
+            "event": event,
+            "eventFilter": event_filter,
+            "userIdFilter": user_id_filter,
+            "headers": headers,
+            "authMethod": auth_method,
+            "authData": auth_data,
+        }
+        clear_from_params_empty(["eventFilter", "userIdFilter", "headers", "authMethod", "authData"], params)
+        return WebhookInfo(await self._session.ocs("POST", f"{self._ep_base}/{webhook_id}", json=params))
+
+    async def unregister(self, webhook_id: int) -> bool:
+        return await self._session.ocs("DELETE", f"{self._ep_base}/{webhook_id}")
+
+    async def unregister_all(self, appid: str = "") -> int:
+        if not appid and isinstance(self._session.cfg, AppConfig):
+            appid = self._session.cfg.app_name
+        else:
+            raise ValueError("The `appid` parameter cannot be empty for non-ExApp use.")
+        return await self._session.ocs("DELETE", f"{self._ep_base}/byappid/{appid}")