arkruntime 0.1.0__py3-none-any.whl

arkruntime/resources/memory_stores/memories.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from ..._base_client import make_request_options
+from ..._managed_agents_serialize import dump_body
+from ..._resource import AsyncAPIResource, SyncAPIResource
+from ..._types import NOT_GIVEN, NotGiven
+from ...types.memory.delete_memory_response import DeleteMemoryResponse
+from ...types.memory.list_memories_order_by import ListMemoriesOrderBy
+from ...types.memory.list_memories_response import ListMemoriesResponse
+from ...types.memory.memory import Memory
+
+__all__ = ["Memories", "AsyncMemories"]
+
+
+def _prefix(memory_store_id: str) -> str:
+    return f"/memory_stores/{memory_store_id}/memories"
+
+
+def _list_query(*, path_prefix=NOT_GIVEN, depth=NOT_GIVEN, order_by=NOT_GIVEN, limit=NOT_GIVEN, page=NOT_GIVEN) -> dict:
+    q: dict = {}
+    for k, v in {
+        "path_prefix": path_prefix,
+        "depth": depth,
+        "order_by": order_by,
+        "limit": limit,
+        "page": page,
+    }.items():
+        if v is not NOT_GIVEN and v is not None:
+            q[k] = v
+    return q
+
+
+class Memories(SyncAPIResource):
+    def create(
+        self,
+        memory_store_id: str,
+        *,
+        path: str,
+        content: str,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> Memory:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return self._post(
+            _prefix(memory_store_id),
+            body=dump_body({"path": path, "content": content}),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Memory,
+        )
+
+    def retrieve(
+        self,
+        memory_store_id: str,
+        memory_id: str,
+        *,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> Memory:
+        if not memory_store_id or not memory_id:
+            raise ValueError("memory_store_id and memory_id are required")
+        return self._get(
+            f"{_prefix(memory_store_id)}/{memory_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Memory,
+        )
+
+    def list(
+        self,
+        memory_store_id: str,
+        *,
+        path_prefix=NOT_GIVEN,
+        depth=NOT_GIVEN,
+        order_by: Optional[ListMemoriesOrderBy] | NotGiven = NOT_GIVEN,
+        limit=NOT_GIVEN,
+        page=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> ListMemoriesResponse:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return self._get(
+            _prefix(memory_store_id),
+            options=make_request_options(
+                query=_list_query(path_prefix=path_prefix, depth=depth, order_by=order_by, limit=limit, page=page),
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=ListMemoriesResponse,
+        )
+
+    def update(
+        self,
+        memory_store_id: str,
+        memory_id: str,
+        *,
+        content=NOT_GIVEN,
+        path=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> Memory:
+        if not memory_store_id or not memory_id:
+            raise ValueError("memory_store_id and memory_id are required")
+        return self._post(
+            f"{_prefix(memory_store_id)}/{memory_id}",
+            body=dump_body({"content": content, "path": path}),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Memory,
+        )
+
+    def delete(
+        self,
+        memory_store_id: str,
+        memory_id: str,
+        *,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> DeleteMemoryResponse:
+        if not memory_store_id or not memory_id:
+            raise ValueError("memory_store_id and memory_id are required")
+        return self._delete(
+            f"{_prefix(memory_store_id)}/{memory_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeleteMemoryResponse,
+        )
+
+
+class AsyncMemories(AsyncAPIResource):
+    async def create(
+        self,
+        memory_store_id: str,
+        *,
+        path: str,
+        content: str,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> Memory:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return await self._post(
+            _prefix(memory_store_id),
+            body=dump_body({"path": path, "content": content}),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Memory,
+        )
+
+    async def retrieve(
+        self,
+        memory_store_id: str,
+        memory_id: str,
+        *,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> Memory:
+        if not memory_store_id or not memory_id:
+            raise ValueError("memory_store_id and memory_id are required")
+        return await self._get(
+            f"{_prefix(memory_store_id)}/{memory_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Memory,
+        )
+
+    async def list(
+        self,
+        memory_store_id: str,
+        *,
+        path_prefix=NOT_GIVEN,
+        depth=NOT_GIVEN,
+        order_by=NOT_GIVEN,
+        limit=NOT_GIVEN,
+        page=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> ListMemoriesResponse:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return await self._get(
+            _prefix(memory_store_id),
+            options=make_request_options(
+                query=_list_query(path_prefix=path_prefix, depth=depth, order_by=order_by, limit=limit, page=page),
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=ListMemoriesResponse,
+        )
+
+    async def update(
+        self,
+        memory_store_id: str,
+        memory_id: str,
+        *,
+        content=NOT_GIVEN,
+        path=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> Memory:
+        if not memory_store_id or not memory_id:
+            raise ValueError("memory_store_id and memory_id are required")
+        return await self._post(
+            f"{_prefix(memory_store_id)}/{memory_id}",
+            body=dump_body({"content": content, "path": path}),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=Memory,
+        )
+
+    async def delete(
+        self,
+        memory_store_id: str,
+        memory_id: str,
+        *,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> DeleteMemoryResponse:
+        if not memory_store_id or not memory_id:
+            raise ValueError("memory_store_id and memory_id are required")
+        return await self._delete(
+            f"{_prefix(memory_store_id)}/{memory_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeleteMemoryResponse,
+        )

arkruntime/resources/memory_stores/memory_stores.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+from ..._base_client import make_request_options
+from ..._compat import cached_property
+from ..._managed_agents_serialize import dump_body
+from ..._resource import AsyncAPIResource, SyncAPIResource
+from ..._types import NOT_GIVEN, NotGiven
+from ...types.memory.delete_memory_store_response import DeleteMemoryStoreResponse
+from ...types.memory.list_memory_stores_response import ListMemoryStoresResponse
+from ...types.memory.memory_store import MemoryStore
+from .memories import AsyncMemories, Memories
+
+__all__ = ["MemoryStores", "AsyncMemoryStores"]
+
+_PREFIX = "/memory_stores"
+
+
+def _list_query(*, limit=NOT_GIVEN, page=NOT_GIVEN, created_by=NOT_GIVEN, name=NOT_GIVEN) -> dict:
+    q: dict = {}
+    for k, v in {"limit": limit, "page": page, "created_by": created_by, "name": name}.items():
+        if v is not NOT_GIVEN and v is not None:
+            q[k] = v
+    return q
+
+
+class MemoryStores(SyncAPIResource):
+    @cached_property
+    def memories(self) -> Memories:
+        return Memories(self._client)
+
+    def create(
+        self,
+        *,
+        name: str,
+        description=NOT_GIVEN,
+        metadata=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> MemoryStore:
+        return self._post(
+            _PREFIX,
+            body=dump_body({"name": name, "description": description, "metadata": metadata}),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryStore,
+        )
+
+    def retrieve(
+        self, memory_store_id: str, *, extra_headers=None, extra_query=None, extra_body=None, timeout=None
+    ) -> MemoryStore:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return self._get(
+            f"{_PREFIX}/{memory_store_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryStore,
+        )
+
+    def list(
+        self,
+        *,
+        limit=NOT_GIVEN,
+        page=NOT_GIVEN,
+        created_by: Optional[List[str]] | NotGiven = NOT_GIVEN,
+        name=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> ListMemoryStoresResponse:
+        return self._get(
+            _PREFIX,
+            options=make_request_options(
+                query=_list_query(limit=limit, page=page, created_by=created_by, name=name),
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=ListMemoryStoresResponse,
+        )
+
+    def update(
+        self,
+        memory_store_id: str,
+        *,
+        name=NOT_GIVEN,
+        description=NOT_GIVEN,
+        metadata=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> MemoryStore:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return self._post(
+            f"{_PREFIX}/{memory_store_id}",
+            body=dump_body({"name": name, "description": description, "metadata": metadata}),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryStore,
+        )
+
+    def delete(
+        self, memory_store_id: str, *, extra_headers=None, extra_query=None, extra_body=None, timeout=None
+    ) -> DeleteMemoryStoreResponse:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return self._delete(
+            f"{_PREFIX}/{memory_store_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeleteMemoryStoreResponse,
+        )
+
+
+class AsyncMemoryStores(AsyncAPIResource):
+    @cached_property
+    def memories(self) -> AsyncMemories:
+        return AsyncMemories(self._client)
+
+    async def create(
+        self,
+        *,
+        name: str,
+        description=NOT_GIVEN,
+        metadata=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> MemoryStore:
+        return await self._post(
+            _PREFIX,
+            body=dump_body({"name": name, "description": description, "metadata": metadata}),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryStore,
+        )
+
+    async def retrieve(
+        self, memory_store_id: str, *, extra_headers=None, extra_query=None, extra_body=None, timeout=None
+    ) -> MemoryStore:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return await self._get(
+            f"{_PREFIX}/{memory_store_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryStore,
+        )
+
+    async def list(
+        self,
+        *,
+        limit=NOT_GIVEN,
+        page=NOT_GIVEN,
+        created_by=NOT_GIVEN,
+        name=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> ListMemoryStoresResponse:
+        return await self._get(
+            _PREFIX,
+            options=make_request_options(
+                query=_list_query(limit=limit, page=page, created_by=created_by, name=name),
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=ListMemoryStoresResponse,
+        )
+
+    async def update(
+        self,
+        memory_store_id: str,
+        *,
+        name=NOT_GIVEN,
+        description=NOT_GIVEN,
+        metadata=NOT_GIVEN,
+        extra_headers=None,
+        extra_query=None,
+        extra_body=None,
+        timeout=None,
+    ) -> MemoryStore:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return await self._post(
+            f"{_PREFIX}/{memory_store_id}",
+            body=dump_body({"name": name, "description": description, "metadata": metadata}),
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=MemoryStore,
+        )
+
+    async def delete(
+        self, memory_store_id: str, *, extra_headers=None, extra_query=None, extra_body=None, timeout=None
+    ) -> DeleteMemoryStoreResponse:
+        if not memory_store_id:
+            raise ValueError("memory_store_id is required")
+        return await self._delete(
+            f"{_PREFIX}/{memory_store_id}",
+            options=make_request_options(
+                extra_headers=extra_headers, extra_query=extra_query, extra_body=extra_body, timeout=timeout
+            ),
+            cast_to=DeleteMemoryStoreResponse,
+        )

arkruntime/resources/multimodal_embeddings/__init__.py

@@ -0,0 +1,9 @@
+# Copyright (c) 2026 ByteDance Ltd. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+
+from arkruntime.resources.multimodal_embeddings.multimodal_embeddings import (
+    AsyncMultimodalEmbeddings,
+    MultimodalEmbeddings,
+)
+
+__all__ = ["MultimodalEmbeddings", "AsyncMultimodalEmbeddings"]

arkruntime/resources/multimodal_embeddings/multimodal_embeddings.py

@@ -0,0 +1,150 @@
+# Copyright (c) 2025 ByteDance Ltd. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+# License text: https://github.com/volcengine/ark-runtime-python/blob/main/LICENSE
+
+from __future__ import annotations
+
+from typing import List, Optional
+
+import httpx
+
+from ..._base_client import make_request_options
+from ..._compat import cached_property
+from ..._resource import AsyncAPIResource, SyncAPIResource
+from ..._response import (
+    async_to_raw_response_wrapper,
+    to_raw_response_wrapper,
+)
+from ..._types import Body, Headers, Query
+from ..._utils import async_maybe_transform, maybe_transform
+
+# AUTOGEN-START create-imports
+from ...types.multimodal_embedding.embedding_input_param import EmbeddingInputParam
+from ...types.multimodal_embedding.encoding_format import EncodingFormat
+from ...types.multimodal_embedding.multi_embedding_config_param import MultiEmbeddingConfigParam
+from ...types.multimodal_embedding.multi_modal_embedding_request_param import MultiModalEmbeddingRequestParam
+from ...types.multimodal_embedding.multi_modal_embedding_response import MultiModalEmbeddingResponse
+from ...types.multimodal_embedding.sparse_embedding_config_param import SparseEmbeddingConfigParam
+
+# AUTOGEN-END create-imports
+
+__all__ = [
+    "MultimodalEmbeddings",
+    "AsyncMultimodalEmbeddings",
+    "MultimodalEmbeddingsWithRawResponse",
+    "AsyncMultimodalEmbeddingsWithRawResponse",
+]
+
+
+class MultimodalEmbeddings(SyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> MultimodalEmbeddingsWithRawResponse:
+        return MultimodalEmbeddingsWithRawResponse(self)
+
+    def create(
+        self,
+        *,
+        # AUTOGEN-START create-kwargs
+        model: str,
+        input: List[EmbeddingInputParam],
+        encoding_format: Optional[EncodingFormat] = None,
+        dimensions: Optional[int] = None,
+        sparse_embedding: Optional[SparseEmbeddingConfigParam] = None,
+        multi_embedding: Optional[MultiEmbeddingConfigParam] = None,
+        instructions: Optional[str] = None,
+        # AUTOGEN-END create-kwargs
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> MultiModalEmbeddingResponse:
+        return self._post(
+            "/embeddings/multimodal",
+            body=maybe_transform(
+                {
+                    # AUTOGEN-START create-body
+                    "model": model,
+                    "input": input,
+                    "encoding_format": encoding_format,
+                    "dimensions": dimensions,
+                    "sparse_embedding": sparse_embedding,
+                    "multi_embedding": multi_embedding,
+                    "instructions": instructions,
+                    # AUTOGEN-END create-body
+                },
+                MultiModalEmbeddingRequestParam,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=MultiModalEmbeddingResponse,
+        )
+
+
+class AsyncMultimodalEmbeddings(AsyncAPIResource):
+    @cached_property
+    def with_raw_response(self) -> AsyncMultimodalEmbeddingsWithRawResponse:
+        return AsyncMultimodalEmbeddingsWithRawResponse(self)
+
+    async def create(
+        self,
+        *,
+        # AUTOGEN-START create-kwargs
+        model: str,
+        input: List[EmbeddingInputParam],
+        encoding_format: Optional[EncodingFormat] = None,
+        dimensions: Optional[int] = None,
+        sparse_embedding: Optional[SparseEmbeddingConfigParam] = None,
+        multi_embedding: Optional[MultiEmbeddingConfigParam] = None,
+        instructions: Optional[str] = None,
+        # AUTOGEN-END create-kwargs
+        extra_headers: Headers | None = None,
+        extra_query: Query | None = None,
+        extra_body: Body | None = None,
+        timeout: float | httpx.Timeout | None = None,
+    ) -> MultiModalEmbeddingResponse:
+        return await self._post(
+            "/embeddings/multimodal",
+            body=await async_maybe_transform(
+                {
+                    # AUTOGEN-START create-body
+                    "model": model,
+                    "input": input,
+                    "encoding_format": encoding_format,
+                    "dimensions": dimensions,
+                    "sparse_embedding": sparse_embedding,
+                    "multi_embedding": multi_embedding,
+                    "instructions": instructions,
+                    # AUTOGEN-END create-body
+                },
+                MultiModalEmbeddingRequestParam,
+            ),
+            options=make_request_options(
+                extra_headers=extra_headers,
+                extra_query=extra_query,
+                extra_body=extra_body,
+                timeout=timeout,
+            ),
+            cast_to=MultiModalEmbeddingResponse,
+        )
+
+
+class MultimodalEmbeddingsWithRawResponse:
+    def __init__(self, multimodal_embeddings: MultimodalEmbeddings) -> None:
+        self._multimodal_embeddings = multimodal_embeddings
+
+        self.create = to_raw_response_wrapper(
+            multimodal_embeddings.create,
+        )
+
+
+class AsyncMultimodalEmbeddingsWithRawResponse:
+    def __init__(self, multimodal_embeddings: AsyncMultimodalEmbeddings) -> None:
+        self._multimodal_embeddings = multimodal_embeddings
+
+        self.create = async_to_raw_response_wrapper(
+            multimodal_embeddings.create,
+        )

arkruntime/resources/responses/__init__.py

@@ -0,0 +1,8 @@
+# Copyright (c) 2025 ByteDance Ltd. and/or its affiliates.
+# SPDX-License-Identifier: Apache-2.0
+# License text: https://github.com/volcengine/ark-runtime-python/blob/main/LICENSE
+
+from .input_items import AsyncInputItems, InputItems
+from .responses import AsyncResponses, Responses
+
+__all__ = ["Responses", "AsyncResponses", "InputItems", "AsyncInputItems"]