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

mindsdb/integrations/handlers/rag_handler/settings.py

@@ -0,0 +1,479 @@
+import json
+from dataclasses import dataclass
+from functools import lru_cache, partial
+from typing import Any, Dict, List, Union, Optional
+
+import html2text
+import openai
+import pandas as pd
+import requests
+import writer
+from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings
+from langchain_community.llms import Writer
+from langchain_community.document_loaders import DataFrameLoader
+from langchain_community.vectorstores import FAISS, Chroma
+from pydantic import BaseModel, Extra, Field, field_validator, ValidationInfo
+
+
+from mindsdb.integrations.handlers.chromadb_handler.chromadb_handler import get_chromadb
+from mindsdb.integrations.handlers.rag_handler.exceptions import (
+    InvalidOpenAIModel,
+    InvalidPromptTemplate,
+    InvalidWriterModel,
+    UnsupportedLLM,
+    UnsupportedVectorStore,
+)
+from langchain_core.callbacks import StreamingStdOutCallbackHandler
+from langchain_core.documents import Document
+from langchain_core.embeddings import Embeddings
+from langchain_core.vectorstores import VectorStore
+
+DEFAULT_EMBEDDINGS_MODEL = "BAAI/bge-base-en"
+
+SUPPORTED_VECTOR_STORES = ("chromadb", "faiss")
+
+SUPPORTED_LLMS = ("writer", "openai")
+
+## Default parameters for RAG Handler
+
+# this is the default prompt template for qa
+DEFAULT_QA_PROMPT_TEMPLATE = """
+Use the following pieces of context to answer the question at the end. If you do not know the answer,
+just say that you do not know, do not try to make up an answer.
+Context: {context}
+Question: {question}
+Helpful Answer:"""
+
+# this is the default prompt template for if the user wants to summarize the context before qa prompt
+DEFAULT_SUMMARIZATION_PROMPT_TEMPLATE = """
+Summarize the following texts for me:
+{context}
+
+When summarizing, please keep the following in mind the following question:
+{question}
+"""
+
+DEFAULT_CHUNK_SIZE = 750
+DEFAULT_CHUNK_OVERLAP = 250
+DEFAULT_VECTOR_STORE_NAME = "chromadb"
+DEFAULT_VECTOR_STORE_COLLECTION_NAME = "collection"
+MAX_EMBEDDINGS_BATCH_SIZE = 2000
+
+chromadb = get_chromadb()
+
+
+def is_valid_store(name) -> bool:
+    return name in SUPPORTED_VECTOR_STORES
+
+
+class VectorStoreFactory:
+    """Factory class for vector stores"""
+
+    @staticmethod
+    def get_vectorstore_class(name) -> Union[FAISS, Chroma, VectorStore]:
+
+        if not isinstance(name, str):
+            raise TypeError("name must be a string")
+
+        if not is_valid_store(name):
+            raise ValueError(f"Invalid vector store {name}")
+
+        if name == "faiss":
+            return FAISS
+
+        if name == "chromadb":
+            return Chroma
+
+
+def get_chroma_client(persist_directory: str) -> chromadb.PersistentClient:
+    """Get Chroma client"""
+    return chromadb.PersistentClient(path=persist_directory)
+
+
+def get_available_writer_model_ids(args: ValidationInfo) -> list:
+    """Get available writer LLM model ids"""
+
+    args = args.data
+
+    writer_client = writer.Writer(
+        api_key=args["writer_api_key"],
+        organization_id=args["writer_org_id"],
+    )
+
+    res = writer_client.models.list(organization_id=args["writer_org_id"])
+
+    available_models_dict = json.loads(res.raw_response.text)
+
+    return [model["id"] for model in available_models_dict["models"]]
+
+
+def get_available_openai_model_ids(args: ValidationInfo) -> list:
+    """Get available openai LLM model ids"""
+
+    args = args.data
+
+    models = openai.OpenAI(api_key=args["openai_api_key"], base_url=args.get("base_url")).models.list().data
+
+    return [models.id for models in models]
+
+
+@dataclass
+class PersistedVectorStoreSaverConfig:
+    vector_store_name: str
+    persist_directory: str
+    collection_name: str
+    vector_store: VectorStore
+
+
+@dataclass
+class PersistedVectorStoreLoaderConfig:
+    vector_store_name: str
+    embeddings_model: Embeddings
+    persist_directory: str
+    collection_name: str
+
+
+class PersistedVectorStoreSaver:
+    """Saves vector store to disk"""
+
+    def __init__(self, config: PersistedVectorStoreSaverConfig):
+        self.config = config
+
+    def save_vector_store(self, vector_store: VectorStore):
+        method_name = f"save_{self.config.vector_store_name}"
+        getattr(self, method_name)(vector_store)
+
+    def save_chromadb(self, vector_store: Chroma):
+        """Save Chroma vector store to disk"""
+        # no need to save chroma vector store to disk, auto save
+        pass
+
+    def save_faiss(self, vector_store: FAISS):
+        vector_store.save_local(
+            folder_path=self.config.persist_directory,
+            index_name=self.config.collection_name,
+        )
+
+
+class PersistedVectorStoreLoader:
+    """Loads vector store from disk"""
+
+    def __init__(self, config: PersistedVectorStoreLoaderConfig):
+        self.config = config
+
+    def load_vector_store_client(
+            self,
+            vector_store: str,
+    ):
+        """Load vector store from the persisted vector store"""
+
+        if vector_store == "chromadb":
+
+            return Chroma(
+                collection_name=self.config.collection_name,
+                embedding_function=self.config.embeddings_model,
+                client=get_chroma_client(self.config.persist_directory),
+            )
+
+        elif vector_store == "faiss":
+
+            return FAISS.load_local(
+                folder_path=self.config.persist_directory,
+                embeddings=self.config.embeddings_model,
+                index_name=self.config.collection_name,
+                allow_dangerous_deserialization=True
+            )
+
+        else:
+            raise NotImplementedError(f"{vector_store} client is not yet supported")
+
+    def load_vector_store(self) -> VectorStore:
+        """Load vector store from the persisted vector store"""
+        method_name = f"load_{self.config.vector_store_name}"
+        return getattr(self, method_name)()
+
+    def load_chromadb(self) -> Chroma:
+        """Load Chroma vector store from the persisted vector store"""
+        return self.load_vector_store_client(vector_store="chromadb")
+
+    def load_faiss(self) -> FAISS:
+        """Load FAISS vector store from the persisted vector store"""
+        return self.load_vector_store_client(vector_store="faiss")
+
+
+class LLMParameters(BaseModel):
+    """Model parameters for the LLM API interface"""
+
+    llm_name: str = Field(default_factory=str, title="LLM API name")
+    max_tokens: int = Field(default=100, title="max tokens in response")
+    temperature: float = Field(default=0.0, title="temperature")
+    base_url: Optional[str] = None
+    top_p: float = 1
+    best_of: int = 5
+    stop: Optional[List[str]] = None
+
+    class Config:
+        extra = Extra.forbid
+        arbitrary_types_allowed = True
+        use_enum_values = True
+        protected_namespaces = ()
+
+
+class OpenAIParameters(LLMParameters):
+    """Model parameters for the LLM API interface"""
+
+    openai_api_key: str
+    model_id: str = Field(default="gpt-3.5-turbo-instruct", title="model name")
+    n: int = Field(default=1, title="number of responses to return")
+
+    @field_validator("model_id", mode="after")
+    def openai_model_must_be_supported(cls, v, values):
+        supported_models = get_available_openai_model_ids(values)
+        if v not in supported_models:
+            raise InvalidOpenAIModel(
+                f"'model_id' must be one of {supported_models}, got {v}"
+            )
+        return v
+
+
+class WriterLLMParameters(LLMParameters):
+    """Model parameters for the Writer LLM API interface"""
+
+    writer_api_key: str
+    writer_org_id: Optional[str] = None
+    model_id: str = "palmyra-x"
+    callbacks: List[StreamingStdOutCallbackHandler] = [StreamingStdOutCallbackHandler()]
+    verbose: bool = False
+
+    @field_validator("model_id")
+    def writer_model_must_be_supported(cls, v, values):
+        supported_models = get_available_writer_model_ids(values)
+        if v not in supported_models:
+            raise InvalidWriterModel(
+                f"'model_id' must be one of {supported_models}, got {v}"
+            )
+        return v
+
+
+class LLMLoader(BaseModel):
+    llm_config: dict
+    config_dict: dict = None
+
+    def load_llm(self) -> Union[Writer, partial]:
+        """Load LLM"""
+        method_name = f"load_{self.llm_config['llm_name']}_llm"
+        self.config_dict = self.llm_config.copy()
+        self.config_dict.pop("llm_name")
+        return getattr(self, method_name)()
+
+    def load_writer_llm(self) -> Writer:
+        """Load Writer LLM API interface"""
+        return Writer(**self.config_dict)
+
+    def load_openai_llm(self) -> partial:
+        """Load OpenAI LLM API interface"""
+        client = openai.OpenAI(api_key=self.config_dict["openai_api_key"], base_url=self.config_dict["base_url"])
+        config = self.config_dict.copy()
+        keys_to_remove = ["openai_api_key", "base_url"]
+        for key in keys_to_remove:
+            config.pop(key)
+        config["model"] = config.pop("model_id")
+
+        return partial(client.completions.create, **config)
+
+
+class RAGBaseParameters(BaseModel):
+    """Base model parameters for RAG Handler"""
+
+    llm_params: Any
+    vector_store_folder_name: str
+    input_column: str
+    use_gpu: bool = False
+    embeddings_batch_size: int = MAX_EMBEDDINGS_BATCH_SIZE  # not used, leaving in place to prevent breaking changes
+    prompt_template: str = DEFAULT_QA_PROMPT_TEMPLATE
+    chunk_size: int = DEFAULT_CHUNK_SIZE
+    chunk_overlap: int = DEFAULT_CHUNK_OVERLAP
+    url: Optional[Union[str, List[str]]] = None
+    url_column_name: Optional[str] = None
+    run_embeddings: Optional[bool] = True
+    top_k: int = 4
+    embeddings_model: Optional[Embeddings] = None
+    embeddings_model_name: str = DEFAULT_EMBEDDINGS_MODEL
+    context_columns: Optional[Union[List[str], str]] = None
+    vector_store_name: str = DEFAULT_VECTOR_STORE_NAME
+    vector_store: Optional[VectorStore] = None
+    collection_name: str = DEFAULT_VECTOR_STORE_COLLECTION_NAME
+    summarize_context: bool = True
+    summarization_prompt_template: str = DEFAULT_SUMMARIZATION_PROMPT_TEMPLATE
+    vector_store_storage_path: Optional[str] = Field(
+        default=None, title="don't use this field, it's for internal use only"
+    )
+
+    class Config:
+        extra = Extra.forbid
+        arbitrary_types_allowed = True
+        use_enum_values = True
+
+    @field_validator("prompt_template")
+    def prompt_format_must_be_valid(cls, v):
+        if "{context}" not in v or "{question}" not in v:
+            raise InvalidPromptTemplate(
+                "prompt_template must contain {context} and {question}"
+                f"\n For example, {DEFAULT_QA_PROMPT_TEMPLATE}"
+            )
+        return v
+
+    @field_validator("vector_store_name")
+    def name_must_be_lower(cls, v):
+        return v.lower()
+
+    @field_validator("vector_store_name")
+    def vector_store_must_be_supported(cls, v):
+        if not is_valid_store(v):
+            raise UnsupportedVectorStore(
+                f"we don't support {v}. currently we only support {', '.join(str(v) for v in SUPPORTED_VECTOR_STORES)} vector store"
+            )
+        return v
+
+
+class RAGHandlerParameters(RAGBaseParameters):
+    """Model parameters for create model"""
+
+    llm_type: str
+    llm_params: LLMParameters
+
+    @field_validator("llm_type")
+    def llm_type_must_be_supported(cls, v):
+        if v not in SUPPORTED_LLMS:
+            raise UnsupportedLLM(f"'llm_type' must be one of {SUPPORTED_LLMS}, got {v}")
+        return v
+
+
+class DfLoader(DataFrameLoader):
+    """
+    override the load method of langchain.document_loaders.DataFrameLoaders to ignore rows with 'None' values
+    """
+
+    def __init__(self, data_frame: pd.DataFrame, page_content_column: str):
+        super().__init__(data_frame=data_frame, page_content_column=page_content_column)
+        self._data_frame = data_frame
+        self._page_content_column = page_content_column
+
+    def load(self) -> List[Document]:
+        """Loads the dataframe as a list of documents"""
+        documents = []
+        for n_row, frame in self._data_frame[self._page_content_column].items():
+            if pd.notnull(frame):
+                # ignore rows with None values
+                column_name = self._page_content_column
+
+                document_contents = frame
+
+                documents.append(
+                    Document(
+                        page_content=document_contents,
+                        metadata={
+                            "source": "dataframe",
+                            "row": n_row,
+                            "column": column_name,
+                        },
+                    )
+                )
+        return documents
+
+
+def df_to_documents(
+        df: pd.DataFrame,
+        page_content_columns: Union[List[str], str],
+        url_column_name: str = None,
+) -> List[Document]:
+    """Converts a given dataframe to a list of documents"""
+    documents = []
+
+    if isinstance(page_content_columns, str):
+        page_content_columns = [page_content_columns]
+
+    for _, page_content_column in enumerate(page_content_columns):
+        if page_content_column not in df.columns.tolist():
+            raise ValueError(
+                f"page_content_column {page_content_column} not in dataframe columns"
+            )
+        if url_column_name is not None and page_content_column == url_column_name:
+            documents.extend(url_to_documents(df[page_content_column].tolist()))
+            continue
+
+        loader = DfLoader(data_frame=df, page_content_column=page_content_column)
+        documents.extend(loader.load())
+
+    return documents
+
+
+def url_to_documents(urls: Union[List[str], str]) -> List[Document]:
+    """Converts a given url to a document"""
+    documents = []
+    if isinstance(urls, str):
+        urls = [urls]
+
+    for url in urls:
+        response = requests.get(url, headers=None).text
+        html_to_text = html2text.html2text(response)
+        documents.append(Document(page_content=html_to_text, metadata={"source": url}))
+
+    return documents
+
+
+@lru_cache()
+def load_embeddings_model(embeddings_model_name, use_gpu=False):
+    """Load embeddings model from Hugging Face Hub"""
+    try:
+        model_kwargs = dict(device="cuda" if use_gpu else "cpu")
+        embedding_model = HuggingFaceEmbeddings(
+            model_name=embeddings_model_name, model_kwargs=model_kwargs
+        )
+    except ValueError:
+        raise ValueError(
+            f"The {embeddings_model_name}  is not supported, please select a valid option from Hugging Face Hub!"
+        )
+    return embedding_model
+
+
+def on_create_build_llm_params(
+        args: dict, llm_config_class: Union[WriterLLMParameters, OpenAIParameters]
+) -> Dict:
+    """build llm params from create args"""
+
+    llm_params = {"llm_name": args["llm_type"]}
+
+    for param in llm_config_class.model_fields.keys():
+        if param in args:
+            llm_params[param] = args.pop(param)
+
+    return llm_params
+
+
+def build_llm_params(args: dict, update=False) -> Dict:
+    """build llm params from args"""
+
+    if args["llm_type"] == "writer":
+        llm_config_class = WriterLLMParameters
+    elif args["llm_type"] == "openai":
+        llm_config_class = OpenAIParameters
+    else:
+        raise UnsupportedLLM(
+            f"'llm_type' must be one of {SUPPORTED_LLMS}, got {args['llm_type']}"
+        )
+
+    if not args.get("llm_params"):
+        # for create method only
+        llm_params = on_create_build_llm_params(args, llm_config_class)
+    else:
+        # for predict method only
+        llm_params = args.pop("llm_params")
+    if update:
+        # for update method only
+        args["llm_params"] = llm_params
+        return args
+
+    args["llm_params"] = llm_config_class(**llm_params)
+
+    return args

mindsdb/integrations/handlers/ray_serve_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB Ray Serve handler'
+__package_name__ = 'mindsdb_ray_serve_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for Ray Serve"
+__author__ = 'MindsDB Inc'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2023- mindsdb'

mindsdb/integrations/handlers/ray_serve_handler/__init__.py

@@ -0,0 +1,18 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+from mindsdb.integrations.handlers.ray_serve_handler.__about__ import __version__ as version, __description__ as description
+try:
+    from mindsdb.integrations.handlers.ray_serve_handler.ray_serve_handler import RayServeHandler as Handler
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'Ray Serve'
+name = 'ray_serve'
+type = HANDLER_TYPE.ML
+icon_path = 'icon.svg'
+permanent = False
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title', 'description', 'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/ray_serve_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="M2.1775 35.2068C2.1775 33.7622 3.35329 32.5878 4.79952 32.5878C6.24482 32.5878 7.42148 33.7622 7.42148 35.2068C7.42148 36.6505 6.24482 37.8249 4.79952 37.8249C3.35329 37.8249 2.1775 36.6505 2.1775 35.2068ZM25.3847 34.1198H9.46333C9.34219 33.6021 9.13549 33.1209 8.86225 32.6834L17.4796 24.0622C18.2136 24.5189 19.0724 24.7945 19.9996 24.7945C22.2709 24.7945 24.1679 23.2071 24.6643 21.0875H25.3847C28.982 21.0875 31.9073 24.0103 31.9073 27.6037C31.9073 31.196 28.982 34.1198 25.3847 34.1198ZM35.2005 7.4131C33.7542 7.4131 32.5785 6.23778 32.5785 4.79406C32.5785 3.34947 33.7542 2.17509 35.2005 2.17509C36.6458 2.17509 37.8225 3.34947 37.8225 4.79406C37.8225 6.23778 36.6458 7.4131 35.2005 7.4131ZM14.7373 5.88118H30.5367C30.6578 6.39789 30.8645 6.88002 31.1378 7.31843L22.5204 15.9396C21.7864 15.4829 20.9267 15.2073 19.9996 15.2073C17.73 15.2073 15.833 16.7938 15.3366 18.9125H14.7373C11.14 18.9125 8.21382 15.9897 8.21382 12.3973C8.21382 8.804 11.14 5.88118 14.7373 5.88118ZM22.6215 20.0014C22.6215 21.4451 21.4458 22.6194 19.9996 22.6194C18.5542 22.6194 17.3785 21.4451 17.3785 20.0014C17.3785 18.5568 18.5542 17.3824 19.9996 17.3824C21.4458 17.3824 22.6215 18.5568 22.6215 20.0014ZM0 35.2068C0 37.8495 2.15293 40 4.79952 40C7.06992 40 8.967 38.4126 9.46333 36.2939H25.3847C30.1824 36.2939 34.0857 32.3959 34.0857 27.6037C34.0857 22.8114 30.1824 18.9125 25.3847 18.9125H24.6634C24.5422 18.3958 24.3364 17.9137 24.0623 17.4761L32.6787 8.85495C33.4128 9.3116 34.2733 9.58726 35.2005 9.58726C37.8471 9.58726 40 7.43764 40 4.79406C40 2.15055 37.8471 0 35.2005 0C32.9301 0 31.033 1.5874 30.5367 3.70608H14.7373C9.93968 3.70608 6.03624 7.605 6.03624 12.3973C6.03624 17.1886 9.93968 21.0875 14.7373 21.0875H15.3366C15.4578 21.6052 15.6635 22.0873 15.9377 22.5248L7.32132 31.146C6.58631 30.6884 5.72665 30.4119 4.79952 30.4119C2.15293 30.4119 0 32.5633 0 35.2068Z" fill="#04A1E9"/>
+</svg>

mindsdb/integrations/handlers/ray_serve_handler/ray_serve_handler.py

@@ -0,0 +1,66 @@
+import requests
+from typing import Dict, Optional
+
+import pandas as pd
+
+from mindsdb.integrations.libs.base import BaseMLEngine
+
+
+class RayServeHandler(BaseMLEngine):
+    """
+    The Ray Serve integration engine needs to have a working connection to Ray Serve. For this:
+        - A Ray Serve server should be running
+
+    Example:
+        
+    """  # noqa
+    name = 'ray_serve'
+
+    @staticmethod
+    def create_validation(target, args=None, **kwargs):
+        if not args.get('using'):
+            raise Exception("Error: This engine requires some parameters via the 'using' clause. Please refer to the documentation of the Ray Serve handler and try again.")  # noqa
+        if not args['using'].get('train_url'):
+            raise Exception("Error: Please provide a URL for the training endpoint.")
+        if not args['using'].get('predict_url'):
+            raise Exception("Error: Please provide a URL for the prediction endpoint.")
+
+    def create(self, target: str, df: Optional[pd.DataFrame] = None, args: Optional[Dict] = None) -> None:
+        # TODO: use join_learn_process to notify users when ray has finished the training process
+        args = args['using']  # ignore the rest of the problem definition
+        args['target'] = target
+        self.model_storage.json_set('args', args)
+        try:
+            resp = requests.post(args['train_url'],
+                                 json={'df': df.to_json(orient='records'), 'target': target},
+                                 headers={'content-type': 'application/json; format=pandas-records'})
+        except requests.exceptions.InvalidSchema:
+            raise Exception("Error: The URL provided for the training endpoint is invalid.")
+
+        resp = resp.json()
+        if resp['status'] != 'ok':
+            raise Exception("Error: Training failed: " + resp['status'])
+
+    def predict(self, df, args=None):
+        args = self.model_storage.json_get('args')  # override any incoming args for now
+        resp = requests.post(args['predict_url'],
+                             json={'df': df.to_json(orient='records')},
+                             headers={'content-type': 'application/json; format=pandas-records'})
+        response = resp.json()
+
+        target = args['target']
+        if target != 'prediction':
+            # rename prediction to target
+            response[target] = response.pop('prediction')
+
+        predictions = pd.DataFrame(response)
+        return predictions
+
+    def describe(self, key: Optional[str] = None) -> pd.DataFrame:
+        args = self.model_storage.json_get('args')
+        description = {
+            'TRAIN_URL': [args['train_url']],
+            'PREDICT_URL': [args['predict_url']],
+            'TARGET': [args['target']],
+        }
+        return pd.DataFrame.from_dict(description)

mindsdb/integrations/handlers/reddit_handler/__about__.py

@@ -0,0 +1,9 @@
+__title__ = 'MindsDB Reddit handler'
+__package_name__ = 'mindsdb_reddit_handler'
+__version__ = '0.0.1'
+__description__ = "MindsDB handler for Reddit"
+__author__ = 'Maro Akpobi'
+__github__ = 'https://github.com/mindsdb/mindsdb'
+__pypi__ = 'https://pypi.org/project/mindsdb/'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2022- mindsdb'

mindsdb/integrations/handlers/reddit_handler/__init__.py

@@ -0,0 +1,21 @@
+from mindsdb.integrations.libs.const import HANDLER_TYPE
+
+from .__about__ import __version__ as version, __description__ as description
+try:
+    from .reddit_handler import (
+        RedditHandler as Handler
+    )
+    import_error = None
+except Exception as e:
+    Handler = None
+    import_error = e
+
+title = 'Reddit'
+name = 'reddit'
+type = HANDLER_TYPE.DATA
+icon_path = 'icon.svg'
+
+__all__ = [
+    'Handler', 'version', 'name', 'type', 'title', 'description',
+    'import_error', 'icon_path'
+]

mindsdb/integrations/handlers/reddit_handler/icon.svg

@@ -0,0 +1,11 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="40" height="40" viewBox="0 0 40 40" fill="none">
+  <g clip-path="url(#clip0_195_341)">
+    <path d="M20 40C31.0457 40 40 31.0457 40 20C40 8.95431 31.0457 0 20 0C8.95431 0 0 8.95431 0 20C0 31.0457 8.95431 40 20 40Z" fill="#FF4500"/>
+    <path d="M33.34 20C33.344 20.274 33.31 20.5475 33.238 20.812C33.166 21.0765 33.057 21.33 32.914 21.564C32.7715 21.798 32.5965 22.011 32.3945 22.1965C32.1925 22.382 31.9655 22.538 31.72 22.66C31.7255 22.733 31.73 22.8065 31.7325 22.88C31.7385 23.0266 31.7385 23.1734 31.7325 23.32C31.73 23.3935 31.7255 23.467 31.72 23.54C31.72 28.02 26.5 31.66 20.06 31.66C13.62 31.66 8.39999 28.02 8.39999 23.54C8.39449 23.467 8.38999 23.3935 8.38749 23.32C8.38148 23.1734 8.38148 23.0266 8.38749 22.88C8.38999 22.8065 8.39449 22.733 8.39999 22.66C8.01537 22.4832 7.67376 22.225 7.39879 21.9031C7.12382 21.5813 6.92207 21.2035 6.80749 20.796C6.69311 20.3883 6.66874 19.9606 6.73609 19.5426C6.80343 19.1246 6.96087 18.7262 7.19749 18.375C7.43391 18.0239 7.74389 17.7285 8.10591 17.5092C8.46793 17.2899 8.87334 17.152 9.29399 17.105C9.7147 17.0579 10.1406 17.1027 10.5423 17.2366C10.9439 17.3704 11.3116 17.5899 11.62 17.88C12.1924 17.492 12.7921 17.146 13.4145 16.8445C14.037 16.5435 14.6805 16.2875 15.34 16.0795C15.9995 15.8715 16.6735 15.712 17.356 15.6015C18.0385 15.491 18.7285 15.4305 19.42 15.42L20.9 8.48001C20.9165 8.39951 20.949 8.32351 20.9955 8.25551C21.0415 8.18801 21.101 8.13001 21.1695 8.08551C21.2385 8.04101 21.3155 8.01051 21.3965 7.99551C21.477 7.98101 21.56 7.98251 21.64 8.00001L26.54 8.98001C27.0345 8.13051 28.0725 7.76651 28.989 8.12051C29.9055 8.47451 30.4295 9.44201 30.2245 10.403C30.02 11.364 29.147 12.034 28.166 11.9835C27.1845 11.933 26.385 11.177 26.28 10.2L22 9.30001L20.7 15.54C21.383 15.5545 22.0645 15.6185 22.7385 15.731C24.0882 15.956 25.3984 16.3746 26.6285 16.974C27.2429 17.273 27.8349 17.6159 28.4 18C28.8063 17.6099 29.3169 17.3458 29.87 17.2395C30.4231 17.1329 30.9953 17.1886 31.5175 17.4C32.0397 17.6113 32.4896 17.9692 32.813 18.4305C33.1364 18.8919 33.3195 19.4369 33.34 20ZM13.492 22.7655C13.593 23.008 13.74 23.2285 13.926 23.414C14.1115 23.6 14.332 23.747 14.5745 23.848C14.8172 23.9484 15.0773 24 15.34 24C16.149 24 16.878 23.5125 17.188 22.7655C17.4975 22.018 17.326 21.158 16.754 20.586C16.182 20.014 15.322 19.8425 14.5745 20.152C13.8275 20.462 13.34 21.191 13.34 22C13.34 22.2625 13.3915 22.5225 13.492 22.7655ZM24.947 27.5665C25.0495 27.4665 25.108 27.33 25.11 27.187C25.112 27.0435 25.0565 26.9055 24.9565 26.803C24.8565 26.7005 24.72 26.642 24.577 26.64C24.4335 26.638 24.2955 26.6935 24.18 26.78C23.8793 26.9957 23.5608 27.1856 23.228 27.3475C22.8952 27.5095 22.5493 27.6432 22.194 27.747C21.839 27.8505 21.4755 27.924 21.108 27.9665C20.74 28.009 20.3695 28.02 20 28C19.631 28.0165 19.261 28.0015 18.8945 27.9555C18.5279 27.91 18.1659 27.833 17.8125 27.7255C17.4585 27.6185 17.115 27.4815 16.7845 27.3165C16.454 27.1515 16.138 26.9585 15.84 26.74C15.7365 26.655 15.605 26.6115 15.471 26.618C15.337 26.6245 15.2105 26.681 15.1155 26.7755C15.021 26.8705 14.9645 26.997 14.958 27.131C14.9515 27.265 14.995 27.3965 15.08 27.5C15.4315 27.765 15.805 27.999 16.1965 28.2C16.588 28.401 16.9965 28.5675 17.4165 28.6985C17.8365 28.8295 18.267 28.924 18.7035 28.9815C19.14 29.0385 19.5805 29.058 20.02 29.04C20.4595 29.058 20.9 29.0385 21.3365 28.9815C22.2108 28.8665 23.0588 28.6022 23.8435 28.2C24.235 27.999 24.6085 27.765 24.96 27.5L24.947 27.5665ZM24.58 24.16C24.851 24.163 25.12 24.1105 25.3705 24.0065C25.621 23.902 25.8475 23.748 26.0365 23.5535C26.2255 23.359 26.3725 23.128 26.4695 22.8745C26.5666 22.6213 26.611 22.351 26.6 22.08C26.6 21.271 26.1125 20.542 25.3655 20.232C24.618 19.9225 23.758 20.094 23.186 20.666C22.614 21.238 22.4425 22.098 22.752 22.8455C23.062 23.5925 23.791 24.08 24.6 24.08L24.58 24.16Z" fill="white"/>
+  </g>
+  <defs>
+    <clipPath id="clip0_195_341">
+      <rect width="40" height="40" fill="white"/>
+    </clipPath>
+  </defs>
+</svg>