Guia de Desenvolvedores

Aspose.Note FOSS for Python is a free, open-source library for reading Microsoft OneNote .one secção de arquivos sem qualquer dependência do Microsoft Office. Ele fornece uma API pública limpa sob o aspose.note O pacote, modelado após a interface Aspose.Note para .NET. A biblioteca é adequada para automação de documentos, indexação do conteúdo, pipelines de extração e fluxos de trabalho de arquivo.

Este guia para desenvolvedores cobre toda a superfície da API pública disponível na versão 26.3.1, com exemplos de código executáveis para cada recurso principal.

Carregamento de documentos

Carregamento a .one O arquivo de um caminho de arquivos ou um fluxo binário. Document A classe é o ponto de entrada para todas as operações.

Carregar a partir de um caminho de arquivo

Carregar um ficheiro de secção do OneNote a partir do disco, passando o caminho diretamente para o arquivo. Document constructor:

from aspose.note import Document

doc = Document("MyNotes.one")

Carga de um fluxo binário

Útil ao ler de armazenamento em nuvem, respostas HTTP ou buffers na memória:

from pathlib import Path
from aspose.note import Document

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

Opções de carga

Utilização: LoadOptions Para definir parâmetros opcionais, tais como carregamento histórico antes de passar o objeto das opções para a Document constructor:

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 em: LoadOptions A tentativa de carregar um arquivo criptografado aumenta a probabilidade de que o usuário não tenha acesso ao código. IncorrectPasswordException.

Estrutura do documento (DOM)

O modelo de documento do OneNote é uma árvore enraizada em: Document.Cada nó expõe os acessores pai e filho para a travessia:

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

Todos os nós expõem ParentNode e a Document Os nós compostos suportam a iteração de filhos, FirstChild, LastChild, AppendChildLast, InsertChild, RemoveChild, e GetChildNodes(Type).

Páginas de iteração

As páginas são filhos diretos de: Document.Iterá-los directamente ou utilizar o código de identificação . 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}]")

Metadados da página:

PropriedadeTipo de veículo:Descrição:
Title`TitleNone`
Author`strNone`
CreationTime`datetimeNone`
LastModifiedTime`datetimeNone`
Level`intNone`

Extração de texto

Extrair todo o texto simples

Chama-me . GetChildNodes(RichText) para recolher cada RichText nó em um único recorrente atravessamento, então juntar-se ao .Text cordas:

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))

Inspecionar executar formatação

Cada um. RichText contém uma lista de: TextRun Cada corrida tem o seu próprio valor. 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)}]")

Extrair hiperlinks

Verificação run.Style.IsHyperlink em cada um dos seguintes: TextRun Identificar as corridas de hiperligações e ler Style.HyperlinkAddress para a URL de destino:

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)

Extração de imagem

Utilização: GetChildNodes(Image) para recolher todas as imagens incorporadas do documento e gravar os bytes brutos de cada imagem no disco:

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})")

Propriedades da imagem: FileName, Bytes, Width, Height, AlternativeTextTitle, AlternativeTextDescription, HyperlinkUrl, Tags.

Análise de tabela

Utilização: GetChildNodes(Table) para iterar todas as tabelas no documento, em seguida, atravessar TableRow e a) TableCell Nodos para extrair texto de célula:

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)

Arquivos anexados

Utilização: GetChildNodes(AttachedFile) para recuperar cada anexo de arquivo incorporado e escrever os seus bytes no disco sob o nome do arquivos original:

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 e listas numeradas

Inspecionar itens de Nota- Marca

Iterar o .Tags lista em cada um dos RichText ou a) Image nó para ler o Label e a) Icon Propriedades de todas as etiquetas do OneNote aplicadas no documento-fonte:

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}")

Inspecção das listas numeradas

Verifique a NumberList propriedade sobre cada um dos OutlineElement nó para ler o formato de qualquer lista numerada associada a esse elemento de contorno:

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}")

DocumentVisitor Pattern (Patrão de visitante)

Utilização: DocumentVisitor para implementar um visitante que percorra toda a árvore de documentos:

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}")

Exportação PDF

A exportação de PDF requer a dependência opcional ReportLab. Instala-a com:

pip install aspose-note

Exportação PDF básica

Passagem . SaveFormat.Pdf a) para o Document.Save() com um caminho de arquivo para escrever o documento inteiro como ficheiro PDF:

from aspose.note import Document, SaveFormat

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

Exportação PDF com opções

Criar um PdfSaveOptions instância e passar para o Document.Save() A Comissão tem de tomar medidas para que o mercado seja mais eficaz. BytesIO buffer em vez de um caminho para capturar os bytes na memória:

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 e a) PageCount No v26.3.1, a operação de salvar exporta todo o documento, independentemente desses valores.

Limitações actuais

Área de exploraçãoEstatuto da União Europeia
Leitura .one ArquivosSubscrito
Exportação PDF (através do ReportLab)Subscrito
A escrever de volta para: .oneNão aplicada
Documentos criptografadosNão apoiado (aumentos) IncorrectPasswordException)
HTML / imagem / formatos de salva ONEDeclarado compatível com API; aumentar UnsupportedSaveFormatException

Guia disponível

Ver também:

 Português