Skip to content

cattle_grid.database

account

Account

Bases: Base

Represents an account

Source code in cattle_grid/database/account.py 
16
17
18
19
20
21
22
23
24
25
26
class Account(Base):
    """Represents an account"""

    __tablename__ = "account"
    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(256))
    password_hash: Mapped[str] = mapped_column(String(256))
    meta_information: Mapped[dict] = mapped_column(JSON(), default={})

    actors: Mapped[list["ActorForAccount"]] = relationship(viewonly=True)
    permissions: Mapped[list["Permission"]] = relationship(viewonly=True)

ActorForAccount

Bases: Base

Represents the actor associated with an account

Source code in cattle_grid/database/account.py 
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
class ActorForAccount(Base):
    """Represents the actor associated with an account"""

    __tablename__ = "actorforaccount"
    id: Mapped[int] = mapped_column(primary_key=True)
    account_id: Mapped[int] = mapped_column(
        ForeignKey("account.id", ondelete="CASCADE")
    )
    account: Mapped[Account] = relationship(lazy="joined")

    actor: Mapped[str] = mapped_column(String(256))
    name: Mapped[str] = mapped_column(
        String(256),
        default="NO NAME",
    )
    status: Mapped[ActorStatus] = mapped_column(String(10), default=ActorStatus.active)

    groups: Mapped[list["ActorGroup"]] = relationship(viewonly=True)

ActorStatus

Bases: StrEnum

Status actors can have for an account

Source code in cattle_grid/database/account.py 
 9
10
11
12
13
class ActorStatus(StrEnum):
    """Status actors can have for an account"""

    active = auto()
    deleted = auto()

activity_pub

Credential

Bases: Base

Stored credential. This corresponds to storing a private key

Source code in cattle_grid/database/activity_pub.py 
10
11
12
13
14
15
16
17
18
class Credential(Base):
    """Stored credential. This corresponds to storing a private key"""

    __tablename__ = "credential"

    id: Mapped[int] = mapped_column(primary_key=True)
    actor_id: Mapped[str] = mapped_column(String(256))
    identifier: Mapped[str] = mapped_column(String(256), unique=True)
    secret: Mapped[str] = mapped_column(Text())

InboxLocation

Bases: Base

Describes the location of an inbox. Used to send ActivityPub Activities addressed to the actor to the corresponding inbox.

This information is also collected for remote actors.

Source code in cattle_grid/database/activity_pub.py 
21
22
23
24
25
26
27
28
29
30
31
32
33
class InboxLocation(Base):
    """Describes the location of an inbox. Used to send
    ActivityPub Activities addressed to the actor to the
    corresponding inbox.

    This information is also collected for remote actors.
    """

    __tablename__ = "inboxlocation"

    id: Mapped[int] = mapped_column(primary_key=True)
    actor: Mapped[str] = mapped_column(String(256), unique=True)
    inbox: Mapped[str] = mapped_column(String(256))

activity_pub_actor

Actor

Bases: Base

Represents the stored information about an actor in the database

Source code in cattle_grid/database/activity_pub_actor.py 
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class Actor(Base):
    """Represents the stored information about an actor in the database"""

    __tablename__ = "actor"

    id: Mapped[int] = mapped_column(primary_key=True)
    actor_id: Mapped[str] = mapped_column(String(256), unique=True)
    inbox_uri: Mapped[str] = mapped_column(String(256), unique=True)
    outbox_uri: Mapped[str] = mapped_column(String(256), unique=True)
    following_uri: Mapped[str] = mapped_column(String(256), unique=True)
    followers_uri: Mapped[str] = mapped_column(String(256), unique=True)

    preferred_username: Mapped[str] = mapped_column(String(256), nullable=True)

    public_key_name: Mapped[str] = mapped_column(String(256))
    public_key: Mapped[str] = mapped_column(Text())

    automatically_accept_followers: Mapped[bool] = mapped_column(Boolean())
    profile: Mapped[dict] = mapped_column(JSON())

    status: Mapped[ActorStatus] = mapped_column(String(7))

    created_at: Mapped[datetime] = mapped_column(server_default=func.now())

    identifiers: Mapped[list["PublicIdentifier"]] = relationship(viewonly=True)
    followers: Mapped[list["Follower"]] = relationship(viewonly=True)
    following: Mapped[list["Following"]] = relationship(viewonly=True)
    blocking: Mapped[list["Blocking"]] = relationship(viewonly=True)

ActorStatus

Bases: StrEnum

Represents the status of the actor

Source code in cattle_grid/database/activity_pub_actor.py 
10
11
12
13
14
class ActorStatus(StrEnum):
    """Represents the status of the actor"""

    active = auto()
    deleted = auto()

Blocking

Bases: Base

The people the actor is blocking

Source code in cattle_grid/database/activity_pub_actor.py 
81
82
83
84
85
86
87
88
89
90
91
class Blocking(Base):
    """The people the actor is blocking"""

    __tablename__ = "blocking"
    id: Mapped[int] = mapped_column(primary_key=True)
    actor_id: Mapped[int] = mapped_column(ForeignKey("actor.id", ondelete="CASCADE"))
    actor: Mapped[Actor] = relationship(lazy="joined")

    blocking: Mapped[str] = mapped_column(String(256))
    request: Mapped[str] = mapped_column(String(256))
    active: Mapped[bool] = mapped_column(Boolean())

Follower

Bases: Base

The people that follow the actor

Source code in cattle_grid/database/activity_pub_actor.py 
55
56
57
58
59
60
61
62
63
64
65
class Follower(Base):
    """The people that follow the actor"""

    __tablename__ = "follower"
    id: Mapped[int] = mapped_column(primary_key=True)
    actor_id: Mapped[int] = mapped_column(ForeignKey("actor.id", ondelete="CASCADE"))
    actor: Mapped[Actor] = relationship(lazy="joined")

    follower: Mapped[str] = mapped_column(String(256))
    request: Mapped[str] = mapped_column(String(256))
    accepted: Mapped[bool] = mapped_column(Boolean())

Following

Bases: Base

The people the actor is following

Source code in cattle_grid/database/activity_pub_actor.py 
68
69
70
71
72
73
74
75
76
77
78
class Following(Base):
    """The people the actor is following"""

    __tablename__ = "following"
    id: Mapped[int] = mapped_column(primary_key=True)
    actor_id: Mapped[int] = mapped_column(ForeignKey("actor.id", ondelete="CASCADE"))
    actor: Mapped[Actor] = relationship(lazy="joined")

    following: Mapped[str] = mapped_column(String(256))
    request: Mapped[str] = mapped_column(String(256))
    accepted: Mapped[bool] = mapped_column(Boolean())

PublicIdentifier

Bases: Base

Public identifier

Source code in cattle_grid/database/activity_pub_actor.py 
108
109
110
111
112
113
114
115
116
117
118
119
120
121
class PublicIdentifier(Base):
    """Public identifier"""

    __tablename__ = "publicidentifier"
    id: Mapped[int] = mapped_column(primary_key=True)
    actor_id: Mapped[int] = mapped_column(ForeignKey("actor.id", ondelete="CASCADE"))
    actor: Mapped[Actor] = relationship(lazy="joined")

    name: Mapped[str] = mapped_column(String(256))
    identifier: Mapped[str] = mapped_column(String(256), unique=True)
    preference: Mapped[int] = mapped_column(default=0)
    status: Mapped[PublicIdentifierStatus] = mapped_column(
        String(10), default=PublicIdentifierStatus.verified
    )

PublicIdentifierStatus

Bases: StrEnum

Represents the status of the public identifier

Source code in cattle_grid/database/activity_pub_actor.py 
17
18
19
20
21
22
class PublicIdentifierStatus(StrEnum):
    """Represents the status of the public identifier"""

    unverified = auto()
    verified = auto()
    owned = auto()

StoredActivity

Bases: Base

cattle_grid generates activities under some circumstances (see FIXME). These will be stored in this table

Source code in cattle_grid/database/activity_pub_actor.py 
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
class StoredActivity(Base):
    """cattle_grid generates activities under some
    circumstances (see FIXME). These will be stored
    in this table"""

    __tablename__ = "storedactivity"
    id: Mapped[str] = mapped_column(String(256), primary_key=True)
    actor_id: Mapped[int] = mapped_column(ForeignKey("actor.id", ondelete="CASCADE"))
    actor: Mapped[Actor] = relationship(lazy="joined")

    data: Mapped[dict] = mapped_column(JSON())
    published: Mapped[datetime] = mapped_column()

auth

RemoteIdentity

Bases: Base

Stored information about a public identifier in the database.

Source code in cattle_grid/database/auth.py 
10
11
12
13
14
15
16
17
18
19
class RemoteIdentity(Base):
    """Stored information about a public identifier in the database."""

    __tablename__ = "cattle_grid_auth_remote_identity"

    id: Mapped[int] = mapped_column(primary_key=True)

    key_id: Mapped[str] = mapped_column(String(512), unique=True)
    controller: Mapped[str] = mapped_column(String(512))
    public_key: Mapped[str] = mapped_column(String(1024))