Struct AnnotatedExample 

pub struct AnnotatedExample {
    pub text: String,
    pub entities: Vec<GoldEntity>,
    pub domain: Domain,
    pub difficulty: Difficulty,
}

A single annotated NER example with text, entities, and metadata.

This is the canonical type for representing labeled NER data, whether from synthetic generation, manual annotation, or loaded from files.

Example

use anno_eval::eval::dataset::{AnnotatedExample, Domain, Difficulty};
use anno_eval::eval::GoldEntity;
use anno::EntityType;

let example = AnnotatedExample::new(
    "Microsoft announced earnings",
    vec![GoldEntity::new("Microsoft", EntityType::Organization, 0)],
);
assert_eq!(example.text, "Microsoft announced earnings");
assert_eq!(example.entities.len(), 1);

Fields

text: String

The input text.

entities: Vec<GoldEntity>

Gold standard entity annotations.

domain: Domain

Domain classification (e.g., News, Biomedical).

difficulty: Difficulty

Difficulty level (e.g., Easy, Hard).

Implementations

impl AnnotatedExample

pub fn new(text: impl Into<String>, entities: Vec<GoldEntity>) -> Self

Create a new annotated example with default domain/difficulty.

pub fn simple(text: impl Into<String>, entities: Vec<(&str, &str)>) -> Self

Convenience constructor from text and entity tuples (alias for from_tuples).

This is the same as from_tuples but with the shorter name commonly used in test code.

pub fn with_metadata( text: impl Into<String>, entities: Vec<GoldEntity>, domain: Domain, difficulty: Difficulty, ) -> Self

Create with explicit domain and difficulty.

pub fn from_tuples(text: impl Into<String>, entities: Vec<(&str, &str)>) -> Self

Convenience constructor for doctests and simple examples.

Entity positions are computed by finding each entity text within the input.

Panics

Panics if an entity text is not found in the input text.

Example

use anno_eval::eval::dataset::AnnotatedExample;

let example = AnnotatedExample::from_tuples(
    "John works at Google.",
    vec![("John", "PER"), ("Google", "ORG")],
);
assert_eq!(example.entities.len(), 2);

pub fn with_domain(self, domain: Domain) -> Self

Set the domain and return self (builder pattern).

pub fn with_difficulty(self, difficulty: Difficulty) -> Self

Set the difficulty and return self (builder pattern).

pub fn is_negative(&self) -> bool

Returns true if this example has no entities (negative example).

pub fn entity_count(&self) -> usize

Returns the number of entities.

pub fn entity_types(&self) -> Vec<&EntityType>

Returns unique entity types in this example.

pub fn as_test_case(&self) -> (&str, &[GoldEntity])

Convert to (text, entities) tuple for evaluation functions.

pub fn into_test_case(self) -> (String, Vec<GoldEntity>)

Consume and convert to owned (text, entities) tuple.

Trait Implementations

impl Clone for AnnotatedExample

fn clone(&self) -> AnnotatedExample

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AnnotatedExample

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AnnotatedExample

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Extend<AnnotatedExample> for NERDataset

fn extend<I: IntoIterator<Item = AnnotatedExample>>(&mut self, iter: I)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl FromIterator<AnnotatedExample> for NERDataset

fn from_iter<I: IntoIterator<Item = AnnotatedExample>>(iter: I) -> Self

Creates a value from an iterator.

impl Serialize for AnnotatedExample

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.