Django: aggiungi un'immagine in un ImageField dall'URL dell'immagine

per favore scusami per il mio brutto inglese ;-)

Immagina questo modello molto semplice:

class Photo(models.Model):
    image = models.ImageField('Label', upload_to='path/')

Vorrei creare una foto da un URL di immagine (cioè, non a mano nel sito di amministrazione di django).

Penso di dover fare qualcosa del genere:

from myapp.models import Photo
import urllib

img_url = 'http://www.site.com/image.jpg'
img = urllib.urlopen(img_url)
# Here I need to retrieve the image (as the same way that if I put it in an input from admin site)
photo = Photo.objects.create(image=image)

Spero di aver spiegato bene il problema, se non dimmi.

Grazie :)

Modificare :

Potrebbe funzionare ma non so come convertire contentin un file django:

from urlparse import urlparse
import urllib2
from django.core.files import File

photo = Photo()
img_url = 'http://i.ytimg.com/vi/GPpN5YUNDeI/default.jpg'
name = urlparse(img_url).path.split('/')[-1]
content = urllib2.urlopen(img_url).read()

# problem: content must be an instance of File
photo.image.save(name, content, save=True)

Ho appena creato http://www.djangosnippets.org/snippets/1890/ per questo stesso problema. Il codice è simile alla risposta di Pithyless sopra tranne che utilizza urllib2.urlopen perché urllib.urlretrieve non esegue alcuna gestione degli errori per impostazione predefinita, quindi è facile ottenere il contenuto di una pagina 404/500 invece di quello che ti serve. Puoi creare una funzione di callback e una sottoclasse URLOpener personalizzata, ma ho trovato più semplice creare il mio file temporaneo in questo modo:

from django.core.files import File
from django.core.files.temp import NamedTemporaryFile

img_temp = NamedTemporaryFile(delete=True)
img_temp.write(urllib2.urlopen(url).read())
img_temp.flush()

im.file.save(img_filename, File(img_temp))

from myapp.models import Photo
import urllib
from urlparse import urlparse
from django.core.files import File

img_url = 'http://www.site.com/image.jpg'

photo = Photo()    # set any other fields, but don't commit to DB (ie. don't save())
name = urlparse(img_url).path.split('/')[-1]
content = urllib.urlretrieve(img_url)

# See also: http://docs.djangoproject.com/en/dev/ref/files/file/
photo.image.save(name, File(open(content[0])), save=True)

Combinando ciò che hanno detto Chris Adams e Stan e aggiornando le cose per funzionare su Python 3, se installi Requests puoi fare qualcosa del genere:

from urllib.parse import urlparse
import requests
from django.core.files.base import ContentFile
from myapp.models import Photo

img_url = 'http://www.example.com/image.jpg'
name = urlparse(img_url).path.split('/')[-1]

photo = Photo() # set any other fields, but don't commit to DB (ie. don't save())

response = requests.get(img_url)
if response.status_code == 200:
    photo.image.save(name, ContentFile(response.content), save=True)

Documenti più rilevanti nella documentazione ContentFile di Django e nell'esempio di download del file Requests .

ImageField è solo una stringa, un percorso relativo al tuo MEDIA_ROOT impostazione. Basta salvare il file (potresti voler usare PIL per verificare che sia un'immagine) e popolare il campo con il suo nome di file.

Quindi è diverso dal codice in quanto è necessario salvare l'output del urllib.urlopenfile su (all'interno della posizione del supporto), elaborare il percorso, salvarlo sul modello.

Lo faccio in questo modo su Python 3, che dovrebbe funzionare con semplici adattamenti su Python 2. Ciò si basa sulla mia conoscenza che i file che sto recuperando sono piccoli. In caso contrario, probabilmente consiglierei di scrivere la risposta su un file invece di eseguire il buffering in memoria.

BytesIO è necessario perché Django chiama seek () sull'oggetto file e le risposte urlopen non supportano la ricerca. Potresti invece passare l'oggetto byte restituito da read () al ContentFile di Django.

from io import BytesIO
from urllib.request import urlopen

from django.core.files import File


# url, filename, model_instance assumed to be provided
response = urlopen(url)
io = BytesIO(response.read())
model_instance.image_field.save(filename, File(io))

Recentemente utilizzo il seguente approccio all'interno di python 3 e Django 3, forse questo potrebbe essere interessante anche per altri. È simile alla soluzione di Chris Adams ma per me non ha funzionato più.

import urllib.request
from django.core.files.uploadedfile import SimpleUploadedFile
from urllib.parse import urlparse

from demoapp import models


img_url = 'https://upload.wikimedia.org/wikipedia/commons/f/f7/Stack_Overflow_logo.png'
basename = urlparse(img_url).path.split('/')[-1]
tmpfile, _ = urllib.request.urlretrieve(img_url)

new_image = models.ModelWithImageOrFileField()
new_image.title = 'Foo bar'
new_image.file = SimpleUploadedFile(basename, open(tmpfile, "rb").read())
new_image.save()

Ho appena scoperto che non è necessario generare un file temporaneo:

Streaming di contenuti URL direttamente da Django a Minio

Devo archiviare i miei file in minio e avere contenitori docker django senza molto spazio su disco e ho bisogno di scaricare file video di grandi dimensioni, quindi questo è stato davvero utile per me.

questo è il modo giusto e funzionante

class Product(models.Model):
    upload_path = 'media/product'
    image = models.ImageField(upload_to=upload_path, null=True, blank=True)
    image_url = models.URLField(null=True, blank=True)

    def save(self, *args, **kwargs):
        if self.image_url:
            import urllib, os
            from urlparse import urlparse
            filename = urlparse(self.image_url).path.split('/')[-1]
            urllib.urlretrieve(self.image_url, os.path.join(file_save_dir, filename))
            self.image = os.path.join(upload_path, filename)
            self.image_url = ''
            super(Product, self).save()