hiagent-components 0.1.0__tar.gz

hiagent_components-0.1.0/.gitignore

@@ -0,0 +1,169 @@
+### Python template
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+chainlit.md
+.chainlit/
+.vscode
+.idea
+license.py

hiagent_components-0.1.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: hiagent-components
+Version: 0.1.0
+Summary: Add your description here
+Requires-Python: >=3.10
+Requires-Dist: hiagent-api<0.2.0,>=0.1.0
+Requires-Dist: json-schema-to-pydantic>=0.2.6
+Requires-Dist: pydantic>=2.11.5
+Requires-Dist: python-dotenv>=1.1.0
+Requires-Dist: strenum>=0.4.15
+Requires-Dist: tenacity>=9.1.2
+Description-Content-Type: text/markdown
+
+HiAgent-Components SDK

hiagent_components-0.1.0/README.md

@@ -0,0 +1 @@
+HiAgent-Components SDK

hiagent_components-0.1.0/hiagent_components/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

hiagent_components-0.1.0/hiagent_components/agent/__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from .base import Agent
+
+__all__ = ["Agent"]

hiagent_components-0.1.0/hiagent_components/agent/base.py

@@ -0,0 +1,260 @@
+# Copyright (c) 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from concurrent.futures import Executor
+from io import StringIO
+from typing import Any, AsyncIterator, Iterator, Optional
+
+from hiagent_api.chat import ChatService
+from hiagent_api.chat_types import (
+    ChatEvent,
+    ChatRequest,
+    CreateConversationRequest,
+    GetAppConfigPreviewRequest,
+    MessageChatEvent,
+    StreamingChatEventType,
+    ToolMessageChatEvent,
+)
+
+from hiagent_components.base.base import Executable
+
+
+class Agent(Executable):
+    def __init__(
+        self,
+        svc: ChatService,
+        app_key: str,
+        user_id: str,
+        conversation_id: str,
+        name: str,
+        description: str,
+    ) -> None:
+        self.svc = svc
+        self.app_key = app_key
+        self.user_id = user_id
+        self.conversation_id = conversation_id
+        self.name = name or ""
+        self.description = description or ""
+
+    @property
+    def input_schema(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "需要智能体解决的原始问题",
+                }
+            },
+            "required": ["query"],
+        }
+
+    @classmethod
+    def init(
+        cls,
+        svc: ChatService,
+        app_key: str,
+        user_id: str,
+        variables: dict,
+        conversation_id: Optional[str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> "Agent":
+        resp = svc.get_app(
+            app_key=app_key,
+            params=GetAppConfigPreviewRequest(
+                app_key=app_key,
+                user_id=user_id,
+            ),
+        )
+        if not name:
+            name = resp.name
+        if not description:
+            description = ""
+
+        if not conversation_id:
+            resp = svc.create_conversation(
+                app_key=app_key,
+                conversation=CreateConversationRequest(
+                    app_key=app_key,
+                    inputs=variables,
+                    user_id=user_id,
+                ),
+            )
+            conversation_id = resp.conversation.app_conversation_id
+
+        agent = cls(
+            svc=svc,
+            app_key=app_key,
+            user_id=user_id,
+            conversation_id=conversation_id,
+            name=name,
+            description=description,
+        )
+
+        return agent
+
+    @classmethod
+    async def ainit(
+        cls,
+        svc: ChatService,
+        app_key: str,
+        user_id: str,
+        variables: dict,
+        conversation_id: Optional[str] = None,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> "Agent":
+        resp = await svc.aget_app(
+            app_key=app_key,
+            params=GetAppConfigPreviewRequest(
+                app_key=app_key,
+                user_id=user_id,
+            ),
+        )
+        if not name:
+            name = resp.name
+        if not description:
+            description = ""
+
+        if not conversation_id:
+            resp = svc.create_conversation(
+                app_key=app_key,
+                conversation=CreateConversationRequest(
+                    app_key=app_key,
+                    inputs=variables,
+                    user_id=user_id,
+                ),
+            )
+            conversation_id = resp.conversation.app_conversation_id
+
+        agent = cls(
+            svc=svc,
+            app_key=app_key,
+            user_id=user_id,
+            conversation_id=conversation_id,
+            name=name,
+            description=description,
+        )
+
+        return agent
+
+    def invoke(
+        self,
+        input: dict,
+        **kwargs: Any,
+    ) -> str:
+        query = input.get("query")
+        if not query:
+            raise ValueError("agent invoke input should contains 'query'")
+
+        resp_generator = self.svc.chat_streaming(
+            self.app_key,
+            ChatRequest(
+                app_key=self.app_key,
+                app_conversation_id=self.conversation_id,
+                query=query,
+                response_mode="streaming",
+                user_id=self.user_id,
+            ),
+        )
+
+        output = StringIO()
+        for event in resp_generator:
+            if event.event == StreamingChatEventType.tool_message:
+                assert isinstance(event, ToolMessageChatEvent)
+                output.write(event.answer)
+            elif event.event == StreamingChatEventType.message:
+                assert isinstance(event, MessageChatEvent)
+                output.write(event.answer)
+
+        return output.getvalue()
+
+    async def ainvoke(
+        self,
+        input: dict,
+        executor: Optional[Executor] = None,
+        **kwargs: Any,
+    ) -> str:
+        query = input.get("query")
+        if not query:
+            raise ValueError("agent invoke input should contains 'query'")
+
+        resp_generator = self.svc.achat_streaming(
+            self.app_key,
+            ChatRequest(
+                app_key=self.app_key,
+                app_conversation_id=self.conversation_id,
+                query=query,
+                response_mode="streaming",
+                user_id=self.user_id,
+            ),
+        )
+
+        output = StringIO()
+        async for event in resp_generator:
+            if event.event == StreamingChatEventType.tool_message:
+                assert isinstance(event, ToolMessageChatEvent)
+                output.write(event.answer)
+            elif event.event == StreamingChatEventType.tool_message_output_end:
+                output.write("\n\n")
+            elif event.event == StreamingChatEventType.message:
+                assert isinstance(event, MessageChatEvent)
+                output.write(event.answer)
+
+        return output.getvalue()
+
+    def stream(
+        self,
+        input: dict,
+        **kwargs: Optional[Any],
+    ) -> Iterator[ChatEvent]:
+        query = input.get("query")
+        if not query:
+            raise ValueError("agent invoke input should contains 'query'")
+
+        resp_generator = self.svc.chat_streaming(
+            self.app_key,
+            ChatRequest(
+                app_key=self.app_key,
+                app_conversation_id=self.conversation_id,
+                query=query,
+                response_mode="streaming",
+                user_id=self.user_id,
+            ),
+        )
+
+        return resp_generator
+
+    async def astream(
+        self,
+        input: dict,
+        **kwargs: Optional[Any],
+    ) -> AsyncIterator[ChatEvent]:
+        query = input.get("query")
+        if not query:
+            raise ValueError("agent invoke input should contains 'query'")
+
+        resp_generator = self.svc.achat_streaming(
+            self.app_key,
+            ChatRequest(
+                app_key=self.app_key,
+                app_conversation_id=self.conversation_id,
+                query=query,
+                response_mode="streaming",
+                user_id=self.user_id,
+            ),
+        )
+
+        async for event in resp_generator:
+            yield event

hiagent_components-0.1.0/hiagent_components/base/__init__.py

@@ -0,0 +1,18 @@
+# Copyright (c) 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from .base import Executable
+
+__all__ = ["Executable"]

hiagent_components-0.1.0/hiagent_components/base/base.py

@@ -0,0 +1,218 @@
+# Copyright (c) 2024 Bytedance Ltd. and/or its affiliates
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from concurrent.futures import Executor
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncIterator,
+    Dict,
+    Generic,
+    Iterator,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from tenacity import (
+    AsyncRetrying,
+    Retrying,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential_jitter,
+)
+
+from hiagent_components.base.utils import (
+    gather_with_concurrency,
+    get_executor,
+    run_in_executor,
+)
+
+if TYPE_CHECKING:
+    from hiagent_components.tool.base import BaseTool
+
+
+Input = TypeVar("Input", contravariant=True)
+Output = TypeVar("Output", covariant=True)
+
+
+class Executable(Generic[Input, Output], ABC):
+    name: str
+
+    description: str
+
+    @property
+    def input_schema(self) -> dict[str, Any]: ...
+
+    def stream(
+        self,
+        input: Input,
+        **kwargs: Optional[Any],
+    ) -> Iterator[Output]:
+        yield self.invoke(input, **kwargs)
+
+    async def astream(
+        self,
+        input: Input,
+        **kwargs: Optional[Any],
+    ) -> AsyncIterator[Output]:
+        yield await self.ainvoke(input, None, **kwargs)
+
+    def batch(
+        self,
+        inputs: list[Input],
+        max_parallel: int,
+        return_exceptions: bool = False,
+        **kwargs: Optional[Any],
+    ) -> list[Output]:
+        if not inputs:
+            return []
+
+        def invoke(input: Input) -> Union[Output, Exception]:
+            if return_exceptions:
+                try:
+                    return self.invoke(input, **kwargs)
+                except Exception as e:
+                    return e
+            else:
+                return self.invoke(input, **kwargs)
+
+        if len(inputs) == 1:
+            return cast("list[Output]", [invoke(inputs[0])])
+
+        with get_executor(max_parallel) as executor:
+            return cast("list[Output]", list[executor.map(invoke, inputs)])
+
+    async def abatch(
+        self,
+        inputs: list[Input],
+        max_parallel: int,
+        return_exceptions: bool = False,
+        **kwargs: Optional[Any],
+    ) -> list[Output]:
+        if not inputs:
+            return []
+
+        with get_executor(max_parallel) as executor:
+
+            async def ainvoke(
+                input: Input,
+            ) -> Union[Output, Exception]:
+                if return_exceptions:
+                    try:
+                        return await self.ainvoke(input, executor, **kwargs)
+                    except Exception as e:
+                        return e
+                else:
+                    return await self.ainvoke(input, executor, **kwargs)
+
+            coros = map(ainvoke, inputs)
+            return await gather_with_concurrency(max_parallel, *coros)
+
+    def with_retry(
+        self,
+        retry_exception_types: Tuple[Type[BaseException]] = (Exception,),
+        wait_exponential_jitter: bool = True,
+        max_attempts: int = 3,
+    ) -> Executable[Input, Output]:
+        return RetryableExecutable(self, retry_exception_types, wait_exponential_jitter, max_attempts)
+
+    def as_tool(
+        self,
+        name: Optional[str] = None,
+        description: Optional[str] = None,
+    ) -> BaseTool:
+        from hiagent_components.tool.tool import ExecutableTool
+
+        return ExecutableTool.from_executable(self, name, description)
+
+    @abstractmethod
+    def invoke(self, input: Input, **kwargs: Any) -> Output: ...
+
+    async def ainvoke(
+        self,
+        input: Input,
+        executor: Optional[Executor] = None,
+        **kwargs: Any,
+    ) -> Output:
+        return await run_in_executor(executor, self.invoke, input, **kwargs)
+
+class RetryableExecutable(Executable[Input, Output]):
+    def __init__(
+        self,
+        executable: Executable[Input, Output],
+        retry_exception_types: Tuple[Type[BaseException], ...] = (Exception,),
+        wait_exponential_jitter: bool = True,
+        max_attempts: int = 3,
+    ):
+        self.max_attempts = max_attempts
+        self.retry_exception_types = retry_exception_types
+        self.wait_exponential_jitter = wait_exponential_jitter
+        self.executable = executable
+
+    @property
+    def _retrying_kwargs(self) -> Dict[str, Any]:
+        kwargs: Dict[str, Any] = dict()
+
+        if self.max_attempts:
+            kwargs["stop"] = stop_after_attempt(self.max_attempts)
+
+        if self.wait_exponential_jitter:
+            kwargs["wait"] = wait_exponential_jitter()
+
+        if self.retry_exception_types:
+            kwargs["retry"] = retry_if_exception_type(self.retry_exception_types)
+
+        return kwargs
+
+    def _sync_retrying(self, **kwargs: Any) -> Retrying:
+        return Retrying(**self._retrying_kwargs, **kwargs)
+
+    def _async_retrying(self, **kwargs: Any) -> AsyncRetrying:
+        return AsyncRetrying(**self._retrying_kwargs, **kwargs)
+
+    def invoke(self, input: Input, **kwargs: Any) -> Output:
+        result = None
+        for attempt in self._sync_retrying(reraise=True):
+            with attempt:
+                result = self.executable.invoke(
+                    input,
+                    **kwargs,
+                )
+            if attempt.retry_state.outcome and not attempt.retry_state.outcome.failed:
+                attempt.retry_state.set_result(result)
+        return result
+
+    async def ainvoke(
+        self,
+        input: Input,
+        executor: Optional[Executor] = None,
+        **kwargs: Any
+    ) -> Output:
+        result = None
+        async for attempt in self._async_retrying(reraise=True):
+            with attempt:
+                result = await self.executable.ainvoke(
+                    input,
+                    executor,
+                    **kwargs,
+                )
+            if attempt.retry_state.outcome and not attempt.retry_state.outcome.failed:
+                attempt.retry_state.set_result(result)
+        return result