MindsDB 25.9.3rc1__py3-none-any.whl → 25.10.0__py3-none-any.whl

mindsdb/integrations/handlers/zendesk_handler/zendesk_tables.py

@@ -34,41 +34,31 @@ class ZendeskUsersTable(APITable):
             If the query contains an unsupported condition
         """
 
-        select_statement_parser = SELECTQueryParser(
-            query,
-            'users',
-            self.get_columns()
-        )
+        select_statement_parser = SELECTQueryParser(query, "users", self.get_columns())
 
-        selected_columns, where_conditions, order_by_conditions, result_limit = (
-            select_statement_parser.parse_query()
-        )
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
 
-        subset_where_conditions = {}
+        subset_where_conditions = []
+        api_filters = {}
         for op, arg1, arg2 in where_conditions:
             if arg1 in self.get_columns():
-                if op != '=':
+                if op != "=":
                     raise NotImplementedError(f"Unknown op: {op}. Only '=' is supported.")
-                subset_where_conditions[arg1] = arg2
+                api_filters[arg1] = arg2
+                subset_where_conditions.append([op, arg1, arg2])
 
-        count = 0
-        result = self.handler.zen_client.users(**subset_where_conditions)
+        result = self.handler.zen_client.users(**api_filters)
         response = []
         if isinstance(result, zenpy.lib.generator.BaseResultGenerator):
-            while count <= result_limit:
-                response.append(result.next().to_dict())
-                count += 1
+            for user in result:
+                response.append(user.to_dict())
         else:
             response.append(result.to_dict())
 
         df = pd.DataFrame(response, columns=self.get_columns())
 
         select_statement_executor = SELECTQueryExecutor(
-            df,
-            selected_columns,
-            subset_where_conditions,
-            order_by_conditions,
-            result_limit
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
         )
 
         df = select_statement_executor.execute_query()
@@ -85,15 +75,43 @@ class ZendeskUsersTable(APITable):
         """
 
         return [
-            "active", "alias", "chat_only", "created_at", "custom_role_id",
-            "details", "email", "external_id", "id", "last_login_at",
-            "locale", "locale_id", "moderator", "name", "notes",
-            "only_private_comments", "organization_id", "phone", "photo",
-            "restricted_agent", "role", "shared", "shared_agent",
-            "signature", "suspended", "tags", "ticket_restriction",
-            "time_zone", "two_factor_auth_enabled", "updated_at", "url",
-            "verified", "iana_time_zone", "shared_phone_number", "role_type",
-            "default_group_id", "report_csv"
+            "active",
+            "alias",
+            "chat_only",
+            "created_at",
+            "custom_role_id",
+            "details",
+            "email",
+            "external_id",
+            "id",
+            "last_login_at",
+            "locale",
+            "locale_id",
+            "moderator",
+            "name",
+            "notes",
+            "only_private_comments",
+            "organization_id",
+            "phone",
+            "photo",
+            "restricted_agent",
+            "role",
+            "shared",
+            "shared_agent",
+            "signature",
+            "suspended",
+            "tags",
+            "ticket_restriction",
+            "time_zone",
+            "two_factor_auth_enabled",
+            "updated_at",
+            "url",
+            "verified",
+            "iana_time_zone",
+            "shared_phone_number",
+            "role_type",
+            "default_group_id",
+            "report_csv",
         ]
 
 
@@ -119,41 +137,31 @@ class ZendeskTicketsTable(APITable):
             If the query contains an unsupported condition
         """
 
-        select_statement_parser = SELECTQueryParser(
-            query,
-            'tickets',
-            self.get_columns()
-        )
+        select_statement_parser = SELECTQueryParser(query, "tickets", self.get_columns())
 
-        selected_columns, where_conditions, order_by_conditions, result_limit = (
-            select_statement_parser.parse_query()
-        )
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
 
-        subset_where_conditions = {}
+        subset_where_conditions = []
+        api_filters = {}
         for op, arg1, arg2 in where_conditions:
             if arg1 in self.get_columns():
-                if op != '=':
+                if op != "=":
                     raise NotImplementedError(f"Unknown op: {op}. Only '=' is supported.")
-                subset_where_conditions[arg1] = arg2
+                api_filters[arg1] = arg2
+                subset_where_conditions.append([op, arg1, arg2])
 
-        count = 0
-        result = self.handler.zen_client.tickets(**subset_where_conditions)
+        result = self.handler.zen_client.tickets(**api_filters)
         response = []
         if isinstance(result, zenpy.lib.generator.BaseResultGenerator):
-            while count <= result_limit:
-                response.append(result.next().to_dict())
-                count += 1
+            for ticket in result:
+                response.append(ticket.to_dict())
         else:
             response.append(result.to_dict())
 
         df = pd.DataFrame(response, columns=self.get_columns())
 
         select_statement_executor = SELECTQueryExecutor(
-            df,
-            selected_columns,
-            subset_where_conditions,
-            order_by_conditions,
-            result_limit
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
         )
 
         df = select_statement_executor.execute_query()
@@ -170,20 +178,54 @@ class ZendeskTicketsTable(APITable):
         """
 
         return [
-            "assignee_id", "brand_id", "collaborator_ids", "created_at",
-            "custom_fields", "description", "due_at", "external_id",
-            "fields", "forum_topic_id", "group_id", "has_incidents", "id",
-            "organization_id", "priority", "problem_id", "raw_subject",
-            "recipient", "requester_id", "sharing_agreement_ids", "status",
-            "subject", "submitter_id", "tags", "type", "updated_at", "url",
-            "generated_timestamp", "follower_ids", "email_cc_ids", "is_public",
-            "custom_status_id", "followup_ids", "ticket_form_id",
-            "allow_channelback", "allow_attachments", "from_messaging_channel",
-            "satisfaction_rating.assignee_id", "satisfaction_rating.created_at",
-            "satisfaction_rating.group_id", "satisfaction_rating.id",
-            "satisfaction_rating.requester_id", "satisfaction_rating.score",
-            "satisfaction_rating.ticket_id", "satisfaction_rating.updated_at",
-            "satisfaction_rating.url", "via.channel", "via.source.rel"
+            "assignee_id",
+            "brand_id",
+            "collaborator_ids",
+            "created_at",
+            "custom_fields",
+            "description",
+            "due_at",
+            "external_id",
+            "fields",
+            "forum_topic_id",
+            "group_id",
+            "has_incidents",
+            "id",
+            "organization_id",
+            "priority",
+            "problem_id",
+            "raw_subject",
+            "recipient",
+            "requester_id",
+            "sharing_agreement_ids",
+            "status",
+            "subject",
+            "submitter_id",
+            "tags",
+            "type",
+            "updated_at",
+            "url",
+            "generated_timestamp",
+            "follower_ids",
+            "email_cc_ids",
+            "is_public",
+            "custom_status_id",
+            "followup_ids",
+            "ticket_form_id",
+            "allow_channelback",
+            "allow_attachments",
+            "from_messaging_channel",
+            "satisfaction_rating.assignee_id",
+            "satisfaction_rating.created_at",
+            "satisfaction_rating.group_id",
+            "satisfaction_rating.id",
+            "satisfaction_rating.requester_id",
+            "satisfaction_rating.score",
+            "satisfaction_rating.ticket_id",
+            "satisfaction_rating.updated_at",
+            "satisfaction_rating.url",
+            "via.channel",
+            "via.source.rel",
         ]
 
 
@@ -209,41 +251,31 @@ class ZendeskTriggersTable(APITable):
             If the query contains an unsupported condition
         """
 
-        select_statement_parser = SELECTQueryParser(
-            query,
-            'triggers',
-            self.get_columns()
-        )
+        select_statement_parser = SELECTQueryParser(query, "triggers", self.get_columns())
 
-        selected_columns, where_conditions, order_by_conditions, result_limit = (
-            select_statement_parser.parse_query()
-        )
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
 
-        subset_where_conditions = {}
+        subset_where_conditions = []
+        api_filters = {}
         for op, arg1, arg2 in where_conditions:
             if arg1 in self.get_columns():
-                if op != '=':
+                if op != "=":
                     raise NotImplementedError(f"Unknown op: {op}. Only '=' is supported.")
-                subset_where_conditions[arg1] = arg2
+                api_filters[arg1] = arg2
+                subset_where_conditions.append([op, arg1, arg2])
 
-        count = 0
-        result = self.handler.zen_client.triggers(**subset_where_conditions)
+        result = self.handler.zen_client.triggers(**api_filters)
         response = []
         if isinstance(result, zenpy.lib.generator.BaseResultGenerator):
-            while count <= result_limit:
-                response.append(result.next().to_dict())
-                count += 1
+            for trigger in result:
+                response.append(trigger.to_dict())
         else:
             response.append(result.to_dict())
 
         df = pd.DataFrame(response, columns=self.get_columns())
 
         select_statement_executor = SELECTQueryExecutor(
-            df,
-            selected_columns,
-            subset_where_conditions,
-            order_by_conditions,
-            result_limit
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
         )
 
         df = select_statement_executor.execute_query()
@@ -260,9 +292,20 @@ class ZendeskTriggersTable(APITable):
         """
 
         return [
-            "actions", "active", "description", "id", "position", "title",
-            "url", "updated_at", "created_at", "default", "raw_title",
-            "category_id", "conditions.all", "conditions.any"
+            "actions",
+            "active",
+            "description",
+            "id",
+            "position",
+            "title",
+            "url",
+            "updated_at",
+            "created_at",
+            "default",
+            "raw_title",
+            "category_id",
+            "conditions.all",
+            "conditions.any",
         ]
 
 
@@ -288,41 +331,31 @@ class ZendeskActivitiesTable(APITable):
             If the query contains an unsupported condition
         """
 
-        select_statement_parser = SELECTQueryParser(
-            query,
-            'activities',
-            self.get_columns()
-        )
+        select_statement_parser = SELECTQueryParser(query, "activities", self.get_columns())
 
-        selected_columns, where_conditions, order_by_conditions, result_limit = (
-            select_statement_parser.parse_query()
-        )
+        selected_columns, where_conditions, order_by_conditions, result_limit = select_statement_parser.parse_query()
 
-        subset_where_conditions = {}
+        subset_where_conditions = []
+        api_filters = {}
         for op, arg1, arg2 in where_conditions:
             if arg1 in self.get_columns():
-                if op != '=':
+                if op != "=":
                     raise NotImplementedError(f"Unknown op: {op}. Only '=' is supported.")
-                subset_where_conditions[arg1] = arg2
+                api_filters[arg1] = arg2
+                subset_where_conditions.append([op, arg1, arg2])
 
-        count = 0
-        result = self.handler.zen_client.activities(**subset_where_conditions)
+        result = self.handler.zen_client.activities(**api_filters)
         response = []
         if isinstance(result, zenpy.lib.generator.BaseResultGenerator):
-            while count <= result_limit:
-                response.append(result.next().to_dict())
-                count += 1
+            for activity in result:
+                response.append(activity.to_dict())
         else:
             response.append(result.to_dict())
 
         df = pd.DataFrame(response, columns=self.get_columns())
 
         select_statement_executor = SELECTQueryExecutor(
-            df,
-            selected_columns,
-            subset_where_conditions,
-            order_by_conditions,
-            result_limit
+            df, selected_columns, subset_where_conditions, order_by_conditions, result_limit
         )
 
         df = select_statement_executor.execute_query()
@@ -459,5 +492,5 @@ class ZendeskActivitiesTable(APITable):
             "target.ticket.type",
             "target.ticket.updated_at",
             "target.ticket.url",
-            "target.ticket.via"
+            "target.ticket.via",
         ]

mindsdb/integrations/libs/response.py

@@ -50,7 +50,7 @@ class HandlerResponse:
         error_message: str | None = None,
         affected_rows: int | None = None,
         mysql_types: list[MYSQL_DATA_TYPE] | None = None,
-        is_acceptable_error: bool = False,
+        is_expected_error: bool = False,
     ) -> None:
         self.resp_type = resp_type
         self.query = query
@@ -61,7 +61,7 @@ class HandlerResponse:
         if isinstance(self.affected_rows, int) is False or self.affected_rows < 0:
             self.affected_rows = 0
         self.mysql_types = mysql_types
-        self.is_acceptable_error = is_acceptable_error
+        self.is_expected_error = is_expected_error
         self.exception = None
         current_exception = sys.exc_info()
         if current_exception[0] is not None:

mindsdb/integrations/utilities/handlers/auth_utilities/snowflake/__init__.py

@@ -0,0 +1 @@
+from .snowflake_jwt_gen import get_validated_jwt as get_validated_jwt

mindsdb/integrations/utilities/handlers/auth_utilities/snowflake/snowflake_jwt_gen.py

@@ -0,0 +1,151 @@
+# Based on https://docs.snowflake.com/en/developer-guide/sql-api/authenticating
+
+import time
+import base64
+import hashlib
+import logging
+from datetime import timedelta, timezone, datetime
+
+from cryptography.hazmat.primitives.serialization import load_pem_private_key
+from cryptography.hazmat.primitives.serialization import Encoding
+from cryptography.hazmat.primitives.serialization import PublicFormat
+from cryptography.hazmat.backends import default_backend
+import jwt
+
+logger = logging.getLogger(__name__)
+
+ISSUER = "iss"
+EXPIRE_TIME = "exp"
+ISSUE_TIME = "iat"
+SUBJECT = "sub"
+
+
+class JWTGenerator(object):
+    """
+    Creates and signs a JWT with the specified private key file, username, and account identifier. The JWTGenerator keeps the
+    generated token and only regenerates the token if a specified period of time has passed.
+    """
+
+    LIFETIME = timedelta(minutes=60)  # The tokens will have a 59 minute lifetime
+    ALGORITHM = "RS256"  # Tokens will be generated using RSA with SHA256
+
+    def __init__(self, account: str, user: str, private_key: str, lifetime: timedelta = LIFETIME):
+        """
+        __init__ creates an object that generates JWTs for the specified user, account identifier, and private key.
+        :param account: Your Snowflake account identifier. See https://docs.snowflake.com/en/user-guide/admin-account-identifier.html. Note that if you are using the account locator, exclude any region information from the account locator.
+        :param user: The Snowflake username.
+        :param private_key: The private key file used for signing the JWTs.
+        :param lifetime: The number of minutes (as a timedelta) during which the key will be valid.
+        """
+
+        logger.info(
+            """Creating JWTGenerator with arguments
+            account : %s, user : %s, lifetime : %s""",
+            account,
+            user,
+            lifetime,
+        )
+
+        # Construct the fully qualified name of the user in uppercase.
+        self.account = self.prepare_account_name_for_jwt(account)
+        self.user = user.upper()
+        self.qualified_username = self.account + "." + self.user
+
+        self.lifetime = lifetime
+        self.renew_time = datetime.now(timezone.utc)
+        self.token = None
+
+        self.private_key = load_pem_private_key(private_key.encode(), None, default_backend())
+
+    def prepare_account_name_for_jwt(self, raw_account: str) -> str:
+        """
+        Prepare the account identifier for use in the JWT.
+        For the JWT, the account identifier must not include the subdomain or any region or cloud provider information.
+        :param raw_account: The specified account identifier.
+        :return: The account identifier in a form that can be used to generate JWT.
+        """
+        account = raw_account
+        if ".global" not in account:
+            # Handle the general case.
+            idx = account.find(".")
+            if idx > 0:
+                account = account[0:idx]
+        else:
+            # Handle the replication case.
+            idx = account.find("-")
+            if idx > 0:
+                account = account[0:idx]
+        # Use uppercase for the account identifier.
+        return account.upper()
+
+    def get_token(self) -> str:
+        """
+        Generates a new JWT.
+        :return: the new token
+        """
+        now = datetime.now(timezone.utc)  # Fetch the current time
+
+        # Prepare the fields for the payload.
+        # Generate the public key fingerprint for the issuer in the payload.
+        public_key_fp = self.calculate_public_key_fingerprint(self.private_key)
+
+        # Create our payload
+        payload = {
+            # Set the issuer to the fully qualified username concatenated with the public key fingerprint.
+            ISSUER: self.qualified_username + "." + public_key_fp,
+            # Set the subject to the fully qualified username.
+            SUBJECT: self.qualified_username,
+            # Set the issue time to now.
+            ISSUE_TIME: now,
+            # Set the expiration time, based on the lifetime specified for this object.
+            EXPIRE_TIME: now + self.lifetime,
+        }
+
+        # Regenerate the actual token
+        token = jwt.encode(payload, key=self.private_key, algorithm=JWTGenerator.ALGORITHM)
+        # If you are using a version of PyJWT prior to 2.0, jwt.encode returns a byte string, rather than a string.
+        # If the token is a byte string, convert it to a string.
+        if isinstance(token, bytes):
+            token = token.decode("utf-8")
+        self.token = token
+
+        return self.token
+
+    def calculate_public_key_fingerprint(self, private_key: str) -> str:
+        """
+        Given a private key in PEM format, return the public key fingerprint.
+        :param private_key: private key string
+        :return: public key fingerprint
+        """
+        # Get the raw bytes of public key.
+        public_key_raw = private_key.public_key().public_bytes(Encoding.DER, PublicFormat.SubjectPublicKeyInfo)
+
+        # Get the sha256 hash of the raw bytes.
+        sha256hash = hashlib.sha256()
+        sha256hash.update(public_key_raw)
+
+        # Base64-encode the value and prepend the prefix 'SHA256:'.
+        public_key_fp = "SHA256:" + base64.b64encode(sha256hash.digest()).decode("utf-8")
+        logger.info("Public key fingerprint is %s", public_key_fp)
+
+        return public_key_fp
+
+
+def get_validated_jwt(token: str, account: str, user: str, private_key: str) -> str:
+    try:
+        content = jwt.decode(token, algorithms=[JWTGenerator.ALGORITHM], options={"verify_signature": False})
+
+        expired = content.get("exp", 0)
+        # add 5 seconds before limit
+        if expired - 5 > time.time():
+            # keep the same
+            return token
+
+    except jwt.DecodeError:
+        # wrong key
+        ...
+
+    # generate new token
+    if private_key is None:
+        raise ValueError("Private key is missing")
+    return JWTGenerator(account, user, private_key).get_token()

mindsdb/integrations/utilities/rag/rerankers/base_reranker.py

@@ -7,7 +7,6 @@ import math
 import os
 import random
 from abc import ABC
-from textwrap import dedent
 from typing import Any, List, Optional, Tuple
 
 from openai import AsyncOpenAI, AsyncAzureOpenAI
@@ -27,6 +26,16 @@ from mindsdb.integrations.libs.base import BaseMLEngine
 log = logging.getLogger(__name__)
 
 
+def get_event_loop():
+    try:
+        loop = asyncio.get_running_loop()
+    except RuntimeError:
+        # If no running loop exists, create a new one
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    return loop
+
+
 class BaseLLMReranker(BaseModel, ABC):
     filtering_threshold: float = 0.0  # Default threshold for filtering
     provider: str = "openai"
@@ -74,7 +83,12 @@ class BaseLLMReranker(BaseModel, ABC):
                     timeout=self.request_timeout,
                     max_retries=2,
                 )
-            elif self.provider == "openai":
+            elif self.provider in ("openai", "ollama"):
+                if self.provider == "ollama":
+                    self.method = "no-logprobs"
+                    if self.api_key is None:
+                        self.api_key = "n/a"
+
                 api_key_var: str = "OPENAI_API_KEY"
                 openai_api_key = self.api_key or os.getenv(api_key_var)
                 if not openai_api_key:
@@ -84,7 +98,6 @@ class BaseLLMReranker(BaseModel, ABC):
                 self.client = AsyncOpenAI(
                     api_key=openai_api_key, base_url=base_url, timeout=self.request_timeout, max_retries=2
                 )
-
             else:
                 # try to use litellm
                 from mindsdb.api.executor.controllers.session_controller import SessionController
@@ -99,7 +112,7 @@ class BaseLLMReranker(BaseModel, ABC):
                 self.method = "no-logprobs"
 
     async def _call_llm(self, messages):
-        if self.provider in ("azure_openai", "openai"):
+        if self.provider in ("azure_openai", "openai", "ollama"):
             return await self.client.chat.completions.create(
                 model=self.model,
                 messages=messages,
@@ -134,7 +147,7 @@ class BaseLLMReranker(BaseModel, ABC):
             for idx, result in enumerate(results):
                 if isinstance(result, Exception):
                     log.error(f"Error processing document {i + idx}: {str(result)}")
-                    raise RuntimeError(f"Error during reranking: {result}")
+                    raise RuntimeError(f"Error during reranking: {result}") from result
 
                 score = result["relevance_score"]
 
@@ -217,13 +230,11 @@ class BaseLLMReranker(BaseModel, ABC):
         return rerank_data
 
     async def search_relevancy_no_logprob(self, query: str, document: str) -> Any:
-        prompt = dedent(
-            f"""
-            Score the relevance between search query and user message on scale between 0 and 100 per cents.
-            Consider semantic meaning, key concepts, and contextual relevance.
-            Return ONLY a numerical score between 0 and 100 per cents. No other text. Stop after sending a number
-            Search query: {query}
-        """
+        prompt = (
+            f"Score the relevance between search query and user message on scale between 0 and 100 per cents. "
+            f"Consider semantic meaning, key concepts, and contextual relevance. "
+            f"Return ONLY a numerical score between 0 and 100 per cents. No other text. Stop after sending a number. "
+            f"Search query: {query}"
         )
 
         response = await self._call_llm(
@@ -392,16 +403,8 @@ class BaseLLMReranker(BaseModel, ABC):
     def get_scores(self, query: str, documents: list[str]):
         query_document_pairs = [(query, doc) for doc in documents]
         # Create event loop and run async code
-        import asyncio
-
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            # If no running loop exists, create a new one
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
 
-        documents_and_scores = loop.run_until_complete(self._rank(query_document_pairs))
+        documents_and_scores = get_event_loop().run_until_complete(self._rank(query_document_pairs))
 
         scores = [score for _, score in documents_and_scores]
         return scores

mindsdb/interfaces/agents/agents_controller.py

@@ -423,8 +423,6 @@ class AgentsController:
             raise ValueError("It is forbidden to change properties of the demo object")
 
         if name is not None and name != agent_name:
-            if not name.islower():
-                raise ValueError(f"The name must be in lower case: {name}")
             # Check to see if updated name already exists
             agent_with_new_name = self.get_agent(name, project_name=project_name)
             if agent_with_new_name is not None: