use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct BoundingBox {
pub page: u32,
pub x: f64,
pub y: f64,
pub width: f64,
pub height: f64,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct Coords {
pub boxes: Vec<BoundingBox>,
}
impl Coords {
pub fn parse(value: &str) -> Result<Self, crate::Error> {
let mut boxes = Vec::new();
for part in value.split(';') {
let fields: Vec<&str> = part.split(',').map(str::trim).collect();
let [page, x, y, width, height] = fields[..] else {
return Err(crate::Error::InvalidCoords {
value: value.to_string(),
});
};
let parse = |s: &str| {
s.parse::<f64>().map_err(|_| crate::Error::InvalidCoords {
value: value.to_string(),
})
};
let page = page
.parse::<u32>()
.map_err(|_| crate::Error::InvalidCoords {
value: value.to_string(),
})?;
boxes.push(BoundingBox {
page,
x: parse(x)?,
y: parse(y)?,
width: parse(width)?,
height: parse(height)?,
});
}
Ok(Coords { boxes })
}
pub fn is_empty(&self) -> bool {
self.boxes.is_empty()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Surface {
pub page: u32,
pub width: f64,
pub height: f64,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Author {
#[serde(skip_serializing_if = "Option::is_none")]
pub full_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub given_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub middle_name: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub surname: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub orcid: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub affiliation: Option<Affiliation>,
#[serde(skip_serializing_if = "Option::is_none")]
pub coords: Option<Coords>,
}
impl Author {
pub fn is_empty(&self) -> bool {
self.full_name.is_none()
&& self.given_name.is_none()
&& self.middle_name.is_none()
&& self.surname.is_none()
&& self.email.is_none()
&& self.orcid.is_none()
&& self.affiliation.as_ref().is_none_or(Affiliation::is_empty)
}
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Affiliation {
#[serde(skip_serializing_if = "Option::is_none")]
pub institution: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub department: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub laboratory: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub address: Option<Address>,
#[serde(skip_serializing_if = "Option::is_none")]
pub coords: Option<Coords>,
}
impl Affiliation {
pub fn is_empty(&self) -> bool {
self.institution.is_none()
&& self.department.is_none()
&& self.laboratory.is_none()
&& self.address.is_none()
}
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Address {
#[serde(skip_serializing_if = "Option::is_none")]
pub addr_line: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub post_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub settlement: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub country: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Biblio {
#[serde(skip_serializing_if = "Vec::is_empty")]
pub authors: Vec<Author>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub editors: Vec<Author>,
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub raw_reference: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub date: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub book_title: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub series_title: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub journal: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub journal_abbrev: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub publisher: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub institution: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub issn: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub eissn: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub volume: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub issue: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pages: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub first_page: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub last_page: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub note: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub doi: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pmid: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pmcid: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub arxiv_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pii: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub ark: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub istex_id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub coords: Option<Coords>,
}
impl Biblio {
pub fn is_empty(&self) -> bool {
if !self.authors.is_empty() || !self.editors.is_empty() {
return false;
}
!any_nonempty(&[
self.date.as_deref(),
self.title.as_deref(),
self.journal.as_deref(),
self.publisher.as_deref(),
self.volume.as_deref(),
self.issue.as_deref(),
self.pages.as_deref(),
self.doi.as_deref(),
self.pmid.as_deref(),
self.pmcid.as_deref(),
self.arxiv_id.as_deref(),
self.url.as_deref(),
])
}
}
fn any_nonempty(values: &[Option<&str>]) -> bool {
values.iter().any(|v| v.is_some_and(|s| !s.is_empty()))
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Header {
#[serde(flatten)]
pub biblio: Biblio,
}
impl std::ops::Deref for Header {
type Target = Biblio;
fn deref(&self) -> &Biblio {
&self.biblio
}
}
impl std::ops::DerefMut for Header {
fn deref_mut(&mut self) -> &mut Biblio {
&mut self.biblio
}
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Citation {
pub index: usize,
#[serde(flatten)]
pub biblio: Biblio,
}
impl std::ops::Deref for Citation {
type Target = Biblio;
fn deref(&self) -> &Biblio {
&self.biblio
}
}
impl std::ops::DerefMut for Citation {
fn deref_mut(&mut self) -> &mut Biblio {
&mut self.biblio
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum RefKind {
#[serde(rename = "bibr")]
Biblio,
#[serde(rename = "figure")]
Figure,
#[serde(rename = "table")]
Table,
#[serde(rename = "formula")]
Formula,
#[serde(untagged)]
Other(String),
}
impl Default for RefKind {
fn default() -> Self {
RefKind::Other(String::new())
}
}
impl RefKind {
pub(crate) fn from_tei(value: Option<&str>) -> Self {
match value {
Some("bibr") => RefKind::Biblio,
Some("figure") => RefKind::Figure,
Some("table") => RefKind::Table,
Some("formula") => RefKind::Formula,
other => RefKind::Other(other.unwrap_or_default().to_string()),
}
}
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct MarkerRef {
pub kind: RefKind,
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
#[serde(skip_serializing_if = "String::is_empty")]
pub label: String,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Sentence {
#[serde(skip_serializing_if = "String::is_empty")]
pub text: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub coords: Option<Coords>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Paragraph {
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(skip_serializing_if = "String::is_empty")]
pub text: String,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub sentences: Vec<Sentence>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub markers: Vec<MarkerRef>,
#[serde(skip_serializing_if = "Option::is_none")]
pub coords: Option<Coords>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Figure {
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub figure_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub head: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub caption: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub coords: Option<Coords>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Formula {
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(skip_serializing_if = "String::is_empty")]
pub text: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub coords: Option<Coords>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Note {
#[serde(skip_serializing_if = "Option::is_none")]
pub place: Option<String>,
#[serde(skip_serializing_if = "String::is_empty")]
pub text: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub coords: Option<Coords>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct List {
#[serde(skip_serializing_if = "Option::is_none")]
pub list_type: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub items: Vec<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum Block {
Paragraph(Paragraph),
Figure(Figure),
Formula(Formula),
Note(Note),
List(List),
Div(Box<Div>),
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Div {
#[serde(skip_serializing_if = "Option::is_none")]
pub div_type: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub head: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub number: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub blocks: Vec<Block>,
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub coords: Option<Coords>,
}
impl Div {
pub fn paragraphs(&self) -> Vec<&Paragraph> {
fn collect<'a>(div: &'a Div, out: &mut Vec<&'a Paragraph>) {
for block in &div.blocks {
match block {
Block::Paragraph(p) => out.push(p),
Block::Div(sub) => collect(sub, out),
_ => {}
}
}
}
let mut out = Vec::new();
collect(self, &mut out);
out
}
pub fn figures(&self) -> Vec<&Figure> {
fn collect<'a>(div: &'a Div, out: &mut Vec<&'a Figure>) {
for block in &div.blocks {
match block {
Block::Figure(f) => out.push(f),
Block::Div(sub) => collect(sub, out),
_ => {}
}
}
}
let mut out = Vec::new();
collect(self, &mut out);
out
}
pub fn subsections(&self) -> impl Iterator<Item = &Div> {
self.blocks.iter().filter_map(|block| match block {
Block::Div(div) => Some(div.as_ref()),
_ => None,
})
}
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(default)]
pub struct Document {
#[serde(skip_serializing_if = "Option::is_none")]
pub grobid_version: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub grobid_timestamp: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub pdf_md5: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub language: Option<String>,
pub header: Header,
#[serde(skip_serializing_if = "Option::is_none")]
pub abstract_text: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub body: Vec<Div>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub body_notes: Vec<Note>,
#[serde(skip_serializing_if = "Option::is_none")]
pub acknowledgements: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub annexes: Option<String>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub citations: Vec<Citation>,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub facsimile: Vec<Surface>,
}
impl Document {
pub fn body_text(&self) -> String {
let mut parts = Vec::new();
for div in &self.body {
collect_div_text(div, &mut parts);
}
for note in &self.body_notes {
parts.push(note.text.clone());
}
parts.join(" ")
}
pub fn find_citation(&self, id: &str) -> Option<&Citation> {
let id = id.strip_prefix('#').unwrap_or(id);
self.citations.iter().find(|c| c.id.as_deref() == Some(id))
}
}
fn collect_div_text(div: &Div, out: &mut Vec<String>) {
if let Some(head) = &div.head {
out.push(head.clone());
}
for block in &div.blocks {
match block {
Block::Paragraph(p) => out.push(p.text.clone()),
Block::Figure(f) => {
if let Some(head) = &f.head {
out.push(head.clone());
}
if let Some(caption) = &f.caption {
out.push(caption.clone());
}
}
Block::Formula(f) => out.push(f.text.clone()),
Block::Note(n) => out.push(n.text.clone()),
Block::List(list) => out.extend(list.items.iter().cloned()),
Block::Div(div) => collect_div_text(div, out),
}
}
}