Ikkodifika u Ibgħat Immaġini f'Base64
F'din il-paġna
Għaliex Tuża Base64?
Fil-lezzjoni ta’ qabel, tgħallimt kif tibgħat immaġini permezz ta’ URL. Madankollu, il-biċċa l-kbira tal-immaġini pproċessati f’kuntesti tan-negozju m’għandhomx URL: fattura li għadha kemm waslet bil-posta elettronika, screenshot iġġenerat minn test awtomatizzat, jew ritratt meħud minn operatur fuq linja tal-produzzjoni. Li tippubblika dawn il-fajls fuq server aċċessibbli mill-internet sempliċiment biex tanalizzahom ikun assurdu, u spiss projbit.
Hawnhekk tidħol il-kodifika Base64. Din tittrasforma d-dejta binarja ta’ immaġini f’string ta’ test li tinkludi direttament fit-talba tal-API tiegħek, mingħajr ma teħtieġ URL estern jew hosting intermedjarju.
Meta Tuża URL vs Base64
| Kriterju | URL | Base64 |
|---|---|---|
| Immaġini diġà ospitati | Ideali | Mhux meħtieġ |
| Immaġini lokali | Mhux xieraq | Ideali |
| Immaġini iġġenerati dinamikament | Mhux xieraq | Ideali |
| Latenza tan-netwerk | Tiddependi mis-server | L-ebda (inkorporata) |
| Daqs tat-talba | Ħafif | Itqal (~33%) |
| Sigurtà/Privatezza | URL pubbliku | Dejta fit-talba |
Ir-regola hija sempliċi: jekk l-immaġini hija aċċessibbli permezz ta’ URL stabbli, uża l-URL. Inkella, uża Base64.
Kif Tikkodifika Immaġini għal Base64
M’hemmx bżonn ta’ dipendenzi; Python jipprovdi l-modulu base64 fil-librerija standard tiegħu:
import base64
def encode_image(file_path):
"""Encode an image file to a Base64 string."""
with open(file_path, "rb") as f:
return base64.standard_b64encode(f.read()).decode("utf-8")
# Encode a local image
image_b64 = encode_image("captures/screenshot.png")
print(f"Base64 string length: {len(image_b64)} characters")
Il-modalità "rb" meta tiftaħ il-fajl mhix għażla: li taqra immaġini f’modalità ta’ test se tqajjem żball fid-dekodifika. Stenna strings twal—il-kodifika tiżdied id-daqs b’madwar 33% meta mqabbla mal-fajl oriġinali, allura immaġini ta’ 1 MB tipproduċi madwar 1.33 MB ta’ test.
Il-Format Data URI
L-istring mhux ipproċessat mhuwiex biżżejjed: l-API trid tkun taf il-format tal-immaġini. Għalhekk, trid tippreżentaha bħala data URI, li jippreċedi d-dejta bit-tip MIME tagħha:
data:image/{format};base64,{base64_data}
L-erba’ prefissi użabbli jikkorrispondu għall-formati appoġġjati:
data:image/jpeg;base64,...data:image/png;base64,...data:image/gif;base64,...data:image/webp;base64,...
Li tħabbar PNG bħala image/jpeg tikkawża żball fl-ipproċessar; għalhekk il-funzjoni ta’ detezzjoni fl-eżempju li jmiss.
Eżempju Sħiħ
Hawnhekk hija l-katina sħiħa, mill-qari tal-fajl lokali sal-risposta tal-mudell:
import base64
import os
from mistralai.client import Mistral
def encode_image(chemin):
"""Encode a local image to Base64."""
with open(chemin, "rb") as f:
return base64.standard_b64encode(f.read()).decode("utf-8")
# Determine MIME type
def obtenir_mime(chemin):
"""Return MIME type based on extension."""
extensions = {
".jpg": "image/jpeg",
".jpeg": "image/jpeg",
".png": "image/png",
".gif": "image/gif",
".webp": "image/webp"
}
ext = os.path.splitext(chemin)[1].lower()
return extensions.get(ext, "image/jpeg")
# Prepare the image
chemin_image = "documents/facture-2024.png"
image_b64 = encode_image(chemin_image)
mime_type = obtenir_mime(chemin_image)
data_uri = f"data:{mime_type};base64,{image_b64}"
# Call the API
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
response = client.chat.complete(
model="mistral-small-latest",
messages=[
{
"role": "user",
"content": [
{"type": "text", "text": "Extract all information from this invoice."},
{"type": "image_url", "image_url": data_uri}
]
}
]
)
print(response.choices[0].message.content)
Il-punt ewlieni: il-qasam dejjem jissejjaħ image_url, anke meta fih data URI. L-istruttura tal-messaġġ ma tinbidilx affattu mil-Lezzjoni 4; biss il-valur huwa differenti.
Kif Tikkodifika Immaġini minn Sorsi Oħra
Fajl fuq id-diska huwa biss każ wieħed fost ħafna. Jekk l-immaġini tiegħek diġà teżisti fil-memorja, bħala oġġett Pillow minn pass ta’ qbid jew ipproċessar, li tiktebha fuq id-diska biss biex terġa’ taqraha immedjatament ikun devjazzjoni mhux meħtieġa—buffer tal-memorja jaħdem tajjeb:
import base64
from io import BytesIO
from PIL import Image
def pil_to_base64(pil_image):
"""Convert a Pillow image to a Base64 data URI."""
buffer = BytesIO()
pil_image.save(buffer, format="PNG")
b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")
return f"data:image/png;base64,{b64}"
# Example with a Pillow image
img = Image.open("capture.png")
data_uri = pil_to_base64(img)
L-istess loġika tapplika għal immaġini miksuba permezz ta’ HTTP li ma tridx taħżen, pereżempju għax tiġi minn link ta’ ħajja qasira:
import base64
import requests
def url_to_base64(url):
"""Download an image and convert it to a data URI."""
response = requests.get(url, timeout=10)
response.raise_for_status()
content_type = response.headers.get("Content-Type", "image/jpeg")
b64 = base64.standard_b64encode(response.content).decode("utf-8")
return f"data:{content_type};base64,{b64}"
data_uri = url_to_base64("https://example.com/photo.jpg")
Ottimizza d-Daqs Qabel ma Tikkodifika
Ritratt minn smartphone illum jiżen bejn 4 u 8 MB, li jsir kważi 10 MB darba kkodifikat. L-API se tbiddel id-daqs tagħha xorta waħda, kif rajt fil-Lezzjoni 2: tkun qed tħallas għat-trasferiment għalxejn. Għalhekk, dejjem ibdel id-daqs qabel ma tikkodifika.
from PIL import Image
from io import BytesIO
import base64
def preparer_et_encoder(chemin, taille_max=1024, qualite=85):
"""Resize, compress, and encode an image."""
img = Image.open(chemin)
# Resize if necessary
if max(img.size) > taille_max:
img.thumbnail((taille_max, taille_max))
# Convert to JPEG to reduce size
buffer = BytesIO()
img.convert("RGB").save(buffer, format="JPEG", quality=qualite)
b64 = base64.standard_b64encode(buffer.getvalue()).decode("utf-8")
taille_ko = len(buffer.getvalue()) / 1024
print(f"Encoded image: {taille_ko:.0f} KB")
return f"data:image/jpeg;base64,{b64}"
data_uri = preparer_et_encoder("photo_haute_resolution.png")
Li turi d-daqs finali mhix biss dekorattiva: żommha matul it-testijiet tiegħek, peress li tgħidlek immedjatament jekk il-pipeline tiegħek qed jibgħatx 80 KB jew 8 MB f’kull sejħa.
Limiti li Trid Tkun Taf
Hemm tliet restrizzjonijiet marbuta ma’ Base64. L-immaġini kkodifikata tiżdied mal-korp tat-talba HTTP, allura lil hinn minn 10 MB tirriskja timeouts. Il-kodifika wkoll tgħabbi l-immaġini sħiħa fil-memorja: għall-ipproċessar bil-biċċiet, immaniġġja l-immaġini waħda waħda minflok ma tibni lista ta’ elf string ikkodifikat. Fl-aħħar nett, kuntrarjament għall-URLs, l-immaġini Base64 jiġu ritrasmessi kompletament ma’ kull talba—li tanalizza l-istess fattura darbtejn ifisser li tibgħatha darbtejn.
Punti Ewlenin
- Base64 huwa ideali għal immaġini lokali jew iġġenerati dinamikament
- Il-format data URI jgħaqqad it-tip MIME u d-dejta:
data:image/png;base64,... - Ibdel id-daqs u kkumpressja l-immaġini tiegħek qabel ma tikkodifika biex tottimizza l-latenza
- Base64 jiżdied id-daqs b’madwar 33%—żomm l-immaġini tiegħek taħt 10 MB
- Uża URL meta l-immaġini tkun diġà ospitata, u Base64 fil-każijiet l-oħra kollha