Upload 6 files

app.py

@@ -0,0 +1,55 @@
+""" Flashcards generator using LLM as a backend """
+
+import streamlit as st
+# from dotenv import find_dotenv, load_dotenv
+
+from flashcard import Flashcards
+# Importing page modules
+from import_export_page import show_import_export_page
+from show_generator_page import show_generator_page
+
+
+def main():
+    """
+    Main function to run the Streamlit app for flashcard generation and management.
+
+    This function initializes the app, setting up the page configuration and session state.
+    It provides navigation between the flashcard generator and import/export pages.
+    """
+
+    # Load environment variables from .env file
+    # load_dotenv(find_dotenv())
+
+    # Set Streamlit page configuration
+    st.set_page_config(page_title="FG", layout="centered", initial_sidebar_state="auto")
+
+    # Initialize flashcards in session state if not already present
+    if "flashcards" not in st.session_state:
+        st.session_state.flashcards = Flashcards([])
+
+    # Initialize expand_all toggle state in session state
+    if "expand_all" not in st.session_state:
+        st.session_state.expand_all = False
+
+    # Define navigation options
+    generator_choice = "🤖 Generator"
+    import_export_choice = "📂 Import/Export"
+
+    # Sidebar for navigation
+    with st.sidebar:
+        # Display application logo
+        st.image(
+            "https://github.com/mikkac/flashcards_generator/blob/main/resources/logo.png?raw=true"
+        )
+        # Radio buttons for page selection
+        choice = st.radio("Select Page", (generator_choice, import_export_choice))
+
+    # Conditional rendering of pages based on user choice
+    if choice == generator_choice:
+        show_generator_page()
+    elif choice == import_export_choice:
+        show_import_export_page()
+
+
+if __name__ == "__main__":
+    main()

constants.py

@@ -0,0 +1,25 @@
+""" File with constants """
+
+languages = [
+    "English",
+    "Spanish",
+    "Polish",
+    "Chinese",
+    "Hindi",
+    "Arabic",
+    "Portuguese",
+    "Bengali",
+    "Russian",
+    "Japanese",
+]
+
+language_to_flag = {
+    "English": "🇬🇧",  # Flag of the United Kingdom
+    "Spanish": "🇪🇸",  # Flag of Spain
+    "Polish": "🇵🇱",  # Flag of Poland
+    "Chinese": "🇨🇳",  # Flag of China
+    "Hindi": "🇮🇳",  # Flag of India
+    "Arabic": "🇸🇦",  # Flag of Saudi Arabia (Arabic is widely spoken in many countries)
+    "Portuguese": "🇵🇹",  # Flag of Portugal
+    "Japanese": "🇯,,🇵"  # Flag of Japan
+}

flashcard.py

@@ -0,0 +1,242 @@
+""" File that contains flashcards' backend """
+import json
+import os
+from dataclasses import asdict, dataclass
+
+# from dotenv import find_dotenv, load_dotenv
+from langchain.chat_models import ChatOpenAI
+from langchain.output_parsers import ResponseSchema, StructuredOutputParser
+from langchain.prompts import ChatPromptTemplate
+
+
+@dataclass
+class Flashcard:
+    """
+    Represents a flashcard containing language translation information.
+
+    Attributes:
+        input_expression (str): The expression in the input language.
+        input_language (str): The language of the input expression.
+        output_expression (str): The translated expression in the output language.
+        output_language (str): The language of the output expression.
+        example_usage (str): An example usage of the input expression in a sentence.
+    """
+
+    input_expression: str
+    input_language: str
+    output_expression: str
+    output_language: str
+    example_usage: str
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "Flashcard":
+        """
+        Creates a Flashcard instance from a dictionary of attributes.
+
+        Args:
+            data (dict): A dictionary containing flashcard attributes.
+
+        Returns:
+            Flashcard: An instance of Flashcard.
+        """
+        return cls(
+            input_expression=data.get("input_expression", None),
+            input_language=data.get("input_language", None),
+            output_expression=data.get("output_expression", None),
+            output_language=data.get("output_language", None),
+            example_usage=data.get("example_usage", None),
+        )
+
+
+@dataclass
+class Flashcards:
+    """
+    Represents a collection of Flashcard instances.
+
+    Attributes:
+        data (list[Flashcard]): A list of Flashcard instances.
+    """
+
+    data: list[Flashcard]
+
+    def as_json(self) -> dict:
+        """
+        Converts the collection of Flashcard instances to a JSON format.
+
+        Returns:
+            dict: A dictionary representing the flashcards in JSON format.
+        """
+        return {"flashcards": [asdict(card) for card in self.data]}
+
+    @classmethod
+    def import_from_json(cls, data: dict) -> "Flashcards":
+        """
+        Creates a Flashcards instance from a JSON file.
+
+        Args:
+            data (file): A JSON file containing flashcard data.
+
+        Returns:
+            Flashcards: An instance of Flashcards containing the imported data.
+        """
+        data = json.load(data)
+        flashcard_objects = [Flashcard(**card) for card in data["flashcards"]]
+        return cls(data=flashcard_objects)
+
+    def __len__(self) -> int:
+        """
+        Returns the number of Flashcard instances in the collection.
+
+        Returns:
+            int: The number of Flashcard instances.
+        """
+        return len(self.data)
+
+
+class FlashcardGeneratorOpenAI: # pylint: disable=R0903
+    """
+    A class to generate language learning flashcards using OpenAI's language model.
+
+    Attributes:
+        chat (ChatOpenAI): An instance of ChatOpenAI for generating flashcards.
+        response_schemas (list): A list of ResponseSchema objects for structuring the response.
+        output_parser (StructuredOutputParser): Parser to structure the output
+                                                from the language model.
+        flashcard_generator_template (str): A template for generating flashcard data.
+        prompt (ChatPromptTemplate): A prompt template for the language model.
+    """
+
+    def __init__(self, api_key: str, llm_model: str = "gpt-3.5-turbo") -> None:
+        """
+        Initializes the FlashcardGeneratorOpenAI class with
+        the specified API key and language model.
+
+        Args:
+            api_key (str): The API key for OpenAI.
+            llm_model (str): The name of the language model to use.
+        """
+        self.chat = ChatOpenAI(temperature=0.0, model=llm_model, api_key=api_key)
+
+        input_expression_schema = ResponseSchema(
+            name="input_expression",
+            type="str",
+            description="Original expression entered by the user, refined"
+            " to create translated_expression.",
+        )
+        input_language_schema = ResponseSchema(
+            name="input_language",
+            type="str",
+            description="Language of the input expression.",
+        )
+        output_expression_schema = ResponseSchema(
+            name="output_expression",
+            type="str",
+            description="Translation of refined expression entered by the user.",
+        )
+        output_language_schema = ResponseSchema(
+            name="output_language",
+            type="str",
+            description="Language of the output expression.",
+        )
+        example_usage_schema = ResponseSchema(
+            name="example_usage",
+            type="str",
+            description="Example usage of input expression, used to give the user some "
+            "example context where it could be used. Limited to one sentence.",
+        )
+
+        response_schemas = [
+            input_expression_schema,
+            input_language_schema,
+            output_expression_schema,
+            output_language_schema,
+            example_usage_schema,
+        ]
+
+        self.output_parser = StructuredOutputParser.from_response_schemas(
+            response_schemas
+        )
+        self.format_instructions = self.output_parser.get_format_instructions()
+
+        self.flashcard_generator_template = """\
+        For the following expression, extract the following information:
+
+        input_expression: Original expression entered by the user, but refined to create translated_expression (for flashcard for language learning). If the expression is too long (more than 10 words), it should be shortened while keeping the sense.
+
+        input_language: Language of the input expression
+
+        output_expression: Refined input expression translated to {output_language} language. Provide 2 alternatives, separated with 'slash' sign (and space before & after the sign).
+
+        example_usage: Example usage of input expression, used to give the user some example context where it could be used. Limited to one sentence.
+
+        input_expression: {input_expression}
+        input_language: {input_language}
+
+        {format_instructions}
+        """
+
+        self.prompt = ChatPromptTemplate.from_template(
+            template=self.flashcard_generator_template
+        )
+
+    def generate_flashcard(
+        self, input_exp: str, input_lang: str, output_lang: str
+    ) -> Flashcard:
+        """
+        Generates a flashcard by translating an input expression from one language to another.
+
+        This method takes an expression in a specified input language, translates it into
+        a specified output language, and then creates a flashcard containing both the original
+        and translated expressions. It uses the ChatOpenAI model to generate the translation
+        and example usage.
+
+        Args:
+            input_expression (str): The expression to be translated.
+            input_language (str): The language of the input expression.
+            output_language (str): The language into which the input expression is to be translated.
+
+        Returns:
+            Flashcard: An instance of the Flashcard class containing the original expression,
+                    its translation, and an example usage in the output language.
+        """
+        messages = self.prompt.format_messages(
+            input_expression=input_exp,
+            input_language=input_lang,
+            output_language=output_lang,
+            format_instructions=self.format_instructions,
+        )
+        response = self.chat(messages)
+        flashcard_dict = self.output_parser.parse(response.content)
+        return Flashcard.from_dict(flashcard_dict)
+
+
+def main():
+    """
+    For debugging purposes only
+    """
+    # _ = load_dotenv(find_dotenv())  # Read local .env file
+
+    generator = FlashcardGeneratorOpenAI(api_key=os.environ["OPENAI_API_KEY"])
+
+    input_expressions = [
+        "cruel",
+        "let someone off the hook",
+        "it absorbed me",
+        "get my thoughts in order",
+        "crude",
+        "pore over",
+    ]
+    input_language = "English"
+    output_language = "Polish"
+
+    flashcards = Flashcards([])
+
+    for input_expression in input_expressions:
+        flashcard = generator.generate_flashcard(
+            input_expression, input_language, output_language
+        )
+        print(flashcard)
+        flashcards.data.append(flashcard)
+
+if __name__ == "__main__":
+    main()

import_export_page.py

@@ -0,0 +1,48 @@
+""" Import/export page definition """
+import json
+
+import streamlit as st
+
+from flashcard import Flashcards
+
+
+def show_import_export_page():
+    """
+    Defines a Streamlit page for importing and exporting flashcards.
+
+    This function creates an interface where users can upload a JSON file
+    to import flashcards, and download a JSON file containing the current
+    flashcards stored in the session state. It handles file upload, file validation,
+    and displays success or error messages accordingly.
+    """
+
+    # Displaying a header for the import section
+    st.header("Import file with flashcards")
+
+    # File uploader widget allowing the user to upload a JSON file
+    flashcards_file = st.file_uploader("Select a file", type="json")
+
+    # Handling the uploaded file
+    if flashcards_file is not None:
+        try:
+            # Attempt to import flashcards from the uploaded file
+            st.session_state.flashcards = Flashcards.import_from_json(flashcards_file)
+            print(st.session_state.flashcards.as_json())  # Debug print statement
+            st.success(f"Imported {len(st.session_state.flashcards)} flashcards!")
+        except json.JSONDecodeError:
+            # Handling invalid JSON files
+            st.error("Invalid JSON file. Please upload a valid JSON file.")
+
+    # Divider to separate import and export sections
+    st.divider()
+
+    # Displaying a header for the export section
+    st.header("Export generated flashcards")
+
+    # Download button to export the flashcards as a JSON file
+    st.download_button(
+        "Download flashcards",
+        data=json.dumps(st.session_state.flashcards.as_json(), indent=4),
+        file_name="flashcards_export.json",
+        mime="application/json",
+    )

requirements.txt

@@ -0,0 +1,4 @@
+streamlit
+langchain
+json
+dataclasses

show_generator_page.py

@@ -0,0 +1,125 @@
+""" Flashcards generator page definition """
+import os
+
+import streamlit as st
+
+from constants import language_to_flag, languages
+from flashcard import Flashcard, FlashcardGeneratorOpenAI
+
+
+def create_flashcard(
+    expression: str, input_language: str, output_language: str
+) -> Flashcard:
+    """
+    Creates a Flashcard instance with given expression and languages.
+
+    Args:
+        expression (str): The expression to be included in the flashcard.
+        input_language (str): The language of the input expression.
+        output_language (str): The target language for translation.
+
+    Returns:
+        Flashcard: A new Flashcard instance.
+    """
+    return Flashcard(
+        input_expression=expression,
+        input_language=input_language,
+        output_expression=None,
+        output_language=output_language,
+        example_usage=None,
+    )
+
+
+def create_toggle(col, original: str, translation: str, example: str):
+    """
+    Creates a toggle (expandable section) in the Streamlit app.
+
+    Args:
+        col: The Streamlit column where the toggle will be placed.
+        original (str): The original expression to be displayed.
+        translation (str): The translated expression.
+        example (str): An example usage of the expression.
+        id (str): A unique identifier for the toggle.
+    """
+    with col:
+        with st.expander(original, expanded=st.session_state.expand_all):
+            st.write(f"**{translation}**\n\n{example}")
+
+
+def show_generator(generator: FlashcardGeneratorOpenAI):
+    """
+    Displays the flashcard generator interface in the Streamlit app.
+
+    Args:
+        generator (FlashcardGeneratorOpenAI): The flashcard generator object.
+    """
+    col1, col2 = st.columns(2)
+    with col1:
+        input_language = st.selectbox(
+            "Select an input language:", languages, index=languages.index("English")
+        )
+    with col2:
+        output_language = st.selectbox(
+            "Select an output language:", languages, index=languages.index("Polish")
+        )
+
+    if "input_language" not in st.session_state:
+        st.session_state.input_language = input_language
+    st.session_state.input_language = input_language
+
+    if "output_language" not in st.session_state:
+        st.session_state.output_language = output_language
+    st.session_state.output_language = output_language
+
+    expression = st.text_input(
+        "Expression",
+        placeholder="Enter an expression and press Enter to generate a flashcard",
+    )
+
+    if expression and not any(
+        flashcard.input_expression == expression
+        for flashcard in st.session_state.flashcards.data
+    ):
+        new_flashcard = generator.generate_flashcard(
+            expression, input_language, output_language
+        )
+        st.session_state.flashcards.data.append(new_flashcard)
+
+
+def show_expand_button():
+    """
+    Displays a button to expand or collapse all flashcards in the Streamlit app.
+    """
+    if st.button("Expand/Collapse All"):
+        st.session_state.expand_all = not st.session_state.expand_all
+
+
+def show_flashcards():
+    """
+    Displays the generated flashcards in the Streamlit app.
+    """
+    if len(st.session_state.flashcards) == 0:
+        st.info("Generate a flashcard or import a file with previously generated ones")
+    else:
+        col1, col2 = st.columns(2)
+        for idx, flashcard in enumerate(st.session_state.flashcards.data):
+            create_toggle(
+                col1 if idx % 2 == 0 else col2,
+                f"{language_to_flag[flashcard.input_language]} {flashcard.input_expression}",
+                f"{language_to_flag[flashcard.output_language]} {flashcard.output_expression}",
+                f"{flashcard.example_usage}",
+            )
+
+
+def show_generator_page():
+    """
+    Sets up the main page of the Streamlit app for the flashcard generator.
+    """
+    generator = FlashcardGeneratorOpenAI(api_key=os.environ["OPENAI_API_KEY"])
+
+    st.title("Flashcards generator")
+    show_generator(generator)
+
+    st.divider()
+    show_expand_button()
+    show_flashcards()