lfx-nightly 0.2.0.dev25__py3-none-any.whl

lfx/components/xai/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.xai.xai import XAIModelComponent
+
+_dynamic_imports = {
+    "XAIModelComponent": "xai",
+}
+
+__all__ = ["XAIModelComponent"]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import xai components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/xai/xai.py

@@ -0,0 +1,167 @@
+import requests
+from langchain_openai import ChatOpenAI
+from pydantic.v1 import SecretStr
+from typing_extensions import override
+
+from lfx.base.models.model import LCModelComponent
+from lfx.field_typing import LanguageModel
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.inputs.inputs import (
+    BoolInput,
+    DictInput,
+    DropdownInput,
+    IntInput,
+    MessageTextInput,
+    SecretStrInput,
+    SliderInput,
+)
+
+XAI_DEFAULT_MODELS = ["grok-2-latest"]
+
+
+class XAIModelComponent(LCModelComponent):
+    display_name = "xAI"
+    description = "Generates text using xAI models like Grok."
+    icon = "xAI"
+    name = "xAIModel"
+
+    inputs = [
+        *LCModelComponent.get_base_inputs(),
+        IntInput(
+            name="max_tokens",
+            display_name="Max Tokens",
+            advanced=True,
+            info="The maximum number of tokens to generate. Set to 0 for unlimited tokens.",
+            range_spec=RangeSpec(min=0, max=128000),
+        ),
+        DictInput(
+            name="model_kwargs",
+            display_name="Model Kwargs",
+            advanced=True,
+            info="Additional keyword arguments to pass to the model.",
+        ),
+        BoolInput(
+            name="json_mode",
+            display_name="JSON Mode",
+            advanced=True,
+            info="If True, it will output JSON regardless of passing a schema.",
+        ),
+        DropdownInput(
+            name="model_name",
+            display_name="Model Name",
+            advanced=False,
+            options=XAI_DEFAULT_MODELS,
+            value=XAI_DEFAULT_MODELS[0],
+            refresh_button=True,
+            combobox=True,
+            info="The xAI model to use",
+        ),
+        MessageTextInput(
+            name="base_url",
+            display_name="xAI API Base",
+            advanced=True,
+            info="The base URL of the xAI API. Defaults to https://api.x.ai/v1",
+            value="https://api.x.ai/v1",
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="xAI API Key",
+            info="The xAI API Key to use for the model.",
+            advanced=False,
+            value="XAI_API_KEY",
+            required=True,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            range_spec=RangeSpec(min=0, max=2, step=0.01),
+            advanced=True,
+        ),
+        IntInput(
+            name="seed",
+            display_name="Seed",
+            info="The seed controls the reproducibility of the job.",
+            advanced=True,
+            value=1,
+        ),
+    ]
+
+    def get_models(self) -> list[str]:
+        """Fetch available models from xAI API."""
+        if not self.api_key:
+            return XAI_DEFAULT_MODELS
+
+        base_url = self.base_url or "https://api.x.ai/v1"
+        url = f"{base_url}/language-models"
+        headers = {"Authorization": f"Bearer {self.api_key}", "Accept": "application/json"}
+
+        try:
+            response = requests.get(url, headers=headers, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+
+            # Extract model IDs and any aliases
+            models = set()
+            for model in data.get("models", []):
+                models.add(model["id"])
+                models.update(model.get("aliases", []))
+
+            return sorted(models) if models else XAI_DEFAULT_MODELS
+        except requests.RequestException as e:
+            self.status = f"Error fetching models: {e}"
+            return XAI_DEFAULT_MODELS
+
+    @override
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Update build configuration with fresh model list when key fields change."""
+        if field_name in {"api_key", "base_url", "model_name"}:
+            models = self.get_models()
+            build_config["model_name"]["options"] = models
+        return build_config
+
+    def build_model(self) -> LanguageModel:
+        api_key = self.api_key
+        temperature = self.temperature
+        model_name: str = self.model_name
+        max_tokens = self.max_tokens
+        model_kwargs = self.model_kwargs or {}
+        base_url = self.base_url or "https://api.x.ai/v1"
+        json_mode = self.json_mode
+        seed = self.seed
+
+        api_key = SecretStr(api_key).get_secret_value() if api_key else None
+
+        output = ChatOpenAI(
+            max_tokens=max_tokens or None,
+            model_kwargs=model_kwargs,
+            model=model_name,
+            base_url=base_url,
+            api_key=api_key,
+            temperature=temperature if temperature is not None else 0.1,
+            seed=seed,
+        )
+
+        if json_mode:
+            output = output.bind(response_format={"type": "json_object"})
+
+        return output
+
+    def _get_exception_message(self, e: Exception):
+        """Get a message from an xAI exception.
+
+        Args:
+            e (Exception): The exception to get the message from.
+
+        Returns:
+            str: The message from the exception.
+        """
+        try:
+            from openai import BadRequestError
+        except ImportError:
+            return None
+        if isinstance(e, BadRequestError):
+            message = e.body.get("message")
+            if message:
+                return message
+        return None

lfx/components/yahoosearch/__init__.py

@@ -0,0 +1,3 @@
+from .yahoo import YfinanceComponent
+
+__all__ = ["YfinanceComponent"]

lfx/components/yahoosearch/yahoo.py

@@ -0,0 +1,137 @@
+import ast
+import pprint
+from enum import Enum
+
+import yfinance as yf
+from langchain_core.tools import ToolException
+from pydantic import BaseModel, Field
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import DropdownInput, IntInput, MessageTextInput
+from lfx.io import Output
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
+
+
+class YahooFinanceMethod(Enum):
+    GET_INFO = "get_info"
+    GET_NEWS = "get_news"
+    GET_ACTIONS = "get_actions"
+    GET_ANALYSIS = "get_analysis"
+    GET_BALANCE_SHEET = "get_balance_sheet"
+    GET_CALENDAR = "get_calendar"
+    GET_CASHFLOW = "get_cashflow"
+    GET_INSTITUTIONAL_HOLDERS = "get_institutional_holders"
+    GET_RECOMMENDATIONS = "get_recommendations"
+    GET_SUSTAINABILITY = "get_sustainability"
+    GET_MAJOR_HOLDERS = "get_major_holders"
+    GET_MUTUALFUND_HOLDERS = "get_mutualfund_holders"
+    GET_INSIDER_PURCHASES = "get_insider_purchases"
+    GET_INSIDER_TRANSACTIONS = "get_insider_transactions"
+    GET_INSIDER_ROSTER_HOLDERS = "get_insider_roster_holders"
+    GET_DIVIDENDS = "get_dividends"
+    GET_CAPITAL_GAINS = "get_capital_gains"
+    GET_SPLITS = "get_splits"
+    GET_SHARES = "get_shares"
+    GET_FAST_INFO = "get_fast_info"
+    GET_SEC_FILINGS = "get_sec_filings"
+    GET_RECOMMENDATIONS_SUMMARY = "get_recommendations_summary"
+    GET_UPGRADES_DOWNGRADES = "get_upgrades_downgrades"
+    GET_EARNINGS = "get_earnings"
+    GET_INCOME_STMT = "get_income_stmt"
+
+
+class YahooFinanceSchema(BaseModel):
+    symbol: str = Field(..., description="The stock symbol to retrieve data for.")
+    method: YahooFinanceMethod = Field(YahooFinanceMethod.GET_INFO, description="The type of data to retrieve.")
+    num_news: int | None = Field(5, description="The number of news articles to retrieve.")
+
+
+class YfinanceComponent(Component):
+    display_name = "Yahoo! Finance"
+    description = """Uses [yfinance](https://pypi.org/project/yfinance/) (unofficial package) \
+to access financial data and market information from Yahoo! Finance."""
+    icon = "trending-up"
+
+    inputs = [
+        MessageTextInput(
+            name="symbol",
+            display_name="Stock Symbol",
+            info="The stock symbol to retrieve data for (e.g., AAPL, GOOG).",
+            tool_mode=True,
+        ),
+        DropdownInput(
+            name="method",
+            display_name="Data Method",
+            info="The type of data to retrieve.",
+            options=list(YahooFinanceMethod),
+            value="get_news",
+        ),
+        IntInput(
+            name="num_news",
+            display_name="Number of News",
+            info="The number of news articles to retrieve (only applicable for get_news).",
+            value=5,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
+    ]
+
+    def run_model(self) -> DataFrame:
+        return self.fetch_content_dataframe()
+
+    def _fetch_yfinance_data(self, ticker: yf.Ticker, method: YahooFinanceMethod, num_news: int | None) -> str:
+        try:
+            if method == YahooFinanceMethod.GET_INFO:
+                result = ticker.info
+            elif method == YahooFinanceMethod.GET_NEWS:
+                result = ticker.news[:num_news]
+            else:
+                result = getattr(ticker, method.value)()
+            return pprint.pformat(result)
+        except Exception as e:
+            error_message = f"Error retrieving data: {e}"
+            logger.debug(error_message)
+            self.status = error_message
+            raise ToolException(error_message) from e
+
+    def fetch_content(self) -> list[Data]:
+        try:
+            return self._yahoo_finance_tool(
+                self.symbol,
+                YahooFinanceMethod(self.method),
+                self.num_news,
+            )
+        except ToolException:
+            raise
+        except Exception as e:
+            error_message = f"Unexpected error: {e}"
+            logger.debug(error_message)
+            self.status = error_message
+            raise ToolException(error_message) from e
+
+    def _yahoo_finance_tool(
+        self,
+        symbol: str,
+        method: YahooFinanceMethod,
+        num_news: int | None = 5,
+    ) -> list[Data]:
+        ticker = yf.Ticker(symbol)
+        result = self._fetch_yfinance_data(ticker, method, num_news)
+
+        if method == YahooFinanceMethod.GET_NEWS:
+            data_list = [
+                Data(text=f"{article['title']}: {article['link']}", data=article)
+                for article in ast.literal_eval(result)
+            ]
+        else:
+            data_list = [Data(text=result, data={"result": result})]
+
+        return data_list
+
+    def fetch_content_dataframe(self) -> DataFrame:
+        data = self.fetch_content()
+        return DataFrame(data)

lfx/components/youtube/__init__.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from .channel import YouTubeChannelComponent
+    from .comments import YouTubeCommentsComponent
+    from .playlist import YouTubePlaylistComponent
+    from .search import YouTubeSearchComponent
+    from .trending import YouTubeTrendingComponent
+    from .video_details import YouTubeVideoDetailsComponent
+    from .youtube_transcripts import YouTubeTranscriptsComponent
+
+_dynamic_imports = {
+    "YouTubeChannelComponent": "channel",
+    "YouTubeCommentsComponent": "comments",
+    "YouTubePlaylistComponent": "playlist",
+    "YouTubeSearchComponent": "search",
+    "YouTubeTranscriptsComponent": "youtube_transcripts",
+    "YouTubeTrendingComponent": "trending",
+    "YouTubeVideoDetailsComponent": "video_details",
+}
+
+__all__ = [
+    "YouTubeChannelComponent",
+    "YouTubeCommentsComponent",
+    "YouTubePlaylistComponent",
+    "YouTubeSearchComponent",
+    "YouTubeTranscriptsComponent",
+    "YouTubeTrendingComponent",
+    "YouTubeVideoDetailsComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import youtube components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    except (ModuleNotFoundError, ImportError, AttributeError) as e:
+        msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
+        raise AttributeError(msg) from e
+    globals()[attr_name] = result
+    return result
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/youtube/channel.py

@@ -0,0 +1,227 @@
+from typing import Any
+from urllib.error import HTTPError
+
+import pandas as pd
+from googleapiclient.discovery import build
+from googleapiclient.errors import HttpError
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import BoolInput, MessageTextInput, SecretStrInput
+from lfx.schema.dataframe import DataFrame
+from lfx.template.field.base import Output
+
+
+class YouTubeChannelComponent(Component):
+    """A component that retrieves detailed information about YouTube channels."""
+
+    display_name: str = "YouTube Channel"
+    description: str = "Retrieves detailed information and statistics about YouTube channels as a DataFrame."
+    icon: str = "YouTube"
+
+    # Constants
+    CHANNEL_ID_LENGTH = 24
+    QUOTA_EXCEEDED_STATUS = 403
+    NOT_FOUND_STATUS = 404
+    MAX_PLAYLIST_RESULTS = 10
+
+    inputs = [
+        MessageTextInput(
+            name="channel_url",
+            display_name="Channel URL or ID",
+            info="The URL or ID of the YouTube channel.",
+            tool_mode=True,
+            required=True,
+        ),
+        SecretStrInput(
+            name="api_key",
+            display_name="YouTube API Key",
+            info="Your YouTube Data API key.",
+            required=True,
+        ),
+        BoolInput(
+            name="include_statistics",
+            display_name="Include Statistics",
+            value=True,
+            info="Include channel statistics (views, subscribers, videos).",
+        ),
+        BoolInput(
+            name="include_branding",
+            display_name="Include Branding",
+            value=True,
+            info="Include channel branding settings (banner, thumbnails).",
+            advanced=True,
+        ),
+        BoolInput(
+            name="include_playlists",
+            display_name="Include Playlists",
+            value=False,
+            info="Include channel's public playlists.",
+            advanced=True,
+        ),
+    ]
+
+    outputs = [
+        Output(name="channel_df", display_name="Channel Info", method="get_channel_info"),
+    ]
+
+    def _extract_channel_id(self, channel_url: str) -> str:
+        """Extracts the channel ID from various YouTube channel URL formats."""
+        import re
+
+        if channel_url.startswith("UC") and len(channel_url) == self.CHANNEL_ID_LENGTH:
+            return channel_url
+
+        patterns = {
+            "custom_url": r"youtube\.com\/c\/([^\/\n?]+)",
+            "channel_id": r"youtube\.com\/channel\/([^\/\n?]+)",
+            "user": r"youtube\.com\/user\/([^\/\n?]+)",
+            "handle": r"youtube\.com\/@([^\/\n?]+)",
+        }
+
+        for pattern_type, pattern in patterns.items():
+            match = re.search(pattern, channel_url)
+            if match:
+                if pattern_type == "channel_id":
+                    return match.group(1)
+                return self._get_channel_id_by_name(match.group(1), pattern_type)
+
+        return channel_url
+
+    def _get_channel_id_by_name(self, channel_name: str, identifier_type: str) -> str:
+        """Gets the channel ID using the channel name or custom URL."""
+        youtube = None
+        try:
+            youtube = build("youtube", "v3", developerKey=self.api_key)
+
+            if identifier_type == "handle":
+                channel_name = channel_name.lstrip("@")
+
+            request = youtube.search().list(part="id", q=channel_name, type="channel", maxResults=1)
+            response = request.execute()
+
+            if response["items"]:
+                return response["items"][0]["id"]["channelId"]
+
+            error_msg = f"Could not find channel ID for: {channel_name}"
+            raise ValueError(error_msg)
+
+        except (HttpError, HTTPError) as e:
+            error_msg = f"YouTube API error while getting channel ID: {e!s}"
+            raise RuntimeError(error_msg) from e
+        except Exception as e:
+            error_msg = f"Unexpected error while getting channel ID: {e!s}"
+            raise ValueError(error_msg) from e
+        finally:
+            if youtube:
+                youtube.close()
+
+    def _get_channel_playlists(self, youtube: Any, channel_id: str) -> list[dict[str, Any]]:
+        """Gets the public playlists for a channel."""
+        try:
+            playlists_request = youtube.playlists().list(
+                part="snippet,contentDetails",
+                channelId=channel_id,
+                maxResults=self.MAX_PLAYLIST_RESULTS,
+            )
+            playlists_response = playlists_request.execute()
+            playlists = []
+
+            for item in playlists_response.get("items", []):
+                playlist_data = {
+                    "playlist_title": item["snippet"]["title"],
+                    "playlist_description": item["snippet"]["description"],
+                    "playlist_id": item["id"],
+                    "playlist_video_count": item["contentDetails"]["itemCount"],
+                    "playlist_published_at": item["snippet"]["publishedAt"],
+                    "playlist_thumbnail_url": item["snippet"]["thumbnails"]["default"]["url"],
+                }
+                playlists.append(playlist_data)
+
+            return playlists
+        except (HttpError, HTTPError) as e:
+            return [{"error": str(e)}]
+        else:
+            return playlists
+
+    def get_channel_info(self) -> DataFrame:
+        """Retrieves channel information and returns it as a DataFrame."""
+        youtube = None
+        try:
+            # Get channel ID and initialize YouTube API client
+            channel_id = self._extract_channel_id(self.channel_url)
+            youtube = build("youtube", "v3", developerKey=self.api_key)
+
+            # Prepare parts for the API request
+            parts = ["snippet", "contentDetails"]
+            if self.include_statistics:
+                parts.append("statistics")
+            if self.include_branding:
+                parts.append("brandingSettings")
+
+            # Get channel information
+            channel_response = youtube.channels().list(part=",".join(parts), id=channel_id).execute()
+
+            if not channel_response["items"]:
+                return DataFrame(pd.DataFrame({"error": ["Channel not found"]}))
+
+            channel_info = channel_response["items"][0]
+
+            # Build basic channel data
+            channel_data = {
+                "title": [channel_info["snippet"]["title"]],
+                "description": [channel_info["snippet"]["description"]],
+                "custom_url": [channel_info["snippet"].get("customUrl", "")],
+                "published_at": [channel_info["snippet"]["publishedAt"]],
+                "country": [channel_info["snippet"].get("country", "Not specified")],
+                "channel_id": [channel_id],
+            }
+
+            # Add thumbnails
+            for size, thumb in channel_info["snippet"]["thumbnails"].items():
+                channel_data[f"thumbnail_{size}"] = [thumb["url"]]
+
+            # Add statistics if requested
+            if self.include_statistics:
+                stats = channel_info["statistics"]
+                channel_data.update(
+                    {
+                        "view_count": [int(stats.get("viewCount", 0))],
+                        "subscriber_count": [int(stats.get("subscriberCount", 0))],
+                        "hidden_subscriber_count": [stats.get("hiddenSubscriberCount", False)],
+                        "video_count": [int(stats.get("videoCount", 0))],
+                    }
+                )
+
+            # Add branding if requested
+            if self.include_branding:
+                branding = channel_info.get("brandingSettings", {})
+                channel_data.update(
+                    {
+                        "brand_title": [branding.get("channel", {}).get("title", "")],
+                        "brand_description": [branding.get("channel", {}).get("description", "")],
+                        "brand_keywords": [branding.get("channel", {}).get("keywords", "")],
+                        "brand_banner_url": [branding.get("image", {}).get("bannerExternalUrl", "")],
+                    }
+                )
+
+            # Create the initial DataFrame
+            channel_df = pd.DataFrame(channel_data)
+
+            # Add playlists if requested
+            if self.include_playlists:
+                playlists = self._get_channel_playlists(youtube, channel_id)
+                if playlists and "error" not in playlists[0]:
+                    # Create a DataFrame for playlists
+                    playlists_df = pd.DataFrame(playlists)
+                    # Join with main DataFrame
+                    channel_df = pd.concat([channel_df] * len(playlists_df), ignore_index=True)
+                    for column in playlists_df.columns:
+                        channel_df[column] = playlists_df[column].to_numpy()
+
+            return DataFrame(channel_df)
+
+        except (HttpError, HTTPError) as e:
+            return DataFrame(pd.DataFrame({"error": [str(e)]}))
+        finally:
+            if youtube:
+                youtube.close()