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

langflow/components/youtube/channel.py

@@ -1,227 +0,0 @@
-from typing import Any
-from urllib.error import HTTPError
-
-import pandas as pd
-from googleapiclient.discovery import build
-from googleapiclient.errors import HttpError
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import BoolInput, MessageTextInput, SecretStrInput
-from langflow.schema.dataframe import DataFrame
-from langflow.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()

langflow/components/youtube/comments.py

@@ -1,231 +0,0 @@
-from contextlib import contextmanager
-
-import pandas as pd
-from googleapiclient.discovery import build
-from googleapiclient.errors import HttpError
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
-from langflow.schema.dataframe import DataFrame
-from langflow.template.field.base import Output
-
-
-class YouTubeCommentsComponent(Component):
-    """A component that retrieves comments from YouTube videos."""
-
-    display_name: str = "YouTube Comments"
-    description: str = "Retrieves and analyzes comments from YouTube videos."
-    icon: str = "YouTube"
-
-    # Constants
-    COMMENTS_DISABLED_STATUS = 403
-    NOT_FOUND_STATUS = 404
-    API_MAX_RESULTS = 100
-
-    inputs = [
-        MessageTextInput(
-            name="video_url",
-            display_name="Video URL",
-            info="The URL of the YouTube video to get comments from.",
-            tool_mode=True,
-            required=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="YouTube API Key",
-            info="Your YouTube Data API key.",
-            required=True,
-        ),
-        IntInput(
-            name="max_results",
-            display_name="Max Results",
-            value=20,
-            info="The maximum number of comments to return.",
-        ),
-        DropdownInput(
-            name="sort_by",
-            display_name="Sort By",
-            options=["time", "relevance"],
-            value="relevance",
-            info="Sort comments by time or relevance.",
-        ),
-        BoolInput(
-            name="include_replies",
-            display_name="Include Replies",
-            value=False,
-            info="Whether to include replies to comments.",
-            advanced=True,
-        ),
-        BoolInput(
-            name="include_metrics",
-            display_name="Include Metrics",
-            value=True,
-            info="Include metrics like like count and reply count.",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(name="comments", display_name="Comments", method="get_video_comments"),
-    ]
-
-    def _extract_video_id(self, video_url: str) -> str:
-        """Extracts the video ID from a YouTube URL."""
-        import re
-
-        patterns = [
-            r"(?:youtube\.com\/watch\?v=|youtu.be\/|youtube.com\/embed\/)([^&\n?#]+)",
-            r"youtube.com\/shorts\/([^&\n?#]+)",
-        ]
-
-        for pattern in patterns:
-            match = re.search(pattern, video_url)
-            if match:
-                return match.group(1)
-
-        return video_url.strip()
-
-    def _process_reply(self, reply: dict, parent_id: str, *, include_metrics: bool = True) -> dict:
-        """Process a single reply comment."""
-        reply_snippet = reply["snippet"]
-        reply_data = {
-            "comment_id": reply["id"],
-            "parent_comment_id": parent_id,
-            "author": reply_snippet["authorDisplayName"],
-            "text": reply_snippet["textDisplay"],
-            "published_at": reply_snippet["publishedAt"],
-            "is_reply": True,
-        }
-        if include_metrics:
-            reply_data["like_count"] = reply_snippet["likeCount"]
-            reply_data["reply_count"] = 0  # Replies can't have replies
-
-        return reply_data
-
-    def _process_comment(
-        self, item: dict, *, include_metrics: bool = True, include_replies: bool = False
-    ) -> list[dict]:
-        """Process a single comment thread."""
-        comment = item["snippet"]["topLevelComment"]["snippet"]
-        comment_id = item["snippet"]["topLevelComment"]["id"]
-
-        # Basic comment data
-        processed_comments = [
-            {
-                "comment_id": comment_id,
-                "parent_comment_id": "",  # Empty for top-level comments
-                "author": comment["authorDisplayName"],
-                "author_channel_url": comment.get("authorChannelUrl", ""),
-                "text": comment["textDisplay"],
-                "published_at": comment["publishedAt"],
-                "updated_at": comment["updatedAt"],
-                "is_reply": False,
-            }
-        ]
-
-        # Add metrics if requested
-        if include_metrics:
-            processed_comments[0].update(
-                {
-                    "like_count": comment["likeCount"],
-                    "reply_count": item["snippet"]["totalReplyCount"],
-                }
-            )
-
-        # Add replies if requested
-        if include_replies and item["snippet"]["totalReplyCount"] > 0 and "replies" in item:
-            for reply in item["replies"]["comments"]:
-                reply_data = self._process_reply(reply, parent_id=comment_id, include_metrics=include_metrics)
-                processed_comments.append(reply_data)
-
-        return processed_comments
-
-    @contextmanager
-    def youtube_client(self):
-        """Context manager for YouTube API client."""
-        client = build("youtube", "v3", developerKey=self.api_key)
-        try:
-            yield client
-        finally:
-            client.close()
-
-    def get_video_comments(self) -> DataFrame:
-        """Retrieves comments from a YouTube video and returns as DataFrame."""
-        try:
-            # Extract video ID from URL
-            video_id = self._extract_video_id(self.video_url)
-
-            # Use context manager for YouTube API client
-            with self.youtube_client() as youtube:
-                comments_data = []
-                results_count = 0
-                request = youtube.commentThreads().list(
-                    part="snippet,replies",
-                    videoId=video_id,
-                    maxResults=min(self.API_MAX_RESULTS, self.max_results),
-                    order=self.sort_by,
-                    textFormat="plainText",
-                )
-
-                while request and results_count < self.max_results:
-                    response = request.execute()
-
-                    for item in response.get("items", []):
-                        if results_count >= self.max_results:
-                            break
-
-                        comments = self._process_comment(
-                            item, include_metrics=self.include_metrics, include_replies=self.include_replies
-                        )
-                        comments_data.extend(comments)
-                        results_count += 1
-
-                    # Get the next page if available and needed
-                    if "nextPageToken" in response and results_count < self.max_results:
-                        request = youtube.commentThreads().list(
-                            part="snippet,replies",
-                            videoId=video_id,
-                            maxResults=min(self.API_MAX_RESULTS, self.max_results - results_count),
-                            order=self.sort_by,
-                            textFormat="plainText",
-                            pageToken=response["nextPageToken"],
-                        )
-                    else:
-                        request = None
-
-                # Convert to DataFrame
-                comments_df = pd.DataFrame(comments_data)
-
-                # Add video metadata
-                comments_df["video_id"] = video_id
-                comments_df["video_url"] = self.video_url
-
-                # Sort columns for better organization
-                column_order = [
-                    "video_id",
-                    "video_url",
-                    "comment_id",
-                    "parent_comment_id",
-                    "is_reply",
-                    "author",
-                    "author_channel_url",
-                    "text",
-                    "published_at",
-                    "updated_at",
-                ]
-
-                if self.include_metrics:
-                    column_order.extend(["like_count", "reply_count"])
-
-                comments_df = comments_df[column_order]
-
-                return DataFrame(comments_df)
-
-        except HttpError as e:
-            error_message = f"YouTube API error: {e!s}"
-            if e.resp.status == self.COMMENTS_DISABLED_STATUS:
-                error_message = "Comments are disabled for this video or API quota exceeded."
-            elif e.resp.status == self.NOT_FOUND_STATUS:
-                error_message = "Video not found."
-
-            return DataFrame(pd.DataFrame({"error": [error_message]}))

langflow/components/youtube/playlist.py

@@ -1,33 +0,0 @@
-from pytube import Playlist  # Ensure you have pytube installed
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import MessageTextInput
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.template.field.base import Output
-
-
-class YouTubePlaylistComponent(Component):
-    display_name = "YouTube Playlist"
-    description = "Extracts all video URLs from a YouTube playlist."
-    icon = "YouTube"  # Replace with a suitable icon
-
-    inputs = [
-        MessageTextInput(
-            name="playlist_url",
-            display_name="Playlist URL",
-            info="URL of the YouTube playlist.",
-            required=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Video URLs", name="video_urls", method="extract_video_urls"),
-    ]
-
-    def extract_video_urls(self) -> DataFrame:
-        playlist_url = self.playlist_url
-        playlist = Playlist(playlist_url)
-        video_urls = [video.watch_url for video in playlist.videos]
-
-        return DataFrame([Data(data={"video_url": url}) for url in video_urls])

langflow/components/youtube/search.py

@@ -1,120 +0,0 @@
-from contextlib import contextmanager
-
-import pandas as pd
-from googleapiclient.discovery import build
-from googleapiclient.errors import HttpError
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import BoolInput, DropdownInput, IntInput, MessageTextInput, SecretStrInput
-from langflow.schema.dataframe import DataFrame
-from langflow.template.field.base import Output
-
-
-class YouTubeSearchComponent(Component):
-    """A component that searches YouTube videos."""
-
-    display_name: str = "YouTube Search"
-    description: str = "Searches YouTube videos based on query."
-    icon: str = "YouTube"
-
-    inputs = [
-        MessageTextInput(
-            name="query",
-            display_name="Search Query",
-            info="The search query to look for on YouTube.",
-            tool_mode=True,
-            required=True,
-        ),
-        SecretStrInput(
-            name="api_key",
-            display_name="YouTube API Key",
-            info="Your YouTube Data API key.",
-            required=True,
-        ),
-        IntInput(
-            name="max_results",
-            display_name="Max Results",
-            value=10,
-            info="The maximum number of results to return.",
-        ),
-        DropdownInput(
-            name="order",
-            display_name="Sort Order",
-            options=["relevance", "date", "rating", "title", "viewCount"],
-            value="relevance",
-            info="Sort order for the search results.",
-        ),
-        BoolInput(
-            name="include_metadata",
-            display_name="Include Metadata",
-            value=True,
-            info="Include video metadata like description and statistics.",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(name="results", display_name="Search Results", method="search_videos"),
-    ]
-
-    @contextmanager
-    def youtube_client(self):
-        """Context manager for YouTube API client."""
-        client = build("youtube", "v3", developerKey=self.api_key)
-        try:
-            yield client
-        finally:
-            client.close()
-
-    def search_videos(self) -> DataFrame:
-        """Searches YouTube videos and returns results as DataFrame."""
-        try:
-            with self.youtube_client() as youtube:
-                search_response = (
-                    youtube.search()
-                    .list(
-                        q=self.query,
-                        part="id,snippet",
-                        maxResults=self.max_results,
-                        order=self.order,
-                        type="video",
-                    )
-                    .execute()
-                )
-
-                results = []
-                for search_result in search_response.get("items", []):
-                    video_id = search_result["id"]["videoId"]
-                    snippet = search_result["snippet"]
-
-                    result = {
-                        "video_id": video_id,
-                        "title": snippet["title"],
-                        "description": snippet["description"],
-                        "published_at": snippet["publishedAt"],
-                        "channel_title": snippet["channelTitle"],
-                        "thumbnail_url": snippet["thumbnails"]["default"]["url"],
-                    }
-
-                    if self.include_metadata:
-                        # Get video details for additional metadata
-                        video_response = youtube.videos().list(part="statistics,contentDetails", id=video_id).execute()
-
-                        if video_response.get("items"):
-                            video_details = video_response["items"][0]
-                            result.update(
-                                {
-                                    "view_count": int(video_details["statistics"]["viewCount"]),
-                                    "like_count": int(video_details["statistics"].get("likeCount", 0)),
-                                    "comment_count": int(video_details["statistics"].get("commentCount", 0)),
-                                    "duration": video_details["contentDetails"]["duration"],
-                                }
-                            )
-
-                    results.append(result)
-
-                return DataFrame(pd.DataFrame(results))
-
-        except HttpError as e:
-            error_message = f"YouTube API error: {e!s}"
-            return DataFrame(pd.DataFrame({"error": [error_message]}))