Help with integrating DALL·E image generation in a Django API alongside GPT responses

I’m working on a Django API that integrates both GPT (for text responses) and DALL·E (for image generation). Text responses from GPT are working fine, but when I try to generate images using DALL·E, I keep getting text responses like “I’m sorry, but I can’t generate images…”. It seems like GPT is responding instead of the image generation process being triggered properly.

My goal is to allow users to send a prompt like “generate image: a white cat”, and for the API to return an image URL generated by DALL·E instead of a text response from GPT. I suspect there’s an issue in how I’m distinguishing between GPT and DALL·E requests.

Here’s the part of the code where I’m handling both the text and image requests. Any advice on how to properly integrate DALL·E for image generation alongside GPT for text would be appreciated!

# Fonction pour appeler l'API DALL·E pour générer des images
def generate_image_with_dalle(prompt, size="1024x1024", quality="standard"):
    try:
        client = OpenAI(api_key=settings.OPENAI_API_KEY)
        response = client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size=size,
            quality=quality,
            n=1,  # Générer une image
        )
        image_url = response.data[0].url
        return image_url
    except Exception as e:
        logging.error(f"Erreur lors de la génération d'image avec DALL·E : {str(e)}")
        return None
class ChatGPTAppendView(APIView):
    permission_classes = [permissions.IsAuthenticated]

    def post(self, request, chat_id):
        chat = get_object_or_404(Chat, id=chat_id, user=request.user)
        return self._generate_response(request, chat)

    def _generate_response(self, request, chat):
        serializer = ImageMessageSerializer(data=request.data)
        if serializer.is_valid():
            message_content = serializer.validated_data.get('content', '')
            image = serializer.validated_data.get('image', None)
            pdf = serializer.validated_data.get('pdf', None)

            # Enregistrer le message texte s'il est présent
            if message_content:
                Message.objects.create(chat=chat, role='user', content=message_content)

                # Vérifier si l'utilisateur demande une génération d'image
                if "generate image:" in message_content.lower():
                    # Extraire le prompt pour l'image à générer
                    prompt = message_content.lower().replace("generate image:", "").strip()

                    # Appel à DALL·E pour générer l'image
                    generated_image_url = generate_image_with_dalle(prompt)

                    if generated_image_url:
                        # Stocker l'URL de l'image générée dans la base de données
                        GeneratedImage.objects.create(user=request.user, url=generated_image_url, prompt=prompt)
                        Message.objects.create(chat=chat, role='assistant', content=f"Image générée: {generated_image_url}")

                        return Response({
                            "chat_id": chat.id,
                            "messages": [{"role": "assistant", "content": f"Image générée: {generated_image_url}"}]
                        }, status=status.HTTP_200_OK)
                else:
                    # Traiter les réponses textuelles avec GPT-4
                    return self._generate_text_response(chat, message_content)

            # Traiter l'image si elle est présente
            if image:
                encoded_image = encode_image_to_base64(image)
                if encoded_image:
                    Message.objects.create(chat=chat, role='user', content=f"data:image/jpeg;base64,{encoded_image}")
                    # Réponse textuelle normale après envoi de l'image
                    return self._generate_text_response(chat, message_content)

            return Response(status=status.HTTP_200_OK)

        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)

    def _generate_text_response(self, chat, message_content):
        # Récupérer les messages précédents pour la requête GPT
        messages_for_openai = [
            {"role": msg.role, "content": msg.content}
            for msg in chat.messages.all().order_by('created_at')
        ]
        messages_for_openai.append({"role": "user", "content": message_content})

        api_request_data = {
            "model": "gpt-4o-2024-08-06",
            "messages": messages_for_openai,
            "temperature": 0.2,
            "max_tokens": 3000,
            "frequency_penalty": 0.2,
            "presence_penalty": 0.5
        }

        try:
            client = OpenAI(api_key=settings.OPENAI_API_KEY)
            response = client.chat.completions.create(**api_request_data)
            assistant_message_content = response.choices[0].message.content.strip()
            formatted_content = format_response(assistant_message_content)
            Message.objects.create(chat=chat, role='assistant', content=formatted_content)

            return Response({
                "chat_id": chat.id,
                "messages": [{"role": "assistant", "content": formatted_content}]
            }, status=status.HTTP_200_OK)

        except Exception as e:
            logging.error(f"Erreur dans la requête à OpenAI : {str(e)}")
            return Response({"error": str(e)}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
1 Like