Introducción
Partir mensajes de correo electrónico programáticamente es un requisito común para la migración de datos, flujos de trabajo de archivo y herramientas de cumplimiento. Los ficheros MSG de Outlook utilizan el formato de contenedor Compound File Binary (CFB) con propiedades MAPI para codificar los metadatos de mensaje, contenido corporal, destinatarios y anexos. Trabajar con este formato en Python tradicionalmente requiere bibliotecas comerciales o manipulación binaria de bajo nivel.
El aspose-email-foss El paquete proporciona una biblioteca de Python puro, MIT licenciado para la lectura, creación y conversión de archivos MSG de Outlook. MapiMessage API para tareas comunes junto a niveles inferiores MsgReader La biblioteca requiere Python 3.10 o más tarde y no tiene dependencias nativas.
Ya sea que necesite extraer la línea y el cuerpo del tema de un conjunto de mensajes archivados, enumerar anexos para indexar o convertir los ficheros MSG en formato RFC 5322 estándar, esta biblioteca maneja el parsón binario para que pueda centrarse en su lógica de aplicación.
Lo que está incluido
Leer archivos MSG con MapiMessage
El MapiMessage clase es el punto de entrada principal para parscar archivos MSG de Outlook. abrir un archivo, acceder a sus propiedades y cerrarlo limpiamente con un gerente de contexto.
from aspose.email_foss import msg
with msg.MapiMessage.from_file("meeting-invite.msg") as message:
print(f"Subject: {message.subject}")
print(f"Body: {message.body[:200]}")
print(f"HTML body available: {message.body_html is not None}")
El from_file El método lee el contenedor CFB, parsa los flujos de propiedades MAPI y populaba atributos tipados. subject, body,y, body_html Las propiedades devuelven las líneas decodificadas directamente.
Extracción de recipientes
Cada archivo MSG almacena la información del destinatario en almacenes MAPI dedicados. MapiMessage.recipients La propiedad devuelve una lista de MapiRecipient Objetos con campos tipados para el nombre de pantalla, la dirección de correo electrónico y el tipo de destinatario (TO, CC o BCC).
from aspose.email_foss import msg
with msg.MapiMessage.from_file("team-update.msg") as message:
for recipient in message.recipients:
print(
f"{recipient.display_name} <{recipient.email_address}> "
f"type={recipient.recipient_type}"
)
Trabajar con los atributos
El iter_attachments_info El método de rendimiento MapiAttachment Objetos que proporcionan el nombre de archivo, bajetas crudas, tipo MIME y ID de contenido opcional para imágenes en línea.
from aspose.email_foss import msg
with msg.MapiMessage.from_file("report.msg") as message:
for att in message.iter_attachments_info():
print(f" {att.filename} ({att.mime_type}, {len(att.data)} bytes)")
if att.content_id:
print(f" inline content-id: {att.content_id}")
Acceso a las propiedades de MAPI
Para los escenarios que requieren valores de propiedad específicos MAPI más allá de los atributos de conveniencia, utilizar get_property_value con A PropertyId Esto proporciona acceso directo a cualquier propiedad almacenada en el archivo MSG.
from aspose.email_foss import msg
with msg.MapiMessage.from_file("notification.msg") as message:
sender = message.get_property_value(msg.PropertyId.SENDER_NAME)
email = message.get_property_value(msg.PropertyId.SENDER_EMAIL_ADDRESS)
delivery = message.get_property_value(msg.PropertyId.MESSAGE_DELIVERY_TIME)
print(f"From: {sender} <{email}>")
print(f"Delivered: {delivery}")
- Iterar todas las propiedades
Cuando necesitas inspeccionar cada propiedad en un mensaje (para desbloquear, auditoría o migración), el iter_properties El método de rendimiento MapiProperty Objetos con etiqueta completa y información de valor.
from aspose.email_foss import msg
with msg.MapiMessage.from_file("sample.msg") as message:
for prop in message.iter_properties():
print(
f"tag=0x{prop.property_tag:08X} "
f"type=0x{prop.property_type:04X} "
f"value={prop.value!r}"
)
Convertir MSG en EML
El to_email_message Convertir un MSG parsed en Python estándar. email.message.EmailMessage Desde allí se puede serializar el mensaje en formato RFC 5322 (EML) utilizando la biblioteca estándar.
from aspose.email_foss import msg
with msg.MapiMessage.from_file("archive.msg") as message:
email_message = message.to_email_message()
eml_bytes = email_message.as_bytes()
with open("archive.eml", "wb") as f:
f.write(eml_bytes)
Nota que la salida EML utiliza Python en el interior email La biblioteca maneja la conversión MSG-to-MAPI-a-EmailMessage; la biblioteca estándar maneje el formato de cable RFC 5322 .
Inicio rápido
Instalar el paquete de PyPI y parse su primer archivo MSG en menos de 20 líneas:
# Install: pip install aspose-email-foss>=26.3
from aspose.email_foss import msg
# Create a new message
message = msg.MapiMessage.create(
"Project status update",
"Hello team,\n\nPlease review the attached report.\n\nRegards",
)
message.add_recipient("alice@example.com", display_name="Alice")
message.add_attachment("notes.txt", b"meeting notes\n", mime_type="text/plain")
message.save("status-update.msg")
# Read it back and extract data
with msg.MapiMessage.from_file("status-update.msg") as loaded:
print(f"Subject: {loaded.subject}")
print(f"Recipients: {len(loaded.recipients)}")
for att in loaded.iter_attachments_info():
print(f"Attachment: {att.filename} ({len(att.data)} bytes)")
Formatos apoyados
| Formato | Extensiones | Leer | Escribe |
|---|---|---|---|
| El Outlook MSG | .msg | Sí | Sí |
| Composición de archivos binarios | .cfb | Sí | Sí |
| EML (via conversión) | .eml | Y sí (via) from_email_message) | Y sí (via) to_email_message) |
El soporte EML funciona a través de la conversión: MapiMessage.from_email_message() Importaciones de Python email.message.EmailMessage objeto y to_email_message() El parsillo de archivos EML directo no se proporciona — la biblioteca estándar gestiona el formato de cable EM L.
Open Source y Licenciación
Aspose.Email FOSS for Python is released under the MIT license. You are free to use, modify, and distribute the library in both commercial and non-commercial projects. The full source code is available on GitHub.
La biblioteca es una implementación de Python pura con ninguna extensión compilada o dependencias nativas. se lleva a cabo en cualquier plataforma que apoye Python 3.10 o más tarde.
Empezando a
Explora más recursos para trabajar con Aspose.Email FOSS para Python:
- Guía de desarrollador - Documentación completa con tutoriales y pasos de API
- Base de conocimientos - Cómo escribir artículos y preguntas frecuentes
- El referente de API - Referencia de clase y método completa
