Comment analyser des documents Microsoft Word (.docx) dans Rust | de Radovan Stevanovic | janvier 2023

Extraction de texte à l’aide d’un tas de bibliothèques Rust

L’analyse des fichiers .docx peut être utile dans de nombreuses applications, telles que l’analyse de texte, l’extraction de données et la conversion de documents. Cet article examinera une solution pour analyser les fichiers .docx à l’aide du langage de programmation Rust.

Notre solution est une simple application en ligne de commande qui prend un nom de fichier en entrée et imprime le contenu textuel du document sur la console.

Nous utiliserons un ensemble de bibliothèques et de dépendances pour accomplir cela, y compris clap pour analyser les arguments de la ligne de commande, docx-rs pour analyser le fichier .docx, serde_json pour convertir les données analysées en un objet JSON, std pour les opérations d’E/S de fichiers, et anyhow.

Voici un organigramme pour montrer le processus global :

       +-------------+ 
|  .docx file |
+-------------+
|
|
+----------------+
|   read_to_vec  |
+----------------+
|
|
+--------------+
|   read_docx  |
+--------------+
|
|
+---------------+
|   parse_docx  |
+---------------+
|
|
+------------------+
| Print to console |
+------------------+

Maintenant que nous avons un aperçu de la solution, approfondissons les bibliothèques et les dépendances que nous utiliserons dans ce code.

Avant de pouvoir commencer, nous devons nous assurer que les bibliothèques nécessaires sont installées. Nous utiliserons le clap, docx_rs, serde_json, anyhowet la bibliothèque standard Rust. Vous pouvez les ajouter à votre Cargo.toml:

[dependencies]
anyhow = "1.0.68"
clap = "2.33.0"
docx_rs = "0.1.1"
serde_json = "1.0.58"

La première étape de l’analyse d’un fichier .docx consiste à lire son contenu dans un vecteur d’octets. Nous pouvons utiliser le std::fs::File et std::io::Read modules de la bibliothèque standard Rust pour accomplir cette tâche.

Voici la fonction read_to_vec, qui accepte le nom du fichier et lit son contenu dans un Vec<u8>:

fn read_to_vec(file_name: &str) -> anyhow::Result<Vec<u8>> {
let mut buf = Vec::new();
std::fs::File::open(file_name)?.read_to_end(&mut buf)?;
Ok(buf)
}

Une fois que nous avons le contenu du fichier .docx dans un vecteur d’octets, nous pouvons le passer au read_docx fonction fournie par le docx_rs une bibliothèque. Cette fonction analysera le contenu du fichier .docx et renverra un Docx struct qui contient le contenu textuel du fichier au format JSON.

Voici la fonction parse_docx, qui accepte le nom du fichier comme argument et analyse le fichier docx en utilisant docx_rs et renvoie la valeur JSON du fichier docx

fn parse_docx(file_name: &str) -> anyhow::Result<()> {
let data: Value = serde_json::from_str(&read_docx(&read_to_vec(file_name)?)?.json())?;
if let Some(children) = data["document"]["children"].as_array() {
children.iter().for_each(read_children);
}
Ok(())
}

Une fois que nous avons la valeur JSON du fichier .docx, nous pouvons utiliser le serde_json bibliothèque pour extraire le contenu du texte. La valeur JSON contient une structure imbriquée d’éléments, nous devons donc parcourir l’arborescence et rechercher des éléments de texte de manière récursive. Nous pouvons utiliser le Value structure fournie par le serde_json bibliothèque pour représenter une valeur JSON.

Voici read_children fonction, qui accepte le nœud et vérifie s’il a une clé ‘enfants’ et de type tableau, puis il itère sur les enfants et appelle le read_children fonction si le type de l’enfant n’est pas « texte ». Sinon, il imprime le contenu textuel de l’enfant.

fn read_children(node: &Value) {
if let Some(children) = node["data"]["children"].as_array() {
children.iter().for_each(|child| {
if child["type"] != "text" {
read_children(child);
} else {
println!("{}", child["data"]["text"]);
}
});
}
}

Nous pouvons maintenant assembler toutes les pièces dans la fonction principale. Tout d’abord, nous analysons les arguments de la ligne de commande à l’aide de la Args::parse() fonction fournie par le clap une bibliothèque. Ensuite, on appelle le parse_docx fonction avec le nom du fichier à analyser, qui à son tour appelle la read_to_vec, read_docx et read_children une fonction. Enfin, la fonction principale renvoie Ok(()).

fn main() -> anyhow::Result<()> {
let args = Args::parse();
parse_docx(&args.name)?;
Ok(())
}

Le code complet ressemble à ceci :

use clap::Parser;
use docx_rs::*;
use serde_json::Value;
use std::io::Read;
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
#[arg(short, long)]
name: String,
}
fn parse_docx(file_name: &str) -> anyhow::Result<()> {
let data: Value = serde_json::from_str(&read_docx(&read_to_vec(file_name)?)?.json())?;
if let Some(children) = data["document"]["children"].as_array() {
children.iter().for_each(read_children);
}
Ok(())
}
fn read_children(node: &Value) {
if let Some(children) = node["data"]["children"].as_array() {
children.iter().for_each(|child| {
if child["type"] != "text" {
read_children(child);
} else {
println!("{}", child["data"]["text"]);
}
});
}
}
fn read_to_vec(file_name: &str) -> anyhow::Result<Vec<u8>> {
let mut buf = Vec::new();
std::fs::File::open(file_name)?.read_to_end(&mut buf)?;
Ok(buf)
}
fn main() -> anyhow::Result<()> {
let args = Args::parse();
parse_docx(&args.name)?;
Ok(())
}

Dans cet article de blog, nous avons montré comment utiliser le langage de programmation Rust pour analyser le contenu d’un fichier .docx et extraire son contenu textuel. Nous avons utilisé le docx_rs et serde_json bibliothèques pour accomplir cette tâche.

Ceci est un exemple de base de la façon d’analyser les fichiers .docx à l’aide de Rust. Comprendre le format docx et la représentation JSON peut rendre les fonctionnalités plus complexes. Cela peut être utilisé pour extraire des informations de nombreux fichiers docx ou pour automatiser le processus d’extraction de texte.