Skip to content

proxystore.connectors.redis

proxystore/connectors/redis.py

Redis connector implementation.

RedisKey

Bases: NamedTuple

Key to objects store in a Redis server.

Attributes:

  • redis_key (str) –

    Unique object ID.

RedisConnector 

RedisConnector(
    hostname: str, port: int, clear: bool = False
)

Redis server connector.

Parameters:

  • hostname (str) –

    Redis server hostname.

  • port (int) –

    Redis server port.

  • clear (bool, default: False ) –

    Remove all keys from the Redis server when close() is called. This will delete keys regardless of if they were created by ProxyStore or not.

Source code in proxystore/connectors/redis.py 
41
42
43
44
45
def __init__(self, hostname: str, port: int, clear: bool = False) -> None:
    self.hostname = hostname
    self.port = port
    self.clear = clear
    self._redis_client = redis.StrictRedis(host=hostname, port=port)

close() 

close(clear: bool | None = None) -> None

Close the connector and clean up.

Warning

Passing clear=True will result in ALL keys in the Redis server being deleted regardless of if they were created by ProxyStore or not.

Parameters:

  • clear (bool | None, default: None ) –

    Remove all keys in the Redis server. Overrides the default value of clear provided when the RedisConnector was instantiated.

Source code in proxystore/connectors/redis.py 
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
def close(self, clear: bool | None = None) -> None:
    """Close the connector and clean up.

    Warning:
        Passing `clear=True` will result in **ALL** keys in the Redis
        server being deleted regardless of if they were created by
        ProxyStore or not.

    Args:
        clear: Remove all keys in the Redis server. Overrides the default
            value of `clear` provided when the
            [`RedisConnector`][proxystore.connectors.redis.RedisConnector]
            was instantiated.
    """
    if self.clear if clear is None else clear:
        self._redis_client.flushdb()
    self._redis_client.close()

config() 

config() -> dict[str, Any]

Get the connector configuration.

The configuration contains all the information needed to reconstruct the connector object.

Source code in proxystore/connectors/redis.py 
82
83
84
85
86
87
88
89
90
91
92
def config(self) -> dict[str, Any]:
    """Get the connector configuration.

    The configuration contains all the information needed to reconstruct
    the connector object.
    """
    return {
        'hostname': self.hostname,
        'port': self.port,
        'clear': self.clear,
    }

from_config() classmethod 

from_config(config: dict[str, Any]) -> RedisConnector

Create a new connector instance from a configuration.

Parameters:

  • config (dict[str, Any]) –

    Configuration returned by .config().

Source code in proxystore/connectors/redis.py 
 94
 95
 96
 97
 98
 99
100
101
@classmethod
def from_config(cls, config: dict[str, Any]) -> RedisConnector:
    """Create a new connector instance from a configuration.

    Args:
        config: Configuration returned by `#!python .config()`.
    """
    return cls(**config)

evict() 

evict(key: RedisKey) -> None

Evict the object associated with the key.

Parameters:

  • key (RedisKey) –

    Key associated with object to evict.

Source code in proxystore/connectors/redis.py 
103
104
105
106
107
108
109
def evict(self, key: RedisKey) -> None:
    """Evict the object associated with the key.

    Args:
        key: Key associated with object to evict.
    """
    self._redis_client.delete(key.redis_key)

exists() 

exists(key: RedisKey) -> bool

Check if an object associated with the key exists.

Parameters:

  • key (RedisKey) –

    Key potentially associated with stored object.

Returns:

  • bool –

    If an object associated with the key exists.

Source code in proxystore/connectors/redis.py 
111
112
113
114
115
116
117
118
119
120
def exists(self, key: RedisKey) -> bool:
    """Check if an object associated with the key exists.

    Args:
        key: Key potentially associated with stored object.

    Returns:
        If an object associated with the key exists.
    """
    return bool(self._redis_client.exists(key.redis_key))

get() 

get(key: RedisKey) -> bytes | None

Get the serialized object associated with the key.

Parameters:

  • key (RedisKey) –

    Key associated with the object to retrieve.

Returns:

  • bytes | None –

    Serialized object or None if the object does not exist.

Source code in proxystore/connectors/redis.py 
122
123
124
125
126
127
128
129
130
131
def get(self, key: RedisKey) -> bytes | None:
    """Get the serialized object associated with the key.

    Args:
        key: Key associated with the object to retrieve.

    Returns:
        Serialized object or `None` if the object does not exist.
    """
    return self._redis_client.get(key.redis_key)

get_batch() 

get_batch(keys: Sequence[RedisKey]) -> list[bytes | None]

Get a batch of serialized objects associated with the keys.

Parameters:

  • keys (Sequence[RedisKey]) –

    Sequence of keys associated with objects to retrieve.

Returns:

  • list[bytes | None] –

    List with same order as keys with the serialized objects or None if the corresponding key does not have an associated object.

Source code in proxystore/connectors/redis.py 
133
134
135
136
137
138
139
140
141
142
143
def get_batch(self, keys: Sequence[RedisKey]) -> list[bytes | None]:
    """Get a batch of serialized objects associated with the keys.

    Args:
        keys: Sequence of keys associated with objects to retrieve.

    Returns:
        List with same order as `keys` with the serialized objects or \
        `None` if the corresponding key does not have an associated object.
    """
    return self._redis_client.mget([key.redis_key for key in keys])

put() 

put(obj: bytes) -> RedisKey

Put a serialized object in the store.

Parameters:

  • obj (bytes) –

    Serialized object to put in the store.

Returns:

  • RedisKey –

    Key which can be used to retrieve the object.

Source code in proxystore/connectors/redis.py 
145
146
147
148
149
150
151
152
153
154
155
156
def put(self, obj: bytes) -> RedisKey:
    """Put a serialized object in the store.

    Args:
        obj: Serialized object to put in the store.

    Returns:
        Key which can be used to retrieve the object.
    """
    key = RedisKey(redis_key=str(uuid.uuid4()))
    self._redis_client.set(key.redis_key, obj)
    return key

put_batch() 

put_batch(objs: Sequence[bytes]) -> list[RedisKey]

Put a batch of serialized objects in the store.

Parameters:

  • objs (Sequence[bytes]) –

    Sequence of serialized objects to put in the store.

Returns:

  • list[RedisKey] –

    List of keys with the same order as objs which can be used to retrieve the objects.

Source code in proxystore/connectors/redis.py 
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
def put_batch(self, objs: Sequence[bytes]) -> list[RedisKey]:
    """Put a batch of serialized objects in the store.

    Args:
        objs: Sequence of serialized objects to put in the store.

    Returns:
        List of keys with the same order as `objs` which can be used to \
        retrieve the objects.
    """
    keys = [RedisKey(redis_key=str(uuid.uuid4())) for _ in objs]
    self._redis_client.mset(
        {key.redis_key: obj for key, obj in zip(keys, objs)},
    )
    return keys