full working ai avatar

Author: ANGELOANTU7

Backend/Narrator.py

@@ -88,16 +88,16 @@ def extract_image_name(questions):
     return important_topics
 
 
-@router.get("/api5")
-async def process_message(message: str):
+@router.get("/narrator")
+async def process_message():
     print("Giving promt to OPENAI...")
-    file_path = 'Local_Storage/Generated_Files/Summarised_Notes/module1_summarized.txt'
+    file_path = 'Local_Storage\Generated_Files\gpt_promt_sum\module2.txt'
     extracted_text = extract_text_from_file(file_path)
     narrate = extract_important_topics(extracted_text)
 
     print(narrate)
     # Save topics to topics.txt
-    with open('Local_Storage/Generated_Files/Narrator_Output/m1.txt', 'w', encoding='utf-8') as file:
+    with open('Local_Storage/Generated_Files/narration.txt', 'w', encoding='utf-8') as file:
         file.write(narrate)
 
     image_name=extract_image_name(narrate)
@@ -116,26 +116,35 @@ async def process_message(message: str):
 
 
 
-    narrate = extract_important_topics(message)
-    with open('Local_Storage/Generated_Files/narration.txt', 'w', encoding='utf-8') as file:
-        file.write(narrate)
-    print(narrate)
-    with open('Local_Storage/Generated_Files/response.txt', 'w') as file:
-        # Truncate the file to remove its contents
-        file.truncate()
-    shutil.rmtree("images")
-
-
-    image_name=extract_image_name(narrate)
-    image_list = image_name.splitlines()
-
-    # Create a directory to store the images
-    os.makedirs("images", exist_ok=True)
-    os.chdir("images")
-
-    # Process the paragraphs and search for related images
-    print(image_list)
-    process_paragraphs(image_list)
-
-    # Return to the parent directory
-    os.chdir("..")
+    while(True):
+        with open('Local_Storage/Generated_Files/response.txt', 'r',encoding='utf-8') as file:
+            content = file.read()
+        if len(content)==0:
+            continue
+        else:
+            if content == "understood":
+                break
+            if content[0]==".":
+                narrate = extract_important_topics(content)
+                with open('Local_Storage/Generated_Files/narration.txt', 'w', encoding='utf-8') as file:
+                    file.write(narrate)
+                print(narrate)
+                with open('Local_Storage/Generated_Files/response.txt', 'w') as file:
+                    # Truncate the file to remove its contents
+                    file.truncate()
+                shutil.rmtree("images")
+
+
+                image_name=extract_image_name(narrate)
+                image_list = image_name.splitlines()
+
+                # Create a directory to store the images
+                os.makedirs("images", exist_ok=True)
+                os.chdir("images")
+
+                # Process the paragraphs and search for related images
+                print(image_list)
+                process_paragraphs(image_list)
+
+                # Return to the parent directory
+                os.chdir("..")

Backend/__pycache__/Narrator.cpython-310.pyc

@@ -4,7 +4,8 @@
 import os
 import azure.cognitiveservices.speech as speechsdk
 from fastapi import UploadFile, APIRouter
-
+import sounddevice as sd
+import soundfile as sf
 # Create an instance of APIRouter
 router = APIRouter()
 
@@ -15,6 +16,22 @@
 speech_config = speechsdk.SpeechConfig(subscription=speech_key, region=service_region)
 speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config)
 
+def record_audio(duration, output_file):
+    # Set the sample rate and number of channels for recording
+    sample_rate = 44100  # CD quality audio
+    channels = 2  # Stereo audio
+
+    # Start recording audio
+    recording = sd.rec(int(duration * sample_rate), samplerate=sample_rate, channels=channels)
+
+    print("Recording audio...")
+    sd.wait()  # Wait until recording is finished
+
+    # Save the recorded audio to a file
+    sf.write(output_file, recording, sample_rate)
+
+    print(f"Audio saved to: {output_file}")
+
 def speech_to_text(audio_file):
     audio_config = speechsdk.audio.AudioConfig(filename=audio_file)
     speech_recognizer = speechsdk.SpeechRecognizer(speech_config=speech_config, audio_config=audio_config)
@@ -28,13 +45,23 @@ def speech_to_text(audio_file):
 
     return transcript
 
-@router.post("/api5")
-async def convert_speech_to_text(file: UploadFile):
-    file_path = f"audio_files/{file.filename}"
-    os.makedirs("audio_files", exist_ok=True)
-    with open(file_path, "wb") as audio:
-        audio.write(await file.read())
+@router.get("/api5")
+def convert_speech_to_text():
+    print("recording..")
+    duration = 5  # Recording duration in seconds
+    output_file = "Local_Storage/Audio/recorded_audio.wav"  # Output file name
+
+    record_audio(duration, output_file)
+    file_path = "Local_Storage/Audio/recorded_audio.wav"
+
 
     transcript = speech_to_text(file_path)
+    transcript="."+transcript
+    
+        # Save the transcript to a text file
+    transcript_file = "Local_Storage/Generated_Files/response.txt"
+    with open(transcript_file, "w") as f:
+        f.write(transcript)
 
-    return {"transcript": transcript}
+    
+    return transcript

Backend/__pycache__/speech_text.cpython-310.pyc

@@ -6,7 +6,7 @@
 
 @router.get('/api6')
 async def get_text_from_file():
-    with open('input.txt', 'r') as file:
+    with open('Local_Storage/Generated_Files/narration.txt', 'r') as file:
         file_text = file.read(200)
     return JSONResponse(content={"blendData": file_text})
 

Backend/__pycache__/texttoAIvideo.cpython-310.pyc

@@ -1,15 +1,19 @@
-Hello, let's talk about digital electronics and specifically about combinational and sequential circuits. Digital circuits are of two types: combinational circuits and sequential circuits. Combinational circuits only depend on the present inputs, while sequential circuits depend on both the present and past inputs.
+Hello! Today we will be discussing digital electronics and specifically focusing on combinational and sequential circuits, as well as adder circuits. Do you have any questions before we begin?
 
-To design a digital circuit, we follow a procedure that involves six steps: we start by stating the problem, then we determine the number of available input and required output variables, assign letter symbols to them, create a truth table that shows their relationship, simplify the Boolean function for each output, and finally draw the logic diagram.
+No? Okay, let's start. The output of a combinational circuit depends only on its present inputs, while the output of a sequential circuit depends on both its present and past inputs. Digital circuits are of two types: combinational circuits and sequential circuits.
 
-For the most basic arithmetic operation, addition, we use adder circuits. There are two types of adder circuits: half-adder and full-adder. The half-adder uses two-input NOR gates to add two binary digits, while the full-adder adds two bits and a carry, and outputs a sum bit and a carrying bit. We can realize a full-adder circuit using an XOR gate and two AND gates.
+Now let's move on to adder circuits. The most basic arithmetic operation is the addition of two binary digits. The logic gates accept signals from the inputs and generate signals to the outputs. They are called adder circuits, which are of two types: half-adder and full-adder.
 
-If we want to subtract one bit from another, we can use a half-subtractor or a full-subtractor. The full-subtractor is a combinational circuit with three inputs and two outputs, and we can realize it with XOR gates and AOI gates. 
+The truth table and block diagram of a half-adder are shown below. Realization using AOI logic is possible using one X-OR gate and one AND gate as shown in Figure 7.3a. The full-adder circuit can be realized by using one gate and the other using a single AND gate. The full-adder circuit is a combinational circuit that performs the addition of three bits (two significant bits).
 
-If we want to add two binary numbers in parallel form, we use an n-bit parallel adder which consists of full adders connected in a chain. The carry-out of each full-adder is the carry-in to the next stage in a ripple carry adder. The subtraction of two binary numbers can be achieved by taking the 2's complement of one of them and adding it to the other.
+The Full-Adder adds the bits A and B and the carry-in C in and outputs the sum bit S. The Full-Adder adds the bit A and A and C in the previous column called the carry in C in, the carry out the other bit called the carrying-in-Cin.
 
-We can speed up the addition process with a look-ahead-carry adder, which examines all the input bits simultaneously and generates the carry-in bits for all the stages simultaneously. The carry-in to each stage is the carry-out of the previous stage, and we get the following Boolean expressions for the final sum and carry outputs of the nth stage: Pn, Cn, P_, Pn-Cn-Sn, P-Sn, and C-Sn.
+And you can also use a half-subtractor as a combinational circuit that subtracts one bit from the other and produces the difference. It also has an output to specify if a 1 has been borrowed.
 
-For code conversion, we use a logic circuit called a code converter that converts a bit-pattern representing numbers from one code to another code. For example, a 4-bit binary-to-Gray-code conversion circuit outputs a Gray-type code for a 4-bit binary input. We can also use a decoder to convert an N-bit-binary input code into M output lines, where only one output line is activated for each possible combination of inputs. Conversely, an encoder does the opposite of decoding, taking decimal digits and/or alphabetic characters and outputting the coded representations.
+An n-bit parallel adder is a digital circuit that adds two binary numbers in parallel form. It consists of full adders connected in a chain, with the output carry of each full-adder connected to the input carry of the next full-adder in the chain.
 
-Finally, we discussed a magnitude comparator, which is a logic circuit that compares two quantities and gives an output signal indicating whether the two input quantities are equal or not. It compares the binary representations of the input quantities and gives the result of A=B, A>B, or A<B.
+The subtraction A - B can be done by taking the 2's complement of B and adding it to A. The subtracted bit is not valid until after the cumulative propagation of two full adders (FA, and FA), and so on. The total sum (the parallel output) of a 4-bit binary adder-subtractor is not. 
+
+The look-ahead-carry adder speeds up the process by eliminating this ripple carry delay. It examines all the input bits simultaneously and also generates the carry-in bits for all the stages simultaneously. The method of speeding up the addition process is based on the two additional functions of the full-adder, called the carry generate and carry-propagate functions.
+
+Do you understand everything so far? Any questions or things you want me to explain more?

Backend/speech_text.py

@@ -1,11 +1,14 @@
-Sure, a truth table is a tool used in logic to analyze the relationships between propositions. It consists of columns representing the different propositions and their possible truth values, as well as a final column representing the resulting truth value of the entire expression. 
+Sure! A truth table is a way of representing the outcomes of logical expressions. It lists all possible combinations of input values and their corresponding output values. The input variables in a truth table are usually denoted as "P," "Q," and so on, while the output values are usually represented as "T" or "F" for true or false.
 
-For example, let's say we have two propositions, P and Q. Each proposition can have one of two possible truth values - true or false. We can use a truth table to analyze the different possible combinations of truth values for P and Q and determine the truth value of the logical expression P AND Q, which represents the conjunction of the two propositions.
+For example, let's consider the logical expression "P OR Q." The truth table for this expression would have two input columns, one for "P" and one for "Q," and one output column for the result of the expression. The truth table would list all possible combinations of "P" and "Q," and then determine whether the expression is true or false for each combination.
 
-So, we would start by creating a table with two columns, one for P and one for Q. Then, we would fill in each row with a different combination of truth values for P and Q - true/false, true/true, false/false, and false/true. 
+So, for the "P OR Q" expression, the truth table would look like this:
 
-Next, we would add a third column representing the truth value of the expression P AND Q. To determine the truth value of this expression for each row, we would simply apply the AND operator to the truth values of P and Q for that row. 
+P   Q   P OR Q
+-------------
+T   T     T
+T   F     T
+F   T     T
+F   F     F
 
-After completing all the rows, we would have a complete truth table showing all the possible truth values for the expression P AND Q, given different truth values for P and Q. This can help us see patterns and relationships between different propositions, and is a powerful tool in understanding logical statements. 
-
-Does that help clarify the concept of truth tables for you?
+Does that make sense? Do you have any questions or need further clarification?

Backend/texttoAIvideo.py

@@ -0,0 +1,24 @@
+import sounddevice as sd
+import soundfile as sf
+
+def record_audio(duration, output_file):
+    # Set the sample rate and number of channels for recording
+    sample_rate = 44100  # CD quality audio
+    channels = 2  # Stereo audio
+
+    # Start recording audio
+    recording = sd.rec(int(duration * sample_rate), samplerate=sample_rate, channels=channels)
+
+    print("Recording audio...")
+    sd.wait()  # Wait until recording is finished
+
+    # Save the recorded audio to a file
+    sf.write(output_file, recording, sample_rate)
+
+    print(f"Audio saved to: {output_file}")
+
+# Example usage
+duration = 5  # Recording duration in seconds
+output_file = "Local_Storage/Audio/recorded_audio.wav"  # Output file name
+
+record_audio(duration, output_file)