ai-parrot 0.3.4__cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

parrot/loaders/youtube.py

@@ -0,0 +1,192 @@
+from typing import Optional, Union
+from pytube import YouTube
+from youtube_transcript_api import NoTranscriptFound
+import torch
+from langchain.docstore.document import Document
+from langchain_community.document_loaders.parsers.audio import (
+    OpenAIWhisperParserLocal
+)
+from langchain_community.document_loaders import YoutubeLoader as YTLoader
+from langchain_community.document_loaders.generic import (
+    GenericLoader
+)
+from langchain_community.document_loaders.blob_loaders.youtube_audio import (
+    YoutubeAudioLoader
+)
+from .video import VideoLoader
+
+
+def extract_video_id(url):
+    parts = url.split("?v=")
+    video_id = parts[1].split("&")[0]
+    return video_id
+
+
+class YoutubeLoader(VideoLoader):
+    """
+    Loader for Youtube videos.
+    """
+    _extension = ['.youtube']
+    encoding = 'utf-8'
+    chunk_size = 768
+
+    def get_video_info(self, url: str) -> dict:
+        yt = YouTube(url)
+        return  {
+            "url": url,
+            "video_id": yt.video_id,
+            "watch_url": yt.watch_url,
+            "embed_url": yt.embed_url,
+            "title": yt.title or "Unknown",
+            "description": yt.description or "Unknown",
+            "view_count": yt.views or 0,
+            #"thumbnail_url": yt.thumbnail_url or "Unknown",
+            "publish_date": yt.publish_date.strftime("%Y-%m-%d %H:%M:%S") if yt.publish_date else "Unknown",
+            # "length": yt.length or 0,
+            "author": yt.author or "Unknown",
+        }
+
+    def load_video(self, url: str, video_title: str, transcript: Optional[Union[str, None]] = None) -> list:
+        # first: load video metadata:
+        video_info = self.get_video_info(url)
+        # Second: load video transcript (if any)
+        if transcript is None:
+            try:
+                documents = []
+                docs = []
+                # first: download video
+                file_path = self.download_video(url, self._video_path)
+                audio_path = file_path.with_suffix('.mp3')
+                transcript_path = file_path.with_suffix('.vtt')
+                # second: extract audio
+                self.extract_audio(file_path, audio_path)
+                transcript_whisper = self.get_whisper_transcript(audio_path)
+                transcript = transcript_whisper['text']
+                # Summarize the transcript
+                try:
+                    summary = self.get_summary_from_text(transcript)
+                except Exception:
+                    summary = ''
+                # Create Two Documents, one is for transcript, second is VTT:
+                metadata = {
+                    "url": f"{url}",
+                    "source": f"{url}",
+                    "index": video_title,
+                    "filename": video_title,
+                    "question": '',
+                    "answer": '',
+                    "source_type": self._source_type,
+                    'type': 'video_transcript',
+                    "summary": f"{summary!s}",
+                    "document_meta": {
+                        "language": self._language,
+                        "title": video_title,
+                        "docinfo": video_info
+                    }
+                }
+                if self.topics:
+                    metadata["document_meta"]['topic_tags'] = self.topics
+                doc = Document(
+                    page_content=transcript,
+                    metadata=metadata
+                )
+                documents.append(doc)
+                # VTT version:
+                transcript = self.transcript_to_vtt(transcript_whisper, transcript_path)
+                if transcript:
+                    doc = Document(
+                        page_content=transcript,
+                        metadata=metadata
+                    )
+                    documents.append(doc)
+                # Saving every dialog chunk as a separate document
+                dialogs = self.transcript_to_blocks(transcript_whisper)
+                for chunk in dialogs:
+                    _meta = {
+                        "index": f"{video_title}:{chunk['id']}",
+                        "document_meta": {
+                            "start": f"{chunk['start_time']}",
+                            "end": f"{chunk['end_time']}",
+                            "id": f"{chunk['id']}",
+                            "language": self._language,
+                            "title": video_title,
+                            "topic_tags": ""
+                        }
+                    }
+                    _info = {**metadata, **_meta}
+                    doc = Document(
+                        page_content=chunk['text'],
+                        metadata=_info
+                    )
+                    docs.append(doc)
+                documents.extend(docs)
+                return documents
+            except Exception:
+                try:
+                    loader = YTLoader.from_youtube_url(
+                        url,
+                        add_video_info=True,
+                        language=[self._language],
+                    )
+                    docs = loader.load()
+                except NoTranscriptFound:
+                    loader = GenericLoader(
+                        YoutubeAudioLoader([url], str(self._video_path)),
+                        OpenAIWhisperParserLocal(
+                            # lang_model='openai/whisper-medium.en',
+                            lang_model='openai/whisper-small.en',
+                            device=self._get_device()
+                        )
+                    )
+                    docs = loader.load()
+                if not docs:
+                    self.logger.warning(
+                        f"Unable to load Youtube Video {url}"
+                    )
+                    return []
+                summary = self.get_summary(
+                    docs
+                )
+                for doc in docs:
+                    doc.metadata['source_type'] = self._source_type
+                    doc.metadata['summary'] = f"{summary!s}"
+                    doc.metadata['index'] = ''
+                    doc.metadata['filename'] = ''
+                    doc.metadata['question'] = ''
+                    doc.metadata['answer'] = ''
+                    doc.metadata['type'] = 'video_transcript'
+                    doc.metadata['document_meta'] = {}
+                    if self.topics:
+                        doc.metadata['document_meta']['topic_tags'] = self.topics
+                    # add video metadata to document metadata:
+                    for key, value in video_info.items():
+                        doc.metadata['document_meta'][key] = f"{value!s}"
+                return docs
+        else:
+            with open(transcript, 'r') as f:
+                transcript = f.read()
+            if transcript:
+                summary = self.get_summary_from_text(transcript)
+                transcript_whisper = None
+                metadata = {
+                    "source": url,
+                    "url": url,
+                    "index": '',
+                    "filename": '',
+                    "question": '',
+                    "answer": '',
+                    "source_type": self._source_type,
+                    'type': 'video_transcript',
+                    'summary': f"{summary!s}",
+                    "document_meta": {
+                        "language": self._language,
+                        "title": video_title
+                    },
+                }
+                if self.topics:
+                    metadata['document_meta']['topic_tags'] = self.topics
+                doc = Document(
+                    page_content=transcript,
+                    metadata=metadata
+                )
+                return [doc]

parrot/manager.py

@@ -0,0 +1,166 @@
+"""
+Chatbot Manager.
+
+Tool for instanciate, managing and interacting with Chatbot through APIs.
+"""
+from typing import Any, Dict, Type
+from importlib import import_module
+from aiohttp import web
+from navconfig.logging import logging
+from .chatbots import (
+    AbstractChatbot,
+    Chatbot
+)
+from .handlers.chat import ChatHandler # , BotHandler
+from .handlers import ChatbotHandler
+from .models import ChatbotModel
+# Manual Load of Copilot Agent:
+from parrot.chatbots.copilot import CopilotAgent
+
+class ChatbotManager:
+    """ChatbotManager.
+
+    Manage chatbots and interact with them through via aiohttp App.
+
+    """
+    app: web.Application = None
+    chatbots: Dict[str, AbstractChatbot] = {}
+
+    def __init__(self) -> None:
+        self.app = None
+        self.chatbots = {}
+        self.logger = logging.getLogger(name='Parrot.Manager')
+
+    def get_chatbot_class(self, class_name: str) -> Type[AbstractChatbot]:
+        """
+        Dynamically import a chatbot class based on the class name from the relative module '.chatbots'.
+        Args:
+        class_name (str): The name of the chatbot class to be imported.
+        Returns:
+        Type[AbstractChatbot]: A chatbot class derived from AbstractChatbot.
+        """
+        module = import_module('.chatbots', __package__)
+        try:
+            return getattr(module, class_name)
+        except AttributeError:
+            raise ImportError(f"No class named '{class_name}' found in the module 'chatbots'.")
+
+    async def load_bots(self, app: web.Application) -> None:
+        """Load all chatbots from DB."""
+        self.logger.info("Loading chatbots from DB...")
+        db = app['database']
+        async with await db.acquire() as conn:
+            ChatbotModel.Meta.connection = conn
+            bots = await ChatbotModel.all()
+            for bot in bots:
+                if bot.bot_type == 'chatbot':
+                    self.logger.notice(
+                        f"Loading chatbot '{bot.name}'..."
+                    )
+                    cls_name = bot.custom_class
+                    if cls_name is None:
+                        class_name = Chatbot
+                    else:
+                        class_name = self.get_chatbot_class(cls_name)
+                    chatbot = class_name(
+                        chatbot_id=bot.chatbot_id,
+                        name=bot.name
+                    )
+                    try:
+                        await chatbot.configure()
+                    except Exception as e:
+                        self.logger.error(
+                            f"Failed to configure chatbot '{chatbot.name}': {e}"
+                        )
+                elif bot.bot_type == 'agent':
+                    self.logger.notice(
+                        f"Loading Agent '{bot.name}'..."
+                    )
+                    # TODO: extract the list of tools from Agent config
+                    try:
+                        tools = CopilotAgent.default_tools()
+                        chatbot = CopilotAgent(
+                            name=bot.name,
+                            llm=bot.llm,
+                            tools=tools
+                        )
+                    except Exception as e:
+                        print('AQUI >>> ', e)
+                        self.logger.error(
+                            f"Failed to configure Agent '{bot.name}': {e}"
+                        )
+                self.add_chatbot(chatbot)
+        self.logger.info(
+            ":: Chatbots loaded successfully."
+        )
+
+    def create_chatbot(self, class_name: Any = None, name: str = None, **kwargs) -> AbstractChatbot:
+        """Create a chatbot and add it to the manager."""
+        if class_name is None:
+            class_name = Chatbot
+        chatbot = class_name(**kwargs)
+        chatbot.name = name
+        self.add_chatbot(chatbot)
+        if 'llm' in kwargs:
+            llm = kwargs['llm']
+            llm_name = llm.pop('name')
+            model = llm.pop('model')
+            llm = chatbot.load_llm(
+                llm_name, model=model, **llm
+            )
+            chatbot.llm = llm
+        return chatbot
+
+    def add_chatbot(self, chatbot: AbstractChatbot) -> None:
+        """Add a chatbot to the manager."""
+        self.chatbots[chatbot.name] = chatbot
+
+    def get_chatbot(self, name: str) -> AbstractChatbot:
+        """Get a chatbot by name."""
+        return self.chatbots.get(name)
+
+    def remove_chatbot(self, name: str) -> None:
+        """Remove a chatbot by name."""
+        del self.chatbots[name]
+
+    def get_chatbots(self) -> Dict[str, AbstractChatbot]:
+        """Get all chatbots."""
+        return self.chatbots
+
+    def get_app(self) -> web.Application:
+        """Get the app."""
+        if self.app is None:
+            raise RuntimeError("App is not set.")
+        return self.app
+
+    def setup(self, app: web.Application) -> web.Application:
+        if isinstance(app, web.Application):
+            self.app = app  # register the app into the Extension
+        else:
+            self.app = app.get_app()  # Nav Application
+        # register signals for startup and shutdown
+        self.app.on_startup.append(self.on_startup)
+        self.app.on_shutdown.append(self.on_shutdown)
+        # Add Manager to main Application:
+        self.app['chatbot_manager'] = self
+        ## Configure Routes
+        router = self.app.router
+        router.add_view(
+            '/api/v1/chat',
+            ChatHandler
+        )
+        router.add_view(
+            '/api/v1/chat/{chatbot_name}',
+            ChatHandler
+        )
+        ChatbotHandler.configure(self.app, '/api/v1/bots')
+        return self.app
+
+    async def on_startup(self, app: web.Application) -> None:
+        """On startup."""
+        # configure all pre-configured chatbots:
+        await self.load_bots(app)
+
+    async def on_shutdown(self, app: web.Application) -> None:
+        """On shutdown."""
+        pass