chore: import upstream snapshot with attribution

haystack/tools/__init__.py

@@ -0,0 +1,59 @@
+# SPDX-FileCopyrightText: 2022-present deepset GmbH <info@deepset.ai>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+import sys
+from typing import TYPE_CHECKING
+
+from lazy_imports import LazyImporter
+
+# The `tool` decorator (from `from_function`) shares its name with the `tool` submodule (`tool.py`).
+# `LazyImporter` registers every key in `import_structure` as a submodule symbol, so adding `"tool"` as a key collides
+# with the `tool` decorator and raises a duplicate-symbol error at construction. We therefore eagerly import the
+# decorator and pass it via `extra_objects`, keeping `"tool"` out of `import_structure`.
+#
+# Guidance for adding future exports:
+#   - Symbols defined in `tool.py` (e.g. `Tool`) CANNOT be lazy: doing so would require `"tool"` as a key, which
+#     re-introduces the collision with the `tool` decorator. Import them eagerly here and add them to `extra_objects`.
+#   - Symbols from `from_function.py` (e.g. `create_tool_from_function`) could be lazy, but since we already eagerly
+#     import this module for the `tool` decorator, we keep its exports eager in `extra_objects` too rather than
+#     splitting them.
+#   - Symbols from any other submodule have no name collision and should be added lazily to `import_structure` (plus
+#     the `TYPE_CHECKING` block below) like the existing entries.
+from haystack.tools.from_function import create_tool_from_function, tool
+from haystack.tools.tool import Tool, _check_duplicate_tool_names
+
+_import_structure = {
+    "toolset": ["Toolset"],
+    "searchable_toolset": ["SearchableToolset"],
+    "skills": ["SkillToolset"],
+    "component_tool": ["ComponentTool"],
+    "pipeline_tool": ["PipelineTool"],
+    "serde_utils": ["deserialize_tools_or_toolset_inplace", "serialize_tools_or_toolset"],
+    "utils": ["flatten_tools_or_toolsets", "warm_up_tools"],
+    "tool_types": ["ToolsType"],
+}
+
+if TYPE_CHECKING:
+    from haystack.tools.component_tool import ComponentTool as ComponentTool
+    from haystack.tools.pipeline_tool import PipelineTool as PipelineTool
+    from haystack.tools.searchable_toolset import SearchableToolset as SearchableToolset
+    from haystack.tools.serde_utils import deserialize_tools_or_toolset_inplace as deserialize_tools_or_toolset_inplace
+    from haystack.tools.serde_utils import serialize_tools_or_toolset as serialize_tools_or_toolset
+    from haystack.tools.skills import SkillToolset as SkillToolset
+    from haystack.tools.tool_types import ToolsType as ToolsType
+    from haystack.tools.toolset import Toolset as Toolset
+    from haystack.tools.utils import flatten_tools_or_toolsets as flatten_tools_or_toolsets
+    from haystack.tools.utils import warm_up_tools as warm_up_tools
+else:
+    sys.modules[__name__] = LazyImporter(
+        name=__name__,
+        module_file=__file__,
+        import_structure=_import_structure,
+        extra_objects={
+            "create_tool_from_function": create_tool_from_function,
+            "tool": tool,
+            "Tool": Tool,
+            "_check_duplicate_tool_names": _check_duplicate_tool_names,
+        },
+    )