Update app.py

app.py

@@ -1,105 +1,99 @@
-import openai
-import transformers
 import gradio as gr
+import random
 
-# Set up the OpenAI API client
-openai.api_key = "YOUR_API_KEY"
-
-# Define the chat function for OpenAI API
-def openai_chat(api_key, model, message):
-    # Check if an API key has been provided
-    if api_key is None:
-        return "Please enter your OpenAI API key and try again."
-    
-    # Set up the OpenAI API request
-    response = openai.Completion.create(
-        engine=model,
-        prompt=message,
-        max_tokens=1024,
-        n=1,
-        stop=None,
-        temperature=0.5,
-        api_key=api_key,
-    )
-    
-    # Extract the bot's response from the API request
-    bot_response = response.choices[0].text.strip()
-    
-    return bot_response
-
-# Define the chat function for Hugging Face API
-def hf_chat(model_name, message):
-    # Load the model and tokenizer
-    model = transformers.pipeline("text-generation", model=model_name)
-    
-    # Generate a response from the model
-    bot_response = model(message, max_length=1024, do_sample=True, temperature=0.7)[0]["generated_text"]
-    
-    return bot_response
-
-# Define the Gradio interface for chatbot
-api_key_input = gr.inputs.Textbox(label="OpenAI API Key", default=None, block="sidebar")
-model_input = gr.inputs.Dropdown(
-    label="Select OpenAI model",
-    choices=["davinci", "curie", "babbage"],
-    default="davinci",
-    block="sidebar"
-)
-hf_model_input = gr.inputs.Dropdown(
-    label="Select Hugging Face model",
-    choices=["microsoft/DialoGPT-large", "Salesforce/codegen-2B-multi", "microsoft/DialoGPT-small"],
-    default="microsoft/DialoGPT-large",
-    block="sidebar"
-)
-mode_input = gr.inputs.Dropdown(
-    label="Select chatbot mode",
-    choices=["OpenAI", "Hugging Face"],
-    default="OpenAI",
-    block="sidebar"
-)
-message_input = gr.inputs.Textbox(label="Enter your message here", block="input")
-output = gr.outputs.Textbox(label="Bot response", block="output")
-
-# Define the chat window
-chat_window = []
-
-def chatbot(chat_window, message, mode, model, hf_model, api_key, send_button, clear_button):
-    if clear_button:
-        chat_window.clear()
-        return "Chat history cleared."
-    if send_button:
-        if message:
-            if mode == "Hugging Face":
-                bot_response = hf_chat(hf_model, message)
-            else:
-                bot_response = openai_chat(api_key, model, message)
-            chat_window.append(("User", message))
-            chat_window.append(("Bot", bot_response))
-    return "\n".join([f"{name}: {text}" for name, text in chat_window])
-
-# Define the Gradio interface for chatbot
-send_button = gr.inputs.Button(label="Send")
-clear_button = gr.inputs.Button(label="Clear Chat History")
-chat_interface = gr.Interface(
-    fn=chatbot,
-    inputs=[
-        message_input,
-        mode_input,
-        model_input,
-        hf_model_input,
-        api_key_input,
-        send_button,
-        clear_button
+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_password_strength = gr.outputs.ProgressBar(label='Password Strength')
+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_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'),
+    ],
+    [
+        output_generated_password,
+        output_generated_key,
+        output_encrypted_password,
+        output_password_strength,
+        output_decrypted_password,
     ],
-    outputs=output,
-    title="Chatbot",
-    description="Enter your message below to chat with an AI",
-    theme="compact",
-    allow_flagging=False,
-    allow_screenshot=False,
-    allow_share=False,
-    layout="vertical"
+    title='Password Generator and Encryption/Decryption System',
 )
 
-# Launch the page
-chat_interface.launch()
+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, 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_callback(generate_password_callback)
+interface.inputs[5].set_callback(password_strength_callback)
+interface.inputs[6].set_callback(password_decrypt_callback)
+
+interface.launch()