MindsDB 1.3.1__py3-none-any.whl → 24.12.4.0__py3-none-any.whl

mindsdb/integrations/handlers/google_fit_handler/google_fit_handler.py

@@ -0,0 +1,155 @@
+import os.path
+import json
+import pandas as pd
+import pytz
+from tzlocal import get_localzone
+from datetime import datetime
+
+from google.auth.transport.requests import Request
+from google.oauth2.credentials import Credentials
+from google_auth_oauthlib.flow import InstalledAppFlow
+from googleapiclient.discovery import Resource
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+from mindsdb_sql_parser import parse_sql
+
+from mindsdb.utilities import log
+from mindsdb.integrations.handlers.google_fit_handler.google_fit_tables import GoogleFitTable
+from mindsdb.integrations.libs.api_handler import APIHandler,FuncParser
+from mindsdb.integrations.libs.response import (
+    HandlerStatusResponse as StatusResponse,
+    HandlerResponse as Response,
+)
+
+SCOPES = ['https://www.googleapis.com/auth/fitness.activity.read']
+DATE_FORMAT = '%Y-%m-%d'
+
+logger = log.getLogger(__name__)
+
+
+class GoogleFitHandler(APIHandler):
+
+    def __init__(self, name: str = None, **kwargs):
+        super().__init__(name)
+        args = kwargs.get('connection_data', {})
+        self.connection_args = {}
+        self.credentials_path = None
+        if 'service_account_file' in args:
+            if os.path.isfile(args['service_account_file']) is False:
+                raise Exception("service_account_file must be a path to the credentials.json file")
+            self.credentials_path = args['service_account_file']
+        elif 'service_account_json' in args:
+            self.connection_args = args['service_account_json']
+            if not isinstance(self.connection_args, dict) or (('redirect_uris' not in self.connection_args.keys()) and len(self.connection_args) != 6) or ('redirect_uris' in self.connection_args.keys()) and len(self.connection_args) != 7:
+                raise Exception("service_account_json has to be a dictionary with all 6 required fields")
+            self.connection_args['redirect_uris'] = ['http://localhost']
+            self.credentials_path = 'mindsdb/integrations/handlers/google_fit_handler/credentials.json'
+        else:
+            raise Exception('Connection args have to content ether service_account_file or service_account_json')
+        
+
+        self.api = None
+        self.is_connected = False
+
+        aggregated_data = GoogleFitTable(self)
+        self._register_table('aggregated_data', aggregated_data)
+
+    def connect(self) -> Resource:
+        if self.is_connected is True and self.api:
+            return self.api
+        if self.connection_args:
+            credentialDict = {"installed":self.connection_args}
+            f = open(self.credentials_path, "w")
+            f.write(json.dumps(credentialDict).replace(" ", ""))
+            f.close()
+            
+        creds = None
+
+        if os.path.isfile('mindsdb/integrations/handlers/google_fit_handler/token.json'):
+            creds = Credentials.from_authorized_user_file('mindsdb/integrations/handlers/google_fit_handler/token.json', SCOPES)
+        if not creds or not creds.valid:
+            if creds and creds.expired and creds.refresh_token:
+                creds.refresh(Request())
+            else:
+                flow = InstalledAppFlow.from_client_secrets_file(
+                    self.credentials_path, SCOPES)
+                creds = flow.run_local_server(port=0)
+            with open('mindsdb/integrations/handlers/google_fit_handler/token.json', 'w') as token:
+                token.write(creds.to_json())
+        self.api = build('fitness', 'v1', credentials=creds)
+        
+        self.is_connected = True
+        return self.api
+
+    def check_connection(self) -> StatusResponse:
+        response = StatusResponse(False)
+
+        try:
+            api = self.connect()
+            response.success = True
+
+        except Exception as e:
+            logger.error(f'Error connecting to Google Fit API: {e}!')
+            response.error_message = e
+
+        self.is_connected = response.success
+        return response
+
+    def retrieve_data(self, service, startTimeMillis, endTimeMillis, dataSourceId) -> dict:
+        try:
+            return service.users().dataset().aggregate(userId="me", body={
+                "aggregateBy": [{
+                    "dataTypeName": "com.google.step_count.delta",
+                    "dataSourceId": dataSourceId
+                }],
+                "bucketByTime": {"durationMillis": 86400000},
+                "startTimeMillis": startTimeMillis,
+                "endTimeMillis": endTimeMillis
+            }).execute()
+        except HttpError:
+            raise HttpError
+
+
+    def native_query(self, query: str = None) -> Response:
+        """Receive raw query and act upon it somehow.
+        Args:
+            query (Any): query in native format (str for sql databases,
+            dict for mongo, api's json etc)
+        Returns:
+            HandlerResponse
+        """
+        ast = parse_sql(query)
+        return self.query(ast)
+    
+    def get_steps(self, start_time_millis, end_time_millis) -> pd.DataFrame:
+        steps = {}
+        steps_data = self.retrieve_data(self.api, start_time_millis, end_time_millis, "derived:com.google.step_count.delta:com.google.android.gms:estimated_steps")
+        for daily_step_data in steps_data['bucket']:
+            local_date = datetime.fromtimestamp(int(daily_step_data['startTimeMillis']) / 1000,
+                                            tz=pytz.timezone(str(get_localzone())))
+            local_date_str = local_date.strftime(DATE_FORMAT)
+
+            data_point = daily_step_data['dataset'][0]['point']
+            if data_point:
+                count = data_point[0]['value'][0]['intVal']
+                data_source_id = data_point[0]['originDataSourceId']
+                steps[local_date_str] = {'steps': count, 'originDataSourceId': data_source_id}
+        ret = pd.DataFrame.from_dict(steps)
+        ret = ret.T
+        ret = ret.drop('originDataSourceId', axis=1)
+        ret = ret.reset_index(drop=False)
+        return ret
+    
+    def call_google_fit_api(self, method_name:str = None, params:dict = None) -> pd.DataFrame:
+        """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, INSERT, DELETE, etc
+        Returns:
+            DataFrame
+        """
+        self.connect()
+        if method_name == 'get_steps':
+            val = self.get_steps(params['start_time'], params['end_time'])
+            return val
+        raise NotImplementedError('Method name {} not supported by Google Fit Handler'.format(method_name))

mindsdb/integrations/handlers/google_fit_handler/google_fit_tables.py

@@ -0,0 +1,69 @@
+from mindsdb.integrations.libs.api_handler import APITable
+from mindsdb.integrations.libs.response import HandlerResponse as Response
+from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions
+from mindsdb_sql_parser import ast
+import datetime
+import pytz
+import time
+from tzlocal import get_localzone
+
+class GoogleFitTable(APITable):
+
+    def time_parser(self, args) -> int:
+        """
+        Receive raw date string and return the calculated milliseconds based on the time string.
+        Args:
+            args: time string in the format of YYYY-MM-DD
+        Returns:
+            the input time string in the format of milliseconds
+        """
+        ymd = args.split('-')
+        epoch0 = datetime.datetime(1970, 1, 1, tzinfo=pytz.utc)
+        time = pytz.timezone(str(get_localzone())).localize(datetime.datetime(int(ymd[0].rstrip()), int(ymd[1].rstrip()), int(ymd[2].rstrip())))
+        return int((time - epoch0).total_seconds() * 1000)
+    
+    def select(self, query: ast.Select) -> Response:
+
+        conditions = extract_comparison_conditions(query.where)
+        
+        params = {}
+        filters = []
+        steps = {}
+        #get the local time
+        now = int(round(time.time() * 1000))
+
+        #hard coded for now as user default query time period
+        one_year = 31536000000
+        one_month = 2629746000
+        for op, arg1, arg2 in conditions:
+            if op == 'or':
+                raise NotImplementedError(f'OR is not supported')
+            if arg1 == 'date':
+                date = self.time_parser(arg2)
+                if op == '>':
+                    params['start_time'] = date
+                    params['end_time'] = now
+                
+                #hard coded as a month
+                elif op == '<':
+                    params['start_time'] = date - one_month
+                    params['end_time'] = date
+                else:
+                    raise NotImplementedError
+            else:
+                raise NotImplementedError(f'This query is not supported')
+        # if time is not provided in the query, the time range is one month ago to now 
+        if not params:
+            params['start_time'] = now - one_month
+            params['end_time'] = now
+        result = self.handler.call_google_fit_api(
+            method_name='get_steps',
+            params=params
+        )
+        return result
+
+    def get_columns(self):
+        return [
+            'dates',
+            'steps'
+        ]     

mindsdb/integrations/handlers/google_fit_handler/icon.svg

@@ -0,0 +1,13 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="34" viewBox="0 0 40 34" fill="none">
+  <g clip-path="url(#clip0_146_392)">
+    <path d="M3.82727 17.986L5.84251 20.009L10.1948 15.657L8.19644 13.634L7.28196 12.716C6.55377 11.985 6.16427 11.033 6.16427 9.996C6.16427 9.095 6.46909 8.279 6.99407 7.633C7.70533 6.732 8.78916 6.154 10.0085 6.154C11.0415 6.154 11.9898 6.562 12.735 7.293L13.6325 8.16L15.6478 10.2L20.0169 5.848L17.9848 3.825L17.0703 2.941C15.2583 1.122 12.7688 0 10.0085 0C4.47079 0 0 4.488 0 10.013C0 11.39 0.270957 12.699 0.779001 13.906C1.28704 15.113 2.01524 16.184 2.92972 17.085L3.82727 17.986Z" fill="#EA4335"/>
+    <path d="M13.8019 20.774L20.0169 14.569L15.6477 10.2L10.1947 15.657L5.8425 20.009L8.1795 22.372L10.1947 24.378L12.2947 22.27" fill="#FBBC04"/>
+    <path d="M24.3522 29.852L34.1744 20.009L29.8052 15.657L20 25.483L14.547 20.026L10.1947 24.378L15.6478 29.852L15.6308 29.869L20 34L24.3692 29.852H24.3522Z" fill="#34A853"/>
+    <path d="M37.0703 17.085C39.1024 15.045 40.271 11.917 39.9492 8.75497C39.475 3.96097 35.5123 0.356967 30.7028 0.033967C27.6715 -0.170033 24.8942 0.968967 22.9297 2.94097L15.6478 10.2L20 14.569L27.282 7.29297C28.1626 6.42597 29.3819 6.01797 30.635 6.22197C32.2608 6.47697 33.5817 7.81997 33.8019 9.45197C33.9712 10.676 33.5648 11.866 32.7011 12.733L29.8052 15.657L34.1744 20.009L37.0703 17.085Z" fill="#4285F4"/>
+  </g>
+  <defs>
+    <clipPath id="clip0_146_392">
+      <rect width="40" height="34" fill="white"/>
+    </clipPath>
+  </defs>
+</svg>

mindsdb/integrations/handlers/google_fit_handler/requirements.txt

@@ -0,0 +1,4 @@
+tzlocal
+google
+google-api-python-client
+tzlocal

mindsdb/integrations/handlers/google_gemini_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = "MindsDB Google Gemini handler"
+__package_name__ = "mindsdb_google_gemini_handler"
+__version__ = "0.0.1"
+__description__ = "MindsDB handler for the Google Gemini (Bard) API"
+__author__ = "someshfengde"
+__github__ = "https://github.com/mindsdb/mindsdb"
+__pypi__ = "https://pypi.org/project/mindsdb/"
+__license__ = "MIT"
+__copyright__ = "Copyright 2023 - mindsdb"

mindsdb/integrations/handlers/google_gemini_handler/__init__.py

@@ -0,0 +1,30 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+from .__about__ import __version__ as version, __description__ as description
+from mindsdb.utilities import log
+
+
+logger = log.getLogger(__name__)
+
+try:
+    from .google_gemini_handler import GoogleGeminiHandler as Handler
+
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = "Google Gemini"
+name = "google_gemini"
+type = HANDLER_TYPE.ML
+icon_path = "icon.svg"
+permanent = False
+__all__ = [
+    "Handler",
+    "version",
+    "name",
+    "type",
+    "title",
+    "description",
+    "import_error",
+    "icon_path",
+]

mindsdb/integrations/handlers/google_gemini_handler/google_gemini_handler.py

@@ -0,0 +1,370 @@
+import os
+from typing import Dict, Optional
+
+from PIL import Image
+import requests
+import numpy as np
+from io import BytesIO
+import json
+import textwrap
+import google.generativeai as genai
+import pandas as pd
+from mindsdb.integrations.libs.base import BaseMLEngine
+from mindsdb.utilities import log
+from mindsdb.utilities.config import Config
+from mindsdb.integrations.libs.llm.utils import get_completed_prompts
+import concurrent.futures
+
+logger = log.getLogger(__name__)
+
+
+class GoogleGeminiHandler(BaseMLEngine):
+    """
+    Integration with the Google generative AI Python Library
+    """
+
+    name = "google_gemini"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.default_model = "gemini-pro"
+        self.default_embedding_model = "models/embedding-001"
+        self.generative = True
+        self.mode = "default"
+
+    # Similiar to openai handler
+    @staticmethod
+    def create_validation(target, args=None, **kwargs):
+        if "using" not in args:
+            raise Exception(
+                "Gemini engine requires a USING clause! Refer to its documentation for more details."
+            )
+        else:
+            args = args["using"]
+
+        if (
+            len(
+                set(args.keys())
+                & {
+                    "img_url",
+                    "input_text",
+                    "question_column",
+                    "prompt_template",
+                    "json_struct",
+                    "prompt",
+                }
+            )
+            == 0
+        ):
+            raise Exception(
+                "One of `question_column`, `prompt_template` or `json_struct` is required for this engine."
+            )
+
+        keys_collection = [
+            ["prompt_template"],
+            ["question_column", "context_column"],
+            ["prompt", "user_column", "assistant_column"],
+            ["json_struct", "input_text"],
+            ["img_url", "ctx_column"],
+        ]
+        for keys in keys_collection:
+            if keys[0] in args and any(
+                x[0] in args for x in keys_collection if x != keys
+            ):
+                raise Exception(
+                    textwrap.dedent(
+                        """\
+                    Please provide one of
+                        1) a `prompt_template`
+                        2) a `question_column` and an optional `context_column`
+                        3) a `json_struct`
+                        4) a `prompt' and 'user_column' and 'assistant_column`
+                        5) a `img_url` and optional `ctx_column` for mode=`vision`
+                """
+                    )
+                )
+
+        # for all args that are not expected, raise an error
+        known_args = set()
+        # flatten of keys_collection
+        for keys in keys_collection:
+            known_args = known_args.union(set(keys))
+
+        # TODO: need a systematic way to maintain a list of known args
+        known_args = known_args.union(
+            {
+                "target",
+                "model_name",
+                "mode",
+                "title_column",
+                "predict_params",
+                "type",
+                "max_tokens",
+                "temperature",
+                "api_key",
+            }
+        )
+
+        unknown_args = set(args.keys()) - known_args
+        if unknown_args:
+            # return a list of unknown args as a string
+            raise Exception(
+                f"Unknown arguments: {', '.join(unknown_args)}.\n Known arguments are: {', '.join(known_args)}"
+            )
+
+    def create(self, target, args=None, **kwargs):
+        args = args["using"]
+        args["target"] = target
+        self.model_storage.json_set("args", args)
+
+    def predict(
+        self, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None
+    ) -> pd.DataFrame:
+        pred_args = args["predict_params"] if args else {}
+        args = self.model_storage.json_get("args")
+        df = df.reset_index(drop=True)
+
+        # same as opeani handler for getting prompt template and mode
+        if pred_args.get("prompt_template", False):
+            base_template = pred_args[
+                "prompt_template"
+            ]  # override with predict-time template if available
+        elif args.get("prompt_template", False):
+            base_template = args["prompt_template"]
+        else:
+            base_template = None
+
+        # Embedding Mode
+        if args.get("mode") == "embedding":
+            args["type"] = pred_args.get("type", "query")
+            return self.embedding_worker(args, df)
+
+        elif args.get("mode") == "vision":
+            return self.vision_worker(args, df)
+
+        elif args.get("mode") == "conversational":
+            # Enable chat mode using
+            # https://ai.google.dev/tutorials/python_quickstart#chat_conversations
+            # OR
+            # https://github.com/google/generative-ai-python?tab=readme-ov-file#developers-who-use-the-palm-api
+            pass
+
+        else:
+            if args.get("prompt_template", False):
+                prompts, empty_prompt_ids = get_completed_prompts(base_template, df)
+
+            # Disclaimer: The following code has been adapted from the OpenAI handler.
+            elif args.get("context_column", False):
+                empty_prompt_ids = np.where(
+                    df[[args["context_column"], args["question_column"]]]
+                    .isna()
+                    .all(axis=1)
+                    .values
+                )[0]
+                contexts = list(df[args["context_column"]].apply(lambda x: str(x)))
+                questions = list(df[args["question_column"]].apply(lambda x: str(x)))
+                prompts = [
+                    f"Give only answer for: \nContext: {c}\nQuestion: {q}\nAnswer: "
+                    for c, q in zip(contexts, questions)
+                ]
+
+                # Disclaimer: The following code has been adapted from the OpenAI handler.
+            elif args.get("json_struct", False):
+                empty_prompt_ids = np.where(
+                    df[[args["input_text"]]].isna().all(axis=1).values
+                )[0]
+                prompts = []
+                for i in df.index:
+                    if "json_struct" in df.columns:
+                        if isinstance(df["json_struct"][i], str):
+                            df["json_struct"][i] = json.loads(df["json_struct"][i])
+                        json_struct = ""
+                        for ind, val in enumerate(df["json_struct"][i].values()):
+                            json_struct = json_struct + f"{ind}. {val}\n"
+                    else:
+                        json_struct = ""
+                        for ind, val in enumerate(args["json_struct"].values()):
+                            json_struct = json_struct + f"{ind + 1}. {val}\n"
+
+                    p = textwrap.dedent(
+                        f"""\
+                        Using text starting after 'The text is:', give exactly {len(args['json_struct'])} answers to the questions:
+                        {{{{json_struct}}}}
+
+                        Answers should be in the same order as the questions.
+                        Answer should be in form of one JSON Object eg. {"{'key':'value',..}"} where key=question and value=answer.
+                        If there is no answer to the question in the text, put a -.
+                        Answers should be as short as possible, ideally 1-2 words (unless otherwise specified).
+
+                        The text is:
+                        {{{{{args['input_text']}}}}}
+                    """
+                    )
+                    p = p.replace("{{json_struct}}", json_struct)
+                    for column in df.columns:
+                        if column == "json_struct":
+                            continue
+                        p = p.replace(f"{{{{{column}}}}}", str(df[column][i]))
+                    prompts.append(p)
+            elif "prompt" in args:
+                empty_prompt_ids = []
+                prompts = list(df[args["user_column"]])
+            else:
+                empty_prompt_ids = np.where(
+                    df[[args["question_column"]]].isna().all(axis=1).values
+                )[0]
+                prompts = list(df[args["question_column"]].apply(lambda x: str(x)))
+
+        # remove prompts without signal from completion queue
+        prompts = [j for i, j in enumerate(prompts) if i not in empty_prompt_ids]
+
+        api_key = self._get_google_gemini_api_key(args)
+        genai.configure(api_key=api_key)
+
+        # called gemini model withinputs
+        model = genai.GenerativeModel(args.get("model_name", self.default_model))
+        results = []
+        for m in prompts:
+            results.append(model.generate_content(m).text)
+
+        pred_df = pd.DataFrame(results, columns=[args["target"]])
+        return pred_df
+
+    def _get_google_gemini_api_key(self, args, strict=True):
+        """
+        API_KEY preference order:
+            1. provided at model creation
+            2. provided at engine creation
+            3. GOOGLE_GENAI_API_KEY env variable
+            4. google_gemini.api_key setting in config.json
+        """
+
+        if "api_key" in args:
+            return args["api_key"]
+        # 2
+        connection_args = self.engine_storage.get_connection_args()
+        if "api_key" in connection_args:
+            return connection_args["api_key"]
+        # 3
+        api_key = os.getenv("GOOGLE_GENAI_API_KEY")
+        if api_key is not None:
+            return api_key
+        # 4
+        config = Config()
+        google_gemini_config = config.get("google_gemini", {})
+        if "api_key" in google_gemini_config:
+            return google_gemini_config["api_key"]
+
+        if strict:
+            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 embedding_worker(self, args: Dict, df: pd.DataFrame):
+        if args.get("question_column"):
+            prompts = list(df[args["question_column"]].apply(lambda x: str(x)))
+            if args.get("title_column", None):
+                titles = list(df[args["title_column"]].apply(lambda x: str(x)))
+            else:
+                titles = None
+
+            api_key = self._get_google_gemini_api_key(args)
+            genai.configure(api_key=api_key)
+            model_name = args.get("model_name", self.default_embedding_model)
+            task_type = args.get("type")
+            task_type = f"retrieval_{task_type}"
+
+            if task_type == "retrieval_query":
+                results = [
+                    str(
+                        genai.embed_content(
+                            model=model_name, content=query, task_type=task_type
+                        )["embedding"]
+                    )
+                    for query in prompts
+                ]
+            elif titles:
+                results = [
+                    str(
+                        genai.embed_content(
+                            model=model_name,
+                            content=doc,
+                            task_type=task_type,
+                            title=title,
+                        )["embedding"]
+                    )
+                    for title, doc in zip(titles, prompts)
+                ]
+            else:
+                results = [
+                    str(
+                        genai.embed_content(
+                            model=model_name, content=doc, task_type=task_type
+                        )["embedding"]
+                    )
+                    for doc in prompts
+                ]
+
+            pred_df = pd.DataFrame(results, columns=[args["target"]])
+            return pred_df
+        else:
+            raise Exception("Embedding mode needs a question_column")
+
+    def vision_worker(self, args: Dict, df: pd.DataFrame):
+        def get_img(url):
+            # URL Validation
+            response = requests.get(url)
+            if response.status_code == 200 and response.headers.get(
+                "content-type", ""
+            ).startswith("image/"):
+                return Image.open(BytesIO(response.content))
+            else:
+                raise Exception(f"{url} is not vaild image URL..")
+
+        if args.get("img_url"):
+            urls = list(df[args["img_url"]].apply(lambda x: str(x)))
+
+        else:
+            raise Exception("Vision mode needs a img_url")
+
+        prompts = None
+        if args.get("ctx_column"):
+            prompts = list(df[args["ctx_column"]].apply(lambda x: str(x)))
+
+        api_key = self._get_google_gemini_api_key(args)
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel("gemini-pro-vision")
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            # Download images concurrently using ThreadPoolExecutor
+            imgs = list(executor.map(get_img, urls))
+        # imgs = [Image.open(BytesIO(requests.get(url).content)) for url in urls]
+        if prompts:
+            results = [
+                model.generate_content([img, text]).text
+                for img, text in zip(imgs, prompts)
+            ]
+        else:
+            results = [model.generate_content(img).text for img in imgs]
+
+        pred_df = pd.DataFrame(results, columns=[args["target"]])
+
+        return pred_df
+
+    # Disclaimer: The following code has been adapted from the OpenAI handler.
+    def describe(self, attribute: Optional[str] = None) -> pd.DataFrame:
+
+        args = self.model_storage.json_get("args")
+
+        if attribute == "args":
+            return pd.DataFrame(args.items(), columns=["key", "value"])
+        elif attribute == "metadata":
+            api_key = self._get_google_gemini_api_key(args)
+            genai.configure(api_key=api_key)
+            model_name = args.get("model_name", self.default_model)
+
+            meta = genai.get_model(f"models/{model_name}").__dict__
+            return pd.DataFrame(meta.items(), columns=["key", "value"])
+        else:
+            tables = ["args", "metadata"]
+            return pd.DataFrame(tables, columns=["tables"])

mindsdb/integrations/handlers/google_gemini_handler/icon.svg

@@ -0,0 +1,3 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <path d="M20 40C18.4349 29.6717 10.3283 21.5651 0 20C10.3283 18.4349 18.4349 10.3283 20 0C21.5651 10.3283 29.6717 18.4349 40 20C29.6717 21.5651 21.5651 29.6717 20 40Z" fill="#076EFF"/>
+</svg>

mindsdb/integrations/handlers/google_gemini_handler/requirements.txt

@@ -0,0 +1,2 @@
+google-generativeai==0.3.2
+pillow

mindsdb/integrations/handlers/google_search_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB Google Search handler'
+__package_name__ = 'mindsdb_google_search_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for the Google Search API"
+__author__ = 'Panagiotis-Alexios Spanakis'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2023 - mindsdb'