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

langflow/components/wikipedia/wikipedia.py

@@ -1,53 +0,0 @@
-from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import BoolInput, IntInput, MessageTextInput, MultilineInput
-from langflow.io import Output
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-
-
-class WikipediaComponent(Component):
-    display_name = "Wikipedia"
-    description = "Call Wikipedia API."
-    icon = "Wikipedia"
-
-    inputs = [
-        MultilineInput(
-            name="input_value",
-            display_name="Input",
-            tool_mode=True,
-        ),
-        MessageTextInput(name="lang", display_name="Language", value="en"),
-        IntInput(name="k", display_name="Number of results", value=4, required=True),
-        BoolInput(name="load_all_available_meta", display_name="Load all available meta", value=False, advanced=True),
-        IntInput(
-            name="doc_content_chars_max", display_name="Document content characters max", value=4000, advanced=True
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
-    ]
-
-    def run_model(self) -> DataFrame:
-        return self.fetch_content_dataframe()
-
-    def _build_wrapper(self) -> WikipediaAPIWrapper:
-        return WikipediaAPIWrapper(
-            top_k_results=self.k,
-            lang=self.lang,
-            load_all_available_meta=self.load_all_available_meta,
-            doc_content_chars_max=self.doc_content_chars_max,
-        )
-
-    def fetch_content(self) -> list[Data]:
-        wrapper = self._build_wrapper()
-        docs = wrapper.load(self.input_value)
-        data = [Data.from_document(doc) for doc in docs]
-        self.status = data
-        return data
-
-    def fetch_content_dataframe(self) -> DataFrame:
-        data = self.fetch_content()
-        return DataFrame(data)

langflow/components/wolframalpha/__init__.py

@@ -1,3 +0,0 @@
-from .wolfram_alpha_api import WolframAlphaAPIComponent
-
-__all__ = ["WolframAlphaAPIComponent"]

langflow/components/wolframalpha/wolfram_alpha_api.py

@@ -1,54 +0,0 @@
-from langchain_community.utilities.wolfram_alpha import WolframAlphaAPIWrapper
-
-from langflow.base.langchain_utilities.model import LCToolComponent
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import MultilineInput, SecretStrInput
-from langflow.io import Output
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-
-
-class WolframAlphaAPIComponent(LCToolComponent):
-    display_name = "WolframAlpha API"
-    description = """Enables queries to WolframAlpha for computational data, facts, and calculations across various \
-topics, delivering structured responses."""
-    name = "WolframAlphaAPI"
-
-    outputs = [
-        Output(display_name="DataFrame", name="dataframe", method="fetch_content_dataframe"),
-    ]
-
-    inputs = [
-        MultilineInput(
-            name="input_value", display_name="Input Query", info="Example query: 'What is the population of France?'"
-        ),
-        SecretStrInput(name="app_id", display_name="App ID", required=True),
-    ]
-
-    icon = "WolframAlphaAPI"
-
-    def run_model(self) -> DataFrame:
-        return self.fetch_content_dataframe()
-
-    def build_tool(self) -> Tool:
-        wrapper = self._build_wrapper()
-        return Tool(name="wolfram_alpha_api", description="Answers mathematical questions.", func=wrapper.run)
-
-    def _build_wrapper(self) -> WolframAlphaAPIWrapper:
-        return WolframAlphaAPIWrapper(wolfram_alpha_appid=self.app_id)
-
-    def fetch_content(self) -> list[Data]:
-        wrapper = self._build_wrapper()
-        result_str = wrapper.run(self.input_value)
-        data = [Data(text=result_str)]
-        self.status = data
-        return data
-
-    def fetch_content_dataframe(self) -> DataFrame:
-        """Convert the WolframAlpha results to a DataFrame.
-
-        Returns:
-            DataFrame: A DataFrame containing the query results.
-        """
-        data = self.fetch_content()
-        return DataFrame(data)

langflow/components/xai/__init__.py

@@ -1,32 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.components._importing import import_mod
-
-if TYPE_CHECKING:
-    from langflow.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__)

langflow/components/xai/xai.py

@@ -1,167 +0,0 @@
-import requests
-from langchain_openai import ChatOpenAI
-from pydantic.v1 import SecretStr
-from typing_extensions import override
-
-from langflow.base.models.model import LCModelComponent
-from langflow.field_typing import LanguageModel
-from langflow.field_typing.range_spec import RangeSpec
-from langflow.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._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

langflow/components/yahoosearch/__init__.py

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

langflow/components/yahoosearch/yahoo.py

@@ -1,137 +0,0 @@
-import ast
-import pprint
-from enum import Enum
-
-import yfinance as yf
-from langchain_core.tools import ToolException
-from pydantic import BaseModel, Field
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import DropdownInput, IntInput, MessageTextInput
-from langflow.io import Output
-from langflow.logging.logger import logger
-from langflow.schema.data import Data
-from langflow.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)

langflow/components/youtube/__init__.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from langflow.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__)