Update app.py

app.py

@@ -5,7 +5,6 @@ import tempfile
 import logging
 import shutil
 import requests
-from huggingface_hub.utils import RepositoryNotFoundError
 
 # Configure logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@@ -18,7 +17,7 @@ if not hf_token:
     logger.warning("Please set the HF_TOKEN environment variable with your Hugging Face token.")
 
 # Backend space name - update this to your private space
-BACKEND_SPACE = "skallewag/prepperoni-backend"  # Using hyphen instead of underscore
+BACKEND_SPACE = "skallewag/prepperoni-backend"
 
 # Initialize client as None first
 client = None
@@ -38,7 +37,7 @@ except Exception as e:
     logger.error(f"Error connecting to backend space '{BACKEND_SPACE}': {str(e)}")
     logger.error("This might be due to a missing or invalid HF_TOKEN, or the backend space may be offline or private.")
 
-# Custom CSS for error box
+# Custom CSS
 css = """
 .error-box {
     background-color: #ffebe9;
@@ -67,14 +66,11 @@ with gr.Blocks(title="Prepperoni - Premiere Pro to XML Converter", css=css) as a
         If you're the administrator, please make sure the HF_TOKEN environment variable is set correctly in Space settings.
         """, elem_classes=["error-box"])
     
-    # State variables for sequence data
-    sequence_list = gr.State([])
-    
     with gr.Row():
         with gr.Column(scale=1):
             # Input components
             file_input = gr.File(label="Upload Premiere Pro Project File (.prproj)", file_types=[".prproj"])
-            sequence_dropdown = gr.Dropdown(label="Select Sequence", choices=[], visible=False, interactive=True)
+            sequence_input = gr.Textbox(label="Sequence Name (optional)", placeholder="Leave blank to use first sequence")
             convert_btn = gr.Button("Convert to XML", variant="primary")
             status = gr.Markdown("Upload a Premiere Pro project file to begin.")
             
@@ -94,7 +90,7 @@ with gr.Blocks(title="Prepperoni - Premiere Pro to XML Converter", css=css) as a
         
         ### How to use:
         1. Upload your Premiere Pro project file (.prproj)
-        2. Select a sequence from the dropdown
+        2. Optionally enter a sequence name (leave blank to use the first sequence)
         3. Click "Convert to XML"
         4. Download the generated XML file
         
@@ -105,135 +101,6 @@ with gr.Blocks(title="Prepperoni - Premiere Pro to XML Converter", css=css) as a
         - Supports nested sequences
         """)
     
-    # Function to update the sequence dropdown when a file is uploaded
-    def update_sequence_dropdown(file):
-        if not file:
-            return gr.Dropdown(choices=[], value=None, visible=False), [], "Please upload a Premiere Pro project file to begin."
-        
-        if not client:
-            return gr.Dropdown(choices=[], value=None, visible=False), [], "Error: Cannot connect to backend service."
-            
-        try:
-            # Save the uploaded file to a temporary path
-            temp_dir = tempfile.mkdtemp()
-            temp_file_path = os.path.join(temp_dir, "project.prproj")
-            
-            # Copy the uploaded file to our temp location
-            shutil.copy(file.name, temp_file_path)
-            
-            # Try to get sequences from the backend
-            try:
-                # Try with update_dropdown endpoint
-                result = client.predict(
-                    handle_file(temp_file_path),
-                    api_name="/update_dropdown"
-                )
-            except Exception as e1:
-                logger.warning(f"Failed with api_name='/update_dropdown': {str(e1)}")
-                try:
-                    # Try with index 0
-                    result = client.predict(
-                        handle_file(temp_file_path),
-                        fn_index=0
-                    )
-                except Exception as e2:
-                    logger.error(f"Error getting sequences: {str(e2)}")
-                    return gr.Dropdown(choices=[], value=None, visible=False), [], f"Error loading sequences: {str(e2)}"
-            
-            # Clean up
-            shutil.rmtree(temp_dir, ignore_errors=True)
-            
-            # Process the result based on format
-            sequences = []
-            error_msg = ""
-            
-            # Log the raw result for debugging
-            logger.info(f"Raw sequence result: {result}")
-            
-            try:
-                # Special handling for Gradio component update objects
-                if isinstance(result, dict) and '__type__' in result and result.get('__type__') == 'update':
-                    # Extract sequence choices from the Gradio update object
-                    if 'choices' in result:
-                        choices = result['choices']
-                        
-                        # Handle nested lists or different formats of choices
-                        if isinstance(choices, list) and len(choices) > 0:
-                            if isinstance(choices[0], list):
-                                # Format is likely [['name1', 'value1'], ['name2', 'value2']]
-                                # or [['name1', 'name1'], ['name2', 'name2']]
-                                sequences = [item[0] for item in choices]  # Take the first item (name)
-                            else:
-                                # Format is likely ['name1', 'name2', 'name3']
-                                sequences = choices
-                else:
-                    # Standard response handling for non-update objects
-                    if isinstance(result, (list, tuple)):
-                        if len(result) > 0:
-                            if isinstance(result[0], (list, tuple)):
-                                # It's a list of sequences
-                                sequences = result[0]
-                            else:
-                                # The result itself is the list of sequences
-                                sequences = result
-                            
-                            if len(result) >= 2 and isinstance(result[1], str):
-                                error_msg = result[1]
-                    elif isinstance(result, dict):
-                        if 'choices' in result:
-                            choices = result['choices']
-                            if isinstance(choices, list) and len(choices) > 0:
-                                if isinstance(choices[0], list):
-                                    # Format is likely [['name1', 'value1'], ['name2', 'value2']]
-                                    sequences = [item[0] for item in choices]
-                                else:
-                                    sequences = choices
-                        elif 'data' in result:
-                            if isinstance(result['data'], (list, tuple)) and len(result['data']) >= 1:
-                                sequences = result['data'][0]
-                            else:
-                                sequences = result['data']
-                        elif 'sequences' in result:
-                            sequences = result['sequences']
-                        
-                        if 'error' in result:
-                            error_msg = result['error']
-                
-                # Ensure sequences is a list and contains only unique values
-                if not isinstance(sequences, (list, tuple)):
-                    # Try to convert to a list if it's something else
-                    if hasattr(sequences, 'items'):  # It's a dictionary-like object
-                        sequences = list(sequences.values())
-                    else:
-                        # Try to make it a list with a single item
-                        sequences = [sequences]
-                
-                # Remove duplicates while preserving order
-                unique_sequences = []
-                for seq in sequences:
-                    if seq not in unique_sequences:
-                        unique_sequences.append(seq)
-                sequences = unique_sequences
-                
-                # Convert any non-string items to strings
-                sequences = [str(seq) for seq in sequences]
-                        
-                logger.info(f"Processed sequences: {sequences}")
-            except Exception as e:
-                logger.exception(f"Error processing sequences result: {e}")
-                return gr.Dropdown(choices=[], value=None, visible=False), [], f"Error processing sequences: {str(e)}"
-            
-            if not sequences:
-                return gr.Dropdown(choices=[], value=None, visible=False), [], "No sequences found in the project."
-                
-            # Update the dropdown with sequence names
-            first_value = sequences[0] if sequences and len(sequences) > 0 else None
-            return gr.Dropdown(choices=sequences, value=first_value, visible=True), sequences, f"Found {len(sequences)} sequences. Select one to convert."
-            
-        except Exception as e:
-            logger.exception("Error in update_sequence_dropdown")
-            return gr.Dropdown(choices=[], value=None, visible=False), [], f"Error: {str(e)}"
-    
     # Function to set the initial processing status
     def set_processing_status():
         return None, "Processing... This may take a minute. Please wait.", "Processing..."
@@ -258,44 +125,17 @@ with gr.Blocks(title="Prepperoni - Premiere Pro to XML Converter", css=css) as a
             shutil.copy(file.name, temp_file_path)
             
             # Prepare sequence name (None if empty)
-            seq_name = sequence_name if sequence_name else None
+            seq_name = sequence_name.strip() if sequence_name and sequence_name.strip() else None
             
             # Try predicting with the backend
             try:
-                logger.info("Sending file to backend for processing...")
-                # Check if client has multiple endpoints and handle appropriately
-                if client.endpoints and len(client.endpoints) > 0:
-                    # First try with /process_file endpoint (with leading slash)
-                    try:
-                        result = client.predict(
-                            handle_file(temp_file_path),
-                            seq_name,
-                            api_name="/process_file"
-                        )
-                    except Exception as e1:
-                        logger.warning(f"Failed with api_name='/process_file': {str(e1)}")
-                        # Try with index 1 which appears to be the process_file endpoint
-                        try:
-                            result = client.predict(
-                                handle_file(temp_file_path),
-                                seq_name,
-                                fn_index=1
-                            )
-                        except Exception as e2:
-                            logger.warning(f"Failed with fn_index=1: {str(e2)}")
-                            # Try with index 0 as fallback
-                            result = client.predict(
-                                handle_file(temp_file_path),
-                                seq_name,
-                                fn_index=0
-                            )
-                else:
-                    # Just try without specifying endpoint
-                    result = client.predict(
-                        handle_file(temp_file_path),
-                        seq_name
-                    )
-                
+                logger.info(f"Sending file to backend for processing with sequence name: {seq_name}")
+                # Use the /process_file endpoint with index 1
+                result = client.predict(
+                    handle_file(temp_file_path),
+                    seq_name,
+                    fn_index=1  # Use fn_index instead of api_name
+                )
                 logger.info(f"Got result from backend: {result}")
             except Exception as e:
                 logger.error(f"Error connecting to backend: {str(e)}")
@@ -305,97 +145,62 @@ with gr.Blocks(title="Prepperoni - Premiere Pro to XML Converter", css=css) as a
             shutil.rmtree(temp_dir, ignore_errors=True)
             
             # Handle the result
-            # Check the format of the result and extract file path and message
-            xml_path = None
-            message = "Unknown response format"
-            
+            # The backend returns [file_path, message]
             try:
-                if isinstance(result, (list, tuple)) and len(result) >= 2:
-                    # Format: [file_path, message]
+                # Extract file path and message from the result
+                if isinstance(result, (list, tuple)) and len(result) >= 1:
                     xml_path = result[0]
-                    message = result[1]
-                elif isinstance(result, dict):
-                    # Try to extract data from dictionary format
-                    if 'file' in result:
-                        xml_path = result['file']
-                    elif 'data' in result and isinstance(result['data'], (list, tuple)) and len(result['data']) >= 1:
-                        xml_path = result['data'][0]
-                    
-                    if 'message' in result:
-                        message = result['message']
-                    elif 'data' in result and isinstance(result['data'], (list, tuple)) and len(result['data']) >= 2:
-                        message = result['data'][1]
-                
-                # Log the extracted values
-                logger.info(f"Extracted from result - xml_path: {xml_path}, message: {message}")
-            except Exception as e:
-                logger.exception(f"Error processing result: {e}")
-                return None, f"Error processing result from backend: {str(e)}", "Error"
-            
-            if xml_path:
-                # Check if xml_path is a string
-                if not isinstance(xml_path, str):
-                    logger.warning(f"XML path is not a string: {type(xml_path)}")
-                    # If it's a dict or complex object, it's likely not a valid path
-                    if isinstance(xml_path, (dict, list, tuple)):
-                        logger.error(f"Invalid XML path, not a string: {xml_path}")
-                        return None, "Error: Invalid response format from backend server", "Error"
-                    # Try to convert to string if it's another type
-                    xml_path = str(xml_path)
+                    message = result[1] if len(result) >= 2 else "Conversion successful"
+                else:
+                    logger.error(f"Unexpected result format: {result}")
+                    return None, "Error: Unexpected response format from backend", "Error"
                 
-                # Check if the path is actually a valid file path
-                if xml_path.startswith("{") or xml_path.startswith("["):
-                    logger.error(f"XML path appears to be JSON or a data structure, not a path: {xml_path}")
-                    return None, "Error: Invalid response format from backend server", "Error"
+                logger.info(f"Extracted XML path: {xml_path}, Message: {message}")
                 
-                # Download the XML file if it's a URL
-                if xml_path.startswith("http"):
-                    logger.info(f"Downloading XML file from {xml_path}")
-                    headers = {"Authorization": f"Bearer {hf_token}"} if hf_token else {}
-                    response = requests.get(xml_path, headers=headers)
-                    
-                    if response.status_code == 200:
-                        # Save to a temporary file
-                        temp_dir = tempfile.mkdtemp()
-                        xml_local_path = os.path.join(temp_dir, "sequence.xml")
-                        with open(xml_local_path, "wb") as f:
-                            f.write(response.content)
-                        logger.info(f"XML file saved to {xml_local_path}")
-                        return xml_local_path, message, "Success!"
+                # Handle the XML file
+                if xml_path:
+                    # Download the XML file if it's a URL
+                    if isinstance(xml_path, str) and xml_path.startswith("http"):
+                        logger.info(f"Downloading XML file from {xml_path}")
+                        headers = {"Authorization": f"Bearer {hf_token}"} if hf_token else {}
+                        response = requests.get(xml_path, headers=headers)
+                        
+                        if response.status_code == 200:
+                            # Save to a temporary file
+                            temp_dir = tempfile.mkdtemp()
+                            xml_local_path = os.path.join(temp_dir, "sequence.xml")
+                            with open(xml_local_path, "wb") as f:
+                                f.write(response.content)
+                            logger.info(f"XML file saved to {xml_local_path}")
+                            return xml_local_path, message, "Success!"
+                        else:
+                            logger.error(f"Failed to download XML: {response.status_code}")
+                            return None, f"Error downloading XML: {response.status_code}", "Error"
+                    elif isinstance(xml_path, str) and os.path.exists(xml_path):
+                        # It's a local file path that exists
+                        logger.info(f"XML file is at local path: {xml_path}")
+                        return xml_path, message, "Success!"
                     else:
-                        logger.error(f"Failed to download XML: {response.status_code}")
-                        return None, f"Error downloading XML: {response.status_code}", "Error"
+                        logger.error(f"Invalid XML path: {xml_path}")
+                        return None, "Error: Invalid XML file path returned from backend", "Error"
                 else:
-                    # Check if it's a local path that actually exists
-                    if not os.path.exists(xml_path):
-                        logger.error(f"XML path does not exist: {xml_path}")
-                        return None, f"Error: XML file not found at path {xml_path}", "Error"
-                    
-                    # It's a valid local path
-                    logger.info(f"XML file is at local path: {xml_path}")
-                    return xml_path, message, "Success!"
-            else:
-                logger.warning(f"No XML file generated. Response: {result}")
-                return None, message or "Failed to generate XML", "Error"
+                    logger.warning("No XML file generated")
+                    return None, "No XML file was generated", "Error"
+            except Exception as e:
+                logger.exception(f"Error processing result: {e}")
+                return None, f"Error processing backend response: {str(e)}", "Error"
                 
         except Exception as e:
             logger.exception("Error in process_file")
             return None, f"Error occurred: {str(e)}", "Error"
     
-    # Connect file upload to sequence dropdown update
-    file_input.change(
-        fn=update_sequence_dropdown,
-        inputs=[file_input],
-        outputs=[sequence_dropdown, sequence_list, status]
-    )
-    
     # Connect the button to first set status, then process
     convert_btn.click(
         fn=set_processing_status,
         outputs=[output_file, output_message, status]
     ).then(
         fn=process_file,
-        inputs=[file_input, sequence_dropdown],
+        inputs=[file_input, sequence_input],
         outputs=[output_file, output_message, status]
     )