langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/components/google/gmail.py

@@ -1,192 +0,0 @@
-import base64
-import json
-import re
-from collections.abc import Iterator
-from json.decoder import JSONDecodeError
-from typing import Any
-
-from google.auth.exceptions import RefreshError
-from google.oauth2.credentials import Credentials
-from googleapiclient.discovery import build
-from langchain_core.chat_sessions import ChatSession
-from langchain_core.messages import HumanMessage
-from langchain_google_community.gmail.loader import GMailLoader
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import MessageTextInput
-from langflow.io import SecretStrInput
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.template.field.base import Output
-
-
-class GmailLoaderComponent(Component):
-    display_name = "Gmail Loader"
-    description = "Loads emails from Gmail using provided credentials."
-    icon = "Google"
-    legacy: bool = True
-
-    inputs = [
-        SecretStrInput(
-            name="json_string",
-            display_name="JSON String of the Service Account Token",
-            info="JSON string containing OAuth 2.0 access token information for service account access",
-            required=True,
-            value="""{
-                "account": "",
-                "client_id": "",
-                "client_secret": "",
-                "expiry": "",
-                "refresh_token": "",
-                "scopes": [
-                    "https://www.googleapis.com/auth/gmail.readonly",
-                ],
-                "token": "",
-                "token_uri": "https://oauth2.googleapis.com/token",
-                "universe_domain": "googleapis.com"
-            }""",
-        ),
-        MessageTextInput(
-            name="label_ids",
-            display_name="Label IDs",
-            info="Comma-separated list of label IDs to filter emails.",
-            required=True,
-            value="INBOX,SENT,UNREAD,IMPORTANT",
-        ),
-        MessageTextInput(
-            name="max_results",
-            display_name="Max Results",
-            info="Maximum number of emails to load.",
-            required=True,
-            value="10",
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Data", name="data", method="load_emails"),
-    ]
-
-    def load_emails(self) -> Data:
-        class CustomGMailLoader(GMailLoader):
-            def __init__(
-                self, creds: Any, *, n: int = 100, label_ids: list[str] | None = None, raise_error: bool = False
-            ) -> None:
-                super().__init__(creds, n, raise_error)
-                self.label_ids = label_ids if label_ids is not None else ["SENT"]
-
-            def clean_message_content(self, message):
-                # Remove URLs
-                message = re.sub(r"http\S+|www\S+|https\S+", "", message, flags=re.MULTILINE)
-
-                # Remove email addresses
-                message = re.sub(r"\S+@\S+", "", message)
-
-                # Remove special characters and excessive whitespace
-                message = re.sub(r"[^A-Za-z0-9\s]+", " ", message)
-                message = re.sub(r"\s{2,}", " ", message)
-
-                # Trim leading and trailing whitespace
-                return message.strip()
-
-            def _extract_email_content(self, msg: Any) -> HumanMessage:
-                from_email = None
-                for values in msg["payload"]["headers"]:
-                    name = values["name"]
-                    if name == "From":
-                        from_email = values["value"]
-                if from_email is None:
-                    msg = "From email not found."
-                    raise ValueError(msg)
-
-                parts = msg["payload"]["parts"] if "parts" in msg["payload"] else [msg["payload"]]
-
-                for part in parts:
-                    if part["mimeType"] == "text/plain":
-                        data = part["body"]["data"]
-                        data = base64.urlsafe_b64decode(data).decode("utf-8")
-                        pattern = re.compile(r"\r\nOn .+(\r\n)*wrote:\r\n")
-                        newest_response = re.split(pattern, data)[0]
-                        return HumanMessage(
-                            content=self.clean_message_content(newest_response),
-                            additional_kwargs={"sender": from_email},
-                        )
-                msg = "No plain text part found in the email."
-                raise ValueError(msg)
-
-            def _get_message_data(self, service: Any, message: Any) -> ChatSession:
-                msg = service.users().messages().get(userId="me", id=message["id"]).execute()
-                message_content = self._extract_email_content(msg)
-
-                in_reply_to = None
-                email_data = msg["payload"]["headers"]
-                for values in email_data:
-                    name = values["name"]
-                    if name == "In-Reply-To":
-                        in_reply_to = values["value"]
-
-                thread_id = msg["threadId"]
-
-                if in_reply_to:
-                    thread = service.users().threads().get(userId="me", id=thread_id).execute()
-                    messages = thread["messages"]
-
-                    response_email = None
-                    for _message in messages:
-                        email_data = _message["payload"]["headers"]
-                        for values in email_data:
-                            if values["name"] == "Message-ID":
-                                message_id = values["value"]
-                                if message_id == in_reply_to:
-                                    response_email = _message
-                    if response_email is None:
-                        msg = "Response email not found in the thread."
-                        raise ValueError(msg)
-                    starter_content = self._extract_email_content(response_email)
-                    return ChatSession(messages=[starter_content, message_content])
-                return ChatSession(messages=[message_content])
-
-            def lazy_load(self) -> Iterator[ChatSession]:
-                service = build("gmail", "v1", credentials=self.creds)
-                results = (
-                    service.users().messages().list(userId="me", labelIds=self.label_ids, maxResults=self.n).execute()
-                )
-                messages = results.get("messages", [])
-                if not messages:
-                    logger.warning("No messages found with the specified labels.")
-                for message in messages:
-                    try:
-                        yield self._get_message_data(service, message)
-                    except Exception:
-                        if self.raise_error:
-                            raise
-                        else:
-                            logger.exception(f"Error processing message {message['id']}")
-
-        json_string = self.json_string
-        label_ids = self.label_ids.split(",") if self.label_ids else ["INBOX"]
-        max_results = int(self.max_results) if self.max_results else 100
-
-        # Load the token information from the JSON string
-        try:
-            token_info = json.loads(json_string)
-        except JSONDecodeError as e:
-            msg = "Invalid JSON string"
-            raise ValueError(msg) from e
-
-        creds = Credentials.from_authorized_user_info(token_info)
-
-        # Initialize the custom loader with the provided credentials
-        loader = CustomGMailLoader(creds=creds, n=max_results, label_ids=label_ids)
-
-        try:
-            docs = loader.load()
-        except RefreshError as e:
-            msg = "Authentication error: Unable to refresh authentication token. Please try to reauthenticate."
-            raise ValueError(msg) from e
-        except Exception as e:
-            msg = f"Error loading documents: {e}"
-            raise ValueError(msg) from e
-
-        # Return the loaded documents
-        self.status = docs
-        return Data(data={"text": docs})

langflow/components/google/google_bq_sql_executor.py

@@ -1,157 +0,0 @@
-import json
-import re
-from pathlib import Path
-
-from google.auth.exceptions import RefreshError
-from google.cloud import bigquery
-from google.oauth2.service_account import Credentials
-
-from langflow.custom import Component
-from langflow.io import BoolInput, FileInput, MessageTextInput, Output
-from langflow.schema.dataframe import DataFrame
-
-
-class BigQueryExecutorComponent(Component):
-    display_name = "BigQuery"
-    description = "Execute SQL queries on Google BigQuery."
-    name = "BigQueryExecutor"
-    icon = "Google"
-    beta: bool = True
-
-    inputs = [
-        FileInput(
-            name="service_account_json_file",
-            display_name="Upload Service Account JSON",
-            info="Upload the JSON file containing Google Cloud service account credentials.",
-            file_types=["json"],
-            required=True,
-        ),
-        MessageTextInput(
-            name="query",
-            display_name="SQL Query",
-            info="The SQL query to execute on BigQuery.",
-            required=True,
-            tool_mode=True,
-        ),
-        BoolInput(
-            name="clean_query",
-            display_name="Clean Query",
-            info="When enabled, this will automatically clean up your SQL query.",
-            value=False,
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Query Results", name="query_results", method="execute_sql"),
-    ]
-
-    def _clean_sql_query(self, query: str) -> str:
-        """Clean SQL query by removing surrounding quotes and whitespace.
-
-        Also extracts SQL statements from text that might contain other content.
-
-        Args:
-            query: The SQL query to clean
-
-        Returns:
-            The cleaned SQL query
-        """
-        # First, try to extract SQL from code blocks
-        sql_pattern = r"```(?:sql)?\s*([\s\S]*?)\s*```"
-        sql_matches = re.findall(sql_pattern, query, re.IGNORECASE)
-
-        if sql_matches:
-            # If we found SQL in code blocks, use the first match
-            query = sql_matches[0]
-        else:
-            # If no code block, try to find SQL statements
-            # Look for common SQL keywords at the start of lines
-            sql_keywords = r"(?i)(SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP|WITH|MERGE)"
-            lines = query.split("\n")
-            sql_lines = []
-            in_sql = False
-
-            for _line in lines:
-                line = _line.strip()
-                if re.match(sql_keywords, line):
-                    in_sql = True
-                if in_sql:
-                    sql_lines.append(line)
-                if line.endswith(";"):
-                    in_sql = False
-
-            if sql_lines:
-                query = "\n".join(sql_lines)
-
-        # Remove any backticks that might be at the start or end
-        query = query.strip("`")
-
-        # Then remove surrounding quotes (single or double) if they exist
-        query = query.strip()
-        if (query.startswith('"') and query.endswith('"')) or (query.startswith("'") and query.endswith("'")):
-            query = query[1:-1]
-
-        # Finally, clean up any remaining whitespace and ensure no backticks remain
-        query = query.strip()
-        # Remove any remaining backticks, but preserve them if they're part of a table/column name
-        # This regex will remove backticks that are not part of a valid identifier
-        return re.sub(r"`(?![a-zA-Z0-9_])|(?<![a-zA-Z0-9_])`", "", query)
-
-    def execute_sql(self) -> DataFrame:
-        try:
-            # First try to read the file
-            try:
-                service_account_path = Path(self.service_account_json_file)
-                with service_account_path.open() as f:
-                    credentials_json = json.load(f)
-                    project_id = credentials_json.get("project_id")
-                    if not project_id:
-                        msg = "No project_id found in service account credentials file."
-                        raise ValueError(msg)
-            except FileNotFoundError as e:
-                msg = f"Service account file not found: {e}"
-                raise ValueError(msg) from e
-            except json.JSONDecodeError as e:
-                msg = "Invalid JSON string for service account credentials"
-                raise ValueError(msg) from e
-
-            # Then try to load credentials
-            try:
-                credentials = Credentials.from_service_account_file(self.service_account_json_file)
-            except Exception as e:
-                msg = f"Error loading service account credentials: {e}"
-                raise ValueError(msg) from e
-
-        except ValueError:
-            raise
-        except Exception as e:
-            msg = f"Error executing BigQuery SQL query: {e}"
-            raise ValueError(msg) from e
-
-        try:
-            client = bigquery.Client(credentials=credentials, project=project_id)
-
-            # Check for empty or whitespace-only query before cleaning
-            if not str(self.query).strip():
-                msg = "No valid SQL query found in input text."
-                raise ValueError(msg)
-
-            # Always clean the query if it contains code block markers, quotes, or if clean_query is enabled
-            if "```" in str(self.query) or '"' in str(self.query) or "'" in str(self.query) or self.clean_query:
-                sql_query = self._clean_sql_query(str(self.query))
-            else:
-                sql_query = str(self.query).strip()  # At minimum, strip whitespace
-
-            query_job = client.query(sql_query)
-            results = query_job.result()
-            output_dict = [dict(row) for row in results]
-
-        except RefreshError as e:
-            msg = "Authentication error: Unable to refresh authentication token. Please try to reauthenticate."
-            raise ValueError(msg) from e
-        except Exception as e:
-            msg = f"Error executing BigQuery SQL query: {e}"
-            raise ValueError(msg) from e
-
-        return DataFrame(output_dict)

langflow/components/google/google_drive.py

@@ -1,92 +0,0 @@
-import json
-from json.decoder import JSONDecodeError
-
-from google.auth.exceptions import RefreshError
-from google.oauth2.credentials import Credentials
-from langchain_google_community import GoogleDriveLoader
-
-from langflow.custom.custom_component.component import Component
-from langflow.helpers.data import docs_to_data
-from langflow.inputs.inputs import MessageTextInput
-from langflow.io import SecretStrInput
-from langflow.schema.data import Data
-from langflow.template.field.base import Output
-
-
-class GoogleDriveComponent(Component):
-    display_name = "Google Drive Loader"
-    description = "Loads documents from Google Drive using provided credentials."
-    icon = "Google"
-    legacy: bool = True
-
-    inputs = [
-        SecretStrInput(
-            name="json_string",
-            display_name="JSON String of the Service Account Token",
-            info="JSON string containing OAuth 2.0 access token information for service account access",
-            required=True,
-        ),
-        MessageTextInput(
-            name="document_id", display_name="Document ID", info="Single Google Drive document ID", required=True
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Loaded Documents", name="docs", method="load_documents"),
-    ]
-
-    def load_documents(self) -> Data:
-        class CustomGoogleDriveLoader(GoogleDriveLoader):
-            creds: Credentials | None = None
-            """Credentials object to be passed directly."""
-
-            def _load_credentials(self):
-                """Load credentials from the provided creds attribute or fallback to the original method."""
-                if self.creds:
-                    return self.creds
-                msg = "No credentials provided."
-                raise ValueError(msg)
-
-            class Config:
-                arbitrary_types_allowed = True
-
-        json_string = self.json_string
-
-        document_ids = [self.document_id]
-        if len(document_ids) != 1:
-            msg = "Expected a single document ID"
-            raise ValueError(msg)
-
-        # TODO: Add validation to check if the document ID is valid
-
-        # Load the token information from the JSON string
-        try:
-            token_info = json.loads(json_string)
-        except JSONDecodeError as e:
-            msg = "Invalid JSON string"
-            raise ValueError(msg) from e
-
-        # Initialize the custom loader with the provided credentials and document IDs
-        loader = CustomGoogleDriveLoader(
-            creds=Credentials.from_authorized_user_info(token_info), document_ids=document_ids
-        )
-
-        # Load the documents
-        try:
-            docs = loader.load()
-        # catch google.auth.exceptions.RefreshError
-        except RefreshError as e:
-            msg = "Authentication error: Unable to refresh authentication token. Please try to reauthenticate."
-            raise ValueError(msg) from e
-        except Exception as e:
-            msg = f"Error loading documents: {e}"
-            raise ValueError(msg) from e
-
-        if len(docs) != 1:
-            msg = "Expected a single document to be loaded."
-            raise ValueError(msg)
-
-        data = docs_to_data(docs)
-        # Return the loaded documents
-        self.status = data
-        return Data(data={"text": data})

langflow/components/google/google_drive_search.py

@@ -1,152 +0,0 @@
-import json
-
-from google.oauth2.credentials import Credentials
-from googleapiclient.discovery import build
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import DropdownInput, MessageTextInput
-from langflow.io import SecretStrInput
-from langflow.schema.data import Data
-from langflow.template.field.base import Output
-
-
-class GoogleDriveSearchComponent(Component):
-    display_name = "Google Drive Search"
-    description = "Searches Google Drive files using provided credentials and query parameters."
-    icon = "Google"
-    legacy: bool = True
-
-    inputs = [
-        SecretStrInput(
-            name="token_string",
-            display_name="Token String",
-            info="JSON string containing OAuth 2.0 access token information for service account access",
-            required=True,
-        ),
-        DropdownInput(
-            name="query_item",
-            display_name="Query Item",
-            options=[
-                "name",
-                "fullText",
-                "mimeType",
-                "modifiedTime",
-                "viewedByMeTime",
-                "trashed",
-                "starred",
-                "parents",
-                "owners",
-                "writers",
-                "readers",
-                "sharedWithMe",
-                "createdTime",
-                "properties",
-                "appProperties",
-                "visibility",
-                "shortcutDetails.targetId",
-            ],
-            info="The field to query.",
-            required=True,
-        ),
-        DropdownInput(
-            name="valid_operator",
-            display_name="Valid Operator",
-            options=["contains", "=", "!=", "<=", "<", ">", ">=", "in", "has"],
-            info="Operator to use in the query.",
-            required=True,
-        ),
-        MessageTextInput(
-            name="search_term",
-            display_name="Search Term",
-            info="The value to search for in the specified query item.",
-            required=True,
-        ),
-        MessageTextInput(
-            name="query_string",
-            display_name="Query String",
-            info="The query string used for searching. You can edit this manually.",
-            value="",  # This will be updated with the generated query string
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Document URLs", name="doc_urls", method="search_doc_urls"),
-        Output(display_name="Document IDs", name="doc_ids", method="search_doc_ids"),
-        Output(display_name="Document Titles", name="doc_titles", method="search_doc_titles"),
-        Output(display_name="Data", name="Data", method="search_data"),
-    ]
-
-    def generate_query_string(self) -> str:
-        query_item = self.query_item
-        valid_operator = self.valid_operator
-        search_term = self.search_term
-
-        # Construct the query string
-        query = f"{query_item} {valid_operator} '{search_term}'"
-
-        # Update the editable query string input with the generated query
-        self.query_string = query
-
-        return query
-
-    def on_inputs_changed(self) -> None:
-        # Automatically regenerate the query string when inputs change
-        self.generate_query_string()
-
-    def generate_file_url(self, file_id: str, mime_type: str) -> str:
-        """Generates the appropriate Google Drive URL for a file based on its MIME type."""
-        return {
-            "application/vnd.google-apps.document": f"https://docs.google.com/document/d/{file_id}/edit",
-            "application/vnd.google-apps.spreadsheet": f"https://docs.google.com/spreadsheets/d/{file_id}/edit",
-            "application/vnd.google-apps.presentation": f"https://docs.google.com/presentation/d/{file_id}/edit",
-            "application/vnd.google-apps.drawing": f"https://docs.google.com/drawings/d/{file_id}/edit",
-            "application/pdf": f"https://drive.google.com/file/d/{file_id}/view?usp=drivesdk",
-        }.get(mime_type, f"https://drive.google.com/file/d/{file_id}/view?usp=drivesdk")
-
-    def search_files(self) -> dict:
-        # Load the token information from the JSON string
-        token_info = json.loads(self.token_string)
-        creds = Credentials.from_authorized_user_info(token_info)
-
-        # Use the query string from the input (which might have been edited by the user)
-        query = self.query_string or self.generate_query_string()
-
-        # Initialize the Google Drive API service
-        service = build("drive", "v3", credentials=creds)
-
-        # Perform the search
-        results = service.files().list(q=query, pageSize=5, fields="nextPageToken, files(id, name, mimeType)").execute()
-        items = results.get("files", [])
-
-        doc_urls = []
-        doc_ids = []
-        doc_titles_urls = []
-        doc_titles = []
-
-        if items:
-            for item in items:
-                # Directly use the file ID, title, and MIME type to generate the URL
-                file_id = item["id"]
-                file_title = item["name"]
-                mime_type = item["mimeType"]
-                file_url = self.generate_file_url(file_id, mime_type)
-
-                # Store the URL, ID, and title+URL in their respective lists
-                doc_urls.append(file_url)
-                doc_ids.append(file_id)
-                doc_titles.append(file_title)
-                doc_titles_urls.append({"title": file_title, "url": file_url})
-
-        return {"doc_urls": doc_urls, "doc_ids": doc_ids, "doc_titles_urls": doc_titles_urls, "doc_titles": doc_titles}
-
-    def search_doc_ids(self) -> list[str]:
-        return self.search_files()["doc_ids"]
-
-    def search_doc_urls(self) -> list[str]:
-        return self.search_files()["doc_urls"]
-
-    def search_doc_titles(self) -> list[str]:
-        return self.search_files()["doc_titles"]
-
-    def search_data(self) -> Data:
-        return Data(data={"text": self.search_files()["doc_titles_urls"]})