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

mindsdb/integrations/handlers/portkey_handler/__init__.py

@@ -1,10 +1,10 @@
+from .__about__ import __version__ as version
+from .__about__ import __description__ as description
 from mindsdb.integrations.libs.const import HANDLER_TYPE
 from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
 
-from .__about__ import __description__ as description
-from .__about__ import __version__ as version
 
 try:
     from .portkey_handler import PortkeyHandler as Handler

mindsdb/integrations/handlers/postgres_handler/postgres_handler.py

@@ -1,12 +1,13 @@
 import time
 import json
-from typing import Optional
+from typing import Optional, Any
 
 import pandas as pd
+from pandas import DataFrame
 import psycopg
-from psycopg.postgres import types
+from psycopg import Column as PGColumn, Cursor
+from psycopg.postgres import TypeInfo, types as pg_types
 from psycopg.pq import ExecStatus
-from pandas import DataFrame
 
 from mindsdb_sql_parser import parse_sql
 from mindsdb.utilities.render.sqlalchemy_render import SqlalchemyRender
@@ -27,7 +28,7 @@ logger = log.getLogger(__name__)
 SUBSCRIBE_SLEEP_INTERVAL = 1
 
 
-def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
+def _map_type(internal_type_name: str | None) -> MYSQL_DATA_TYPE:
     """Map Postgres types to MySQL types.
 
     Args:
@@ -36,14 +37,22 @@ def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
     Returns:
         MYSQL_DATA_TYPE: The MySQL type that corresponds to the Postgres type.
     """
+    fallback_type = MYSQL_DATA_TYPE.VARCHAR
+
+    if internal_type_name is None:
+        return fallback_type
+
     internal_type_name = internal_type_name.lower()
     types_map = {
-        ('smallint', 'integer', 'bigint', 'int', 'smallserial', 'serial', 'bigserial'): MYSQL_DATA_TYPE.INT,
-        ('real', 'money', 'float'): MYSQL_DATA_TYPE.FLOAT,
+        ('smallint', 'smallserial'): MYSQL_DATA_TYPE.SMALLINT,
+        ('integer', 'int', 'serial'): MYSQL_DATA_TYPE.INT,
+        ('bigint', 'bigserial'): MYSQL_DATA_TYPE.BIGINT,
+        ('real', 'float'): MYSQL_DATA_TYPE.FLOAT,
         ('numeric', 'decimal'): MYSQL_DATA_TYPE.DECIMAL,
         ('double precision',): MYSQL_DATA_TYPE.DOUBLE,
         ('character varying', 'varchar'): MYSQL_DATA_TYPE.VARCHAR,
-        ('character', 'char', 'bpchar', 'bpchar', 'text'): MYSQL_DATA_TYPE.TEXT,
+        # NOTE: if return chars-types as mysql's CHAR, then response will be padded with spaces, so return as TEXT
+        ('money', 'character', 'char', 'bpchar', 'bpchar', 'text'): MYSQL_DATA_TYPE.TEXT,
         ('timestamp', 'timestamp without time zone', 'timestamp with time zone'): MYSQL_DATA_TYPE.DATETIME,
         ('date', ): MYSQL_DATA_TYPE.DATE,
         ('time', 'time without time zone', 'time with time zone'): MYSQL_DATA_TYPE.TIME,
@@ -55,8 +64,51 @@ def _map_type(internal_type_name: str) -> MYSQL_DATA_TYPE:
         if internal_type_name in db_types_list:
             return mysql_data_type
 
-    logger.warning(f"Postgres handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
-    return MYSQL_DATA_TYPE.VARCHAR
+    logger.debug(f"Postgres handler type mapping: unknown type: {internal_type_name}, use VARCHAR as fallback.")
+    return fallback_type
+
+
+def _make_table_response(result: list[tuple[Any]], cursor: Cursor) -> Response:
+    """Build response from result and cursor.
+
+    Args:
+        result (list[tuple[Any]]): result of the query.
+        cursor (psycopg.Cursor): cursor object.
+
+    Returns:
+        Response: response object.
+    """
+    description: list[PGColumn] = cursor.description
+    mysql_types: list[MYSQL_DATA_TYPE] = []
+    for column in description:
+        pg_type_info: TypeInfo = pg_types.get(column.type_code)
+        if pg_type_info is None:
+            logger.warning(f'Postgres handler: unknown type: {column.type_code}')
+        regtype: str = pg_type_info.regtype if pg_type_info is not None else None
+        mysql_type = _map_type(regtype)
+        mysql_types.append(mysql_type)
+
+    # region cast int and bool to nullable types
+    serieses = []
+    for i, mysql_type in enumerate(mysql_types):
+        expected_dtype = None
+        if mysql_type in (
+            MYSQL_DATA_TYPE.SMALLINT, MYSQL_DATA_TYPE.INT, MYSQL_DATA_TYPE.MEDIUMINT,
+            MYSQL_DATA_TYPE.BIGINT, MYSQL_DATA_TYPE.TINYINT
+        ):
+            expected_dtype = 'Int64'
+        elif mysql_type in (MYSQL_DATA_TYPE.BOOL, MYSQL_DATA_TYPE.BOOLEAN):
+            expected_dtype = 'boolean'
+        serieses.append(pd.Series([row[i] for row in result], dtype=expected_dtype, name=description[i].name))
+    df = pd.concat(serieses, axis=1, copy=False)
+    # endregion
+
+    return Response(
+        RESPONSE_TYPE.TABLE,
+        data_frame=df,
+        affected_rows=cursor.rowcount,
+        mysql_types=mysql_types
+    )
 
 
 class PostgresHandler(DatabaseHandler):
@@ -199,13 +251,13 @@ class PostgresHandler(DatabaseHandler):
         for column_index, column_name in enumerate(df.columns):
             col = df[column_name]
             if str(col.dtype) == 'object':
-                pg_type = types.get(description[column_index].type_code)
-                if pg_type is not None and pg_type.name in types_map:
-                    col = col.fillna(0)
+                pg_type_info: TypeInfo = pg_types.get(description[column_index].type_code)        # type_code is int!?
+                if pg_type_info is not None and pg_type_info.name in types_map:
+                    col = col.fillna(0)   # TODO rework
                     try:
-                        df[column_name] = col.astype(types_map[pg_type.name])
+                        df[column_name] = col.astype(types_map[pg_type_info.name])
                     except ValueError as e:
-                        logger.error(f'Error casting column {col.name} to {types_map[pg_type.name]}: {e}')
+                        logger.error(f'Error casting column {col.name} to {types_map[pg_type_info.name]}: {e}')
         df.columns = columns
 
     @profiler.profile()
@@ -232,16 +284,7 @@ class PostgresHandler(DatabaseHandler):
                     response = Response(RESPONSE_TYPE.OK, affected_rows=cur.rowcount)
                 else:
                     result = cur.fetchall()
-                    df = DataFrame(
-                        result,
-                        columns=[x.name for x in cur.description]
-                    )
-                    self._cast_dtypes(df, cur.description)
-                    response = Response(
-                        RESPONSE_TYPE.TABLE,
-                        data_frame=df,
-                        affected_rows=cur.rowcount
-                    )
+                    response = _make_table_response(result, cur)
                 connection.commit()
             except Exception as e:
                 logger.error(f'Error running query: {query} on {self.database}, {e}!')
@@ -257,6 +300,44 @@ class PostgresHandler(DatabaseHandler):
 
         return response
 
+    def query_stream(self, query: ASTNode, fetch_size: int = 1000):
+        """
+        Executes a SQL query and stream results outside by batches
+
+        :param query: An ASTNode representing the SQL query to be executed.
+        :param fetch_size: size of the batch
+        :return: generator with query results
+        """
+        query_str, params = self.renderer.get_exec_params(query, with_failback=True)
+
+        need_to_close = not self.is_connected
+
+        connection = self.connect()
+        with connection.cursor() as cur:
+            try:
+                if params is not None:
+                    cur.executemany(query_str, params)
+                else:
+                    cur.execute(query_str)
+
+                if cur.pgresult is not None and ExecStatus(cur.pgresult.status) != ExecStatus.COMMAND_OK:
+                    while True:
+                        result = cur.fetchmany(fetch_size)
+                        if not result:
+                            break
+                        df = DataFrame(
+                            result,
+                            columns=[x.name for x in cur.description]
+                        )
+                        self._cast_dtypes(df, cur.description)
+                        yield df
+                connection.commit()
+            finally:
+                connection.rollback()
+
+        if need_to_close:
+            self.disconnect()
+
     def insert(self, table_name: str, df: pd.DataFrame) -> Response:
         need_to_close = not self.is_connected
 

mindsdb/integrations/handlers/postgres_handler/tests/test_postgres_handler.py

@@ -1,7 +1,6 @@
 import pytest
 import psycopg2
 import os
-import time
 
 from mindsdb.integrations.handlers.postgres_handler.postgres_handler import (
     PostgresHandler,
@@ -14,7 +13,9 @@ HANDLER_KWARGS = {
         "port": os.environ.get("MDB_TEST_POSTGRES_PORT", "5432"),
         "user": os.environ.get("MDB_TEST_POSTGRES_USER", "postgres"),
         "password": os.environ.get("MDB_TEST_POSTGRES_PASSWORD", "supersecret"),
-        "database": os.environ.get("MDB_TEST_POSTGRES_DATABASE", "postgres_db_handler_test"),
+        "database": os.environ.get(
+            "MDB_TEST_POSTGRES_DATABASE", "postgres_db_handler_test"
+        ),
     }
 }
 
@@ -24,6 +25,7 @@ expected_columns = ["col_one", "col_two", "col_three", "col_four"]
 
 curr_dir = os.path.dirname(os.path.realpath(__file__))
 
+
 def seed_db():
     """Seed the test DB with some data"""
 
@@ -36,7 +38,7 @@ def seed_db():
     try:
         cursor.execute("DROP DATABASE IF EXISTS postgres_db_handler_test;")
         db.commit()
-        
+
         # Create the test database
         cursor.execute("CREATE DATABASE postgres_db_handler_test;")
 
@@ -56,12 +58,14 @@ def seed_db():
         cursor.close()
         db.close()
 
+
 @pytest.fixture(scope="module")
 def handler(request):
     seed_db()
     handler = PostgresHandler(**HANDLER_KWARGS)
     yield handler
 
+
 def check_valid_response(res):
     if res.resp_type == RESPONSE_TYPE.TABLE:
         assert res.data_frame is not None, "expected to have some data, but got None"
@@ -72,6 +76,7 @@ def check_valid_response(res):
         res.error_message is None
     ), f"expected to have None in error message, but got {res.error_message}"
 
+
 def get_table_names(handler):
     res = handler.get_tables()
     tables = res.data_frame
@@ -157,15 +162,15 @@ class TestPostgresColumns:
         describe_data = described.data_frame
         check_valid_response(described)
         got_columns = list(describe_data.iloc[:, 0])
-        assert (
-            set(got_columns) == set(expected_columns)
+        assert set(got_columns) == set(
+            expected_columns
         ), f"expected to have next columns in test table:\n{expected_columns}\nbut got:\n{got_columns}"
 
 
 class TestPostgresDisconnect:
     def test_disconnect(self, handler):
         handler.disconnect()
-        assert handler.is_connected == False, "failed to disconnect"
+        assert handler.is_connected is False, "failed to disconnect"
 
     def test_check_connection(self, handler):
         res = handler.check_connection()

mindsdb/integrations/handlers/questdb_handler/questdb_handler.py

@@ -5,7 +5,6 @@ from questdb.ingress import Sender
 
 from mindsdb.integrations.handlers.postgres_handler import Handler as PostgresHandler
 from mindsdb.integrations.libs.response import (
-    HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
     RESPONSE_TYPE
 )
@@ -17,7 +16,7 @@ logger = log.getLogger(__name__)
 
 class QuestDBHandler(PostgresHandler):
     """
-    This handler handles connection and execution of the QuestDB statements. 
+    This handler handles connection and execution of the QuestDB statements.
     TODO: check the dialect for questdb
     """
     name = 'questdb'

mindsdb/integrations/handlers/questdb_handler/tests/test_questdb_handler.py

@@ -19,11 +19,11 @@ class QuestDBHandlerTest(unittest.TestCase):
 
     def test_0_check_connection(self):
         assert self.handler.check_connection()
-    
+
     def test_1_describe_table(self):
         described = self.handler.describe_table("house_rentals_data")
         assert described['type'] is not RESPONSE_TYPE.ERROR
-    
+
     def test_2_get_tables(self):
         tables = self.handler.get_tables()
         assert tables['type'] is not RESPONSE_TYPE.ERROR
@@ -32,4 +32,3 @@ class QuestDBHandlerTest(unittest.TestCase):
         query = "SELECT * FROM house_rentals_data WHERE 'id'='1'"
         result = self.handler.query(query)
         assert len(result) > 0
-

mindsdb/integrations/handlers/quickbooks_handler/quickbooks_handler.py

@@ -1,11 +1,8 @@
 import os
-import pandas as pd
 from qbosdk import QuickbooksOnlineSDK
 from mindsdb.integrations.libs.api_handler import APIHandler
 from mindsdb.integrations.libs.response import (
-    HandlerStatusResponse as StatusResponse,
-    HandlerResponse as Response,
-    RESPONSE_TYPE
+    HandlerStatusResponse as StatusResponse
 )
 from mindsdb.utilities.config import Config
 from mindsdb.utilities import log
@@ -14,11 +11,12 @@ from .quickbooks_table import AccountsTable, PurchasesTable, BillPaymentsTable,
 
 logger = log.getLogger(__name__)
 
+
 class QuickbooksHandler(APIHandler):
     """
         A class for handling connections and interactions with Quickbooks API.
     """
-    
+
     def __init__(self, name=None, **kwargs):
         super().__init__(name)
 
@@ -26,7 +24,7 @@ class QuickbooksHandler(APIHandler):
 
         self.connection_args = {}
         handler_config = Config().get('quickbooks_handler', {})
-        for k in ['client_id', 'client_secret', 'refresh_token', 'realm_id',  'environment']:
+        for k in ['client_id', 'client_secret', 'refresh_token', 'realm_id', 'environment']:
             if k in args:
                 self.connection_args[k] = args[k]
             elif f'QUICKBOOKS_{k.upper()}' in os.environ:
@@ -39,7 +37,7 @@ class QuickbooksHandler(APIHandler):
 
         accountso = AccountsTable(self)
         self._register_table('accountso', accountso)
-        purchases= PurchasesTable(self)
+        purchases = PurchasesTable(self)
         self._register_table('purchases', purchases)
         bills_payments = BillPaymentsTable(self)
         self._register_table('bills_payments', bills_payments)
@@ -47,7 +45,7 @@ class QuickbooksHandler(APIHandler):
         self._register_table('vendors', vendors)
         bills = BillsTable(self)
         self._register_table('bills', bills)
-        employees= EmployeesTable(self)
+        employees = EmployeesTable(self)
         self._register_table('employees', employees)
 
     def connect(self):

mindsdb/integrations/handlers/quickbooks_handler/quickbooks_table.py

@@ -1,7 +1,6 @@
 import pandas as pd
 from mindsdb.integrations.libs.api_handler import APITable
 from mindsdb_sql_parser import ast
-from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
 
 
 class AccountsTable(APITable):
@@ -77,8 +76,6 @@ class PurchasesTable(APITable):
                 flat_data[f"{prefix}{key}"] = value
         return flat_data
 
-
-
     def select(self, query: ast.Select) -> pd.DataFrame:
         qbo = self.handler.connect()
         purchases_data = qbo.purchases.get()
@@ -124,6 +121,7 @@ class PurchasesTable(APITable):
         if len(columns) > 0:
             result = result[columns]
 
+
 class BillPaymentsTable(APITable):
     def flatten_dict(self, data: dict, prefix: str = ""):
         flat_data = {}
@@ -174,7 +172,7 @@ class BillPaymentsTable(APITable):
             'domain',
             'sparse',
         ]
-        
+
     def filter_columns(self, result: pd.DataFrame, query: ast.Select = None):
         columns = []
         if query is not None:
@@ -187,8 +185,9 @@ class BillPaymentsTable(APITable):
         if len(columns) > 0:
             result = result[columns]
 
+
 class VendorsTable(APITable):
-    
+
     def flatten_dict(self, data: dict, prefix: str = ""):
         flat_data = {}
         for key, value in data.items():
@@ -198,7 +197,7 @@ class VendorsTable(APITable):
             else:
                 flat_data[f"{prefix}{key}"] = value
         return flat_data
-    
+
     def select(self, query: ast.Select) -> pd.DataFrame:
         qbo = self.handler.connect()
         vendors_data = qbo.vendors.get()
@@ -206,7 +205,7 @@ class VendorsTable(APITable):
         result = pd.DataFrame(flattened_vendors_data)
         self.filter_columns(result, query)
         return result
-    
+
     def get_columns(self):
         return [
             'Balance',
@@ -223,7 +222,7 @@ class VendorsTable(APITable):
             'domain',
             'sparse'
         ]
-    
+
     def filter_columns(self, result: pd.DataFrame, query: ast.Select = None):
         columns = []
         if query is not None:
@@ -316,8 +315,9 @@ class BillsTable(APITable):
         if len(columns) > 0:
             result = result[columns]
 
+
 class EmployeesTable(APITable):
-    
+
     def flatten_dict(self, data: dict, prefix: str = ""):
         flat_data = {}
         for key, value in data.items():
@@ -371,4 +371,4 @@ class EmployeesTable(APITable):
                 elif isinstance(target, ast.Identifier):
                     columns.append(target.value)
         if len(columns) > 0:
-            result = result[columns]
+            result = result[columns]

mindsdb/integrations/handlers/rag_handler/ingest.py

@@ -64,7 +64,7 @@ class RAGIngestor:
 
     def split_documents(self, chunk_size, chunk_overlap) -> list:
         # Load documents and split in chunks
-        logger.info(f"Loading documents from input data")
+        logger.info("Loading documents from input data")
 
         documents = []
 
@@ -146,7 +146,7 @@ class RAGIngestor:
             self.embeddings_model_name, self.args.use_gpu
         )
 
-        logger.info(f"Creating vectorstore from documents")
+        logger.info("Creating vectorstore from documents")
 
         if not validate_documents(documents):
             raise ValueError("Invalid documents")

mindsdb/integrations/handlers/rag_handler/rag_handler.py

@@ -61,7 +61,7 @@ class RAGHandler(BaseMLEngine):
         ml_engine_args = self.engine_storage.get_connection_args()
 
         # for a model created with USING, only get api for that specific llm type
-        args.update({k:v for k, v in ml_engine_args.items() if args["llm_type"] in k})
+        args.update({k: v for k, v in ml_engine_args.items() if args["llm_type"] in k})
 
         input_args = build_llm_params(args)
 

mindsdb/integrations/handlers/rag_handler/settings.py

@@ -34,7 +34,7 @@ SUPPORTED_VECTOR_STORES = ("chromadb", "faiss")
 
 SUPPORTED_LLMS = ("writer", "openai")
 
-## Default parameters for RAG Handler
+# Default parameters for RAG Handler
 
 # this is the default prompt template for qa
 DEFAULT_QA_PROMPT_TEMPLATE = """

mindsdb/integrations/handlers/reddit_handler/reddit_handler.py

@@ -1,6 +1,5 @@
 import praw
-import pandas as pd
-from datetime import datetime
+import os
 from mindsdb.integrations.libs.api_handler import APIHandler
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
@@ -14,8 +13,8 @@ from .reddit_tables import CommentTable, SubmissionTable
 
 logger = log.getLogger(__name__)
 
-class RedditHandler(APIHandler):
 
+class RedditHandler(APIHandler):
 
     def __init__(self, name=None, **kwargs):
         super().__init__(name)
@@ -57,7 +56,6 @@ class RedditHandler(APIHandler):
         self.is_connected = True
         return self.reddit
 
-
     def check_connection(self) -> StatusResponse:
         '''It evaluates if the connection with Reddit API is alive and healthy.
         Returns:
@@ -101,6 +99,3 @@ class RedditHandler(APIHandler):
             RESPONSE_TYPE.TABLE,
             data_frame=df
         )
-
-
-

mindsdb/integrations/handlers/reddit_handler/reddit_tables.py

@@ -49,7 +49,6 @@ class CommentTable(APITable):
         self.filter_columns(result, query)
         return result
 
-
     def get_columns(self):
         '''Get the list of column names for the comment table.
 
@@ -80,6 +79,7 @@ class CommentTable(APITable):
         if len(columns) > 0:
             result = result[columns]
 
+
 class SubmissionTable(APITable):
     def select(self, query: ast.Select) -> pd.DataFrame:
         '''Select data from the submission table and return it as a pandas DataFrame.
@@ -143,7 +143,6 @@ class SubmissionTable(APITable):
         self.filter_columns(result, query)
         return result
 
-
     def get_columns(self):
         '''Get the list of column names for the submission table.
 
@@ -188,7 +187,7 @@ class SubmissionTable(APITable):
                 result[col] = None
 
             result = result[columns]
-        
+
         if query is not None and query.limit is not None:
             return result.head(query.limit.value)
 

mindsdb/integrations/handlers/replicate_handler/replicate_handler.py

@@ -33,7 +33,7 @@ class ReplicateHandler(BaseMLEngine):
                 raise Exception("Provided api_key is Incorrect. Get your api_key here: https://replicate.com/account/api-tokens")
 
             else:
-                raise Exception(f"Error occured.", e)
+                raise Exception("Error occured.", e)
 
     def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
         """Saves model details in storage to access it later
@@ -44,11 +44,11 @@ class ReplicateHandler(BaseMLEngine):
 
     def predict(self, df: pd.DataFrame, args: Optional[Dict] = None) -> pd.DataFrame:
         """Using replicate makes the prediction according to your parameters
-        
+
         Args:
             df (pd.DataFrame): The input DataFrame containing data to predict.
             args (Optional[Dict]): Additional arguments for prediction parameters.
-        
+
         Returns:
             pd.DataFrame: The DataFrame containing the predicted results.
         """
@@ -67,7 +67,7 @@ class ReplicateHandler(BaseMLEngine):
             output = replicate.run(
                 f"{args['model_name']}:{args['version']}",
                 input={**conditions.to_dict(), **pred_args}         # Unpacking parameters inputted
-            ) 
+            )
             # Process output based on the model type
             if isinstance(output, types.GeneratorType) and args.get('model_type') == 'LLM':
                 output = ''.join(list(output))  # If model_type is LLM, make the stream a string
@@ -87,7 +87,7 @@ class ReplicateHandler(BaseMLEngine):
 
         if wrong_params:
             raise Exception(f"""'{wrong_params}' is/are not supported parameter for this model.
-Use DESCRIBE PREDICTOR mindsdb.<model_name>.features; to know about available parameters. OR 
+Use DESCRIBE PREDICTOR mindsdb.<model_name>.features; to know about available parameters. OR
 Visit https://replicate.com/{model_name}/versions/{version} to check parameters.""")
 
         # Set the Replicate API token for communication with the server
@@ -134,7 +134,7 @@ Visit https://replicate.com/{model_name}/versions/{version} to check parameters.
             return replicate_cfg['api_key']
 
         if strict:
-            raise Exception(f'Missing API key "api_key". Either re-create this ML_ENGINE specifying the `api_key` parameter,\
+            raise Exception('Missing API key "api_key". Either re-create this ML_ENGINE specifying the `api_key` parameter,\
                  or re-create this model and pass the API key with `USING` syntax.')
 
     def _get_schema(self, only_keys=False):

mindsdb/integrations/handlers/rocket_chat_handler/rocket_chat_handler.py

@@ -1,5 +1,4 @@
 import pandas as pd
-from typing import Dict, List
 
 from rocketchat_API.rocketchat import RocketChat
 
@@ -15,6 +14,7 @@ from mindsdb_sql_parser import parse_sql
 
 logger = log.getLogger(__name__)
 
+
 class RocketChatHandler(APIChatHandler):
     """A class for handling connections and interactions with the Rocket Chat API.
 
@@ -132,7 +132,6 @@ class RocketChatHandler(APIChatHandler):
         ast = parse_sql(query)
         return self.query(ast)
 
-
     def call_api(self, method_name: str = None, *args, **kwargs) -> pd.DataFrame:
         """Calls the Rocket Chat API method with the given params.
 

mindsdb/integrations/handlers/rocket_chat_handler/rocket_chat_tables.py

@@ -1,5 +1,3 @@
-from typing import List
-
 import pandas as pd
 
 from mindsdb.integrations.libs.api_handler import APITable
@@ -198,4 +196,3 @@ class UsersTable(APITable):
             'active',
             'type',
         ]
-