updates

app.py

@@ -1,25 +1,39 @@
-import streamlit as st
+"""
+Module: main
 
-from controller import Controller
+This module initializes the Streamlit app and sets up the user interface for interacting with the chatbot.
+
+Dependencies:
+- streamlit: The Streamlit library for building web applications.
+- controller: Module providing the Controller class for handling user submissions and managing conversations.
+- view.app_header: Module providing the app_header function for displaying the header section of the app.
+- view.app_sidebar: Module providing the app_sidebar function for displaying the sidebar section of the app.
+- view.app_chat: Module providing the app_chat function for displaying the main chat interface.
 
+Usage:
+- Run the Streamlit app using 'streamlit run main.py' command in the terminal.
+"""
+
+import streamlit as st
+from controller import Controller
 from view.app_header import app_header
 from view.app_sidebar import app_sidebar
 from view.app_chat import app_chat
 
-## Streamlit configuration (holds the session and session history as well)
+# Streamlit configuration (holds the session and session history as well)
 st.set_page_config(
-    page_title="Custom Transformers can realy do anything...",
+    page_title="Custom Transformers can really do anything...",
     page_icon="👋" 
 )
 
-# Create an instance of Controller with agentConfig ## holds all data, config and settings
+# Create an instance of Controller with agentConfig ## holds all data, config, and settings
 controller = Controller()
 
-## sidebar for context & config
+# Sidebar for context & config
 app_sidebar(controller)
 
-## app header
+# App header
 app_header(controller)
 
-## Main content the chat     
-app_chat(controller)
+# Main content - the chat interface
+app_chat(controller)

app_agent_config.py

@@ -1,9 +1,38 @@
-# app_agent_config.py
-from utils.tool_loader import ToolLoader
-from utils.tool_config import tool_names
+"""
+Module: app_agent_config
+
+This module defines the AgentConfig class, which holds configuration settings for the agent.
+
+Dependencies:
+- utils.tool_loader: Module providing the ToolLoader class for loading tools.
+- utils.tool_config: Module providing tool_names for configuration.
+
+Classes:
+- AgentConfig: A class for managing configuration settings for the agent.
+"""
+
+from utils.tool_loader import ToolLoader  # Importing ToolLoader class from utils.tool_loader module
+from utils.tool_config import tool_names   # Importing tool_names from utils.tool_config module
 
 class AgentConfig:
+    """
+    A class for managing configuration settings for the agent.
+    """
     def __init__(self):
+        """
+        Initializes an instance of the AgentConfig class.
+
+        Attributes:
+        - url_endpoint (str): The URL endpoint for the agent.
+        - tool_checkboxes (list): Checkboxes for available tools.
+        - s_tool_checkboxes (list): Selected checkboxes for tools.
+        - image (list): Image data.
+        - document (str): Document data.
+        - log_enabled (bool): Flag indicating whether logging is enabled.
+        - context (str): Context data.
+        - tool_loader (ToolLoader): Instance of ToolLoader class for loading tools.
+        - agent_urls (list): URLs for different agents.
+        """
         self.url_endpoint = ""
         self.tool_checkboxes = []
         self.s_tool_checkboxes = []
@@ -13,8 +42,7 @@ class AgentConfig:
         self.context = ""
         self.tool_loader = ToolLoader(tool_names)
         self.agent_urls = [
-        "https://api-inference.huggingface.co/models/bigcode/starcoder",
-        "https://api-inference.huggingface.co/models/OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5",
-        "https://api-inference.huggingface.co/models/gpt2"
-    ]
-
+            "https://api-inference.huggingface.co/models/bigcode/starcoder",
+            "https://api-inference.huggingface.co/models/OpenAssistant/oasst-sft-4-pythia-12b-epoch-3.5",
+            "https://api-inference.huggingface.co/models/gpt2"
+        ]

controller.py

@@ -1,30 +1,67 @@
+"""
+Module: controller
+
+This module provides a Controller class for handling user submissions and managing conversations.
+
+Dependencies:
+- app_agent_config: Module providing the AgentConfig class for configuring agents.
+- utils.logger: Module providing logging functionalities.
+- model.custom_agent: Module providing the CustomHfAgent class for interacting with Hugging Face models.
+- model.conversation_chain_singleton: Module providing the ConversationChainSingleton class for managing conversation chains.
+
+Classes:
+- Controller: A class for handling user submissions and managing conversations.
+"""
 import os
-from app_agent_config import AgentConfig
-from utils.logger import log_response
-from model.custom_agent import CustomHfAgent
-from model.conversation_chain_singleton import ConversationChainSingleton
+from app_agent_config import AgentConfig  # Importing AgentConfig class from app_agent_config module
+from utils.logger import log_response     # Importing log_response function from utils.logger module
+from model.custom_agent import CustomHfAgent  # Importing CustomHfAgent class from model.custom_agent module
+from model.conversation_chain_singleton import ConversationChainSingleton  # Importing ConversationChainSingleton class from model.conversation_chain_singleton module
 
 def cut_text_after_keyword(text, keyword):
+    """
+    Cuts text after the occurrence of a keyword.
+
+    Args:
+    - text (str): The text to be processed.
+    - keyword (str): The keyword to search for in the text.
+
+    Returns:
+    - str: The processed text.
+    """
     index = text.find(keyword)
     if index != -1:
         return text[:index].strip()
     return text
 
-
 class Controller:
+    """
+    Controller class for handling user submissions and managing conversations.
+    """
     def __init__(self):
-        self.agent_config = AgentConfig()
-        #self.app_config = AppConfig()
+        self.agent_config = AgentConfig()  # Initialize AgentConfig instance
 
-    image = []
-    def handle_submission(self, user_message ):        
+    image = []  # Class attribute for storing image data
+
+    def handle_submission(self, user_message):
+        """
+        Handles user submission and interaction with the Hugging Face model.
+
+        Args:
+        - user_message (str): The message submitted by the user.
+
+        Returns:
+        - str: The response from the Hugging Face model.
+        """
         log_response("User input \n {}".format(user_message))
         log_response("selected_tools \n {}".format(self.agent_config.s_tool_checkboxes))
         log_response("url_endpoint \n {}".format(self.agent_config.url_endpoint))
         log_response("document \n {}".format(self.agent_config.document))
         log_response("image \n {}".format(self.agent_config.image))
-        log_response("context \n {}".format(self.agent_config.context))   
+        log_response("context \n {}".format(self.agent_config.context))
+
         selected_tools = [self.agent_config.tool_loader.tools[idx] for idx, checkbox in enumerate(self.agent_config.s_tool_checkboxes) if checkbox]
+
         agent = CustomHfAgent(
             url_endpoint=self.agent_config.url_endpoint,
             token=os.environ['HF_token'],
@@ -32,22 +69,29 @@ class Controller:
             input_params={"max_new_tokens": 192},
         )
 
+        agent_response = agent.chat(user_message, document=self.agent_config.document, image=self.agent_config.image, context=self.agent_config.context)
+
+        log_response("Agent Response\n {}".format(agent_response))
 
-        angent_respone = agent.chat(user_message,document=self.agent_config.document,image=self.agent_config.image, context = self.agent_config.context)
+        return agent_response
 
-        log_response("Agent Response\n {}".format(angent_respone))
+    def handle_submission_chat(self, user_message, agent_response):
+        """
+        Handles user messages and responses in a conversation chain.
 
-        return angent_respone
+        Args:
+        - user_message (str): The message submitted by the user.
+        - agent_response (str): The response from the agent.
 
-    def handle_submission_chat(self, user_message, angent_respone):
-        # os.environ['HUGGINGFACEHUB_API_TOKEN'] = os.environ['HF_token']
+        Returns:
+        - str: The response from the conversation chain.
+        """
         agent_chat_bot = ConversationChainSingleton().get_conversation_chain()
-        if angent_respone is not None:
-            text = agent_chat_bot.predict(input=user_message + angent_respone)
+        if agent_response is not None:
+            text = agent_chat_bot.predict(input=user_message + agent_response)
         else:
             text = agent_chat_bot.predict(input=user_message)
 
         result = cut_text_after_keyword(text, "Human:")
         print(result)
         return result
-    

model/conversation_chain_singleton.py

@@ -35,43 +35,30 @@ class ConversationChainSingleton:
     _instance = None
 
     def __new__(cls, *args, **kwargs):
-        """
-        Create a new instance of the ConversationChainSingleton class if it doesn't exist.
-
-        Returns:
-        - ConversationChainSingleton: The singleton instance.
-        """
         if not cls._instance:
             cls._instance = super(ConversationChainSingleton, cls).__new__(cls)
             # Initialize your conversation chain here
-            cls._instance.conversation_chain = cls.get_conversation_chain()
+            cls._instance.conversation_chain = cls.get_conversation_chain(cls._instance)
         return cls._instance
 
-    def get_conversation_chain(self):
+    @staticmethod
+    def get_conversation_chain(instance):
         """
-        Get the conversation chain instance.
+        Create a conversational retrieval chain and a language model.
+
+        Args:
+        - instance: The instance of the ConversationChainSingleton class.
 
         Returns:
-        - ConversationChain: The conversation chain instance.
+        - ConversationChain: The initialized conversation chain.
         """
-        return self.conversation_chain
-
-@staticmethod
-def get_conversation_chain():
-    """
-    Create a conversational retrieval chain and a language model.
-
-    Returns:
-    - ConversationChain: The conversation chain instance.
-    """
-    llm = HuggingFaceHub(
-        repo_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
-        model_kwargs={"max_length": 1048, "temperature": 0.2, "max_new_tokens": 256, "top_p": 0.95, "repetition_penalty": 1.0},
-    )
-    # llm = ChatOpenAI(temperature=0, model="gpt-3.5-turbo-0613")
-
-    memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
-    conversation_chain = ConversationChain(
-        llm=llm, verbose=True, memory=memory
-    )
-    return conversation_chain
+        llm = HuggingFaceHub(
+            repo_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
+            model_kwargs={"max_length": 1048, "temperature": 0.2, "max_new_tokens": 256, "top_p": 0.95, "repetition_penalty": 1.0},
+        )
+        memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+        conversation_chain = ConversationChain(
+            llm=llm, verbose=True, memory=memory
+        )
+        return conversation_chain
+    

utils/tool_loader.py

@@ -1,4 +1,17 @@
-# tool_loader.py
+"""
+Module: tool_loader
+
+This module defines the ToolLoader class for loading tools.
+
+Dependencies:
+- logging: Standard Python logging library for logging messages.
+- transformers: Library for natural language processing with pre-trained models.
+- utils.logger: Module providing logging functionalities.
+- utils.tool_config: Module providing tool_names for configuration.
+
+Classes:
+- ToolLoader: A class for loading tools.
+"""
 
 import logging
 from transformers import load_tool
@@ -6,10 +19,31 @@ from utils.logger import log_response  # Import the logger
 from utils.tool_config import tool_names   
 
 class ToolLoader:
+    """
+    A class for loading tools.
+    """
     def __init__(self, tool_names):
+        """
+        Initializes an instance of the ToolLoader class.
+
+        Args:
+        - tool_names (list): A list of tool names to load.
+
+        Returns:
+        - None
+        """
         self.tools = self.load_tools(tool_names)
 
     def load_tools(self, tool_names):
+        """
+        Loads tools based on the provided tool names.
+
+        Args:
+        - tool_names (list): A list of tool names to load.
+
+        Returns:
+        - list: A list of loaded tools.
+        """
         loaded_tools = []
         for tool_name in tool_names:
             try:

view/app_chat.py

@@ -1,82 +1,105 @@
+"""
+Module: app_chat
+
+This module defines the app_chat function for managing user interactions in the chat interface.
+
+Dependencies:
+- streamlit: The Streamlit library for building web applications.
+- pandas: Library for data manipulation and analysis.
+- PIL: Python Imaging Library for image processing.
+- pydub: Library for audio manipulation.
+- controller: Module providing the Controller class for handling user submissions and managing conversations.
+
+Functions:
+- app_chat: Function for managing user interactions in the chat interface.
+"""
+
 import streamlit as st
-import pandas as pd   
-import matplotlib.figure   
- 
+import pandas as pd
 from PIL import Image
 from pydub import AudioSegment
+from controller import Controller
 
 def app_chat(controller):
+    """
+    Function for managing user interactions in the chat interface.
+
+    Args:
+    - controller (Controller): An instance of the Controller class for handling user submissions and managing conversations.
+
+    Returns:
+    - None
+    """
     agent_config = controller.agent_config
+
     # Chat code (user input, agent responses, etc.)
     if "messages" not in st.session_state:
         st.session_state.messages = []
         st.markdown("Hello there! How can I assist you today?")
-  
+
     for message in st.session_state.messages:
         with st.chat_message(message["role"]):
             st.markdown(message["content"])
-    
+
     if user_message := st.chat_input("Enter message"):
         st.chat_message("user").markdown(user_message)
         st.session_state.messages.append({"role": "user", "content": user_message, "avatar": "🤗"})
-        
+
         response = ""
-        chat_respone = ""
+        chat_response = ""
         with st.spinner('Please stand by ...'):
             response = controller.handle_submission(user_message)
 
         with st.chat_message("assistant"):
             if response is None:
-                chat_respone = controller.handle_submission_chat(user_message, response)
-                st.write(chat_respone)
-               # st.warning("The agent's response is None. Please try again. Generate an image of a flying uncormn.")
+                chat_response = controller.handle_submission_chat(user_message, response)
+                st.write(chat_response)
             elif isinstance(response, Image.Image):
                 agent_config.image = response
-                chat_respone = controller.handle_submission_chat(user_message, "No context . Created an image.")
-                st.write(chat_respone)
+                chat_response = controller.handle_submission_chat(user_message, "No context. Created an image.")
+                st.write(chat_response)
                 st.image(response)
             elif isinstance(response, AudioSegment):
                 agent_config.audio = response
-                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool created audio file.")
-                st.write(chat_respone)
+                chat_response = controller.handle_submission_chat(user_message, "Agent Tool created audio file.")
+                st.write(chat_response)
                 st.audio(response)
             elif isinstance(response, int): 
-                chat_respone = controller.handle_submission_chat(user_message, response)
-                st.write(chat_respone)
+                chat_response = controller.handle_submission_chat(user_message, response)
+                st.write(chat_response)
                 st.markdown(response)
             elif isinstance(response, str):
                 if "emojified_text" in response: 
-                    chat_respone = controller.handle_submission_chat(user_message, "Agent Tool created the text with emojies.")
-                    st.write(chat_respone)
+                    chat_response = controller.handle_submission_chat(user_message, "Agent Tool created the text with emojis.")
+                    st.write(chat_response)
                     st.markdown(f"{response['emojified_text']}")
                 else:
-                    chat_respone = controller.handle_submission_chat(user_message, response)
-                    st.write(chat_respone)
+                    chat_response = controller.handle_submission_chat(user_message, response)
+                    st.write(chat_response)
                     st.markdown(response)
             elif isinstance(response, list):
-                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a list")
+                chat_response = controller.handle_submission_chat(user_message, "Agent Tool produced a list")
                 for item in response:
                     st.markdown(item)  # Assuming the list contains strings
-                st.write(chat_respone)
+                st.write(chat_response)
             elif isinstance(response, pd.DataFrame):
-                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a pd.DataFrame")
-                st.write(chat_respone) 
+                chat_response = controller.handle_submission_chat(user_message, "Agent Tool produced a pd.DataFrame")
+                st.write(chat_response) 
                 st.dataframe(response)
-               
             elif isinstance(response, pd.Series):
-                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a pd.Series")
-                st.write(chat_respone) 
+                chat_response = controller.handle_submission_chat(user_message, "Agent Tool produced a pd.Series")
+                st.write(chat_response) 
                 st.table(response.iloc[0:10])
             elif isinstance(response, dict):
-                chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a dict")
-                st.write(chat_respone) 
+                chat_response = controller.handle_submission_chat(user_message, "Agent Tool produced a dict")
+                st.write(chat_response) 
                 st.json(response)
             else:
                 st.warning("Unrecognized response type. Please try again. e.g. Generate an image of a flying horse.")
 
-        st.session_state.messages.append({"role": "assistant", "content": chat_respone, "avatar": "🦖"})
+        st.session_state.messages.append({"role": "assistant", "content": chat_response, "avatar": "🦖"})
         st.session_state.messages.append({"role": "assistant", "content": response, "avatar": "🤖"})
-                  
+              
 """          elif isinstance(response, st.graphics_altair.AltairChart):
                 chat_respone = controller.handle_submission_chat(user_message, "Agent Tool produced a st.graphics_altair.AltairChart")
                 st.write(chat_respone) 

view/app_sidebar.py

@@ -1,3 +1,19 @@
+"""
+Module: app_sidebar
+
+This module defines the app_sidebar function for managing the sidebar interface.
+
+Dependencies:
+- streamlit: The Streamlit library for building web applications.
+- PIL: Python Imaging Library for image processing.
+- numpy: Library for numerical computing.
+- pandas: Library for data manipulation and analysis.
+
+Functions:
+- app_sidebar: Function for managing the sidebar interface.
+- configure: Function for configuring the agent and tools.
+- content_and_context: Function for setting the content and context.
+"""
 
 import streamlit as st
 from PIL import Image 
@@ -5,15 +21,32 @@ import numpy as np
 import pandas as pd
 
 def app_sidebar(controller):
+    """
+    Function for managing the sidebar interface.
 
+    Args:
+    - controller (Controller): An instance of the Controller class for handling user submissions and managing conversations.
+
+    Returns:
+    - None
+    """
     with st.sidebar:
         st.header("Set Tools and Option. ")
         with st.expander("Configure the agent and tools"):
-                configure(controller.agent_config)
+            configure(controller.agent_config)
         with st.expander("Set the Content and Context"):
-                content_and_context(controller.agent_config)
+            content_and_context(controller.agent_config)
 
 def configure(agent_config):
+    """
+    Function for configuring the agent and tools.
+
+    Args:
+    - agent_config (AgentConfig): An instance of the AgentConfig class for managing configuration settings for the agent.
+
+    Returns:
+    - None
+    """
     st.markdown("Change the agent's configuration here.")
 
     agent_config.url_endpoint = st.selectbox("Select Inference URL", agent_config.agent_urls)
@@ -23,6 +56,15 @@ def configure(agent_config):
     agent_config.s_tool_checkboxes = [st.checkbox(f"{tool.name} --- {tool.description} ") for tool in agent_config.tool_loader.tools]
 
 def content_and_context(agent_config):
+    """
+    Function for setting the content and context.
+
+    Args:
+    - agent_config (AgentConfig): An instance of the AgentConfig class for managing configuration settings for the agent.
+
+    Returns:
+    - None
+    """
     agent_config.context = st.text_area("Context")
 
     agent_config.image = st.camera_input("Take a picture")
@@ -31,50 +73,31 @@ def content_and_context(agent_config):
 
     if img_file_buffer is not None:
         image_raw = Image.open(img_file_buffer)
-        #global image
         agent_config.image = np.array(image_raw)
-        ######## 
         st.image(agent_config.image)
         
     uploaded_file = st.file_uploader("Choose a pdf", type='pdf')
     if uploaded_file is not None:
-        # To read file as bytes:
         agent_config.document = uploaded_file.getvalue()  
         st.write(agent_config.document)
         
     uploaded_txt_file = st.file_uploader("Choose a txt", type='txt')
     if uploaded_txt_file is not None:
-        # To read file as bytes:
         agent_config.document = uploaded_txt_file.getvalue() 
         st.write(agent_config.document)
         
     uploaded_csv_file = st.file_uploader("Choose a csv", type='csv')
     if uploaded_csv_file is not None:
-        # To read file as bytes:
         agent_config.document = uploaded_csv_file.getvalue() 
         st.write(agent_config.document)
                     
     uploaded_csv_file = st.file_uploader("Choose audio", type='wav')
     if uploaded_csv_file is not None:
-        # To read file as bytes:
         agent_config.document = uploaded_csv_file.getvalue() 
         st.write(agent_config.document)
         
     uploaded_csv_file = st.file_uploader("Choose video", type='avi')
     if uploaded_csv_file is not None:
-        # To read file as bytes:
         agent_config.document = uploaded_csv_file.getvalue() 
         st.write(agent_config.document)
                 
-        # To convert to a string based IO:
-        #stringio = StringIO(uploaded_file.getvalue().decode("utf-8"))
-        #st.write(stringio)
-    
-        # To read file as string:
-        #string_data = stringio.read()
-        #st.write(string_data)
-    
-        # Can be used wherever a "file-like" object is accepted:
-        dataframe = pd.read_csv(uploaded_file)
-        st.write(dataframe)
-