Merge branch 'release/0.11.0'

Author: s3rius

docs/.vuepress/config.ts

@@ -1,6 +1,6 @@
 import { defineUserConfig } from "vuepress";
-import { searchProPlugin } from "vuepress-plugin-search-pro";
 import { hopeTheme } from "vuepress-theme-hope";
+import { viteBundler } from '@vuepress/bundler-vite'
 
 export default defineUserConfig({
   lang: "en-US",
@@ -16,6 +16,8 @@ export default defineUserConfig({
     ],
   ],
 
+  bundler: viteBundler(),
+
   theme: hopeTheme({
     hostname: "https://taskiq-python.github.io",
     logo: "/logo.svg",
@@ -28,7 +30,6 @@ export default defineUserConfig({
     sidebar: "structure",
 
     pure: true,
-    backToTop: false,
 
     plugins: {
       readingTime: false,
@@ -45,8 +46,10 @@ export default defineUserConfig({
         changefreq: "daily",
         sitemapFilename: "sitemap.xml",
       },
+      searchPro: {
+        indexContent: true,
+        autoSuggestions: false,
+      }
     },
-  }),
-
-  plugins: [searchProPlugin({ indexContent: true })],
+  })
 });

docs/available-components/schedule-sources.md

@@ -7,6 +7,23 @@ order: 4
 These objects are used to fetch current schedule for tasks.
 Currently we have only one schedule source.
 
+## RedisScheduleSource
+
+This source is capable of adding new schedules in runtime. It uses Redis as a storage for schedules.
+To use this source you need to install `taskiq-redids` package.
+
+```python
+from taskiq_redis import RedisScheduleSource
+
+from taskiq import TaskiqScheduler
+
+redis_source = RedisScheduleSource("redis://localhost:6379/0")
+scheduler = TaskiqScheduler(broker, sources=[redis_source])
+```
+
+For more information on how to use dynamic schedule sources read [Dynamic scheduling section](../guide/scheduling-tasks.md#dynamic-scheduling).
+
+
 ## LabelScheduleSource
 
 This source parses labels of tasks, and if it finds a `schedule` label, it considers this task as scheduled.

docs/contrib.md

@@ -4,17 +4,6 @@ order: 5
 
 # Contribution guide
 
-We love contributions. This guide is for all folks who want to make taskiq
-better together.
-
-We have several rules for contributors:
-* Please do not add malware.
-* Please make sure that your request solves problem.
-
-If you struggle with something or feel frustrating, you either create an issue, create a discussion on page or publish draft PR and ask your question in description.
-
-We have lots of tests in CI. But since runs from first-time contributors should be approved you better test locally, it just takes less time.
-
 We love contributions. This guide is for all folks who want to make taskiq better together.
 We have several rules for contributors:
 * Please do not add malware.

docs/examples/extending/schedule_source.py

@@ -38,6 +38,9 @@ async def pre_send(self, task: "ScheduledTask") -> None:
         """
         Actions to execute before task will be sent to broker.
 
+        This method may raise ScheduledTaskCancelledError.
+        This cancels the task execution.
+
         :param task: task that will be sent
         """
 

docs/examples/schedule/redis_schedule.py

@@ -0,0 +1,18 @@
+from taskiq_redis import ListQueueBroker, RedisScheduleSource
+
+from taskiq import TaskiqScheduler
+
+# Here's the broker that is going to execute tasks
+broker = ListQueueBroker("redis://localhost:6379/0")
+
+# Here's the source that is used to store scheduled tasks
+redis_source = RedisScheduleSource("redis://localhost:6379/0")
+
+# And here's the scheduler that is used to query scheduled sources
+scheduler = TaskiqScheduler(broker, sources=[redis_source])
+
+
+@broker.task
+async def my_task(arg1: int, arg2: str) -> None:
+    """Example task."""
+    print("Hello from my_task!", arg1, arg2)  # noqa: T201

docs/framework_integrations/faststream.md

@@ -0,0 +1,32 @@
+---
+order: 3
+---
+
+# Taskiq + FastStream
+
+[FastStream](https://faststream.airt.ai/latest/) is a library that allows you to write consumers and producers for different message brokers almost like taskiq. But the differense is that taskiq is more focused on tasks for a specific project and more like celery but async, while FastStream is more focused on events and defining how different systems communicate with each other using distributed brokers.
+
+If you want to declare communication between different projects you can use taskiq, but it might be a bit more complex than using FastStream.
+
+Although these libraries solve different problems, they have integration between each other, so you can use FastStream as a broker for taskiq. It allows FastStream to use taskiq's scheduler along with its own features.
+
+To use FastStream as a broker for taskiq you need to install the `taskiq-faststream` library:
+
+```bash:no-line-numbers
+pip install "taskiq-faststream"
+```
+
+And you can use it like this:
+
+```python
+from faststream import FastStream
+from faststream.kafka import KafkaBroker
+from taskiq_faststream import BrokerWrapper
+
+broker = KafkaBroker("localhost:9092")
+app = FastStream(broker)
+
+taskiq_broker = BrokerWrapper(broker)
+```
+
+You can read more about scheduling tasks for FastStream in the [FastStream documentation](https://faststream.airt.ai/latest/scheduling/?h=schedule).

docs/framework_integrations/taskiq-with-aiogram.md

@@ -0,0 +1,102 @@
+# Taskiq + Aiogram
+
+[Taskiq-Aiogram](https://github.com/taskiq-python/taskiq-aiogram) is a nice integration with one of the best telegram bot libraries - [aiogram](https://docs.aiogram.dev/en/latest/).
+
+This integration allows you to easily send delayed messages or run intensive functions without blocking the message handing.
+
+This integration adds three main dependencies which you can use in your taskiq functions:
+
+- `aiogram.Bot` - the bot instance that you can use to send messages or perform other actions. If multiple bots listen to the same dispatcher, this dependency will be resolved to the latest bot passed in the `taskiq_aiogram.init` function.
+- `aiogram.Dispatcher` - current dispatcher instance.
+- `List[aiogram.Bot]` - list of all bots that were passed to the `taskiq_aiogram.init` function.
+
+To enable the integration, please install the `taskiq-aiogram` library:
+
+```bash:no-line-numbers
+pip install "taskiq-aiogram"
+```
+
+After the installation is complete, add an initialization function call to your broker's main file so it becomes something like this:
+
+```python title="tkq.py"
+import asyncio
+
+import taskiq_aiogram
+from aiogram import Bot
+from taskiq import TaskiqDepends
+from taskiq_redis import ListQueueBroker
+
+broker = ListQueueBroker("redis://localhost")
+
+# This line is going to initialize everything.
+taskiq_aiogram.init(
+    broker,
+    # This is path to the dispatcher.
+    "bot:dp",
+    # This is path to the bot instance.
+    "bot:bot",
+    # You can specify more bots here.
+)
+
+
+@broker.task(task_name="my_task")
+async def my_task(chat_id: int, bot: Bot = TaskiqDepends()) -> None:
+    print("I'm a task")
+    await asyncio.sleep(4)
+    await bot.send_message(chat_id, "task completed")
+
+```
+
+Let's see how to use this integration.
+
+```python title="bot.py"
+import asyncio
+import logging
+import sys
+
+from aiogram import Bot, Dispatcher, types
+from aiogram.filters import Command
+
+from tkq import broker, my_task
+
+dp = Dispatcher()
+bot = Bot(token="TOKEN")
+
+
+# Taskiq calls this function when starting the worker.
+@dp.startup()
+async def setup_taskiq(bot: Bot, *_args, **_kwargs):
+    # Here we check if it's a clien-side,
+    # Becuase otherwise you're going to
+    # create infinite loop of startup events.
+    if not broker.is_worker_process:
+        logging.info("Setting up taskiq")
+        await broker.startup()
+
+
+# Taskiq calls this function when shutting down the worker.
+@dp.shutdown()
+async def shutdown_taskiq(bot: Bot, *_args, **_kwargs):
+    if not broker.is_worker_process:
+        logging.info("Shutting down taskiq")
+        await broker.shutdown()
+
+
+## Simple command to handle
+@dp.message(Command("task"))
+async def message(message: types.Message):
+    await my_task.kiq(message.chat.id)
+
+
+## Main function that starts the bot.
+async def main():
+    await dp.start_polling(bot)
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, stream=sys.stdout)
+    asyncio.run(main())
+
+```
+
+That's it. Now you can easily call tasks from your bots and access bots from within your tasks.

docs/framework_integrations/taskiq-with-aiohttp.md

@@ -6,7 +6,7 @@ order: 2
 
 AioHTTP is a framework for building robust applications. We created several libraries to make the experience with AioHTTP even better.
 
-# Dependency inecjeciton for AioHTTP
+# Dependency injection for AioHTTP
 
 We created a library [aiohttp-deps](https://pypi.org/project/aiohttp-deps/) to add FastAPI-like dependency injection in AioHTTP.
 

docs/guide/architecture-overview.md

@@ -15,7 +15,7 @@ If you use dark theme and cannot see words on diagram,
 try switching to light theme and back to dark.
 :::
 
-```mermaid
+```sequence
 rect rgb(191, 223, 255)
 note right of Your code: Client side.
 Your code ->> Kicker: assemble message

docs/guide/cli.md

@@ -26,7 +26,7 @@ That's why taskiq can auto-discover tasks in current directory recursively.
 We have two options for this:
 
 - `--tasks-pattern` or `-tp`.
-  It's a name of files to import. By default is searches for all `tasks.py` files.
+  It's a glob pattern of files to import. By default it is `**/tasks.py` which searches for all `tasks.py` files. May be specified multiple times.
 - `--fs-discover` or `-fsd`. This option enables search of task files in current directory recursively, using the given pattern.
 
 ### Acknowledgements
@@ -87,13 +87,15 @@ when you modify ignored files. To disable this functionality pass `--do-not-use-
 ### Other parameters
 
 * `--no-configure-logging` - disables default logging configuration for workers.
+- `--log-level` is used to set a log level (default `INFO`).
 * `--max-async-tasks` - maximum number of simultaneously running async tasks.
 * `--max-prefetch` - number of tasks to be prefetched before execution. (Useful for systems with high message rates, but brokers should support acknowledgements).
 * `--max-threadpool-threads` - number of threads for sync function exection.
 * `--no-propagate-errors` - if this parameter is enabled, exceptions won't be thrown in generator dependencies.
 * `--receiver` - python path to custom receiver class.
 * `--receiver_arg` - custom args for receiver.
 * `--ack-type` - Type of acknowledgement. This parameter is used to set when to acknowledge the task. Possible values are `when_received`, `when_executed`, `when_saved`. Default is `when_saved`.
+- `--shutdown-timeout` - maximum amount of time for graceful broker's shutdown in seconds.
 
 ## Scheduler
 
@@ -116,6 +118,8 @@ taskiq scheduler my_project.broker:scheduler my_project.module1 my_project.modul
 Path to scheduler is the only required argument.
 
 - `--tasks-pattern` or `-tp`.
-  It's a name of files to import. By default is searches for all `tasks.py` files.
+  It's a glob pattern of files to import. By default it is `**/tasks.py` which searches for all `tasks.py` files. May be specified multiple times.
 - `--fs-discover` or `-fsd`. This option enables search of task files in current directory recursively, using the given pattern.
-- `--log-level` is used to set a log level.
+- `--no-configure-logging` - use this parameter if your application configures custom logging.
+- `--log-level` is used to set a log level (default `INFO`).
+- `--skip-first-run` - skip first run of scheduler. This option skips running tasks immediately after scheduler start.