Introduktion
Aspose.Email FOSS för Python är ett gratis, MIT-licensierat bibliotek för att skapa, läsa och konvertera Outlook-kompatibla meddelandefiler i ren Python. Tillgängligt på PyPI som aspose-email-foss, fungerar det på Windows, macOS, Linux, Docker och serverlösa miljöer utan Microsoft Office-beroende och utan proprietär runtime.
Biblioteket täcker två huvudområden: ett hög nivå MAPI-lager (MapiMessage) för att arbeta med meddelandeämnen, brödtexter, mottagare och bilagor; samt ett låg nivå strukturlager (MsgReader, CFBReader, CFBStorage, CFBStream) som exponerar de råa Compound File Binary-containrarna som ligger till grund för varje .msg-fil.
Den här artikeln går igenom de viktiga funktionerna som levererades i version 26.3, baserat på den bekräftade API-ytan.
Huvudfunktioner
Meddelandeskapande på hög nivå med MapiMessage
MapiMessage är den primära ingångspunkten för att skapa Outlook-kompatibla meddelanden från grunden. Anropa MapiMessage.create() med ett ämne och en brödtext, lägg till mottagare och bilagor, och spara sedan direkt till en .msg-fil.
from aspose.email_foss import msg
message = msg.MapiMessage.create(
"Quarterly status update",
"Hello team,\n\nPlease review the attached summary.\n\nRegards,\nEngineering",
)
message.set_property(msg.PropertyId.SENDER_NAME, "Build Agent")
message.set_property(msg.PropertyId.SENDER_EMAIL_ADDRESS, "agent@example.com")
message.add_recipient("alice@example.com", display_name="Alice Example")
message.add_recipient(
"carol@example.com",
display_name="Carol Example",
recipient_type=msg.RECIPIENT_TYPE_CC,
)
message.add_attachment("report.txt", b"Summary content here.\n", mime_type="text/plain")
message.save("output.msg")
Läsa och inspektera MSG-filer
MsgReader ger strukturerad åtkomst till en befintlig .msg-fil utan att helt ladda den i en MapiMessage. Den exponerar top-nivå egenskapsposter, mottagar-lagringar och bilagors-lagringar individuellt, vilket gör den praktisk för inspektion av stora filer och validerings-pipelines.
from aspose.email_foss import msg
with msg.MsgReader.from_file("output.msg") as reader:
header = reader.top_level_header
print(f"Recipients : {header.recipient_count}")
print(f"Attachments: {header.attachment_count}")
for entry in reader.iter_recipient_storages():
_, props = reader.parse_subobject_property_stream(entry.stream_id)
print(f" Recipient storage {entry.name}: {len(props)} property entries")
MSG-rundresa: Läs, ändra, spara
Eftersom MapiMessage stödjer from_file() för inläsning och save() för skrivning, kräver en fullständig läs-ändra-skriv-cykel bara några få rader. Namngivna egenskaper, typade uppräkningar och Unicode-stränghantering finns tillgängliga via set_property, PropertyId och MapiNamedProperty.
from aspose.email_foss import msg
with msg.MapiMessage.from_file("original.msg") as message:
message.set_property(msg.PropertyId.SUBJECT, "Updated Subject")
message.save("updated.msg")
EML / RFC-5322-konvertering
MapiMessage.to_email_message() konverterar en inläst MSG till ett standard Python email.message.EmailMessage-objekt, vilket möjliggör export till RFC 5322 .eml-format med standardbiblioteket. Den omvända riktningen (MapiMessage.from_email_message()) bygger ett MapiMessage från en EmailMessage.
from pathlib import Path
from aspose.email_foss import msg
with msg.MapiMessage.from_file("message.msg") as message:
eml_bytes = message.to_email_bytes()
Path("message.eml").write_bytes(eml_bytes)
# Reverse: load EML into MapiMessage
import email
raw_eml = Path("message.eml").read_bytes()
email_obj = email.message_from_bytes(raw_eml)
mapi = msg.MapiMessage.from_email_message(email_obj)
mapi.save("from_eml.msg")
CFB-behållartraversering
Varje .msg-fil är en Compound File Binary (CFB)-behållare. CFBReader ger skrivskyddad åtkomst till katalogträdet, så att du kan lista lagringar och strömmar, gå igenom hierarkin och extrahera råa stream-bytes — utan att förlita dig på MsgReader.
from aspose.email_foss.cfb import CFBReader
with CFBReader.from_file("message.msg") as reader:
print(f"CFB version : {reader.major_version}")
print(f"Sector size : {reader.sector_size}")
for depth, entry in reader.iter_tree():
indent = " " * depth
size = entry.stream_size if entry.is_stream() else "-"
print(f"{indent}{entry.name} [size={size}]")
Hantera bilagor
Bilagor läggs till via MapiMessage.add_attachment() (för binär data) eller MapiMessage.add_embedded_message_attachment() (för inbäddade MSG-meddelanden). Båda metoderna accepterar ett filnamn, råa bytes och en valfri MIME-typ.
from aspose.email_foss import msg
message = msg.MapiMessage.create("Attachment demo", "See files below.")
message.add_attachment("data.csv", b"id,value\n1,100\n", mime_type="text/csv")
inner = msg.MapiMessage.create("Nested message", "This is embedded.")
message.add_embedded_message_attachment(inner, "nested.msg")
message.save("with_attachments.msg")
Snabbstart
pip install aspose-email-fossfrom aspose.email_foss import msg
# Create and save a minimal MSG
message = msg.MapiMessage.create("Hello World", "This is a test message.")
message.set_property(msg.PropertyId.SENDER_EMAIL_ADDRESS, "sender@example.com")
message.add_recipient("recipient@example.com", display_name="Recipient")
message.save("hello.msg")
# Load it back and convert to EML
with msg.MapiMessage.from_file("hello.msg") as loaded:
print(loaded.get_property_value(msg.PropertyId.SUBJECT))
eml = loaded.to_email_bytes()
open("hello.eml", "wb").write(eml)
Stödda format
| Format | Filändelse | Läs | Skriv |
|---|---|---|---|
| Compound File Binary | .cfb | ✓ | ✓ |
| Outlook-meddelande | .msg | ✓ | ✓ |
| EML / RFC 5322 | .eml | ✓ | ✓ |
Öppen källkod & licensiering
Aspose.Email FOSS för Python släpps under MIT-licensen. Källkodsrepositoriet finns på github.com/aspose-email-foss och paketet publiceras på PyPI som aspose-email-foss. Kommersiell användning, modifiering och vidaredistribution är alla tillåtna enligt MIT-villkoren.
