linglong-web 0.0.1__tar.gz

linglong_web-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Victor Lai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

linglong_web-0.0.1/MANIFEST.in

@@ -0,0 +1,14 @@
+global-exclude __pycache__ *.py[cod] *.pyo *.pyd .DS_Store
+prune .pytest_cache
+prune .mypy_cache
+prune .ruff_cache
+prune .venv
+prune build
+prune dist
+exclude .coverage
+exclude coverage.xml
+include README.md
+include LICENSE
+include pyproject.toml
+recursive-include linglong_web *.py
+recursive-include linglong_web *.typed

linglong_web-0.0.1/PKG-INFO

@@ -0,0 +1,249 @@
+Metadata-Version: 2.4
+Name: linglong-web
+Version: 0.0.1
+Summary: Asynchronous FastAPI toolkit with service bootstrap, resource orchestration, and observability utilities
+Author-email: Victor Lai <victor.lai@foxmail.com>
+Maintainer-email: Victor Lai <victor.lai@foxmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/10000ms/linglong_web
+Project-URL: Repository, https://github.com/10000ms/linglong_web
+Project-URL: Documentation, https://github.com/10000ms/linglong_web/tree/master/docs
+Project-URL: Bug Tracker, https://github.com/10000ms/linglong_web/issues
+Keywords: fastapi,asyncio,microservices,service-registry,resource-manager,scheduler,http-client
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Framework :: FastAPI
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi<1.0.0,>=0.115.0
+Requires-Dist: uvicorn[standard]<1.0.0,>=0.30.0
+Requires-Dist: aiohttp<4.0.0,>=3.9.0
+Requires-Dist: aioclock<1.0.0,>=0.3.0
+Requires-Dist: limits<7.0.0,>=3.0.0
+Requires-Dist: redis<9.0.0,>=5.0.0
+Requires-Dist: orjson<4.0.0,>=3.9.0
+Requires-Dist: pydantic<3.0.0,>=2.0.0
+Requires-Dist: nanoid<4.0.0,>=2.0.0
+Requires-Dist: yarl<2.0.0,>=1.9.0
+Provides-Extra: postgres
+Requires-Dist: asyncpg<1.0.0,>=0.29.0; extra == "postgres"
+Requires-Dist: sqlalchemy[asyncio]<3.0.0,>=2.0.0; extra == "postgres"
+Provides-Extra: mongo
+Requires-Dist: pymongo<5.0.0,>=4.9.0; extra == "mongo"
+Provides-Extra: rabbitmq
+Requires-Dist: aio-pika<10.0.0,>=9.4.0; extra == "rabbitmq"
+Provides-Extra: celery
+Requires-Dist: celery<6.0.0,>=5.3.0; extra == "celery"
+Provides-Extra: speedups
+Requires-Dist: redis[hiredis]<9.0.0,>=5.0.0; extra == "speedups"
+Provides-Extra: all
+Requires-Dist: asyncpg<1.0.0,>=0.29.0; extra == "all"
+Requires-Dist: sqlalchemy[asyncio]<3.0.0,>=2.0.0; extra == "all"
+Requires-Dist: pymongo<5.0.0,>=4.9.0; extra == "all"
+Requires-Dist: aio-pika<10.0.0,>=9.4.0; extra == "all"
+Requires-Dist: celery<6.0.0,>=5.3.0; extra == "all"
+Requires-Dist: redis[hiredis]<9.0.0,>=5.0.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-mock>=3.12.0; extra == "dev"
+Requires-Dist: aiosqlite>=0.19.0; extra == "dev"
+Requires-Dist: black>=24.0.0; extra == "dev"
+Requires-Dist: isort>=5.13.0; extra == "dev"
+Requires-Dist: mypy>=1.8.0; extra == "dev"
+Requires-Dist: pre-commit>=3.6.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.5.0; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.24.0; extra == "docs"
+Dynamic: license-file
+
+# Linglong Web
+
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+Linglong Web is a FastAPI toolkit for microservice scenarios, focusing on "simple startup, flexible extension, and complete observability".
+
+中文文档：see [README.zh-CN.md](README.zh-CN.md)
+
+## Links
+
+- GitHub: https://github.com/10000ms/linglong_web
+- Issues: https://github.com/10000ms/linglong_web/issues
+- Changelog: https://github.com/10000ms/linglong_web/blob/master/CHANGELOG.md
+
+## Why this library
+
+When building microservices with FastAPI, you often need:
+
+- **Service lifecycle management** - startup, shutdown, health checks, graceful termination
+- **Resource orchestration** - database connections, cache, message queues, schedulers
+- **Observability** - request-id propagation, structured logging, rate limiting
+- **Extensibility** - plugin hooks for service registration, remote config, etc.
+
+Linglong Web provides all these out of the box as modular components.
+
+## Features
+
+- **AppServer lifecycle** - Built-in middleware, error handling, health checks, and signal handling
+- **Extension hooks** - `on_config_ready`, `on_app_created`, `on_startup`, `on_shutdown` for custom logic injection
+- **Thread-safe config** - `LinglongConfig` with hot reload support
+- **Resource management** - Unified initialization for PostgreSQL, Redis, MongoDB, RabbitMQ, Celery
+- **HTTP client** - aiohttp wrapper with request-id propagation and unified error handling
+- **Decorators** - Redis cache, rate limit, and distributed lock decorators
+- **Scheduler** - aioclock integration for periodic tasks
+- **Bilingual comments** - Chinese and English comments throughout the codebase
+
+## Installation
+
+```bash
+# Core: FastAPI bootstrapper + HTTP client + scheduler + Redis-backed decorators
+pip install linglong-web
+
+# Add resource backends on demand
+pip install "linglong-web[postgres]"   # PostgreSQL (asyncpg + SQLAlchemy)
+pip install "linglong-web[mongo]"      # MongoDB (PyMongo async)
+pip install "linglong-web[rabbitmq]"   # RabbitMQ (aio-pika)
+pip install "linglong-web[celery]"     # Celery
+pip install "linglong-web[all]"        # everything
+```
+
+`import linglong_web` always works with just the core install; a backend you
+haven't installed only raises a clear error if you actually initialize it.
+
+## Quick Start
+
+```python
+import asyncio
+
+from linglong_web import LinglongConfigBase, init_config
+from linglong_web import build_success_response
+from linglong_web import BaseRoute, ServerRouter
+from linglong_web import LinglongAppServer
+
+
+class DevConfig(LinglongConfigBase):
+    """Development configuration"""
+    DEBUG = True
+    SERVICE_NAME = "demo-service"
+
+
+router = ServerRouter()
+router.initialize([
+    BaseRoute(
+        path="/ping",
+        method="GET",
+        handler=lambda: build_success_response({"pong": True}),
+    )
+])
+
+init_config({"dev": DevConfig}, mode_name="dev")
+
+
+async def main():
+    app_server = LinglongAppServer()
+    await app_server.initialize(
+        service_name="demo-service",
+        router=router.get_router(),
+        config_dict={"dev": DevConfig},
+    )
+    await app_server.start(host="0.0.0.0", port=8080)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Module Overview
+
+| Module | Description |
+| --- | --- |
+| `server` | FastAPI bootstrapper with middlewares & extension hooks |
+| `server_extensions` | Lifecycle extension protocol for custom capabilities |
+| `config` | Thread-safe config proxy with hot reload |
+| `resource` | Unified resource bootstrapper (DB, Cache, MQ, Scheduler) |
+| `http` | aiohttp client with request-id injection |
+| `cacher` | Redis cache decorator |
+| `limiter` | Rate limit decorator |
+| `cluster_lock` | Distributed lock decorator |
+| `scheduler` | aioclock helpers for periodic tasks |
+| `utils` | Context, logging, signal handling, time utilities |
+
+## Extension Example
+
+```python
+from linglong_web.server_extensions import BaseServerExtension
+
+
+class RegistryExtension(BaseServerExtension):
+    """Example: custom service registration logic"""
+
+    def __init__(self, client):
+        self._client = client
+
+    async def on_startup(self, server):
+        payload = {"service": server.service_name, "instance": server.instance_id}
+        await self._client.register(payload)
+        server.register_shutdown_callback(lambda: self._client.deregister(payload))
+
+
+extensions = [RegistryExtension(client)]
+await app_server.initialize(
+    service_name="demo",
+    router=router.get_router(),
+    config_dict={"dev": DevConfig},
+    extensions=extensions,
+)
+```
+
+> Linglong no longer bundles service registration or remote config capabilities. Implement them in your business repository using extension hooks.
+
+## Testing & Coverage
+
+```bash
+# Run tests with coverage
+pytest tests/ -v --cov=linglong_web --cov-report=term-missing
+
+# Or with PYTHONPATH
+PYTHONPATH=. pytest tests/ -v --cov=linglong_web --cov-report=term-missing
+```
+
+- All new modules should maintain **80%+** test coverage.
+- Use `pytest-asyncio` and `pytest-mock` for fine-grained mocking of resources, rate limiters, and signal handlers.
+
+## Project Layout
+
+```
+linglong_web/
+├── linglong_web/
+│   ├── core/               # Core modules
+│   │   ├── server.py       # FastAPI bootstrapper
+│   │   ├── config.py       # Config proxy
+│   │   ├── resource.py     # Resource manager
+│   │   ├── http.py         # HTTP client
+│   │   ├── cacher.py       # Cache decorator
+│   │   ├── limiter.py      # Rate limit decorator
+│   │   └── ...
+│   └── utils/              # Utilities
+├── tests/                  # Test suite
+└── docs/                   # Documentation
+```
+
+## Versioning
+
+The package version is sourced from `linglong_web/__version__.py`.
+
+## License
+
+MIT License. See LICENSE.

linglong_web-0.0.1/README.md

@@ -0,0 +1,180 @@
+# Linglong Web
+
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+[![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+Linglong Web is a FastAPI toolkit for microservice scenarios, focusing on "simple startup, flexible extension, and complete observability".
+
+中文文档：see [README.zh-CN.md](README.zh-CN.md)
+
+## Links
+
+- GitHub: https://github.com/10000ms/linglong_web
+- Issues: https://github.com/10000ms/linglong_web/issues
+- Changelog: https://github.com/10000ms/linglong_web/blob/master/CHANGELOG.md
+
+## Why this library
+
+When building microservices with FastAPI, you often need:
+
+- **Service lifecycle management** - startup, shutdown, health checks, graceful termination
+- **Resource orchestration** - database connections, cache, message queues, schedulers
+- **Observability** - request-id propagation, structured logging, rate limiting
+- **Extensibility** - plugin hooks for service registration, remote config, etc.
+
+Linglong Web provides all these out of the box as modular components.
+
+## Features
+
+- **AppServer lifecycle** - Built-in middleware, error handling, health checks, and signal handling
+- **Extension hooks** - `on_config_ready`, `on_app_created`, `on_startup`, `on_shutdown` for custom logic injection
+- **Thread-safe config** - `LinglongConfig` with hot reload support
+- **Resource management** - Unified initialization for PostgreSQL, Redis, MongoDB, RabbitMQ, Celery
+- **HTTP client** - aiohttp wrapper with request-id propagation and unified error handling
+- **Decorators** - Redis cache, rate limit, and distributed lock decorators
+- **Scheduler** - aioclock integration for periodic tasks
+- **Bilingual comments** - Chinese and English comments throughout the codebase
+
+## Installation
+
+```bash
+# Core: FastAPI bootstrapper + HTTP client + scheduler + Redis-backed decorators
+pip install linglong-web
+
+# Add resource backends on demand
+pip install "linglong-web[postgres]"   # PostgreSQL (asyncpg + SQLAlchemy)
+pip install "linglong-web[mongo]"      # MongoDB (PyMongo async)
+pip install "linglong-web[rabbitmq]"   # RabbitMQ (aio-pika)
+pip install "linglong-web[celery]"     # Celery
+pip install "linglong-web[all]"        # everything
+```
+
+`import linglong_web` always works with just the core install; a backend you
+haven't installed only raises a clear error if you actually initialize it.
+
+## Quick Start
+
+```python
+import asyncio
+
+from linglong_web import LinglongConfigBase, init_config
+from linglong_web import build_success_response
+from linglong_web import BaseRoute, ServerRouter
+from linglong_web import LinglongAppServer
+
+
+class DevConfig(LinglongConfigBase):
+    """Development configuration"""
+    DEBUG = True
+    SERVICE_NAME = "demo-service"
+
+
+router = ServerRouter()
+router.initialize([
+    BaseRoute(
+        path="/ping",
+        method="GET",
+        handler=lambda: build_success_response({"pong": True}),
+    )
+])
+
+init_config({"dev": DevConfig}, mode_name="dev")
+
+
+async def main():
+    app_server = LinglongAppServer()
+    await app_server.initialize(
+        service_name="demo-service",
+        router=router.get_router(),
+        config_dict={"dev": DevConfig},
+    )
+    await app_server.start(host="0.0.0.0", port=8080)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```
+
+## Module Overview
+
+| Module | Description |
+| --- | --- |
+| `server` | FastAPI bootstrapper with middlewares & extension hooks |
+| `server_extensions` | Lifecycle extension protocol for custom capabilities |
+| `config` | Thread-safe config proxy with hot reload |
+| `resource` | Unified resource bootstrapper (DB, Cache, MQ, Scheduler) |
+| `http` | aiohttp client with request-id injection |
+| `cacher` | Redis cache decorator |
+| `limiter` | Rate limit decorator |
+| `cluster_lock` | Distributed lock decorator |
+| `scheduler` | aioclock helpers for periodic tasks |
+| `utils` | Context, logging, signal handling, time utilities |
+
+## Extension Example
+
+```python
+from linglong_web.server_extensions import BaseServerExtension
+
+
+class RegistryExtension(BaseServerExtension):
+    """Example: custom service registration logic"""
+
+    def __init__(self, client):
+        self._client = client
+
+    async def on_startup(self, server):
+        payload = {"service": server.service_name, "instance": server.instance_id}
+        await self._client.register(payload)
+        server.register_shutdown_callback(lambda: self._client.deregister(payload))
+
+
+extensions = [RegistryExtension(client)]
+await app_server.initialize(
+    service_name="demo",
+    router=router.get_router(),
+    config_dict={"dev": DevConfig},
+    extensions=extensions,
+)
+```
+
+> Linglong no longer bundles service registration or remote config capabilities. Implement them in your business repository using extension hooks.
+
+## Testing & Coverage
+
+```bash
+# Run tests with coverage
+pytest tests/ -v --cov=linglong_web --cov-report=term-missing
+
+# Or with PYTHONPATH
+PYTHONPATH=. pytest tests/ -v --cov=linglong_web --cov-report=term-missing
+```
+
+- All new modules should maintain **80%+** test coverage.
+- Use `pytest-asyncio` and `pytest-mock` for fine-grained mocking of resources, rate limiters, and signal handlers.
+
+## Project Layout
+
+```
+linglong_web/
+├── linglong_web/
+│   ├── core/               # Core modules
+│   │   ├── server.py       # FastAPI bootstrapper
+│   │   ├── config.py       # Config proxy
+│   │   ├── resource.py     # Resource manager
+│   │   ├── http.py         # HTTP client
+│   │   ├── cacher.py       # Cache decorator
+│   │   ├── limiter.py      # Rate limit decorator
+│   │   └── ...
+│   └── utils/              # Utilities
+├── tests/                  # Test suite
+└── docs/                   # Documentation
+```
+
+## Versioning
+
+The package version is sourced from `linglong_web/__version__.py`.
+
+## License
+
+MIT License. See LICENSE.

linglong_web-0.0.1/linglong_web/__init__.py

@@ -0,0 +1,132 @@
+"""Linglong Web – 异步 FastAPI 工具集 / Asynchronous FastAPI toolkit."""
+from .__version__ import (
+    __author__,
+    __description__,
+    __license__,
+    __version__,
+)
+
+from .core.auth import login_required
+from .core.cacher import cacher
+from .core.cluster_lock import cluster_lock
+from .core.config import (
+    LinglongConfigBase,
+    LinglongConfig,
+    init_config,
+)
+from .core.constants import LinglongConst
+from .core.cors import allow_cors_specific
+from .core.db import TableBase
+from .core.ddl_manager import (
+    AutoDDLManager,
+    DDLManagerConfig,
+)
+from .core.http import (
+    HTTPClientConfig,
+    AsyncHTTPClient,
+    LinglongHTTPError,
+    http_client,
+)
+from .core.limiter import LimiterGuard, limiter
+from .core.limiter_local import (
+    limiter_local,
+    reset_limiter,
+    get_limiter_stats,
+)
+from .core.resource import (
+    ResourceManager,
+    Rmanager,
+    DEFAULT_DB_ALIAS,
+    init_resources,
+    close_resources,
+)
+from .core.response import (
+    APIError,
+    APIResponse,
+    build_api_response,
+    build_success_response,
+    build_error_response,
+)
+from .core.router import (
+    BaseRoute,
+    ServerRouter,
+)
+from .core.scheduler import (
+    BaseScheduler,
+    SchedulerGroup,
+    to_group,
+)
+from .core.server import LinglongAppServer
+from .core.server_extensions import BaseServerExtension
+from .core.schemas import (
+    PgsqlConfig,
+    RedisConfig,
+    RabbitMQConfig,
+    MongoConfig,
+    CeleryConfig,
+    ResourceInitConfig,
+)
+from .core.errors import (
+    ErrorCode,
+    ErrorMsg,
+    LinglongHTTPException,
+    LoginRequiredError,
+    LimiterError,
+    ClusterLockError,
+)
+
+__all__ = [
+    "login_required",
+    "cacher",
+    "cluster_lock",
+    "LinglongConfigBase",
+    "LinglongConfig",
+    "LinglongConst",
+    "init_config",
+    "allow_cors_specific",
+    "TableBase",
+    "AutoDDLManager",
+    "DDLManagerConfig",
+    "BaseRoute",
+    "ServerRouter",
+    "APIError",
+    "APIResponse",
+    "build_api_response",
+    "build_success_response",
+    "build_error_response",
+    "HTTPClientConfig",
+    "AsyncHTTPClient",
+    "LinglongHTTPError",
+    "http_client",
+    "LimiterGuard",
+    "limiter",
+    "limiter_local",
+    "reset_limiter",
+    "get_limiter_stats",
+    "ResourceManager",
+    "Rmanager",
+    "DEFAULT_DB_ALIAS",
+    "init_resources",
+    "close_resources",
+    "BaseScheduler",
+    "SchedulerGroup",
+    "to_group",
+    "LinglongAppServer",
+    "BaseServerExtension",
+    "PgsqlConfig",
+    "RedisConfig",
+    "RabbitMQConfig",
+    "MongoConfig",
+    "CeleryConfig",
+    "ResourceInitConfig",
+    "ErrorCode",
+    "ErrorMsg",
+    "LinglongHTTPException",
+    "LoginRequiredError",
+    "LimiterError",
+    "ClusterLockError",
+    "__version__",
+    "__author__",
+    "__license__",
+    "__description__",
+]

linglong_web-0.0.1/linglong_web/__version__.py

@@ -0,0 +1,9 @@
+"""Linglong Web metadata / 版本信息模块."""
+
+__version__ = "0.0.1"
+__author__ = "Victor Lai"
+__license__ = "MIT"
+__description__ = (
+    "Asynchronous FastAPI toolkit providing service bootstrap, registry hooks, resource orchestration, "
+    "and observability helpers"
+)

linglong_web-0.0.1/linglong_web/core/__init__.py

@@ -0,0 +1,54 @@
+"""Linglong Web – 异步 FastAPI 工具集 / Asynchronous FastAPI toolkit."""
+from .auth import login_required
+from .cacher import cacher
+from .cluster_lock import cluster_lock
+from .config import (
+    LinglongConfigBase,
+    LinglongConfig,
+    LinglongConfigProxy,
+    init_config,
+)
+from .constants import LinglongConst
+from .cors import allow_cors_specific
+from .db import TableBase
+from .ddl_manager import (
+    AutoDDLManager,
+    DDLManagerConfig,
+)
+from .http import (
+    HTTPClientConfig,
+    AsyncHTTPClient,
+    LinglongHTTPError,
+    http_client,
+)
+from .limiter import (
+    LimiterGuard,
+    limiter,
+)
+from .limiter_local import (
+    limiter_local,
+    reset_limiter,
+    get_limiter_stats,
+)
+from .resource import (
+    ResourceManager,
+    Rmanager,
+    DEFAULT_DB_ALIAS,
+    init_resources,
+    close_resources,
+)
+from .response import (
+    APIError,
+    APIResponse,
+    build_api_response,
+    build_success_response,
+    build_error_response,
+)
+from .router import BaseRoute, ServerRouter
+from .scheduler import (
+    BaseScheduler,
+    SchedulerGroup,
+    to_group,
+)
+from .server import LinglongAppServer
+from .server_extensions import BaseServerExtension

linglong_web-0.0.1/linglong_web/core/auth.py

@@ -0,0 +1,31 @@
+"""Authentication helpers shared across Linglong services.
+
+提供 Linglong 服务统一的认证装饰器工具。
+"""
+from functools import wraps
+from typing import (
+    Awaitable,
+    Callable,
+)
+
+from .errors import LoginRequiredError
+from .types import P, R
+from ..utils.context import get_context_user_id
+from ..utils.log import logger
+
+
+def login_required(func: Callable[P, Awaitable[R]]) -> Callable[P, Awaitable[R]]:
+    """Ensure the current request has a valid login user id.
+
+    确保当前请求已经完成登录校验，如果缺少用户信息则抛出 ``LoginRequiredError``。
+    """
+
+    @wraps(func)
+    async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        user_id = get_context_user_id()
+        if user_id is not None and isinstance(user_id, int):
+            return await func(*args, **kwargs)
+        logger.warning("user is not login")
+        raise LoginRequiredError()
+
+    return wrapper