Update app.py

app.py

@@ -3,95 +3,115 @@ import logging
 import os
 import datetime
 import gradio as gr
-from huggingface_hub import HfApi, HfFolder
-# Set up logging
-logging.basicConfig(level=logging.INFO)
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from huggingface_hub import HfApi
 
+# Set up logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
-# Define the function to convert text to JSON
+# Load DeepSeek-V3 model and tokenizer for CPU
+MODEL_NAME = "deepseek-ai/deepseek-v3"
+logger.info(f"Loading model: {MODEL_NAME} (CPU mode)")
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, torch_dtype=torch.float32, device_map="cpu")
+
+# Function to process text with DeepSeek-V3
+def process_text_with_model(text):
+    logger.info("Processing text with DeepSeek-V3 model (CPU)...")
+    inputs = tokenizer(text, return_tensors="pt").to("cpu")  # Ensures CPU usage
+    outputs = model.generate(**inputs, max_length=200)
+    processed_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return processed_text
+
+# Function to convert text to JSON
 def text_to_json(text):
-    lines = text.strip().split('\n')
+    lines = text.strip().split("\n")
     data = [{"text": line} for line in lines]
     timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
     filename = f"output_{timestamp}.json"
-    with open(filename, "a") as f:
+
+    with open(filename, "w") as f:
         json.dump(data, f, indent=4)
+
+    logger.info(f"JSON file created: {filename}")
     return filename
 
-# Define the function to generate and upload the JSON file
+# Function to generate JSON and upload to Hugging Face
 def generate_and_upload(text):
     try:
-        if not text:
+        if not text.strip():
             raise ValueError("Text input is empty.")
         
         logger.info(f"Received text input: {text}")
-        
-        # Convert text to JSON and save to file
-        json_file = text_to_json(text)
-        logger.info(f"JSON file created: {json_file}")
-        
-        # Authenticate with Hugging Face Hub
-        api = HfApi()
-        token = os.environ['HUGGINGFACE_API_TOKEN']
-        if token is None:
+
+        # Process text with DeepSeek-V3
+        processed_text = process_text_with_model(text)
+        logger.info(f"Processed text: {processed_text}")
+
+        # Convert processed text to JSON
+        json_file = text_to_json(processed_text)
+
+        # Get Hugging Face API token
+        token = os.getenv("HUGGINGFACE_API_TOKEN")
+        if not token:
             raise ValueError("Hugging Face API token not found. Please set HUGGINGFACE_API_TOKEN environment variable.")
-        
-        # Upload the file to the dataset repository
+
+        # Upload file to Hugging Face
+        api = HfApi()
         repo_id = "katsukiai/DeepFocus-X3"
         upload_info = api.upload_file(
             path_or_fileobj=json_file,
-            path_in_repo="convert/"+os.path.basename(json_file),
+            path_in_repo=f"convert/{os.path.basename(json_file)}",
             repo_id=repo_id,
             repo_type="dataset",
             token=token
         )
-        logger.info(f"Upload info: {upload_info}")
-        message = f"Upload successful! Filename: {os.path.basename(json_file)}"
-        return message, json_file
-    except Exception as e:
-        logger.error(f"Error uploading file: {e}")
-        return f"Error: {e}", None
+        
+        logger.info(f"File uploaded successfully: {upload_info}")
 
+        # Delete local JSON file after upload
+        os.remove(json_file)
+        logger.info(f"Deleted local file: {json_file}")
 
+        return f"Upload successful! Filename: {os.path.basename(json_file)}", None
 
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        return f"Error: {str(e)}", None
 
-# Create the Gradio interface
+# Create Gradio UI
 with gr.Blocks() as demo:
     with gr.Tab("About"):
         gr.Markdown("""
-        # Text to JSON uploader
-        This app allows you to input text, convert it to JSON format, and upload it to the Hugging Face dataset repository.
-        
-        ## Instructions
-        1. Enter your text in the "Generate" tab.
-        2. Click the "Generate and Upload" button.
-        3. Download the JSON file if desired.
-        4. Check the message for upload status.
-        
-        ## Requirements
-        - Hugging Face API token set as environment variable `HUGGINGFACE_API_TOKEN`.
-        
-        ## Obtaining Hugging Face API Token
-        1. Log in to your Hugging Face account.
-        2. Go to your profile settings.
-        3. Generate a new token or use an existing one.
-        4. Set the token as an environment variable named `HUGGINGFACE_API_TOKEN`.
-        
-        ## Setting Environment Variable
-        - **Windows**: Set it in System Properties > Advanced > Environment Variables.
-        - **macOS/Linux**: Add `export HUGGINGFACE_API_TOKEN=your_token` to your shell profile (e.g., `.bashrc`, `.zshrc`).
+        # Text Processor with DeepSeek-V3 (CPU)
+        - Processes text with DeepSeek-V3 Transformer  
+        - Converts output to JSON  
+        - Uploads to Hugging Face  
+
+        ## Instructions:
+        1. Enter text in the "Generate" tab.  
+        2. Click "Generate and Upload."  
+        3. Download JSON if needed.  
+        4. Check upload status.  
+
+        ## Requirements:
+        - **Runs on CPU** (No GPU required).  
+        - **Hugging Face API Token** (`HUGGINGFACE_API_TOKEN`) must be set.  
         """)
-    
+
     with gr.Tab("Generate"):
         text_input = gr.Textbox(label="Enter text")
         output_message = gr.Textbox(label="Status message")
-        json_file_downloader = gr.File(label="Download JSON", interactive=False)
+        json_file_downloader = gr.File(label="Download JSON", interactive=True)
         generate_button = gr.Button("Generate and Upload")
-        generate_button.click(fn=generate_and_upload, inputs=text_input, outputs=[output_message, json_file_downloader])
-        
-# Launch the Gradio app
-demo.launch()
-
 
+        generate_button.click(
+            fn=generate_and_upload, 
+            inputs=text_input, 
+            outputs=[output_message, json_file_downloader]
+        )
 
+# Launch Gradio app
+demo.launch()