Guía del desarrollador

Aspose.Note FOSS for Python is a free, open-source library for reading Microsoft OneNote .one archivos de sección sin ninguna dependencia de Microsoft Office. Proporciona una API pública limpia bajo el aspose.note paquete, modelado después del Aspose.Note para la interfaz .NET. La biblioteca es adecuada para la automatización de documentos, indexación de contenido, canalizaciones de extracción de datos y flujos de trabajo de archivado.

Esta guía para desarrolladores cubre toda la superficie de la API pública disponible en la versión 26.3.1, con ejemplos de código ejecutables para cada característica principal.

Carga de Documentos

Cargar un .one archivo desde una ruta de archivo o un flujo binario. El Document clase es el punto de entrada para todas las operaciones.

Cargar desde una ruta de archivo 

from aspose.note import Document

doc = Document("MyNotes.one")

Cargar desde un flujo binario

Útil al leer desde almacenamiento en la nube, respuestas HTTP o buffers en memoria:

from pathlib import Path
from aspose.note import Document

with Path("MyNotes.one").open("rb") as f:
    doc = Document(f)

Opciones de carga

Usar LoadOptions para establecer parámetros opcionales al cargar:

from aspose.note import Document, LoadOptions

opts = LoadOptions()
opts.LoadHistory = True   # Include page history in the DOM
doc = Document("MyNotes.one", opts)

Nota: DocumentPassword existe en LoadOptions para compatibilidad de API, pero los documentos cifrados no son compatibles. Intentar cargar un archivo cifrado genera IncorrectPasswordException.

Estructura del Documento (DOM)

El modelo de documento OneNote es un árbol:

Document
  └── Page (0..n)
        ├── Title
        │     ├── TitleText (RichText)
        │     ├── TitleDate (RichText)
        │     └── TitleTime (RichText)
        └── Outline (0..n)
              └── OutlineElement (0..n)
                    ├── RichText
                    ├── Image
                    ├── Table
                    │     └── TableRow
                    │           └── TableCell
                    │                 └── RichText / Image
                    └── AttachedFile

Cada nodo expone ParentNode y un Document propiedad que recorre hasta la raíz. Los nodos compuestos admiten iteración de hijos, FirstChild, LastChild, AppendChildLast, InsertChild, RemoveChild, y GetChildNodes(Type).

Iteración de Páginas

Las páginas son los hijos directos de Document. Itera directamente o usa GetChildNodes:

from aspose.note import Document, Page

doc = Document("MyNotes.one")

for page in doc:
    title = page.Title.TitleText.Text if page.Title and page.Title.TitleText else "(untitled)"
    author = page.Author or "(unknown)"
    print(f"  {title}  [by {author}]")

Metadatos de la página:

PropiedadTipoDescripción
Title`TitleNone`
Author`strNone`
CreationTime`datetimeNone`
LastModifiedTime`datetimeNone`
Level`intNone`

Extracción de texto

Extraer todo el texto plano 

from aspose.note import Document, RichText

doc = Document("MyNotes.one")
all_text = [rt.Text for rt in doc.GetChildNodes(RichText) if rt.Text]
print("\n".join(all_text))

Inspeccionar ejecuciones de formato

Cada RichText contiene una lista de TextRun segmentos. Cada ejecución lleva su propio TextStyle:

from aspose.note import Document, RichText

doc = Document("FormattedNotes.one")
for rt in doc.GetChildNodes(RichText):
    for run in rt.TextRuns:
        style = run.Style
        flags = []
        if style.IsBold: flags.append("bold")
        if style.IsItalic: flags.append("italic")
        if style.IsHyperlink: flags.append(f"link={style.HyperlinkAddress}")
        print(f"{run.Text!r:40s} [{', '.join(flags)}]")

Extraer hipervínculos 

from aspose.note import Document, RichText

doc = Document("MyNotes.one")
for rt in doc.GetChildNodes(RichText):
    for run in rt.TextRuns:
        if run.Style.IsHyperlink and run.Style.HyperlinkAddress:
            print(run.Text, "->", run.Style.HyperlinkAddress)

Extracción de imágenes 

from aspose.note import Document, Image

doc = Document("MyNotes.one")
for i, img in enumerate(doc.GetChildNodes(Image), start=1):
    name = img.FileName or f"image_{i}.bin"
    with open(name, "wb") as f:
        f.write(img.Bytes)
    print(f"Saved {name}  ({img.Width}x{img.Height})")

Propiedades de la imagen: FileName, Bytes, Width, Height, AlternativeTextTitle, AlternativeTextDescription, HyperlinkUrl, Tags.

Análisis de tablas 

from aspose.note import Document, Table, TableRow, TableCell, RichText

doc = Document("MyNotes.one")
for table in doc.GetChildNodes(Table):
    print("Column widths:", [col.Width for col in table.Columns])
    for r, row in enumerate(table.GetChildNodes(TableRow), start=1):
        cells = row.GetChildNodes(TableCell)
        row_text = [
            " ".join(rt.Text for rt in cell.GetChildNodes(RichText)).strip()
            for cell in cells
        ]
        print(f"Row {r}:", row_text)

Archivos adjuntos 

from aspose.note import Document, AttachedFile

doc = Document("NotesWithAttachments.one")
for i, af in enumerate(doc.GetChildNodes(AttachedFile), start=1):
    name = af.FileName or f"attachment_{i}.bin"
    with open(name, "wb") as f:
        f.write(af.Bytes)
    print(f"Saved: {name}")

Etiquetas y listas numeradas

Inspeccionar elementos NoteTag 

from aspose.note import Document, RichText, Image, Table

doc = Document("TaggedNotes.one")
for rt in doc.GetChildNodes(RichText):
    for tag in rt.Tags:
        print(f"RichText tag: {tag.Label} icon={tag.Icon}")
for img in doc.GetChildNodes(Image):
    for tag in img.Tags:
        print(f"Image tag: {tag.Label}")

Inspeccionar listas numeradas 

from aspose.note import Document, OutlineElement

doc = Document("NumberedNotes.one")
for oe in doc.GetChildNodes(OutlineElement):
    nl = oe.NumberList
    if nl:
        print(f"format={nl.Format!r}")

Patrón DocumentVisitor

Usar DocumentVisitor para implementar un visitante que recorre todo el árbol del documento:

from aspose.note import Document, DocumentVisitor, Page, RichText, Image

class ContentCounter(DocumentVisitor):
    def __init__(self):
        self.pages = 0
        self.texts = 0
        self.images = 0

    def VisitPageStart(self, page: Page) -> None:
        self.pages += 1

    def VisitRichTextStart(self, rt: RichText) -> None:
        self.texts += 1

    def VisitImageStart(self, img: Image) -> None:
        self.images += 1

doc = Document("MyNotes.one")
counter = ContentCounter()
doc.Accept(counter)
print(f"Pages: {counter.pages}, Texts: {counter.texts}, Images: {counter.images}")

Exportación a PDF

La exportación a PDF requiere la dependencia opcional ReportLab. Instálala con:

pip install "aspose-note[pdf]"

Exportación básica de PDF 

from aspose.note import Document, SaveFormat

doc = Document("MyNotes.one")
doc.Save("output.pdf", SaveFormat.Pdf)

Exportación de PDF con opciones 

import io
from aspose.note import Document, SaveFormat
from aspose.note.saving import PdfSaveOptions

doc = Document("MyNotes.one")

##With save options
opts = PdfSaveOptions()
doc.Save("output.pdf", opts)

##Save to in-memory stream
buf = io.BytesIO()
doc.Save(buf, PdfSaveOptions())
pdf_bytes = buf.getvalue()

Nota: PdfSaveOptions.PageIndex y PageCount los campos existen pero no se envían al exportador PDF en la v26.3.1. El documento completo siempre se exporta.

Limitaciones actuales

ÁreaEstado
Lectura .one archivosTotalmente compatible
Exportación PDF (a través de ReportLab)Compatible
Escribiendo de nuevo a .oneNo implementado
Documentos encriptadosNo compatible (lanza IncorrectPasswordException)
HTML / imagen / formatos de guardado ONEDeclarado para compatibilidad de API; raise UnsupportedSaveFormatException

Guías disponibles

Ver también

 Español