小编Bir*_*e94的帖子

我最近开始使用 vscode 进行 React 开发，目前遇到了一个问题。

给出以下小代码片段：

export default class foo extends React.Component {
    render() {
        return <div>Hello World</div>;
    }
}

vscode 有下划线，React因为名称未定义。当尝试应用快速修复（alt+enter 映射到editor.action.quickFix）时，vscode 建议执行以下操作：

import * as React from "../../../Users/daniel/Library/Caches/typescript/2.4/node_modules/@types/react"

我已将 React 安装在文件夹内的当前工作目录中node_modules（通过 npm 安装）。为什么 vscode 不建议我从那里包含 React 而是希望我包含一个打字文件？

预期推荐：

import * as React from "react";

我的jsconfig.json

{
    "compilerOptions": {
        "target": "ES6",
        "checkJs": true,
        "module": "commonjs",
        "allowSyntheticDefaultImports": true,
        "baseUrl": "./",
    },
    "exclude": [
        "dist"
    ],
    "include": [
        "./**/*.js"
    ]
}

文件夹结构：

/
   node_modules/ …

我试图通过仅从嵌套项中获取一个字段来将嵌套对象列表序列化为标量值。而不是[{key: value}, ...]我想收到[value1, value2, ...].

代码：

from marshmallow import *

class MySchema(Schema):
    key = fields.String(required=True)

class ParentSchema(Schema):
    items = fields.Nested(MySchema, only='key', many=True)

鉴于上述模式，我想序列化一些数据：

>>> data = {'items': [{'key': 1}, {'key': 2}, {'key': 3}]}
>>> result, errors = ParentSchema().dump(data)
>>> result
{'items': ['1', '2', '3']}

这按预期工作，为我提供了标量值列表。但是，当尝试使用上述模型反序列化数据时，数据突然无效：

>>> data, errors = ParentSchema().load(result)
>>> data
{'items': [{}, {}, {}]}
>>> errors
{'items': {0: {}, '_schema': ['Invalid input type.', 'Invalid input type.', 'Invalid input type.'], 1: {}, 2: {}}}

我是否缺少任何配置选项，或者这根本不可能？

我正在尝试使用 SQLAlchemy 的bulk_save_objects方法一次更新大量对象（大约 1000-1500）。

下面是代码的简化版本。真正的用例还包括对象的有条件创建，这就是为什么我不使用bulk_update_mappings.

对于每个对象，可以修改多个列。为了将所有更新批处理为一个查询，我使用update_changed_only=False. 我认为这没有缺点，因为无论如何所有对象都被修改了。

代码：

import random

from sqlalchemy import *
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, scoped_session
import logging

logging.basicConfig()
logger = logging.getLogger('sqlalchemy.engine')
logger.setLevel(logging.DEBUG)

# init sqlalchemy
engine = create_engine('sqlite://')
session_factory = sessionmaker(bind=engine)
Session = scoped_session(session_factory)
session = Session()

Base = declarative_base()


# simple test model
class Foo(Base):
    __tablename__ = 'test_foo'

    id = Column(Integer, primary_key=True, autoincrement=True)
    a = Column(String, default='')
    b = Column(String, default='')
    c = Column(String, default='') …

在AWS上更新我的一台Ubuntu 16.04机器后,python/pip似乎被破坏了.

ubuntu@host:~$ pip install celery
Traceback (most recent call last):
  File "/home/ubuntu/virtualenvs/myenv/bin/pip", line 7, in <module>
    from pip import main
  File "/home/ubuntu/virtualenvs/myenv/lib/python3.6/site-packages/pip/__init__.py", line 43, in <module>
    from pip.utils import get_installed_distributions, get_prog
  File "/home/ubuntu/virtualenvs/myenv/lib/python3.6/site-packages/pip/utils/__init__.py", line 23, in <module>
    from pip.locations import (
  File "/home/ubuntu/virtualenvs/myenv/lib/python3.6/site-packages/pip/locations.py", line 9, in <module>
    from distutils import sysconfig
  File "/home/ubuntu/virtualenvs/myenv/lib/python3.6/distutils/__init__.py", line 25, in <module>
    from distutils import dist, sysconfig
ImportError: cannot import name 'dist'

ubuntu@host:~$ python3.6 -m pip install celery
Traceback (most recent call last):
  File …

问题

我有一个库，目前没有异步支持，需要从异步代码调用。handler异步代码通过处理程序（下面代码中的函数）调用库。当处理程序执行时，库会定期调用回调 ( callback_wrapper) 来报告进度。

同步处理程序的执行顺序是为了ThreadPoolExecutor使主事件循环能够在处理程序运行时处理更多事件。

发生的情况是同步回调立即执行，但异步回调仅在主处理程序执行后执行。期望的结果是立即执行异步回调。

我猜事件循环在run_in_executor调用时被阻止，但我不知道如何解决这个问题。

代码

import asyncio
import time
from concurrent.futures.thread import ThreadPoolExecutor

loop = asyncio.get_event_loop()


def handler():
    print('handler started')
    callback_wrapper()
    time.sleep(1)
    print('handler stopped')


async def callback():
    print('callback')


def callback_wrapper():
    print('callback wrapper started')
    asyncio.ensure_future(callback(), loop=loop)
    print('callback wrapper stopped')


async def main():
    handler()


with ThreadPoolExecutor() as pool:
    async def thread_handler():
        await loop.run_in_executor(pool, handler)


    loop.run_until_complete(main())

输出

handler started
callback wrapper started
callback wrapper stopped
handler stopped
callback

所需输出

handler started
callback …