API#

API

class celery_batches.Batches#

Strategy(task: Batches, app: Celery, consumer: Consumer) → Callable#

str(object=’’) -> str str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.

abstract = True#: Deprecated attribute abstract here for compatibility.

apply(args: Tuple[Any, ...] | None = None, kwargs: dict | None = None, *_args: Any, **options: Any) → Any#

Execute the task synchronously as a batch of size 1.

Arguments:: args: positional arguments passed on to the task.
Returns:: celery.result.EagerResult: pre-evaluated result.

flush(requests: Collection[Request]) → Any#

flush_every = 10#: Maximum number of message in buffer.

flush_interval = 30#: Timeout in seconds before buffer is flushed anyway.

ignore_result = False#: If enabled the worker won’t store task state and return values for this task. Defaults to the task_ignore_result setting.

priority = None#: Default task priority.

rate_limit = None#: Rate limit for this task type. Examples: None (no rate limit), ‘100/s’ (hundred tasks a second), ‘100/m’ (hundred tasks a minute),`’100/h’` (hundred tasks an hour)

reject_on_worker_lost = None#

Even if acks_late is enabled, the worker will acknowledge tasks when the worker process executing them abruptly exits or is signaled (e.g., KILL/INT, etc).

Setting this to true allows the message to be re-queued instead, so that the task will execute again by the same worker, or another worker.

Warning: Enabling this can cause message loops; make sure you know what you’re doing.

request_stack = <celery.utils.threads._LocalStack object>#: Task request stack, the current request will be the topmost.

run(*args: Any, **kwargs: Any) → NoReturn#: The body of the task executed by workers.

serializer = 'json'#: The name of a serializer that are registered with kombu.serialization.registry. Default is ‘json’.

store_errors_even_if_ignored = False#: When enabled errors will be stored even if the task is otherwise configured to ignore results.

track_started = False#

If enabled the task will report its status as ‘started’ when the task is executed by a worker. Disabled by default as the normal behavior is to not report that level of granularity. Tasks are either pending, finished, or waiting to be retried.

Having a ‘started’ status can be useful for when there are long running tasks and there’s a need to report what task is currently running.

The application default can be overridden using the task_track_started setting.

typing = False#: Enable argument checking. You can set this to false if you don’t want the signature to be checked when calling the task. Defaults to app.strict_typing.

class celery_batches.SimpleRequest(id: str, name: str, args: Tuple[Any, ...], kwargs: Dict[Any, Any], delivery_info: dict, hostname: str, ignore_result: bool, reply_to: str | None, correlation_id: str | None, request_dict: Dict[str, Any] | None)#

A request to execute a task.

A list of SimpleRequest instances is provided to the batch task during execution.

This must be pickleable (if using the prefork pool), but generally should have the same properties as Request.

args: Tuple[Any, ...] = ()#: positional arguments

chord = None#: TODO

correlation_id = None#: used similarly to reply_to

delivery_info = None#: message delivery information.

classmethod from_request(request: Request) → SimpleRequest#

hostname = None#: worker node name

id = None#: task id

ignore_result = None#: if the results of this request should be ignored

kwargs: Dict[Any, Any] = {}#: keyword arguments

name = None#: task name

reply_to = None#: used by rpc backend when failures reported by parent process

request_dict: Dict[str, Any] | None = {}#: includes all of the original request headers