Update app.py

app.py

@@ -151,33 +151,55 @@ with gr.Blocks(title="Prepperoni - Premiere Pro to XML Converter", css=css) as a
             logger.info(f"Raw sequence result: {result}")
             
             try:
-                # Handle different result formats
-                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):
+                # 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:
-                        sequences = result['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']
+                        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
+                # 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
@@ -186,6 +208,13 @@ with gr.Blocks(title="Prepperoni - Premiere Pro to XML Converter", css=css) as a
                         # 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]
                         
@@ -307,8 +336,18 @@ with gr.Blocks(title="Prepperoni - Premiere Pro to XML Converter", css=css) as a
                 # 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)
                 
+                # 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"
+                
                 # Download the XML file if it's a URL
                 if xml_path.startswith("http"):
                     logger.info(f"Downloading XML file from {xml_path}")
@@ -327,7 +366,12 @@ with gr.Blocks(title="Prepperoni - Premiere Pro to XML Converter", css=css) as a
                         logger.error(f"Failed to download XML: {response.status_code}")
                         return None, f"Error downloading XML: {response.status_code}", "Error"
                 else:
-                    # It's already a local path
+                    # 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: