This is my solution:

from PIL import Image
import io

def image_to_byte_array(image: Image) -> bytes:
  # BytesIO is a file-like buffer stored in memory
  imgByteArr = io.BytesIO()
  # image.save expects a file-like as a argument
  image.save(imgByteArr, format=image.format)
  # Turn the BytesIO object back into a bytes object
  imgByteArr = imgByteArr.getvalue()
  return imgByteArr

You can try this:

image = Image.frombytes('RGBA', (128,128), image_data, 'raw')

Source Code:

def frombytes(mode, size, data, decoder_name="raw", *args):
    param mode: The image mode.
    param size: The image size.
    param data: A byte buffer containing raw data for the given mode.
    param decoder_name: What decoder to use.

.. warning::

This method returns the raw image data from the internal storage. For compressed image data (e.g. PNG, JPEG) use :meth:~.save, with a BytesIO parameter for in-memory data.

This is the warning in the tobytes method. So we can use the save method with a BytesIO parameter to get a compressed byte array.

import io

byteIO = io.BytesIO()
image.save(byteIO, format='PNG')
byteArr = byteIO.getvalue()

If you already have the image on the filesystem:

    import os
    # Get the size in bytes.
    os.path.getsize("path_to_file.jpg")

If, however, you want to get the saved size of an image that is in memory and has not been saved to the filesystem:

    from io import BytesIO
    img_file = BytesIO()
    # quality='keep' is a Pillow setting that maintains the quantization of the image.
    # Not having the same quantization can result in different sizes between the in-
    # memory image and the file size on disk.
    image.save(img_file, "png", quality = "keep")
    image_file_size = img_file.tell()

NOTE: if you use a different quality setting for each method you can end up with a smaller size in one or the other.

This method will avoid multiple reads of the image data as with StringIO. Note, however, that it will use more RAM. Everything is a tradeoff. :-)

Edit: I just saw this comment from the OP:

finally, the problem is from the beginnig, if someone will upload a picture that have 1 giga (forged one) he'll kill the server before PIL will do its stuff, so i must block the request before it finishs!

This is a very different question, and is probably best accomplished at the web server. For nginx, you can add this to your configuration:

    http {
      # or whatever size you want as your limit
      client_max_body_size 100m;
    }