aiqtoolkit 1.2.0rc3__py3-none-any.whl → 1.2.0rc5__py3-none-any.whl

aiq/cli/commands/info/list_components.py

@@ -1,129 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.
-
-import asyncio
-import logging
-from contextlib import AsyncExitStack
-
-import click
-
-from aiq.data_models.component import AIQComponentEnum
-from aiq.data_models.registry_handler import RegistryHandlerBaseConfig
-from aiq.registry_handlers.schemas.search import SearchFields
-
-logger = logging.getLogger(__name__)
-
-
-async def search_artifacts(  # pylint: disable=R0917
-        registry_handler_config: RegistryHandlerBaseConfig,
-        component_types: list[AIQComponentEnum],
-        visualize: bool,
-        query: str,
-        num_results: int,
-        query_fields: list[SearchFields],
-        save_path: str | None) -> None:
-
-    from aiq.cli.type_registry import GlobalTypeRegistry
-    from aiq.registry_handlers.schemas.search import SearchQuery
-
-    registry = GlobalTypeRegistry.get()
-
-    async with AsyncExitStack() as stack:
-
-        registry_handler_info = registry.get_registry_handler(type(registry_handler_config))
-        registry_handler = await stack.enter_async_context(registry_handler_info.build_fn(registry_handler_config))
-
-        if (len(component_types) == 0):
-            component_types = [t.value for t in AIQComponentEnum]
-
-        if (len(query_fields) == 0):
-            query_fields = (SearchFields.ALL, )
-
-        query = SearchQuery(query=query, fields=query_fields, top_k=num_results, component_types=component_types)
-        search_response = await stack.enter_async_context(registry_handler.search(query=query))
-
-        if (visualize):
-            registry_handler.visualize_search_results(search_response=search_response)
-        if (save_path is not None):
-            registry_handler.save_search_results(search_response=search_response, save_path=save_path)
-
-
-@click.group(name=__name__, invoke_without_command=True, help="List the locally registered AIQ Toolkit components.")
-@click.option(
-    "-t",
-    "--types",
-    "component_types",
-    multiple=True,
-    type=click.Choice([e.value for e in AIQComponentEnum], case_sensitive=False),
-    required=False,
-    help=("Filter the search by AIQ Toolkit component type."),
-)
-@click.option(
-    "-o",
-    "--output_path",
-    type=str,
-    required=False,
-    help=("Path to save search results."),
-)
-@click.option(
-    "-q",
-    "--query",
-    type=str,
-    default="",
-    required=False,
-    help=("The query string."),
-)
-@click.option(
-    "-n",
-    "--num_results",
-    type=int,
-    default=-1,
-    required=False,
-    help=("Number of results to return."),
-)
-@click.option(
-    "-f",
-    "--fields",
-    multiple=True,
-    type=click.Choice([e.value for e in SearchFields], case_sensitive=False),
-    required=False,
-    help=("Fields used when applying query."),
-)
-def list_components(fields: list[SearchFields],
-                    query: str,
-                    num_results: int,
-                    component_types: list[AIQComponentEnum],
-                    output_path: str | None = None) -> None:
-
-    from aiq.runtime.loader import PluginTypes
-    from aiq.runtime.loader import discover_and_register_plugins
-    from aiq.settings.global_settings import GlobalSettings
-
-    discover_and_register_plugins(PluginTypes.ALL)
-
-    config_dict = {"channels": {"list_components": {"_type": "local"}}}
-    registry_config = GlobalSettings.get().model_validate(config_dict)
-    local_registry_config = registry_config.channels.get("list_components", None)
-    if (local_registry_config is None):
-        logger.error("Channel runtime instance not found.")
-
-    asyncio.run(
-        search_artifacts(local_registry_config,
-                         query=query,
-                         num_results=num_results,
-                         query_fields=fields,
-                         component_types=component_types,
-                         visualize=True,
-                         save_path=output_path))

aiq/cli/commands/info/list_mcp.py

@@ -1,213 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.
-
-import json
-import logging
-from typing import Any
-
-import anyio
-import click
-
-from aiq.tool.mcp.exceptions import MCPError
-from aiq.tool.mcp.mcp_client import MCPBuilder
-from aiq.utils.exception_handlers.mcp import format_mcp_error
-
-# Suppress verbose logs from mcp.client.sse and httpx
-logging.getLogger("mcp.client.sse").setLevel(logging.WARNING)
-logging.getLogger("httpx").setLevel(logging.WARNING)
-
-logger = logging.getLogger(__name__)
-
-
-def format_tool(tool: Any) -> dict[str, str | None]:
-    """Format an MCP tool into a dictionary for display.
-
-    Extracts name, description, and input schema from various MCP tool object types
-    and normalizes them into a consistent dictionary format for CLI display.
-
-    Args:
-        tool (Any): MCPToolClient or raw MCP Tool object (uses Any due to different types)
-
-    Returns:
-        dict[str, str | None]: Dictionary with name, description, and input_schema as keys
-    """
-    name = getattr(tool, 'name', None)
-    description = getattr(tool, 'description', '')
-    input_schema = getattr(tool, 'input_schema', None) or getattr(tool, 'inputSchema', None)
-
-    schema_str = None
-    if input_schema:
-        if hasattr(input_schema, "schema_json"):
-            schema_str = input_schema.schema_json(indent=2)
-        else:
-            schema_str = str(input_schema)
-
-    return {
-        "name": name,
-        "description": description,
-        "input_schema": schema_str,
-    }
-
-
-def print_tool(tool_dict: dict[str, str | None], detail: bool = False) -> None:
-    """Print a formatted tool to the console with optional detailed information.
-
-    Outputs tool information in a user-friendly format to stdout. When detail=True
-    or when description/schema are available, shows full information with separator.
-
-    Args:
-        tool_dict (dict[str, str | None]): Dictionary containing tool information with name, description, and
-        input_schema as keys
-        detail (bool, optional): Whether to force detailed output. Defaults to False.
-    """
-    click.echo(f"Tool: {tool_dict.get('name', 'Unknown')}")
-    if detail or tool_dict.get('input_schema') or tool_dict.get('description'):
-        click.echo(f"Description: {tool_dict.get('description', 'No description available')}")
-        if tool_dict.get("input_schema"):
-            click.echo("Input Schema:")
-            click.echo(tool_dict.get("input_schema"))
-        else:
-            click.echo("Input Schema: None")
-        click.echo("-" * 60)
-
-
-async def list_tools_and_schemas(url: str, tool_name: str | None = None) -> list[dict[str, str | None]]:
-    """List MCP tools using MCPBuilder with structured exception handling.
-
-    Args:
-        url (str): MCP server URL to connect to
-        tool_name (str | None, optional): Specific tool name to retrieve.
-        If None, retrieves all available tools. Defaults to None.
-
-    Returns:
-        list[dict[str, str | None]]: List of formatted tool dictionaries, each containing name, description, and
-        input_schema as keys
-
-    Raises:
-        MCPError: Caught internally and logged, returns empty list instead
-    """
-    builder = MCPBuilder(url=url)
-    try:
-        if tool_name:
-            tool = await builder.get_tool(tool_name)
-            return [format_tool(tool)]
-        else:
-            tools = await builder.get_tools()
-            return [format_tool(tool) for tool in tools.values()]
-    except MCPError as e:
-        format_mcp_error(e, include_traceback=False)
-        return []
-
-
-async def list_tools_direct(url: str, tool_name: str | None = None) -> list[dict[str, str | None]]:
-    """List MCP tools using direct MCP protocol with exception conversion.
-
-    Bypasses MCPBuilder and uses raw MCP ClientSession and SSE client directly.
-    Converts raw exceptions to structured MCPErrors for consistent user experience.
-    Used when --direct flag is specified in CLI.
-
-    Args:
-        url (str): MCP server URL to connect to
-        tool_name (str | None, optional): Specific tool name to retrieve.
-        If None, retrieves all available tools. Defaults to None.
-
-    Returns:
-        list[dict[str, str | None]]: List of formatted tool dictionaries, each containing name, description, and
-        input_schema as keys
-
-    Note:
-        This function handles ExceptionGroup by extracting the most relevant exception
-        and converting it to MCPError for consistent error reporting.
-    """
-    from mcp import ClientSession
-    from mcp.client.sse import sse_client
-
-    try:
-        async with sse_client(url=url) as (read, write):
-            async with ClientSession(read, write) as session:
-                await session.initialize()
-                response = await session.list_tools()
-
-                tools = []
-                for tool in response.tools:
-                    if tool_name:
-                        if tool.name == tool_name:
-                            return [format_tool(tool)]
-                    else:
-                        tools.append(format_tool(tool))
-                if tool_name and not tools:
-                    click.echo(f"[INFO] Tool '{tool_name}' not found.")
-                return tools
-    except Exception as e:
-        # Convert raw exceptions to structured MCPError for consistency
-        from aiq.utils.exception_handlers.mcp import convert_to_mcp_error
-        from aiq.utils.exception_handlers.mcp import extract_primary_exception
-
-        if isinstance(e, ExceptionGroup):  # noqa: F821
-            primary_exception = extract_primary_exception(list(e.exceptions))
-            mcp_error = convert_to_mcp_error(primary_exception, url)
-        else:
-            mcp_error = convert_to_mcp_error(e, url)
-
-        format_mcp_error(mcp_error, include_traceback=False)
-        return []
-
-
-@click.group(invoke_without_command=True, help="List tool names (default), or show details with --detail or --tool.")
-@click.option('--direct', is_flag=True, help='Bypass MCPBuilder and use direct MCP protocol')
-@click.option('--url', default='http://localhost:9901/sse', show_default=True, help='MCP server URL')
-@click.option('--tool', default=None, help='Get details for a specific tool by name')
-@click.option('--detail', is_flag=True, help='Show full details for all tools')
-@click.option('--json-output', is_flag=True, help='Output tool metadata in JSON format')
-@click.pass_context
-def list_mcp(ctx: click.Context, direct: bool, url: str, tool: str | None, detail: bool, json_output: bool) -> None:
-    """List MCP tool names (default) or show detailed tool information.
-
-    Use --detail for full output including descriptions and input schemas.
-    If --tool is provided, always shows full output for that specific tool.
-    Use --direct to bypass MCPBuilder and use raw MCP protocol.
-    Use --json-output to get structured JSON data instead of formatted text.
-
-    Args:
-        ctx (click.Context): Click context object for command invocation
-        direct (bool): Whether to bypass MCPBuilder and use direct MCP protocol
-        url (str): MCP server URL to connect to (default: http://localhost:9901/sse)
-        tool (str | None): Optional specific tool name to retrieve detailed info for
-        detail (bool): Whether to show full details (description + schema) for all tools
-        json_output (bool): Whether to output tool metadata in JSON format instead of text
-
-    Examples:
-        aiq info mcp                           # List tool names only
-        aiq info mcp --detail                  # Show all tools with full details
-        aiq info mcp --tool my_tool            # Show details for specific tool
-        aiq info mcp --json-output             # Get JSON format output
-        aiq info mcp --direct --url http://...  # Use direct protocol with custom URL
-    """
-    if ctx.invoked_subcommand is not None:
-        return
-    fetcher = list_tools_direct if direct else list_tools_and_schemas
-    tools = anyio.run(fetcher, url, tool)
-
-    if json_output:
-        click.echo(json.dumps(tools, indent=2))
-    elif tool:
-        for tool_dict in tools:
-            print_tool(tool_dict, detail=True)
-    elif detail:
-        for tool_dict in tools:
-            print_tool(tool_dict, detail=True)
-    else:
-        for tool_dict in tools:
-            click.echo(tool_dict.get('name', 'Unknown tool'))

aiq/cli/commands/registry/__init__.py

@@ -1,14 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.

aiq/cli/commands/registry/publish.py

@@ -1,88 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.
-
-import asyncio
-import logging
-from contextlib import AsyncExitStack
-from pathlib import Path
-
-import click
-
-from aiq.data_models.registry_handler import RegistryHandlerBaseConfig
-from aiq.utils.data_models.schema_validator import validate_yaml
-
-logger = logging.getLogger(__name__)
-
-
-async def publish_artifact(registry_handler_config: RegistryHandlerBaseConfig, package_root: str) -> None:
-
-    from aiq.cli.type_registry import GlobalTypeRegistry
-    from aiq.registry_handlers.package_utils import build_aiq_artifact
-
-    registry = GlobalTypeRegistry.get()
-
-    async with AsyncExitStack() as stack:
-
-        registry_handler_info = registry.get_registry_handler(type(registry_handler_config))
-        registry_handler = await stack.enter_async_context(registry_handler_info.build_fn(registry_handler_config))
-        try:
-            artifact = build_aiq_artifact(package_root=package_root)
-        except Exception as e:
-            logger.exception("Error building artifact: %s", e, exc_info=True)
-            return
-        await stack.enter_async_context(registry_handler.publish(artifact=artifact))
-
-
-@click.group(name=__name__,
-             invoke_without_command=True,
-             help=("Publish local AIQ Toolkit artifacts to a remote "
-                   "registry from package repository."))
-@click.option(
-    "--config_file",
-    type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
-    callback=validate_yaml,
-    required=False,
-    help=("A YAML file to override configured channel settings."),
-)
-@click.option(
-    "-c",
-    "--channel",
-    type=str,
-    required=True,
-    help=("The remote registry channel to use when publishing the AIQ Toolkit artifact."),
-)
-@click.argument("package_root", type=str)
-def publish(channel: str, config_file: str, package_root: str) -> None:
-    """
-    Publish AIQ Toolkit artifacts with the specified configuration
-    """
-    from aiq.settings.global_settings import GlobalSettings
-
-    settings = GlobalSettings().get()
-
-    if (config_file is not None):
-        settings = settings.override_settings(config_file)
-
-    try:
-        publish_channel_config = settings.channels.get(channel)
-
-        if (publish_channel_config is None):
-            logger.error("Publish channel '%s' has not been configured.", channel)
-            return
-    except Exception as e:
-        logger.exception("Error loading user settings: %s", e, exc_info=True)
-        return
-
-    asyncio.run(publish_artifact(registry_handler_config=publish_channel_config, package_root=package_root))

aiq/cli/commands/registry/pull.py

@@ -1,118 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.
-
-import asyncio
-import logging
-from contextlib import AsyncExitStack
-from pathlib import Path
-
-import click
-
-from aiq.data_models.registry_handler import RegistryHandlerBaseConfig
-from aiq.utils.data_models.schema_validator import validate_yaml
-
-logger = logging.getLogger(__name__)
-
-
-async def pull_artifact(registry_handler_config: RegistryHandlerBaseConfig, packages: list[str]) -> None:
-
-    from aiq.cli.type_registry import GlobalTypeRegistry
-    from aiq.registry_handlers.schemas.package import PackageNameVersion
-    from aiq.registry_handlers.schemas.pull import PullPackageWhl
-    from aiq.registry_handlers.schemas.pull import PullRequestPackages
-
-    registry = GlobalTypeRegistry.get()
-
-    async with AsyncExitStack() as stack:
-
-        registry_handler_info = registry.get_registry_handler(type(registry_handler_config))
-        registry_handler = await stack.enter_async_context(registry_handler_info.build_fn(registry_handler_config))
-
-        try:
-            package_list = []
-            for package in packages:
-
-                package_data = {}
-
-                assert len(package) > 0, f"Supplied invalid package '{package}'."
-
-                if package[:-4] == ".whl":
-                    package_data["whl_path"] = package
-                    package_list.append(PullPackageWhl(**package_data))
-                else:
-                    package_split = package.split("==")
-
-                    assert len(package_split) in (1, 2), f"Supplied invalid package '{package}'."
-
-                    package_data["name"] = package_split[0]
-
-                    if (package_split == 2):
-                        package_data["version"] = package_split[1]
-
-                    package_list.append(PackageNameVersion(**package_data))
-
-            validated_packages = PullRequestPackages(packages=package_list)
-
-        except Exception as e:
-            logger.exception("Error processing package names: %s", e, exc_info=True)
-            return
-
-        await stack.enter_async_context(registry_handler.pull(packages=validated_packages))
-
-
-@click.group(name=__name__,
-             invoke_without_command=True,
-             help=("Pull AIQ Toolkit artifacts from a remote registry "
-                   "by package name."))
-@click.option(
-    "--config_file",
-    type=click.Path(exists=True, file_okay=True, dir_okay=False, path_type=Path),
-    callback=validate_yaml,
-    required=False,
-    help=("A YAML file to override the channel settings."),
-)
-@click.option(
-    "-c",
-    "--channel",
-    type=str,
-    required=True,
-    help=("The remote registry channel to use when pulling the AIQ Toolkit artifact."),
-)
-@click.argument("packages", type=str)
-def pull(channel: str, config_file: str, packages: str) -> None:
-    """
-    Pull AIQ Toolkit artifacts from a remote registry channel.
-    """
-
-    from aiq.settings.global_settings import GlobalSettings
-
-    packages = packages.split()
-
-    settings = GlobalSettings().get()
-
-    if (config_file is not None):
-        settings = settings.override_settings(config_file)
-
-    try:
-        pull_channel_config = settings.channels.get(channel)
-
-        if (pull_channel_config is None):
-            logger.error("Pull channel '%s' has not been configured.", channel)
-            return
-    except Exception as e:
-        logger.exception("Error loading user settings: %s", e, exc_info=True)
-        return
-
-    asyncio.run(pull_artifact(pull_channel_config, packages))

aiq/cli/commands/registry/registry.py

@@ -1,38 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-#
-# 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.
-
-import logging
-
-import click
-
-from aiq.cli.commands.registry.publish import publish
-from aiq.cli.commands.registry.pull import pull
-from aiq.cli.commands.registry.remove import remove
-from aiq.cli.commands.registry.search import search
-
-logger = logging.getLogger(__name__)
-
-
-@click.group(name=__name__,
-             invoke_without_command=False,
-             help="Utility to configure AIQ Toolkit remote registry channels.")
-def registry_command(**kwargs):
-    pass
-
-
-registry_command.add_command(publish, "publish")
-registry_command.add_command(pull, "pull")
-registry_command.add_command(remove, "remove")
-registry_command.add_command(search, "search")