Python sample projects

from django.core.files.uploadedfile import UploadedFile
from django.db import models
from cloudinary.models import CloudinaryField
from django.core.exceptions import ValidationError

# For testing model validation
FILE_UPLOAD_MAX_MEMORY_SIZE = 1024 * 1024 * 10  # 10mb


def file_validation(file):
    if not file:
        raise ValidationError("No file selected.")

    # For regular upload, we get UploadedFile instance, so we can validate it.
    # When using direct upload from the browser, here we get an instance of the CloudinaryResource
    # and file is already uploaded to Cloudinary.
    # Still can perform all kinds on validations and maybe delete file, approve moderation, perform analysis, etc.
    if isinstance(file, UploadedFile):
        if file.size > FILE_UPLOAD_MAX_MEMORY_SIZE:
            raise ValidationError("File shouldn't be larger than 10MB.")


class Photo(models.Model):
    """
    This is the main model in the project. It holds a reference to cloudinary-stored
    image and contains some metadata about the image.
    """

    # Misc Django Fields
    create_time = models.DateTimeField(auto_now_add=True)
    title = models.CharField("Title (optional)", max_length=200, blank=True)

    # Points to a Cloudinary image
    image = CloudinaryField('image', validators=[file_validation])

    """ Informative name for model """

    def __unicode__(self):
        try:
            public_id = self.image.public_id
        except AttributeError:
            public_id = ''
        return "Photo <%s:%s>" % (self.title, public_id)

from django.forms import ModelForm

import cloudinary
import hashlib
# Next two lines are only used for generating the upload preset sample name
from cloudinary.compat import to_bytes
from cloudinary.forms import CloudinaryJsFileField, CloudinaryUnsignedJsFileField
from .models import Photo


class PhotoForm(ModelForm):
    class Meta:
        model = Photo
        fields = '__all__'


class PhotoDirectForm(PhotoForm):
    image = CloudinaryJsFileField(
        attrs={'style': "margin-top: 30px"},
        options={
            'tags': "directly_uploaded",
            'crop': 'limit', 'width': 1000, 'height': 1000,
            'eager': [{'crop': 'fill', 'width': 150, 'height': 100}]
        })


class PhotoUnsignedDirectForm(PhotoForm):
    upload_preset_name = "sample_" + hashlib.sha1(
        to_bytes(cloudinary.config().api_key + cloudinary.config().api_secret)).hexdigest()[0:10]
    image = CloudinaryUnsignedJsFileField(upload_preset_name)

from django.forms import ModelForm     
from cloudinary.forms import CloudinaryFileField
from .models import Photo

class PhotoForm(ModelForm):
    image = CloudinaryFileField()

    class Meta:
        model = Photo
        fields = '__all__'

    def __init__(self, *args, **kwargs):
       super().__init__(*args, **kwargs)
       self.fields['image'].options={
           'tags': 'new_image',
           'format': 'png'

    }

from django.db import models
from cloudinary.models import CloudinaryField

class Photo(models.Model):
    image = CloudinaryField('image')

from django.shortcuts import render, redirect

from .models import Photo
from .forms import PhotoForm

def upload(request):
  context = dict( backend_form = PhotoForm())

  if request.method == 'POST':
    form = PhotoForm(request.POST, request.FILES)
    if form.is_valid():
        form.save()
        return redirect('display')
  return render(request, 'upload.html', context)

def display(request):
    photos = Photo.objects.all()  # Retrieve all photos from the database
    return render(request, 'display.html', {'photos': photos})

from django.db import models
from django.contrib.auth.models import User
from cloudinary.models import CloudinaryField

class Lookbook(models.Model):
    """
    Model representing a lookbook created by a user.
    """
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    title = models.CharField(max_length=100)
    description = models.TextField(blank=True)
    overlay_image = CloudinaryField('overlay_images')
    orientation = models.CharField(max_length=10, choices=[('portrait', 'Portrait'), ('landscape', 'Landscape'), ('square', 'Square')], default='square')
    border_width = models.CharField(max_length=10, default='0px')
    border_color = models.CharField(max_length=10, default='black')

    def __str__(self):
        return self.title

class LookbookImage(models.Model):
    """
    Model representing an image associated with a lookbook.
    """
    lookbook = models.ForeignKey(Lookbook, on_delete=models.CASCADE, related_name='images')
    image = CloudinaryField('images')
    transformed_image = models.URLField(blank=True, null=True)

    def __str__(self):
        return f"Image for {self.lookbook.title}"

class LookbookForm(forms.ModelForm):
    """
    Form for creating or updating a lookbook.
    """

    class Meta:
        model = Lookbook
        fields = ['title', 'description', 'overlay_image']

    def save(self, commit=True):
        instance = super().save(commit=False)
        if commit:
            instance.save()
        return instance

class LookbookImageForm(forms.ModelForm):    
    """
    Form for handling LookbookImage model.
    """

    class Meta:
        model = LookbookImage
        fields = ['image']

    def save(self, commit=True, image_url=None):
        instance = super().save(commit=False)
        if commit:
            instance.save()
        return instance

def display(request, lookbook_id):
   lookbook = get_object_or_404(Lookbook, pk=lookbook_id)
   images = lookbook.images.all()
   return render(request, 'display.html', {'photos': images, 'lookbook': lookbook})

{% for photo in photos %}
   <div class="gallery-col">
      <div class="gallery-image">
          <!-- Display transformed image -->
          <img src="{{ photo.transformed_image }}" alt="Image" class="img-fluid">
          <div class="gallery-overlay">
             <!-- Link to view in a new browser tab -->
             <a href="{{ photo.transformed_image }}" target="_blank"><h5>Click to View</h5></a>
          </div>
      </div>
   </div>
{% endfor %}

from cloudinary.uploader import upload
from cloudinary.utils import cloudinary_url
from flask import Flask, render_template, request

app = Flask(__name__)


@app.route('/', methods=['GET', 'POST'])
def upload_file():
    upload_result = None
    thumbnail_url1 = None
    thumbnail_url2 = None
    if request.method == 'POST':
        file_to_upload = request.files['file']
        if file_to_upload:
            upload_result = upload(file_to_upload)
            thumbnail_url1, options = cloudinary_url(upload_result['public_id'], format="jpg", crop="fill", width=100,
                                                     height=100)
            thumbnail_url2, options = cloudinary_url(upload_result['public_id'], format="jpg", crop="fill", width=200,
                                                     height=100, radius=20, effect="sepia")
    return render_template('upload_form.html', upload_result=upload_result, thumbnail_url1=thumbnail_url1,
                           thumbnail_url2=thumbnail_url2)


if __name__ == "__main__":
    app.debug = True
    app.run()

...
@app.route("/output", methods=['POST'])
def output():
    selected_imgs = request.form.getlist("selected_imgs")
    if not selected_imgs:
        message = "Select at least one product image."
        recommendations = []
    else:
        result = all_images()
        tag_list = []
        for img in selected_imgs:
            for asset in result['resources']:
                if asset['public_id'] == img:
                    img_details = cloudinary.api.resource(img)
                    tag_list.extend(tag for tag in img_details['tags'] if tag not in ["adult", "my_products"])
        most_frequent_tags = most_frequent(tag_list)
        recommendations = []
        for frequent_tag in most_frequent_tags:
            for asset in result['resources']:
                show = "yes"
                img_details = cloudinary.api.resource(asset['public_id'])
                for i in selected_imgs:
                    if i == asset['public_id']:
                        show = "no"
                    if frequent_tag[0] in img_details['tags'] and show == "yes":
                        url="https://res.cloudinary.com/demo/image/upload/f_auto/q_auto/c_fill_pad,g_auto,w_100,h_100/v"+str(asset["version"])+"/" +asset["public_id"]         
                        if url not in recommendations:
                            recommendations.append(url)
        message = "We thought you might like to try these:"
    return render_template('output.html', recommendations=recommendations, msg=message)
...

...
# Create an upload preset to pre-process the images:

cloudinary.api.create_upload_preset(
  name = "pre-process",
  unsigned = True,  
  transformation = {"width": 400, "height": 400, "crop": "fill", "gravity": "auto", "effect": "grayscale"}
)

...
# Upload the images and apply the upload preset:

for x in range(1,5):
  cat_num="cat"+str(x)
  cat_url="https://res.cloudinary.com/demo/image/upload/v1/blogs/python-preprocessing/"+"cat"+str(x)
  dog_num="dog"+str(x)
  dog_url="https://res.cloudinary.com/demo/image/upload/v1/blogs/python-preprocessing/"+"dog"+str(x)
  resp_cat = cloudinary.uploader.upload(cat_url, public_id = cat_num, unique_filename = False, overwrite = True, upload_preset = "pre-process")
  print(resp_cat)
  resp_dog=cloudinary.uploader.upload(dog_url, public_id = dog_num, unique_filename = False, overwrite = True, upload_preset = "pre-process")
  print(resp_dog)

...
# Saturation
# Adjusted the image saturation to 70:

for x in range(1,3):
  id="dog" + str(x) + "_saturated"
  url="https://res.cloudinary.com/demo/image/upload/v1/blogs/python-preprocessing/"+"dog"+str(x)
  resp = cloudinary.uploader\
  .upload(url, public_id = id, unique_filename = False, overwrite = True,
    transformation = {"width": 400, "height": 400, "crop": "fill", "gravity": "auto", "effect": "saturation:70"})
  print(resp)