关于 Async DRF

Django 4.1 支持异步 orm 和 CBV ，想请教一下现阶段 drf 要用 async 的正确姿势是怎么样的
找了一圈没找到答案

#Django #4.1 #orm #CBV #drf #async #异步 #请教 #现阶段 #姿势

我的 React Query 使用姿势是不是不对

刚使用 React Query 一天，有个问题请教大家。

在做一个应用，有一个接口比如 `/api/foo`，这是进入每一个页面都会调用的，我想要 cache 住。

我现在的代码:

```javascript
const PageA = () => {
const {data} = useQuery(['foo'], async () => {
// 忽略请求部分代码
}, {
cacheTime: 10000,
staleTime: 30000,
})
}

const PageB = () => {
const {data} = useQuery(['foo'], async () => {
// 忽略请求部分代码
}, {
cacheTime: 10000,
staleTime: 30000,
})
}
```

我发现这样是可以，那么，这样是否就规范了呢？我不需要把 data 再放在 redux 里吧(我感觉不用)？

另外一个问题，每个页面都有这一段代码，怎么抽成比较简单的 hook 呢？

#const #foo #data #代码 #useQuery #async #cacheTime #10000 #staleTime #30000

go 的爬虫 colly 中 queue async 和 parallelism 之间关系会冲突吗？

如果使用 queue 的话本身就是 async 了吧？不需要再启用 colly.Async ？再启用的话会有什么影响吗？
Limit 中的 Parallelism 是不是只在 async 或者 queue 的情形下有效？

#queue #async #启用 #colly #Async #Limit #Parallelism #的话 #情形 #是不是

django+ celery 的 gevent 模式使用 sync_to_async 时报错, 请问有什么好的处理方案吗?

复现方式:
## 使用 gevent 模式运行 celery
```
celery -A config.celery_app worker -P gevent -l INFO
```

## celery 任务
```
from asgiref.sync import sync_to_async


async def _test_async():
print(await sync_to_async(User.objects.get)(pk=1))


@shared_task(ignore_result=True)
def test_async():
asyncio.run(_test_async())
```

在 django 中运行调用异步任务将得到以下异常:
```
[2022-11-02 11:58:12,883: ERROR/MainProcess] Task apps.dark_chain.tasks.test_async[fbf4f896-0020-4273-90c2-8a4ef8f4cc46] raised unexpected: SynchronousOnlyOperation('You cannot call this from an async context - use a thread or sync_to_async.')
Traceback (most recent call last):
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/celery/app/trace.py", line 451, in trace_task
R = retval = fun(*args, **kwargs)
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/celery/app/trace.py", line 734, in __protected_call__
return self.run(*args, **kwargs)
File "/Users/xxxxx/Desktop/work_shuan/web/YingYan/apps/dark_chain/tasks.py", line 179, in test_async
asyncio.run(_test_async())
File "/Users/xxxxx/.pyenv/versions/3.9.7/lib/python3.9/asyncio/runners.py", line 44, in run
return loop.run_until_complete(main)
File "/Users/xxxxx/.pyenv/versions/3.9.7/lib/python3.9/asyncio/base_events.py", line 642, in run_until_complete
return future.result()
File "/Users/xxxxx/Desktop/work_shuan/web/YingYan/apps/dark_chain/tasks.py", line 174, in _test_async
print(await sync_to_async(User.objects.get)(pk=1))
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/asgiref/sync.py", line 435, in __call__
ret = await asyncio.wait_for(future, timeout=None)
File "/Users/xxxxx/.pyenv/versions/3.9.7/lib/python3.9/asyncio/tasks.py", line 442, in wait_for
return await fut
File "/Users/xxxxx/.pyenv/versions/3.9.7/lib/python3.9/concurrent/futures/thread.py", line 52, in run
result = self.fn(*self.args, **self.kwargs)
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/asgiref/sync.py", line 476, in thread_handler
return func(*args, **kwargs)
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/django/db/models/manager.py", line 85, in manager_method
return getattr(self.get_queryset(), name)(*args, **kwargs)
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/django/db/models/query.py", line 435, in get
num = len(clone)
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/django/db/models/query.py", line 262, in __len__
self._fetch_all()
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/django/db/models/query.py", line 1354, in _fetch_all
self._result_cache = list(self._iterable_class(self))
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/django/db/models/query.py", line 51, in __iter__
results = compiler.execute_sql(chunked_fetch=self.chunked_fetch, chunk_size=self.chunk_size)
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/django/db/models/sql/compiler.py", line 1200, in execute_sql
cursor = self.connection.cursor()
File "/Users/xxxxx/.pyenv/versions/3.9.7/envs/yingyan3/lib/python3.9/site-packages/django/utils/asyncio.py", line 23, in inner
raise SynchronousOnlyOperation(message)
django.core.exceptions.SynchronousOnlyOperation: You cannot call this from an async context - use a thread or sync_to_async.

```

#File #Users #xxxxx #py #line #async #pyenv #versions #3.9 #lib

请教一下， nodejs/express 是如何处理多个请求的

就是没有太理解这一点，虽然知道 IO 操作通过 async/await 异步执行的话不会阻塞主线程运行，但是如果有多个请求的话 node 是如何处理的呢，就是请求本身是否会被异步处理吗，还是说同一时间，只会有一个请求被处理，直到遇到 async/await ，如果有其他请求的话，主线程才会处理这些请求。
由于对并发问题不是特别了解，请各位大佬指教一下。

#请求 #async #await #异步 #处理 #主线 #的话 #IO #node #程才

请教一下，在 node 后端里面大量通过 Promise.all 来查询数据库有什么影响吗

一个新项目用 node 做后端，前段时间看到一个删除接口需要操作三张表，大概长这样:

```javascript
async delete(){
await order.delete();
await item.delete();
await history.delete();
}
```
然后这个时候从前端调用接口响应时间差不多是 600ms (测试库部署在良心云的便宜实例 docker 上所以比较慢)
由于这几个调用之间没有关联，所以尝试了一下使用 `Promise.all()` 来提交:
```javascript
async delete(){
const asyncRes = await Promise.all([
order.delete(),
item.delete(),
history.delete(),
])
}
```
然后发现响应时间居然直接变成 180ms 了，居然快了这么多。
所以想着有时间就把所有类似的没有关联的请求都换成 all()，但不知道有没有什么大的影响

#delete #await #javascript #async #order #item #history #Promise #接口 #调用

自动删除自己在 Telegram 群组内的全部发言

家人们，不废话，上链接：

https://github.com/lifetyper/TelegramRunAway

不骗 Star 版本：
```
from pyrogram import Client
from pyrogram.enums import ChatType

api_id = YOUR_APP_ID
api_hash = "YOUR_APP_HASH)"
app = Client("AnyString")


async def main():
async with app:
async for dialog in app.get_dialogs():
if dialog.chat.type in [ChatType.SUPERGROUP, ChatType.GROUP]:
print("Cleaning Messages in Group:{}...".format(dialog.chat.title))
async for msg in app.search_messages(chat_id=dialog.chat.id, from_user="me"):
if msg.text:
print("Deleting Message Contents:{}...".format(msg.text))
await app.delete_messages(chat_id=dialog.chat.id, message_ids=msg.id)


app.run(main())
```

#id #app #chat #dialog #async #msg #ChatType #pyrogram #import #Client

写了一本关于 Rust 异步原理的电子小书

[async-rust]( https://github.com/night-cruise/async-rust)详细介绍了 Rust 中 async/await 语法和异步运行时的原理和工作机制，在线阅读地址： https://night-cruise.github.io/async-rust

如果大佬们觉得有用的话，能给我一个 star 吗😋👉https://github.com/night-cruise/async-rust

#async #rust #https #github #night #cruise #com #Rust #await #io

SwiftUI 中如何优化下面这种场景?

封装了几个网络请求:

```swift
class API: ObservableObject {
@Published private(set) var isAccessTokenValid = false
@AppStorage("Passcode") var passcode: String = ""
@AppStorage("AccessToken") var accessToken: String = ""
@AppStorage("RefreshToken") var refreshToken: String = ""
privite func request() async throws -> (T?, URLResponse?) where T : Decodable {
// 省略具体实现
}
func request1() async throws -> SomeResponseType {}
func request2() async throws -> SomeResponseType {}
func request3() async throws -> SomeResponseType {}
}
```

在 `@main` 中, 使用 `.environmentObject(API())` 将网络请求加入到全局环境中, 在每个页面用到它的地方使用 `@EnvironmentObject var api: API` 来获取.

比如进入页面 A 需要进行网络请求, 则:

```
struct A: View {
@EnvironmentObject var api: API
@State private var data: [SomeResponseType] = []
var body: View {
VStack {}
.task {
let r = try? await api.request1()
if let d = r {
data = d
}
}
}
}
```

但这样的代码是 UIKit 的思路, 在 SwiftUI 中应该使用 Model 层进行网络请求, 应该这样添加一层 Model:

```swift
class ModelA: ObservableObject {
@Published var data: [SomeResponseType]
init() {
// do the request and then init data using the response
}
}
```

在页面中只需要

```
struct A: View {
@StateObject private var model = ModelA()
var body: View {
VStack {
model.data...
}
}
}
```

但现在问题出现了, 在 Model 里面无法直接使用上面封装的 API, 也就是在 model 的初始化函数中, 无法获取 environment 数据. 于是只能修改一下 API, 使其变成单例:

```
class API: ObservableObject {
static let shared = API()
...
}
```

这样在 model 里直接可以使用它了.


虽然这样看起来解决了, 但感觉代码结构还需要调整一下, 但不知道如何调整. 请大佬指点指点

#var #API #SomeResponseType #data #func #async #throws #View #model #class

请教下 mac 系统下谷歌浏览器被自动添加为登录项的疑问

如何所示，我发现我把谷歌浏览器从 13 系统中的登录项移除后，电脑重启后还是会自动添加进来，并且不停地弹窗，如何去除这个恶心的东西；

#png #https #pic1 #async #net #cn #2022 #12 #26 #移除