naas-abi-core 1.0.0__py3-none-any.whl

naas_abi_core/apps/terminal_agent/terminal_style.py

@@ -0,0 +1,175 @@
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.text import Text
+from rich.box import ROUNDED
+from PIL import Image
+import os
+import platform
+import subprocess
+
+console = Console()
+
+
+def set_terminal_title():
+    """Set the terminal title to 'ABI'"""
+    if platform.system() == "Windows":
+        os.system("title ABI")
+    else:  # For Unix-like systems (Linux, macOS)
+        print("\33]0;ABI\a", end="", flush=True)
+
+
+def print_agent_response(text, agent_label):
+    console.print()  # Add a blank line before the assistant's response
+    console.print(f"[bold green]{agent_label}:[/bold green] ", end="")
+    md = Markdown(text)
+    console.print(md)
+    console.print()  # Add a blank line after the assistant's response
+
+
+def print_system_message(text):
+    console.print()  # Add a blank line before the system message
+    system_text = Text(text, style="yellow")
+    console.print(
+        Panel(
+            system_text,
+            border_style="yellow",
+            box=ROUNDED,
+            expand=False,
+            title="System",
+            title_align="left",
+        )
+    )
+    console.print()  # Add a blank line after the system message
+
+
+def print_code(code, language="python"):
+    syntax = Syntax(code, language, theme="monokai", line_numbers=True)
+    console.print(
+        Panel(
+            syntax,
+            border_style="red",
+            box=ROUNDED,
+            expand=False,
+            title=f"Code ({language})",
+            title_align="left",
+        )
+    )
+
+
+def dict_to_equal_string(d: dict) -> str:
+    return "\n".join([f'-{key}="{value}"' for key, value in d.items()])
+
+
+def print_tool_usage(message):
+    print_message = ""
+    tool_name = message.tool_calls[0]["name"]
+    arguments = ""
+    if (
+        "args" in message.tool_calls[0]
+        and len(message.tool_calls[0]["args"].values()) > 0
+    ):
+        arguments += dict_to_equal_string(message.tool_calls[0]["args"])
+
+    if tool_name.startswith("transfer_to_"):
+        tool_label = " ".join(
+            word.capitalize()
+            for word in tool_name.split("transfer_to_")[1].replace("_", " ").split()
+        )
+        print_message = f"\n🧞 [bold blue]Delegated to [/bold blue]{tool_label}"
+    else:
+        tool_label = tool_name.capitalize().replace("_", " ")
+        print_message = f"\n[bold blue]Tool Used:[/bold blue] {tool_label}\n{arguments}"
+    console.print(print_message)
+
+
+def print_tool_response(response):
+    console.print(f"\n[bold blue]Response:[/bold blue] {response}")
+
+
+def clear_screen():
+    console.clear()
+
+
+def print_welcome_message(agent):
+    # Set terminal title
+    set_terminal_title()
+    
+    # Skip the welcome - we already said hello in the CLI startup
+    # Just quietly start the conversation
+    pass
+
+
+def print_divider():
+    console.print("─" * console.width, style="dim")
+
+
+def get_user_input(agent_label):
+    try:
+        user_input = console.input(
+            "\n[bold cyan]You:[/bold cyan] "
+        )  # Add a newline before the prompt
+        console.print()  # Add a blank line after the user's input
+        return user_input
+    except EOFError:
+        console.print(
+            f"\n[bold red]{agent_label}:[/bold red] Conversation ended by user."
+        )
+        return "exit"
+    except KeyboardInterrupt:
+        console.print(
+            f"\n[bold red]{agent_label}:[/bold red] Conversation ended by user."
+        )
+        return "exit"
+
+
+def print_image(image_path: str):
+    """Display an image in the terminal."""
+    try:
+        console.print()  # Add some spacing
+
+        # Display the file path and viewing instructions
+        message = (
+            f"[yellow]Image saved at: {image_path}[/yellow]\n\n"
+            "[dim]To view the image:[/dim]\n"
+            f"[cyan]• Local system: Open {image_path} with your image viewer[/cyan]\n"
+            "[cyan]• Remote/SSH: Download the file to your local machine to view[/cyan]"
+        )
+
+        console.print(
+            Panel(
+                message,
+                border_style="yellow",
+                box=ROUNDED,
+                expand=False,
+                title="Graph Output",
+                title_align="left",
+            )
+        )
+
+        # Only try to show the image if we're in a GUI environment
+        if os.environ.get("DISPLAY") and platform.system() != "Windows":
+            try:
+                img = Image.open(image_path)
+                img.show()
+            except Exception:
+                pass  # Silently fail if we can't display the image
+        elif platform.system() == "Windows":
+            try:
+                subprocess.run(['start', '', image_path], shell=True)  # Windows-specific file opening
+            except Exception:
+                pass
+
+        console.print()  # Add some spacing after
+    except Exception as e:
+        console.print(
+            Panel(
+                f"[yellow]Unable to process image. File saved at: {image_path}[/yellow]\nError: {str(e)}",
+                border_style="yellow",
+                box=ROUNDED,
+                expand=False,
+                title="Graph Output",
+                title_align="left",
+            )
+        )

naas_abi_core/cli/__init__.py

@@ -0,0 +1,53 @@
+import click
+
+from .agent import agent
+from .chat import chat
+from .config import config
+from .init import init
+from .module import module
+from .new import new
+from .secret import secrets
+
+# from dotenv import load_dotenv
+
+# load_dotenv()
+
+
+@click.group("abi")
+def main():
+    pass
+
+
+# @main.command("chat")
+# @click.option("--module-name", type=str, required=True, default="chatgpt")
+# @click.option("--agent-name", type=str, required=True, default="ChatGPTAgent")
+# def chat(module_name: str, agent_name: str):
+#     from naas_abi_core.engine.Engine import Engine
+
+#     engine = Engine()
+#     engine.load(module_names=[module_name])
+
+#     from naas_abi_core.apps.terminal_agent.main import run_agent
+
+#     logger.debug(f"Module agents: {engine.modules[module_name].agents}")
+
+#     for agent_class in engine.modules[module_name].agents:
+#         logger.debug(f"Agent class: {agent_class.__name__}")
+#         if agent_class.__name__ == agent_name:
+#             run_agent(agent_class.New())
+#             break
+
+
+# Add the secrets group to the main abi group
+
+
+main.add_command(secrets)
+main.add_command(config)
+main.add_command(module)
+main.add_command(agent)
+main.add_command(chat)
+main.add_command(new)
+main.add_command(init)
+
+if __name__ == "__main__":
+    main()

naas_abi_core/cli/agent.py

@@ -0,0 +1,30 @@
+import click
+from rich.console import Console
+from rich.table import Table
+
+from naas_abi_core.engine.Engine import Engine
+
+
+@click.group("agent")
+def agent():
+    pass
+
+
+@agent.command("list")
+def list():
+    engine = Engine()
+    engine.load()
+
+    console = Console()
+    table = Table(
+        title="Available Agents", show_header=True, header_style="bold magenta"
+    )
+    table.add_column("Module", style="cyan", no_wrap=True)
+    table.add_column("Agent", style="green")
+
+    modules = engine.modules
+    for module in modules:
+        for agent in modules[module].agents:
+            table.add_row(module, agent.__name__)
+
+    console.print(table)

naas_abi_core/cli/chat.py

@@ -0,0 +1,26 @@
+import click
+
+from naas_abi_core import logger
+
+
+@click.command("chat")
+@click.argument("module-name", type=str, required=True, default="naas_abi")
+@click.argument("agent-name", type=str, required=True, default="AbiAgent")
+def chat(module_name: str, agent_name: str):
+    from naas_abi_core.engine.Engine import Engine
+
+    engine = Engine()
+    engine.load(module_names=[module_name])
+
+    from naas_abi_core.apps.terminal_agent.main import run_agent
+
+    if module_name not in engine.modules:
+        raise ValueError(f"Module {module_name} not found")
+
+    logger.debug(f"Module agents: {engine.modules[module_name].agents}")
+
+    for agent_class in engine.modules[module_name].agents:
+        logger.debug(f"Agent class: {agent_class.__name__}")
+        if agent_class.__name__ == agent_name:
+            run_agent(agent_class.New())
+            break

naas_abi_core/cli/config.py

@@ -0,0 +1,49 @@
+import os
+
+import click
+import yaml
+
+from naas_abi_core.engine.engine_configuration.EngineConfiguration import (
+    EngineConfiguration,
+)
+
+
+@click.group("config")
+def config():
+    pass
+
+
+@config.command("validate")
+@click.option("--configuration-file", type=str, required=False, default=None)
+def validate(configuration_file: str | None):
+    configuration_content: str | None = None
+
+    if configuration_file is not None:
+        if not os.path.exists(configuration_file):
+            raise FileNotFoundError(
+                f"Configuration file {configuration_file} not found"
+            )
+        with open(configuration_file, "r") as file:
+            configuration_content = file.read()
+
+    EngineConfiguration.load_configuration(configuration_content)
+    print("Configuration is valid")
+
+
+@config.command("render")
+@click.option("--configuration-file", type=str, required=False, default=None)
+def render(configuration_file: str | None):
+    configuration_content: str | None = None
+
+    if configuration_file is not None:
+        if not os.path.exists(configuration_file):
+            raise FileNotFoundError(
+                f"Configuration file {configuration_file} not found"
+            )
+        with open(configuration_file, "r") as file:
+            configuration_content = file.read()
+
+    configuration: EngineConfiguration = EngineConfiguration.load_configuration(
+        configuration_content
+    )
+    print(yaml.dump(configuration.model_dump(), indent=2))

naas_abi_core/cli/init.py

@@ -0,0 +1,13 @@
+import os
+
+import click
+
+
+@click.command("init")
+@click.argument("path")
+def init(path: str):
+    if path == ".":
+        path = os.getcwd()
+
+    os.makedirs(path, exist_ok=True)
+    # os.exec(f"cd {path} && uv init .")

naas_abi_core/cli/module.py

@@ -0,0 +1,28 @@
+import click
+from naas_abi_core.engine.engine_configuration.EngineConfiguration import (
+    EngineConfiguration,
+)
+from rich.console import Console
+from rich.table import Table
+
+
+@click.group("module")
+def module():
+    pass
+
+
+@module.command("list")
+def list() -> None:
+    configuration: EngineConfiguration = EngineConfiguration.load_configuration()
+
+    console = Console()
+    table = Table(
+        title="Available Modules", show_header=True, header_style="bold magenta"
+    )
+    table.add_column("Module", style="cyan", no_wrap=True)
+    table.add_column("Enabled", style="green")
+
+    for module in configuration.modules:
+        table.add_row(module.module, str(module.enabled))
+
+    console.print(table)

naas_abi_core/cli/new.py

@@ -0,0 +1,13 @@
+import click
+
+
+@click.group("new")
+def new():
+    pass
+
+
+@new.command("module")
+@click.argument("module-name")
+@click.argument("module-path")
+def new_module(module_name: str, module_path: str):
+    print(f"Creating a new module: {module_name} at {module_path}")

naas_abi_core/cli/secret.py

@@ -0,0 +1,79 @@
+import os
+
+import click
+
+
+@click.group("secrets")
+def secrets():
+    pass
+
+
+@secrets.group("naas")
+def naas():
+    pass
+
+
+@naas.command("push-env-as-base64")
+@click.option(
+    "--naas-api-key", type=str, required=True, default=os.getenv("NAAS_API_KEY")
+)
+@click.option("--naas-api-url", type=str, required=True, default="https://api.naas.ai")
+@click.option("--naas-secret-name", type=str, required=True, default="abi_secrets")
+@click.option("--env-file", type=str, required=True, default=".env.prod")
+def push_env_to_naas(naas_api_key, naas_api_url, naas_secret_name, env_file):
+    import base64
+
+    from naas_abi_core.services.secret.adaptors.secondary.NaasSecret import NaasSecret
+
+    naas_secret = NaasSecret(naas_api_key, naas_api_url)
+
+    envfile_content = ""
+
+    with open(env_file, "r") as envfile:
+        envfile_content = envfile.read()
+
+    print(envfile_content)
+
+    base64_content = base64.b64encode(envfile_content.encode("utf-8")).decode("utf-8")
+    naas_secret.set(naas_secret_name, base64_content)
+
+    print(f"Pushed {env_file} to Naas as base64 secret {naas_secret_name}")
+
+
+@naas.command("list")
+@click.option(
+    "--naas-api-key", type=str, required=True, default=os.getenv("NAAS_API_KEY")
+)
+@click.option("--naas-api-url", type=str, required=True, default="https://api.naas.ai")
+def list_secrets(naas_api_key, naas_api_url):
+    from naas_abi_core.services.secret.adaptors.secondary.NaasSecret import NaasSecret
+
+    naas_secret = NaasSecret(naas_api_key, naas_api_url)
+
+    naas_secret.list()
+
+    for key, value in naas_secret.list().items():
+        print(f"{key}: {value}")
+
+
+@naas.command("get-base64-env")
+@click.option(
+    "--naas-api-key", type=str, required=True, default=os.getenv("NAAS_API_KEY")
+)
+@click.option("--naas-api-url", type=str, required=True, default="https://api.naas.ai")
+@click.option("--naas-secret-name", type=str, required=True, default="abi_secrets")
+def get_secret(naas_api_key, naas_api_url, naas_secret_name):
+    from naas_abi_core.services.secret.adaptors.secondary.Base64Secret import (
+        Base64Secret,
+    )
+    from naas_abi_core.services.secret.adaptors.secondary.NaasSecret import NaasSecret
+
+    naas_secret = NaasSecret(naas_api_key, naas_api_url)
+    base64_secret = Base64Secret(naas_secret, naas_secret_name)
+
+    for key, value in base64_secret.list().items():
+        # If value is multiline
+        if "\n" in value:
+            print(f'{key}="{value}"')
+        else:
+            print(f"{key}={value}")

naas_abi_core/engine/Engine.py

@@ -0,0 +1,87 @@
+from typing import Dict, List
+
+from naas_abi_core import logger
+from naas_abi_core.engine.engine_configuration.EngineConfiguration import (
+    EngineConfiguration,
+)
+from naas_abi_core.engine.engine_loaders.EngineModuleLoader import EngineModuleLoader
+from naas_abi_core.engine.engine_loaders.EngineOntologyLoader import (
+    EngineOntologyLoader,
+)
+from naas_abi_core.engine.engine_loaders.EngineServiceLoader import EngineServiceLoader
+from naas_abi_core.engine.IEngine import IEngine
+from naas_abi_core.module.Module import BaseModule
+
+
+class Engine(IEngine):
+    __configuration: EngineConfiguration
+    __engine_module_loader: EngineModuleLoader
+    __engine_service_loader: EngineServiceLoader
+
+    __modules: Dict[
+        str, BaseModule
+    ]  # Must not set a default value to prevent modules to try to access modules inside constructors.
+
+    __services: IEngine.Services
+
+    @property
+    def configuration(self) -> EngineConfiguration:
+        return self.__configuration
+
+    @property
+    def modules(self) -> Dict[str, BaseModule]:
+        try:
+            return self.__modules
+        except AttributeError:
+            error_message = "You are trying to access the engine's modules before the engine is loaded. Modules are accessible when on_initialized is called. If you are in your module constructor or in the on_load method, you should not try to access self.engine yet."
+            logger.error(error_message)
+            raise RuntimeError(error_message)
+
+    @property
+    def services(self) -> IEngine.Services:
+        return self.__services
+
+    def __init__(self, configuration: str | None = None):
+        # Load configuration
+        self.__configuration = EngineConfiguration.load_configuration(configuration)
+        self.__engine_module_loader = EngineModuleLoader(self.__configuration)
+        self.__engine_service_loader = EngineServiceLoader(self.__configuration)
+
+    def load(self, module_names: List[str] = []):
+        module_dependencies = self.__engine_module_loader.get_modules_dependencies(
+            module_names
+        )
+
+        logger.debug("Loading engine services")
+        self.__services = self.__engine_service_loader.load_services(
+            module_dependencies
+        )
+        logger.debug("Engine services loaded")
+
+        logger.debug("Loading engine modules")
+        self.__modules = self.__engine_module_loader.load_modules(self, module_names)
+        logger.debug("Engine modules loaded")
+
+        if self.__services.triple_store_available():
+            logger.debug("Loading engine ontologies")
+            EngineOntologyLoader.load_ontologies(
+                self.__services.triple_store,
+                self.__engine_module_loader.ordered_modules,
+            )
+            logger.debug("Engine ontologies loaded")
+        else:
+            logger.debug("No triple store available, skipping ontology loading")
+
+        logger.debug("Initializing engine")
+        self.on_initialized()
+        logger.debug("Engine initialized")
+
+    def on_initialized(self):
+        for module in self.__modules.values():
+            module.on_initialized()
+
+
+if __name__ == "__main__":
+    engine = Engine()
+    engine.load(module_names=["chatgpt"])
+    print("Engine loaded successfully")

naas_abi_core/engine/EngineProxy.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict
+
+from naas_abi_core.engine.IEngine import IEngine
+from naas_abi_core.services.object_storage.ObjectStorageService import (
+    ObjectStorageService,
+)
+from naas_abi_core.services.secret.Secret import Secret
+from naas_abi_core.services.triple_store.TripleStoreService import TripleStoreService
+from naas_abi_core.services.vector_store.VectorStoreService import VectorStoreService
+
+if TYPE_CHECKING:
+    from naas_abi_core.module.Module import BaseModule, ModuleDependencies
+
+
+class ServicesProxy:
+    __engine: IEngine
+    __module_name: str
+    __module_dependencies: ModuleDependencies
+
+    def __init__(
+        self, engine: IEngine, module_name: str, module_dependencies: ModuleDependencies
+    ):
+        self.__engine = engine
+        self.__module_name = module_name
+        self.__module_dependencies = module_dependencies
+
+    # def __accessible_services(self) -> List[Any]:
+    #     engine_services = {
+    #         type(service): service for service in self.__engine.services.all
+    #     }
+
+    #     for service_type in self.__module_dependencies.services:
+    #         assert service_type in engine_services, (
+    #             f"Service {service_type} not found in engine services"
+    #         )
+
+    #     return [
+    #         service
+    #         for service in engine_services.values()
+    #         if type(service) in self.__module_dependencies.services
+    #     ]
+
+    def __ensure_access(self, service_type: type) -> None:
+        if service_type not in self.__module_dependencies.services:
+            raise ValueError(
+                f"Module {self.__module_name} does not have access to {service_type}"
+            )
+
+    @property
+    def object_storage(self) -> ObjectStorageService:
+        self.__ensure_access(ObjectStorageService)
+
+        return self.__engine.services.object_storage
+
+    @property
+    def triple_store(self) -> TripleStoreService:
+        self.__ensure_access(TripleStoreService)
+
+        return self.__engine.services.triple_store
+
+    @property
+    def vector_store(self) -> VectorStoreService:
+        self.__ensure_access(VectorStoreService)
+
+        return self.__engine.services.vector_store
+
+    @property
+    def secret(self) -> Secret:
+        self.__ensure_access(Secret)
+
+        return self.__engine.services.secret
+
+
+class EngineProxy:
+    __engine: IEngine
+    __module_name: str
+    __module_dependencies: ModuleDependencies
+
+    __services_proxy: ServicesProxy
+
+    def __init__(
+        self,
+        engine: IEngine,
+        module_name: str,
+        module_dependencies: ModuleDependencies,
+    ):
+        self.__engine = engine
+        self.__module_name = module_name
+        self.__module_dependencies = module_dependencies
+        self.__services_proxy = ServicesProxy(engine, module_name, module_dependencies)
+
+    @property
+    def modules(self) -> Dict[str, BaseModule]:
+        _modules = {}
+
+        for module in self.__module_dependencies.modules:
+            is_soft = module.endswith("#soft")
+            module = module.replace("#soft", "")
+            if module not in self.__engine.modules and is_soft:
+                continue
+            _modules[module] = self.__engine.modules[module]
+
+        return _modules
+
+    @property
+    def services(self) -> ServicesProxy:
+        return self.__services_proxy

naas_abi_core/engine/Engine_test.py

@@ -0,0 +1,6 @@
+from naas_abi_core.engine.Engine import Engine
+
+
+def test_engine(test_configuration: str):
+    engine = Engine(test_configuration)
+    assert engine is not None