agenthink 0.1.18__tar.gz → 0.1.20__tar.gz

{agenthink-0.1.18 → agenthink-0.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenthink
-Version: 0.1.18
+Version: 0.1.20
 Summary: A unified agent framework for connecting workflows, databases, and agents
 Author: Ritobroto
 Requires-Python: >=3.10

{agenthink-0.1.18 → agenthink-0.1.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agenthink"
-version = "0.1.18"
+version = "0.1.20"
 description = "A unified agent framework for connecting workflows, databases, and agents"
 authors = [
   { name = "Ritobroto" }

{agenthink-0.1.18 → agenthink-0.1.20}/src/agenthink/connection.py

@@ -20,15 +20,6 @@ import logging
 import re
 dotenv.load_dotenv()
 
-# Create and configure logger
-# logging.basicConfig(
-#     filename="datastore_library.log",
-#     format='%(asctime)s %(levelname)s:%(name)s:%(message)s',
-#     filemode='w'
-# )
-# logger = logging.getLogger(__name__)
-# logger.setLevel(logging.DEBUG)
-
 logger = logging.getLogger(__name__)
 logger.addHandler(logging.NullHandler())
 
@@ -223,14 +214,34 @@ class DBConnector:
             return f"Database: {db_name}, Connection Object: {conn}"
 
     def execute_query(self, db_name: str, query: str):
+
         """
-        Execute a query on the specified database connection.
+        Execute a read-only SQL query on a MySQL or MSSQL database.
+
+        Parameters
+        ----------
+        db_name : str
+            Name of the database connection.
+        query : str
+            Read-only SQL query to execute (SELECT / WITH / SHOW / DESCRIBE / EXPLAIN).
+
+        Returns
+        -------
+        Any or None
+            Query results if successful, otherwise None.
+
+        Notes
+        -----
+        - Only read-only queries are allowed and enforced by prefix checks.
+        - Write or mutating queries are blocked.
+        - Errors are logged and cursors are safely closed.
+        - Behavior may differ slightly between MySQL and MSSQL drivers.
         """
+
         if db_name not in self.connection_object_dict:
             logger.error("No connection found for database: %s", db_name)
             return None
         
-        
         database_dict = self.connection_object_dict[db_name]
         database_type = database_dict.get("database_type")
         database_connection = database_dict.get("connection_object")
@@ -252,19 +263,18 @@ class DBConnector:
             return None
 
         if database_type == "mysql":
-            # try:
-            cursor = database_connection.cursor()
-            cursor.execute(query)
-            results = cursor.fetchall()
-            logger.info("Executed query on MySQL database '%s': %s", db_name, query)
-            # return f"{results}"
-            return f"{cursor}, {results}"
-            # except Exception as e:
-            #     logger.exception("Failed to execute query on MySQL database '%s': %s", db_name, e)
-            #     return None
-            # finally:
-            #     if cursor:
-            #         cursor.close()
+            try:
+                cursor = database_connection.cursor()
+                cursor.execute(query)
+                results = cursor.fetchall()
+                logger.info("Executed query on MySQL database '%s': %s", db_name, query)
+                return f"{results}"
+            except Exception as e:
+                logger.exception("Failed to execute query on MySQL database '%s': %s", db_name, e)
+                return None
+            finally:
+                if cursor:
+                    cursor.close()
         elif database_type == "mssql":
             try:
                 cursor = database_connection.cursor()
@@ -283,6 +293,211 @@ class DBConnector:
         else:
             logger.error("Unsupported database type '%s' for database '%s'", database_type, db_name)
             return None
+        
+    def display_tables(self,db_name:str):
+        """
+        Retrieve a list of user tables from a MySQL or MSSQL database.
+
+        Parameters
+        ----------
+        db_name : str
+            Name of the database connection.
+
+        Returns
+        -------
+        list[str] or None
+            List of table names if successful, otherwise None.
+
+        Notes
+        -----
+        - Uses `SHOW TABLES` for MySQL.
+        - Uses `INFORMATION_SCHEMA.TABLES` for MSSQL.
+        - Errors are logged and not raised.
+        """
+        database_dict = self.connection_object_dict[db_name]
+        database_type = database_dict.get("database_type")
+        database_connection = database_dict.get("connection_object")
+        if database_type == "mysql":
+            try:
+                cursor = database_connection.cursor()
+                cursor.execute("SHOW TABLES")
+                tables = cursor.fetchall()
+                table_list = [table[0] for table in tables]
+                return table_list
+            except Exception as e:
+                logger.exception("Failed to retrieve tables from MySQL database '%s': %s", db_name, e)
+                return None
+            
+        if database_type == "mssql":
+            try:
+                cursor = database_connection.cursor()
+                cursor.execute("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'")
+                tables = cursor.fetchall()
+                table_list = [table[0] for table in tables]
+                return table_list
+            except Exception as e:
+                logger.exception("Failed to retrieve tables from MSSQL database '%s': %s", db_name, e)
+                return None
+            
+
+    def insert_data(self,db_name:str,table_name:str,data:dict):
+        """
+        Insert a single row into a MySQL or MSSQL table.
+
+        Parameters
+        ----------
+        db_name : str
+            Name of the database connection.
+        table_name : str
+            Target table name (must be trusted).
+        data : dict
+            Column-to-value mapping for the row to insert.
+
+        Notes
+        -----
+        - Uses `%s` placeholders for MySQL and `?` for MSSQL.
+        - Commits the transaction on success and logs the result.
+        - Table and column names are not parameterized and must be validated.
+        """
+        database_dict = self.connection_object_dict[db_name]
+        database_type = database_dict.get("database_type")
+        database_connection = database_dict.get("connection_object")
+        columns = ', '.join(data.keys())
+        placeholders = ', '.join(['%s'] * len(data))
+        values = tuple(data.values())
+        if database_type == "mysql":
+            try:
+                cursor = database_connection.cursor()
+                sql = f"INSERT INTO {table_name} ({columns}) VALUES ({placeholders})"
+                cursor.execute(sql, values)
+                database_connection.commit()
+                cursor.close()
+                logger.debug("Data inserted into MySQL database '%s', table '%s'", db_name, table_name)
+            except Exception as e:
+                logger.exception("Failed to insert data into MySQL database '%s', table '%s': %s", db_name, table_name, e)
+        if database_type == "mssql":
+            try:
+                cursor = database_connection.cursor()
+                columns_sql = ", ".join(f"[{c}]" for c in data.keys())
+                placeholders = ", ".join("?" for _ in data)
+                values = tuple(data.values())
+
+                sql = f"INSERT INTO [{table_name}] ({columns_sql}) VALUES ({placeholders})"
+
+                cursor.execute(sql, values)
+                database_connection.commit()
+
+                logger.info(
+                    "Data inserted into MSSQL database '%s', table '%s'",
+                    db_name,
+                    table_name
+                )
+                cursor.close()
+            except Exception as e:
+                logger.exception("Insert failed for %s database '%s', table '%s'", database_type, db_name, table_name)
+
+    def get_data(self, db_name: str, table_name: str, num_rows: int = 5):
+        """
+        Retrieve a limited number of rows from a table for display.
+
+        Parameters
+        ----------
+        db_name : str
+            Name of the database connection.
+        table_name : str
+            Target table name (must be trusted).
+        num_rows : int, optional
+            Number of rows to retrieve (default is 5).
+
+        Returns
+        -------
+        list[tuple] or None
+            Retrieved rows if successful, otherwise None.
+        """
+        db = self.connection_object_dict[db_name]
+        db_type = db["database_type"]
+        conn = db["connection_object"]
+
+        cursor = conn.cursor()
+        try:
+            if db_type == "mysql":
+                sql = f"SELECT * FROM {table_name} LIMIT %s"
+                cursor.execute(sql, (num_rows,))
+            elif db_type == "mssql":
+                sql = f"SELECT TOP ({num_rows}) * FROM [{table_name}]"
+                cursor.execute(sql)
+            else:
+                return None
+
+            return cursor.fetchall()
+        except Exception:
+            logger.exception(
+                "Failed to retrieve data from %s database '%s', table '%s'",
+                db_type, db_name, table_name
+            )
+            return None
+        finally:
+            cursor.close()
+
+    def get_schema(self, db_name: str, table_name: str):
+        """
+        Retrieve column metadata for a table from a database.
+
+        Parameters
+        ----------
+        db_name : str
+            Name of the database connection.
+        table_name : str
+            Target table name (must be trusted).
+
+        Returns
+        -------
+        list[tuple] or None
+            List of (column_name, data_type, is_nullable) ordered by column position,
+            or None if the schema cannot be retrieved.
+
+        Notes
+        -----
+        - Uses INFORMATION_SCHEMA for portability.
+        - Supports MySQL and MSSQL.
+        - Errors are logged and not raised.
+        """
+
+        db = self.connection_object_dict[db_name]
+        db_type = db["database_type"]
+        conn = db["connection_object"]
+
+        cursor = conn.cursor()
+        try:
+            if db_type == "mysql":
+                sql = """
+                    SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE
+                    FROM INFORMATION_SCHEMA.COLUMNS
+                    WHERE TABLE_SCHEMA = DATABASE()
+                    AND TABLE_NAME = %s
+                    ORDER BY ORDINAL_POSITION
+                    """
+                cursor.execute(sql, (table_name,))
+                result =  cursor.fetchall()
+            if db_type == "mssql":
+                sql = """
+                    SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE
+                    FROM INFORMATION_SCHEMA.COLUMNS
+                    WHERE TABLE_NAME = ?
+                    ORDER BY ORDINAL_POSITION
+                    """
+                cursor.execute(sql, (table_name,))
+                result = cursor.fetchall()
+        except Exception:
+            logger.exception(
+                "Failed to retrieve schema from %s database '%s', table '%s'",
+                db_type, db_name, table_name
+            )
+            return None
+        finally:
+            cursor.close()
+        return result
+
 
     def _debugging_function(self):
             prefix = f"{self._workflow_id}/{self._user_id}/"
@@ -300,4 +515,6 @@ class DBConnector:
             Number of datastores: {self.no_of_datastores}\n
             Current connection_object_dict: {self.connection_object_dict}\n
             """
-            return output_message
+            return output_message
+    
+    

{agenthink-0.1.18 → agenthink-0.1.20}/src/agenthink.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenthink
-Version: 0.1.18
+Version: 0.1.20
 Summary: A unified agent framework for connecting workflows, databases, and agents
 Author: Ritobroto
 Requires-Python: >=3.10