apparently works

app.py

@@ -816,84 +816,131 @@ async def generate_piclet(image, hf_token: str) -> dict:
         # Get user profile (creates if doesn't exist)
         user_profile = PicletDiscoveryService.get_or_create_user_profile(user_info)
 
-        # Extract image from Gradio input and read it immediately to avoid cleanup issues
-        # Gradio cleans up temp files, so we read the image data right away
+        # Extract image from Gradio input - save to temp file to pass to API calls
+        # Gradio cleans up temp files, so we save to our own temp file
         from PIL import Image as PILImage
+        import shutil
+
         image_path = image if isinstance(image, str) else image.name if hasattr(image, 'name') else str(image)
-        image_data = PILImage.open(image_path)
-
-        # Step 1: Generate caption
-        print("Step 1/5: Generating image caption...")
-        caption = await PicletGeneratorService.generate_enhanced_caption(image_data, hf_token)
-
-        # Step 2: Generate concept
-        print("Step 2/5: Generating Piclet concept...")
-        concept_data = await PicletGeneratorService.generate_piclet_concept(caption, hf_token)
-
-        object_name = concept_data['objectName']
-        attributes = concept_data['attributes']
-        stats = concept_data['stats']
-        image_prompt = concept_data['imagePrompt']
-        concept_text = concept_data['concept']
-
-        # Step 3: Generate image
-        print("Step 3/5: Generating Piclet image...")
-        image_result = await PicletGeneratorService.generate_piclet_image(
-            image_prompt,
-            stats['tier'],
-            hf_token
-        )
 
-        # Step 4: Check for canonical/variation
-        print("Step 4/5: Checking for existing canonical...")
-        existing_data = PicletDiscoveryService.load_piclet_data(object_name)
+        # Save to a temporary file that we control
+        with tempfile.NamedTemporaryFile(mode='wb', suffix='.jpg', delete=False) as f:
+            temp_image_path = f.name
+            img = PILImage.open(image_path)
+            img.save(temp_image_path, format='JPEG')
 
-        discovery_status = 'new'
-        canonical_id = None
-        scan_count = 1
-
-        if existing_data:
-            # Check if this is an exact canonical match (no attributes)
-            if not attributes or len(attributes) == 0:
-                discovery_status = 'existing'
-                canonical_id = existing_data['canonical']['typeId']
-                # Increment scan count
-                existing_data['canonical']['scanCount'] = existing_data['canonical'].get('scanCount', 0) + 1
-                scan_count = existing_data['canonical']['scanCount']
-                PicletDiscoveryService.save_piclet_data(object_name, existing_data)
-            else:
-                # Check for matching variation
-                variations = existing_data.get('variations', [])
-                matched_variation = None
-
-                for variation in variations:
-                    var_attrs = set(variation.get('attributes', []))
-                    search_attrs = set(attributes)
-                    overlap = len(var_attrs.intersection(search_attrs))
-
-                    if overlap >= len(search_attrs) * 0.5:
-                        matched_variation = variation
-                        discovery_status = 'existing'
-                        canonical_id = existing_data['canonical']['typeId']
-                        # Increment variation scan count
-                        variation['scanCount'] = variation.get('scanCount', 0) + 1
-                        scan_count = variation['scanCount']
-                        PicletDiscoveryService.save_piclet_data(object_name, existing_data)
-                        break
-
-                if not matched_variation:
-                    discovery_status = 'variation'
+        try:
+            # Step 1: Generate caption
+            print("Step 1/5: Generating image caption...")
+            caption = await PicletGeneratorService.generate_enhanced_caption(temp_image_path, hf_token)
+
+            # Step 2: Generate concept
+            print("Step 2/5: Generating Piclet concept...")
+            concept_data = await PicletGeneratorService.generate_piclet_concept(caption, hf_token)
+
+            object_name = concept_data['objectName']
+            attributes = concept_data['attributes']
+            stats = concept_data['stats']
+            image_prompt = concept_data['imagePrompt']
+            concept_text = concept_data['concept']
+
+            # Step 3: Generate image
+            print("Step 3/5: Generating Piclet image...")
+            image_result = await PicletGeneratorService.generate_piclet_image(
+                image_prompt,
+                stats['tier'],
+                hf_token
+            )
+
+            # Step 4: Check for canonical/variation
+            print("Step 4/5: Checking for existing canonical...")
+            existing_data = PicletDiscoveryService.load_piclet_data(object_name)
+
+            discovery_status = 'new'
+            canonical_id = None
+            scan_count = 1
+
+            if existing_data:
+                # Check if this is an exact canonical match (no attributes)
+                if not attributes or len(attributes) == 0:
+                    discovery_status = 'existing'
                     canonical_id = existing_data['canonical']['typeId']
+                    # Increment scan count
+                    existing_data['canonical']['scanCount'] = existing_data['canonical'].get('scanCount', 0) + 1
+                    scan_count = existing_data['canonical']['scanCount']
+                    PicletDiscoveryService.save_piclet_data(object_name, existing_data)
+                else:
+                    # Check for matching variation
+                    variations = existing_data.get('variations', [])
+                    matched_variation = None
+
+                    for variation in variations:
+                        var_attrs = set(variation.get('attributes', []))
+                        search_attrs = set(attributes)
+                        overlap = len(var_attrs.intersection(search_attrs))
+
+                        if overlap >= len(search_attrs) * 0.5:
+                            matched_variation = variation
+                            discovery_status = 'existing'
+                            canonical_id = existing_data['canonical']['typeId']
+                            # Increment variation scan count
+                            variation['scanCount'] = variation.get('scanCount', 0) + 1
+                            scan_count = variation['scanCount']
+                            PicletDiscoveryService.save_piclet_data(object_name, existing_data)
+                            break
+
+                    if not matched_variation:
+                        discovery_status = 'variation'
+                        canonical_id = existing_data['canonical']['typeId']
 
-        # Step 5: Save new discovery if needed
-        print("Step 5/5: Saving to dataset...")
-        if discovery_status == 'new':
-            # Create new canonical
-            type_id = f"{PicletDiscoveryService.normalize_object_name(object_name)}_canonical"
-            canonical_data = {
-                "canonical": {
-                    "objectName": object_name,
-                    "typeId": type_id,
+            # Step 5: Save new discovery if needed
+            print("Step 5/5: Saving to dataset...")
+            if discovery_status == 'new':
+                # Create new canonical
+                type_id = f"{PicletDiscoveryService.normalize_object_name(object_name)}_canonical"
+                canonical_data = {
+                    "canonical": {
+                        "objectName": object_name,
+                        "typeId": type_id,
+                        "discoveredBy": user_info['preferred_username'],
+                        "discovererSub": user_info['sub'],
+                        "discovererUsername": user_info['preferred_username'],
+                        "discovererName": user_info.get('name'),
+                        "discovererPicture": user_info.get('picture'),
+                        "discoveredAt": datetime.now().isoformat(),
+                        "scanCount": scan_count,
+                        "picletData": {
+                            "typeId": type_id,
+                            "nickname": stats['name'],
+                            "stats": stats,
+                            "imageUrl": image_result['imageUrl'],
+                            "imageCaption": caption,
+                            "concept": concept_text,
+                            "imagePrompt": image_prompt,
+                            "createdAt": datetime.now().isoformat()
+                        }
+                    },
+                    "variations": []
+                }
+                canonical_id = type_id
+
+                PicletDiscoveryService.save_piclet_data(object_name, canonical_data)
+
+                # Update user profile
+                user_profile["discoveries"].append(type_id)
+                user_profile["uniqueFinds"] = user_profile.get("uniqueFinds", 0) + 1
+                user_profile["totalFinds"] = user_profile.get("totalFinds", 0) + 1
+                user_profile["rarityScore"] = user_profile.get("rarityScore", 0) + 100
+                PicletDiscoveryService.save_user_data(user_info['sub'], user_profile)
+
+            elif discovery_status == 'variation':
+                # Create new variation
+                existing_data = PicletDiscoveryService.load_piclet_data(object_name)
+                variation_id = f"{PicletDiscoveryService.normalize_object_name(object_name)}_{len(existing_data['variations']) + 1:03d}"
+
+                variation_data = {
+                    "typeId": variation_id,
+                    "attributes": attributes,
                     "discoveredBy": user_info['preferred_username'],
                     "discovererSub": user_info['sub'],
                     "discovererUsername": user_info['preferred_username'],
@@ -902,7 +949,7 @@ async def generate_piclet(image, hf_token: str) -> dict:
                     "discoveredAt": datetime.now().isoformat(),
                     "scanCount": scan_count,
                     "picletData": {
-                        "typeId": type_id,
+                        "typeId": variation_id,
                         "nickname": stats['name'],
                         "stats": stats,
                         "imageUrl": image_result['imageUrl'],
@@ -911,90 +958,65 @@ async def generate_piclet(image, hf_token: str) -> dict:
                         "imagePrompt": image_prompt,
                         "createdAt": datetime.now().isoformat()
                     }
-                },
-                "variations": []
-            }
-            canonical_id = type_id
-
-            PicletDiscoveryService.save_piclet_data(object_name, canonical_data)
-
-            # Update user profile
-            user_profile["discoveries"].append(type_id)
-            user_profile["uniqueFinds"] = user_profile.get("uniqueFinds", 0) + 1
-            user_profile["totalFinds"] = user_profile.get("totalFinds", 0) + 1
-            user_profile["rarityScore"] = user_profile.get("rarityScore", 0) + 100
-            PicletDiscoveryService.save_user_data(user_info['sub'], user_profile)
+                }
 
-        elif discovery_status == 'variation':
-            # Create new variation
-            existing_data = PicletDiscoveryService.load_piclet_data(object_name)
-            variation_id = f"{PicletDiscoveryService.normalize_object_name(object_name)}_{len(existing_data['variations']) + 1:03d}"
+                existing_data['variations'].append(variation_data)
+                PicletDiscoveryService.save_piclet_data(object_name, existing_data)
 
-            variation_data = {
-                "typeId": variation_id,
+                # Update user profile
+                user_profile["discoveries"].append(variation_id)
+                user_profile["totalFinds"] = user_profile.get("totalFinds", 0) + 1
+                user_profile["rarityScore"] = user_profile.get("rarityScore", 0) + 50
+                PicletDiscoveryService.save_user_data(user_info['sub'], user_profile)
+
+            # Build complete response
+            piclet_data = {
+                "typeId": canonical_id,
+                "nickname": stats['name'],
+                "stats": stats,
+                "imageUrl": image_result['imageUrl'],
+                "imageCaption": caption,
+                "concept": concept_text,
+                "imagePrompt": image_prompt,
+                "objectName": object_name,
                 "attributes": attributes,
-                "discoveredBy": user_info['preferred_username'],
-                "discovererSub": user_info['sub'],
-                "discovererUsername": user_info['preferred_username'],
-                "discovererName": user_info.get('name'),
-                "discovererPicture": user_info.get('picture'),
-                "discoveredAt": datetime.now().isoformat(),
+                "discoveryStatus": discovery_status,
                 "scanCount": scan_count,
-                "picletData": {
-                    "typeId": variation_id,
-                    "nickname": stats['name'],
-                    "stats": stats,
-                    "imageUrl": image_result['imageUrl'],
-                    "imageCaption": caption,
-                    "concept": concept_text,
-                    "imagePrompt": image_prompt,
-                    "createdAt": datetime.now().isoformat()
-                }
+                "createdAt": datetime.now().isoformat()
             }
 
-            existing_data['variations'].append(variation_data)
-            PicletDiscoveryService.save_piclet_data(object_name, existing_data)
-
-            # Update user profile
-            user_profile["discoveries"].append(variation_id)
-            user_profile["totalFinds"] = user_profile.get("totalFinds", 0) + 1
-            user_profile["rarityScore"] = user_profile.get("rarityScore", 0) + 50
-            PicletDiscoveryService.save_user_data(user_info['sub'], user_profile)
-
-        # Build complete response
-        piclet_data = {
-            "typeId": canonical_id,
-            "nickname": stats['name'],
-            "stats": stats,
-            "imageUrl": image_result['imageUrl'],
-            "imageCaption": caption,
-            "concept": concept_text,
-            "imagePrompt": image_prompt,
-            "objectName": object_name,
-            "attributes": attributes,
-            "discoveryStatus": discovery_status,
-            "scanCount": scan_count,
-            "createdAt": datetime.now().isoformat()
-        }
+            messages = {
+                'new': f"Congratulations! You discovered the first {object_name} Piclet!",
+                'variation': f"You found a new variation of {object_name}!",
+                'existing': f"You encountered a known {object_name} Piclet."
+            }
 
-        messages = {
-            'new': f"Congratulations! You discovered the first {object_name} Piclet!",
-            'variation': f"You found a new variation of {object_name}!",
-            'existing': f"You encountered a known {object_name} Piclet."
-        }
+            return {
+                "success": True,
+                "piclet": piclet_data,
+                "discoveryStatus": discovery_status,
+                "canonicalId": canonical_id,
+                "message": messages.get(discovery_status, "Piclet generated!")
+            }
 
-        return {
-            "success": True,
-            "piclet": piclet_data,
-            "discoveryStatus": discovery_status,
-            "canonicalId": canonical_id,
-            "message": messages.get(discovery_status, "Piclet generated!")
-        }
+        except Exception as e:
+            print(f"Failed to generate Piclet: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                "success": False,
+                "error": str(e)
+            }
+        finally:
+            # Clean up temporary image file
+            if os.path.exists(temp_image_path):
+                try:
+                    os.unlink(temp_image_path)
+                except:
+                    pass
 
     except Exception as e:
-        print(f"Failed to generate Piclet: {e}")
-        import traceback
-        traceback.print_exc()
+        print(f"Failed to process image: {e}")
         return {
             "success": False,
             "error": str(e)