hana-ai 1.0.25121700__tar.gz → 1.0.26011600__tar.gz

{hana_ai-1.0.25121700/src/hana_ai.egg-info → hana_ai-1.0.26011600}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hana_ai
-Version: 1.0.25121700
+Version: 1.0.26011600
 Summary: Generative AI Toolkit for SAP HANA Cloud
 Author: SAP
 License: Apache-2.0
@@ -12,20 +12,15 @@ Keywords: Generative AI Toolkit SAP HANA Cloud
 Requires-Python: >=3.0
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: langchain
+Requires-Dist: langchain-community==0.3.27
+Requires-Dist: langchain-experimental==0.3.3
+Requires-Dist: langchain-text-splitters==0.3.9
 Requires-Dist: numpy
 Requires-Dist: pandas
-Requires-Dist: hana-ml>=2.26.25101500
-Requires-Dist: langchain-community
-Requires-Dist: langchain-core
-Requires-Dist: langchain-experimental
-Requires-Dist: langchain-text-splitters
-Requires-Dist: langchain-hana
-Requires-Dist: pydantic
-Requires-Dist: pydantic-core
-Requires-Dist: cryptography
-Requires-Dist: ipython
-Requires-Dist: deprecated
+Requires-Dist: hana-ml>=2.27.25122200
+Requires-Dist: pydantic<2.13,>=2.11
+Requires-Dist: sap-ai-sdk-gen[all]==5.10.0
+Requires-Dist: fastmcp>=2.0
 Dynamic: license-file
 
 [![REUSE status](https://api.reuse.software/badge/github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud)](https://api.reuse.software/info/github.com/SAP/generative-ai-toolkit-for-sap-hana-cloud)

{hana_ai-1.0.25121700 → hana_ai-1.0.26011600}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hana_ai"
-version = "1.0.25121700"
+version = "1.0.26011600"
 authors = [
     {name = "SAP"}
 ]

hana_ai-1.0.26011600/requirements.txt

@@ -0,0 +1,14 @@
+langchain-community==0.3.27
+langchain-experimental==0.3.3
+langchain-text-splitters==0.3.9
+
+numpy
+pandas
+
+hana-ml>=2.27.25122200
+
+pydantic>=2.11,<2.13
+
+sap-ai-sdk-gen[all]==5.10.0
+
+fastmcp>=2.0

{hana_ai-1.0.25121700 → hana_ai-1.0.26011600}/src/hana_ai/__init__.py

@@ -2,4 +2,4 @@
 hana_ai is a Python package for AI/ML related utilities.
 """
 
-__version__ = "1.0.25121700"
+__version__ = "1.0.26011600"

hana_ai-1.0.26011600/src/hana_ai/agents/hana_agent/agent_base.py

@@ -0,0 +1,271 @@
+"""
+hana_ml.agents.agent_base
+"""
+import json
+import logging
+import threading
+import time
+
+from hana_ml.ml_base import MLBase
+from hana_ml.visualizers.shared import EmbeddedUI
+
+from .progress_monitor import TextProgressMonitor
+from .utility import _call_agent_sql, _create_ai_core_remote_source, _delete_ai_core_pse, _drop_ai_core_remote_source, _drop_certificate
+
+logger = logging.getLogger(__name__)
+
+class AgentBase(MLBase):
+    """
+    Discovery Agent for interacting with AI Core services.
+    """
+    def __init__(self, connection_context, agent_type):
+        """
+        Initialize the AgentBase.
+
+        Parameters
+        ----------
+        connection_context : ConnectionContext
+            The HANA connection context.
+        agent_type : {"DISCOVERY_AGENT_DEV", "DISCOVERY_AGENT", "DATA_AGENT_DEV", "DATA_AGENT"}
+            The type of agent to be used.
+        """
+        super().__init__(connection_context)
+        self.conn_context = connection_context
+        self.remote_source_name = "HANA_DISCOVERY_AGENT_CREDENTIALS"
+        self.pse_name = "AI_CORE_PSE"
+        if agent_type not in {"DISCOVERY_AGENT_DEV", "DISCOVERY_AGENT", "DATA_AGENT_DEV", "DATA_AGENT"}:
+            raise ValueError("Invalid agent_type. Must be one of 'DISCOVERY_AGENT_DEV', 'DISCOVERY_AGENT', 'DATA_AGENT_DEV', 'DATA_AGENT'.")
+        self.agent_type = agent_type
+
+    def drop_remote_source(self, remote_source_name: str, cascade: bool = True):
+        """
+        Drop the remote source for AI Core.
+
+        Parameters
+        ----------
+        remote_source_name : str, optional
+            The name of the remote source to be dropped. Default is "AI_CORE_REMOTE_SOURCE".
+        cascade : bool, optional
+            Whether to drop dependent objects as well. Default is True.
+        """
+        try:
+            _drop_ai_core_remote_source(
+                connection_context=self.conn_context,
+                remote_source_name=remote_source_name,
+                cascade=cascade
+            )
+        except Exception as exc:
+            logger.warning("Failed to drop remote source %s: %s", remote_source_name, str(exc))
+
+    def drop_pse(self, pse_name: str, cascade: bool = True):
+        """
+        Drop the PSE for AI Core.
+
+        Parameters
+        ----------
+        pse_name : str, optional
+            The name of the PSE to be dropped. Default is "AI_CORE_PSE".
+        cascade : bool, optional
+            Whether to drop dependent objects as well. Default is True.
+        """
+        try:
+            _delete_ai_core_pse(
+                connection_context=self.conn_context,
+                pse_name=pse_name,
+                cascade=cascade
+            )
+        except Exception as exc:
+            logger.warning("Failed to drop PSE %s: %s", pse_name, str(exc))
+
+    def drop_certificates(self):
+        """
+        Drop the certificate X1ROOT and DIGICERTG5.
+        """
+        try:
+            _drop_certificate(
+                connection_context=self.conn_context,
+                certificate_name="X1ROOT"
+            )
+        except Exception as exc:
+            logger.warning("Failed to drop certificate X1ROOT: %s", str(exc))
+        try:
+            _drop_certificate(
+                connection_context=self.conn_context,
+                certificate_name="DIGICERTG5"
+            )
+        except Exception as exc:
+            logger.warning("Failed to drop certificate DIGICERTG5: %s", str(exc))
+
+    def create_remote_source(self, credentials, pse_name: str = "AI_CORE_PSE", remote_source_name: str = "HANA_DISCOVERY_AGENT_CREDENTIALS", create_pse: bool = True):
+        """
+        Configure the Discovery/Data Agent by creating necessary PSE and remote source.
+
+        Parameters
+        ----------
+        credentials : dict or str
+            The credentials for AI Core service. If str, it should be a credentials filepath in JSON format.
+        pse_name : str, optional
+            The name of the PSE to be created. Default is "AI_CORE_PSE".
+        remote_source_name : str, optional
+            The name of the remote source to be created. Default is "HANA_DISCOVERY_AGENT_CREDENTIALS".
+        create_pse : bool, optional
+            Whether to create the PSE. Default is True.
+
+        Remarks
+        -------
+        The X1ROOT and DIGICERTG5 certificates will be created if they do not already exist. One can provide the enviroment variables DIGICERTG5_PATH and X1ROOT_PATH to specify the certificate file paths, otherwise the default certificate files will be used.
+        """
+        if isinstance(credentials, str):
+            with open(credentials, 'r') as file:
+                credentials = json.load(file)
+        _create_ai_core_remote_source(
+            connection_context=self.conn_context,
+            credentials=credentials,
+            pse_name=pse_name,
+            remote_source_name=remote_source_name,
+            create_pse=create_pse
+        )
+        self.remote_source_name = remote_source_name
+        self.pse_name = pse_name
+
+    def check_remote_source_detailed(self, remote_source_name):
+        """
+        Check if the remote source exists and retrieve detailed information.
+        """
+        try:
+            cursor = self.conn_context.connection.cursor()
+
+            # Query more detailed information
+            sql = """
+            SELECT *
+            FROM SYS.REMOTE_SOURCES
+            WHERE REMOTE_SOURCE_NAME = ?
+            """
+            cursor.execute(sql, (remote_source_name,))
+            result = cursor.fetchone()
+
+            if result:
+                return {
+                    'exists': True,
+                    'details': {
+                        'remote_source_name': result[0],
+                        'adapter_name': result[1],
+                        'connection_info': result[2],
+                        'created': result[3],
+                        'owner': result[4]
+                    }
+                }
+            else:
+                return {'exists': False, 'details': None}
+
+        except Exception as exc:
+            return {'exists': False, 'error': str(exc)}
+
+    def run(self, query: str, additional_config: dict = None, show_progress: bool = True):
+        """
+        Run a query using the Discovery/Data Agent.
+
+        Parameters
+        ----------
+        query : str
+            The query string to be executed.
+
+        additional_config : dict, optional
+            Additional configuration parameters for the Discovery/Data Agent.
+        Returns
+        -------
+        result : DataFrame
+            The result of the query execution.
+        """
+        config = {
+            "remoteSourceName": self.remote_source_name
+        }
+        if additional_config:
+            config.update(additional_config)
+
+        sql_query = _call_agent_sql(
+            query=query,
+            config=config,
+            agent_type=self.agent_type
+        )
+
+        logger.info("Executing Discovery Agent SQL: %s", sql_query)
+
+        # Get current connection ID
+        connection_id = int(self.conn_context.get_connection_id())
+
+        # Used to store result
+        result = None
+        execution_error = None
+        execution_completed = threading.Event()
+
+        def execute_query():
+            nonlocal result, execution_error
+            try:
+                with self.conn_context.connection.cursor() as cursor:
+                    cursor.execute(sql_query)
+                    logger.info("SQL executed successfully.")
+                    logger.info("Fetching result...")
+                    query_result = cursor.fetchone()
+                    result = query_result[0] if query_result else None
+                    logger.info("Result fetched successfully.")
+            except Exception as exc:
+                execution_error = exc
+                logger.error("Error executing query: %s", exc)
+            finally:
+                execution_completed.set()
+
+        if show_progress:
+            # Create progress monitor
+            monitor = TextProgressMonitor(
+                connection=EmbeddedUI.create_connection_context(self.conn_context).connection,
+                connection_id=connection_id,
+                show_progress=show_progress
+            )
+
+            # Start progress monitoring
+            monitor.start()
+
+            try:
+                # Start query thread
+                query_thread = threading.Thread(target=execute_query)
+                query_thread.daemon = True
+                query_thread.start()
+
+                # Poll progress until query completes
+                while not execution_completed.is_set():
+                    monitor.update()
+                    time.sleep(monitor.refresh_interval)
+
+                # Wait for query thread to finish
+                query_thread.join(timeout=5)
+
+                # Query completed
+                if execution_error:
+                    monitor.complete(success=False, final_message="Query failed: %s" % str(execution_error)[:100])
+                else:
+                    monitor.complete(success=True, final_message="Query completed successfully.")
+
+            except KeyboardInterrupt:
+                # User interruption
+                logger.warning("Query execution interrupted by user")
+                monitor.complete(success=False, final_message="interrupted by user")
+                raise
+
+            except Exception as exc:
+                # Other exceptions
+                monitor.complete(success=False, final_message="Error: %s" % str(exc)[:100])
+                raise
+
+            finally:
+                # Ensure monitor stops
+                monitor.stop()
+
+                # Store monitor for later progress history
+                self._progress_monitor = monitor
+
+        else:
+            # No progress display
+            execute_query()
+
+        return result

hana_ai-1.0.26011600/src/hana_ai/agents/hana_agent/data_agent.py

@@ -0,0 +1,38 @@
+"""
+hana_ml.agents.data_agent
+
+The following classes are available:
+
+    * :class:`DataAgent`
+"""
+import logging
+
+from .agent_base import AgentBase
+
+
+logger = logging.getLogger(__name__)
+
+class DataAgent(AgentBase):
+    """
+    Data Agent for interacting with AI Core services.
+
+    The user has the below privileges to create/drop remote source and PSE as well as call the Data Agent SQL:
+
+    - EXECUTE privilege on the DATA_AGENT_DEV or DATA_AGENT stored procedure.
+    - CREATE REMOTE SOURCE privilege.
+    - TRUST ADMIN privilege.
+    - CERTIFICATE ADMIN privilege.
+    """
+    def __init__(self, connection_context, agent_type="DATA_AGENT_DEV"):
+        """
+        Initialize the DataAgent.
+
+        Parameters
+        ----------
+        connection_context : ConnectionContext
+            The HANA connection context.
+        """
+        super().__init__(connection_context, agent_type=agent_type)
+        self.conn_context = connection_context
+        self.remote_source_name = "HANA_DISCOVERY_AGENT_CREDENTIALS"
+        self.pse_name = "AI_CORE_PSE"

hana_ai-1.0.26011600/src/hana_ai/agents/hana_agent/discovery_agent.py

@@ -0,0 +1,38 @@
+"""
+hana_ml.agents.discovery_agent
+
+The following classes are available:
+    * :class:`DiscoveryAgent`
+"""
+import logging
+
+from .agent_base import AgentBase
+
+
+logger = logging.getLogger(__name__)
+
+class DiscoveryAgent(AgentBase):
+    """
+    Discovery Agent for interacting with AI Core services.
+
+    The user has the below privileges to create/drop remote source and PSE as well as call the Discovery Agent SQL:
+
+    - EXECUTE privilege on the DISCOVERY_AGENT_DEV or DISCOVERY_AGENT stored procedure.
+    - CREATE REMOTE SOURCE privilege.
+    - TRUST ADMIN privilege.
+    - CERTIFICATE ADMIN privilege.
+
+    """
+    def __init__(self, connection_context, agent_type="DISCOVERY_AGENT_DEV"):
+        """
+        Initialize the DiscoveryAgent.
+
+        Parameters
+        ----------
+        connection_context : ConnectionContext
+            The HANA connection context.
+        """
+        super().__init__(connection_context, agent_type=agent_type)
+        self.conn_context = connection_context
+        self.remote_source_name = "HANA_DISCOVERY_AGENT_CREDENTIALS"
+        self.pse_name = "AI_CORE_PSE"

hana_ai-1.0.26011600/src/hana_ai/agents/hana_agent/progress_monitor.py

@@ -0,0 +1,223 @@
+
+"""
+Text progress monitor for agent progress display.
+"""
+import time
+from datetime import datetime
+from typing import List, Dict, Optional, Callable
+from tqdm import tqdm
+
+# pylint: disable=too-many-instance-attributes
+
+class TextProgressMonitor:
+    """Text progress monitor, suitable for scenarios with only textual description and no percentage."""
+
+    def __init__(self,
+                 connection,
+                 connection_id: int,
+                 refresh_interval: float = 1.0,
+                 show_progress: bool = True):
+        """
+        Initialize the text progress monitor.
+
+        Parameters
+        ----------
+        connection : database connection object
+            The database connection used to query progress information.
+        connection_id : int
+            The current connection ID, used to query corresponding progress information.
+        refresh_interval : float, optional
+            Progress query interval (seconds), default is 1.0 second.
+        show_progress : bool, optional
+            Whether to display progress, default is True.
+        """
+        self.connection = connection
+        self.connection_id = connection_id
+        self.refresh_interval = refresh_interval
+        self.show_progress = show_progress
+        # Progress related
+        self.progress_messages: List[Dict[str, str]] = []
+        self.last_message = ""
+        self.last_displayed_message = ""
+        # Monitor state
+        self.is_monitoring = False
+        self.completed = False
+        # Progress callbacks
+        self.on_progress_update: Optional[Callable[[str], None]] = None
+        self.on_complete: Optional[Callable[[bool], None]] = None
+        # tqdm progress bar
+        self.progress_bar = None
+        self.message_count = 0
+
+    def start(self) -> 'TextProgressMonitor':
+        """Start progress monitoring."""
+        if self.show_progress:
+            # Use custom format, only show elapsed time and message
+            self.progress_bar = tqdm(
+                total=None,  # No definite total progress
+                bar_format="{n}[{elapsed}{postfix}]",  # Show elapsed time and description
+                dynamic_ncols=True,
+                leave=True
+            )
+            # Set initial description
+            self.progress_bar.set_postfix_str("Starting...")
+        self.is_monitoring = True
+        self.completed = False
+        self.start_time = datetime.now()
+        self.message_count = 0
+        return self
+
+    def update(self) -> Optional[str]:
+        """
+        Update progress information.
+
+        Returns
+        -------
+        str or None
+            Returns the latest progress message, or None if there is no new message.
+        """
+        if not self.is_monitoring or self.completed:
+            return None
+        try:
+            # Only query PROGRESS_DETAIL field
+            progress_sql = f"""
+                SELECT PROGRESS_DETAIL, CURRENT_PROGRESS
+                FROM M_JOB_PROGRESS
+                WHERE CONNECTION_ID = {self.connection_id}
+                ORDER BY START_TIME DESC
+                LIMIT 1
+            """
+            with self.connection.cursor() as cursor:
+                cursor.execute(progress_sql)
+                result = cursor.fetchone()
+                if result and result[0]:
+                    current_message = result[0]
+                    current_progress = result[1]
+                    # If there is a new message
+                    if current_message and current_message != self.last_message:
+                        self.last_message = current_message
+                        self.message_count += 1
+
+                        # Use local time as timestamp
+                        timestamp = datetime.now().strftime("%H:%M:%S")
+
+                        self.progress_messages.append({
+                            'timestamp': timestamp,
+                            'message': current_message
+                        })
+
+                        # Use tqdm to display progress
+                        if self.show_progress and current_message != self.last_displayed_message:
+                            if self.progress_bar is not None:
+                                # Directly set description, bar_format will show elapsed time
+                                self.progress_bar.set_postfix_str(current_message)
+                                self.progress_bar.n = current_progress
+                                self.progress_bar.refresh()
+                            self.last_displayed_message = current_message
+
+                        # Call progress callback function
+                        if self.on_progress_update:
+                            self.on_progress_update(current_message)
+
+                        return current_message
+                else:
+                    # No progress information
+                    if self.show_progress and self.progress_bar is not None:
+                        if self.message_count == 0:
+                            self.progress_bar.set_postfix_str("Waiting for progress update...")
+        except Exception as exc:
+            # If progress query fails, do not interrupt main process
+            if self.show_progress and self.progress_bar is not None:
+                error_msg = str(exc)[:50]
+                self.progress_bar.set_postfix_str("Error: %s..." % error_msg)
+
+        return None
+
+    def complete(self, success: bool = True, final_message: str = None) -> None:
+        """
+        Complete progress monitoring.
+
+        Parameters
+        ----------
+        success : bool, optional
+            Whether completed successfully, default is True.
+        final_message : str, optional
+            Final message to display.
+        """
+        self.completed = True
+        if self.show_progress and self.progress_bar is not None:
+            end_time = datetime.now()
+            elapsed_time = end_time - self.start_time
+            elapsed_seconds = elapsed_time.total_seconds()
+            elapsed_str = self._format_time(elapsed_seconds)
+
+            # Update tqdm with final status
+            if final_message:
+                self.progress_bar.set_postfix_str(final_message)
+            else:
+                if success:
+                    self.progress_bar.set_postfix_str("Query completed successfully")
+                else:
+                    self.progress_bar.set_postfix_str("Query failed")
+
+            # Refresh display
+            self.progress_bar.refresh()
+
+            # Close the progress bar
+            time.sleep(0.1)  # Short delay to ensure display
+            self.progress_bar.close()
+
+        # Call complete callback
+        if self.on_complete:
+            self.on_complete(success)
+        self.is_monitoring = False
+
+    @staticmethod
+    def _format_time(seconds: float) -> str:
+        """Format elapsed time for display."""
+        if seconds < 60:
+            return "%ds" % int(seconds)
+        if seconds < 3600:
+            minutes = int(seconds // 60)
+            secs = int(seconds % 60)
+            return "%dm%ds" % (minutes, secs)
+        hours = int(seconds // 3600)
+        minutes = int((seconds % 3600) // 60)
+        return "%dh%dm" % (hours, minutes)
+
+    def stop(self) -> None:
+        """Stop progress monitoring."""
+        if not self.completed:
+            if self.show_progress and self.progress_bar is not None:
+                self.progress_bar.set_postfix_str("Stopped")
+                time.sleep(0.1)
+                self.progress_bar.close()
+            self.completed = True
+        self.is_monitoring = False
+
+    def get_recent_messages(self, count: int = 10) -> List[Dict[str, str]]:
+        """Get recent progress messages."""
+        return self.progress_messages[-count:] if self.progress_messages else []
+
+    def get_all_messages(self) -> List[Dict[str, str]]:
+        """Get all progress messages."""
+        return self.progress_messages.copy()
+
+    def clear_messages(self) -> None:
+        """Clear progress messages."""
+        self.progress_messages = []
+
+    def register_callback(self,
+                         on_progress: Optional[Callable[[str], None]] = None,
+                         on_complete: Optional[Callable[[bool], None]] = None) -> None:
+        """
+        Register callback functions.
+        Parameters
+        ----------
+        on_progress : Callable[[str], None], optional
+            Callback function when progress updates.
+        on_complete : Callable[[bool], None], optional
+            Callback function when completed.
+        """
+        self.on_progress_update = on_progress
+        self.on_complete = on_complete