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

mindsdb/integrations/handlers/monetdb_handler/__about__.py

@@ -1,9 +1,9 @@
-__title__ = 'MindsDB MonetDB handler'
-__package_name__ = 'mindsdb_monetdb_handler'
-__version__ = '0.0.1'
+__title__ = "MindsDB MonetDB handler"
+__package_name__ = "mindsdb_monetdb_handler"
+__version__ = "0.0.1"
 __description__ = "MindsDB handler for MonetDB"
-__author__ = 'Parthiv Makwana'
-__github__ = 'https://github.com/mindsdb/mindsdb'
-__pypi__ = 'https://pypi.org/project/mindsdb/'
-__license__ = 'MIT'
-__copyright__ = 'Copyright 2022- mindsdb'
+__author__ = "Parthiv Makwana"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2022- mindsdb"

mindsdb/integrations/handlers/monetdb_handler/__init__.py

@@ -2,19 +2,29 @@ from mindsdb.integrations.libs.const import HANDLER_TYPE
 
 from .__about__ import __version__ as version, __description__ as description
 from .connection_args import connection_args, connection_args_example
+
 try:
     from .monetdb_handler import MonetDBHandler as Handler
+
     import_error = None
 except Exception as e:
     Handler = None
     import_error = e
 
-title = 'MonetDB'
-name = 'monetdb'
+title = "MonetDB"
+name = "monetdb"
 type = HANDLER_TYPE.DATA
-icon_path = 'icon.svg'
+icon_path = "icon.svg"
 
 __all__ = [
-    'Handler', 'version', 'name', 'type', 'title', 'description',
-    'connection_args', 'connection_args_example', 'import_error', 'icon_path'
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "connection_args",
+    "connection_args_example",
+    "import_error",
+    "icon_path",
 ]

mindsdb/integrations/handlers/monetdb_handler/connection_args.py

@@ -5,40 +5,39 @@ from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_T
 
 connection_args = OrderedDict(
     host={
-        'type': ARG_TYPE.STR,
-        'description': 'The host name or IP address of the MonetDB server/database.'
+        "type": ARG_TYPE.STR,
+        "description": "The host name or IP address of the MonetDB server/database.",
     },
     database={
-        'type': ARG_TYPE.STR,
-        'description': """
+        "type": ARG_TYPE.STR,
+        "description": """
             The database name to use when connecting with the MonetDB server.
-        """
+        """,
     },
     user={
-        'type': ARG_TYPE.STR,
-        'description': 'The user name used to authenticate with the MonetDB server.'
+        "type": ARG_TYPE.STR,
+        "description": "The user name used to authenticate with the MonetDB server.",
     },
     password={
-        'type': ARG_TYPE.PWD,
-        'description': 'The password to authenticate the user with the MonetDB server.',
-        'secret': True
+        "type": ARG_TYPE.PWD,
+        "description": "The password to authenticate the user with the MonetDB server.",
+        "secret": True,
     },
     port={
-        'type': ARG_TYPE.INT,
-        'description': 'Specify port to connect MonetDB through TCP/IP'
+        "type": ARG_TYPE.INT,
+        "description": "Specify port to connect MonetDB through TCP/IP",
     },
     schema_name={
-        'type': ARG_TYPE.STR,
-        'description': 'Specify the schema name for Listing Table '
+        "type": ARG_TYPE.STR,
+        "description": "Specify the schema name for Listing Table ",
     },
-
 )
 
 connection_args_example = OrderedDict(
-    host='127.0.0.1',
+    host="127.0.0.1",
     port=50000,
-    password='monetdb',
-    user='monetdb',
+    password="monetdb",
+    user="monetdb",
     schemaName="sys",
     database="demo",
 )

mindsdb/integrations/handlers/monetdb_handler/monetdb_handler.py

@@ -7,45 +7,45 @@ from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 
 import pandas as pd
 import pymonetdb as mdb
-from .utils.monet_get_id import *
-from sqlalchemy_monetdb.dialect import MonetDialect 
+from .utils.monet_get_id import schema_id, table_id
+from sqlalchemy_monetdb.dialect import MonetDialect
 
 logger = log.getLogger(__name__)
 
 
 class MonetDBHandler(DatabaseHandler):
-    name= 'monetdb'
+    name = "monetdb"
 
     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.database = connection_data['database']
-        self.user = connection_data['user']
-        self.password = connection_data['password']
-        self.schemaName = connection_data['schema_name'] if 'schema_name' in connection_data else None
-        self.host = connection_data['host']
-        self.port = connection_data['port']
-        
+        self.database = connection_data["database"]
+        self.user = connection_data["user"]
+        self.password = connection_data["password"]
+        self.schemaName = (
+            connection_data["schema_name"] if "schema_name" in connection_data else None
+        )
+        self.host = connection_data["host"]
+        self.port = connection_data["port"]
 
         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:
@@ -56,39 +56,35 @@ class MonetDBHandler(DatabaseHandler):
 
         try:
             self.connection = mdb.connect(
-                database=self.database, 
-                hostname=self.host, 
-                port=self.port, 
+                database=self.database,
+                hostname=self.host,
+                port=self.port,
                 username=self.user,
                 password=self.password,
             )
 
-  
-            self.is_connected= True
+            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
+            self.is_connected = False
         except Exception as e:
             logger.error(f"Error while disconnecting to {self.database}, {e}")
 
-        return 
-
+        return
 
     def check_connection(self) -> StatusResponse:
-        """ Check connection to the handler
+        """Check connection to the handler
         Returns:
             HandlerStatusResponse
         """
@@ -99,7 +95,7 @@ class MonetDBHandler(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:
@@ -109,7 +105,6 @@ class MonetDBHandler(DatabaseHandler):
 
         return responseCode
 
-
     def native_query(self, query: str) -> StatusResponse:
         """Receive raw query and act upon it somehow.
         Args:
@@ -120,38 +115,33 @@ class MonetDBHandler(DatabaseHandler):
         """
         need_to_close = self.is_connected is False
         conn = self.connect()
-        cur=conn.cursor() 
+        cur = conn.cursor()
         try:
             cur.execute(query)
-                   
-            if len(cur._rows)>0 :
-                result = cur.fetchall() 
+
+            if len(cur._rows) > 0:
+                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)
             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))
             self.connection.rollback()
 
-        cur.close()    
+        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.
         Args:
@@ -159,25 +149,20 @@ class MonetDBHandler(DatabaseHandler):
                 of query: SELECT, INTSERT, DELETE, etc
         Returns: HandlerResponse
         """
-        
-
 
         renderer = SqlalchemyRender(MonetDialect)
         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()
-        schema = schema_id(connection=self.connection,schema_name=self.schemaName)
-
-
+        schema = schema_id(connection=self.connection, schema_name=self.schemaName)
 
         q = f"""
             SELECT name as TABLE_NAME
@@ -186,13 +171,11 @@ class MonetDBHandler(DatabaseHandler):
             AND type = 0
             AND schema_id = {schema}
         """
- 
 
         return self.query(q)
 
-    
     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:
@@ -203,14 +186,14 @@ class MonetDBHandler(DatabaseHandler):
                 python data types (by default it str).
         """
         self.connect()
-        table=table_id(
+        table = table_id(
             connection=self.connection,
             table_name=table_name,
-            schema_name=self.schemaName
+            schema_name=self.schemaName,
         )
 
         q = f"""
-            SELECT  
+            SELECT
             name as COLUMN_NAME,
             type as DATA_TYPE
             FROM sys.columns

mindsdb/integrations/handlers/monetdb_handler/tests/test_monetdb_handler.py

@@ -14,28 +14,27 @@ class MonetDBHandlerTest(unittest.TestCase):
                 "password": "monetdb",
                 "database": "demo",
             }
-            
         }
-        cls.handler = MonetDBHandler('test_monet_handler', cls.kwargs)
+        cls.handler = MonetDBHandler("test_monet_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 PREM;")
-        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 PREM (Premi varchar(50));")
-        assert res.type is not  RESPONSE_TYPE.ERROR 
+        assert res.type is not RESPONSE_TYPE.ERROR
 
     def test_3_insert_table(self):
         res = self.handler.query("INSERT INTO PREM VALUES('Radha <3 Krishna');")
-        assert res.type is not  RESPONSE_TYPE.ERROR 
+        assert res.type is not RESPONSE_TYPE.ERROR
 
     def test_4_get_tables(self):
         tables = self.handler.get_tables()
-        assert tables.type is not  RESPONSE_TYPE.ERROR
+        assert tables.type is not RESPONSE_TYPE.ERROR
 
     def test_5_select_query(self):
         query = "SELECT * FROM PREM;"
@@ -46,5 +45,5 @@ class MonetDBHandlerTest(unittest.TestCase):
         self.handler.check_connection()
 
 
-if __name__ == '__main__':
-    unittest.main()
+if __name__ == "__main__":
+    unittest.main()

mindsdb/integrations/handlers/monetdb_handler/utils/monet_get_id.py

@@ -1,34 +1,35 @@
-from sqlalchemy import  exc
+from sqlalchemy import exc
+
 
 def schema_id(connection, schema_name=None):
     """Fetch the id for schema"""
-    cur=connection.cursor()
+    cur = connection.cursor()
     if schema_name is None:
         cur.execute("SELECT current_schema")
-        schema_name=cur.fetchall()[0][0]
+        schema_name = cur.fetchall()[0][0]
 
     query = f"""
                 SELECT id
                 FROM sys.schemas
                 WHERE name = '{schema_name}'
             """
-    
+
     cur.execute(query)
 
     try:
         schema_id = cur.fetchall()[0][0]
-    except:
+    except Exception:
         raise exc.InvalidRequestError(schema_name)
-        
+
     return schema_id
 
-    
+
 def table_id(connection, table_name, schema_name=None):
     """Fetch the id for schema.table_name, defaulting to current schema if
-       schema is None
+    schema is None
     """
 
-    schema_idm = schema_id(connection=connection,schema_name=schema_name)
+    schema_idm = schema_id(connection=connection, schema_name=schema_name)
 
     q = f"""
         SELECT id
@@ -36,15 +37,13 @@ def table_id(connection, table_name, schema_name=None):
         WHERE name = '{table_name}'
         AND schema_id = {schema_idm}
         """
-    
+
     cur = connection.cursor()
     cur.execute(q)
 
     try:
-        table_id = cur.fetchall()[0][0] 
-    except:
+        table_id = cur.fetchall()[0][0]
+    except Exception:
         raise exc.NoSuchTableError(table_name)
 
-    
-
     return table_id

mindsdb/integrations/handlers/monkeylearn_handler/__about__.py

@@ -6,4 +6,4 @@ __author__ = 'Pranav Prajapati'
 __github__ = 'https://github.com/mindsdb/mindsdb'
 __pypi__ = 'https://pypi.org/project/mindsdb/'
 __license__ = 'MIT'
-__copyright__ = 'Copyright 2022- mindsdb'
+__copyright__ = 'Copyright 2022- mindsdb'

mindsdb/integrations/handlers/monkeylearn_handler/__init__.py

@@ -16,4 +16,4 @@ permanent = False
 
 __all__ = [
     'Handler', 'version', 'name', 'type', 'title', 'description', 'import_error', 'icon_path'
-]
+]

mindsdb/integrations/handlers/monkeylearn_handler/monkeylearn_handler.py

@@ -2,10 +2,7 @@ from typing import Optional, Dict
 import pandas as pd
 import requests
 
-from monkeylearn import MonkeyLearn
-
 from mindsdb.integrations.libs.base import BaseMLEngine
-
 from mindsdb.integrations.utilities.handler_utils import get_api_key
 
 
@@ -13,7 +10,7 @@ class monkeylearnHandler(BaseMLEngine):
     name = "monkeylearn"
 
     @staticmethod
-    def create_validations(self,args=None,**kwargs):
+    def create_validations(self, args=None, **kwargs):
 
         if "using" in args:
             args = args["using"]
@@ -78,4 +75,4 @@ class monkeylearnHandler(BaseMLEngine):
         # pre-trained monkeylearn models guide about what industries they can be used
         description['industries'] = response.body['industries']
         des_df = pd.DataFrame([description])
-        return des_df
+        return des_df

mindsdb/integrations/handlers/ms_one_drive_handler/ms_graph_api_one_drive_client.py

@@ -14,6 +14,7 @@ class MSGraphAPIOneDriveClient(MSGraphAPIBaseClient):
     This client is used for accessing the Microsoft OneDrive specific endpoints of the Microsoft Graph API.
     Several common methods for submitting requests, fetching data, etc. are inherited from the base class.
     """
+
     def __init__(self, access_token: Text) -> None:
         super().__init__(access_token)
 

mindsdb/integrations/handlers/ms_one_drive_handler/ms_one_drive_handler.py

@@ -9,7 +9,7 @@ from requests.exceptions import RequestException
 
 from mindsdb.integrations.handlers.ms_one_drive_handler.ms_graph_api_one_drive_client import MSGraphAPIOneDriveClient
 from mindsdb.integrations.handlers.ms_one_drive_handler.ms_one_drive_tables import FileTable, ListFilesTable
-from mindsdb.integrations.utilities.handlers.auth_utilities import MSGraphAPIDelegatedPermissionsManager
+from mindsdb.integrations.utilities.handlers.auth_utilities.microsoft import MSGraphAPIDelegatedPermissionsManager
 from mindsdb.integrations.utilities.handlers.auth_utilities.exceptions import AuthException
 from mindsdb.integrations.libs.response import (
     HandlerResponse as Response,