MindsDB 25.5.3.0__py3-none-any.whl → 25.5.4.0__py3-none-any.whl

mindsdb/integrations/handlers/informix_handler/informix_handler.py

@@ -8,98 +8,92 @@ from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
 
 
-
 import pandas as pd
-import IfxPyDbi as I 
-from sqlalchemy_informix.ibmdb import  InformixDialect
+import IfxPyDbi as Ifx
+from sqlalchemy_informix.ibmdb import InformixDialect
 
 logger = log.getLogger(__name__)
 
-class InformixHandler(DatabaseHandler):
 
+class InformixHandler(DatabaseHandler):
 
-    name= 'informix'
+    name = "informix"
 
     def __init__(self, name: str, connection_data: Optional[dict], **kwargs):
-        ''' Initialize the handler
+        """Initialize the handler
         Args:
             name (str): name of particular handler instance
             connection_data (dict): parameters for connecting to the database
             **kwargs: arbitrary keyword arguments.
-        '''
+        """
         super().__init__(name)
-        
+
         self.kwargs = kwargs
         self.parser = parse_sql
-        self.loging_enabled = connection_data['loging_enabled'] if 'loging_enabled' in connection_data else True
-        self.server = connection_data['server']
-        self.database = connection_data['database']
-        self.user = connection_data['user']
-        self.password = connection_data['password']
-        self.schemaName = connection_data['schema_name'] 
-        self.host = connection_data['host']
-        self.port = connection_data['port']
+        self.loging_enabled = (
+            connection_data["loging_enabled"]
+            if "loging_enabled" in connection_data
+            else True
+        )
+        self.server = connection_data["server"]
+        self.database = connection_data["database"]
+        self.user = connection_data["user"]
+        self.password = connection_data["password"]
+        self.schemaName = connection_data["schema_name"]
+        self.host = connection_data["host"]
+        self.port = connection_data["port"]
         self.connString = (
-    'SERVER={0};'
-    'DATABASE={1};'
-    'HOST={2};'
-    'PORT={3};'
-    'UID={4};'
-    'PWD={5};').format(self.server, self.database, self.host, self.port, self.user, self.password)
-
-        
-        
+            "SERVER={0};" "DATABASE={1};" "HOST={2};" "PORT={3};" "UID={4};" "PWD={5};"
+        ).format(
+            self.server, self.database, self.host, self.port, self.user, self.password
+        )
 
         self.connection = None
         self.is_connected = False
-          
-    
+
     def connect(self):
-        ''' Set up any connections required by the handler
+        """Set up any connections required by the handler
         Should return output of check_connection() method after attempting
         connection. Should switch self.is_connected.
         Returns:
             Connection Object
-        '''
+        """
         if self.is_connected is True:
             return self.connection
 
         try:
-            self.connection = I.connect(self.connString,'','')
-  
-            self.is_connected= True
-        except Exception as e:
-            logger.error(f'Error while connecting to {self.database}, {e}')
+            self.connection = Ifx.connect(self.connString, "", "")
 
+            self.is_connected = True
+        except Exception as e:
+            logger.error(f"Error while connecting to {self.database}, {e}")
 
         return self.connection
 
-
     def disconnect(self):
-        ''' Close any existing connections
+        """Close any existing connections
         Should switch self.is_connected.
-        '''
+        """
         if self.is_connected is False:
             return
         try:
             self.connection.close()
             self.is_connected = False
         except Exception as e:
-            logger.error(f'Error while disconnecting to {self.database}, {e}')
-
-        return 
+            logger.error(f"Error while disconnecting to {self.database}, {e}")
 
+        return
 
     def check_connection(self) -> StatusResponse:
-        ''' Check connection to the handler
+        """Check connection to the handler
         Returns:
             HandlerStatusResponse
-        '''
+        """
         responseCode = StatusResponse(False)
         need_to_close = self.is_connected is False
 
@@ -107,7 +101,7 @@ class InformixHandler(DatabaseHandler):
             self.connect()
             responseCode.success = True
         except Exception as e:
-            logger.error(f'Error connecting to database {self.database}, {e}!')
+            logger.error(f"Error connecting to database {self.database}, {e}!")
             responseCode.error_message = str(e)
         finally:
             if responseCode.success is True and need_to_close:
@@ -117,107 +111,93 @@ class InformixHandler(DatabaseHandler):
 
         return responseCode
 
-
     def native_query(self, query: str) -> StatusResponse:
-        '''Receive raw query and act upon it somehow.
+        """Receive raw query and act upon it somehow.
         Args:
             query (Any): query in native format (str for sql databases,
                 dict for mongo, etc)
         Returns:
             HandlerResponse
-        '''
+        """
         need_to_close = self.is_connected is False
         conn = self.connect()
         cur = conn.cursor()
         try:
             cur.execute(query)
-                   
-            if cur._result_set_produced :
-                result = cur.fetchall() 
+
+            if cur._result_set_produced:
+                result = cur.fetchall()
                 response = Response(
                     RESPONSE_TYPE.TABLE,
                     data_frame=pd.DataFrame(
-                        result,
-                        columns=[x[0] for x in cur.description]
-                    )
+                        result, columns=[x[0] for x in cur.description]
+                    ),
                 )
             else:
                 response = Response(RESPONSE_TYPE.OK)
                 if self.loging_enabled:
                     self.connection.commit()
         except Exception as e:
-            logger.error(f'Error running query: {query} on {self.database}')
-            response = Response(
-                RESPONSE_TYPE.ERROR,
-                error_message=str(e)
-            )
+            logger.error(f"Error running query: {query} on {self.database}")
+            response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
             if self.loging_enabled:
                 self.connection.rollback()
 
             cur.close()
 
-
         if need_to_close is True:
             self.disconnect()
 
         return response
 
-    
     def query(self, query: ASTNode) -> StatusResponse:
-        '''Receive query as AST (abstract syntax tree) and act upon it somehow.
+        """Receive query as AST (abstract syntax tree) and act upon it somehow.
         Args:
             query (ASTNode): sql query represented as AST. May be any kind
                 of query: SELECT, INTSERT, DELETE, etc
         Returns:
             HandlerResponse
-        '''
-        
-
+        """
 
         renderer = SqlalchemyRender(InformixDialect)
         query_str = renderer.get_string(query, with_failback=True)
         return self.native_query(query_str)
 
-
     def get_tables(self) -> StatusResponse:
-        ''' Return list of entities
+        """Return list of entities
         Return list of entities that will be accesible as tables.
         Returns:
             HandlerResponse: shoud have same columns as information_schema.tables
                 (https://dev.mysql.com/doc/refman/8.0/en/information-schema-tables-table.html)
                 Column 'TABLE_NAME' is mandatory, other is optional.
-        '''
+        """
         self.connect()
 
-
-        result=self.connection.tables()
+        result = self.connection.tables()
         try:
             if result:
                 response = Response(
                     RESPONSE_TYPE.TABLE,
                     data_frame=pd.DataFrame(
-                        [x['TABLE_NAME'] for x in result if x['TABLE_SCHEM']==self.schemaName],
-                        columns=['TABLE_NAME']
-                        
-                    )
+                        [
+                            x["TABLE_NAME"]
+                            for x in result
+                            if x["TABLE_SCHEM"] == self.schemaName
+                        ],
+                        columns=["TABLE_NAME"],
+                    ),
                 )
             else:
                 response = Response(RESPONSE_TYPE.OK)
-            
-        except Exception as e:
-            logger.error(f'Error running while getting table {e} on ')
-            response = Response(
-                RESPONSE_TYPE.ERROR,
-                error_message=str(e)
-            )
-
 
+        except Exception as e:
+            logger.error(f"Error running while getting table {e} on ")
+            response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
 
         return response
 
-    
     def get_columns(self, table_name: str) -> StatusResponse:
-        ''' Returns a list of entity columns
+        """Returns a list of entity columns
         Args:
             table_name (str): name of one of tables returned by self.get_tables()
         Returns:
@@ -226,93 +206,79 @@ class InformixHandler(DatabaseHandler):
                 Column 'COLUMN_NAME' is mandatory, other is optional. Hightly
                 recomended to define also 'DATA_TYPE': it should be one of
                 python data types (by default it str).
-        '''
-        
-        self.connect()
+        """
 
+        self.connect()
 
-        result=self.connection.columns(table_name=table_name)
+        result = self.connection.columns(table_name=table_name)
         try:
             if result:
                 response = Response(
                     RESPONSE_TYPE.TABLE,
                     data_frame=pd.DataFrame(
-                        [result[i]['COLUMN_NAME'] for i in range(len(result)) ],
-                        columns=['COLUMN_NAME']
-                        
-                    )
+                        [result[i]["COLUMN_NAME"] for i in range(len(result))],
+                        columns=["COLUMN_NAME"],
+                    ),
                 )
             else:
                 response = Response(RESPONSE_TYPE.OK)
-            
-        except Exception as e:
-            logger.error(f'Error running while getting table {e} on ')
-            response = Response(
-                RESPONSE_TYPE.ERROR,
-                error_message=str(e)
-            )
-
 
+        except Exception as e:
+            logger.error(f"Error running while getting table {e} on ")
+            response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
 
         return response
 
-        
-
-
-
-
 
 connection_args = OrderedDict(
     server={
-        'type': ARG_TYPE.STR,
-        'description': '''
+        "type": ARG_TYPE.STR,
+        "description": """
             The server name you want to get connected.
-        '''
+        """,
     },
     database={
-        'type': ARG_TYPE.STR,
-        'description': '''
+        "type": ARG_TYPE.STR,
+        "description": """
             The database name to use when connecting with the DB2 server.
-        '''
+        """,
     },
     user={
-        'type': ARG_TYPE.STR,
-        'description': 'The user name used to authenticate with the DB2 server.'
+        "type": ARG_TYPE.STR,
+        "description": "The user name used to authenticate with the DB2 server.",
     },
     password={
-        'type': ARG_TYPE.STR,
-        'description': 'The password to authenticate the user with the DB2 server.'
+        "type": ARG_TYPE.STR,
+        "description": "The password to authenticate the user with the DB2 server.",
     },
     host={
-        'type': ARG_TYPE.STR,
-        'description': 'The host name or IP address of the DB2 server/database.'
+        "type": ARG_TYPE.STR,
+        "description": "The host name or IP address of the DB2 server/database.",
     },
     port={
-        'type': ARG_TYPE.INT,
-        'description': 'Specify port to connect DB2 through TCP/IP'
+        "type": ARG_TYPE.INT,
+        "description": "Specify port to connect DB2 through TCP/IP",
     },
     schema_name={
-        'type': ARG_TYPE.STR,
-        'description': 'Specify the schema name for showing tables '
+        "type": ARG_TYPE.STR,
+        "description": "Specify the schema name for showing tables ",
     },
     logging_enabled={
-        'type': ARG_TYPE.BOOL,
-        'description': '''
+        "type": ARG_TYPE.BOOL,
+        "description": """
         Used for COMMIT and ROLLBACK as this command works only for logging enabled database.
         Note: Its optional.
         Default is TRUE
-        '''
-    }
-
+        """,
+    },
 )
 
 connection_args_example = OrderedDict(
-    server='server',
-    database='stores_demo',
-    user='informix',
-    password='in4mix',
-    host='127.0.0.1',
-    port='9091',
-    schema_name='Love'
-    
+    server="server",
+    database="stores_demo",
+    user="informix",
+    password="in4mix",
+    host="127.0.0.1",
+    port="9091",
+    schema_name="Love",
 )

mindsdb/integrations/handlers/informix_handler/tests/test_informix_handler.py

@@ -1,5 +1,7 @@
 import unittest
-from mindsdb.integrations.handlers.informix_handler.informix_handler import InformixHandler
+from mindsdb.integrations.handlers.informix_handler.informix_handler import (
+    InformixHandler,
+)
 from mindsdb.api.executor.data_types.response_type import RESPONSE_TYPE
 
 
@@ -15,30 +17,30 @@ class InformixHandlerTest(unittest.TestCase):
                 "password": "in4mix",
                 "database": "demo",
                 "schema_name": "love",
-                "loging_enabled": False
+                "loging_enabled": False,
             }
         }
-        cls.handler = InformixHandler('test_informix_handler', cls.kwargs)
+        cls.handler = InformixHandler("test_informix_handler", cls.kwargs)
 
     def test_0_connect(self):
         self.handler.connect()
 
     def test_1_drop_table(self):
         res = self.handler.query("DROP TABLE IF EXISTS LOVE;")
-        assert res.type is  not RESPONSE_TYPE.ERROR
+        assert res.type is not RESPONSE_TYPE.ERROR
 
     def test_2_create_table(self):
         res = self.handler.query("CREATE TABLE IF NOT EXISTS LOVE (LOVER varchar(20));")
-        assert res.type is not  RESPONSE_TYPE.ERROR 
-    
+        assert res.type is not RESPONSE_TYPE.ERROR
+
     def test_3_insert(self):
         res = self.handler.query("INSERT INTO LOVE VALUES('Hari');")
         assert res.type is not RESPONSE_TYPE.ERROR
-    
+
     def test_4_get_tables(self):
         tables = self.handler.get_tables()
         assert tables.type is RESPONSE_TYPE.TABLE
- 
+
     def test_5_select_query(self):
         query = "SELECT * FROM LOVE;"
         result = self.handler.native_query(query)
@@ -47,6 +49,6 @@ class InformixHandlerTest(unittest.TestCase):
     def test_5_check_connection(self):
         self.handler.check_connection()
 
-        
-if __name__ == '__main__':
-    unittest.main()
+
+if __name__ == "__main__":
+    unittest.main()

mindsdb/integrations/handlers/ingres_handler/__about__.py

@@ -7,4 +7,3 @@ __github__ = 'https://github.com/mindsdb/mindsdb'
 __pypi__ = 'https://pypi.org/project/mindsdb/'
 __license__ = 'MIT'
 __copyright__ = 'Copyright 2023- mindsdb'
-

mindsdb/integrations/handlers/ingres_handler/ingres_handler.py

@@ -17,6 +17,7 @@ from mindsdb.integrations.libs.response import (
 
 logger = log.getLogger(__name__)
 
+
 class IngresHandler(DatabaseHandler):
     """
     This handler handles connection and execution of the Ingres statements.

mindsdb/integrations/handlers/jira_handler/jira_handler.py

@@ -55,14 +55,14 @@ class JiraHandler(APIHandler):
         """
         if self.is_connected is True:
             return self.connection
-        
+
         is_cloud = self.connection_data.get("cloud", True)
 
         if is_cloud:
             # Jira Cloud supports API token authentication.
             if not all(key in self.connection_data for key in ['username', 'api_token', 'url']):
                 raise ValueError("Required parameters (username, api_token, url) must be provided.")
-            
+
             config = {
                 "username": self.connection_data['username'],
                 "password": self.connection_data['api_token'],
@@ -72,7 +72,7 @@ class JiraHandler(APIHandler):
             # Jira Server supports personal access token authentication or open access.
             if 'url' not in self.connection_data:
                 raise ValueError("Required parameter 'url' must be provided.")
-            
+
             config = {
                 "url": self.connection_data['url'],
                 "cloud": False
@@ -147,4 +147,4 @@ class JiraHandler(APIHandler):
                 error_message=str(unknown_error)
             )
 
-        return response
+        return response

mindsdb/integrations/handlers/jira_handler/jira_tables.py

@@ -24,7 +24,7 @@ class JiraProjectsTable(APIResource):
 
         projects = []
         for condition in conditions:
-            if condition.column in ('id', 'key'): 
+            if condition.column in ('id', 'key'):
                 if condition.op == FilterOperator.EQUAL:
                     projects = [client.get_project(condition.value)]
                 elif condition.op == FilterOperator.IN:
@@ -43,7 +43,7 @@ class JiraProjectsTable(APIResource):
             projects_df = pd.DataFrame([], columns=self.get_columns())
 
         return projects_df
-    
+
     def get_columns(self) -> List[str]:
         return [
             "id",
@@ -56,7 +56,7 @@ class JiraProjectsTable(APIResource):
             "entityId",
             "uuid",
         ]
-    
+
 
 class JiraIssuesTable(APIResource):
     def list(
@@ -71,7 +71,7 @@ class JiraIssuesTable(APIResource):
 
         issues = []
         for condition in conditions:
-            if condition.column in ('id', 'key'): 
+            if condition.column in ('id', 'key'):
                 if condition.op == FilterOperator.EQUAL:
                     issues = [client.get_issue(condition.value)]
                 elif condition.op == FilterOperator.IN:
@@ -88,7 +88,7 @@ class JiraIssuesTable(APIResource):
                         issues.extend(client.get_all_project_issues(project_id, limit=limit))
 
                 condition.applied = True
-                
+
         if not issues:
             project_ids = [project['id'] for project in client.get_all_projects()]
             for project_id in project_ids:
@@ -100,7 +100,7 @@ class JiraIssuesTable(APIResource):
             issues_df = pd.DataFrame([], columns=self.get_columns())
 
         return issues_df
-    
+
     def _get_project_issues_with_limit(self, client: Jira, project_id, limit=None, current_issues=None):
         """
         Helper to get issues from a project, respecting the limit.
@@ -147,8 +147,8 @@ class JiraIssuesTable(APIResource):
             "assignee",
             "status",
         ]
-        
-        
+
+
 class JiraGroupsTable(APIResource):
     def list(
         self,
@@ -194,7 +194,7 @@ class JiraUsersTable(APIResource):
 
         users = []
         for condition in conditions:
-            if condition.column == 'accountId': 
+            if condition.column == 'accountId':
                 if condition.op == FilterOperator.EQUAL:
                     users = [client.user(account_id=condition.value)]
                 elif condition.op == FilterOperator.IN:

mindsdb/integrations/handlers/kinetica_handler/__init__.py

@@ -8,7 +8,6 @@ try:
 except Exception as e:
     Handler = None
     import_error = e
-from .__about__ import __version__ as version, __description__ as description
 
 
 title = 'Kinetica'

mindsdb/integrations/handlers/langchain_handler/langchain_handler.py

@@ -108,7 +108,7 @@ AI: {response}'''
         self.model_storage.json_set('args', args)
 
     @staticmethod
-    def create_validation(_, args: Dict=None, **kwargs):
+    def create_validation(_, args: Dict = None, **kwargs):
         if 'using' not in args:
             raise Exception("LangChain engine requires a USING clause! Refer to its documentation for more details.")
         else:
@@ -117,7 +117,7 @@ AI: {response}'''
             if not args.get('mode') == 'retrieval':
                 raise ValueError('Please provide a `prompt_template` for this engine.')
 
-    def predict(self, df: pd.DataFrame, args: Dict=None) -> pd.DataFrame:
+    def predict(self, df: pd.DataFrame, args: Dict = None) -> pd.DataFrame:
         """
         Dispatch is performed depending on the underlying model type. Currently, only the default text completion
         is supported.
@@ -125,7 +125,7 @@ AI: {response}'''
         pred_args = args['predict_params'] if args else {}
         args = self.model_storage.json_get('args')
         if 'prompt_template' not in args and 'prompt_template' not in pred_args:
-            raise ValueError(f"This model expects a `prompt_template`, please provide one.")
+            raise ValueError("This model expects a `prompt_template`, please provide one.")
         # Back compatibility for old models
         args['provider'] = args.get('provider', get_llm_provider(args))
         args['embedding_model_provider'] = args.get('embedding_model', get_embedding_model_provider(args))
@@ -155,7 +155,7 @@ AI: {response}'''
 
         return pd.DataFrame([resp.content], columns=[assistant_column])
 
-    def create_agent(self, df: pd.DataFrame, args: Dict=None, pred_args: Dict=None) -> AgentExecutor:
+    def create_agent(self, df: pd.DataFrame, args: Dict = None, pred_args: Dict = None) -> AgentExecutor:
         pred_args = pred_args if pred_args else {}
 
         # Set up tools.