Update app.py

app.py

@@ -1,99 +1,42 @@
+import openai
+import re
 import gradio as gr
-import random
 
-import sentence_transformers
-from sentence_transformers import SentenceTransformer
-
-model = SentenceTransformer('distilbert-base-nli-stsb-mean-tokens')
-
-def get_password_strength(password):
-    embeddings = model.encode([password])
-    vector = embeddings[0]
-    strength = int(round(vector.dot(vector) * 100))
-    return strength
-
-def generate_password(length):
-    characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()'
-    password = ''.join(random.choice(characters) for i in range(length))
-    return password
-
-def encrypt_password(password, key):
-    encrypted_password = []
-    for i in range(len(password)):
-        char_code = ord(password[i]) ^ ord(key[i % len(key)])
-        encrypted_password.append(str(char_code))
-    return ','.join(encrypted_password)
-
-def decrypt_password(encrypted_password, key):
-    decrypted_password = []
-    encrypted_char_codes = encrypted_password.split(',')
-    for i in range(len(encrypted_char_codes)):
-        char_code = int(encrypted_char_codes[i]) ^ ord(key[i % len(key)])
-        decrypted_password.append(chr(char_code))
-    return ''.join(decrypted_password)
-
-def password_generator(password_length):
-    password = generate_password(password_length)
-    key = generate_password(password_length)
-    encrypted_password = encrypt_password(password, key)
-    return {'password': password, 'key': key, 'encrypted_password': encrypted_password}
-
-def password_strength(password):
-    return {'password_strength': get_password_strength(password)}
-
-def password_decrypt(encrypted_password, key):
-    password = decrypt_password(encrypted_password, key)
-    return {'password': password}
-
-input_password_length = gr.inputs.Slider(minimum=4, maximum=32, step=1, default=12, label='Password Length')
-input_password = gr.inputs.Textbox(label='Password')
-input_encrypted_password = gr.inputs.Textbox(label='Encrypted Password')
-input_key = gr.inputs.Textbox(label='Key')
-
-output_generated_password = gr.outputs.Textbox(label='Generated Password')
-output_generated_key = gr.outputs.Textbox(label='Generated Key')
-output_encrypted_password = gr.outputs.Textbox(label='Encrypted Password')
-output_password_strength = gr.outputs.Label(label='Password Strength')
-output_decrypted_password = gr.outputs.Textbox(label='Decrypted Password')
-
-interface = gr.Interface(
-    [
-        input_password_length,
-        input_password,
-        input_encrypted_password,
-        input_key,
-        gr.inputs.Button(label='Generate Password'),
-        gr.inputs.Button(label='Check Password Strength'),
-        gr.inputs.Button(label='Decrypt Password'),
+# Define a function to solve math problems
+def solve_math_problem(prompt, api_key):
+    # Set up the OpenAI API credentials
+    openai.api_key = api_key
+
+    # Send the prompt to OpenAI's GPT-3 engine
+    response = openai.Completion.create(
+        engine="davinci",
+        prompt=prompt,
+        max_tokens=100,
+        n=1,
+        stop=None,
+        temperature=0.5,
+    )
+
+    # Extract the answer from the response
+    answer = response.choices[0].text.strip()
+
+    # Remove any non-numeric characters from the answer
+    answer = re.sub("[^0-9\.]", "", answer)
+
+    return float(answer)
+
+# Define the Gradio interface
+iface = gr.Interface(
+    fn=solve_math_problem,
+    inputs=[
+        gr.inputs.Textbox(label="Enter a math problem"),
+        gr.inputs.Textbox(label="Enter your OpenAI API key", type="password")
     ],
-    [
-        output_generated_password,
-        output_generated_key,
-        output_encrypted_password,
-        output_password_strength,
-        output_decrypted_password,
-    ],
-    title='Password Generator and Encryption/Decryption System',
+    outputs=gr.outputs.Textbox(label="Answer"),
+    title="OpenAI Calculator",
+    description="Enter a math problem and let OpenAI solve it for you!",
+    live=True
 )
 
-def generate_password_callback(password_length):
-    result = password_generator(password_length)
-    return [result['password'], result['key'], result['encrypted_password'], None, None]
-
-def password_strength_callback(password):
-    result = password_strength(password)
-    return [None, None, None, f'{result["password_strength"]}%', None]
-
-def password_decrypt_callback(encrypted_password, key):
-    result = password_decrypt(encrypted_password, key)
-    return [None, None, None, None, result['password']]
-
-interface.inputs[4].set_uploadable(False)
-interface.inputs[5].set_uploadable(False)
-interface.inputs[6].set_uploadable(False)
-
-interface.inputs[4].set_action(generate_password_callback)
-interface.inputs[5].set_action(password_strength_callback)
-interface.inputs[6].set_action(password_decrypt_callback)
-
-interface.launch()
+# Launch the Gradio interface
+iface.launch()