lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/components/data/json_to_data.py

@@ -0,0 +1,98 @@
+import json
+from pathlib import Path
+
+from json_repair import repair_json
+
+from lfx.custom.custom_component.component import Component
+from lfx.io import FileInput, MessageTextInput, MultilineInput, Output
+from lfx.schema.data import Data
+
+
+class JSONToDataComponent(Component):
+    display_name = "Load JSON"
+    description = (
+        "Convert a JSON file, JSON from a file path, or a JSON string to a Data object or a list of Data objects"
+    )
+    icon = "braces"
+    name = "JSONtoData"
+    legacy = True
+
+    inputs = [
+        FileInput(
+            name="json_file",
+            display_name="JSON File",
+            file_types=["json"],
+            info="Upload a JSON file to convert to a Data object or list of Data objects",
+        ),
+        MessageTextInput(
+            name="json_path",
+            display_name="JSON File Path",
+            info="Provide the path to the JSON file as pure text",
+        ),
+        MultilineInput(
+            name="json_string",
+            display_name="JSON String",
+            info="Enter a valid JSON string (object or array) to convert to a Data object or list of Data objects",
+        ),
+    ]
+
+    outputs = [
+        Output(name="data", display_name="Data", method="convert_json_to_data"),
+    ]
+
+    def convert_json_to_data(self) -> Data | list[Data]:
+        if sum(bool(field) for field in [self.json_file, self.json_path, self.json_string]) != 1:
+            msg = "Please provide exactly one of: JSON file, file path, or JSON string."
+            self.status = msg
+            raise ValueError(msg)
+
+        json_data = None
+
+        try:
+            if self.json_file:
+                resolved_path = self.resolve_path(self.json_file)
+                file_path = Path(resolved_path)
+                if file_path.suffix.lower() != ".json":
+                    self.status = "The provided file must be a JSON file."
+                else:
+                    json_data = file_path.read_text(encoding="utf-8")
+
+            elif self.json_path:
+                file_path = Path(self.json_path)
+                if file_path.suffix.lower() != ".json":
+                    self.status = "The provided file must be a JSON file."
+                else:
+                    json_data = file_path.read_text(encoding="utf-8")
+
+            else:
+                json_data = self.json_string
+
+            if json_data:
+                # Try to parse the JSON string
+                try:
+                    parsed_data = json.loads(json_data)
+                except json.JSONDecodeError:
+                    # If JSON parsing fails, try to repair the JSON string
+                    repaired_json_string = repair_json(json_data)
+                    parsed_data = json.loads(repaired_json_string)
+
+                # Check if the parsed data is a list
+                if isinstance(parsed_data, list):
+                    result = [Data(data=item) for item in parsed_data]
+                else:
+                    result = Data(data=parsed_data)
+                self.status = result
+                return result
+
+        except (json.JSONDecodeError, SyntaxError, ValueError) as e:
+            error_message = f"Invalid JSON or Python literal: {e}"
+            self.status = error_message
+            raise ValueError(error_message) from e
+
+        except Exception as e:
+            error_message = f"An error occurred: {e}"
+            self.status = error_message
+            raise ValueError(error_message) from e
+
+        # An error occurred
+        raise ValueError(self.status)

lfx/components/data/news_search.py

@@ -0,0 +1,164 @@
+from urllib.parse import quote_plus
+
+import pandas as pd
+import requests
+from bs4 import BeautifulSoup
+
+from lfx.custom import Component
+from lfx.io import IntInput, MessageTextInput, Output
+from lfx.schema import DataFrame
+
+
+class NewsSearchComponent(Component):
+    display_name = "News Search"
+    description = "Searches Google News via RSS. Returns clean article data."
+    documentation: str = "https://docs.langflow.org/components-data#news-search"
+    icon = "newspaper"
+    name = "NewsSearch"
+
+    inputs = [
+        MessageTextInput(
+            name="query",
+            display_name="Search Query",
+            info="Search keywords for news articles.",
+            tool_mode=True,
+            required=True,
+        ),
+        MessageTextInput(
+            name="hl",
+            display_name="Language (hl)",
+            info="Language code, e.g. en-US, fr, de. Default: en-US.",
+            tool_mode=False,
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="gl",
+            display_name="Country (gl)",
+            info="Country code, e.g. US, FR, DE. Default: US.",
+            tool_mode=False,
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="ceid",
+            display_name="Country:Language (ceid)",
+            info="e.g. US:en, FR:fr. Default: US:en.",
+            tool_mode=False,
+            value="US:en",
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="topic",
+            display_name="Topic",
+            info="One of: WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SCIENCE, SPORTS, HEALTH.",
+            tool_mode=False,
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
+        MessageTextInput(
+            name="location",
+            display_name="Location (Geo)",
+            info="City, state, or country for location-based news. Leave blank for keyword search.",
+            tool_mode=False,
+            input_types=[],
+            required=False,
+            advanced=True,
+        ),
+        IntInput(
+            name="timeout",
+            display_name="Timeout",
+            info="Timeout for the request in seconds.",
+            value=5,
+            required=False,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [Output(name="articles", display_name="News Articles", method="search_news")]
+
+    def search_news(self) -> DataFrame:
+        # Defaults
+        hl = getattr(self, "hl", None) or "en-US"
+        gl = getattr(self, "gl", None) or "US"
+        ceid = getattr(self, "ceid", None) or f"{gl}:{hl.split('-')[0]}"
+        topic = getattr(self, "topic", None)
+        location = getattr(self, "location", None)
+        query = getattr(self, "query", None)
+
+        # Build base URL
+        if topic:
+            # Topic-based feed
+            base_url = f"https://news.google.com/rss/headlines/section/topic/{quote_plus(topic.upper())}"
+            params = f"?hl={hl}&gl={gl}&ceid={ceid}"
+            rss_url = base_url + params
+        elif location:
+            # Location-based feed
+            base_url = f"https://news.google.com/rss/headlines/section/geo/{quote_plus(location)}"
+            params = f"?hl={hl}&gl={gl}&ceid={ceid}"
+            rss_url = base_url + params
+        elif query:
+            # Keyword search feed
+            base_url = "https://news.google.com/rss/search?q="
+            query_parts = [query]
+            query_encoded = quote_plus(" ".join(query_parts))
+            params = f"&hl={hl}&gl={gl}&ceid={ceid}"
+            rss_url = f"{base_url}{query_encoded}{params}"
+        else:
+            self.status = "No search query, topic, or location provided."
+            self.log(self.status)
+            return DataFrame(
+                pd.DataFrame(
+                    [
+                        {
+                            "title": "Error",
+                            "link": "",
+                            "published": "",
+                            "summary": "No search query, topic, or location provided.",
+                        }
+                    ]
+                )
+            )
+
+        try:
+            response = requests.get(rss_url, timeout=self.timeout)
+            response.raise_for_status()
+            soup = BeautifulSoup(response.content, "xml")
+            items = soup.find_all("item")
+        except requests.RequestException as e:
+            self.status = f"Failed to fetch news: {e}"
+            self.log(self.status)
+            return DataFrame(pd.DataFrame([{"title": "Error", "link": "", "published": "", "summary": str(e)}]))
+        except (AttributeError, ValueError, TypeError) as e:
+            self.status = f"Unexpected error: {e!s}"
+            self.log(self.status)
+            return DataFrame(pd.DataFrame([{"title": "Error", "link": "", "published": "", "summary": str(e)}]))
+
+        if not items:
+            self.status = "No news articles found."
+            self.log(self.status)
+            return DataFrame(pd.DataFrame([{"title": "No articles found", "link": "", "published": "", "summary": ""}]))
+
+        articles = []
+        for item in items:
+            try:
+                title = self.clean_html(item.title.text if item.title else "")
+                link = item.link.text if item.link else ""
+                published = item.pubDate.text if item.pubDate else ""
+                summary = self.clean_html(item.description.text if item.description else "")
+                articles.append({"title": title, "link": link, "published": published, "summary": summary})
+            except (AttributeError, ValueError, TypeError) as e:
+                self.log(f"Error parsing article: {e!s}")
+                continue
+
+        df_articles = pd.DataFrame(articles)
+        self.log(f"Found {len(df_articles)} articles.")
+        return DataFrame(df_articles)
+
+    def clean_html(self, html_string: str) -> str:
+        return BeautifulSoup(html_string, "html.parser").get_text(separator=" ", strip=True)

lfx/components/data/rss.py

@@ -0,0 +1,69 @@
+import pandas as pd
+import requests
+from bs4 import BeautifulSoup
+
+from lfx.custom import Component
+from lfx.io import IntInput, MessageTextInput, Output
+from lfx.log.logger import logger
+from lfx.schema import DataFrame
+
+
+class RSSReaderComponent(Component):
+    display_name = "RSS Reader"
+    description = "Fetches and parses an RSS feed."
+    documentation: str = "https://docs.langflow.org/components-data#rss-reader"
+    icon = "rss"
+    name = "RSSReaderSimple"
+
+    inputs = [
+        MessageTextInput(
+            name="rss_url",
+            display_name="RSS Feed URL",
+            info="URL of the RSS feed to parse.",
+            tool_mode=True,
+            required=True,
+        ),
+        IntInput(
+            name="timeout",
+            display_name="Timeout",
+            info="Timeout for the RSS feed request.",
+            value=5,
+            advanced=True,
+        ),
+    ]
+
+    outputs = [Output(name="articles", display_name="Articles", method="read_rss")]
+
+    def read_rss(self) -> DataFrame:
+        try:
+            response = requests.get(self.rss_url, timeout=self.timeout)
+            response.raise_for_status()
+            if not response.content.strip():
+                msg = "Empty response received"
+                raise ValueError(msg)
+            # Check if the response is valid XML
+            try:
+                BeautifulSoup(response.content, "xml")
+            except Exception as e:
+                msg = f"Invalid XML response: {e}"
+                raise ValueError(msg) from e
+            soup = BeautifulSoup(response.content, "xml")
+            items = soup.find_all("item")
+        except (requests.RequestException, ValueError) as e:
+            self.status = f"Failed to fetch RSS: {e}"
+            return DataFrame(pd.DataFrame([{"title": "Error", "link": "", "published": "", "summary": str(e)}]))
+
+        articles = [
+            {
+                "title": item.title.text if item.title else "",
+                "link": item.link.text if item.link else "",
+                "published": item.pubDate.text if item.pubDate else "",
+                "summary": item.description.text if item.description else "",
+            }
+            for item in items
+        ]
+
+        # Ensure the DataFrame has the correct columns even if empty
+        df_articles = pd.DataFrame(articles, columns=["title", "link", "published", "summary"])
+        logger.info(f"Fetched {len(df_articles)} articles.")
+        return DataFrame(df_articles)

lfx/components/data/sql_executor.py

@@ -0,0 +1,101 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_community.utilities import SQLDatabase
+from sqlalchemy.exc import SQLAlchemyError
+
+from lfx.custom.custom_component.component_with_cache import ComponentWithCache
+from lfx.io import BoolInput, MessageTextInput, MultilineInput, Output
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+from lfx.services.cache.utils import CacheMiss
+
+if TYPE_CHECKING:
+    from sqlalchemy.engine import Result
+
+
+class SQLComponent(ComponentWithCache):
+    """A sql component."""
+
+    display_name = "SQL Database"
+    description = "Executes SQL queries on SQLAlchemy-compatible databases."
+    documentation: str = "https://docs.langflow.org/components-data#sql-database"
+    icon = "database"
+    name = "SQLComponent"
+    metadata = {"keywords": ["sql", "database", "query", "db", "fetch"]}
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.db: SQLDatabase = None
+
+    def maybe_create_db(self):
+        if self.database_url != "":
+            if self._shared_component_cache:
+                cached_db = self._shared_component_cache.get(self.database_url)
+                if not isinstance(cached_db, CacheMiss):
+                    self.db = cached_db
+                    return
+                self.log("Connecting to database")
+            try:
+                self.db = SQLDatabase.from_uri(self.database_url)
+            except Exception as e:
+                msg = f"An error occurred while connecting to the database: {e}"
+                raise ValueError(msg) from e
+            if self._shared_component_cache:
+                self._shared_component_cache.set(self.database_url, self.db)
+
+    inputs = [
+        MessageTextInput(name="database_url", display_name="Database URL", required=True),
+        MultilineInput(name="query", display_name="SQL Query", tool_mode=True, required=True),
+        BoolInput(name="include_columns", display_name="Include Columns", value=True, tool_mode=True, advanced=True),
+        BoolInput(
+            name="add_error",
+            display_name="Add Error",
+            value=False,
+            tool_mode=True,
+            info="If True, the error will be added to the result",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Result Table", name="run_sql_query", method="run_sql_query"),
+    ]
+
+    def build_component(
+        self,
+    ) -> Message:
+        error = None
+        self.maybe_create_db()
+        try:
+            result = self.db.run(self.query, include_columns=self.include_columns)
+            self.status = result
+        except SQLAlchemyError as e:
+            msg = f"An error occurred while running the SQL Query: {e}"
+            self.log(msg)
+            result = str(e)
+            self.status = result
+            error = repr(e)
+
+        if self.add_error and error is not None:
+            result = f"{result}\n\nError: {error}\n\nQuery: {self.query}"
+        elif error is not None:
+            # Then we won't add the error to the result
+            result = self.query
+
+        return Message(text=result)
+
+    def __execute_query(self) -> list[dict[str, Any]]:
+        self.maybe_create_db()
+        try:
+            cursor: Result[Any] = self.db.run(self.query, fetch="cursor")
+            return [x._asdict() for x in cursor.fetchall()]
+        except SQLAlchemyError as e:
+            msg = f"An error occurred while running the SQL Query: {e}"
+            self.log(msg)
+            raise ValueError(msg) from e
+
+    def run_sql_query(self) -> DataFrame:
+        result = self.__execute_query()
+        df_result = DataFrame(result)
+        self.status = df_result
+        return df_result