Spaces:
Running
Running
# Text to Vedio | |
# import torch | |
# from diffusers import DiffusionPipeline, DPMSolverMultistepScheduler | |
# from diffusers.utils import export_to_video | |
# import streamlit as st | |
# import numpy as np | |
# # Title and User Input | |
# st.title("Text-to-Video with Streamlit") | |
# prompt = st.text_input("Enter your text prompt:", "Spiderman is surfing") | |
# # Button to trigger generation | |
# if st.button("Generate Video"): | |
# # Ensure you have 'accelerate' version 0.17.0 or higher | |
# import accelerate | |
# if accelerate.__version__ < "0.17.0": | |
# st.warning("Please upgrade 'accelerate' to version 0.17.0 or higher for CPU offloading.") | |
# else: | |
# with st.spinner("Generating video..."): | |
# # Define the pipeline for image generation | |
# pipe = DiffusionPipeline.from_pretrained("damo-vilab/text-to-video-ms-1.7b", | |
# torch_dtype=torch.float16, variant="fp16", device="cpu") | |
# pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config) | |
# pipe.enable_model_cpu_offload() | |
# # Generate video frames | |
# video_frames = pipe(prompt, num_inference_steps=25).frames | |
# # Create dummy frames for testing (replace with actual manipulation later) | |
# dummy_frames = [np.ones((256, 256, 3), dtype=np.uint8) for _ in range(20)] | |
# # Export to video | |
# video_path = export_to_video(dummy_frames) | |
# # Display the video in the Streamlit app | |
# st.video(video_path) | |
# Text to 3D | |
# import streamlit as st | |
# import torch | |
# from diffusers import ShapEPipeline | |
# from diffusers.utils import export_to_gif | |
# from PIL import Image | |
# import numpy as np | |
# # import PyTorch | |
# # Model loading (Ideally done once at the start for efficiency) | |
# ckpt_id = "openai/shap-e" | |
# @st.cache_resource # Caches the model for faster subsequent runs | |
# def process_image_for_pil(image): | |
# if isinstance(image, torch.Tensor): | |
# # Your PyTorch conversion logic here (with correct indentation) | |
# # elif isinstance(image, np.ndarray): | |
# # Your Numpy conversion logic here (with correct indentation) | |
# image_array = image.astype('uint8') # Assuming 8-bit conversion is needed | |
# return Image.fromarray(image_array) | |
# else: | |
# raise TypeError("Unsupported image format. Please provide conversion logic.") | |
# test_image = np.random.randint(0, 256, size=(256, 256, 3), dtype=np.uint8) # Placeholder image | |
# result = process_image_for_pil(test_image) | |
# def should_resize(image): # Add 'image' as an argument | |
# """Determines whether to resize images (replace with your own logic)""" | |
# if image.width > 512 or image.height > 512: | |
# return True | |
# else: | |
# return False | |
# def load_model(): | |
# return ShapEPipeline.from_pretrained(ckpt_id).to("cuda") | |
# pipe = load_model() | |
# # App Title | |
# st.title("Shark 3D Image Generator") | |
# # User Inputs | |
# prompt = st.text_input("Enter your prompt:", "a shark") | |
# guidance_scale = st.slider("Guidance Scale", 0.0, 20.0, 15.0, step=0.5) | |
# # Generate and Display Images | |
# if st.button("Generate"): | |
# with st.spinner("Generating images..."): | |
# images = pipe(prompt, guidance_scale=guidance_scale, num_inference_steps=64).images | |
# # ... (Process images for PIL conversion) | |
# # Resize Images (Optional) | |
# pil_images = [] # Modified to store resized images if needed | |
# for image in images: | |
# processed_image = process_image_for_pil(image) | |
# if should_resize(processed_image): # Pass image to should_resize | |
# resized_image = processed_image.resize((256, 256)) | |
# pil_images.append(resized_image) | |
# else: | |
# pil_images.append(processed_image) # Append without resizing | |
# gif_path = export_to_gif(pil_images, "shark_3d.gif") | |
# st.image(pil_images[0]) | |
# st.success("GIF saved as shark_3d.gif") | |
# # Visual Qa | |
# import streamlit as st | |
# import requests | |
# from PIL import Image | |
# from transformers import BlipProcessor, BlipForQuestionAnswering | |
# # Model Loading | |
# processor = BlipProcessor.from_pretrained("Salesforce/blip-vqa-capfilt-large") | |
# model = BlipForQuestionAnswering.from_pretrained("Salesforce/blip-vqa-capfilt-large") | |
# # Streamlit App Structure | |
# st.title("Visual Question Answering ") | |
# def get_image(): | |
# img_url = st.text_input("Enter Image URL", value='https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg') | |
# if img_url: | |
# raw_image = Image.open(requests.get(img_url, stream=True).raw).convert('RGB') | |
# st.image(raw_image) | |
# return raw_image | |
# def process_vqa(image, question): | |
# if image and question: | |
# inputs = processor(image, question, return_tensors="pt") | |
# output = model.generate(**inputs) | |
# answer = processor.decode(output[0], skip_special_tokens=True) | |
# st.write("Answer:", answer) | |
# # User Input | |
# image = get_image() | |
# question = st.text_input("Ask your question about the image:") | |
# # Process Question and Generate Answer | |
# process_vqa(image, question) | |
# # Chat with pdf | |
# import gradio as gr | |
# import streamlit as st | |
# from langchain.embeddings.openai import OpenAIEmbeddings | |
# from langchain.text_splitter import CharacterTextSplitter | |
# from langchain.vectorstores import Chroma | |
# from langchain.chains import ConversationalRetrievalChain | |
# from langchain.chat_models import ChatOpenAI | |
# from langchain.document_loaders import PyPDFLoader | |
# import os | |
# import fitz | |
# from PIL import Image | |
# # Global variables | |
# COUNT, N = 0, 0 | |
# chat_history = [] | |
# chain = None # Initialize chain as None | |
# # Function to set the OpenAI API key | |
# def set_apikey(api_key): | |
# os.environ['OPENAI_API_KEY'] = api_key | |
# return disable_box | |
# # Function to enable the API key input box | |
# def enable_api_box(): | |
# return enable_box | |
# # Function to add text to the chat history | |
# def add_text(history, text): | |
# if not text: | |
# raise gr.Error('Enter text') | |
# history = history + [(text, '')] | |
# return history | |
# # Function to process the PDF file and create a conversation chain | |
# def process_file(file): | |
# global chain | |
# if 'OPENAI_API_KEY' not in os.environ: | |
# raise gr.Error('Upload your OpenAI API key') | |
# # Replace with your actual PDF processing logic | |
# loader = PyPDFLoader(file.name) | |
# documents = loader.load() | |
# embeddings = OpenAIEmbeddings() | |
# pdfsearch = Chroma.from_documents(documents, embeddings) | |
# chain = ConversationalRetrievalChain.from_llm(ChatOpenAI(temperature=0.3), | |
# retriever=pdfsearch.as_retriever(search_kwargs={"k": 1}), | |
# return_source_documents=True) | |
# return chain | |
# # Function to generate a response based on the chat history and query | |
# def generate_response(history, query, pdf_upload): | |
# global COUNT, N, chat_history, chain | |
# if not pdf_upload: | |
# raise gr.Error(message='Upload a PDF') | |
# if COUNT == 0: | |
# chain = process_file(pdf_upload) | |
# COUNT += 1 | |
# # Replace with your LangChain logic to generate a response | |
# result = chain({"question": query, 'chat_history': chat_history}, return_only_outputs=True) | |
# chat_history += [(query, result["answer"])] | |
# N = list(result['source_documents'][0])[1][1]['page'] # Adjust as needed | |
# for char in result['answer']: | |
# history[-1][-1] += char | |
# return history, '' | |
# # Function to render a specific page of a PDF file as an image | |
# def render_file(file): | |
# global N | |
# doc = fitz.open(file.name) | |
# page = doc[N] | |
# pix = page.get_pixmap(matrix=fitz.Matrix(300/72, 300/72)) | |
# image = Image.frombytes('RGB', [pix.width, pix.height], pix.samples) | |
# return image | |
# # Function to render initial content from the PDF | |
# def render_first(pdf_file): | |
# # Replace with logic to process the PDF and generate an initial image | |
# image = Image.new('RGB', (600, 400), color = 'white') # Placeholder | |
# return image | |
# # Streamlit & Gradio Interface | |
# st.title("PDF-Powered Chatbot") | |
# with st.container(): | |
# gr.Markdown(""" | |
# <style> | |
# .image-container { height: 680px; } | |
# </style> | |
# """) | |
# with gr.Blocks() as demo: | |
# pdf_upload1 = gr.UploadButton("📁 Upload PDF 1", file_types=[".pdf"]) # Define pdf_upload1 | |
# # ... (rest of your interface creation) | |
# txt = gr.Textbox(label="Enter your query", placeholder="Ask a question...") | |
# submit_btn = gr.Button('Submit') | |
# @submit_btn.click() | |
# def on_submit(): | |
# add_text(chatbot, txt) | |
# generate_response(chatbot, txt, pdf_upload1) # Use pdf_upload1 here | |
# render_file(pdf_upload1) # Use pdf_upload1 here | |
# if __name__ == "__main__": | |
# gr.Interface( | |
# fn=generate_response, | |
# inputs=[ | |
# "file", # Define pdf_upload1 | |
# "text", # Define chatbot output | |
# "text" # Define txt | |
# ], | |
# outputs=[ | |
# "image", # Define show_img | |
# "text", # Define chatbot output | |
# "text" # Define txt | |
# ], | |
# title="PDF-Powered Chatbot" | |
# ).launch(server_port=8888) | |
# # Text to audio | |
# from transformers import AutoProcessor , BarkModel | |
# import scipy | |
# processor = AutoProcessor.from_pretrained("suno/bark") | |
# model = BarkModel.from_pretrained("suno/bark") | |
# model.to("cuda") | |
# def generate_audio(text,preset, output): | |
# inputs = processor(text, voice_preset=preset) | |
# for k , v in inputs.items(): | |
# inputs[k] = v.to("cuda") | |
# audio_array = model.generate(**inputs) | |
# audio_array = audio_array.cuda().numpy().squeeze() | |
# scipy.io.wavfile.write(output,rate= sample_rate,data= audio_array) | |
# generate_audio( | |
# text= "HI, welcome to our app hope you enjoy our app ,Thankyou for using our app YOURS Sincerely, Cosmo", | |
# preset= "v2/en_speaker_3", | |
# output= "output.wav", | |
# ) | |
# Fbgroup | |
# from selenium import webdriver | |
# from selenium.webdriver.common.by import By | |
# from selenium.webdriver.common.keys import Keys | |
# import time | |
# from time import sleep | |
# from selenium.webdriver.chrome.options import Options | |
# from selenium.webdriver.chrome.service import Service | |
# from webdriver_manager.chrome import ChromeDriverManager | |
# import streamlit as st | |
# import setuptools | |
# with open("README.md", encoding="utf-8") as readme_file: | |
# readme = readme_file.read() | |
# setuptools.setup( | |
# name='webdriver_manager', | |
# python_requires=">=3.7", | |
# long_description=readme, | |
# long_description_content_type="text/markdown", | |
# packages=setuptools.find_packages(include=['webdriver_manager*']), | |
# include_package_data=True, | |
# version='4.0.1', | |
# description='Library provides the way to automatically manage drivers for different browsers', | |
# author='Sergey Pirogov', | |
# author_email='[email protected]', | |
# url='https://github.com/SergeyPirogov/webdriver_manager', | |
# keywords=['testing', 'selenium', 'driver', 'test automation'], | |
# classifiers=[ | |
# 'License :: OSI Approved :: Apache Software License', | |
# 'Intended Audience :: Information Technology', | |
# 'Intended Audience :: Developers', | |
# 'Programming Language :: Python :: 3.7', | |
# 'Programming Language :: Python :: 3.8', | |
# 'Programming Language :: Python :: 3.9', | |
# 'Programming Language :: Python :: 3.10', | |
# 'Programming Language :: Python :: 3.11', | |
# 'Topic :: Software Development :: ' | |
# 'Libraries :: Python Modules', | |
# 'Operating System :: Microsoft :: Windows', | |
# 'Operating System :: POSIX', | |
# 'Operating System :: Unix', | |
# 'Operating System :: MacOS', | |
# ], | |
# install_requires=[ | |
# 'requests', | |
# 'python-dotenv', | |
# 'packaging' | |
# ], | |
# package_data={ | |
# "webdriver_manager": ["py.typed"] | |
# }, | |
# ) | |
# def main(): | |
# # Input fields | |
# st.title("Facebook Group Poster") | |
# account = st.text_input("Facebook Account Email", "[email protected]") | |
# password = st.text_input("Facebook Password", "sample", type="password") | |
# groups_links_list = st.text_area("Facebook Group URLs (one per line)", | |
# "https://www.facebook.com/groups/sample1\nhttps://www.facebook.com/groups/sample2") | |
# message = st.text_area("Post Message", "Checkout this amazing script...") | |
# images_list = st.file_uploader("Upload Images", accept_multiple_files=True) | |
# if st.button('Post to Facebook Groups'): | |
# if not account or not password or not groups_links_list or not message or not images_list: | |
# st.error("Please fill all the fields.") | |
# else: | |
# chrome_options = Options() | |
# prefs = {"profile.default_content_setting_values.notifications": 2} | |
# chrome_options.add_experimental_option("prefs", prefs) | |
# with st.spinner("Posting to Facebook..."): | |
# driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()), options=chrome_options) | |
# driver.get('https://www.facebook.com') | |
# # Login Logic (Replace XPaths if needed) | |
# emailelement = driver.find_element(By.XPATH,'//*[@id="email"]') | |
# emailelement.send_keys(account) | |
# passelement = driver.find_element(By.XPATH,'//*[@id="pass"]') | |
# passelement.send_keys(password) | |
# loginelement = driver.find_element(By.XPATH,'//*[@id="loginbutton"]') | |
# loginelement.click() | |
# # Posting Logic | |
# groups_links = groups_links_list.splitlines() | |
# for group in groups_links: | |
# driver.get(group) | |
# time.sleep(2) | |
# try: | |
# driver.find_element(By.XPATH,'//*[@label="Start Discussion"]').click() | |
# post_box=driver.find_element_by_css_selector("[name='xhpc_message_text']") | |
# except: | |
# post_box=driver.find_element_by_css_selector("[name='xhpc_message_text']") | |
# post_box.send_keys(message) | |
# time.sleep(1) | |
# # Image Upload Logic (Adapt based on Streamlit setup) | |
# for image_file in images_list: | |
# photo_element = driver.find_element(By.XPATH,'//input[@type="file"]') | |
# image_path = image_file.name # Placeholder! Adjust how you get the path | |
# photo_element.send_keys(image_path) | |
# time.sleep(1) | |
# # time.sleep(6) | |
# # post_button = driver.find_element_by_xpath("//*[@data-testid='react-composer-post-button']") | |
# # Handle image uploads (assuming one upload field per image) | |
# for image_file in images_list: | |
# photo_element = driver.find_element(By.XPATH,'//input[@type="file"]') | |
# photo_element.send_keys(image_file.name) # Or image_file.path, adjust as needed | |
# time.sleep(1) | |
# time.sleep(6) | |
# post_button = driver.find_element_by_xpath("//*[@data-testid='react-composer-post-button']") | |
# # ... (Rest of your logic to click the post button) | |
# driver.close() | |
# if __name__ == '__main__': | |
# main() | |
# text to Image | |
import streamlit as st | |
import torch | |
from diffusers import StableDiffusionXLPipeline, UNet2DConditionModel, EulerDiscreteScheduler | |
from huggingface_hub import hf_hub_download | |
from safetensors.torch import load_file | |
# Model Path/Repo Information | |
base = "stabilityai/stable-diffusion-xl-base-1.0" | |
repo = "ByteDance/SDXL-Lightning" | |
ckpt = "sdxl_lightning_4step_unet.safetensors" | |
# Load model (Executed only once for efficiency) | |
def load_sdxl_pipeline(): | |
unet = UNet2DConditionModel.from_config(base, subfolder="unet").to("cuda", torch.float16) | |
unet.load_state_dict(load_file(hf_hub_download(repo, ckpt), device="cuda")) | |
pipe = StableDiffusionXLPipeline.from_pretrained(base, unet=unet, torch_dtype=torch.float16, variant="fp16").to("cuda") | |
pipe.scheduler = EulerDiscreteScheduler.from_config(pipe.scheduler.config, timestep_spacing="trailing") | |
return pipe | |
# Streamlit UI | |
st.title("Image Generation") | |
prompt = st.text_input("Enter your image prompt:") | |
if st.button("Generate Image"): | |
if not prompt: | |
st.warning("Please enter a prompt.") | |
else: | |
pipe = load_sdxl_pipeline() # Load the pipeline from cache | |
with torch.no_grad(): | |
image = pipe(prompt).images[0] | |
st.image(image) | |
# text generation | |
# import streamlit as st | |
# from transformers import AutoTokenizer, AutoModelForCausalLM | |
# st.title("Text Generation with Bloom") | |
# tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom") | |
# model = AutoModelForCausalLM.from_pretrained("bigscience/bloom") | |
# user_input = st.text_area("Enter your prompt:", height=100) | |
# if st.button('Generate Text'): | |
# inputs = tokenizer(user_input, return_tensors="pt") | |
# outputs = model.generate(**inputs, max_length=100) # Adjust max_length as needed | |
# generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True) | |
# st.write("Generated Text:") | |
# st.write(generated_text) |