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

langflow/components/youtube/trending.py

@@ -1,285 +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, SecretStrInput
-from langflow.logging.logger import logger
-from langflow.schema.dataframe import DataFrame
-from langflow.template.field.base import Output
-
-HTTP_FORBIDDEN = 403
-HTTP_NOT_FOUND = 404
-MAX_API_RESULTS = 50
-
-
-class YouTubeTrendingComponent(Component):
-    """A component that retrieves trending videos from YouTube."""
-
-    display_name: str = "YouTube Trending"
-    description: str = "Retrieves trending videos from YouTube with filtering options."
-    icon: str = "YouTube"
-
-    # Dictionary of country codes and names
-    COUNTRY_CODES = {
-        "Global": "US",  # Default to US for global
-        "United States": "US",
-        "Brazil": "BR",
-        "United Kingdom": "GB",
-        "India": "IN",
-        "Japan": "JP",
-        "South Korea": "KR",
-        "Germany": "DE",
-        "France": "FR",
-        "Canada": "CA",
-        "Australia": "AU",
-        "Spain": "ES",
-        "Italy": "IT",
-        "Mexico": "MX",
-        "Russia": "RU",
-        "Netherlands": "NL",
-        "Poland": "PL",
-        "Argentina": "AR",
-    }
-
-    # Dictionary of video categories
-    VIDEO_CATEGORIES = {
-        "All": "0",
-        "Film & Animation": "1",
-        "Autos & Vehicles": "2",
-        "Music": "10",
-        "Pets & Animals": "15",
-        "Sports": "17",
-        "Travel & Events": "19",
-        "Gaming": "20",
-        "People & Blogs": "22",
-        "Comedy": "23",
-        "Entertainment": "24",
-        "News & Politics": "25",
-        "Education": "27",
-        "Science & Technology": "28",
-        "Nonprofits & Activism": "29",
-    }
-
-    inputs = [
-        SecretStrInput(
-            name="api_key",
-            display_name="YouTube API Key",
-            info="Your YouTube Data API key.",
-            required=True,
-        ),
-        DropdownInput(
-            name="region",
-            display_name="Region",
-            options=list(COUNTRY_CODES.keys()),
-            value="Global",
-            info="The region to get trending videos from.",
-        ),
-        DropdownInput(
-            name="category",
-            display_name="Category",
-            options=list(VIDEO_CATEGORIES.keys()),
-            value="All",
-            info="The category of videos to retrieve.",
-        ),
-        IntInput(
-            name="max_results",
-            display_name="Max Results",
-            value=10,
-            info="Maximum number of trending videos to return (1-50).",
-        ),
-        BoolInput(
-            name="include_statistics",
-            display_name="Include Statistics",
-            value=True,
-            info="Include video statistics (views, likes, comments).",
-        ),
-        BoolInput(
-            name="include_content_details",
-            display_name="Include Content Details",
-            value=True,
-            info="Include video duration and quality info.",
-            advanced=True,
-        ),
-        BoolInput(
-            name="include_thumbnails",
-            display_name="Include Thumbnails",
-            value=True,
-            info="Include video thumbnail URLs.",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(name="trending_videos", display_name="Trending Videos", method="get_trending_videos"),
-    ]
-
-    max_results: int
-
-    def _format_duration(self, duration: str) -> str:
-        """Formats ISO 8601 duration to readable format."""
-        import re
-
-        # Remove 'PT' from the start of duration
-        duration = duration[2:]
-
-        hours = 0
-        minutes = 0
-        seconds = 0
-
-        # Extract hours, minutes and seconds
-        time_dict = {}
-        for time_unit in ["H", "M", "S"]:
-            match = re.search(r"(\d+)" + time_unit, duration)
-            if match:
-                time_dict[time_unit] = int(match.group(1))
-
-        if "H" in time_dict:
-            hours = time_dict["H"]
-        if "M" in time_dict:
-            minutes = time_dict["M"]
-        if "S" in time_dict:
-            seconds = time_dict["S"]
-
-        # Format the time string
-        if hours > 0:
-            return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
-        return f"{minutes:02d}:{seconds:02d}"
-
-    @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_trending_videos(self) -> DataFrame:
-        """Retrieves trending videos from YouTube and returns as DataFrame."""
-        try:
-            # Validate max_results
-            if not 1 <= self.max_results <= MAX_API_RESULTS:
-                self.max_results = min(max(1, self.max_results), MAX_API_RESULTS)
-
-            # Use context manager for YouTube API client
-            with self.youtube_client() as youtube:
-                # Get country code
-                region_code = self.COUNTRY_CODES[self.region]
-
-                # Prepare API request parts
-                parts = ["snippet"]
-                if self.include_statistics:
-                    parts.append("statistics")
-                if self.include_content_details:
-                    parts.append("contentDetails")
-
-                # Prepare API request parameters
-                request_params = {
-                    "part": ",".join(parts),
-                    "chart": "mostPopular",
-                    "regionCode": region_code,
-                    "maxResults": self.max_results,
-                }
-
-                # Add category filter if not "All"
-                if self.category != "All":
-                    request_params["videoCategoryId"] = self.VIDEO_CATEGORIES[self.category]
-
-                # Get trending videos
-                request = youtube.videos().list(**request_params)
-                response = request.execute()
-
-                videos_data = []
-                for item in response.get("items", []):
-                    video_data = {
-                        "video_id": item["id"],
-                        "title": item["snippet"]["title"],
-                        "description": item["snippet"]["description"],
-                        "channel_id": item["snippet"]["channelId"],
-                        "channel_title": item["snippet"]["channelTitle"],
-                        "published_at": item["snippet"]["publishedAt"],
-                        "url": f"https://www.youtube.com/watch?v={item['id']}",
-                        "region": self.region,
-                        "category": self.category,
-                    }
-
-                    # Add thumbnails if requested
-                    if self.include_thumbnails:
-                        for size, thumb in item["snippet"]["thumbnails"].items():
-                            video_data[f"thumbnail_{size}_url"] = thumb["url"]
-                            video_data[f"thumbnail_{size}_width"] = thumb.get("width", 0)
-                            video_data[f"thumbnail_{size}_height"] = thumb.get("height", 0)
-
-                    # Add statistics if requested
-                    if self.include_statistics and "statistics" in item:
-                        video_data.update(
-                            {
-                                "view_count": int(item["statistics"].get("viewCount", 0)),
-                                "like_count": int(item["statistics"].get("likeCount", 0)),
-                                "comment_count": int(item["statistics"].get("commentCount", 0)),
-                            }
-                        )
-
-                    # Add content details if requested
-                    if self.include_content_details and "contentDetails" in item:
-                        content_details = item["contentDetails"]
-                        video_data.update(
-                            {
-                                "duration": self._format_duration(content_details["duration"]),
-                                "definition": content_details.get("definition", "hd").upper(),
-                                "has_captions": content_details.get("caption", "false") == "true",
-                                "licensed_content": content_details.get("licensedContent", False),
-                                "projection": content_details.get("projection", "rectangular"),
-                            }
-                        )
-
-                    videos_data.append(video_data)
-
-                # Convert to DataFrame
-                videos_df = pd.DataFrame(videos_data)
-
-                # Organize columns
-                column_order = [
-                    "video_id",
-                    "title",
-                    "channel_id",
-                    "channel_title",
-                    "category",
-                    "region",
-                    "published_at",
-                    "url",
-                    "description",
-                ]
-
-                if self.include_statistics:
-                    column_order.extend(["view_count", "like_count", "comment_count"])
-
-                if self.include_content_details:
-                    column_order.extend(["duration", "definition", "has_captions", "licensed_content", "projection"])
-
-                # Add thumbnail columns at the end if included
-                if self.include_thumbnails:
-                    thumbnail_cols = [col for col in videos_df.columns if col.startswith("thumbnail_")]
-                    column_order.extend(sorted(thumbnail_cols))
-
-                # Reorder columns, including any that might not be in column_order
-                remaining_cols = [col for col in videos_df.columns if col not in column_order]
-                videos_df = videos_df[column_order + remaining_cols]
-
-                return DataFrame(videos_df)
-
-        except HttpError as e:
-            error_message = f"YouTube API error: {e}"
-            if e.resp.status == HTTP_FORBIDDEN:
-                error_message = "API quota exceeded or access forbidden."
-            elif e.resp.status == HTTP_NOT_FOUND:
-                error_message = "Resource not found."
-
-            return DataFrame(pd.DataFrame({"error": [error_message]}))
-
-        except Exception as e:  # noqa: BLE001
-            logger.exception("An unexpected error occurred:")
-            return DataFrame(pd.DataFrame({"error": [str(e)]}))

langflow/components/youtube/video_details.py

@@ -1,263 +0,0 @@
-from contextlib import contextmanager
-
-import googleapiclient
-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 YouTubeVideoDetailsComponent(Component):
-    """A component that retrieves detailed information about YouTube videos."""
-
-    display_name: str = "YouTube Video Details"
-    description: str = "Retrieves detailed information and statistics about YouTube videos."
-    icon: str = "YouTube"
-
-    inputs = [
-        MessageTextInput(
-            name="video_url",
-            display_name="Video URL",
-            info="The URL of the YouTube video.",
-            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 video statistics (views, likes, comments).",
-        ),
-        BoolInput(
-            name="include_content_details",
-            display_name="Include Content Details",
-            value=True,
-            info="Include video duration, quality, and age restriction info.",
-            advanced=True,
-        ),
-        BoolInput(
-            name="include_tags",
-            display_name="Include Tags",
-            value=True,
-            info="Include video tags and keywords.",
-            advanced=True,
-        ),
-        BoolInput(
-            name="include_thumbnails",
-            display_name="Include Thumbnails",
-            value=True,
-            info="Include video thumbnail URLs in different resolutions.",
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(name="video_data", display_name="Video Data", method="get_video_details"),
-    ]
-
-    API_FORBIDDEN = 403
-    VIDEO_NOT_FOUND = 404
-
-    @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 _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 _format_duration(self, duration: str) -> str:
-        """Formats the ISO 8601 duration to a readable format."""
-        import re
-
-        hours = 0
-        minutes = 0
-        seconds = 0
-
-        hours_match = re.search(r"(\d+)H", duration)
-        minutes_match = re.search(r"(\d+)M", duration)
-        seconds_match = re.search(r"(\d+)S", duration)
-
-        if hours_match:
-            hours = int(hours_match.group(1))
-        if minutes_match:
-            minutes = int(minutes_match.group(1))
-        if seconds_match:
-            seconds = int(seconds_match.group(1))
-
-        if hours > 0:
-            return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
-        return f"{minutes:02d}:{seconds:02d}"
-
-    def get_video_details(self) -> DataFrame:
-        """Retrieves detailed information about a YouTube video and returns as DataFrame."""
-        try:
-            with self.youtube_client() as youtube:
-                # Extract video ID
-                video_id = self._extract_video_id(self.video_url)
-
-                # Prepare parts for the API request
-                parts = ["snippet"]
-                if self.include_statistics:
-                    parts.append("statistics")
-                if self.include_content_details:
-                    parts.append("contentDetails")
-
-                # Get video information
-                video_response = youtube.videos().list(part=",".join(parts), id=video_id).execute()
-
-                if not video_response["items"]:
-                    return DataFrame(pd.DataFrame({"error": ["Video not found"]}))
-
-                video_info = video_response["items"][0]
-                snippet = video_info["snippet"]
-
-                # Build video data dictionary
-                video_data = {
-                    "video_id": [video_id],
-                    "url": [f"https://www.youtube.com/watch?v={video_id}"],
-                    "title": [snippet["title"]],
-                    "description": [snippet["description"]],
-                    "published_at": [snippet["publishedAt"]],
-                    "channel_id": [snippet["channelId"]],
-                    "channel_title": [snippet["channelTitle"]],
-                    "category_id": [snippet.get("categoryId", "Unknown")],
-                    "live_broadcast_content": [snippet.get("liveBroadcastContent", "none")],
-                }
-
-                # Add thumbnails if requested
-                if self.include_thumbnails:
-                    for size, thumb in snippet["thumbnails"].items():
-                        video_data[f"thumbnail_{size}_url"] = [thumb["url"]]
-                        video_data[f"thumbnail_{size}_width"] = [thumb.get("width", 0)]
-                        video_data[f"thumbnail_{size}_height"] = [thumb.get("height", 0)]
-
-                # Add tags if requested
-                if self.include_tags and "tags" in snippet:
-                    video_data["tags"] = [", ".join(snippet["tags"])]
-                    video_data["tags_count"] = [len(snippet["tags"])]
-
-                # Add statistics if requested
-                if self.include_statistics and "statistics" in video_info:
-                    stats = video_info["statistics"]
-                    video_data.update(
-                        {
-                            "view_count": [int(stats.get("viewCount", 0))],
-                            "like_count": [int(stats.get("likeCount", 0))],
-                            "favorite_count": [int(stats.get("favoriteCount", 0))],
-                            "comment_count": [int(stats.get("commentCount", 0))],
-                        }
-                    )
-
-                # Add content details if requested
-                if self.include_content_details and "contentDetails" in video_info:
-                    content_details = video_info["contentDetails"]
-                    video_data.update(
-                        {
-                            "duration": [self._format_duration(content_details["duration"])],
-                            "dimension": [content_details.get("dimension", "2d")],
-                            "definition": [content_details.get("definition", "hd").upper()],
-                            "has_captions": [content_details.get("caption", "false") == "true"],
-                            "licensed_content": [content_details.get("licensedContent", False)],
-                            "projection": [content_details.get("projection", "rectangular")],
-                            "has_custom_thumbnails": [content_details.get("hasCustomThumbnail", False)],
-                        }
-                    )
-
-                    # Add content rating if available
-                    if "contentRating" in content_details:
-                        rating_info = content_details["contentRating"]
-                        video_data["content_rating"] = [str(rating_info)]
-
-                # Create DataFrame with organized columns
-                video_df = pd.DataFrame(video_data)
-
-                # Organize columns in logical groups
-                basic_cols = [
-                    "video_id",
-                    "title",
-                    "url",
-                    "channel_id",
-                    "channel_title",
-                    "published_at",
-                    "category_id",
-                    "live_broadcast_content",
-                    "description",
-                ]
-
-                stat_cols = ["view_count", "like_count", "favorite_count", "comment_count"]
-
-                content_cols = [
-                    "duration",
-                    "dimension",
-                    "definition",
-                    "has_captions",
-                    "licensed_content",
-                    "projection",
-                    "has_custom_thumbnails",
-                    "content_rating",
-                ]
-
-                tag_cols = ["tags", "tags_count"]
-
-                thumb_cols = [col for col in video_df.columns if col.startswith("thumbnail_")]
-
-                # Reorder columns based on what's included
-                ordered_cols = basic_cols.copy()
-
-                if self.include_statistics:
-                    ordered_cols.extend([col for col in stat_cols if col in video_df.columns])
-
-                if self.include_content_details:
-                    ordered_cols.extend([col for col in content_cols if col in video_df.columns])
-
-                if self.include_tags:
-                    ordered_cols.extend([col for col in tag_cols if col in video_df.columns])
-
-                if self.include_thumbnails:
-                    ordered_cols.extend(sorted(thumb_cols))
-
-                # Add any remaining columns
-                remaining_cols = [col for col in video_df.columns if col not in ordered_cols]
-                ordered_cols.extend(remaining_cols)
-
-                return DataFrame(video_df[ordered_cols])
-
-        except (HttpError, googleapiclient.errors.HttpError) as e:
-            error_message = f"YouTube API error: {e!s}"
-            if e.resp.status == self.API_FORBIDDEN:
-                error_message = "API quota exceeded or access forbidden."
-            elif e.resp.status == self.VIDEO_NOT_FOUND:
-                error_message = "Video not found."
-
-            return DataFrame(pd.DataFrame({"error": [error_message]}))
-
-        except KeyError as e:
-            return DataFrame(pd.DataFrame({"error": [str(e)]}))

langflow/components/youtube/youtube_transcripts.py

@@ -1,118 +0,0 @@
-import pandas as pd
-import youtube_transcript_api
-from langchain_community.document_loaders import YoutubeLoader
-from langchain_community.document_loaders.youtube import TranscriptFormat
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import DropdownInput, IntInput, MultilineInput
-from langflow.schema.data import Data
-from langflow.schema.dataframe import DataFrame
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-
-
-class YouTubeTranscriptsComponent(Component):
-    """A component that extracts spoken content from YouTube videos as transcripts."""
-
-    display_name: str = "YouTube Transcripts"
-    description: str = "Extracts spoken content from YouTube videos with multiple output options."
-    icon: str = "YouTube"
-    name = "YouTubeTranscripts"
-
-    inputs = [
-        MultilineInput(
-            name="url",
-            display_name="Video URL",
-            info="Enter the YouTube video URL to get transcripts from.",
-            tool_mode=True,
-            required=True,
-        ),
-        IntInput(
-            name="chunk_size_seconds",
-            display_name="Chunk Size (seconds)",
-            value=60,
-            info="The size of each transcript chunk in seconds.",
-        ),
-        DropdownInput(
-            name="translation",
-            display_name="Translation Language",
-            advanced=True,
-            options=["", "en", "es", "fr", "de", "it", "pt", "ru", "ja", "ko", "hi", "ar", "id"],
-            info="Translate the transcripts to the specified language. Leave empty for no translation.",
-        ),
-    ]
-
-    outputs = [
-        Output(name="dataframe", display_name="Chunks", method="get_dataframe_output"),
-        Output(name="message", display_name="Transcript", method="get_message_output"),
-        Output(name="data_output", display_name="Transcript + Source", method="get_data_output"),
-    ]
-
-    def _load_transcripts(self, *, as_chunks: bool = True):
-        """Internal method to load transcripts from YouTube."""
-        loader = YoutubeLoader.from_youtube_url(
-            self.url,
-            transcript_format=TranscriptFormat.CHUNKS if as_chunks else TranscriptFormat.TEXT,
-            chunk_size_seconds=self.chunk_size_seconds,
-            translation=self.translation or None,
-        )
-        return loader.load()
-
-    def get_dataframe_output(self) -> DataFrame:
-        """Provides transcript output as a DataFrame with timestamp and text columns."""
-        try:
-            transcripts = self._load_transcripts(as_chunks=True)
-
-            # Create DataFrame with timestamp and text columns
-            data = []
-            for doc in transcripts:
-                start_seconds = int(doc.metadata["start_seconds"])
-                start_minutes = start_seconds // 60
-                start_seconds %= 60
-                timestamp = f"{start_minutes:02d}:{start_seconds:02d}"
-                data.append({"timestamp": timestamp, "text": doc.page_content})
-
-            return DataFrame(pd.DataFrame(data))
-
-        except (youtube_transcript_api.TranscriptsDisabled, youtube_transcript_api.NoTranscriptFound) as exc:
-            return DataFrame(pd.DataFrame({"error": [f"Failed to get YouTube transcripts: {exc!s}"]}))
-
-    def get_message_output(self) -> Message:
-        """Provides transcript output as continuous text."""
-        try:
-            transcripts = self._load_transcripts(as_chunks=False)
-            result = transcripts[0].page_content
-            return Message(text=result)
-
-        except (youtube_transcript_api.TranscriptsDisabled, youtube_transcript_api.NoTranscriptFound) as exc:
-            error_msg = f"Failed to get YouTube transcripts: {exc!s}"
-            return Message(text=error_msg)
-
-    def get_data_output(self) -> Data:
-        """Creates a structured data object with transcript and metadata.
-
-        Returns a Data object containing transcript text, video URL, and any error
-        messages that occurred during processing. The object includes:
-        - 'transcript': continuous text from the entire video (concatenated if multiple parts)
-        - 'video_url': the input YouTube URL
-        - 'error': error message if an exception occurs
-        """
-        default_data = {"transcript": "", "video_url": self.url, "error": None}
-
-        try:
-            transcripts = self._load_transcripts(as_chunks=False)
-            if not transcripts:
-                default_data["error"] = "No transcripts found."
-                return Data(data=default_data)
-
-            # Combine all transcript parts
-            full_transcript = " ".join(doc.page_content for doc in transcripts)
-            return Data(data={"transcript": full_transcript, "video_url": self.url})
-
-        except (
-            youtube_transcript_api.TranscriptsDisabled,
-            youtube_transcript_api.NoTranscriptFound,
-            youtube_transcript_api.CouldNotRetrieveTranscript,
-        ) as exc:
-            default_data["error"] = str(exc)
-            return Data(data=default_data)

langflow/components/zep/__init__.py

@@ -1,3 +0,0 @@
-from .zep import ZepChatMemory
-
-__all__ = ["ZepChatMemory"]