betty.model package¶
Submodules¶
- betty.model.ancestry module
AncestryAnonymousCitationAnonymousSourceAttendeeBeneficiaryCelebrantCitationDatedDescribedEnclosureEventFileHasCitationsHasFilesHasLinksHasLinksEntityHasMediaTypeHasNotesHasPrivacyLinkNoteOrganizerPersonPersonNamePlacePlaceNamePresencePresenceRolePrivacySourceSpeakerSubjectWitnessis_private()is_public()merge_privacies()ref_link()ref_link_collection()ref_media_type()ref_role()resolve_privacy()
- betty.model.event_type module
AdoptionBaptismBirthBurialConferenceConfirmationCorrespondenceCreatableDerivableEventTypeCremationDeathDerivableEventTypeDivorceDivorceAnnouncementDuringLifeEventTypeEmigrationEndOfLifeEventTypeEngagementEventTypeEventTypeProviderFinalDispositionEventTypeFuneralImmigrationMarriageMarriageAnnouncementMissingOccupationPostDeathEventTypePreBirthEventTypeResidenceRetirementStartOfLifeEventTypeUnknownEventTypeWill
Module contents¶
Provide Betty’s data model API.
- class betty.model.AliasedEntity[source]¶
Bases:
Generic[EntityT]An aliased entity wraps an entity and gives aliases its ID.
Aliases are used when deserializing ancestries from sources where intermediate IDs are used to declare associations between entities. By wrapping an entity in an alias, the alias can use the intermediate ID, allowing it to be inserted into APIs such as
betty.model.EntityGraphBuilderwho will use the alias ID to finalize associations before the original entities are returned.- Parameters:
original_entity (
typing.TypeVar(EntityT, bound=betty.model.Entity))
- __init__(original_entity: betty.model.EntityT, aliased_entity_id: str | None = None)[source]¶
- Parameters:
original_entity (
typing.TypeVar(EntityT, bound=betty.model.Entity))
- unalias() betty.model.EntityT[source]¶
Get the original entity.
- Return type:
typing.TypeVar(EntityT, bound=betty.model.Entity)
- class betty.model.BidirectionalEntityTypeAssociation[source]¶
Bases:
Generic[OwnerT,AssociateT],_EntityTypeAssociation[OwnerT,AssociateT]A bidirectional entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)associate_attr_name (
str)
- __init__(owner_type: type[betty.model.OwnerT], owner_attr_name: str, associate_type_name: str, associate_attr_name: str)[source]¶
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)associate_attr_name (
str)
- inverse() betty.model.BidirectionalEntityTypeAssociation[betty.model.AssociateT, betty.model.OwnerT][source]¶
Get the inverse association.
- Return type:
betty.model.BidirectionalEntityTypeAssociation[typing.TypeVar(AssociateT),typing.TypeVar(OwnerT)]
- class betty.model.BidirectionalToManyEntityTypeAssociation[source]¶
Bases:
Generic[OwnerT,AssociateT],ToManyEntityTypeAssociation[OwnerT,AssociateT],BidirectionalEntityTypeAssociation[OwnerT,AssociateT]A bidirectional *-to-many entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)associate_attr_name (
str)
- class betty.model.BidirectionalToOneEntityTypeAssociation[source]¶
Bases:
Generic[OwnerT,AssociateT],ToOneEntityTypeAssociation[OwnerT,AssociateT],BidirectionalEntityTypeAssociation[OwnerT,AssociateT]A bidirectional *-to-one entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)associate_attr_name (
str)
- class betty.model.Entity[source]¶
Bases:
LinkedDataDumpableAn entity is a uniquely identifiable data container.
- Parameters:
args (
typing.Any)kwargs (
typing.Any)
- __init__(id: str | None = None, *args: Any, **kwargs: Any)[source]¶
- Parameters:
args (
typing.Any)kwargs (
typing.Any)
- async dump_linked_data(app: betty.app.App) dict[str, bool | int | float | str | None | Sequence[bool | int | float | str | None | Sequence[Dump] | Mapping[str, Dump]] | Mapping[str, bool | int | float | str | None | Sequence[Dump] | Mapping[str, Dump]]][source]¶
Dump this instance to JSON-LD.
- Parameters:
app (
betty.app.App)- Return type:
dict[str,typing.Union[bool,int,float,str,None,typing.Sequence[typing.Union[bool,int,float,str,None,typing.Sequence[Dump],typing.Mapping[str, Dump]]],typing.Mapping[str,typing.Union[bool,int,float,str,None,typing.Sequence[Dump],typing.Mapping[str, Dump]]]]]
- classmethod entity_type_label() betty.locale.Str[source]¶
The human-readable entity type label, singular.
- Return type:
- classmethod entity_type_label_plural() betty.locale.Str[source]¶
The human-readable entity type label, plural.
- Return type:
- async classmethod linked_data_schema(app: betty.app.App) dict[str, bool | int | float | str | None | Sequence[bool | int | float | str | None | Sequence[Dump] | Mapping[str, Dump]] | Mapping[str, bool | int | float | str | None | Sequence[Dump] | Mapping[str, Dump]]][source]¶
Define the JSON Schema for
betty.json.linked_data.LinkedDataDumpable.dump_linked_data().- Parameters:
app (
betty.app.App)- Return type:
dict[str,typing.Union[bool,int,float,str,None,typing.Sequence[typing.Union[bool,int,float,str,None,typing.Sequence[Dump],typing.Mapping[str, Dump]]],typing.Mapping[str,typing.Union[bool,int,float,str,None,typing.Sequence[Dump],typing.Mapping[str, Dump]]]]]
- class betty.model.EntityCollection[source]¶
Bases:
Generic[TargetT]Provide a collection of entities.
- add(*entities: TargetT & Entity) None[source]¶
Add the given entities.
- Parameters:
entities (TargetT & Entity)
- Return type:
None
- remove(*entities: TargetT & Entity) None[source]¶
Remove the given entities.
- Parameters:
entities (TargetT & Entity)
- Return type:
None
- replace(*entities: TargetT & Entity) None[source]¶
Replace all entities with the given ones.
- Parameters:
entities (TargetT & Entity)
- Return type:
None
- property view: list[TargetT & Entity]¶
A view of the entities at the time of calling.
- class betty.model.EntityGraphBuilder[source]¶
Bases:
_EntityGraphBuilderAssemble entities and their associations.
(De)serializing data often means that special care must be taken with the associations, relationships, or links between data points, as those form a graph, a network, a tangled web of data. When deserializing entity A with an association to entity B, that association cannot be finalized until entity B is parsed as well. But, if entity B subsequently has an association with entity A (the association is bidirectional), this results in an endless cycle.
This class prevents the problem by letting you add entities and associations separately. Associations are finalized when you are done adding, avoiding cycle errors.
- add_association(owner_type: type[betty.model.Entity], owner_id: str, owner_attr_name: str, associate_type: type[betty.model.Entity], associate_id: str) None[source]¶
Add an association between two entities to the graph.
- Parameters:
owner_type (
type[betty.model.Entity])owner_id (
str)owner_attr_name (
str)associate_type (
type[betty.model.Entity])associate_id (
str)
- Return type:
- add_entity(*entities: betty.model.Entity | betty.model.AliasedEntity[betty.model.Entity]) None[source]¶
Add entities to the graph.
- Parameters:
entities (
typing.Union[betty.model.Entity,betty.model.AliasedEntity[betty.model.Entity]])- Return type:
- class betty.model.EntityTypeAssociationRegistry[source]¶
Bases:
objectInspect any known entity type associations.
- classmethod finalize(*owners: betty.model.Entity) None[source]¶
Finalize all associations from the given owners.
- Parameters:
owners (
betty.model.Entity)- Return type:
- classmethod get_all_associations(owner: type | object) set[betty.model.ToOneEntityTypeAssociation[Any, Any] | betty.model.ToManyEntityTypeAssociation[Any, Any]][source]¶
Get all associations for an owner.
- Parameters:
- Return type:
set[typing.Union[betty.model.ToOneEntityTypeAssociation[typing.Any,typing.Any],betty.model.ToManyEntityTypeAssociation[typing.Any,typing.Any]]]
- classmethod get_associates(owner: betty.model.EntityT, association: betty.model.ToOneEntityTypeAssociation[betty.model.EntityT, betty.model.AssociateT] | betty.model.ToManyEntityTypeAssociation[betty.model.EntityT, betty.model.AssociateT]) Iterable[betty.model.AssociateT][source]¶
Get the associates for a given owner and association.
- Parameters:
owner (
typing.TypeVar(EntityT, bound=betty.model.Entity))association (
typing.Union[betty.model.ToOneEntityTypeAssociation[typing.TypeVar(EntityT, bound=betty.model.Entity),typing.TypeVar(AssociateT)],betty.model.ToManyEntityTypeAssociation[typing.TypeVar(EntityT, bound=betty.model.Entity),typing.TypeVar(AssociateT)]])
- Return type:
typing.Iterable[typing.TypeVar(AssociateT)]
- classmethod get_association(owner: type[OwnerT] | OwnerT & Entity, owner_attr_name: str) ToAny[OwnerT, Any][source]¶
Get the association for a given owner and attribute name.
- Parameters:
owner (type[OwnerT] | OwnerT & Entity)
owner_attr_name (str)
- Return type:
ToAny[OwnerT, Any]
- classmethod initialize(*owners: betty.model.Entity) None[source]¶
Initialize the given owners’ associations.
- Parameters:
owners (
betty.model.Entity)- Return type:
- exception betty.model.EntityTypeError[source]¶
Bases:
ValueErrorA error occurred when trying to determine and import an entity type.
- exception betty.model.EntityTypeImportError[source]¶
Bases:
EntityTypeError,ImportErrorRaised when an alleged entity type cannot be imported.
- Parameters:
entity_type_name (
str)
- exception betty.model.EntityTypeInvalidError[source]¶
Bases:
EntityTypeError,ImportErrorRaised for types that are not valid entity types.
- Parameters:
entity_type (
type)
- class betty.model.EntityTypeProvider[source]¶
Bases:
objectProvide additional entity types.
- async entity_types() set[type[betty.model.Entity]][source]¶
The entity types.
- Return type:
- class betty.model.GeneratedEntityId[source]¶
Bases:
strGenerate a unique entity ID.
Entities must have IDs for identification. However, not all entities can be provided with an ID that exists in the original data set (such as a third-party family tree loaded into Betty), so IDs can be generated.
- class betty.model.ManyToMany[source]¶
Bases:
Generic[OwnerT,AssociateT],BidirectionalToManyEntityTypeAssociation[OwnerT,AssociateT]A bidirectional many-to-many entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)associate_attr_name (
str)
- class betty.model.ManyToOne[source]¶
Bases:
Generic[OwnerT,AssociateT],BidirectionalToOneEntityTypeAssociation[OwnerT,AssociateT]A bidirectional many-to-one entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)associate_attr_name (
str)
- class betty.model.MultipleTypesEntityCollection[source]¶
Bases:
Generic[TargetT],EntityCollection[TargetT]Collect entities of multiple types.
- class betty.model.OneToMany[source]¶
Bases:
Generic[OwnerT,AssociateT],BidirectionalToManyEntityTypeAssociation[OwnerT,AssociateT]A bidirectional one-to-many entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)associate_attr_name (
str)
- class betty.model.OneToOne[source]¶
Bases:
Generic[OwnerT,AssociateT],BidirectionalToOneEntityTypeAssociation[OwnerT,AssociateT]A bidirectional one-to-one entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)associate_attr_name (
str)
- class betty.model.SingleTypeEntityCollection[source]¶
Bases:
Generic[TargetT],EntityCollection[TargetT]Collect entities of a single type.
- Parameters:
target_type (
type[typing.TypeVar(TargetT)])
- __init__(target_type: type[betty.model.TargetT])[source]¶
- Parameters:
target_type (
type[typing.TypeVar(TargetT)])
- class betty.model.ToMany[source]¶
Bases:
Generic[OwnerT,AssociateT],ToManyEntityTypeAssociation[OwnerT,AssociateT]A unidirectional to-many entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)
- class betty.model.ToManyEntityTypeAssociation[source]¶
Bases:
Generic[OwnerT,AssociateT],_EntityTypeAssociation[OwnerT,AssociateT]A to-many entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)
- associate(owner: OwnerT & Entity, associate: AssociateT & Entity) None[source]¶
- Parameters:
owner (OwnerT & Entity)
associate (AssociateT & Entity)
- Return type:
None
- disassociate(owner: OwnerT & Entity, associate: AssociateT & Entity) None[source]¶
- Parameters:
owner (OwnerT & Entity)
associate (AssociateT & Entity)
- Return type:
None
- class betty.model.ToOne[source]¶
Bases:
Generic[OwnerT,AssociateT],ToOneEntityTypeAssociation[OwnerT,AssociateT]A unidirectional to-one entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)
- class betty.model.ToOneEntityTypeAssociation[source]¶
Bases:
Generic[OwnerT,AssociateT],_EntityTypeAssociation[OwnerT,AssociateT]A unidirectional to-one entity type association.
- Parameters:
owner_type (
type[typing.TypeVar(OwnerT)])owner_attr_name (
str)associate_type_name (
str)
- associate(owner: OwnerT & Entity, associate: AssociateT & Entity) None[source]¶
- Parameters:
owner (OwnerT & Entity)
associate (AssociateT & Entity)
- Return type:
None
- disassociate(owner: OwnerT & Entity, associate: AssociateT & Entity) None[source]¶
- Parameters:
owner (OwnerT & Entity)
associate (AssociateT & Entity)
- Return type:
None
- get(owner: OwnerT & Entity) AssociateT & Entity | None[source]¶
Get the associate from the given owner.
- Parameters:
owner (OwnerT & Entity)
- Return type:
AssociateT & Entity | None
- class betty.model.UserFacingEntity[source]¶
Bases:
objectA sentinel to mark an entity type as being visible to users (e.g. not internal).
- betty.model.get_entity_type(entity_type_name: str) type[betty.model.Entity][source]¶
Get the entity type for an entity type name.
- Parameters:
entity_type_name (
str)- Return type:
- betty.model.get_entity_type_name(entity_type_definition: type[betty.model.Entity] | betty.model.Entity) str[source]¶
Get the entity type name for an entity or entity type.
- Parameters:
entity_type_definition (
type[betty.model.Entity] |betty.model.Entity)- Return type:
- betty.model.many_to_many(owner_attr_name: str, associate_type_name: str, associate_attr_name: str) Callable[[type[betty.model.OwnerT]], type[betty.model.OwnerT]][source]¶
Add a bidirectional many-to-many association to an entity or entity mixin.
- Parameters:
- Return type:
typing.Callable[[type[typing.TypeVar(OwnerT)]],type[typing.TypeVar(OwnerT)]]
- betty.model.many_to_one(owner_attr_name: str, associate_type_name: str, associate_attr_name: str) Callable[[type[betty.model.OwnerT]], type[betty.model.OwnerT]][source]¶
Add a bidirectional many-to-one association to an entity or entity mixin.
- Parameters:
- Return type:
typing.Callable[[type[typing.TypeVar(OwnerT)]],type[typing.TypeVar(OwnerT)]]
- betty.model.many_to_one_to_many(left_associate_type_name: str, left_associate_attr_name: str, left_owner_attr_name: str, right_owner_attr_name: str, right_associate_type_name: str, right_associate_attr_name: str) Callable[[type[betty.model.OwnerT]], type[betty.model.OwnerT]][source]¶
Add a bidirectional many-to-one-to-many association to an entity or entity mixin.
- Parameters:
- Return type:
typing.Callable[[type[typing.TypeVar(OwnerT)]],type[typing.TypeVar(OwnerT)]]
- betty.model.one_to_many(owner_attr_name: str, associate_type_name: str, associate_attr_name: str) Callable[[type[betty.model.OwnerT]], type[betty.model.OwnerT]][source]¶
Add a bidirectional one-to-many association to an entity or entity mixin.
- Parameters:
- Return type:
typing.Callable[[type[typing.TypeVar(OwnerT)]],type[typing.TypeVar(OwnerT)]]
- betty.model.one_to_one(owner_attr_name: str, associate_type_name: str, associate_attr_name: str) Callable[[type[betty.model.OwnerT]], type[betty.model.OwnerT]][source]¶
Add a bidirectional one-to-one association to an entity or entity mixin.
- Parameters:
- Return type:
typing.Callable[[type[typing.TypeVar(OwnerT)]],type[typing.TypeVar(OwnerT)]]
- betty.model.record_added(entities: betty.model.EntityCollection[betty.model.EntityT]) Iterator[betty.model.MultipleTypesEntityCollection[betty.model.EntityT]][source]¶
Record all entities that are added to a collection.
- Parameters:
entities (
betty.model.EntityCollection[typing.TypeVar(EntityT, bound=betty.model.Entity)])- Return type:
typing.Iterator[betty.model.MultipleTypesEntityCollection[typing.TypeVar(EntityT, bound=betty.model.Entity)]]
- betty.model.to_many(owner_attr_name: str, associate_type_name: str) Callable[[type[betty.model.OwnerT]], type[betty.model.OwnerT]][source]¶
Add a unidirectional to-many association to an entity or entity mixin.
- Parameters:
- Return type:
typing.Callable[[type[typing.TypeVar(OwnerT)]],type[typing.TypeVar(OwnerT)]]
- betty.model.to_one(owner_attr_name: str, associate_type_name: str) Callable[[type[betty.model.OwnerT]], type[betty.model.OwnerT]][source]¶
Add a unidirectional to-one association to an entity or entity mixin.
- Parameters:
- Return type:
typing.Callable[[type[typing.TypeVar(OwnerT)]],type[typing.TypeVar(OwnerT)]]
- betty.model.unalias(entity: betty.model.EntityT | betty.model.AliasedEntity[betty.model.EntityT]) betty.model.EntityT[source]¶
Unalias a potentially aliased entity.
- Parameters:
entity (
typing.Union[typing.TypeVar(EntityT, bound=betty.model.Entity),betty.model.AliasedEntity[typing.TypeVar(EntityT, bound=betty.model.Entity)]])- Return type:
typing.TypeVar(EntityT, bound=betty.model.Entity)