libapidokuwiki 1.0__tar.gz

libapidokuwiki-1.0/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.3
+Name: libapidokuwiki
+Version: 1.0
+Summary: Asynchronous client for your DokuWiki JSON API
+Keywords: dokuwiki,api,async,client
+Author: Ibryaev Timur
+Author-email: Ibryaev Timur <nicecock@disroot.org>
+License: GPL-3.0-or-later
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Framework :: AsyncIO
+Classifier: Typing :: Typed
+Requires-Dist: aiohttp
+Requires-Dist: pydantic
+Requires-Python: >=3.14
+Project-URL: Homepage, https://codeberg.org/ourempirecommunity/libapidokuwiki
+Project-URL: Repository, https://codeberg.org/ourempirecommunity/libapidokuwiki
+Project-URL: Issues, https://codeberg.org/ourempirecommunity/libapidokuwiki/issues
+Description-Content-Type: text/markdown
+
+# libapidokuwiki
+

libapidokuwiki-1.0/README.md

@@ -0,0 +1,2 @@
+# libapidokuwiki
+

libapidokuwiki-1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "libapidokuwiki"
+version = "1.0"
+description = "Asynchronous client for your DokuWiki JSON API"
+readme = "README.md"
+requires-python = ">=3.14"
+classifiers = [
+    "Intended Audience :: Developers",
+    "Development Status :: 2 - Pre-Alpha",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.14",
+    "Framework :: AsyncIO",
+    "Typing :: Typed",
+]
+keywords = [
+    "dokuwiki",
+    "api",
+    "async",
+    "client",
+]
+dependencies = [
+    "aiohttp",
+    "pydantic",
+]
+
+[project.license]
+text = "GPL-3.0-or-later"
+
+[[project.authors]]
+name = "Ibryaev Timur"
+email = "nicecock@disroot.org"
+
+[project.urls]
+Homepage = "https://codeberg.org/ourempirecommunity/libapidokuwiki"
+Repository = "https://codeberg.org/ourempirecommunity/libapidokuwiki"
+Issues = "https://codeberg.org/ourempirecommunity/libapidokuwiki/issues"
+
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14.0"]
+build-backend = "uv_build"

libapidokuwiki-1.0/pyproject.toml.orig

@@ -0,0 +1,33 @@
+[project]
+name = "libapidokuwiki"
+version = "1.0"
+description = "Asynchronous client for your DokuWiki JSON API"
+readme = "README.md"
+license = {text = "GPL-3.0-or-later"}
+authors = [
+    { name = "Ibryaev Timur", email = "nicecock@disroot.org" }
+]
+requires-python = ">=3.14"
+classifiers = [
+    "Intended Audience :: Developers",
+    "Development Status :: 2 - Pre-Alpha",
+    "License :: OSI Approved :: GNU General Public License v3 (GPLv3)",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.14",
+    "Framework :: AsyncIO",
+    "Typing :: Typed",
+]
+keywords = ["dokuwiki", "api", "async", "client"]
+dependencies = [
+    "aiohttp",
+    "pydantic"
+]
+
+[project.urls]
+Homepage = "https://codeberg.org/ourempirecommunity/libapidokuwiki"
+Repository = "https://codeberg.org/ourempirecommunity/libapidokuwiki"
+Issues = "https://codeberg.org/ourempirecommunity/libapidokuwiki/issues" 
+
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14.0"]
+build-backend = "uv_build"

libapidokuwiki-1.0/src/libapidokuwiki/__init__.py

@@ -0,0 +1,6 @@
+from .client import DokuWikiClient
+
+
+__all__: tuple[str] = (
+    'DokuWikiClient',
+)

libapidokuwiki-1.0/src/libapidokuwiki/client/__init__.py

@@ -0,0 +1,6 @@
+from .base import DokuWikiClient
+
+
+__all__: tuple[str] = (
+    'DokuWikiClient',
+)

libapidokuwiki-1.0/src/libapidokuwiki/client/base.py

@@ -0,0 +1,489 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Iterable
+    from datetime import datetime
+    from aiohttp import ClientResponse
+    from ..types import Payload
+
+from aiohttp import ClientSession, ClientTimeout
+from aiohttp.client_exceptions import ClientResponseError
+
+
+from ..types import (
+    DokuWikiResult,
+    DokuWikiResultString,
+    DokuWikiResultInteger,
+    DokuWikiResultBoolean,
+    DokuWikiResultListString,
+    DokuWikiResultDatetime,
+    DokuWikiResultWhoAmI,
+    DokuWikiResultListPages,
+    DokuWikiResultSearchPages,
+    DokuWikiResultHistory,
+    DokuWikiResultGetPageInfo,
+    DokuWikiResultGetPageLinks,
+    DokuWikiResultListMedia,
+    DokuWikiResulGetMediaInfo,
+)
+from ..enums import core
+from ..errors import (
+    DokuWikiHTTPError, DokuWikiHTMLError,
+    DokuWikiRPCError,
+    DokuWikiDataError,
+    DokuWikiBadRequestError, DokuWikiForbiddenError, DokuWikiNotFoundError, DokuWikiMethodNotAllowedError, DokuWikiInternalServerError, DokuWikiServiceUnaviableError
+)
+
+
+class DokuWikiClient:
+    def __init__(
+        self,
+        url: str,
+        token: str | None = None,
+        timeout: float = 10.0,
+        proxy_url: str | None = None
+    ) -> None:
+        self._url: str = url.rstrip('/') + '/lib/exe/jsonrpc.php'
+        self.__token: str = token
+        self.__headers: dict[str, str] = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        }
+        if token:
+            self.__headers['Authorization'] = 'Bearer ' + token
+
+        self._session: ClientSession | None = None
+        self._timeout: ClientTimeout = ClientTimeout(total=timeout)
+        self._id: int = 0
+        self._proxy = proxy_url
+
+    @property
+    def token(self) -> str:
+        tkn = self.__token
+        if len(tkn) >= 12:
+            return tkn[:3] + '*' * (len(tkn) - 6) + tkn[-3:]
+        elif len(tkn) <= 3:
+            return '*' * len(tkn)
+        return tkn[:3] + '*' * (len(tkn) - 3)
+
+    async def __aenter__(self) -> DokuWikiClient:
+        if self._session is None or self._session.closed:
+            self._session = ClientSession(
+                headers=self.__headers,
+                proxy=self._proxy,
+                timeout=self._timeout
+            )
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        if self._session and not self._session.closed:
+            await self._session.close()
+
+    def _get_payload(
+        self,
+        method: str,
+        params: Iterable | None
+    ) -> Payload:
+        # Before calling this method, make sure to increment self._id by 1
+        return {
+            'jsonrpc': '2.0',
+            'method': method,
+            'params': params or (),
+            'id': self._id
+        }
+
+
+    @staticmethod
+    def _catch_http_error(response_status: int, method: str) -> None:
+        if 200 <= response_status < 300:
+            return
+
+        match response_status:
+            case 400: raise DokuWikiBadRequestError(method)
+            case 403: raise DokuWikiForbiddenError(method)
+            case 404: raise DokuWikiNotFoundError(method)
+            case 405: raise DokuWikiMethodNotAllowedError(method)
+            case 500: raise DokuWikiInternalServerError(method)
+            case 503: raise DokuWikiServiceUnaviableError(method)
+            case _:   raise DokuWikiHTTPError(response_status, None)
+
+    @staticmethod
+    async def _catch_html_error(response: ClientResponse) -> None:
+        if response.content_type != 'application/json':
+            html_content = await response.text('utf-8')
+            raise DokuWikiHTMLError(response.status, html_content)
+
+    @staticmethod
+    def _catch_data_error(data: dict[str]) -> None:
+        if 'error' in data:
+            error: dict[str] = data['error']
+            raise DokuWikiRPCError(
+                code=error.get('code'),
+                message=error.get('message')
+            )
+
+        if not 'result' in data:
+            raise DokuWikiDataError(
+                code=None,
+                message='JSON-RPC response has neither error nor result'
+            )
+
+
+    @staticmethod
+    def _model_validate_string(data: dict[str]) -> DokuWikiResultString:
+        return DokuWikiResultString.model_validate(data)
+
+    @staticmethod
+    def _model_validate_integer(data: dict[str]) -> DokuWikiResultInteger:
+        return DokuWikiResultInteger.model_validate(data)
+
+    @staticmethod
+    def _model_validate_boolean(data: dict[str]) -> DokuWikiResultBoolean:
+        return DokuWikiResultBoolean.model_validate(data)
+
+    @staticmethod
+    def _model_validate_list_string(data: dict[str]) -> DokuWikiResultListString:
+        return DokuWikiResultListString.model_validate(data)
+
+
+    async def _request(
+        self,
+        method: str,
+        *params
+    ) -> DokuWikiResult:
+        if not self._session:
+            raise RuntimeError('Session isn\'t initialized')
+
+        self._id += 1
+        payload = self._get_payload(method, params)
+
+        try:
+            async with self._session.post(
+                url=self._url,
+                json=payload,
+                allow_redirects=False
+            ) as response:
+                self._catch_http_error(response.status, method)
+                await self._catch_html_error(response)
+
+                data: dict[str] = await response.json()
+                self._catch_data_error(data)
+
+                return data
+
+        except ClientResponseError as e:
+            raise DokuWikiHTTPError(e.status, e.message) from e
+
+
+    # Info
+
+    async def _get_api_version(self) -> DokuWikiResultInteger:
+        return self._model_validate_integer(await self._request(core.Info.GET_API_VERSION.value))
+
+    async def _get_wiki_version(self) -> DokuWikiResultString:
+        return self._model_validate_string(await self._request(core.Info.GET_WIKI_VERSION.value))
+
+    async def _get_wiki_title(self) -> DokuWikiResultString:
+        return self._model_validate_string(await self._request(core.Info.GET_WIKI_TITLE.value))
+
+    async def _get_wiki_time(self) -> DokuWikiResultDatetime:
+        return DokuWikiResultDatetime.model_validate(await self._request(core.Info.GET_WIKI_TIME.value))
+
+    # User
+
+    async def _login(self, user: str, passwd: str) -> DokuWikiResultInteger:
+        return self._model_validate_integer(await self._request(
+            core.User.LOGIN.value,
+            user, passwd
+        ))
+
+    async def _logoff(self) -> DokuWikiResultInteger:
+        return self._model_validate_integer(await self._request(core.User.LOGOFF.value))
+
+    async def _whoami(self) -> DokuWikiResultWhoAmI:
+        return DokuWikiResultWhoAmI.model_validate(await self._request(core.User.WHO_AM_I.value))
+
+    async def _acl_check(self, page: str, user: str = '', groups: list[str] = []) -> DokuWikiResultInteger:
+        return self._model_validate_integer(await self._request(
+            core.User.ACL_CHECK.value,
+            page, user, groups
+        ))
+
+    # Pages
+
+    async def _list_pages(self, namespace: str = '', depth: int = 1, hash: bool = False) -> DokuWikiResultListPages:
+        return DokuWikiResultListPages.model_validate(await self._request(
+            core.Pages.LIST_PAGES.value,
+            namespace, depth, hash
+        ))
+
+    async def _search_pages(self, query: str) -> DokuWikiResultSearchPages:
+        return DokuWikiResultSearchPages.model_validate(await self._request(
+            core.Pages.SEARCH_PAGES.value,
+            query
+        ))
+
+    async def _get_recent_page_changes(self, timestamp: int = 0) -> DokuWikiResultHistory:
+        return DokuWikiResultHistory.model_validate(await self._request(
+            core.Pages.GET_RECENT_PAGE_CHANGES.value,
+            timestamp
+        ))
+
+    async def _get_page(self, page: str, rev: int = 0) -> DokuWikiResultString:
+        return self._model_validate_string(await self._request(
+            core.Pages.GET_PAGE.value,
+            page, rev
+        ))
+
+    async def _get_page_html(self, page: str, rev: int = 0) -> DokuWikiResultString:
+        return self._model_validate_string(await self._request(
+            core.Pages.GET_PAGE_HTML.value,
+            page, rev
+        ))
+
+    async def _get_page_info(self, page: str, rev: datetime = 0, author: bool = False, hash: bool = False) -> DokuWikiResultGetPageInfo:
+        return DokuWikiResultGetPageInfo.model_validate(await self._request(
+            core.Pages.GET_PAGE_INFO.value,
+            page, rev, author, hash
+        ))
+
+    async def _get_page_history(self, page: str, first: int = 0) -> DokuWikiResultHistory:
+        return DokuWikiResultHistory.model_validate(await self._request(
+            core.Pages.GET_PAGE_HISTORY.value,
+            page, first
+        ))
+
+    async def _get_page_links(self, page: str) -> DokuWikiResultGetPageLinks:
+        return DokuWikiResultGetPageLinks.model_validate(await self._request(
+            core.Pages.GET_PAGE_LINKS.value,
+            page
+        ))
+
+    async def _get_page_back_links(self, page: str) -> DokuWikiResultListString:
+        return self._model_validate_list_string(await self._request(
+            core.Pages.GET_PAGE_BACK_LINKS.value,
+            page
+        ))
+
+    async def _lock_pages(self, pages: list[str]) -> DokuWikiResultListString:
+        return self._model_validate_list_string(await self._request(
+            core.Pages.LOCK_PAGES.value,
+            pages
+        ))
+
+    async def _unlock_pages(self, pages: list[str]) -> DokuWikiResultListString:
+        return self._model_validate_list_string(await self._request(
+            core.Pages.UNLOCK_PAGES.value,
+            pages
+        ))
+
+    async def _save_page(self, page: str, text: str, summary: str = '', isminor: bool = False) -> DokuWikiResultBoolean:
+        return self._model_validate_boolean(await self._request(
+            core.Pages.SAVE_PAGE.value,
+            page, text, summary, isminor
+        ))
+
+    async def _append_page(self, page: str, text: str, summary: str = '', isminor: bool = False) -> DokuWikiResultBoolean:
+        return self._model_validate_boolean(await self._request(
+            core.Pages.APPEND_PAGE.value,
+            page, text, summary, isminor
+        ))
+
+
+    # Info
+
+    async def get_api_version(self):
+        result = await self._get_api_version()
+        return result.result
+
+    async def get_wiki_version(self):
+        result = await self._get_wiki_version()
+        return result.result
+
+    async def get_wiki_title(self):
+        result = await self._get_wiki_title()
+        return result.result
+
+    async def get_wiki_time(self):
+        result = await self._get_wiki_time()
+        return result.result
+
+    # User
+
+    async def login(
+        self,
+        login: str,
+        password: str
+    ):
+        result = await self._login(
+            user=login,
+            passwd=password
+        )
+        return result.result
+
+    async def logoff(self):
+        result = await self._logoff()
+        return result.result
+
+    async def whoami(self):
+        result = await self._whoami()
+        return result.result
+
+    async def acl_check(
+        self,
+        id: str,
+        login: str | None = None,
+        groups: list[str] | None = None
+    ):
+        result = await self._acl_check(
+            page=id,
+            user=login or '',
+            groups=groups or []
+        )
+        return result.result
+
+    # Pages
+
+    async def list_pages(
+        self,
+        namespace: str | None = None,
+        depth: int | None = None,
+        include_hash: bool | None = None
+    ):
+        result = await self._list_pages(
+            namespace=namespace or '',
+            depth=depth or 1,
+            hash=include_hash or False
+        )
+        return result.result
+
+    async def search_pages(
+        self,
+        text_to_search: str
+    ):
+        result = await self._search_pages(
+            query=text_to_search
+        )
+        return result.result
+
+    async def get_recent_page_changes(
+        self,
+        time: datetime | None = None
+    ):
+        result = await self._get_recent_page_changes(
+            timestamp=int(time.time()) or 0
+        )
+        return result.result
+
+    async def get_page(
+        self,
+        page_id: str,
+        revision_time: datetime | None = None
+    ):
+        result = await self._get_page(
+            page=page_id,
+            rev=int(revision_time.timestamp()) or 0
+        )
+        return result.result
+
+    async def get_page_html(
+        self,
+        page_id: str,
+        revision_time: datetime | None = None
+    ):
+        result = await self._get_page_html(
+            page=page_id,
+            rev=int(revision_time.timestamp()) or 0
+        )
+        return result.result
+
+    async def get_page_info(
+        self,
+        page_id: str,
+        revision_time: datetime | None = None,
+        show_author: bool | None = None,
+        include_hash: bool | None = None
+    ):
+        result = await self._get_page_info(
+            page=page_id,
+            rev=int(revision_time.timestamp()) or 0,
+            author=show_author or False,
+            hash=include_hash or False
+        )
+        return result.result
+
+    async def get_page_history(
+        self,
+        page_id: str,
+        skip_N_versions: int | None = None
+    ):
+        result = await self._get_page_history(
+            page=page_id,
+            first=skip_N_versions
+        )
+        return result.result
+
+    async def get_page_links(
+        self,
+        page_id: str
+    ):
+        result = await self._get_page_links(page_id)
+        return result.result
+
+    async def get_page_back_links(
+        self,
+        page_id: str
+    ):
+        result = await self._get_page_back_links(
+            page=page_id
+        )
+        return result.result
+
+    async def lock_pages(
+        self,
+        pages_id: list[str]
+    ):
+        result = await self._lock_pages(
+            pages=pages_id
+        )
+        return result.result
+
+    async def unlock_pages(
+        self,
+        pages_id: list[str]
+    ):
+        result = await self._unlock_pages(
+            pages=pages_id
+        )
+        return result.result
+
+    async def save_page(
+        self,
+        page_id: str,
+        new_text: str,
+        comment: str | None = None,
+        is_minor: bool | None = None
+    ):
+        result = await self._save_page(
+            page=page_id,
+            text=new_text,
+            summary=comment or '',
+            isminor=is_minor or False
+        )
+        return result.result
+
+    async def append_page(
+        self,
+        page_id: str,
+        text_to_append: str,
+        comment: str | None = None,
+        is_minor: bool | None = None
+    ):
+        result = await self._append_page(
+            page=page_id,
+            text=text_to_append,
+            summary=comment or '',
+            isminor=is_minor or False
+        )
+        return result.result

libapidokuwiki-1.0/src/libapidokuwiki/enums/__init__.py

@@ -0,0 +1,14 @@
+from .change_type import ChangeType
+from .page_link_type import PageLinkType
+from .acl import Acl
+
+from .operations import core
+
+
+__all__: tuple[str] = (
+    'ChangeType',
+    'PageLinkType',
+    'Acl',
+
+    'core',
+)

libapidokuwiki-1.0/src/libapidokuwiki/enums/acl.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from enum import IntFlag
+
+class Acl(IntFlag):
+    """
+    Bitmask of the users' rights.
+    """
+
+    NONE = 0
+    READ = 1
+    EDIT = 2
+    CREATE = 4
+    UPLOAD = 8
+    DELETE = 16
+    ADMIN = 255
+
+    # Backward compatibility aliases
+    AUTH_NONE = 0
+    AUTH_READ = 1
+    AUTH_EDIT = 2
+    AUTH_CREATE = 4
+    AUTH_UPLOAD = 8
+    AUTH_DELETE = 16
+    AUTH_ADMIN = 255

libapidokuwiki-1.0/src/libapidokuwiki/enums/change_type.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+from enum import Enum
+
+
+class ChangeType(str, Enum):
+    """Type of change"""
+
+    E = 'E'
+    """edit"""
+    C = 'C'
+    """create"""
+    D = 'D'
+    """delete"""
+    R = 'R'
+    """revert"""
+
+    e = 'e'
+    """edit"""
+    c = 'c'
+    """create"""
+    d = 'd'
+    """delete"""
+    r = 'r'
+    """revert"""

libapidokuwiki-1.0/src/libapidokuwiki/enums/operations/__init__.py

@@ -0,0 +1,6 @@
+from . import core
+
+
+__all__: tuple[str] = (
+    'core',
+)

libapidokuwiki-1.0/src/libapidokuwiki/enums/operations/core/__init__.py

@@ -0,0 +1,12 @@
+from .info import Info
+from .user import User
+from .pages import Pages
+from .media import Media
+
+
+__all__: tuple[str] = (
+    'Info',
+    'User',
+    'Pages',
+    'Media',
+)

libapidokuwiki-1.0/src/libapidokuwiki/enums/operations/core/info.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from enum import Enum
+
+
+class Info(str, Enum):
+    GET_API_VERSION = 'core.getAPIVersion'
+    GET_WIKI_VERSION = 'core.getWikiVersion'
+    GET_WIKI_TITLE = 'core.getWikiTitle'
+    GET_WIKI_TIME = 'core.getWikiTime'

libapidokuwiki-1.0/src/libapidokuwiki/enums/operations/core/media.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+from enum import Enum
+
+
+class Media(str, Enum):
+    LIST_MEDIA = 'core.listMedia'
+    GET_RECENT_MEDIA_CHANGES = 'core.getRecentMediaChanges'
+    GET_MEDIA = 'core.getMedia'
+    GET_MEDIA_INFO = 'core.getMediaInfo'
+    GET_MEDIA_USAGE = 'core.getMediaUsage'
+    GET_MEDIA_HISTORY = 'core.getMediaHistory'
+    SAVE_MEDIA = 'core.saveMedia'
+    DELETE_MEDIA = 'core.deleteMedia'

libapidokuwiki-1.0/src/libapidokuwiki/enums/operations/core/pages.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+from enum import Enum
+
+
+class Pages(str, Enum):
+    LIST_PAGES = 'core.listPages'
+    SEARCH_PAGES = 'core.searchPages'
+    GET_RECENT_PAGE_CHANGES = 'core.getRecentPageChanges'
+    GET_PAGE = 'core.getPage'
+    GET_PAGE_HTML = 'core.getPageHTML'
+    GET_PAGE_INFO = 'core.getPageInfo'
+    GET_PAGE_HISTORY = 'core.getPageHistory'
+    GET_PAGE_LINKS = 'core.getPageLinks'
+    GET_PAGE_BACK_LINKS = 'core.getPageBackLinks'
+    LOCK_PAGES = 'core.lockPages'
+    UNLOCK_PAGES = 'core.unlockPages'
+    SAVE_PAGE = 'core.savePage'
+    APPEND_PAGE = 'core.appendPage'

libapidokuwiki-1.0/src/libapidokuwiki/enums/operations/core/user.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from enum import Enum
+
+
+class User(str, Enum):
+    LOGIN = 'core.login'
+    LOGOFF = 'core.logoff'
+    WHO_AM_I = 'core.whoAmI'
+    ACL_CHECK = 'core.aclCheck'

libapidokuwiki-1.0/src/libapidokuwiki/enums/page_link_type.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from enum import Enum
+
+
+class PageLinkType(str, Enum):
+    """Type of page link"""
+
+    local = 'local'
+    extern = 'extern'

libapidokuwiki-1.0/src/libapidokuwiki/errors.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+from re import (
+    IGNORECASE, DOTALL,
+    search
+)
+
+
+class _DokuWikiError(Exception):
+    def __init__(
+        self,
+        error_name: str | None = None,
+        code: int | None = None,
+        message: str | None = None
+    ):
+        error_name: str = error_name or 'Unnamed Error'
+        code: int = -1 if code is None else code
+        message: str = message or 'Unknown ' + error_name
+        super().__init__(f'{error_name} {code}: {message}')
+
+
+class DokuWikiHTMLError(_DokuWikiError):
+    def __init__(self, code: int | None, html_content: str | None):
+        message: str | None = None
+        if html_content:
+            title_match = search(r'<title[^>]*>(.*?)</title>', html_content, IGNORECASE | DOTALL)
+            message = title_match.group(1).strip() if title_match else None
+        
+        super().__init__(
+            error_name='HTML Error',
+            code=code,
+            message=message
+        )
+
+class DokuWikiHTTPError(_DokuWikiError):
+    def __init__(self, code: int | None, message: str | None):
+        super().__init__(
+            error_name='HTTP Error',
+            code=code,
+            message=message
+        )
+
+class DokuWikiDataError(_DokuWikiError):
+    def __init__(self, code: int | None, message: str | None):
+        super().__init__(
+            error_name='JSON Data Error',
+            code=code,
+            message=message
+        )
+
+class DokuWikiRPCError(DokuWikiDataError):
+    def __init__(self, code: int | None, message: str | None):
+        super().__init__(
+            error_name='JSON-RPC Error',
+            code=code,
+            message=message
+        )
+
+
+class _DokuWikiSpecifiedError(DokuWikiHTTPError):
+    def __init__(self, code: int, message: str):
+        super().__init__(code, message)
+
+class DokuWikiBadRequestError(_DokuWikiSpecifiedError):
+    def __init__(self, method: str):
+        super().__init__(
+            code=400,
+            message=f'Bad request for method \'{method}\'. Is it exists? Does you have required plugins installed?'
+        )
+
+class DokuWikiForbiddenError(_DokuWikiSpecifiedError):
+    def __init__(self, method: str):
+        super().__init__(
+            code=403,
+            message=f'Forbidden for method \'{method}\'. Does your token have required permissions?'
+        )
+
+class DokuWikiNotFoundError(_DokuWikiSpecifiedError):
+    def __init__(self, method: str):
+        super().__init__(
+            code=404,
+            message=f'Not found for method \'{method}\'. Is it exists? Does you have required plugins installed?'
+        )
+
+class DokuWikiMethodNotAllowedError(_DokuWikiSpecifiedError):
+    def __init__(self, method: str):
+        super().__init__(
+            code=405,
+            message=f'Method not allowed for method \'{method}\'. Is it exists? Does you have required plugins installed?'
+        )
+
+class DokuWikiInternalServerError(_DokuWikiSpecifiedError):
+    def __init__(self, method: str):
+        super().__init__(
+            code=500,
+            message=f'Internal server error for method \'{method}\'. Try again later or contact your server administrator'
+        )
+
+class DokuWikiServiceUnaviableError(_DokuWikiSpecifiedError):
+    def __init__(self, method: str):
+        super().__init__(
+            code=503,
+            message=f'Service unavailable for method \'{method}\'. Try again later or contact your server administrator'
+        )

libapidokuwiki-1.0/src/libapidokuwiki/models/__init__.py

@@ -0,0 +1,18 @@
+from .base import DokuWikiObject
+from .user import User
+from .page import Page
+from .link import Link
+from .media import Media
+from .version import Version
+from .search import Search
+
+
+__all__: tuple[str] = (
+    'DokuWikiObject',
+    'User',
+    'Page',
+    'Link',
+    'Media',
+    'Version',
+    'Search',
+)

libapidokuwiki-1.0/src/libapidokuwiki/models/base.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class DokuWikiObject(BaseModel):
+    """
+    Base DokuWiki object.
+    """
+
+    model_config = ConfigDict(frozen=True)

libapidokuwiki-1.0/src/libapidokuwiki/models/link.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+from .base import DokuWikiObject
+
+
+class Link(DokuWikiObject):
+    type: str
+    page: str
+    href: str

libapidokuwiki-1.0/src/libapidokuwiki/models/media.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from datetime import datetime
+
+from .base import DokuWikiObject
+
+
+class Media(DokuWikiObject):
+    id: str
+    revision: datetime
+    size: int
+    permission: int
+    isimage: bool
+    hash: str
+    author: str

libapidokuwiki-1.0/src/libapidokuwiki/models/page.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from datetime import datetime
+
+from .base import DokuWikiObject
+
+
+class Page(DokuWikiObject):
+    id: str
+    revision: datetime
+    size: int
+    title: str
+    permission: int
+    hash: str
+    author: str

libapidokuwiki-1.0/src/libapidokuwiki/models/search.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from datetime import datetime
+
+from .base import DokuWikiObject
+
+
+class Search(DokuWikiObject):
+    id: str
+    revision: datetime
+    size: int
+    title: str
+    permission: int
+    hash: str
+    author: str
+    score: int
+    snippet: str

libapidokuwiki-1.0/src/libapidokuwiki/models/user.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from .base import DokuWikiObject
+
+
+class User(DokuWikiObject):
+    login: str
+    name: str
+    mail: str
+    groups: list[str]
+    isadmin: bool
+    ismanager: bool

libapidokuwiki-1.0/src/libapidokuwiki/models/version.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+from datetime import datetime
+
+from .base import DokuWikiObject
+
+
+class Version(DokuWikiObject):
+    id: str
+    revision: datetime
+    author: str
+    ip: str
+    summary: str
+    type: str
+    sizechange: int

libapidokuwiki-1.0/src/libapidokuwiki/types/__init__.py

@@ -0,0 +1,41 @@
+from .payload import Payload
+
+from .base import DokuWikiResult, DokuWikiError
+from .base_results import (
+    DokuWikiResultString,
+    DokuWikiResultInteger,
+    DokuWikiResultBoolean,
+    DokuWikiResultListString,
+    DokuWikiResultDatetime,
+    DokuWikiResultWhoAmI,
+    DokuWikiResultListPages,
+    DokuWikiResultSearchPages,
+    DokuWikiResultHistory,
+    DokuWikiResultGetPageInfo,
+    DokuWikiResultGetPageLinks,
+    DokuWikiResultListMedia,
+    DokuWikiResulGetMediaInfo,
+)
+
+
+__all__: tuple[str] = (
+    'Payload',
+
+    'DokuWikiResult',
+    'DokuWikiError',
+
+    'DokuWikiResultString',
+    'DokuWikiResultInteger',
+    'DokuWikiResultBoolean',
+    'DokuWikiResultListString',
+    'DokuWikiResultDatetime',
+    'DokuWikiResultAclCheck',
+    'DokuWikiResultWhoAmI',
+    'DokuWikiResultListPages',
+    'DokuWikiResultSearchPages',
+    'DokuWikiResultHistory',
+    'DokuWikiResultGetPageInfo',
+    'DokuWikiResultGetPageLinks',
+    'DokuWikiResultListMedia',
+    'DokuWikiResulGetMediaInfo',
+)

libapidokuwiki-1.0/src/libapidokuwiki/types/base.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class DokuWikiReturnBase(BaseModel):
+    jsonrpc: str
+    id: int
+
+class DokuWikiResult(DokuWikiReturnBase):
+    result: Any
+
+class _DokuWikiErrorInner(BaseModel):
+    code: int
+    message: str
+    data: Any | None = None
+
+class DokuWikiError(DokuWikiReturnBase):
+    error: _DokuWikiErrorInner

libapidokuwiki-1.0/src/libapidokuwiki/types/base_results.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+from datetime import datetime
+
+from .base import DokuWikiResult
+from ..models import User
+from ..models import Page
+from ..models import Search
+from ..models import Version
+from ..models import Link
+from ..models import Media
+
+
+class DokuWikiResultString(DokuWikiResult):
+    result: str
+
+class DokuWikiResultInteger(DokuWikiResult):
+    result: int
+
+class DokuWikiResultBoolean(DokuWikiResult):
+    result: bool
+
+class DokuWikiResultListString(DokuWikiResult):
+    result: list[str]
+
+class DokuWikiResultDatetime(DokuWikiResult):
+    result: datetime
+
+
+class DokuWikiResultWhoAmI(DokuWikiResult):
+    result: User
+
+class DokuWikiResultListPages(DokuWikiResult):
+    result: list[Page]
+
+class DokuWikiResultSearchPages(DokuWikiResult):
+    result: list[Search]
+
+class DokuWikiResultHistory(DokuWikiResult):
+    result: list[Version]
+
+class DokuWikiResultGetPageInfo(DokuWikiResult):
+    result: Page
+
+class DokuWikiResultGetPageLinks(DokuWikiResult):
+    result: list[Link]
+
+class DokuWikiResultListMedia(DokuWikiResult):
+    result: list[Media]
+
+class DokuWikiResulGetMediaInfo(DokuWikiResult):
+    result: Media

libapidokuwiki-1.0/src/libapidokuwiki/types/payload.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+from typing import TypedDict
+
+
+class Payload(TypedDict):
+    jsonrpc: str
+    method: str
+    params: list
+    id: int