Utils Module

Utility and boilerplate functions, such as parsers, value transformers etc.

class redgrease.utils.CaseInsensitiveDict(data)[source]

Case insensitive dict implementation. Assumes string keys only. Heavily derived from redis.client `https://github.com/andymccurdy/redis-py/blob/master/redis/client.py`_

get(k, default=None)[source]

Return the value for key if key is in the dictionary, else default.

update([E, ]**F) None.  Update D from dict/iterable E and F.[source]

If E is present and has a .keys() method, then does: for k in E: D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

redgrease.utils.as_is(value: redgrease.typing.T) redgrease.typing.T[source]

Passthrough parser / identity function

Parameters

value (T) – Input value

Returns

The value, unmodified.

Return type

T

redgrease.utils.str_if_bytes(value: redgrease.typing.T) Union[redgrease.typing.T, str][source]

Parses byte values into a string, non-byte values passthrough unchanged Slightly modified from redis.utils, as it is not exported

Parameters

value (T) – Any serialized Redis value

Returns

Either a string or the input unchanged

Return type

Union[T, str]

redgrease.utils.safe_str(value: Any) str[source]

Parse anything to a string

Parameters

value (Any) – Input value

Returns

String

Return type

str

redgrease.utils.safe_str_upper(value: Any) str[source]

Parse anything to an uppercase string

Parameters

value (Any) – Input value

Returns

Parsed uppercase string

Return type

str

redgrease.utils.bool_ok(value: Any) bool[source]

Parse redis response as bool, such that:

"Ok" => True

Anything else => False

Same name as in redis.client but slightly different implementation. Should be better for long non-Ok replies, e.g. images, erroneously passed to it

Parameters

value (Any) – Input value

Returns

Parsed boolean

Return type

bool

redgrease.utils.optional(constructor: Union[Type[redgrease.typing.T], Callable[[Any], redgrease.typing.T]]) Union[Type[Optional[redgrease.typing.T]], Callable[[Any], Optional[redgrease.typing.T]]][source]

Create parser that accepts None values, but otherwise behaves like the provided parser.

Parameters

constructor (Constructor[T]) – constructor to apply, unless the value is None.

redgrease.utils.safe_bool(input: Any) bool[source]

Parse a bool, slightly more accepting

allowing for literal "True"/"False", integer 0 or1, as well as "Ok" and "yes"/"no" values.

Parameters

input (Any) – Input value

Returns

Parsed boolean

Return type

bool

redgrease.utils.to_int_if_bool(value: Any) Union[int, Any][source]

Transforms any boolean into an integer As booleans are not natively supported as a separate datatype in Redis

True => 1

False => 0

Parameters

value (Union[bool,Any]) – A boolean value

Returns

Integer representation of the bool

Return type

Union[int, Any]

redgrease.utils.to_redis_type(value: Any) Union[bytes, int, float][source]

Attempts to serialize a value to a Redis-native type. I.e. either: bytes, int or float It will serialize most primitive types (str, bool, int, float), as well as any complex type that implements __bytes__ method

Parameters

value (Any) – Value to serialize for Redis

Returns

A serialized version

Return type

RedisType

redgrease.utils.to_list(mapping: Optional[Dict[redgrease.typing.Key, redgrease.typing.Val]], key_transform: Callable[[redgrease.typing.Key], Any] = <function str_if_bytes>, val_transform: Callable[[redgrease.typing.Val], Any] = <function to_redis_type>) List[source]

Flattens a Dict to a list consisting of the of keys and values altertnating. This is useful generating the arguments for Redis commands.

Parameters
  • mapping (Dict[Key, Val]) – The dict to flatten.

  • key_transform (Callable[[Key], Any], optional) – Transformation function for the keys. Defaults to ‘str_if_bytes’

  • val_transform (Callable[[Val], Any], optional) – Transformation function for the values. Defaults to ‘to_redis_type’.

Returns

Flattened list of the transformed keys and values

Return type

List

redgrease.utils.transform(value: Any, constructor: Union[Type[redgrease.typing.T], Callable[[Any], redgrease.typing.T], Dict[redgrease.typing.Key, Union[Type[redgrease.typing.T], Callable[[Any], redgrease.typing.T]]]], key: Optional[redgrease.typing.Key] = None) redgrease.typing.T[source]

Applies a transformation to a value. The tranformation function could either be passed directly or in a dictionary along with a key to look it up. This is mostly only useful as a helper function for constructors of composite types, where the value may need to be transformed differently depending on the field/key.

Parameters
  • value (Any) – Value to transform

  • constructor (Union[Constructor[T], Dict[Any, Constructor[T]]]) – Transformation function or a dict of transformation functions. If a dict is used, the key argument is used to look up the transformation. If the key is not present in the dict, but there is a ‘None’-key mapping to a functsion, this function will be used as a default. Otherwise, the value will be returned untransformed.

  • key (Key) – key to use to look up the appropriate transforpation

Returns

Transformed value

Return type

T

redgrease.utils.to_dict(items: Iterable, keys: Optional[Iterable] = None, key_transform: Optional[Union[Type[redgrease.typing.Key], Callable[[Any], redgrease.typing.Key], Dict[Any, Union[Type[redgrease.typing.Key], Callable[[Any], redgrease.typing.Key]]]]] = None, val_transform: Optional[Union[Type[redgrease.typing.Val], Callable[[Any], redgrease.typing.Val], Dict[redgrease.typing.Key, Union[Type[redgrease.typing.Val], Callable[[Any], redgrease.typing.Val]]]]] = None) Dict[redgrease.typing.Key, redgrease.typing.Val][source]

Folds an iterable of values into a dict. This is useful for parsing Redis’ list responseses into a more manageable structure. It can be used on lists of alternating unnamed Key and values, i.e:

[key_1, value_1, key_2, value_2, ... ]

eg:

to_dict(["foo", 42, 13, 37]) == {"foo": 42, 13: 37}

to_dict(["foo", 42, 13, 37], key_transform=str) == {"foo": 42, "13": 37}

to_dict(["foo", 42, 13, 37], val_transform=str) == {"foo": "42", 13: "37"}

to_dict(
    ["foo", 42, 13, 37],
    val_transform={"foo":int, 13:float}
) == {"foo": 42, 13: 37.0}

to_dict(
    ["foo", 42, 13, 37],
    key_transform=str,
    val_transform={"foo":int, "13":float}
) == {"foo": 42, "13": 37.0}
Parameters
  • items (Iterable) – Iterable to “fold” into a dict

  • key_transform (Union[Constructor[Key], Dict[Any, Constructor[Key]]], optional) – Transformation function / type / constructor to apply to keys. It can either be a callable, which is then applied to all keys. Altertnatively, it can be a mapping from ‘raw’ key to a specific transform for that key Defaults to None (No key transformation).

  • val_transform (Union[Constructor[Val], Dict[Key, Constructor[Val]]], optional) – Transformation function / type / constructor to apply to values. It can either be a callable, which is then applied to all values. Altertnatively, it can be a mapping from (transformed) key to a specific transform for the value of that key Defaults to None (No value transformation).

Returns

Folded dictionary

Return type

Dict[Key, Val]

redgrease.utils.to_kwargs(items: Iterable) Dict[str, Any][source]

Folds an iterable of values into a ‘kwargs-compatible’ dict. This is useful for constructing objects from Redis’ list responseses, by means of an intermediate kwargs dict that can be passed to for example a constructor. It behaves exactly as ‘to_dict’ but enforces keys to be parsed to strings.

  • Alternating unnamed Key and values, i.e::

    [key_1, value_1, key_2, value_2, … ]

eg:

  • input: ["foo", 42, 13, 37]

  • output: {"foo": 42, "13": 37}

Parameters

items (Iterable) – Iterable to “fold” into a dict

Returns

Folded dictionary

Return type

Dict[str, Any]

redgrease.utils.list_parser(item_parser: Union[Type[redgrease.typing.T], Callable[[Any], redgrease.typing.T]]) Callable[[Iterable], List[redgrease.typing.T]][source]

Creates a list parser for lists of objects created with a given constructor. E.g:

parser = list_parser(bool)
parser(['', 1, None])

=> [False, True, False]

Parameters

item_parser (Constructor[T]) – The constructor to apply to each element.

Returns

Function that takes maps the constructor on to the iterable and returns the result as a list.

Return type

Callable[[Iterable[Any]], List[T]]

redgrease.utils.dict_of(constructors: Dict[redgrease.typing.Key, Union[Type[Any], Callable[[Any], Any]]]) Callable[[Iterable, Iterable[redgrease.typing.Key]], Dict[redgrease.typing.Key, Any]][source]

Creates a parser that parses a list of values to a dict, according to a dict of named constructors.

The generated parser takes both the iterable of values to parse, as well as, an equally long, iterable of names/keys to to use to lookup the corresponding parser/constructor in the constructor lookup dict.

The parser for the Nth value is using the parser found by looking up the Nth name/key in the key list in the lookup dict. This key is also used as the key in the resulting dict.

E.g:

parser = dict_of({"b":bool, "i":int, "s":str, "f":float})
parser([0,1,0,1], ["b","f","s","i"])

=> {"b":False, "f":1.0, "i":1, "s":"0"}

Parameters

constructors (Dict[str, Constructor[Any]]) – Dict of named constructors

Returns

Dict parser

Return type

Callable[…, Dict[str, Any]]

class redgrease.utils.Record(key: str, value: Optional[Any] = None, type: Optional[str] = None, event: Optional[str] = None, **kwargs)[source]

Class representing a Redis Record, as generated by KeysReader.

key

The name of the Redis key.

Type

str

value

The value corresponting to the key. None if deleted.

Type

Any

type

The core Redis type. Either ‘string’, ‘hash’, ‘list’, ‘set’, ‘zset’ or ‘stream’.

Type

str

event

The event that triggered the execution. (None if the execution was created via the run function.)

Type

str

class redgrease.utils.StreamRecord(key: str, id: Optional[str] = None, value: Optional[Any] = None, **kwargs)[source]

Class representing a Redis Record, as generated by KeysReader.

key

The name of the Redis key.

Type

str

value

The value corresponting to the key. None if deleted.

Type

Any

type

The core Redis type. Either ‘string’, ‘hash’, ‘list’, ‘set’, ‘zset’ or ‘stream’.

Type

str

event

The event that triggered the execution. (None if the execution was created via the run function.)

Type

str

redgrease.utils.record(rec: Any) redgrease.utils.Record[source]

Create a Record

Parameters

rec (Any) – the value to parse. Either a string (key only) or a dict with at minimum the key key present and optionally any of the keys value, type and/or event.

Returns

Parsed Record object.

Return type

Record

redgrease.utils.stream_record(rec: Any) redgrease.utils.StreamRecord[source]

Create a Record

Parameters

rec (Any) – the value to parse. Either a string (key only) or a dict with at minimum the key key present and optionally any of the keys value, type and/or event.

Returns

Parsed Record object.

Return type

Record

redgrease.utils.compose(*function: Callable) Callable[source]

Compose functions. I.e:

lambda x: f(g(x))

can be written:

compose(f, g)``
Parameters

*function (Callable) – Any number of functions to compose together. Output type of function N must be the input type of function N+1.

Returns

A composed function with input type same as the firs function, and output type same as the last function.

Return type

Callable

redgrease.utils.dict_filter(**kwargs) Callable[[Dict[str, Any]], bool][source]

Create a dictionary matching predicate function.

This function takes any number of keyword arguments, and returns a predicate function that takes a single dict as argument and returns a bool.

The predicate function returns True if, and only if, for all keyword arguments:

  1. The keyword argument name is a key in the dict, and

  2. Depending on the value, V, of the keyword argument, either:

    • V is Container type (excluding str)

      The dict value for the key is present in V

    • V is a Type (e.g. bool)

      The dict value for the key is of type V.

    • V is any value, except ... (Ellipsis)

      The dict value for the key equals V.

    • V is ... (Ellipsis)

      The dict value can be any value.

redgrease.utils.passfun(fun: Optional[redgrease.typing.T] = None, default: Optional[redgrease.typing.T] = None) redgrease.typing.T[source]

Create a Python ‘function’ object from any ‘Callable’, or constant.

RedisGears operator callbacks ony accept proper ‘function’s and not every type of ‘Callable’, such as for example ‘method’s (e.g. redgrease.cmd.incr) or ‘method-desriptor’s (e.g. str.split), which forces users to write seemingly “unnecessary” lambda-functions to wrap these.

This function ensures that the argument is a proper ‘function’, and thus will be accepted as RedisGears operator callback (assuming the type signature is correct).

It can also be used to create ‘constant’-functions, if passing a non-callable, or to create the ‘identity-function`, if called with no arguments.

Parameters
  • fun (Optional[T], optional) – Callable to turn into a ‘function` Alternatively a constant, to use to create a constant function, i.e. a function that alway return the same thing, regarding of input. If None, and no default, the ‘identity-function’ is returned. Defaults to None.

  • default (Optional[T], optional) – Default Callable to use as fallback if the ‘fun’ argument isn’t a callable. Defaults to None.

Returns

[description]

Return type

T

Typing Module

Type variables, Type aliases and Protocol Types.

redgrease.typing.InputRecord

Type variable for the input value of a GearFunction step / operation.

alias of TypeVar(‘InputRecord’, contravariant=True)

redgrease.typing.OutputRecord

Type variable for the output value of a GearFunction step / operation.

alias of TypeVar(‘OutputRecord’, covariant=True)

redgrease.typing.Key

Type variable for a Keys used in extractor functions in GroupBy operations and similar.

alias of TypeVar(‘Key’, bound=Hashable, contravariant=True)

redgrease.typing.Val

Type variable for intermediate values inside a step / operation.

alias of TypeVar(‘Val’)

redgrease.typing.Constructor

Joint type for primitive Types and (single argument) object constructors

alias of Union[Type[redgrease.typing.T], Callable[[Any], redgrease.typing.T]]

redgrease.typing.RedisType

Types native to Redis

alias of Union[bytes, int, float]

redgrease.typing.SafeType

Types that Redis happily accepts as input without any manipulation.

alias of Union[bytes, int, float, str]

redgrease.typing.SupportedType

Types that RedGrease supports

alias of Union[bool, str, bytes, int, float]

redgrease.typing.RedisKey

Accepted types for Redis Keys

alias of Union[str, bytes]

redgrease.typing.Record

The type of a record from KeysReader and others.

alias of Dict

redgrease.typing.Registrator

“Type definition for Registrator functions.

I.e. callback functions that may be called on each shard upon function registration. Such functions provide a good place to initialize non-serializable objects such as network connections.

An function of Registrator type shoud take no arguments, nor return any value.

alias of Callable[[], None]

redgrease.typing.Extractor

Type definition for Extractor functions.

Extractor functions are used in the following operations:

Extractor functions extracts or calculates the value that should be used as (grouping) key, from an input record of the operation.

Parameters

(InputRecord) - A single input-record, of the same type as the

operations’ input type.

Returns

A any ‘Hashable’ value.

Return type

Key

Example - Count users per supervisor:

# Function of "Extractor" type
# Extracts the "supervisor" for a user,
# If the user has no supervisor, then the user is considered its own supervisor.
def supervisor(user)
    return user.get("supervisor", user["id"])

KeysReader("user:*").values().countby(supervisor).run()

alias of Callable[[redgrease.typing.InputRecord], redgrease.typing.Key]

redgrease.typing.Mapper

Type definition for Mapper functions.

Mapper functions are used in the following operations:

Mapper functions transforms a value from the operations input to some new value.

Parameters

(InputRecord) - A single input-record, of the same type as the

operations’ input type.

Returns

A any value.

Return type

OutputRecord

alias of Callable[[redgrease.typing.InputRecord], redgrease.typing.OutputRecord]

redgrease.typing.Expander

Type definition forExpander functions.

Expander functions are used in the following operations:

Expander functions transforms a value from the operations input into several new values.

Parameters

(InputRecord) - A single input-record, of the same type as the

operations’ input type.

Returns

An iterable sequence of values, for example a list, each of which becomes an input to the next operation.

Return type

Iterable[OutputRecord]

alias of Callable[[redgrease.typing.InputRecord], Iterable[redgrease.typing.OutputRecord]]

redgrease.typing.Processor

Type definition forProcessor functions.

Processor functions are used in the following operations:

Processor functions performs some side effect using a value from the operations input.

Parameters

(InputRecord) - A single input-record, of the same type as the

operations’ input type.

Returns

Nothing.

Return type

None

alias of Callable[[redgrease.typing.InputRecord], None]

redgrease.typing.Filterer

Type definition forFilterer functions.

Filterer functions are used in the following operations:

Filter functions evaluates a value from the operations input to either True or False.

Parameters

(InputRecord) - A single input-record, of the same type as the

operations’ input type.

Returns

Either True or False.

Return type

bool

alias of Callable[[redgrease.typing.InputRecord], bool]

redgrease.typing.Accumulator

Type definition forAccumulator functions.

Accumulator functions are used in the following operations:

Accumulator functions takes a variable that’s also called an accumulator, as well as an input record. It aggregates inputs into the accumulator variable, which stores the state between the function’s invocations. The function must return the accumulator’s updated value after each call.

Parameters

  • ( T ) - An accumulator value.

  • (InputRecord) - A single input-record, of the same type as the operations’ input

type.

Returns

The updated accumulator value.

Return type

T

alias of Callable[[redgrease.typing.T, redgrease.typing.InputRecord], redgrease.typing.T]

redgrease.typing.Reducer

Type definition forReducer functions.

Reducer functions are used in the following operations:

Reducer functions receives a key, a variable that’s called an accumulator and an an input. It performs similarly to the redgrease.typing.Accumulator callback, with the difference being that it maintains an accumulator per reduced key.

Parameters

  • (Key) - A key value for the group.

  • ( T ) - An accumulator value.

  • (InputRecord) - A single input-record, of the same type as the operations’ input

type.

Returns

The updated accumulator value.

Return type

T

alias of Callable[[redgrease.typing.Key, redgrease.typing.T, redgrease.typing.InputRecord], redgrease.typing.T]

redgrease.typing.BatchReducer

Type definition forBatchReducer functions.

BatchReducer functions are used in the following operations:

BatchReducer functions receives a key and a list of input records. It performs similarly to the redgrease.typing.Reducer callback, with the difference being that it is input with a list of records instead of a single one. It is expected to return an accumulator value for these records

Parameters

  • (Key) - A key value for the group.

  • (Iterable[InputRecord]) - A collection of input-record, of the same type as the

operations’ input type.

Returns

A reduced output value.

Return type

OutputRecord

alias of Callable[[redgrease.typing.Key, Iterable[redgrease.typing.InputRecord]], redgrease.typing.OutputRecord]

Data Module

Datatypes and parsers for the various structures, specific to Redis Gears.

These datatypes are returned from various redgrease functions, merely for the purpose of providing more convenient structure, typing and documentation compared to the native ‘list-based’ structures.

They are generally not intended to be instantiated by end-users.

class redgrease.data.ExecID(shard_id: str = '0000000000000000000000000000000000000000', sequence: int = 0)[source]

Execution ID

shard_id

Shard Identifier

Type

str

sequence

Sequence number

Type

in

Method generated by attrs for class ExecID.

static parse(value: Union[str, bytes]) redgrease.data.ExecID[source]

Parses a string or bytes representation into a redgrease.data.ExecID

Returns

The parsed ExecID

Return type

redgrease.data.ExecID

Raises

ValueError – If the the value cannot be parsed.

class redgrease.data.ExecutionResult(value: redgrease.data.T, errors: Optional[List] = None)[source]

Common class for all types of execution results. Generic / Polymorphic on the result type (T) of the Gears function.

Redis Gears specifies a few different commands for getting the results of a function execution (pyexecute, getresults, getresultsblocking and trigger), each potentially having more than one different possible value type, depending on context.

In addition, while most gears functions result in collection of values, some functions (notably those ending with a count or avg operation) semantically always have scalar results, but are still natively returned as a list.

redgrease.data.ExecutionResult is a unified result type for all scenarios, aiming at providing as intuitive API experience as possible.

It is generic and walks and quacks just like the main result type (T) it wraps. With some notable exceptions:

  • It has an additional property errors containing any accumulated errors

  • Scalar results, behaves like scalars, but also like a single element list.

This behavior isn’t always perfect but gives for the most part an intuitive api experience.

If the behavior in some situations are confusing, the raw wrapped value can be accessed through the value property.

property value

Gets the raw result value of the Gears function execution.

Returns

The result value / values

Return type

T

redgrease.data.parse_execute_response(response) redgrease.data.ExecutionResult[source]

Parses raw responses from pyexecute, getresults and getresultsblocking into a redgrease.data.ExecuteResponse object.

Parameters

response (Any) –

The raw gears function response. This is most commonly a tuple of a list with the actual results and a list of errors List[List[Union[T, Any]]].

For some scenarios the response may take other forms, like a simple Ok (e.g. in the absence of a closing run() operation) or an execution ID (e.g. for non-blocking executions).

Returns

A parsed execution response

Return type

ExecutionResult[T]

redgrease.data.parse_trigger_response(response) redgrease.data.ExecutionResult[source]

Parses raw responses from trigger into a redgrease.data.ExecuteResponse object.

Parameters
  • response (Any) – The gears function response. This is a tuple of a list with the actual results and a list of errors List[List[Union[T, Any]]].

  • pickled (bool, optional) – Indicates if the response is pickled and need to be unpickled. Defaults to False.

Returns

A parsed execution response

Return type

ExecutionResult[T]

class redgrease.data.ExecutionStatus(value)[source]

Representation of the various states an execution could be in.

created = b'created'

Created - The execution has been created.

running = b'running'

Running - The execution is running.

done = b'done'

Done - Thee execution is done.

aborted = b'aborted'

Aborted - The execution has been aborted.

pending_cluster = b'pending_cluster'

Pending Cluster - Initiator is waiting for all workers to finish.

pending_run = b'pending_run'

Pending Run - Worker is pending ok from initiator to execute.

pending_receive = b'pending_receive'

Pending Receive - Initiator is pending acknowledgement from workers on receiving execution.

pending_termination = b'pending_termination'

Pending Termination - Worker is pending termination messaging from initiator

class redgrease.data.ExecLocality(value)[source]

Locality of execution: Shard or Cluster

class redgrease.data.RedisObject[source]

Base class for many of the more complex Redis Gears configuration values

classmethod from_redis(params) redgrease.data.RedisObject[source]

Default parser

Assumes the object is seralized as a list of alternating attribute names and values.

Note: This method should not be invoked directly on the ‘RedisObject’ base class. It should be only be invoked on subclasses of RedisObjects.

Returns

Returns the RedisObject subclass if, and only if, its constructor argument names and value types exactly match the names and values in the input list.

Return type

RedisObject

Raises

TypeError – If either the input list contains attributes not defined in the subclass constructor, or if the subclass defines mandatory constructor arguments that are not present in the input list.

redgrease.data.parse_PD(value: Union[str, bytes]) Dict[source]

Parses str or bytes to a dict.

Used for the ‘PD’ field in the ‘Registration’ type, returned by ‘getregistrations’.

Parameters

value (Union[str,bytes]) – Serialized version of a dict.

Returns

A dictionary

Return type

Dict

class redgrease.data.ExecutionInfo(executionId: Union[str, bytes], status, registered: Any)[source]

Return object for redgrease.client.Redis.dumpexecutions command.

Method generated by attrs for class ExecutionInfo.

executionId: redgrease.data.ExecID

The execution Id

status: redgrease.data.ExecutionStatus

The status

registered: bool

Indicates whether this is a registered execution

class redgrease.data.RegData(mode: Any, numTriggered: int, numSuccess: int, numFailures: int, numAborted: int, lastError: str, args: Iterable, status=None)[source]

Object reprenting the values for the Registration.RegistrationData, part of the return value of redgrease.client.dupregistrations command.

Method generated by attrs for class RegData.

mode: str

Registration mode.

numTriggered: int

A counter of triggered executions.

numSuccess: int

A counter of successful executions.

numFailures: int

A counter of failed executions.

numAborted: int

A conter of aborted executions.

lastError: str

The last error returned.

args: Dict[str, Any]

Reader-specific arguments

status: Optional[bool]

Undocumented status field

class redgrease.data.Registration(id: Union[str, bytes], reader: Any, desc: str, RegistrationData, PD: Union[str, bytes], ExecutionThreadPool: Optional[Any] = None)[source]

Return object for redgrease.client.Redis.dumpregistrations command. Contains the information about a function registration.

Method generated by attrs for class Registration.

id: redgrease.data.ExecID

The registration ID.

reader: str

The Reader.

desc: str

The description.

RegistrationData: redgrease.data.RegData

Registration Data, see RegData.

PD: Dict[Any, Any]

Private data

class redgrease.data.ExecutionStep(type: Any, duration: int, name: Any, arg: Any)[source]

Object reprenting a ‘step’ in the ExecutionPlan.steps, attribute of the return value of redgrease.client.getexecution command.

Method generated by attrs for class ExecutionStep.

type: str

Step type.

duration: int

The step’s duration in milliseconds (0 when ProfileExecutions is disabled)

name: str

Step callback

arg: str

Step argument

class redgrease.data.ExecutionPlan(status, shards_received: int, shards_completed: int, results: int, errors: int, total_duration: int, read_duration: int, steps)[source]

Object representing the execution plan for a given shard in the response from the redgrease.client.Redis.getexecution command.

Method generated by attrs for class ExecutionPlan.

status: redgrease.data.ExecutionStatus

The current status of the execution.

shards_received: int

Number of shards that received the execution.

shards_completed: int

Number of shards that completed the execution.

results: int

Count of results returned.

errors: int

Count of the errors raised.

total_duration: int

Total execution duration in milliseconds.

read_duration: int

Reader execution duration in milliseconds.

steps: List[redgrease.data.ExecutionStep]

The steps of the execution plan.

static parse(res: Iterable[bytes]) Dict[str, redgrease.data.ExecutionPlan][source]

Parse the raw results of redgrease.client.Redis.getexecution into a dict that maps from shard identifiers to ExecutionStep objects.

Returns

Execution plan mapping.

Return type

Dict[str, ExecutionPlan]

class redgrease.data.ShardInfo(id: Any, ip: Any, port: int, unixSocket: Any, runid: Any, minHslot: int, maxHslot: int, pendingMessages: int)[source]

Object representing a shard in the ClusterInfo.shards attribute in the response from redgrease.client.Redis.infocluster command.

Method generated by attrs for class ShardInfo.

id: str

The shard’s identifier int the cluster.

ip: str

The shard’s IP address.

port: int

The shard’s port.

unixSocket: str

The shards UDS.

runid: str

The engines run identifier.

minHslot: int

Lowest hash slot served by the shard.

maxHslot: int

Highest hash slot served by the shard.

pendingMessages: int

Number of pending messages

class redgrease.data.ClusterInfo(my_id: str, my_run_id: str, shards)[source]

Information about the Redis Gears cluster.

Return object for redgrease.client.Redis.infocluster command.

Method generated by attrs for class ClusterInfo.

my_id: str

The identifier of the shard the client is connected to.

shards: List[redgrease.data.ShardInfo]

List of the all the shards in the cluster.

static parse(res: bytes) Optional[redgrease.data.ClusterInfo][source]

Parses the response from redgrease.client.Redis.infocluster into a ClusterInfo object.

If the client is not connected to a Redis Gears cluster, None is returned.

Returns

A ClusterInfo object or None (if not in cluster mode).s

Return type

Optional[ClusterInfo]

class redgrease.data.PyStats(TotalAllocated: int, PeakAllocated: int, CurrAllocated: int)[source]

Memory usage statistics from the Python interpreter. As returned by redgrease.client.Redis.pystats

Method generated by attrs for class PyStats.

TotalAllocated: int

A total of all allocations over time, in bytes.

PeakAllocated: int

The peak allocations, in bytes.

CurrAllocated: int

The currently allocated memory, in bytes.

class redgrease.data.PyRequirementInfo(GearReqVersion: int, Name: Any, IsDownloaded: Any, IsInstalled: Any, CompiledOs: Any, Wheels)[source]

Information about a Python requirement / dependency.

Method generated by attrs for class PyRequirementInfo.

GearReqVersion: int

An internally-assigned version of the requirement. (note: this isn’t the package’s version)

Name: str

The name of the requirement as it was given to the ‘requirements’ argument of the pyexecute command.

IsDownloaded: bool

True if the requirement wheels was successfully download, otherwise False.

IsInstalled: bool

True if the requirement wheels was successfully installed, otherwise False.

CompiledOs: str

The underlying Operating System

Wheels: List[str]

A List of Wheels required by the requirement.