repo stringclasses 454
values | file_path stringlengths 5 201 | extension stringclasses 1
value | content stringlengths 8 509k | num_lines int64 3 16.9k | size_bytes int64 8 511k |
|---|---|---|---|---|---|
celery | t/unit/contrib/test_migrate.py | .py | from contextlib import contextmanager
from unittest.mock import Mock, patch
import pytest
from amqp import ChannelError
from kombu import Connection, Exchange, Producer, Queue
from kombu.transport.virtual import QoS
from kombu.utils.encoding import ensure_bytes
from celery.contrib.migrate import (State, StopFiltering... | 305 | 10,615 |
celery | t/unit/contrib/test_sphinx.py | .py | import os
import pytest
try:
from sphinx.application import Sphinx # noqa
from sphinx_testing import TestApp
sphinx_installed = True
except ImportError:
sphinx_installed = False
SRCDIR = os.path.join(os.path.dirname(__file__), 'proj')
@pytest.mark.skipif(
sphinx_installed is False,
reason... | 34 | 870 |
celery | t/unit/contrib/test_rdb.py | .py | import errno
import socket
from unittest.mock import Mock, patch
import pytest
import t.skip
from celery.contrib.rdb import Rdb, debugger, set_trace
from celery.utils.text import WhateverIO
class SockErr(socket.error):
errno = None
class test_Rdb:
@patch('celery.contrib.rdb.Rdb')
def test_debugger(se... | 109 | 3,146 |
celery | t/unit/contrib/test_worker.py | .py | from unittest.mock import Mock, patch
import pytest
# this import adds a @shared_task, which uses connect_on_app_finalize
# to install the celery.ping task that the test lib uses
import celery.contrib.testing.tasks # noqa
from celery import Celery
from celery.contrib.testing.worker import TestWorkController, start_w... | 97 | 3,642 |
celery | t/unit/contrib/test_abortable.py | .py | from celery.contrib.abortable import AbortableAsyncResult, AbortableTask
class test_AbortableTask:
def setup_method(self):
@self.app.task(base=AbortableTask, shared=False)
def abortable():
return True
self.abortable = abortable
def test_async_result_is_abortable(self):
... | 45 | 1,394 |
celery | t/unit/contrib/test_pytest.py | .py | import pytest
pytest_plugins = ["pytester"]
try:
pytest.fail()
except BaseException as e:
Failed = type(e)
@pytest.mark.skipif(
not hasattr(pytest, "PytestUnknownMarkWarning"),
reason="Older pytest version without marker warnings",
)
def test_pytest_celery_marker_registration(testdir):
"""Verify... | 32 | 785 |
celery | t/unit/contrib/django/test_task.py | .py | from unittest.mock import patch
import pytest
@pytest.mark.patched_module(
'django',
'django.db',
'django.db.transaction',
)
@pytest.mark.usefixtures("module")
class test_DjangoTask:
@pytest.fixture
def task_instance(self):
from celery.contrib.django.task import DjangoTask
yield D... | 33 | 866 |
celery | t/unit/contrib/proj/conf.py | .py | import os
import sys
extensions = ['sphinx.ext.autodoc', 'celery.contrib.sphinx']
autodoc_default_flags = ['members']
sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
| 8 | 183 |
celery | t/unit/contrib/proj/foo.py | .py | from xyzzy import plugh # noqa
from celery import Celery, shared_task
app = Celery()
@app.task
def bar():
"""Task.
This is a sample Task.
"""
@shared_task
def baz():
"""Shared Task.
This is a sample Shared Task.
"""
| 22 | 249 |
celery | t/unit/contrib/proj/xyzzy.py | .py | from celery import Celery
app = Celery()
@app.task
def plugh():
"""This task is in a different module!"""
| 9 | 113 |
celery | t/unit/worker/test_revoke.py | .py | from celery.worker import state
class test_revoked:
def test_is_working(self):
state.revoked.add('foo')
assert 'foo' in state.revoked
state.revoked.pop_value('foo')
assert 'foo' not in state.revoked
| 11 | 238 |
celery | t/unit/worker/test_native_delayed_delivery.py | .py | import itertools
import sys
from logging import LogRecord
from typing import Iterator
from unittest.mock import MagicMock, Mock, patch
if sys.version_info < (3, 11): # pragma: no cover
from exceptiongroup import ExceptionGroup
import pytest
from amqp import NotFound
from kombu import Exchange, Queue
from kombu.u... | 494 | 21,053 |
celery | t/unit/worker/test_components.py | .py | from unittest.mock import Mock, patch
import pytest
import t.skip
from celery.exceptions import ImproperlyConfigured
from celery.worker.components import Beat, Hub, Pool, Timer
# some of these are tested in test_worker, so I've only written tests
# here to complete coverage. Should move everything to this module at... | 106 | 3,083 |
celery | t/unit/worker/test_control.py | .py | import socket
import sys
import time
from collections import defaultdict
from datetime import datetime, timedelta
from queue import Queue as FastQueue
from unittest.mock import Mock, PropertyMock, call, patch
import pytest
from kombu import pidbox
from kombu.utils.uuid import uuid
from celery.utils.collections import... | 948 | 33,563 |
celery | t/unit/worker/test_consumer.py | .py | import errno
import logging
import socket
from collections import deque
from unittest.mock import MagicMock, Mock, call, patch
import pytest
from amqp import ChannelError
from billiard.exceptions import RestartFreqExceeded
from celery import bootsteps
from celery.contrib.testing.mocks import ContextMock
from celery.e... | 1,829 | 70,756 |
celery | t/unit/worker/test_strategy.py | .py | import logging
from contextlib import contextmanager
from unittest.mock import ANY, Mock, patch
import pytest
from kombu.utils.limits import TokenBucket
from celery import Task, signals
from celery.app.trace import LOG_RECEIVED
from celery.exceptions import InvalidTaskError
from celery.utils.time import rate
from cel... | 359 | 12,408 |
celery | t/unit/worker/test_autoscale.py | .py | import sys
from time import monotonic
from unittest.mock import Mock, patch
import pytest
from celery.concurrency.base import BasePool
from celery.utils.objects import Bunch
from celery.worker import autoscale, state
class MockPool(BasePool):
shrink_raises_exception = False
shrink_raises_ValueError = False... | 289 | 9,759 |
celery | t/unit/worker/test_request.py | .py | import numbers
import os
import signal
import socket
from datetime import datetime, timedelta, timezone
from time import monotonic, time
from unittest.mock import ANY, Mock, patch
import pytest
from billiard.einfo import ExceptionInfo
from kombu.utils.encoding import from_utf8, safe_repr, safe_str
from kombu.utils.uui... | 1,871 | 68,165 |
celery | t/unit/worker/test_bootsteps.py | .py | from unittest.mock import Mock, patch
import pytest
from celery import bootsteps
class test_StepFormatter:
def test_get_prefix(self):
f = bootsteps.StepFormatter()
s = Mock()
s.last = True
assert f._get_prefix(s) == f.blueprint_prefix
s2 = Mock()
s2.last = False... | 369 | 9,597 |
celery | t/unit/worker/test_heartbeat.py | .py | from unittest.mock import Mock
from celery.worker.heartbeat import Heart
class MockDispatcher:
heart = None
next_iter = 0
def __init__(self):
self.sent = []
self.on_enabled = set()
self.on_disabled = set()
self.enabled = True
def send(self, msg, **_fields):
s... | 94 | 2,384 |
celery | t/unit/worker/test_worker.py | .py | import os
import socket
import sys
from collections import deque
from datetime import datetime, timedelta
from functools import partial
from queue import Empty
from queue import Queue as FastQueue
from threading import Event
from unittest.mock import Mock, patch
import pytest
from amqp import ChannelError
from kombu i... | 1,283 | 43,272 |
celery | t/unit/worker/test_loops.py | .py | import errno
import socket
from queue import Empty
from unittest.mock import Mock
import pytest
from kombu.asynchronous import ERR, READ, WRITE, Hub
from kombu.exceptions import DecodeError
from celery.bootsteps import CLOSE, RUN
from celery.exceptions import InvalidTaskError, WorkerLostError, WorkerShutdown, WorkerT... | 731 | 25,430 |
celery | t/unit/worker/test_state.py | .py | import os
import pickle
import sys
from importlib import import_module
from time import time
from unittest.mock import Mock, patch
import pytest
from celery import uuid
from celery.exceptions import WorkerShutdown, WorkerTerminate
from celery.platforms import EX_OK
from celery.utils.collections import LimitedSet
from... | 223 | 6,339 |
celery | t/unit/app/test_backends.py | .py | import threading
from contextlib import contextmanager
from unittest.mock import patch
import pytest
import celery.contrib.testing.worker as contrib_embed_worker
from celery.app import backends
from celery.backends.cache import CacheBackend
from celery.exceptions import ImproperlyConfigured
from celery.utils.nodename... | 137 | 4,510 |
celery | t/unit/app/test_builtins.py | .py | from unittest.mock import Mock, patch
import pytest
from celery import chord, group
from celery.app import builtins
from celery.contrib.testing.mocks import ContextMock
from celery.utils.functional import pass1
class BuiltinsCase:
def setup_method(self):
@self.app.task(shared=False)
def xsum(x)... | 185 | 5,528 |
celery | t/unit/app/test_exceptions.py | .py | import pickle
from datetime import datetime, timezone
from celery.exceptions import Reject, Retry
class test_Retry:
def test_when_datetime(self):
x = Retry('foo', KeyError(), when=datetime.now(timezone.utc))
assert x.humanize()
def test_pickleable(self):
x = Retry('foo', KeyError(),... | 34 | 829 |
celery | t/unit/app/test_log.py | .py | import logging
import sys
from collections import defaultdict
from io import StringIO
from tempfile import mkstemp
from unittest.mock import Mock, patch
import pytest
from celery import signals, uuid
from celery.app.log import TaskFormatter
from celery.utils.log import ColorFormatter, LoggingProxy, get_logger, get_ta... | 360 | 11,820 |
celery | t/unit/app/test_beat.py | .py | import dbm
import errno
import pickle
import sys
from datetime import datetime, timedelta, timezone
from pickle import dumps, loads
from unittest.mock import MagicMock, Mock, call, patch
import pytest
from celery import __version__, beat, uuid
from celery.beat import BeatLazyFunc, event_t
from celery.schedules import... | 956 | 33,572 |
celery | t/unit/app/test_loaders.py | .py | import os
import sys
import warnings
from unittest.mock import Mock, patch
import pytest
from celery import loaders
from celery.exceptions import NotConfigured
from celery.loaders import base, default
from celery.loaders.app import AppLoader
from celery.utils.imports import NotAPackage
class DummyLoader(base.BaseLo... | 308 | 11,599 |
celery | t/unit/app/test_schedules.py | .py | import sys
import time
from contextlib import contextmanager
from datetime import datetime, timedelta, timezone
from pickle import dumps, loads
from unittest import TestCase
from unittest.mock import Mock
import pytest
from celery.exceptions import ImproperlyConfigured
from celery.schedules import ParseException, cro... | 1,073 | 41,599 |
celery | t/unit/app/test_control.py | .py | from unittest.mock import Mock
import pytest
from celery import uuid
from celery.app import control
from celery.exceptions import DuplicateNodenameWarning, ImproperlyConfigured
from celery.utils.collections import LimitedSet
def _info_for_commandclass(type_):
from celery.worker.control import Panel
return [... | 583 | 19,670 |
celery | t/unit/app/test_registry.py | .py | import pytest
from celery.app.registry import _unpickle_task, _unpickle_task_v2
from celery.exceptions import InvalidTaskError
def returns():
return 1
@pytest.mark.usefixtures('depends_on_current_app')
class test_unpickle_task:
def test_unpickle_v1(self, app):
app.tasks['txfoo'] = 'bar'
as... | 78 | 2,349 |
celery | t/unit/app/test_app.py | .py | import gc
import importlib
import inspect
import itertools
import os
import ssl
import sys
import typing
import uuid
from copy import deepcopy
from datetime import datetime, timedelta
from datetime import timezone as datetime_timezone
from logging import LogRecord
from pickle import dumps, loads
from typing import Opti... | 2,200 | 81,694 |
celery | t/unit/app/test_celery.py | .py | import pytest
import celery
def test_version():
assert celery.VERSION
assert len(celery.VERSION) >= 3
celery.VERSION = (0, 3, 0)
assert celery.__version__.count('.') >= 2
@pytest.mark.parametrize('attr', [
'__author__', '__contact__', '__homepage__', '__docformat__',
])
def test_meta(attr):
... | 18 | 356 |
celery | t/unit/app/test_preload_cli.py | .py | import contextlib
from typing import Tuple
from unittest.mock import patch
import pytest
from click.testing import CliRunner
from celery.bin.celery import celery
@pytest.fixture(autouse=True)
def reset_command_params_between_each_test():
with contextlib.ExitStack() as stack:
for command in celery.comman... | 58 | 1,720 |
celery | t/unit/app/test_defaults.py | .py | import sys
from importlib import import_module
from celery.app.defaults import (_OLD_DEFAULTS, _OLD_SETTING_KEYS, _TO_NEW_KEY, _TO_OLD_KEY, DEFAULTS, NAMESPACES,
SETTING_KEYS)
class test_defaults:
def setup_method(self):
self._prev = sys.modules.pop('celery.app.defaults'... | 48 | 1,608 |
celery | t/unit/app/test_routes.py | .py | from unittest.mock import ANY, Mock
import pytest
from kombu import Exchange, Queue
from kombu.utils.functional import maybe_evaluate
from celery.app import routes
from celery.exceptions import QueueNotFound
from celery.utils.imports import qualname
def Router(app, *args, **kwargs):
return routes.Router(*args, ... | 235 | 8,026 |
celery | t/unit/app/test_trace.py | .py | """Unit tests for celery.app.trace module."""
import sys
from celery.app.trace import traceback_clear
class test_traceback_clear:
"""Unit tests for traceback_clear function."""
def test_uses_exc_argument(self):
"""Test that traceback_clear(exc) correctly uses the exc argument.
This test pr... | 135 | 5,083 |
celery | t/unit/app/test_annotations.py | .py | from celery.app.annotations import MapAnnotation, prepare
from celery.utils.imports import qualname
class MyAnnotation:
foo = 65
class AnnotationCase:
def setup_method(self):
@self.app.task(shared=False)
def add(x, y):
return x + y
self.add = add
@self.app.task(... | 53 | 1,338 |
celery | t/unit/app/test_utils.py | .py | from collections.abc import Mapping, MutableMapping
from unittest.mock import Mock
from celery.app.utils import Settings, bugreport, filter_hidden_settings
class test_Settings:
def test_is_mapping(self):
"""Settings should be a collections.Mapping"""
assert issubclass(Settings, Mapping)
def... | 60 | 1,790 |
celery | t/unit/app/test_amqp.py | .py | from datetime import datetime, timedelta, timezone
from unittest.mock import Mock, patch
import pytest
from kombu import Exchange, Queue
from celery import uuid
from celery.app.amqp import Queues, utf8dict
from celery.utils.time import to_utc
class test_TaskConsumer:
def test_accept_content(self, app):
... | 500 | 17,537 |
celery | t/smoke/signals.py | .py | """Signal Handlers for the smoke test."""
from celery.signals import worker_init, worker_process_init, worker_process_shutdown, worker_ready, worker_shutdown
@worker_init.connect
def worker_init_handler(sender, **kwargs):
print("worker_init_handler")
@worker_process_init.connect
def worker_process_init_handler... | 29 | 744 |
celery | t/smoke/tasks.py | .py | """Smoke tests tasks."""
from __future__ import annotations
import os
import sys
from signal import SIGKILL
from time import sleep
import celery.utils
from celery import Task, shared_task, signature
from celery.canvas import Signature
from t.integration.tasks import * # noqa
from t.integration.tasks import replaced... | 104 | 2,609 |
celery | t/smoke/conftest.py | .py | from __future__ import annotations
import os
import pytest
from pytest_celery import (LOCALSTACK_CREDS, REDIS_CONTAINER_TIMEOUT, REDIS_ENV, REDIS_IMAGE, REDIS_PORTS,
CeleryTestSetup, RedisContainer)
from pytest_docker_tools import container, fetch, fxtr
from celery import Celery
from t.smo... | 156 | 5,068 |
celery | t/smoke/operations/worker_restart.py | .py | from __future__ import annotations
from enum import Enum, auto
from pytest_celery import CeleryTestWorker
class WorkerRestart:
"""Restarts a worker in different ways."""
class Method(Enum):
POOL_RESTART = auto()
DOCKER_RESTART_GRACEFULLY = auto()
DOCKER_RESTART_FORCE = auto()
de... | 43 | 1,369 |
celery | t/smoke/operations/task_termination.py | .py | from __future__ import annotations
from enum import Enum, auto
from pytest_celery import CeleryTestWorker
from celery.canvas import Signature
from celery.result import AsyncResult
from t.smoke.tasks import (self_termination_delay_timeout, self_termination_exhaust_memory, self_termination_sigkill,
... | 49 | 1,855 |
celery | t/smoke/operations/worker_kill.py | .py | from __future__ import annotations
from enum import Enum, auto
from pytest_celery import CeleryTestWorker
from celery.app.control import Control
class WorkerKill:
"""Kills a worker in different ways."""
class Method(Enum):
DOCKER_KILL = auto()
CONTROL_SHUTDOWN = auto()
SIGTERM = au... | 48 | 1,346 |
celery | t/smoke/tests/test_tasks.py | .py | from __future__ import annotations
import pytest
from pytest_celery import RESULT_TIMEOUT, CeleryTestSetup, CeleryTestWorker, CeleryWorkerCluster
from tenacity import retry, stop_after_attempt, wait_fixed
from celery import Celery, signature
from celery.exceptions import SoftTimeLimitExceeded, TimeLimitExceeded, Work... | 147 | 5,529 |
celery | t/smoke/tests/test_gossip.py | .py | from __future__ import annotations
import os
import socket
import time
from contextlib import closing, suppress
from time import monotonic
from unittest.mock import Mock, patch
from pytest_celery import CeleryTestSetup
from celery import uuid
from celery.events.state import HEARTBEAT_DRIFT_MAX
from celery.utils.obje... | 79 | 2,900 |
celery | t/smoke/tests/test_control.py | .py | from pytest_celery import CeleryTestSetup
class test_control:
def test_sanity(self, celery_setup: CeleryTestSetup):
r = celery_setup.app.control.ping()
assert all(
[
all([res["ok"] == "pong" for _, res in response.items()])
for response in r
... | 19 | 688 |
celery | t/smoke/tests/test_consumer.py | .py | import pytest
from pytest_celery import RESULT_TIMEOUT, CeleryTestSetup, RedisTestBroker
from celery import Celery
from celery.canvas import chain, group
from t.smoke.tasks import long_running_task, noop
WORKER_PREFETCH_MULTIPLIER = 2
WORKER_CONCURRENCY = 5
MAX_PREFETCH = WORKER_PREFETCH_MULTIPLIER * WORKER_CONCURREN... | 178 | 7,872 |
celery | t/smoke/tests/test_rpc_backend.py | .py | """Smoke tests for the RPC result backend.
Regression coverage for https://github.com/celery/celery/issues/4830:
polling the RPC backend for a completed task used to requeue the final
result message instead of acking it, so final results recirculated on
the reply queue on every state poll. These tests run against a re... | 163 | 5,772 |
celery | t/smoke/tests/test_dedup_chain_dispatch.py | .py | """Smoke tests for chain/callback dispatch on the dedup fast-path.
When ``worker_deduplicate_successful_tasks=True`` and
``task_acks_late=True``, a redelivered task that hits the dedup
fast-path in ``trace.py`` must still dispatch its chain and link
callbacks.
See https://github.com/celery/celery/issues/9835
"""
from... | 60 | 2,338 |
celery | t/smoke/tests/test_signals.py | .py | import pytest
from pytest_celery import CeleryBackendCluster, CeleryTestSetup
from celery.signals import after_task_publish, before_task_publish
from t.smoke.tasks import noop
@pytest.fixture
def default_worker_signals(default_worker_signals: set) -> set:
from t.smoke import signals
default_worker_signals.a... | 61 | 1,847 |
celery | t/smoke/tests/test_worker.py | .py | from time import sleep
from types import ModuleType
import pytest
from pytest_celery import CeleryTestSetup, CeleryTestWorker, RabbitMQTestBroker, RedisTestBroker
from pytest_docker_tools.wrappers.container import wait_for_callable
import celery
from celery import Celery
from celery.canvas import chain, group
from t.... | 631 | 28,792 |
celery | t/smoke/tests/test_thread_safe.py | .py | from __future__ import annotations
from concurrent.futures import ThreadPoolExecutor
from unittest.mock import Mock
import pytest
from pytest_celery import CeleryTestSetup, CeleryTestWorker, CeleryWorkerCluster
from celery import Celery
from celery.app.base import set_default_app
from celery.signals import after_tas... | 74 | 1,976 |
celery | t/smoke/tests/test_canvas.py | .py | import uuid
import pytest
from pytest_celery import RESULT_TIMEOUT, CeleryTestSetup
from celery.canvas import chain, chord, group, signature
from t.integration.conftest import get_redis_connection
from t.integration.tasks import ExpectedException, add, fail, identity, redis_echo
class test_signature:
def test_s... | 194 | 7,238 |
celery | t/smoke/tests/quorum_queues/test_quorum_queues.py | .py | import requests
from pytest_celery import RESULT_TIMEOUT, CeleryTestSetup
from requests.auth import HTTPBasicAuth
from celery.canvas import group
from t.integration.tasks import add, identity
from t.smoke.tests.quorum_queues.conftest import RabbitMQManagementBroker
class test_broker_configuration:
def test_queue... | 37 | 1,669 |
celery | t/smoke/tests/quorum_queues/test_default_queue_type.py | .py | """Smoke tests for default queue type fallback behavior.
Tests that Celery respects task_default_exchange_type and
task_default_queue_type when using implicit routing.
"""
from __future__ import annotations
import pytest
import requests
from pytest_celery import RESULT_TIMEOUT, CeleryTestSetup
from requests.auth impo... | 54 | 1,927 |
celery | t/smoke/tests/quorum_queues/test_native_delayed_delivery.py | .py | import time
from datetime import datetime, timedelta
from datetime import timezone as datetime_timezone
import pytest
import requests
from pytest_celery import CeleryTestSetup
from requests.auth import HTTPBasicAuth
from celery import Celery, chain
from t.smoke.tasks import add, noop
from t.smoke.tests.quorum_queues.... | 284 | 10,128 |
celery | t/smoke/tests/quorum_queues/test_native_delayed_delivery_binding.py | .py | """Smoke tests for native delayed delivery queue binding.
Verifies queue bindings are created correctly for native delayed delivery,
including when some queues in task_queues fail to bind.
See https://github.com/celery/celery/issues/9960
"""
from __future__ import annotations
import pytest
import requests
from pytes... | 78 | 2,798 |
celery | t/smoke/tests/quorum_queues/test_qos.py | .py | """Smoke tests for quorum queue QoS behavior.
Verifies that tasks execute correctly on quorum queues with QoS settings
that differ from classic queues (no global QoS).
See https://github.com/celery/celery/issues/9929
"""
from __future__ import annotations
import pytest
from pytest_celery import RESULT_TIMEOUT, Celer... | 204 | 9,641 |
celery | t/smoke/tests/quorum_queues/test_chord_unlock_routing.py | .py | """Smoke tests for chord_unlock routing to quorum queues.
Reproduces Celery Discussion #9742: when chord_unlock is routed to a
quorum queue via topic exchange, it may not be consumed even if declared
and bound.
"""
from __future__ import annotations
import pytest
from pytest_celery import RESULT_TIMEOUT, CeleryTestS... | 66 | 2,197 |
celery | t/smoke/tests/quorum_queues/test_cycle_detection.py | .py | """Smoke tests for RabbitMQ cycle detection with quorum queues.
Reproduces conditions for https://github.com/celery/celery/issues/9867
when running against RabbitMQ <4.0.1.
"""
from __future__ import annotations
from pytest_celery import RESULT_TIMEOUT, CeleryTestSetup
from t.smoke.tasks import countdown_task_with_r... | 27 | 1,112 |
celery | t/smoke/tests/quorum_queues/conftest.py | .py | from __future__ import annotations
import os
import pytest
from pytest_celery import RABBITMQ_PORTS, CeleryBrokerCluster, RabbitMQContainer, RabbitMQTestBroker, defaults
from pytest_docker_tools import build, container, fxtr
from celery import Celery
from t.smoke.workers.dev import SmokeWorkerContainer
############... | 120 | 3,441 |
celery | t/smoke/tests/failover/test_worker_failover.py | .py | from __future__ import annotations
import pytest
from pytest_celery import RESULT_TIMEOUT, CeleryTestSetup, CeleryTestWorker, CeleryWorkerCluster
from celery import Celery
from t.smoke.conftest import SuiteOperations, WorkerKill
from t.smoke.tasks import long_running_task
@pytest.fixture
def celery_worker_cluster(
... | 56 | 1,774 |
celery | t/smoke/tests/failover/test_broker_failover.py | .py | import pytest
from pytest_celery import (RABBITMQ_CONTAINER_TIMEOUT, RESULT_TIMEOUT, CeleryBrokerCluster, CeleryTestSetup,
RabbitMQContainer, RabbitMQTestBroker)
from pytest_docker_tools import container, fxtr
from t.integration.tasks import identity
failover_broker = container(
image="... | 61 | 2,451 |
celery | t/smoke/tests/stamping/test_revoke.py | .py | from __future__ import annotations
import pytest
from pytest_celery import CeleryBackendCluster, CeleryTestWorker, CeleryWorkerCluster
from celery.canvas import Signature, chain
from celery.result import AsyncResult
from t.integration.tasks import StampOnReplace, identity
from t.smoke.tests.stamping.tasks import wait... | 76 | 2,209 |
celery | t/smoke/tests/stamping/test_visitor.py | .py | from __future__ import annotations
import json
from pytest_celery import RESULT_TIMEOUT, CeleryTestWorker
from celery.canvas import StampingVisitor
from t.integration.tasks import add, identity
class test_stamping_visitor:
def test_callback(self, dev_worker: CeleryTestWorker):
on_signature_stamp = {"on... | 41 | 1,457 |
celery | t/smoke/tests/stamping/signals.py | .py | import json
from celery.signals import task_received
@task_received.connect
def task_received_handler(request, **kwargs):
stamps = request.request_dict.get("stamps")
stamped_headers = request.request_dict.get("stamped_headers")
stamps_dump = json.dumps(stamps, indent=4, sort_keys=True) if stamps else sta... | 13 | 411 |
celery | t/smoke/tests/stamping/test_hybrid_cluster.py | .py | from __future__ import annotations
import json
import pytest
from pytest_celery import RESULT_TIMEOUT, CeleryTestSetup, CeleryTestWorker, CeleryWorkerCluster
from celery.canvas import StampingVisitor, chain
from t.integration.tasks import StampOnReplace, identity, replace_with_stamped_task
def get_hybrid_clusters_... | 161 | 5,915 |
celery | t/smoke/tests/stamping/tasks.py | .py | from time import sleep
from celery import shared_task
from t.integration.tasks import LEGACY_TASKS_DISABLED
@shared_task
def waitfor(seconds: int) -> None:
print(f"Waiting for {seconds} seconds...")
for i in range(seconds):
sleep(1)
print(f"{i+1} seconds passed")
print("Done waiting")
i... | 23 | 708 |
celery | t/smoke/tests/stamping/conftest.py | .py | import pytest
from pytest_celery import CeleryTestSetup, CeleryTestWorker
from t.smoke.tests.stamping.workers.legacy import * # noqa
from t.smoke.tests.stamping.workers.legacy import LegacyWorkerContainer
from t.smoke.workers.dev import SmokeWorkerContainer
@pytest.fixture
def default_rabbitmq_broker_image() -> str... | 48 | 1,399 |
celery | t/smoke/tests/stamping/workers/legacy.py | .py | from typing import Any
import pytest
from pytest_celery import CeleryTestWorker, CeleryWorkerContainer, defaults
from pytest_docker_tools import build, container, fxtr
from celery import Celery
class LegacyWorkerContainer(CeleryWorkerContainer):
@property
def client(self) -> Any:
return self
@c... | 58 | 1,491 |
celery | t/smoke/workers/alias.py | .py | """Celery worker app module declaring a queue selected by its alias.
Used as the app module of a worker container to declare a queue topology
with :class:`kombu.Queue` objects, which cannot be serialized through the
worker configuration changes.
"""
from __future__ import annotations
import json
from kombu import Q... | 29 | 641 |
celery | t/smoke/workers/latest.py | .py | from typing import Any
import pytest
from pytest_celery import CeleryTestWorker, CeleryWorkerContainer, defaults
from pytest_docker_tools import build, container, fxtr
from celery import Celery
class CeleryLatestWorkerContainer(CeleryWorkerContainer):
"""Defines the configurations for a Celery worker container.... | 63 | 1,761 |
celery | t/smoke/workers/alt.py | .py | from __future__ import annotations
import os
import pytest
from pytest_celery import CeleryTestWorker, defaults
from pytest_docker_tools import build, container, fxtr
from celery import Celery
from t.smoke.workers.dev import SmokeWorkerContainer
class AltSmokeWorkerContainer(SmokeWorkerContainer):
"""Alternati... | 59 | 1,671 |
celery | t/smoke/workers/other.py | .py | from __future__ import annotations
import os
import pytest
from pytest_celery import CeleryTestWorker, defaults
from pytest_docker_tools import build, container, fxtr
from celery import Celery
from t.smoke.workers.dev import SmokeWorkerContainer
class OtherSmokeWorkerContainer(SmokeWorkerContainer):
"""Alterna... | 63 | 1,813 |
celery | t/smoke/workers/dev.py | .py | import os
from typing import Any, Type
import pytest
from pytest_celery import CeleryWorkerContainer, defaults
from pytest_docker_tools import build, container, fxtr
import celery
class SmokeWorkerContainer(CeleryWorkerContainer):
"""Defines the configurations for the smoke tests worker container.
This wor... | 86 | 2,363 |
celery | examples/security/mysecureapp.py | .py | """mysecureapp.py
Usage::
Generate Certificate:
```
mkdir ssl
openssl req -x509 -newkey rsa:4096 -keyout ssl/worker.key -out ssl/worker.pem -days 365
# remove passphrase
openssl rsa -in ssl/worker.key -out ssl/worker.key
Enter pass phrase for ssl/worker.key:
writing RSA key
```
cd examp... | 54 | 1,058 |
celery | examples/django/manage.py | .py | #!/usr/bin/env python
import os
import sys
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'proj.settings')
from django.core.management import execute_from_command_line
execute_from_command_line(sys.argv)
| 12 | 248 |
celery | examples/django/proj/wsgi.py | .py | """
WSGI config for proj project.
This module contains the WSGI application used by Django's development server
and any production WSGI deployments. It should expose a module-level variable
named ``application``. Django's ``runserver`` and ``runfcgi`` commands discover
this application via the ``WSGI_APPLICATION`` set... | 31 | 1,132 |
celery | examples/django/proj/celery.py | .py | import os
from celery import Celery
# Set the default Django settings module for the 'celery' program.
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'proj.settings')
app = Celery('proj')
# Using a string here means the worker doesn't have to serialize
# the configuration object to child processes.
# - namespace='... | 23 | 659 |
celery | examples/django/proj/settings.py | .py | import os
# ^^^ The above is required if you want to import from the celery
# library. If you don't have this then `from celery.schedules import`
# becomes `proj.celery.schedules` in Python 2.x since it allows
# for relative imports by default.
# Celery settings
CELERY_BROKER_URL = 'amqp://guest:guest@localhost'
#... | 139 | 3,639 |
celery | examples/django/demoapp/models.py | .py | from django.db import models
class Widget(models.Model):
name = models.CharField(max_length=140)
| 6 | 103 |
celery | examples/django/demoapp/tasks.py | .py | # Create your tasks here
from demoapp.models import Widget
from celery import shared_task
@shared_task
def add(x, y):
return x + y
@shared_task
def mul(x, y):
return x * y
@shared_task
def xsum(numbers):
return sum(numbers)
@shared_task
def count_widgets():
return Widget.objects.count()
@sha... | 53 | 1,024 |
celery | examples/eventlet/bulk_task_producer.py | .py | from eventlet import Timeout, monkey_patch, spawn_n
from eventlet.event import Event
from eventlet.queue import LightQueue
monkey_patch()
class Receipt:
result = None
def __init__(self, callback=None):
self.callback = callback
self.ready = Event()
def finished(self, result):
sel... | 64 | 1,673 |
celery | examples/eventlet/celeryconfig.py | .py | import os
import sys
sys.path.insert(0, os.getcwd())
# ## Start worker with -P eventlet
# Never use the worker_pool setting as that'll patch
# the worker too late.
broker_url = 'amqp://guest:guest@localhost:5672//'
worker_disable_rate_limits = True
result_expires = 30 * 60
imports = ('tasks', 'webcrawler')
| 15 | 312 |
celery | examples/eventlet/tasks.py | .py | import requests
from celery import shared_task
@shared_task()
def urlopen(url):
print(f"-open: {url}")
try:
response = requests.get(url, timeout=10.0)
except requests.exceptions.RequestException as exc:
print(f"-url {url} gave error: {exc!r}")
return
return len(response.text)
| 15 | 320 |
celery | examples/eventlet/webcrawler.py | .py | """Recursive webcrawler example.
For asynchronous DNS lookups install the `dnspython` package:
$ pip install dnspython
Requires the `pybloom` module for the bloom filter which is used
to ensure a lower chance of recrawling a URL previously seen.
Since the bloom filter is not shared, but only passed as an argume... | 69 | 2,009 |
celery | examples/next-steps/setup.py | .py | """
Example setup file for a project using Celery.
This can be used to distribute your tasks and worker
as a Python package, on PyPI or on your own private package index.
"""
from setuptools import find_packages, setup
setup(
name='example-tasks',
url='http://github.com/example/celery-tasks',
author='Ol... | 40 | 1,224 |
celery | examples/next-steps/proj/celery.py | .py | from celery import Celery
app = Celery('proj',
broker='amqp://',
backend='rpc://',
include=['proj.tasks'])
# Optional configuration, see the application user guide.
app.conf.update(
result_expires=3600,
)
if __name__ == '__main__':
app.start()
| 15 | 294 |
celery | examples/next-steps/proj/tasks.py | .py | from .celery import app
@app.task
def add(x, y):
return x + y
@app.task
def mul(x, y):
return x * y
@app.task
def xsum(numbers):
return sum(numbers)
| 17 | 167 |
celery | examples/tutorial/tasks.py | .py | from celery import Celery
app = Celery('tasks', broker='amqp://')
@app.task()
def add(x, y):
return x + y
if __name__ == '__main__':
app.start()
| 13 | 158 |
celery | examples/celery_http_gateway/manage.py | .py | #!/usr/bin/env python
from django.core.management import execute_manager
try:
import settings # Assumed to be in the same directory.
except ImportError:
import sys
sys.stderr.write(
"Error: Can't find the file 'settings.py' in the directory "
"containing {!r}.".format(__file__))
sys.e... | 16 | 385 |
celery | examples/celery_http_gateway/urls.py | .py | from celery_http_gateway.tasks import hello_world
from django.conf.urls.defaults import handler404, handler500, include, patterns, url # noqa
from djcelery import views as celery_views
# Uncomment the next two lines to enable the admin:
# from django.contrib import admin
# admin.autodiscover()
urlpatterns = patterns... | 18 | 678 |
celery | examples/celery_http_gateway/settings.py | .py | import django
# Django settings for celery_http_gateway project.
DEBUG = True
TEMPLATE_DEBUG = DEBUG
CELERY_RESULT_BACKEND = 'database'
BROKER_URL = 'amqp://guest:guest@localhost:5672//'
ADMINS = (
# ('Your Name', 'your_email@domain.com'),
)
MANAGERS = ADMINS
DATABASES = {
'default': {
'ENGINE': ... | 100 | 3,001 |
celery | examples/celery_http_gateway/tasks.py | .py | from celery import task
@task()
def hello_world(to='world'):
return f'Hello {to}'
| 7 | 88 |
celery | examples/quorum-queues/declare_queue.py | .py | """Create a quorum queue using Kombu."""
from kombu import Connection, Exchange, Queue
my_quorum_queue = Queue(
"my-quorum-queue",
Exchange("default"),
routing_key="default",
queue_arguments={"x-queue-type": "quorum"},
)
with Connection("amqp://guest@localhost//") as conn:
channel = conn.channel(... | 16 | 389 |
celery | examples/quorum-queues/myapp.py | .py | """myapp.py
Usage::
(window1)$ python myapp.py worker -l INFO
(window2)$ celery shell
>>> from myapp import example
>>> example()
You can also specify the app to use with the `celery` command,
using the `-A` / `--app` option::
$ celery -A myapp worker -l INFO
With the `-A myproj` argument the pro... | 150 | 4,266 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.