Updated docs. (#165)

Author: s3rius

docs/.vuepress/styles/index.scss

@@ -1,18 +1,14 @@
-.toggle-navbar-button {
+.vp-site-name {
     visibility: hidden;
 }
 
-.hero-info-wrapper {
+.vp-hero-info {
     img {
         max-width: 60% !important;
         padding: 1rem;
     }
 }
 
-.actions {
+.vp-actions {
     align-items: flex-end;
 }
-
-span.site-name {
-    visibility: hidden;
-}

docs/guide/architecture-overview.md

@@ -82,9 +82,60 @@ asyncio.run(main())
 
 ```
 
+## Messages
+
+Every message has labels. You can define labels
+using `task` decorator, or you can add them using kicker.
+
+For example:
+
+```python
+
+@broker.task(my_label=1, label2="something")
+async def my_async_task() -> None:
+    """My lovely task."""
+    await asyncio.sleep(1)
+    print("Hello")
+
+async def main():
+    await my_async_task.kiq()
+```
+
+It's equivalent to this
+
+```python
+
+@broker.task
+async def my_async_task() -> None:
+    """My lovely task."""
+    await asyncio.sleep(1)
+    print("Hello")
+
+async def main():
+    await my_async_task.kicker().with_labels(
+        my_label=1,
+        label2="something",
+    ).kiq()
+```
+
+Also you can assign custom task names using decorator.
+This is useful to be sure that task names are unique and resolved correctly.
+Also it may be useful to balance message routing in some brokers.
+
+for example:
+
+```python
+@broker.task(task_name="my_tasks.add_one", label1=1)
+async def my_async_task() -> None:
+    """My lovely task."""
+    await asyncio.sleep(1)
+    print("Hello")
+
+```
+
 ## Result backend
 
-This part is used to store and get results of the execution.
+Result backend is used to store and get results of the execution.
 Results have type `TaskiqResult` from [taskiq.result](https://github.com/taskiq-python/taskiq/blob/master/taskiq/result.py).
 
 Every ResultBackend must implement `AsyncResultBackend` from [taskiq.abc.result_backend](https://github.com/taskiq-python/taskiq/blob/master/taskiq/abc/result_backend.py). By default, brokers use `DummyResultBackend`. It doesn't do anything and cannot be used
@@ -131,6 +182,12 @@ taskiq worker test_project.broker:broker -fsd
 If you have uvloop installed, taskiq will automatically install new policies to event loop.
 You can get more info about the CLI in the [CLI](./cli.md) section.
 
+::: info Cool info
+
+By default we start two processes, if you want to change this value, please take a look at `--help`.
+
+:::
+
 ## Middlewares
 
 Middlewares are used to modify message, or take
@@ -182,88 +239,35 @@ Middlewares can store information in `message.labels` for
 later use. For example `SimpleRetryMiddleware` uses labels
 to remember number of failed attempts.
 
-## Messages
+## Context
 
-Every message has labels. You can define labels
-using `task` decorator, or you can add them using kicker.
+Context is a useful class with some additional functions.
+You can use context to get broker that runs this task, from inside of the task.
 
-For example:
+Or it has ability to control the flow of execution. Here's example of how to get
+the context.
 
 ```python
+from taskiq import Context, TaskiqDepends, ZeroMQBroker
 
-@broker.task(my_label=1, label2="something")
-async def my_async_task() -> None:
-    """My lovely task."""
-    await asyncio.sleep(1)
-    print("Hello")
+broker = ZeroMQBroker()
 
-async def main():
-    await my_async_task.kiq()
-```
-
-It's equivalent to this
-
-```python
 
 @broker.task
-async def my_async_task() -> None:
-    """My lovely task."""
-    await asyncio.sleep(1)
-    print("Hello")
-
-async def main():
-    await my_async_task.kicker().with_labels(
-        my_label=1,
-        label2="something",
-    ).kiq()
+async def my_task(context: Context = TaskiqDepends()):
+    ...
 ```
 
-Also you can assign custom task names using decorator.
-This is useful to be sure that task names are unique and resolved correctly.
-Also it may be useful to balance message routing in some brokers.
-
-for example:
+Also through contexts you can reject or requeue a task. It's easy as this:
 
 ```python
-@broker.task(task_name="my_tasks.add_one", label1=1)
-async def my_async_task() -> None:
-    """My lovely task."""
-    await asyncio.sleep(1)
-    print("Hello")
-
+@broker.task
+async def my_task(context: Context = TaskiqDepends()):
+   await context.requeue()
 ```
 
-## Context
-
-This section is useful for library developers. Who want to get current broker during shared task execution.
-
-For example, you've created shared_task and you want to send message in that task.
-This can be done with context.
-
-Context holds information about the current broker and current incoming message.
-To get it, simply add the context parameter with `type-hint`.
-
-::: danger Cool warning!
-Context injected only if you have a type hint.
-:::
-
-Example:
-
-```python
-from taskiq import async_shared_broker, BrokerMessage, Context
-
-
-@async_shared_broker.task
-async def my_shr_task(context: Context):
-    message = BrokerMessage(
-        task_id="123",
-        task_name="dummy_name",
-        message='{"one": "two"}',
-        labels={},
-    )
-    await context.broker.kick(message)
-
-```
+Calling `requeue` or `reject` stops task execution and either drops the message,
+or puts it back to the queue.
 
-This is useless example, but it's good as a demonstration.
-Pipelines are built using this magic.
+Also, with context you'll be able to get current message that was received by the broker
+or even instance of a broker who received a message. This may be useful for lib developers.

docs/guide/cli.md

@@ -71,6 +71,16 @@ To enable this option simply pass the `--reload` or `-r` option to worker taskiq
 Also this option supports `.gitignore` files. If you have such file in your directory, it won't reload worker
 when you modify ignored files. To disable this functionality pass `--do-not-use-gitignore` option.
 
+### Other parameters
+
+* `--no-configure-logging` - disables default logging configuration for workers.
+* `--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.
+
 ## Scheduler
 
 Scheduler is used to schedule tasks as described in [Scheduling tasks](./scheduling-tasks.md) section.

docs/guide/state-and-deps.md

@@ -165,29 +165,12 @@ If you want to do something asynchronously, convert this function to an asynchro
 
 @[code python](../examples/state/async_generator_deps.py)
 
-### Default dependencies
-
-By default taskiq has only two dependencies:
-
-- Context from `taskiq.context.Context`
-- TaskiqState from `taskiq.state.TaskiqState`
-
-
-### Adding first-level dependencies
-
-You can expand default list of available dependencies for you application.
-Taskiq have an ability to add new first-level dependencies using brokers.
-
-The AsyncBroker interface has a function called `add_dependency_context` and you can add
-more default dependencies to the taskiq. This may be useful for libraries if you want to
-add new dependencies to users.
-
 
-### Exception handling
+#### Exception handling
 
-Dependencies can handle exceptions that happen in tasks. This feature is handy if you want your system to be more atomic.
+Generator dependencies can handle exceptions that happen in tasks. This feature is handy if you want your system to be more atomic.
 
-For example, if you open a database transaction in your dependency and want to commit it only if the function is completed successfully.
+For example, if you open a database transaction in your dependency and want to commit it only if the function you execute is completed successfully.
 
 ```python
 async def get_transaction(db_driver: DBDriver = TaskiqDepends(get_driver)) -> AsyncGenerator[Transaction, None]:
@@ -211,3 +194,20 @@ taskiq worker my_file:broker --no-propagate-errors
 ```
 
 In this case, no exception will ever going to be propagated to any dependency.
+
+### Default dependencies
+
+By default taskiq has only two dependencies:
+
+- Context from `taskiq.context.Context`
+- TaskiqState from `taskiq.state.TaskiqState`
+
+
+### Adding first-level dependencies
+
+You can expand default list of available dependencies for you application.
+Taskiq have an ability to add new first-level dependencies using brokers.
+
+The AsyncBroker interface has a function called `add_dependency_context` and you can add
+more default dependencies to the taskiq. This may be useful for libraries if you want to
+add new dependencies to users.

package.json

@@ -11,10 +11,10 @@
   },
   "packageManager": "pnpm@7.22.0",
   "devDependencies": {
-    "@vuepress/client": "2.0.0-beta.62",
-    "vue": "^3.3.2",
-    "vuepress": "2.0.0-beta.62",
-    "vuepress-plugin-search-pro": "2.0.0-beta.210",
-    "vuepress-theme-hope": "2.0.0-beta.210"
+    "@vuepress/client": "2.0.0-beta.64",
+    "vue": "^3.3.4",
+    "vuepress": "2.0.0-beta.64",
+    "vuepress-plugin-search-pro": "2.0.0-beta.230",
+    "vuepress-theme-hope": "2.0.0-beta.230"
   }
 }