notex-python 0.1.0__py3-none-any.whl

notex/__init__.py

@@ -0,0 +1,105 @@
+"""Public API for the NoteX Python SDK."""
+
+from notex_sdk import (
+    API_V1,
+    API_V2,
+    CREDITS_ME_ENDPOINT,
+    CREDITS_QUOTA_ENDPOINT,
+    DEFAULT_BASE_URL,
+    FLASHCARDS_CREATE_ENDPOINT,
+    MINDMAP_CREATE_ENDPOINT,
+    NOTE_CREATE_ENDPOINT,
+    NOTE_VALIDATE_ENDPOINT,
+    PODCAST_CREATE_ENDPOINT,
+    PRESIGNED_URL_ENDPOINT,
+    QUIZ_CREATE_ENDPOINT,
+    QUIZ_VIDEO_CREATE_ENDPOINT,
+    SHORTS_CREATE_ENDPOINT,
+    SLIDE_CREATE_ENDPOINT,
+    TASK_RESULT_ENDPOINT,
+    TRANSLATE_CREATE_ENDPOINT,
+    USER_NOTES_ENDPOINT,
+    USER_PROFILE_ENDPOINT,
+    AsyncNotexClient,
+    Credits,
+    Flashcard,
+    FlashcardSet,
+    GeneratedNote,
+    Mindmap,
+    MindmapNode,
+    NoteItem,
+    NotesPage,
+    NotexAPIError,
+    NotexAuthenticationError,
+    NotexClient,
+    NotexPermissionError,
+    NotexRateLimitError,
+    NotexTaskError,
+    NotexUploadError,
+    Podcast,
+    QuizQuestion,
+    QuizSet,
+    Quota,
+    RetryPolicy,
+    SlideDeck,
+    SourceValidation,
+    TaskResult,
+    TaskStatus,
+    TaskSubmission,
+    UrllibTransport,
+    UserProfile,
+    Video,
+)
+
+__all__ = [
+    "NotexClient",
+    "AsyncNotexClient",
+    "NotexAPIError",
+    "NotexAuthenticationError",
+    "NotexPermissionError",
+    "NotexRateLimitError",
+    "NotexUploadError",
+    "NotexTaskError",
+    "Credits",
+    "GeneratedNote",
+    "Flashcard",
+    "FlashcardSet",
+    "QuizQuestion",
+    "QuizSet",
+    "MindmapNode",
+    "Mindmap",
+    "Podcast",
+    "Video",
+    "SlideDeck",
+    "Quota",
+    "UserProfile",
+    "NoteItem",
+    "NotesPage",
+    "SourceValidation",
+    "TaskSubmission",
+    "TaskResult",
+    "TaskStatus",
+    "RetryPolicy",
+    "UrllibTransport",
+    "DEFAULT_BASE_URL",
+    "API_V1",
+    "API_V2",
+    "CREDITS_ME_ENDPOINT",
+    "CREDITS_QUOTA_ENDPOINT",
+    "USER_PROFILE_ENDPOINT",
+    "USER_NOTES_ENDPOINT",
+    "TASK_RESULT_ENDPOINT",
+    "PRESIGNED_URL_ENDPOINT",
+    "NOTE_CREATE_ENDPOINT",
+    "NOTE_VALIDATE_ENDPOINT",
+    "FLASHCARDS_CREATE_ENDPOINT",
+    "MINDMAP_CREATE_ENDPOINT",
+    "PODCAST_CREATE_ENDPOINT",
+    "QUIZ_CREATE_ENDPOINT",
+    "SHORTS_CREATE_ENDPOINT",
+    "QUIZ_VIDEO_CREATE_ENDPOINT",
+    "SLIDE_CREATE_ENDPOINT",
+    "TRANSLATE_CREATE_ENDPOINT",
+]
+
+__version__ = "0.1.0"

notex/py.typed

@@ -0,0 +1 @@
+

notex_python-0.1.0.dist-info/METADATA

@@ -0,0 +1,323 @@
+Metadata-Version: 2.4
+Name: notex-python
+Version: 0.1.0
+Summary: Typed, dependency-free Python SDK for the NoteX API
+Author: NoteX
+License-Expression: MIT
+Project-URL: Homepage, https://notexapp.com
+Project-URL: Documentation, https://be-docs.notexapp.com
+Keywords: notex,ai,notes,sdk,api-client
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pyright>=1.1.400; extra == "dev"
+Requires-Dist: ruff>=0.12; extra == "dev"
+Requires-Dist: twine>=6; extra == "dev"
+Dynamic: license-file
+
+# NoteX Python SDK
+
+Typed, dependency-free Python SDK for API-key-enabled NoteX endpoints.
+
+```bash
+pip install notex-python
+```
+
+```python
+from notex import NotexClient
+
+client = NotexClient(api_key="ntx_live_xxx")
+```
+
+Requires Python 3.9 or newer.
+
+## Naming convention
+
+The public SDK has one flat, explicit naming convention:
+
+| Operation | Convention | Examples |
+| --- | --- | --- |
+| Read one value | `get_<resource>()` | `get_profile()`, `get_task_result()` |
+| Read a collection | `list_<resources>()` | `list_notes()` |
+| Validate input | `validate_<resource>()` | `validate_source()` |
+| Create content | `create_<resource>()` | `create_note()`, `create_quiz()` |
+| Wait for an async operation | `wait_for_<resource>()` | `wait_for_task()` |
+
+Sync and async clients expose the same method names. The async variants are
+awaited.
+
+## Multi-user integration
+
+Each client represents one user API key for one request or background job.
+Do not mutate a singleton client's key between users.
+
+```python
+from notex import NotexClient
+
+
+def notex_for_connection(connection_id: str) -> NotexClient:
+    api_key = credential_store.decrypt(connection_id)
+    return NotexClient(api_key=api_key)
+```
+
+The SDK does not create, list, delete, persist, or automatically load API
+keys. The integrating backend owns credential storage and rotation.
+
+## Supported methods
+
+### Account and notes
+
+```python
+credits = client.get_credits()
+quota = client.get_quota()
+profile = client.get_profile()
+notes = client.list_notes(limit=20, sort_field="createdAt", sort_order=-1)
+```
+
+Credit fields vary by account/plan. `Credits` exposes optional
+`total_credits`, `reward_credits`, `purchased_credits`, `user_type`, and
+`has_paid`, while `raw` preserves the complete backend payload. `balance` is
+an optional compatibility alias for responses that provide `balance` or
+`total_credits`.
+
+### Validate and create notes
+
+Create a note from a web URL:
+
+```python
+submission = client.create_note(
+    web_url="https://youtu.be/example",
+    language_hints=["en"],
+)
+```
+
+Convenience equivalent:
+
+```python
+submission = client.create_note_from_url(
+    "https://youtu.be/example",
+    language_hints=["en"],
+)
+```
+
+Create a note from an existing NoteX file URL:
+
+```python
+submission = client.create_note_from_file_url(
+    "audio/user-1/lecture.mp3",
+    language_hints=["en"],
+)
+```
+
+Create a note from a local file:
+
+```python
+submission = client.create_note_from_file(
+    "./lecture.mp3",
+    upload_file_name="lecture.mp3",
+    language_hints=["en"],
+    content_type="audio/mpeg",
+)
+```
+
+The local-file method performs the complete internal flow:
+
+1. Request a presigned upload contract.
+2. Upload the file directly without the NoteX API key.
+3. Submit note creation using the returned `file_url`.
+
+Presign and direct-upload helpers are intentionally private. Use
+`upload_file_name` when the local filename contains characters rejected by the
+target gateway or object storage.
+
+Validate a source before spending credits:
+
+```python
+validation = client.validate_source(web_url="https://youtu.be/example")
+```
+
+Exactly one of `web_url` or `file_url` is accepted by `create_note()` and
+`validate_source()`.
+
+### Create content from a note
+
+All create methods return `TaskSubmission` with a `task_id`.
+
+```python
+flashcards = client.create_flashcards(
+    "note-id",
+    num_cards=10,
+    difficulty="medium",
+)
+quiz = client.create_quiz("note-id", num_questions=10)
+mindmap = client.create_mindmap("note-id")
+podcast = client.create_podcast("note-id", duration=180)
+shorts = client.create_shorts("note-id", voice_id="en-US-Standard-A")
+quiz_video = client.create_quiz_video("note-id", voice_id="en-US-Standard-A")
+slides = client.create_slide("note-id", template_id="default", language="en")
+translation = client.create_translation("note-id", language="vi")
+```
+
+### Poll task results
+
+Use `get_task_result()` when the integrating backend manages scheduling:
+
+```python
+result = client.get_task_result(submission.task_id)
+```
+
+Use `wait_for_task()` in a worker when a blocking helper is appropriate:
+
+```python
+result = client.wait_for_task(
+    submission.task_id,
+    poll_interval=5,
+    timeout=120,
+)
+```
+
+Do not run file uploads or blocking task polling directly in a web request.
+Use a durable queue or background worker.
+
+Completed results can be parsed into feature-specific typed models:
+
+```python
+from notex import FlashcardSet
+
+result = client.wait_for_task(flashcards.task_id)
+flashcard_set = FlashcardSet.from_task_result(result)
+print(flashcard_set.cards[0].front)
+```
+
+Available result models include `GeneratedNote`, `FlashcardSet`, `QuizSet`,
+`Mindmap`, `Podcast`, `Video`, and `SlideDeck`.
+
+## Async client
+
+`AsyncNotexClient` exposes the same names and runs blocking standard-library
+I/O in worker threads so the event loop remains responsive.
+
+```python
+from notex import AsyncNotexClient
+
+client = AsyncNotexClient(api_key="ntx_live_xxx")
+
+submission = await client.create_quiz("note-id", num_questions=10)
+result = await client.wait_for_task(submission.task_id, timeout=120)
+```
+
+## Errors and retry behavior
+
+```python
+from notex import NotexAuthenticationError, NotexRateLimitError
+
+try:
+    client.get_credits()
+except NotexAuthenticationError:
+    reconnect_notex_account()
+except NotexRateLimitError as error:
+    reschedule_job(error.retry_after)
+```
+
+Public errors:
+
+- `NotexAPIError`
+- `NotexAuthenticationError`
+- `NotexPermissionError`
+- `NotexRateLimitError`
+- `NotexUploadError`
+- `NotexTaskError`
+
+GET and HEAD requests retry transient network failures and HTTP 429/5xx
+responses, honoring `Retry-After`. Content-creating POST requests are not
+retried by default because repeating them can create duplicate work.
+
+## API compatibility
+
+Every high-level method accepts `endpoint=` and `base_url=` overrides. This
+allows an integration to adopt a new backend version before the SDK releases
+an update.
+
+```python
+client.get_credits(endpoint="/v3/credits/me")
+client.create_flashcards("note-id", endpoint="/v7/create/flashcards")
+```
+
+For a documented endpoint that is not wrapped yet, use the low-level escape
+hatch:
+
+```python
+response = client.request(
+    "POST",
+    "/v10/feature",
+    form={"note_id": "note-id"},
+    headers={"Idempotency-Key": "internal-job-id"},
+)
+```
+
+## Real API integration tests
+
+Copy the safe template and put the real key/base URL in the local file:
+
+```powershell
+Copy-Item .notex-test.env.example .notex-test.env
+```
+
+Edit `.notex-test.env`:
+
+```dotenv
+NOTEX_TEST_API_KEY=ntx_test_your_real_key
+NOTEX_TEST_BASE_URL=https://api.notexapp.com
+```
+
+The file is ignored by Git. Read-only tests cover profile, credits, quota, and
+note listing:
+
+```bash
+python -m pytest tests/test_staging_integration.py -v
+```
+
+Creation tests can upload files and spend credits, so they require explicit
+opt-in:
+
+```dotenv
+NOTEX_RUN_WRITE_TESTS=1
+NOTEX_TEST_WEB_URL=https://youtu.be/example
+NOTEX_TEST_FILE=C:\path\to\lecture.mp3
+NOTEX_TEST_NOTE_ID=existing-note-id
+NOTEX_TEST_FEATURES=flashcards,quiz,mindmap,translation
+```
+
+Optional feature configuration is documented in
+`.notex-test.env.example`. Test output is not persisted by the suite; local
+credentials and `.notex-test-results/` are both excluded from Git.
+
+## Development and release checks
+
+```bash
+python -m pip install -e ".[dev]"
+python -m ruff check .
+python -m pyright
+python -m pytest -q
+python -m build
+python -m twine check dist/*
+```
+
+See [RELEASING.md](RELEASING.md) for the Trusted Publishing release flow.
+Never log, commit, or return API keys to frontend clients.

notex_python-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+notex/__init__.py,sha256=OBOztsFwlrmVvQ82zOyetq58UohSSsjuVcwu__dCugk,2220
+notex/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+notex_python-0.1.0.dist-info/licenses/LICENSE,sha256=0r4I_CjDc3JvT4P7yEovJieS72PEtUVTtNbiiWEpQTg,1062
+notex_sdk/__init__.py,sha256=8OGtE4hcOHrug2l8axHLFJOFHsYYgxzSa7tJMLtcq4U,2309
+notex_sdk/async_client.py,sha256=scUJa3dCh8SRQ5DofNbSNkHlya7enOcsSXpeocW-eJI,4534
+notex_sdk/client.py,sha256=LtJMlRydqecwo9gOaKOTx-nO9tGEbgUTqNYg085HrWw,21463
+notex_sdk/config.py,sha256=g45ngEVeBkVgHUmEI_yC8ylntpVKkLScCR3kqG-LpY8,931
+notex_sdk/errors.py,sha256=U2spHvwdDhEqzHeWmhmGEuVyW2u8e_MfGB4hB2euMpo,1260
+notex_sdk/models.py,sha256=HrofQN5H3fs6OQN4nmYSIw_3yEFgq0BJ9hvCwfnrzHI,15794
+notex_sdk/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+notex_sdk/transport.py,sha256=Fse4oU5jwKRqz_SCbq8u4Cm3H9V9VfovU_-GyMn813s,5148
+notex_python-0.1.0.dist-info/METADATA,sha256=RvuaRYHtu391qrzvGqxaDK4HXElWJwQWGs2XaUU8liE,9111
+notex_python-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+notex_python-0.1.0.dist-info/top_level.txt,sha256=grCQy8NrHm0nJ2DNQmu1uzZg2G56SRfPBbcHLSYjI7Q,16
+notex_python-0.1.0.dist-info/RECORD,,

notex_python-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

notex_python-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NoteX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

notex_python-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+notex
+notex_sdk

notex_sdk/__init__.py

@@ -0,0 +1,108 @@
+"""Python SDK for the NoteX API."""
+
+from .async_client import AsyncNotexClient
+from .client import NotexClient
+from .config import (
+    API_V1,
+    API_V2,
+    CREDITS_ME_ENDPOINT,
+    CREDITS_QUOTA_ENDPOINT,
+    DEFAULT_BASE_URL,
+    FLASHCARDS_CREATE_ENDPOINT,
+    MINDMAP_CREATE_ENDPOINT,
+    NOTE_CREATE_ENDPOINT,
+    NOTE_VALIDATE_ENDPOINT,
+    PODCAST_CREATE_ENDPOINT,
+    PRESIGNED_URL_ENDPOINT,
+    QUIZ_CREATE_ENDPOINT,
+    QUIZ_VIDEO_CREATE_ENDPOINT,
+    SHORTS_CREATE_ENDPOINT,
+    SLIDE_CREATE_ENDPOINT,
+    TASK_RESULT_ENDPOINT,
+    TRANSLATE_CREATE_ENDPOINT,
+    USER_NOTES_ENDPOINT,
+    USER_PROFILE_ENDPOINT,
+)
+from .errors import (
+    NotexAPIError,
+    NotexAuthenticationError,
+    NotexPermissionError,
+    NotexRateLimitError,
+    NotexTaskError,
+    NotexUploadError,
+)
+from .models import (
+    Credits,
+    Flashcard,
+    FlashcardSet,
+    GeneratedNote,
+    Mindmap,
+    MindmapNode,
+    NoteItem,
+    NotesPage,
+    Podcast,
+    QuizQuestion,
+    QuizSet,
+    Quota,
+    SlideDeck,
+    SourceValidation,
+    TaskResult,
+    TaskStatus,
+    TaskSubmission,
+    UserProfile,
+    Video,
+)
+from .transport import RetryPolicy, UrllibTransport
+
+__all__ = [
+    "NotexClient",
+    "AsyncNotexClient",
+    "NotexAPIError",
+    "NotexAuthenticationError",
+    "NotexPermissionError",
+    "NotexRateLimitError",
+    "NotexUploadError",
+    "NotexTaskError",
+    "Credits",
+    "GeneratedNote",
+    "Flashcard",
+    "FlashcardSet",
+    "QuizQuestion",
+    "QuizSet",
+    "MindmapNode",
+    "Mindmap",
+    "Podcast",
+    "Video",
+    "SlideDeck",
+    "Quota",
+    "UserProfile",
+    "NoteItem",
+    "NotesPage",
+    "SourceValidation",
+    "TaskSubmission",
+    "TaskResult",
+    "TaskStatus",
+    "RetryPolicy",
+    "UrllibTransport",
+    "DEFAULT_BASE_URL",
+    "API_V1",
+    "API_V2",
+    "CREDITS_ME_ENDPOINT",
+    "CREDITS_QUOTA_ENDPOINT",
+    "USER_PROFILE_ENDPOINT",
+    "USER_NOTES_ENDPOINT",
+    "TASK_RESULT_ENDPOINT",
+    "PRESIGNED_URL_ENDPOINT",
+    "NOTE_CREATE_ENDPOINT",
+    "NOTE_VALIDATE_ENDPOINT",
+    "FLASHCARDS_CREATE_ENDPOINT",
+    "MINDMAP_CREATE_ENDPOINT",
+    "PODCAST_CREATE_ENDPOINT",
+    "QUIZ_CREATE_ENDPOINT",
+    "SHORTS_CREATE_ENDPOINT",
+    "QUIZ_VIDEO_CREATE_ENDPOINT",
+    "SLIDE_CREATE_ENDPOINT",
+    "TRANSLATE_CREATE_ENDPOINT",
+]
+
+__version__ = "0.1.0"

notex_sdk/async_client.py

@@ -0,0 +1,100 @@
+"""Async adapter for the dependency-free synchronous NoteX client."""
+
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from typing import Any, Mapping, Optional, Union
+
+from .client import NotexClient
+from .models import (
+    Credits,
+    NotesPage,
+    Quota,
+    SourceValidation,
+    TaskResult,
+    TaskSubmission,
+    UserProfile,
+)
+
+
+class AsyncNotexClient:
+    """Run a request-scoped :class:`NotexClient` without blocking an event loop.
+
+    This adapter delegates blocking I/O to a worker thread. It is intentionally
+    small; it keeps sync and async behavior identical without adding an HTTP
+    dependency to the SDK.
+    """
+
+    def __init__(self, client: Optional[NotexClient] = None, **client_options: Any) -> None:
+        if client is not None and client_options:
+            raise ValueError("pass either client or client options, not both")
+        self._client = client or NotexClient(**client_options)
+
+    @property
+    def sync_client(self) -> NotexClient:
+        return self._client
+
+    async def get_credits(self, **options: Any) -> Credits:
+        return await asyncio.to_thread(self._client.get_credits, **options)
+
+    async def get_quota(self, **options: Any) -> Quota:
+        return await asyncio.to_thread(self._client.get_quota, **options)
+
+    async def get_profile(self, **options: Any) -> UserProfile:
+        return await asyncio.to_thread(self._client.get_profile, **options)
+
+    async def list_notes(self, **options: Any) -> NotesPage:
+        return await asyncio.to_thread(self._client.list_notes, **options)
+
+    async def validate_source(self, **options: Any) -> SourceValidation:
+        return await asyncio.to_thread(self._client.validate_source, **options)
+
+    async def create_note(self, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_note, **options)
+
+    async def create_note_from_url(self, web_url: str, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_note_from_url, web_url, **options)
+
+    async def create_note_from_file_url(self, file_url: str, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_note_from_file_url, file_url, **options)
+
+    async def create_note_from_file(
+        self, file_path: Union[str, Path], **options: Any
+    ) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_note_from_file, file_path, **options)
+
+    async def create_flashcards(self, note_id: str, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_flashcards, note_id, **options)
+
+    async def create_mindmap(self, note_id: str, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_mindmap, note_id, **options)
+
+    async def create_podcast(self, note_id: str, duration: int, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_podcast, note_id, duration, **options)
+
+    async def create_quiz(self, note_id: str, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_quiz, note_id, **options)
+
+    async def create_shorts(self, note_id: str, voice_id: str, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_shorts, note_id, voice_id, **options)
+
+    async def create_quiz_video(self, note_id: str, voice_id: str, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_quiz_video, note_id, voice_id, **options)
+
+    async def create_slide(self, note_id: str, template_id: str, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_slide, note_id, template_id, **options)
+
+    async def create_translation(self, note_id: str, language: str, **options: Any) -> TaskSubmission:
+        return await asyncio.to_thread(self._client.create_translation, note_id, language, **options)
+
+    async def get_task_result(self, task_id: str, **options: Any) -> TaskResult:
+        return await asyncio.to_thread(self._client.get_task_result, task_id, **options)
+
+    async def wait_for_task(self, task_id: str, **options: Any) -> TaskResult:
+        return await asyncio.to_thread(self._client.wait_for_task, task_id, **options)
+
+    async def request(
+        self, method: str, path: str, **options: Any
+    ) -> Mapping[str, Any]:
+        return await asyncio.to_thread(self._client.request, method, path, **options)