unfazed-taskiq 0.0.1__tar.gz

unfazed_taskiq-0.0.1/.env

@@ -0,0 +1 @@
+COMPOSE_PROJECT_NAME=unfazed_taskiq

unfazed_taskiq-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,18 @@
+name: Publish to PyPI
+on:
+  push:
+    tags:
+      - "v[0-9]+.[0-9]+.[0-9]+"  # 更精确的版本号匹配
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Build and publish to pypi
+        uses: astral-sh/setup-uv@v5
+      - run: |
+          uv build
+          uv publish
+        env:
+          UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}

unfazed_taskiq-0.0.1/.github/workflows/test.yml

@@ -0,0 +1,46 @@
+name: Test Unfazed Taskiq
+
+on:
+  push:
+    branches: ["main"]
+  pull_request:
+    branches: ["main"]
+
+jobs:
+  tests:
+    services:
+      rabbitmq:
+        image: rabbitmq:3-management-alpine
+        env:
+          RABBITMQ_DEFAULT_USER: guest
+          RABBITMQ_DEFAULT_PASS: guest
+        ports: ['5672:5672', '15672:15672']
+      redis:
+        image: redis
+        ports: ['6379:6379']
+    name: "Python ${{ matrix.python-version }}"
+    runs-on: "ubuntu-latest"
+
+    strategy:
+      matrix:
+        python-version: ["3.12"]
+
+    steps:
+      - uses: "actions/checkout@v4"
+      - uses: "actions/setup-python@v5"
+        with:
+          python-version: "${{ matrix.python-version }}"
+          allow-prereleases: true
+      - name: "Install dependencies"
+        run: |
+          pip install uv
+          uv sync
+      - name: "Run format"
+        run: make format
+      - name: "Run Test"
+        run: make test
+        env:
+          UNFAZED_SETTINGS_MODULE: "tests.proj.entry.settings"
+          REDIS_HOST: "localhost"
+          RABBITMQ_HOST: "localhost"
+

unfazed_taskiq-0.0.1/.gitignore

@@ -0,0 +1,12 @@
+__pycache__
+.pytest_cache
+.DS_Store
+.ruff_cache
+.coverage
+.venv
+migrations
+.VSCodeCounter
+dist
+.mypy_cache
+.vscode
+site

unfazed_taskiq-0.0.1/Dockerfile

@@ -0,0 +1,9 @@
+FROM python:3.12.3-bullseye
+
+
+COPY . /unfazed_taskiq
+WORKDIR /unfazed_taskiq
+
+RUN pip3 install uv
+ENV UV_PROJECT_ENVIRONMENT="/usr/local"
+RUN uv sync

unfazed_taskiq-0.0.1/Makefile

@@ -0,0 +1,16 @@
+all: test
+
+test:
+	@echo "Running tests..."
+	uv run pytest -v -s --cov ./unfazed_taskiq --cov-report term-missing
+
+format:
+	@echo "Formatting code..."
+	uv run ruff format tests/ unfazed_taskiq/
+	uv run ruff check tests/ unfazed_taskiq/  --fix
+	uv run mypy --check-untyped-defs --explicit-package-bases --ignore-missing-imports tests/ unfazed_taskiq/
+
+publish:
+	@echo "Publishing package..."
+	uv build
+	uv publish

unfazed_taskiq-0.0.1/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: unfazed-taskiq
+Version: 0.0.1
+Summary: Taskiq Plugin for Unfazed
+Requires-Python: >=3.12
+Requires-Dist: taskiq-aio-pika>=0.4.2
+Requires-Dist: taskiq>=0.11.16
+Requires-Dist: unfazed>=0.0.8
+Description-Content-Type: text/markdown
+
+Unfazed Taskiq
+===============
+
+taskiq wrapper with unfazed.
+
+
+Installation
+------------
+
+```bash
+pip install unfazed-taskiq
+```
+
+
+Quick Start
+-----
+
+Add settings to your unfazed settings file:
+
+```python
+# entry/settings.py
+UNFAZED_TASKIQ_SETTINGS = {
+    "BROKER": {
+        "BACKEND": "taskiq.InMemoryBroker",
+        "OPTIONS": {},
+    },
+    "RESULT": {
+        "BACKEND": "taskiq_redis.RedisAsyncResultBackend",
+        "OPTIONS": {
+            "redis_url": "redis://redis:6379",
+        },
+    },
+    "SCHEDULER": {
+        "BACKEND": "taskiq.scheduler.scheduler.TaskiqScheduler",
+        "SOURCES_CLS": ["taskiq.schedule_sources.LabelScheduleSource"],
+    },
+}
+
+# add lifespan to your settings
+UNFAZED_SETTINGS = {
+    "LIFESPAN": ["unfazed_taskiq.lifespan.TaskiqLifeSpan"],
+}
+
+```
+
+Use UnfazedTaskiqAgent in your app's `tasks.py`:
+
+```python
+# app/tasks.py
+from unfazed_taskiq import agent
+
+@agent.broker.task
+async def add(a: int, b: int) -> int:
+    return a + b
+
+
+@agent.broker.task(schedule=[{"crontab": "*/1 * * * *", "args": [1, 2]}])
+async def add_schedule(a: int, b: int) -> int:
+    return a + b
+
+```
+
+
+Kick off tasks 
+
+```python
+
+from .tasks import add
+
+async def your_service():
+    await add.kiq(1, 2)
+
+```
+
+
+Start Taskiq Worker or Scheduler
+
+```bash
+taskiq worker unfazed_taskiq.cli:broker
+
+# or
+taskiq scheduler unfazed_taskiq.cli:scheduler
+```
+
+

unfazed_taskiq-0.0.1/README.md

@@ -0,0 +1,85 @@
+Unfazed Taskiq
+===============
+
+taskiq wrapper with unfazed.
+
+
+Installation
+------------
+
+```bash
+pip install unfazed-taskiq
+```
+
+
+Quick Start
+-----
+
+Add settings to your unfazed settings file:
+
+```python
+# entry/settings.py
+UNFAZED_TASKIQ_SETTINGS = {
+    "BROKER": {
+        "BACKEND": "taskiq.InMemoryBroker",
+        "OPTIONS": {},
+    },
+    "RESULT": {
+        "BACKEND": "taskiq_redis.RedisAsyncResultBackend",
+        "OPTIONS": {
+            "redis_url": "redis://redis:6379",
+        },
+    },
+    "SCHEDULER": {
+        "BACKEND": "taskiq.scheduler.scheduler.TaskiqScheduler",
+        "SOURCES_CLS": ["taskiq.schedule_sources.LabelScheduleSource"],
+    },
+}
+
+# add lifespan to your settings
+UNFAZED_SETTINGS = {
+    "LIFESPAN": ["unfazed_taskiq.lifespan.TaskiqLifeSpan"],
+}
+
+```
+
+Use UnfazedTaskiqAgent in your app's `tasks.py`:
+
+```python
+# app/tasks.py
+from unfazed_taskiq import agent
+
+@agent.broker.task
+async def add(a: int, b: int) -> int:
+    return a + b
+
+
+@agent.broker.task(schedule=[{"crontab": "*/1 * * * *", "args": [1, 2]}])
+async def add_schedule(a: int, b: int) -> int:
+    return a + b
+
+```
+
+
+Kick off tasks 
+
+```python
+
+from .tasks import add
+
+async def your_service():
+    await add.kiq(1, 2)
+
+```
+
+
+Start Taskiq Worker or Scheduler
+
+```bash
+taskiq worker unfazed_taskiq.cli:broker
+
+# or
+taskiq scheduler unfazed_taskiq.cli:scheduler
+```
+
+

unfazed_taskiq-0.0.1/docker-compose.yml

@@ -0,0 +1,25 @@
+services:
+  rabbitmq:
+    image: rabbitmq:3-management-alpine
+    environment:
+      - RABBITMQ_DEFAULT_USER=guest
+      - RABBITMQ_DEFAULT_PASS=guest
+    ports:
+      - 5672:5672
+      - 15672:15672
+  redis:
+    image: redis:latest
+    ports:
+      - 6379:6379
+  app:
+    build: .
+    ports:
+      - "127.0.0.1:9927:9927"
+    depends_on:
+      - rabbitmq
+      - redis
+    command: tail -f /unfazed_taskiq/README.md
+    environment:
+      - UNFAZED_SETTINGS_MODULE=tests.proj.entry.settings
+    volumes:
+      - .:/unfazed_taskiq

unfazed_taskiq-0.0.1/pyproject.toml

@@ -0,0 +1,80 @@
+[project]
+name = "unfazed-taskiq"
+version = "0.0.1"
+description = "Taskiq Plugin for Unfazed"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "taskiq>=0.11.16",
+    "taskiq-aio-pika>=0.4.2",
+    "unfazed>=0.0.8",
+]
+
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["unfazed_taskiq"]
+
+
+[dependency-groups]
+dev = [
+    "mypy>=1.15.0",
+    "pytest>=8.3.4",
+    "pytest-asyncio>=0.25.0",
+    "pytest-cov>=6.0.0",
+    "ruff>=0.8.4",
+    "taskiq-redis>=1.0.7",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "session"
+testpaths = [
+    "tests"
+]
+
+[tool.ruff.lint]
+ignore = [
+    "B006",
+    "B007",
+    "B009",
+    "B010",
+    "B026",
+    "B904",
+    "B905",
+    "C408",
+    "C901",
+    "E501",
+    "E714",
+]
+select = ["B", "C", "E", "F", "W", "I"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+docstring-code-format = false
+docstring-code-line-length = "dynamic"
+
+[tool.mypy]
+python_version = "3.12"
+pretty = true
+ignore_missing_imports = true
+check_untyped_defs = true
+disallow_untyped_calls = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = false
+disallow_untyped_decorators = false
+warn_redundant_casts = true
+warn_unused_ignores = false
+warn_return_any = false
+warn_no_return = false
+warn_unreachable = false
+warn_unused_configs = true
+allow_redefinition = true
+strict_equality = true
+show_error_context = true

unfazed_taskiq-0.0.1/tests/conftest.py

@@ -0,0 +1,13 @@
+import typing as t
+
+import pytest
+from pytest import Item
+from pytest_asyncio import is_async_test
+
+
+# dont need decorate test functions with pytest.mark.asyncio
+def pytest_collection_modifyitems(items: t.List[Item]) -> None:
+    pytest_asyncio_tests = (item for item in items if is_async_test(item))
+    session_scope_marker = pytest.mark.asyncio(loop_scope="session")
+    for async_test in pytest_asyncio_tests:
+        async_test.add_marker(session_scope_marker, append=False)

unfazed_taskiq-0.0.1/tests/proj/app1/app.py

@@ -0,0 +1,6 @@
+from unfazed.app import BaseAppConfig
+
+
+class AppConfig(BaseAppConfig):
+    async def ready(self) -> None:
+        pass

unfazed_taskiq-0.0.1/tests/proj/app1/endpoints.py

@@ -0,0 +1,11 @@
+from unfazed.http import HttpRequest, JsonResponse
+
+from .tasks import add
+
+
+async def add_endpoint(request: HttpRequest, a: int, b: int) -> JsonResponse:
+    task = await add.kiq(a, b)
+
+    result = await task.wait_result(timeout=10)
+
+    return JsonResponse({"result": result.return_value})

unfazed_taskiq-0.0.1/tests/proj/app1/routes.py

@@ -0,0 +1,7 @@
+import typing as t
+
+from unfazed.route import Route, path
+
+from .endpoints import add_endpoint
+
+patterns: t.List[Route] = [path("/add", endpoint=add_endpoint)]

unfazed_taskiq-0.0.1/tests/proj/app1/tasks.py

@@ -0,0 +1,11 @@
+from unfazed_taskiq import agent
+
+
+@agent.broker.task
+async def add(a: int, b: int) -> int:
+    return a + b
+
+
+@agent.broker.task(schedule=[{"crontab": "*/1 * * * *", "args": [1, 2]}])
+async def add_schedule(a: int, b: int) -> int:
+    return a + b

unfazed_taskiq-0.0.1/tests/proj/entry/routes.py

@@ -0,0 +1,5 @@
+from unfazed.route import include, path
+
+patterns = [
+    path("/app1", routes=include("app1.routes")),
+]

unfazed_taskiq-0.0.1/tests/proj/entry/settings.py

@@ -0,0 +1,27 @@
+import os
+
+REDIS_HOST = os.getenv("REDIS_HOST", "redis")
+
+UNFAZED_SETTINGS = {
+    "LIFESPAN": ["unfazed_taskiq.lifespan.TaskiqLifeSpan"],
+    "ROOT_URLCONF": "entry.routes",
+    "INSTALLED_APPS": ["app1"],
+}
+
+
+UNFAZED_TASKIQ_SETTINGS = {
+    "BROKER": {
+        "BACKEND": "taskiq.InMemoryBroker",
+        "OPTIONS": {},
+    },
+    "RESULT": {
+        "BACKEND": "taskiq_redis.RedisAsyncResultBackend",
+        "OPTIONS": {
+            "redis_url": f"redis://{REDIS_HOST}:6379",
+        },
+    },
+    "SCHEDULER": {
+        "BACKEND": "taskiq.scheduler.scheduler.TaskiqScheduler",
+        "SOURCES_CLS": ["taskiq.schedule_sources.LabelScheduleSource"],
+    },
+}

unfazed_taskiq-0.0.1/tests/proj/entry2/routes.py

@@ -0,0 +1,5 @@
+import typing as t
+
+from unfazed.route import Route
+
+patterns: t.List[Route] = []

unfazed_taskiq-0.0.1/tests/proj/entry2/settings.py

@@ -0,0 +1,18 @@
+UNFAZED_SETTINGS = {
+    "LIFESPAN": ["unfazed_taskiq.lifespan.TaskiqLifeSpan"],
+    "ROOT_URLCONF": "entry.routes",
+}
+
+
+UNFAZED_TASKIQ_SETTINGS = {
+    "BROKER": {
+        "BACKEND": "taskiq.InMemoryBroker",
+        "OPTIONS": {},
+    },
+    "RESULT": {
+        "BACKEND": "taskiq_redis.RedisAsyncResultBackend",
+        "OPTIONS": {
+            "redis_url": "redis://redis:6379",
+        },
+    },
+}

unfazed_taskiq-0.0.1/tests/proj/manage.py

@@ -0,0 +1,33 @@
+import asyncio
+import os
+import sys
+import traceback
+import warnings
+
+
+async def main() -> None:
+    root_path = os.path.dirname(os.path.abspath(__file__))
+    sys.path.append(root_path)
+    os.environ.setdefault("UNFAZED_SETTINGS_MODULE", "entry.settings")
+    try:
+        from unfazed.core import Unfazed
+    except ImportError:
+        warnings.warn(
+            "Could not import unfazed. Did you forget to install it?", stacklevel=2
+        )
+        sys.exit(1)
+
+    try:
+        unfazed = Unfazed()
+        await unfazed.setup()
+
+    except Exception as e:
+        print(traceback.format_exc())
+        warnings.warn(f"An error occurred when init unfazed: {e}", stacklevel=2)
+        sys.exit(1)
+
+    await unfazed.execute_command_from_argv()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

unfazed_taskiq-0.0.1/tests/test_taskiq/test_api.py

@@ -0,0 +1,29 @@
+import os
+import sys
+import typing as t
+
+import pytest
+from unfazed.core import Unfazed
+from unfazed.test import Requestfactory
+
+
+@pytest.fixture
+async def unfazed() -> t.AsyncGenerator[Unfazed, None]:
+    os.environ["UNFAZED_SETTINGS_MODULE"] = "tests.proj.entry.settings"
+
+    path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "../proj")
+
+    sys.path.append(path)
+
+    unfazed = Unfazed()
+    await unfazed.setup()
+
+    yield unfazed
+
+
+async def test_api(unfazed: Unfazed) -> None:
+    async with Requestfactory(unfazed) as rf:
+        resp = await rf.get("/app1/add?a=1&b=2")
+
+        assert resp.status_code == 200
+        assert resp.json() == {"result": 3}

unfazed_taskiq-0.0.1/tests/test_taskiq/test_base.py

@@ -0,0 +1,42 @@
+import os
+
+from taskiq import InMemoryBroker
+from taskiq.scheduler.scheduler import TaskiqScheduler
+from taskiq_redis import RedisAsyncResultBackend
+
+from unfazed_taskiq import TaskiqAgent
+from unfazed_taskiq.settings import UnfazedTaskiqSettings
+
+REDIS_HOST = os.getenv("REDIS_HOST", "redis")
+
+TEMP_SETTINGS = {
+    "BROKER": {
+        "BACKEND": "taskiq.InMemoryBroker",
+        "OPTIONS": {},
+    },
+    "RESULT": {
+        "BACKEND": "taskiq_redis.RedisAsyncResultBackend",
+        "OPTIONS": {
+            "redis_url": f"redis://{REDIS_HOST}:6379",
+        },
+    },
+    "SCHEDULER": {
+        "BACKEND": "taskiq.scheduler.scheduler.TaskiqScheduler",
+        "SOURCES_CLS": ["taskiq.schedule_sources.LabelScheduleSource"],
+    },
+}
+
+
+async def test_agent() -> None:
+    agent = TaskiqAgent()
+
+    settings = UnfazedTaskiqSettings.model_validate(TEMP_SETTINGS)
+    agent.setup(settings)
+
+    assert isinstance(agent.broker, InMemoryBroker)
+    assert isinstance(agent.broker.result_backend, RedisAsyncResultBackend)
+    assert isinstance(agent.scheduler, TaskiqScheduler)
+
+    await agent.startup()
+
+    await agent.shutdown()

unfazed_taskiq-0.0.1/tests/test_taskiq/test_cli.py

@@ -0,0 +1,51 @@
+import os
+import typing as t
+
+import pytest
+from taskiq import InMemoryBroker
+from taskiq.scheduler.scheduler import TaskiqScheduler
+from taskiq_redis import RedisAsyncResultBackend
+
+from unfazed_taskiq.cli import get_agent
+
+
+@pytest.fixture
+def setup_cli() -> t.Generator[None, None, None]:
+    os.environ["UNFAZED_SETTINGS_MODULE"] = "tests.proj.entry.settings"
+
+    yield
+
+    del os.environ["UNFAZED_SETTINGS_MODULE"]
+
+
+@pytest.fixture
+def setup_cli2() -> t.Generator[None, None, None]:
+    os.environ["UNFAZED_SETTINGS_MODULE"] = "tests.proj.entry2.settings"
+
+    yield
+
+    del os.environ["UNFAZED_SETTINGS_MODULE"]
+
+
+def test_cli(setup_cli: t.Generator[None, None, None]) -> None:
+    agent = get_agent()
+
+    assert isinstance(agent.broker, InMemoryBroker)
+    assert isinstance(agent.broker.result_backend, RedisAsyncResultBackend)
+    assert isinstance(agent.scheduler, TaskiqScheduler)
+
+
+def test_cli_without_env() -> None:
+    if "UNFAZED_SETTINGS_MODULE" in os.environ:
+        del os.environ["UNFAZED_SETTINGS_MODULE"]
+
+    with pytest.raises(ValueError):
+        get_agent()
+
+
+def test_cli_without_scheduler(setup_cli2: t.Generator[None, None, None]) -> None:
+    agent = get_agent()
+
+    assert isinstance(agent.broker, InMemoryBroker)
+    assert isinstance(agent.broker.result_backend, RedisAsyncResultBackend)
+    assert agent.scheduler is None

unfazed_taskiq-0.0.1/unfazed_taskiq/__init__.py

@@ -0,0 +1,4 @@
+from .base import TaskiqAgent, agent
+from .settings import UnfazedTaskiqSettings
+
+__all__ = ["agent", "TaskiqAgent", "UnfazedTaskiqSettings"]