glazing.propbank.models¶

PropBank core data models.

`models` ¶

PropBank data models.

Defines Pydantic models for PropBank framesets, rolesets, and annotations.

CLASS	DESCRIPTION
`Frameset`	Container for all senses of a predicate.
`Alias`	Alias for a predicate with part of speech.
`ArgAlias`	Argument-specific alias.
`Aliases`	Container for all alias types.
`Usage`	Usage information for a resource.
`UsageNotes`	Container for usage information.
`Roleset`	A single sense of a predicate with its semantic roles.
`Role`	Semantic role definition.
`RoleLink`	Link from a role to VerbNet/FrameNet.
`LexLink`	Confidence-scored link to external resource.
`PropBankAnnotation`	PropBank annotation structure for examples.
`Arg`	Argument annotation in an example.
`Rel`	Relation/predicate marker in example.
`AMRAnnotation`	AMR annotation for an example.
`Example`	Annotated example sentence.

Classes¶

`AMRAnnotation` `pydantic-model` ¶

Bases: GlazingBaseModel

AMR annotation for an example.

ATTRIBUTE	DESCRIPTION
`version`	AMR version. TYPE: `str`
`graph`	AMR graph representation. TYPE: `str`

Examples:

>>> amr = AMRAnnotation(
...     version="1.0",
...     graph="(g / give-01 :ARG0 (p / person :name John) :ARG1 (g2 / gift))"
... )

Fields:

version (str)
graph (str)

`Alias` `pydantic-model` ¶

Bases: GlazingBaseModel

Alias for a predicate with part of speech.

ATTRIBUTE	DESCRIPTION
`text`	The alias text (e.g., "abandon", "abandonment"). TYPE: `str`
`pos`	Part of speech marker. TYPE: `AliasPOS`

Examples:

>>> alias = Alias(text="abandon", pos="v")
>>> alias = Alias(text="abandonment", pos="n")

Fields:

text (str)
pos (AliasPOS)

Validators:

validate_alias_text → text

Functions¶

`validate_alias_text(v: str) -> str` `pydantic-validator` ¶

Validate alias text format.

PARAMETER	DESCRIPTION
`v`	Alias text to validate. TYPE: `str`

RETURNS	DESCRIPTION
`str`	Validated alias text.

RAISES	DESCRIPTION
`ValueError`	If alias text format is invalid.

Source code in src/glazing/propbank/models.py

@field_validator("text")
@classmethod
def validate_alias_text(cls, v: str) -> str:
    """Validate alias text format.

    Parameters
    ----------
    v : str
        Alias text to validate.

    Returns
    -------
    str
        Validated alias text.

    Raises
    ------
    ValueError
        If alias text format is invalid.
    """
    # Allow: alphabetic start OR numeric start, plus spaces, hyphens, apostrophes, underscores
    if not re.match(r"^[a-zA-Z0-9][a-zA-Z0-9_\-\'\s]*$", v):
        msg = f"Invalid alias text: {v}"
        raise ValueError(msg)
    return v

`Aliases` `pydantic-model` ¶

Bases: GlazingBaseModel

Container for all alias types.

ATTRIBUTE	DESCRIPTION
`alias`	Regular aliases for the predicate. TYPE: `list[Alias], default=[]`
`argalias`	Argument-specific aliases. TYPE: `list[ArgAlias], default=[]`

Examples:

>>> aliases = Aliases(
...     alias=[Alias(text="give", pos="v")],
...     argalias=[ArgAlias(text="giver", pos="n", arg="0")]
... )

Fields:

alias (list[Alias])
argalias (list[ArgAlias])

`Arg` `pydantic-model` ¶

Bases: GlazingBaseModel

Argument annotation in an example.

ATTRIBUTE	DESCRIPTION
`type`	Argument type (e.g., "ARG0", "ARGM-TMP"). TYPE: `ArgumentTypePB`
`start`	Start token index or "?" for unknown. TYPE: `IntOrQuestionMark`
`end`	End token index or "?" for unknown. TYPE: `IntOrQuestionMark`
`text`	Extracted text (optional). TYPE: `str \| None, default=None`

Examples:

>>> arg = Arg(type="ARG0", start=0, end=1, text="John")
>>> arg = Arg(type="ARGM-TMP", start=5, end=6, text="yesterday")
>>> arg = Arg(type="ARG0", start="?", end="?")  # Unknown position

Fields:

type (ArgumentTypePB)
start (IntOrQuestionMark)
end (IntOrQuestionMark)
text (str | None)

Validators:

validate_indices → start, end

Functions¶

`validate_indices(v: int | str) -> int | str` `pydantic-validator` ¶

Validate token indices.

PARAMETER	DESCRIPTION
`v`	Token index or "?" to validate. TYPE: `int \| str`

RETURNS	DESCRIPTION
`int \| str`	Validated token index or "?".

RAISES	DESCRIPTION
`ValueError`	If token index is invalid.

Source code in src/glazing/propbank/models.py

@field_validator("start", "end")
@classmethod
def validate_indices(cls, v: int | str) -> int | str:
    """Validate token indices.

    Parameters
    ----------
    v : int | str
        Token index or "?" to validate.

    Returns
    -------
    int | str
        Validated token index or "?".

    Raises
    ------
    ValueError
        If token index is invalid.
    """
    if v == "?":
        return v
    if isinstance(v, int) and v < 0:
        msg = f"Token index cannot be negative: {v}"
        raise ValueError(msg)
    return v

`ArgAlias` `pydantic-model` ¶

Bases: GlazingBaseModel

Argument-specific alias.

ATTRIBUTE	DESCRIPTION
`text`	The alias text (e.g., "actress" for arg0 of "act"). TYPE: `str`
`pos`	Part of speech marker. TYPE: `AliasPOS`
`arg`	Argument number it refers to (e.g., "0", "1"). TYPE: `str`

Examples:

>>> arg_alias = ArgAlias(text="giver", pos="n", arg="0")
>>> arg_alias = ArgAlias(text="gift", pos="n", arg="1")

Fields:

text (str)
pos (AliasPOS)
arg (str)

Validators:

validate_arg → arg

Functions¶

`validate_arg(v: str) -> str` `pydantic-validator` ¶

Validate argument reference.

PARAMETER	DESCRIPTION
`v`	Argument reference to validate. TYPE: `str`

RETURNS	DESCRIPTION
`str`	Validated argument reference.

RAISES	DESCRIPTION
`ValueError`	If argument reference is invalid.

Source code in src/glazing/propbank/models.py

@field_validator("arg")
@classmethod
def validate_arg(cls, v: str) -> str:
    """Validate argument reference.

    Parameters
    ----------
    v : str
        Argument reference to validate.

    Returns
    -------
    str
        Validated argument reference.

    Raises
    ------
    ValueError
        If argument reference is invalid.
    """
    # Check standard argument references
    if v in ["0", "1", "2", "3", "4", "5", "6", "7", "M"]:
        return v

    # Check if it's a known special case
    if SpecialCaseRegistry.is_valid_arg_exception(v):
        return v

    msg = f"Invalid argument reference: {v}"
    raise ValueError(msg)

`Example` `pydantic-model` ¶

Bases: GlazingBaseModel

Annotated example sentence.

ATTRIBUTE	DESCRIPTION
`name`	Optional example name. TYPE: `str \| None, default=None`
`src`	Source of the example. TYPE: `str \| None, default=None`
`text`	The sentence text. TYPE: `str`
`propbank`	PropBank annotation. TYPE: `PropBankAnnotation \| None, default=None`
`amr`	AMR annotation. TYPE: `AMRAnnotation \| None, default=None`
`notes`	Additional notes. TYPE: `list[str], default=[]`

Examples:

>>> example = Example(
...     text="John gave Mary a book",
...     propbank=PropBankAnnotation(
...         args=[
...             Arg(type="ARG0", start=0, end=1),
...             Arg(type="ARG2", start=2, end=3),
...             Arg(type="ARG1", start=4, end=6)
...         ],
...         rel=Rel(relloc="1")
...     )
... )

Fields:

name (str | None)
src (str | None)
text (str)
propbank (PropBankAnnotation | None)
amr (AMRAnnotation | None)
notes (list[str])

`Frameset` `pydantic-model` ¶

Bases: GlazingBaseModel

Container for all senses of a predicate.

ATTRIBUTE	DESCRIPTION
`predicate_lemma`	The predicate lemma (e.g., "give", "abandon"). TYPE: `PredicateLemma`
`rolesets`	All senses of this predicate. TYPE: `list[Roleset]`
`notes`	Additional notes about the frameset. TYPE: `list[str], default=[]`

Examples:

>>> frameset = Frameset(
...     predicate_lemma="give",
...     rolesets=[
...         Roleset(id="give.01", name="transfer", roles=[...]),
...         Roleset(id="give.02", name="emit", roles=[...])
...     ]
... )

Fields:

predicate_lemma (PredicateLemma)
rolesets (list[Roleset])
notes (list[str])

Validators:

validate_predicate_lemma → predicate_lemma

Functions¶

`validate_predicate_lemma(v: str) -> str` `pydantic-validator` ¶

Validate predicate lemma format.

PARAMETER	DESCRIPTION
`v`	Predicate lemma to validate. TYPE: `str`

RETURNS	DESCRIPTION
`str`	Validated predicate lemma.

RAISES	DESCRIPTION
`ValueError`	If predicate lemma format is invalid.

Source code in src/glazing/propbank/models.py

@field_validator("predicate_lemma")
@classmethod
def validate_predicate_lemma(cls, v: str) -> str:
    """Validate predicate lemma format.

    Parameters
    ----------
    v : str
        Predicate lemma to validate.

    Returns
    -------
    str
        Validated predicate lemma.

    Raises
    ------
    ValueError
        If predicate lemma format is invalid.
    """
    # Allow alphabetic predicates OR pure numeric OR predicates with dots
    lemma_pattern = r"^[a-zA-Z][a-zA-Z0-9_\-\.]*$"
    if not (re.match(PREDICATE_LEMMA_PATTERN, v) or v.isdigit() or re.match(lemma_pattern, v)):
        msg = f"Invalid predicate lemma format: {v}"
        raise ValueError(msg)
    return v

`LexLink` `pydantic-model` ¶

Bases: GlazingBaseModel

Confidence-scored link to external resource.

ATTRIBUTE	DESCRIPTION
`class_name`	Name of the external class/frame. TYPE: `str`
`confidence`	Confidence score (0.0-1.0). TYPE: `float`
`resource`	Target resource type. TYPE: `ResourceType`
`version`	Version of the target resource. TYPE: `str`
`src`	Source of the mapping. TYPE: `MappingSource`

Examples:

>>> link = LexLink(
...     class_name="give-13.1",
...     confidence=0.95,
...     resource="VerbNet",
...     version="3.4",
...     src="manual"
... )

Fields:

class_name (str)
confidence (float)
resource (ResourceType)
version (str)
src (MappingSource)

Validators:

validate_confidence → confidence

Functions¶

`validate_confidence(v: float) -> float` `pydantic-validator` ¶

Validate confidence score.

PARAMETER	DESCRIPTION
`v`	Confidence score to validate. TYPE: `float`

RETURNS	DESCRIPTION
`float`	Validated confidence score.

RAISES	DESCRIPTION
`ValueError`	If confidence is not between 0 and 1.

Source code in src/glazing/propbank/models.py

@field_validator("confidence")
@classmethod
def validate_confidence(cls, v: float) -> float:
    """Validate confidence score.

    Parameters
    ----------
    v : float
        Confidence score to validate.

    Returns
    -------
    float
        Validated confidence score.

    Raises
    ------
    ValueError
        If confidence is not between 0 and 1.
    """
    if not 0.0 <= v <= 1.0:
        msg = f"Confidence must be between 0 and 1: {v}"
        raise ValueError(msg)
    return v

`PropBankAnnotation` `pydantic-model` ¶

Bases: GlazingBaseModel

PropBank annotation structure for examples.

ATTRIBUTE	DESCRIPTION
`args`	Argument annotations. TYPE: `list[Arg], default=[]`
`rel`	Predicate/relation marker (optional, some annotations lack rel). TYPE: `Rel \| None, default=None`
`notes`	Additional annotation notes. TYPE: `list[str], default=[]`

Examples:

>>> annotation = PropBankAnnotation(
...     args=[
...         Arg(type="ARG0", start=0, end=1, text="John"),
...         Arg(type="ARG1", start=3, end=4, text="gift")
...     ],
...     rel=Rel(relloc="2", text="gave")
... )

Fields:

args (list[Arg])
rel (Rel | None)
notes (list[str])

`Rel` `pydantic-model` ¶

Bases: GlazingBaseModel

Relation/predicate marker in example.

ATTRIBUTE	DESCRIPTION
`relloc`	Location indices (can be space-separated). TYPE: `str`
`text`	The predicate text. TYPE: `str \| None, default=None`

Examples:

>>> rel = Rel(relloc="2", text="gave")
>>> rel = Rel(relloc="2 3", text="gave up")

Fields:

relloc (str)
text (str | None)

Validators:

validate_relloc → relloc

Functions¶

`validate_relloc(v: str) -> str` `pydantic-validator` ¶

Validate relation location format.

PARAMETER	DESCRIPTION
`v`	Relation location to validate. TYPE: `str`

RETURNS	DESCRIPTION
`str`	Validated relation location.

RAISES	DESCRIPTION
`ValueError`	If location format is invalid.

Source code in src/glazing/propbank/models.py

@field_validator("relloc")
@classmethod
def validate_relloc(cls, v: str) -> str:
    """Validate relation location format.

    Parameters
    ----------
    v : str
        Relation location to validate.

    Returns
    -------
    str
        Validated relation location.

    Raises
    ------
    ValueError
        If location format is invalid.
    """
    if not re.match(r"^\d+(\s+\d+)*$", v) and v != "?":
        msg = f"Invalid relloc format: {v}"
        raise ValueError(msg)
    return v

`Role` `pydantic-model` ¶

Bases: GlazingBaseModel

Semantic role definition.

ATTRIBUTE	DESCRIPTION
`n`	Argument number (0-7, m, or M). TYPE: `ArgumentNumber`
`f`	Function tag. TYPE: `FunctionTag`
`descr`	Description of the role. TYPE: `str`
`rolelinks`	Links to external resources. TYPE: `list[RoleLink], default=[]`

Examples:

>>> role = Role(
...     n="0",
...     f="PAG",
...     descr="The giver"
... )

Fields:

n (ArgumentNumber)
f (FunctionTag)
descr (str)
rolelinks (list[RoleLink])

`RoleLink` `pydantic-model` ¶

Bases: GlazingBaseModel

Link from a role to VerbNet/FrameNet.

ATTRIBUTE	DESCRIPTION
`class_name`	VerbNet class or FrameNet frame. TYPE: `str`
`resource`	Target resource type. TYPE: `ResourceType`
`version`	Version of the target resource. TYPE: `str`
`role`	Role name in target resource. TYPE: `str \| None, default=None`

Examples:

>>> link = RoleLink(
...     class_name="give-13.1",
...     resource="VerbNet",
...     version="3.4",
...     role="Agent"
... )

Fields:

class_name (str)
resource (ResourceType)
version (str)
role (str | None)

Validators:

validate_class_name → class_name

Functions¶

`validate_class_name(v: str) -> str` `pydantic-validator` ¶

Validate VerbNet class or FrameNet frame name.

PARAMETER	DESCRIPTION
`v`	Class name to validate. TYPE: `str`

RETURNS	DESCRIPTION
`str`	Validated class name.

Source code in src/glazing/propbank/models.py

@field_validator("class_name")
@classmethod
def validate_class_name(cls, v: str) -> str:
    """Validate VerbNet class or FrameNet frame name.

    Parameters
    ----------
    v : str
        Class name to validate.

    Returns
    -------
    str
        Validated class name.
    """
    vn_pattern = r"^[a-z_]+-[\d.]+([-\d.]+)?$"
    fn_pattern = r"^[A-Z][A-Za-z0-9_]*$"
    special_pattern = r"^[a-z_]+$"

    if not (re.match(vn_pattern, v) or re.match(fn_pattern, v) or re.match(special_pattern, v)):
        pass
    return v

`Roleset` `pydantic-model` ¶

Bases: GlazingBaseModel

A single sense of a predicate with its semantic roles.

ATTRIBUTE	DESCRIPTION
`id`	Roleset identifier (e.g., "give.01"). TYPE: `RolesetID`
`name`	Optional descriptive name. TYPE: `str \| None, default=None`
`aliases`	Predicate aliases. TYPE: `Aliases \| None, default=None`
`roles`	Semantic roles for this sense. TYPE: `list[Role]`
`usagenotes`	Usage information. TYPE: `UsageNotes \| None, default=None`
`lexlinks`	Confidence-scored external links. TYPE: `list[LexLink], default=[]`
`examples`	Annotated example sentences. TYPE: `list[Example], default=[]`
`notes`	Additional notes. TYPE: `list[str], default=[]`

Examples:

>>> roleset = Roleset(
...     id="give.01",
...     name="transfer",
...     roles=[
...         Role(n="0", f="PAG", descr="giver"),
...         Role(n="1", f="PPT", descr="thing given"),
...         Role(n="2", f="GOL", descr="entity given to")
...     ]
... )

Fields:

id (RolesetID)
name (str | None)
aliases (Aliases | None)
roles (list[Role])
usagenotes (UsageNotes | None)
lexlinks (list[LexLink])
examples (list[Example])
notes (list[str])

Validators:

validate_roleset_id → id

Functions¶

`validate_roleset_id(v: str) -> str` `pydantic-validator` ¶

Validate roleset ID format.

PARAMETER	DESCRIPTION
`v`	Roleset ID to validate. TYPE: `str`

RETURNS	DESCRIPTION
`str`	Validated roleset ID.

RAISES	DESCRIPTION
`ValueError`	If roleset ID format is invalid.

Source code in src/glazing/propbank/models.py

@field_validator("id")
@classmethod
def validate_roleset_id(cls, v: str) -> str:
    """Validate roleset ID format.

    Parameters
    ----------
    v : str
        Roleset ID to validate.

    Returns
    -------
    str
        Validated roleset ID.

    Raises
    ------
    ValueError
        If roleset ID format is invalid.
    """
    # First check against the standard pattern (includes .LV for light verbs)
    if re.match(ROLESET_ID_PATTERN, v):
        return v

    # Check if it's a known special case
    if SpecialCaseRegistry.is_valid_roleset_exception(v):
        return v

    msg = f"Invalid roleset ID: {v}"
    raise ValueError(msg)

`Usage` `pydantic-model` ¶

Bases: GlazingBaseModel

Usage information for a resource.

ATTRIBUTE	DESCRIPTION
`resource`	The resource type (e.g., "VerbNet", "FrameNet"). TYPE: `ResourceType`
`version`	Version of the resource. TYPE: `str`
`inuse`	Usage status indicator (+ or -). TYPE: `UsageInUse`

Examples:

>>> usage = Usage(resource="verbnet", version="3.4", inuse="+")

Fields:

resource (ResourceType)
version (str)
inuse (UsageInUse)

`UsageNotes` `pydantic-model` ¶

Bases: GlazingBaseModel

Container for usage information.

ATTRIBUTE	DESCRIPTION
`usage`	List of usage information. TYPE: `list[Usage]`

Examples:

>>> usage_notes = UsageNotes(
...     usage=[Usage(resource="VerbNet", version="3.4", inuse="+")]
... )

Fields:

usage (list[Usage])

glazing.propbank.models¶

models ¶

Classes¶

AMRAnnotation pydantic-model ¶

Alias pydantic-model ¶

Functions¶

validate_alias_text(v: str) -> str pydantic-validator ¶

Aliases pydantic-model ¶

Arg pydantic-model ¶

Functions¶

validate_indices(v: int | str) -> int | str pydantic-validator ¶

ArgAlias pydantic-model ¶

Functions¶

validate_arg(v: str) -> str pydantic-validator ¶

Example pydantic-model ¶

Frameset pydantic-model ¶

Functions¶

validate_predicate_lemma(v: str) -> str pydantic-validator ¶

LexLink pydantic-model ¶

Functions¶

validate_confidence(v: float) -> float pydantic-validator ¶

PropBankAnnotation pydantic-model ¶

Rel pydantic-model ¶

Functions¶

validate_relloc(v: str) -> str pydantic-validator ¶

Role pydantic-model ¶

RoleLink pydantic-model ¶

Functions¶

validate_class_name(v: str) -> str pydantic-validator ¶

Roleset pydantic-model ¶

Functions¶

validate_roleset_id(v: str) -> str pydantic-validator ¶

Usage pydantic-model ¶

UsageNotes pydantic-model ¶

`models` ¶

`AMRAnnotation` `pydantic-model` ¶

`Alias` `pydantic-model` ¶

`validate_alias_text(v: str) -> str` `pydantic-validator` ¶

`Aliases` `pydantic-model` ¶

`Arg` `pydantic-model` ¶

`validate_indices(v: int | str) -> int | str` `pydantic-validator` ¶

`ArgAlias` `pydantic-model` ¶

`validate_arg(v: str) -> str` `pydantic-validator` ¶

`Example` `pydantic-model` ¶

`Frameset` `pydantic-model` ¶

`validate_predicate_lemma(v: str) -> str` `pydantic-validator` ¶

`LexLink` `pydantic-model` ¶

`validate_confidence(v: float) -> float` `pydantic-validator` ¶

`PropBankAnnotation` `pydantic-model` ¶

`Rel` `pydantic-model` ¶

`validate_relloc(v: str) -> str` `pydantic-validator` ¶

`Role` `pydantic-model` ¶

`RoleLink` `pydantic-model` ¶

`validate_class_name(v: str) -> str` `pydantic-validator` ¶

`Roleset` `pydantic-model` ¶

`validate_roleset_id(v: str) -> str` `pydantic-validator` ¶

`Usage` `pydantic-model` ¶

`UsageNotes` `pydantic-model` ¶