naas-abi-core 1.4.1__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/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

naas_abi_core/engine/IEngine.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List, Union
+
+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
+
+
+class IEngine:
+    class Services:
+        __object_storage: ObjectStorageService | None
+        __triple_store: TripleStoreService | None
+        __vector_store: VectorStoreService | None
+        __secret: Secret | None
+
+        def __init__(
+            self,
+            object_storage: ObjectStorageService | None = None,
+            triple_store: TripleStoreService | None = None,
+            vector_store: VectorStoreService | None = None,
+            secret: Secret | None = None,
+        ):
+            self.__object_storage = object_storage
+            self.__triple_store = triple_store
+            self.__vector_store = vector_store
+            self.__secret = secret
+
+        @property
+        def object_storage(self) -> ObjectStorageService:
+            assert self.__object_storage is not None, (
+                "Object storage service is not initialized"
+            )
+            return self.__object_storage
+
+        @property
+        def triple_store(self) -> TripleStoreService:
+            assert self.__triple_store is not None, (
+                "Triple store service is not initialized"
+            )
+            return self.__triple_store
+
+        def triple_store_available(self) -> bool:
+            return self.__triple_store is not None
+
+        @property
+        def vector_store(self) -> VectorStoreService:
+            assert self.__vector_store is not None, (
+                "Vector store service is not initialized"
+            )
+            return self.__vector_store
+
+        @property
+        def secret(self) -> Secret:
+            assert self.__secret is not None, "Secret service is not initialized"
+            return self.__secret
+
+        @property
+        def all(
+            self,
+        ) -> List[
+            Union[
+                ObjectStorageService | None,
+                TripleStoreService | None,
+                VectorStoreService | None,
+                Secret | None,
+            ]
+        ]:
+            return [
+                self.__object_storage,
+                self.__triple_store,
+                self.__vector_store,
+                self.__secret,
+            ]
+
+    __services: Services
+    __modules: Dict[str, BaseModule]
+
+    @property
+    def services(self) -> Services:
+        return self.__services
+
+    @property
+    def modules(self) -> Dict[str, BaseModule]:
+        return self.__modules

naas_abi_core/engine/conftest.py

@@ -0,0 +1,45 @@
+from pytest import fixture
+
+
+@fixture
+def test_configuration():
+    return """
+workspace_id: "1234567890"
+storage_name: "test"
+github_repository: "test"
+github_project_id: 1234567890
+triple_store_path: "test"
+api_title: "test"
+api_description: "test"
+logo_path: "test"
+favicon_path: "test"
+space_name: "test"
+cors_origins:
+  - "http://localhost:9879"
+
+services:
+    object_storage: &object_storage_service
+      object_storage_adapter:
+        adapter: "fs"
+        config:
+          base_path: "test"
+          test: "{{ secret.OXIGRAPH_URL }}"
+
+    triple_store:
+      triple_store_adapter:
+        adapter: "object_storage"
+        config:
+          triples_prefix: "test"
+          object_storage_service: *object_storage_service
+
+        
+    vector_store:
+      vector_store_adapter:
+        adapter: "qdrant"
+        config: {}
+        
+    secret:
+      secret_adapters:
+        - adapter: "dotenv"
+          config: {}
+"""