Skip to content

sake.redis#

Redis based implementations of Sake's clients.

DEFAULT_EXPIRE module-attribute #

DEFAULT_EXPIRE: typing.Final[int] = 3600000

The default expire time (in milliseconds) used for expiring resources of 60 minutes.

DEFAULT_FAST_EXPIRE module-attribute #

DEFAULT_FAST_EXPIRE: typing.Final[int] = 300000

The default expire time (in milliseconds) used for expiring resources quickly of 5 minutes.

DEFAULT_INVITE_EXPIRE module-attribute #

DEFAULT_INVITE_EXPIRE: typing.Final[int] = 2592000000

A special case month long default expire time for invite entries without a set "expire_at".

DEFAULT_SLOW_EXPIRE module-attribute #

DEFAULT_SLOW_EXPIRE: typing.Final[int] = 604800

The default expire time (in milliseconds) used for gateway-event deleted resources (1 week).

EmojiCache #

Bases: _Reference, sake_abc.RefEmojiCache

Redis implementation of sake.abc.EmojiCache.

GuildCache #

Bases: ResourceClient, sake_abc.GuildCache

Redis implementation of sake.abc.GuildCache.

GuildChannelCache #

Bases: _Reference, sake_abc.RefGuildChannelCache

Redis implementation of sake.abc.RefGuildChannelCache.

InviteCache #

Bases: ResourceClient, sake_abc.InviteCache

Redis implementation of sake.abc.InviteCache.

with_invite_expire #

with_invite_expire(expire)

Set the default expire time for invite entries added with this client.

PARAMETER DESCRIPTION
expire

The default expire time to add for invites in this cache or None to set back to the default behaviour. This may either be the number of seconds as an int or float (where millisecond precision is supported) or a timedelta.

TYPE: typing.Optional[_internal.ExpireT]

RETURNS DESCRIPTION
Self

The client this is being called on to enable chained calls.

MemberCache #

Bases: ResourceClient, sake_abc.MemberCache

Redis implementation of sake.abc.MemberCache.

MessageCache #

Bases: ResourceClient, sake_abc.MessageCache

Redis implementation of sake.abc.MessageCache.

with_message_expire #

with_message_expire(expire)

Set the default expire time for message entries added with this client.

PARAMETER DESCRIPTION
expire

The default expire time to add for messages in this cache or None to set back to the default behaviour. This may either be the number of seconds as an int or float (where millisecond precision is supported) or a timedelta.

TYPE: typing.Optional[_internal.ExpireT]

RETURNS DESCRIPTION
Self

The client this is being called on to enable chained calls.

PresenceCache #

Bases: ResourceClient, sake_abc.PresenceCache

Redis implementation of sake.abc.PresenceCache.

RedisCache #

Bases: GuildCache, EmojiCache, GuildChannelCache, InviteCache, MemberCache, MessageCache, PresenceCache, RoleCache, UserCache, VoiceStateCache, sake_abc.Cache

A Redis implementation of all the defined cache resources.

ResourceClient #

Bases: sake_abc.Resource, abc.ABC

A base client which all resources in this implementation will implement.

Note

This cannot be initialised by itself and is useless alone.

app property #

app: hikari.RESTAware

The Hikari client this resource client is tied to.

This is used to build models with a app attribute.

config property #

config: collections.MutableMapping[str, typing.Any]

This client's settings.

default_expire property #

default_expire: typing.Optional[int]

The default expire time used for fields with no actual lifetime.

If this is None then these cases will have no set expire after.

event_manager property #

event_manager: typing.Optional[hikari.api.EventManager]

The event manager this resource client is using for managing state.

__init__ #

__init__(address, app, event_manager=None, *, config=None, default_expire=DEFAULT_SLOW_EXPIRE, event_managed=False, password=None, max_connections_per_db=5, dumps=lambda obj: json.dumps(obj).encode(), loads=json.loads)

Initialise a resource client.

PARAMETER DESCRIPTION
app

The Hikari client all the models returned by this client should be bound to.

TYPE: hikari.RESTAware

address

The address to use to connect to the Redis backend server this resource is linked to.

E.g: - "redis://[[username]:[password]]@localhost:6379" - "rediss://[[username]:[password]]@localhost:6379" - "unix://[[username]:[password]]@/path/to/socket.sock"

Three URL schemes are supported: - redis://: creates a TCP socket connection. See more at: https://www.iana.org/assignments/uri-schemes/prov/redis - rediss://: creates a SSL wrapped TCP socket connection. See more at: https://www.iana.org/assignments/uri-schemes/prov/rediss - unix://: creates a Unix Domain Socket connection.

TYPE: str

event_manager

The event manager to bind this resource client to.

If provided then this client will automatically manage resources based on received gateway events.

TYPE: typing.Optional[hikari.api.EventManager] DEFAULT: None

event_managed

Whether the client should be started and stopped based on the attached event_manager's lifetime events.

TYPE: bool DEFAULT: False

password

The password to use to connect to the backend Redis server.

TYPE: typing.Optional[str] DEFAULT: None

RAISES DESCRIPTION
ValueError

When event_managed is True and event_manager wasn't passed.

add_to_tanjun #

add_to_tanjun(client, /, *, trust_get_for=None, tanjun_managed=False)

Add this Redis client to a Tanjun client.

This method will register type dependencies for the resources implemented by it (including tanjun.dependencies.async_cache compatible adapters which will allow Tanjun extensions and standard utility such as converters to be aware of this cache).

The type dependencies this will register depend on which resources are implemented but are as follows for each standard resource implementation:

PARAMETER DESCRIPTION
client

The Tanjun client to add this client to.

TYPE: tanjun.abc.Client

trust_get_for

A collection of resource types which the tanjun.dependencies.async_cache adapter "get" methods should raise tanjun.dependencies.async_cache.EntryNotFound if the entry isn't found rather than just tanjun.dependencies.async_cache.CacheMissError.

If not passed then this will default to the following resources:

TYPE: typing.Optional[collections.Collection[type[sake_abc.Resource]]] DEFAULT: None

tanjun_managed

Whether the client should be started and stopped based on the tanjun client's lifecycle.

This is useful if the client isn't being event managed.

TYPE: bool DEFAULT: False

RAISES DESCRIPTION
RuntimeError

If this is called in an environment without Tanjun.

all_indexes #

all_indexes()

Get a set of all the Redis client indexes this is using.

Note

This accounts for index overrides.

RETURNS DESCRIPTION
collections.abc.MutableSet[ResourceIndex | int]

A set of all the Redis client indexes this is using.

all_intents classmethod #

all_intents()

The intents required for a client to be sufficient event managed.

If not all these intents are present in the linked event manager then this client won't be able to reliably fill and manage the linked redis database(s).

dump #

dump(data)

Serialize a dict object representation into the form to be stored.

PARAMETER DESCRIPTION
data

The dict object to serialize.

TYPE: _ObjectT

RETURNS DESCRIPTION
bytes

The object serialized as bytes.

get_index_override #

get_index_override(index)

Get the override set for an index.

PARAMETER DESCRIPTION
index

The index to get the override for.

TYPE: ResourceIndex

RETURNS DESCRIPTION
int | None

The found override if set, else None.

index classmethod abstractmethod #

index()

The index for the resource which this class is linked to.

Note

This should be called on specific base classes and will not be accurate after inheritance.

Warning

This doesn't account for overrides.

RETURNS DESCRIPTION
collections.abc.Sequence[ResourceIndex]

The index of the resource this class is linked to.

intents classmethod abstractmethod #

intents()

The intents the resource requires to function properly.

Note

This should be called on specific base classes and will not be accurate after inheritance.

RETURNS DESCRIPTION
hikari.intents.Intents

The intents the resource requires to function properly.

load #

load(data)

Deserialize a bytes representation to a dict object.

PARAMETER DESCRIPTION
data

The bytes representation from the database to a dict object.

TYPE: bytes

RETURNS DESCRIPTION
dict[str, typing.Any]

The deserialized dict object.

with_index_override #

with_index_override(index, /, *, override=None)

Add an index override.

PARAMETER DESCRIPTION
index

The index to override.

TYPE: ResourceIndex

override

The override to set.

If this is left at None then any previous override is unset. This will decide which Redis database is targeted for a resource.

TYPE: typing.Optional[int] DEFAULT: None

ResourceIndex #

Bases: enum.IntEnum

An enum of the indexes used to map cache resources to their redis databases.

RoleCache #

Bases: _Reference, sake_abc.RoleCache

Redis implementation of sake.abc.RoleCache.

UserCache #

Bases: _MeCache, sake_abc.UserCache

Redis implementation of sake.abc.UserCache.

with_user_expire #

with_user_expire(expire)

Set the default expire time for user entries added with this client.

PARAMETER DESCRIPTION
expire

The default expire time to add for users in this cache or None to set back to the default behaviour. This may either be the number of seconds as an int or float (where millisecond precision is supported) or a timedelta.

TYPE: typing.Optional[_internal.ExpireT]

RETURNS DESCRIPTION
Self

The client this is being called on to enable chained calls.

VoiceStateCache #

Bases: _Reference, sake_abc.VoiceStateCache

Redis implementation of sake.abc.VoiceStateCache.