Struct Signature 

pub struct Signature {
    pub task: String,
    pub args: Vec<Value>,
    pub kwargs: HashMap<String, Value>,
    pub options: TaskOptions,
    pub immutable: bool,
}

Signature (a task definition with arguments)

Fields

task: String

Task name

args: Vec<Value>

Positional arguments

kwargs: HashMap<String, Value>

Keyword arguments

options: TaskOptions

Task options

immutable: bool

Immutability flag (whether args can be replaced)

Implementations

impl Signature

pub fn new(task: String) -> Signature

pub fn with_args(self, args: Vec<Value>) -> Signature

pub fn with_kwargs(self, kwargs: HashMap<String, Value>) -> Signature

pub fn with_priority(self, priority: u8) -> Signature

pub fn with_queue(self, queue: String) -> Signature

pub fn with_task_id(self, task_id: Uuid) -> Signature

pub fn with_link(self, link: Signature) -> Signature

pub fn with_link_error(self, link_error: Signature) -> Signature

pub fn add_link(self, link: Signature) -> Signature

Add a callback to the success callback chain

pub fn add_link_error(self, link_error: Signature) -> Signature

Add a callback to the error callback chain

pub fn with_on_retry(self, callback: Signature) -> Signature

Set the on_retry callback

pub fn with_soft_time_limit(self, seconds: u64) -> Signature

Set soft time limit (warning before kill)

pub fn with_time_limit(self, seconds: u64) -> Signature

Set hard time limit (force kill)

pub fn with_retry_delay(self, seconds: u64) -> Signature

Set retry delay in seconds

pub fn with_retry_backoff(self, factor: f64) -> Signature

Set retry backoff factor (exponential multiplier)

pub fn with_retry_backoff_max(self, seconds: u64) -> Signature

Set maximum retry delay

pub fn with_retry_jitter(self, jitter: bool) -> Signature

Enable/disable retry jitter

pub fn immutable(self) -> Signature

pub fn has_args(&self) -> bool

Check if task has arguments

pub fn has_kwargs(&self) -> bool

Check if task has keyword arguments

pub fn is_immutable(&self) -> bool

Check if task is immutable (args cannot be replaced)

pub fn has_kwarg(&self, key: &str) -> bool

Check if task has a specific kwarg

pub fn get_kwarg(&self, key: &str) -> Option<&Value>

Get a kwarg value

pub fn add_kwarg(self, key: impl Into<String>, value: Value) -> Signature

Add a single kwarg

pub fn add_arg(self, arg: Value) -> Signature

Add a single argument

pub fn clone_signature(&self) -> Signature

Clone the signature

pub fn si(self) -> Signature

Create an immutable signature (shorthand for .immutable())

This is equivalent to Python Celery’s .si() method. Immutable signatures cannot have their arguments replaced when used in workflows.

Example

use celers_canvas::Signature;

let sig = Signature::new("process".to_string())
    .with_args(vec![serde_json::json!(1)])
    .si();

assert!(sig.is_immutable());

pub fn partial(self, args: Vec<Value>) -> Signature

Create a partial signature with some arguments pre-filled

The partial signature can have additional arguments added later. This is useful for creating task templates with some fixed arguments.

Example

use celers_canvas::Signature;

// Create a partial with first argument fixed
let partial = Signature::new("add".to_string())
    .partial(vec![serde_json::json!(10)]);

// Complete with remaining arguments
let complete = partial.complete(vec![serde_json::json!(5)]);
assert_eq!(complete.args.len(), 2);

pub fn complete(self, additional_args: Vec<Value>) -> Signature

Complete a partial signature with additional arguments

Appends the provided arguments to the existing arguments. If the signature is immutable, returns the signature unchanged.

pub fn merge(self, other: Signature) -> Signature

Merge another signature into this one

This combines kwargs from both signatures (the other’s kwargs take precedence) and inherits options from the other signature if not already set.

pub fn replace_args(self, args: Vec<Value>) -> Option<Signature>

Replace arguments in signature (respects immutability)

If the signature is immutable, returns None. Otherwise, returns a new signature with replaced arguments.

pub fn with_expires(self, expires: u64) -> Signature

Set expiration time in seconds

pub fn with_countdown(self, countdown: u64) -> Signature

Set countdown (delay before execution) in seconds

pub fn with_retries(self, max_retries: u32) -> Signature

Set retry policy

pub fn with_routing_key(self, routing_key: String) -> Signature

Set task routing key

pub fn with_callback_arg_mode(self, mode: CallbackArgMode) -> Signature

Set callback argument passing mode

Controls how task result is passed to linked callbacks.

Example

use celers_canvas::{Signature, CallbackArgMode};

let sig = Signature::new("task".to_string())
    .with_callback_arg_mode(CallbackArgMode::Append);

pub fn with_callback_kwarg_key(self, key: impl Into<String>) -> Signature

Set callback kwarg key (used when CallbackArgMode::Kwarg)

Specifies the keyword argument name for passing the result. Defaults to “result” if not set.

pub fn with_result_as_kwarg(self, key: impl Into<String>) -> Signature

Configure callback to receive result as keyword argument

Shorthand for setting CallbackArgMode::Kwarg with a key.

pub fn to_json(&self) -> Result<String, Error>

Serialize signature to JSON string

pub fn from_json(json: &str) -> Result<Signature, Error>

Deserialize signature from JSON string

pub fn to_json_bytes(&self) -> Result<Vec<u8>, Error>

Serialize signature to JSON bytes

pub fn from_json_bytes(bytes: &[u8]) -> Result<Signature, Error>

Deserialize signature from JSON bytes

pub fn clear_args(self) -> Option<Signature>

Clear all arguments from the signature

Returns None if the signature is immutable.

Example

use celers_canvas::Signature;

let sig = Signature::new("task".to_string())
    .with_args(vec![serde_json::json!(1), serde_json::json!(2)]);

let cleared = sig.clear_args().unwrap();
assert!(cleared.args.is_empty());

pub fn clear_kwargs(self) -> Signature

Clear all keyword arguments from the signature

Example

use celers_canvas::Signature;
use std::collections::HashMap;

let mut kwargs = HashMap::new();
kwargs.insert("key".to_string(), serde_json::json!("value"));

let sig = Signature::new("task".to_string()).with_kwargs(kwargs);
let cleared = sig.clear_kwargs();
assert!(cleared.kwargs.is_empty());

pub fn remove_kwarg(self, key: &str) -> Signature

Remove a specific keyword argument

Example

use celers_canvas::Signature;

let sig = Signature::new("task".to_string())
    .add_kwarg("key1", serde_json::json!("value1"))
    .add_kwarg("key2", serde_json::json!("value2"));

let modified = sig.remove_kwarg("key1");
assert!(!modified.has_kwarg("key1"));
assert!(modified.has_kwarg("key2"));

pub fn args_count(&self) -> usize

Get the number of positional arguments

Example

use celers_canvas::Signature;

let sig = Signature::new("task".to_string())
    .with_args(vec![serde_json::json!(1), serde_json::json!(2)]);

assert_eq!(sig.args_count(), 2);

pub fn kwargs_count(&self) -> usize

Get the number of keyword arguments

Example

use celers_canvas::Signature;

let sig = Signature::new("task".to_string())
    .add_kwarg("key1", serde_json::json!("value1"))
    .add_kwarg("key2", serde_json::json!("value2"));

assert_eq!(sig.kwargs_count(), 2);

pub fn kwarg_keys(&self) -> Vec<&str>

Get all keyword argument keys

Example

use celers_canvas::Signature;

let sig = Signature::new("task".to_string())
    .add_kwarg("key1", serde_json::json!("value1"))
    .add_kwarg("key2", serde_json::json!("value2"));

let keys = sig.kwarg_keys();
assert_eq!(keys.len(), 2);
assert!(keys.contains(&"key1"));
assert!(keys.contains(&"key2"));

pub fn has_retry_config(&self) -> bool

Check if signature has any retry configuration

Example

use celers_canvas::Signature;

let sig1 = Signature::new("task".to_string()).with_retries(3);
let sig2 = Signature::new("task".to_string());

assert!(sig1.has_retry_config());
assert!(!sig2.has_retry_config());

pub fn has_time_limit_config(&self) -> bool

Check if signature has any time limit configuration

Example

use celers_canvas::Signature;

let sig1 = Signature::new("task".to_string()).with_time_limit(60);
let sig2 = Signature::new("task".to_string());

assert!(sig1.has_time_limit_config());
assert!(!sig2.has_time_limit_config());

pub fn clone_without_args(&self) -> Signature

Create a new signature with the same task name but no arguments

Example

use celers_canvas::Signature;

let sig = Signature::new("task".to_string())
    .with_args(vec![serde_json::json!(1)])
    .with_priority(5);

let clean = sig.clone_without_args();
assert_eq!(clean.task, "task");
assert!(clean.args.is_empty());
assert_eq!(clean.options.priority, Some(5)); // Options preserved

pub fn estimated_size(&self) -> usize

Calculate the estimated serialized size in bytes

This gives a rough estimate of how much space the signature will take when serialized.

Example

use celers_canvas::Signature;

let sig = Signature::new("task".to_string())
    .with_args(vec![serde_json::json!(1), serde_json::json!(2)]);

let size = sig.estimated_size();
assert!(size > 0);

Trait Implementations

impl Clone for Signature

fn clone(&self) -> Signature

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Signature

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Signature

fn deserialize<__D>( __deserializer: __D, ) -> Result<Signature, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Signature

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl From<Signature> for CanvasElement

fn from(sig: Signature) -> CanvasElement

Converts to this type from the input type.

impl FromIterator<Signature> for Chain

fn from_iter<T>(iter: T) -> Chain

where T: IntoIterator<Item = Signature>,

Creates a value from an iterator.

impl FromIterator<Signature> for Group

fn from_iter<T>(iter: T) -> Group

where T: IntoIterator<Item = Signature>,

Creates a value from an iterator.

impl PartialEq for Signature

fn eq(&self, other: &Signature) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Signature

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Signature