steady-queue 0.2.0__tar.gz → 0.3.0__tar.gz

{steady_queue-0.2.0/steady_queue.egg-info → steady_queue-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steady-queue
-Version: 0.2.0
+Version: 0.3.0
 Summary: An asynchronous task library for Django that supports delayed tasks, concurrency controls, recurring tasks, pausing queues, numeric priorities per task, priorities by queue order and bulk enqueueing.
 Author-email: Elias Hernandis <elias@hernandis.me>
 License-Expression: MIT
@@ -535,8 +535,17 @@ instance that is handling the task, as well as the `task_result` (a
 `django.tasks.TaskResult` instance) with information on how the task was called
 and its status.
 
-Unlike Solid Queue, steady queue doesn't yet emit signals related to the
-lifecycle of its processes.
+Steady Queue also emits operational signals from ``steady_queue.signals``:
+
+- `process_started` and `process_stopped` when a supervisor or child process
+  enters or leaves its run loop.
+- `process_restarted` when the supervisor replaces a terminated child.
+- `queue_paused` and `queue_resumed` after queue control actions.
+
+Process signals include process identity and metadata. Queue signals include a
+`changed` flag so receivers can distinguish state transitions from idempotent
+actions. See the [configuration documentation](https://steady-queue.readthedocs.io/en/latest/configuration.html#signals)
+for the complete payloads.
 
 ## Logging
 
@@ -824,8 +833,9 @@ there are a few differences which we outline below.
   will ever be supported, but we've kept the database column for compatibility.
 - Steady Queue worker processes do not set the process name (or procline)
   because doing so requires introducing an external dependency.
-- Steady Queue does not expose rich instrumentation like Solid Queue does due to
-  the lack of a framework-native equivalent to `ActiveSupport::Notifications`.
+- Steady Queue exposes Django signals for task and operational lifecycle events,
+  but does not yet provide the full timed instrumentation event set emitted by
+  Solid Queue through `ActiveSupport::Notifications`.
 - **Priority ordering:** Steady Queue follows Django's convention where larger
   numbers indicate higher priority (e.g., a task with priority 10 runs before
   priority 0), whereas Solid Queue uses the inverse (smaller numbers = higher

{steady_queue-0.2.0 → steady_queue-0.3.0}/README.md

@@ -506,8 +506,17 @@ instance that is handling the task, as well as the `task_result` (a
 `django.tasks.TaskResult` instance) with information on how the task was called
 and its status.
 
-Unlike Solid Queue, steady queue doesn't yet emit signals related to the
-lifecycle of its processes.
+Steady Queue also emits operational signals from ``steady_queue.signals``:
+
+- `process_started` and `process_stopped` when a supervisor or child process
+  enters or leaves its run loop.
+- `process_restarted` when the supervisor replaces a terminated child.
+- `queue_paused` and `queue_resumed` after queue control actions.
+
+Process signals include process identity and metadata. Queue signals include a
+`changed` flag so receivers can distinguish state transitions from idempotent
+actions. See the [configuration documentation](https://steady-queue.readthedocs.io/en/latest/configuration.html#signals)
+for the complete payloads.
 
 ## Logging
 
@@ -795,8 +804,9 @@ there are a few differences which we outline below.
   will ever be supported, but we've kept the database column for compatibility.
 - Steady Queue worker processes do not set the process name (or procline)
   because doing so requires introducing an external dependency.
-- Steady Queue does not expose rich instrumentation like Solid Queue does due to
-  the lack of a framework-native equivalent to `ActiveSupport::Notifications`.
+- Steady Queue exposes Django signals for task and operational lifecycle events,
+  but does not yet provide the full timed instrumentation event set emitted by
+  Solid Queue through `ActiveSupport::Notifications`.
 - **Priority ordering:** Steady Queue follows Django's convention where larger
   numbers indicate higher priority (e.g., a task with priority 10 runs before
   priority 0), whereas Solid Queue uses the inverse (smaller numbers = higher

{steady_queue-0.2.0 → steady_queue-0.3.0}/steady_queue/__init__.py

@@ -1,7 +1,7 @@
 from datetime import timedelta
 from typing import Optional
 
-VERSION = (0, 2, 0)
+VERSION = (0, 3, 0)
 
 __version__ = ".".join(map(str, VERSION))
 

{steady_queue-0.2.0 → steady_queue-0.3.0}/steady_queue/app_executor.py

@@ -40,9 +40,8 @@ class AppExecutor:
                 connection.close()
             raise
         finally:
-            # Django automatically manages connection lifecycle,
-            # but we can explicitly close if needed for long-running processes
             if threading.current_thread() != threading.main_thread():
-                # Only close connections in background threads
-                # Main thread connections are handled by Django's request/response cycle
-                connection.close()
+                # Worker threads are reused without Django's request cleanup.
+                # Return connections for every initialized alias, including the
+                # application databases used by the task, to their pools.
+                connections.close_all()

{steady_queue-0.2.0 → steady_queue-0.3.0}/steady_queue/models/queue.py

@@ -2,6 +2,7 @@ from django.db import models
 
 from steady_queue.models.pause import Pause
 from steady_queue.models.ready_execution import ReadyExecution
+from steady_queue.signals import QueueLifecycle, queue_paused, queue_resumed
 
 
 class QueueQuerySet(models.QuerySet):
@@ -48,10 +49,20 @@ class Queue(models.Model):
         return not self.is_paused
 
     def pause(self) -> None:
-        Pause.objects.get_or_create(queue_name=self.queue_name)
+        _, changed = Pause.objects.get_or_create(queue_name=self.queue_name)
+        queue_paused.send(
+            sender=QueueLifecycle,
+            queue_name=self.queue_name,
+            changed=changed,
+        )
 
     def resume(self) -> None:
-        Pause.objects.filter(queue_name=self.queue_name).delete()
+        deleted, _ = Pause.objects.filter(queue_name=self.queue_name).delete()
+        queue_resumed.send(
+            sender=QueueLifecycle,
+            queue_name=self.queue_name,
+            changed=deleted > 0,
+        )
 
     def __str__(self) -> str:
         return self.queue_name

{steady_queue-0.2.0 → steady_queue-0.3.0}/steady_queue/models/recurring_execution.py

@@ -1,4 +1,4 @@
-from django.db import models
+from django.db import IntegrityError, models
 from django.tasks import TaskResult
 
 from .execution import Execution, ExecutionQuerySet
@@ -9,9 +9,10 @@ class RecurringExecutionQuerySet(ExecutionQuerySet):
         return self.filter(job__isnull=True)
 
     def record(self, task_result: TaskResult, task, run_at):
-        self.update_or_create(
-            task=task, run_at=run_at, defaults={"job_id": task_result.id}
-        )
+        try:
+            self.create(task=task, run_at=run_at, job_id=task_result.id)
+        except IntegrityError as e:
+            raise self.model.AlreadyRecorded from e
 
     def clear_in_batches(self, batch_size=500):
         while True:
@@ -21,6 +22,9 @@ class RecurringExecutionQuerySet(ExecutionQuerySet):
 
 
 class RecurringExecution(Execution):
+    class AlreadyRecorded(Exception):
+        pass
+
     class Meta:
         verbose_name = "recurring execution"
         verbose_name_plural = "recurring executions"

{steady_queue-0.2.0 → steady_queue-0.3.0}/steady_queue/models/recurring_task.py

@@ -97,7 +97,10 @@ class RecurringTask(UpdatedAtMixin, BaseModel):
         return self.recurring_executions.max("run_at")
 
     def enqueue(self, run_at: datetime):
-        return self.enqueue_and_record(run_at)
+        try:
+            return self.enqueue_and_record(run_at)
+        except RecurringExecution.AlreadyRecorded:
+            return False
 
     def enqueue_and_record(self, run_at: datetime):
         with transaction.atomic(using=self._state.db):
@@ -108,6 +111,7 @@ class RecurringTask(UpdatedAtMixin, BaseModel):
                 queue_name=self.queue_name, priority=self.priority
             ).enqueue(*args, **kwargs)
             RecurringExecution.objects.record(task_result, self, run_at)
+            return task_result
 
     @property
     def previous_time(self) -> datetime:

{steady_queue-0.2.0 → steady_queue-0.3.0}/steady_queue/processes/runnable.py

@@ -1,6 +1,12 @@
 import logging
 
 from steady_queue.processes.supervised import Supervised
+from steady_queue.signals import (
+    _process_signal_context,
+    _send_process_signal,
+    process_started,
+    process_stopped,
+)
 
 logger = logging.getLogger("steady_queue")
 
@@ -10,11 +16,22 @@ class Runnable(Supervised):
 
     def start(self):
         self.boot()
-
-        if self.is_running_async:
-            raise NotImplementedError
-        else:
-            self.run()
+        signal_context = _process_signal_context(self)
+        _send_process_signal(process_started, self, context=signal_context)
+
+        error = None
+        try:
+            if self.is_running_async:
+                raise NotImplementedError
+            else:
+                self.run()
+        except BaseException as exception:
+            error = exception
+            raise
+        finally:
+            _send_process_signal(
+                process_stopped, self, context=signal_context, error=error
+            )
 
     def stop(self):
         super().stop()

{steady_queue-0.2.0 → steady_queue-0.3.0}/steady_queue/processes/supervisor.py

@@ -15,6 +15,14 @@ from steady_queue.processes.pidfiled import Pidfiled
 from steady_queue.processes.registrable import Registrable
 from steady_queue.processes.signals import Signals
 from steady_queue.processes.timer import wait_until
+from steady_queue.signals import (
+    ProcessLifecycle,
+    _process_signal_context,
+    _send_process_signal,
+    process_restarted,
+    process_started,
+    process_stopped,
+)
 
 logger = logging.getLogger("steady_queue")
 
@@ -40,19 +48,35 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
         super().__init__()
 
     def start(self) -> None:
-        logger.info("starting supervisor with PID %(pid)d", {"pid": self.pid})
+        originating_pid = self.pid
+        logger.info("starting supervisor with PID %(pid)d", {"pid": originating_pid})
+        started = False
+        error = None
+        signal_context = None
         try:
-            self.boot()
-            # Fork only after resetting DB state (connections + psycopg pools).
-            self.reset_database_connections()
-            self.start_processes()
-            self.launch_maintenance_task()
-        except SystemExit:
-            logger.info("supervisor interrupted during boot, shutting down")
-            self.restore_default_signal_handlers()
-            self.shutdown()
-            return
-        self.supervise()
+            try:
+                self.boot()
+                started = True
+                signal_context = _process_signal_context(self)
+                _send_process_signal(process_started, self, context=signal_context)
+                # Fork only after resetting DB state (connections + psycopg pools).
+                self.reset_database_connections()
+                self.start_processes()
+                self.launch_maintenance_task()
+            except SystemExit:
+                logger.info("supervisor interrupted during boot, shutting down")
+                self.restore_default_signal_handlers()
+                self.shutdown()
+                return
+            self.supervise()
+        except BaseException as exception:
+            error = exception
+            raise
+        finally:
+            if started and self.pid == originating_pid:
+                _send_process_signal(
+                    process_stopped, self, context=signal_context, error=error
+                )
 
     def boot(self) -> None:
         super().boot()
@@ -80,12 +104,15 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
             logger.debug("supervisor finally block")
             self.shutdown()
 
-    def start_process(self, process: Configuration.Process) -> None:
+    def start_process(self, process: Configuration.Process) -> int:
         logger.info("starting process %(process)s", {"process": process})
         instance = process.instantiate()
         instance.supervisor = self.process
         instance.mode = "fork"
 
+        # Replacement recovery queries the database after the startup reset.
+        # Clear that connection and pool state before the child inherits it.
+        self.reset_database_connections()
         if (pid := os.fork()) == 0:
             # child
             instance.start()
@@ -95,6 +122,7 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
         self.reset_database_connections()
         self.configured_processes[pid] = process
         self.forks[pid] = instance
+        return pid
 
     def set_procline(self) -> None:
         pass
@@ -130,14 +158,14 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
     def reap_and_replace_terminated_forks(self) -> None:
         while True:
             try:
-                pid, exitcode = os.waitpid(-1, os.WNOHANG)
+                pid, wait_status = os.waitpid(-1, os.WNOHANG)
             except ChildProcessError:
                 break
             else:
                 if not pid:
                     break
 
-            self.replace_fork(pid, exitcode)
+            self.replace_fork(pid, wait_status)
 
     def reap_terminated_forks(self) -> None:
         while True:
@@ -158,11 +186,23 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
 
             self.configured_processes.pop(pid, None)
 
-    def replace_fork(self, pid: int, exitcode: int) -> None:
+    def replace_fork(self, pid: int, wait_status: int) -> None:
+        exitcode = os.waitstatus_to_exitcode(wait_status)
         logger.info("replacing fork %s due to exit code %s", pid, exitcode)
         if terminated_fork := self.forks.pop(pid, None):
-            self.handle_claimed_jobs_by(terminated_fork, exitcode)
-            self.start_process(self.configured_processes.pop(pid))
+            self.handle_claimed_jobs_by(terminated_fork, wait_status)
+            replacement_pid = self.start_process(self.configured_processes.pop(pid))
+            process_restarted.send(
+                sender=ProcessLifecycle,
+                process_kind=terminated_fork.kind,
+                process_name=terminated_fork.name,
+                pid=pid,
+                hostname=terminated_fork.hostname,
+                metadata=terminated_fork.metadata,
+                exitcode=exitcode,
+                replacement_pid=replacement_pid,
+                supervisor_pid=self.pid,
+            )
 
     def handle_claimed_jobs_by(self, terminated_fork: Base, exitcode: int) -> None:
         if not self.process:

steady_queue-0.3.0/steady_queue/signals.py

@@ -0,0 +1,37 @@
+from django.dispatch import Signal
+
+
+class ProcessLifecycle:
+    """Public sender for process lifecycle signals."""
+
+
+class QueueLifecycle:
+    """Public sender for queue lifecycle signals."""
+
+
+# Process lifecycle signals carry stable data suitable for logs and metrics.
+process_started = Signal()
+process_stopped = Signal()
+process_restarted = Signal()
+
+# Queue control signals. Receivers get ``queue_name`` and ``changed``.
+queue_paused = Signal()
+queue_resumed = Signal()
+
+
+def _process_signal_context(process) -> dict:
+    return {
+        "process_kind": process.kind,
+        "process_name": process.name,
+        "pid": process.pid,
+        "hostname": process.hostname,
+        "metadata": process.metadata,
+    }
+
+
+def _send_process_signal(signal: Signal, process, *, context=None, **kwargs) -> None:
+    signal.send(
+        sender=ProcessLifecycle,
+        **(context or _process_signal_context(process)),
+        **kwargs,
+    )

{steady_queue-0.2.0 → steady_queue-0.3.0/steady_queue.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steady-queue
-Version: 0.2.0
+Version: 0.3.0
 Summary: An asynchronous task library for Django that supports delayed tasks, concurrency controls, recurring tasks, pausing queues, numeric priorities per task, priorities by queue order and bulk enqueueing.
 Author-email: Elias Hernandis <elias@hernandis.me>
 License-Expression: MIT
@@ -535,8 +535,17 @@ instance that is handling the task, as well as the `task_result` (a
 `django.tasks.TaskResult` instance) with information on how the task was called
 and its status.
 
-Unlike Solid Queue, steady queue doesn't yet emit signals related to the
-lifecycle of its processes.
+Steady Queue also emits operational signals from ``steady_queue.signals``:
+
+- `process_started` and `process_stopped` when a supervisor or child process
+  enters or leaves its run loop.
+- `process_restarted` when the supervisor replaces a terminated child.
+- `queue_paused` and `queue_resumed` after queue control actions.
+
+Process signals include process identity and metadata. Queue signals include a
+`changed` flag so receivers can distinguish state transitions from idempotent
+actions. See the [configuration documentation](https://steady-queue.readthedocs.io/en/latest/configuration.html#signals)
+for the complete payloads.
 
 ## Logging
 
@@ -824,8 +833,9 @@ there are a few differences which we outline below.
   will ever be supported, but we've kept the database column for compatibility.
 - Steady Queue worker processes do not set the process name (or procline)
   because doing so requires introducing an external dependency.
-- Steady Queue does not expose rich instrumentation like Solid Queue does due to
-  the lack of a framework-native equivalent to `ActiveSupport::Notifications`.
+- Steady Queue exposes Django signals for task and operational lifecycle events,
+  but does not yet provide the full timed instrumentation event set emitted by
+  Solid Queue through `ActiveSupport::Notifications`.
 - **Priority ordering:** Steady Queue follows Django's convention where larger
   numbers indicate higher priority (e.g., a task with priority 10 runs before
   priority 0), whereas Solid Queue uses the inverse (smaller numbers = higher

{steady_queue-0.2.0 → steady_queue-0.3.0}/steady_queue.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ steady_queue/db_router.py
 steady_queue/queue_selector.py
 steady_queue/recurring_schedule.py
 steady_queue/recurring_task.py
+steady_queue/signals.py
 steady_queue/task.py
 steady_queue.egg-info/PKG-INFO
 steady_queue.egg-info/SOURCES.txt
@@ -67,6 +68,7 @@ steady_queue/processes/supervised.py
 steady_queue/processes/supervisor.py
 steady_queue/processes/timer.py
 steady_queue/processes/worker.py
+tests/test_app_executor.py
 tests/test_arguments.py
 tests/test_backend.py
 tests/test_concurrency_controls.py
@@ -75,9 +77,11 @@ tests/test_db_router.py
 tests/test_executions.py
 tests/test_fork_safety.py
 tests/test_job.py
+tests/test_observability_signals.py
 tests/test_pidfile.py
 tests/test_process_lifecycle.py
 tests/test_queue_selector.py
+tests/test_recurring_execution.py
 tests/test_recurring_task.py
 tests/test_semaphore.py
 tests/test_task.py

steady_queue-0.3.0/tests/test_app_executor.py

@@ -0,0 +1,84 @@
+from concurrent.futures import ThreadPoolExecutor
+from unittest import skipUnless
+
+from django.db import connections, transaction
+from django.test import TransactionTestCase
+
+from steady_queue.app_executor import AppExecutor
+from tests.dummy.models import Dummy
+
+
+@skipUnless(
+    connections["default"].vendor == "postgresql",
+    "Requires PostgreSQL application connection pooling",
+)
+class AppExecutorConnectionsTest(TransactionTestCase):
+    databases = {"default", "queue"}
+
+    def setUp(self):
+        self.application = connections["default"]
+        self.application.close()
+        self.application.close_pool()
+        self.original_options = self.application.settings_dict["OPTIONS"]
+        self.application.settings_dict["OPTIONS"] = {
+            **self.original_options,
+            "pool": {"min_size": 0, "max_size": 1, "timeout": 0.25},
+        }
+        self.addCleanup(self.restore_application_pool)
+
+    def restore_application_pool(self):
+        self.application.close()
+        self.application.close_pool()
+        self.application.settings_dict["OPTIONS"] = self.original_options
+
+    @staticmethod
+    def perform_task(*, fail=False):
+        with AppExecutor.wrap_in_app_executor():
+            Dummy.objects.count()
+            if fail:
+                raise ValueError("Task failed")
+        return (
+            connections["default"].connection is None,
+            connections["queue"].connection is None,
+        )
+
+    def assert_pool_reusable_by_another_worker(self, *, fail=False):
+        # Keep both threads alive: ending a thread must not stand in for the
+        # per-task cleanup that long-lived worker threads need.
+        workers = [ThreadPoolExecutor(max_workers=1) for _ in range(2)]
+        try:
+            first = workers[0].submit(self.perform_task, fail=fail)
+            if fail:
+                with self.assertRaisesMessage(ValueError, "Task failed"):
+                    first.result(timeout=5)
+            else:
+                first.result(timeout=5)
+
+            # A leaked application connection leaves this separate thread
+            # unable to borrow the only connection in the application pool.
+            state = workers[1].submit(self.perform_task).result(timeout=5)
+            self.assertEqual(state, (True, True))
+            self.assertEqual(self.application.pool.get_stats()["pool_available"], 1)
+        finally:
+            for worker in workers:
+                worker.submit(connections.close_all).result(timeout=5)
+                worker.shutdown()
+
+    def test_success_returns_application_connection_for_other_workers(self):
+        self.assert_pool_reusable_by_another_worker()
+
+    def test_failure_returns_application_connection_for_other_workers(self):
+        self.assert_pool_reusable_by_another_worker(fail=True)
+
+    def test_main_thread_preserves_callers_connections_and_transaction(self):
+        connections["queue"].ensure_connection()
+        queue_connection = connections["queue"].connection
+        with transaction.atomic():
+            Dummy.objects.count()
+            application_connection = self.application.connection
+            with AppExecutor.wrap_in_app_executor():
+                Dummy.objects.count()
+            self.assertIs(self.application.connection, application_connection)
+            self.assertIs(connections["queue"].connection, queue_connection)
+            self.assertTrue(self.application.in_atomic_block)
+            Dummy.objects.count()

{steady_queue-0.2.0 → steady_queue-0.3.0}/tests/test_executions.py

@@ -1,6 +1,10 @@
+from concurrent.futures import ThreadPoolExecutor
 from datetime import timedelta
+from unittest import skipUnless
+from unittest.mock import patch
 
-from django.test import TestCase
+from django.db import connections
+from django.test import TestCase, TransactionTestCase
 from django.utils import timezone
 
 import steady_queue
@@ -14,6 +18,7 @@ from steady_queue.models import (
     ScheduledExecution,
     Semaphore,
 )
+from steady_queue.models.claimed_execution import ClaimedExecutionQuerySet
 from tests.dummy.tasks import dummy_task, limited_task, limited_task_with_lambda_key
 
 
@@ -106,6 +111,57 @@ class ReadyExecutionTestCase(TestHelperMixin, TestCase):
         self.assertEqual(ReadyExecution.objects.count(), 1)
 
 
+class ConcurrentClaimTestCase(TestHelperMixin, TransactionTestCase):
+    databases = {"default", "queue"}
+
+    @skipUnless(
+        connections["queue"].features.has_select_for_update_skip_locked,
+        "The queue database must support SELECT FOR UPDATE SKIP LOCKED",
+    )
+    def test_higher_priority_arrival_does_not_change_claimed_candidates(self):
+        """#25: keep the selected jobs stable across insertion and retrieval."""
+        process = self.create_test_process()
+        original = self.create_job_in_queue("default", priority=0)
+        bulk_create = ClaimedExecutionQuerySet.bulk_create
+
+        def enqueue_higher_priority_job():
+            try:
+                return self.create_job_in_queue("default", priority=10).pk
+            finally:
+                connections.close_all()
+
+        def insert_claims_then_enqueue(queryset, *args, **kwargs):
+            result = bulk_create(queryset, *args, **kwargs)
+            # Commit an arrival on another connection after claims are inserted,
+            # but before claiming() retrieves them. No sleeps or timing races.
+            with ThreadPoolExecutor(max_workers=1) as executor:
+                arrival = executor.submit(enqueue_higher_priority_job)
+                arrivals.append(arrival.result(timeout=10))
+            return result
+
+        arrivals = []
+        with patch.object(
+            ClaimedExecutionQuerySet, "bulk_create", insert_claims_then_enqueue
+        ):
+            claimed = ReadyExecution.objects.claim(["*"], 1, process.pk)
+
+        self.assertEqual([execution.job_id for execution in claimed], [original.pk])
+        self.assertFalse(
+            ReadyExecution.objects.filter(
+                job_id__in=ClaimedExecution.objects.values("job_id")
+            ).exists()
+        )
+        self.assertEqual(
+            list(ReadyExecution.objects.values_list("job_id", flat=True)), arrivals
+        )
+
+        # Draining the remaining queue must not try to claim the original again.
+        next_claimed = ReadyExecution.objects.claim(["*"], 1, process.pk)
+        self.assertEqual([execution.job_id for execution in next_claimed], arrivals)
+        self.assertEqual(ReadyExecution.objects.claim(["*"], 1, process.pk), [])
+        self.assertEqual(ClaimedExecution.objects.count(), 2)
+
+
 class ClaimedExecutionTestCase(TestHelperMixin, TestCase):
     """Tests for ClaimedExecution behavior."""