使用gevent websockets、promises和redis订阅python的apollo graphql端口
graphql-subscriptions的Python项目详细描述
#graphql python订阅
（正在工作！）
apollographql订阅python的端口，使用gevent websockets和redis
这是python中graphql订阅的实现。它使用apollographql[订阅传输ws]（https://github.com/apollographql/subscriptions-transport-ws）和[graphql订阅]（https://github.com/apollographql/graphql-subscriptions）包作为基础。它目前使用[redis py]（https://github.com/andymccurdy/redis-py）实现pubsub，并使用[gevent websockets]（https://bitbucket.org/noppo/gevent-websocket）实现并发。它还大量使用[syrusakbary/promise]（https://github.com/syrusakbary/promise）python实现来镜像Apollo GraphQL库中的逻辑。
打算与[graphql python]一起使用（https://github.com/graphql-python）/[graphene]（http://graphene python.org/）服务器和[Apollo客户端]（http://dev.apollodata.com/）用于GraphQL。api如下所示，但如果您需要更多信息，请参考上面引用的apollo graphql库，并具体说明其与使用graphql订阅客户端相关的内容。
良好的测试覆盖率。两者都适用于python 2/3。
```````
$pip install graphql订阅
````
redispubsubub（host='localhost'，port=6379，\*args，**kwargs，**kwargs）参数
<<
`````````````````````````````服务器实例url或ip（可选）
-`port`:redis服务器port（可选）
-`args，kwargs`：任何附加的位置和关键字参数都将传递给redis py构造函数（可选）
方法
-`publish（触发器名称，消息）`：触发器名称是订阅或pubsub通道；消息是以b结尾的变异对象或消息作为根值传递给订阅；此方法应在变异解析函数内部调用
-`subscribe（触发器名称，在消息处理程序上，选项）`：触发器名称是订阅或pubsub通道；在消息处理程序上是每次变异时将触发的回调ion；此方法由订阅管理器调用e`method在服务器的第一次订阅期间；在单独的greenlet中运行并调用redis`get_message（）`method在pubsub通道上持续轮询新消息
-`handle_message（message）`：当在订阅通道上接收到消息时由pubsub调用；将检查所有e现有的pubsub订阅，然后为所有匹配项调用"on_message_handler（）"（schema，pubsub，setup_funcs={}）
参数
-`schema`:graphql schema instance（必需）
-`pubsub`:publish、subscribe和unsubscribe方法的任何pubsub实例ds（在本例中是redispubsub类的实例）（必需）
-`setup_funcs`：从订阅名称映射到pubsub通道名称及其筛选函数的设置函数字典；kwargs参数是：`query，operation_name，callback，variables，context，format_error，format_response，args，subscription_name`（可选）
}
}
setup_funcs={new_user'：new_user}
`````
````方法是publish（trigger_name，payload）`：trigger name是订阅或pubsub通道；payload是最终传递给订阅根值的变异对象或消息；methodd在变异解析函数内部调用ribe（query，operation_name，callback，variables，context，format_error，format_response）`：当从WebSocket接收到新订阅时，SubscriptionServer调用。subscriptionserver从graphql订阅查询中分析参数
-`unsubscribe（sub_id）`：sub_id是订阅管理器实例正在跟踪的订阅id--从'subscribe（）方法返回，并由subscriptionserver调用onserver（订阅管理器，websocket，keep_alive=none，on_subscribe=none，on_unsubscribe=none，on_connect=none，on_disconnect=none）
er（必需）。
-`keep_alive`：服务器将向客户端发送keep alive消息的时间段（秒）。（可选）
-`on-subscribe（消息，订阅参数，websocket）`：创建自定义参数的函数，这些参数将在解析此订阅时使用（可选）
-`on-unsubscribe（websocket）`：当客户端取消订阅时调用的函数（可选）
-`on-connect（消息\u-payload，websocket）`：当客户端连接到套接字时将调用的函数，使用来自客户端的消息_payload调用，如果返回值是对象，则其元素将添加到上下文中。返回false或引发异常以拒绝连接。可以回信。（可选）
-`on戋disconnect（websocket）`：当客户端断开连接时调用的函数（可选）
\戋戋方法
-`on戋open（）`：当套接字首次打开时调用；检查正确的订阅协议并初始化keep alive消息
-`on戋close（reason）`：当sockET关闭；取消订阅并删除订阅对象
-`on_message（message）`：为服务器和客户端之间在套接字上交换的所有消息提供主控制流；分析初始消息、检查异常、响应客户端和订阅/取消订阅socket到突变通道，通过pubsub
-`unsubscribe（sub-id）`：从客户端指定的订阅中取消socket
-`timer（）`：向客户端发送保持活动的消息的计时器；在每个socket中单独运行
-`send-init-result（result），send-keep-alive（），send-subscription_u data（sub_u id，payload）、send_u subscription懔u fail（sub懔u id，payload）、send懔u subscription懔u success（sub懔u id）`：向客户端发送不同消息和有效负载的方便方法
r/>从Flask_套接字导入套接字
从Graphql_订阅导入（
SubscriptionManager，
RedisPubSub，
SubscriptionServer
）
app=Flask（
并将其附加到flask app对象
sockets=sockets（app）
实例化pubsub——这将用于"发布"突变
，并将其传递到订阅管理器
pubsub=redispubsub（）
使用graphene或另一个python graphql库创建模式
#此处不显示模型或架构设计，因为其简洁性
schema=graphene.schema（
query=query，
coveration=coveration，
subscription=subscription
）
chema，pubsub）
_websocket经理）
订阅服务器.handle（）
返回[]
#使用gevent webserver可以同时维护多个连接——gevent websocket为每个请求生成一个新的greenlet，并将请求转发到flask
app或socket app，具体取决于geventwebsocket import websocketserv的请求类型er
server=websocketserver（（''，5000），app）
print'服务于主机0.0.0.0:5000…\n'
server.serve_forever（）
````
当然，在服务器上，每次发生变异时（在本例中是redis频道），您都必须"发布"。这看起来像这样（使用graphene/sql炼金术）：
``python
class adduser（graphene.clientidmutation）：
class输入：
username=graphene.string（必需=true）
email=graphene.string（）
ok=graphene.boolean（）
user=graphene.field（lambda:user）
@classmethod
def mutate_and_get_payload（cls，args，context，info）：
u input=args.copy（）
del_input['clientmutationid']
new_user=usermodel（**u input）
db.session.add（new_user）
db.sesession.commit（）
ok=true
发布
如果pubsub.subscriptions:
pubsub.publish（'users'，new_user.as_dict（））
返回adduser（ok=ok，user=new_user）
类订阅（graphene.objecttype）：
users=graphene_sqlalchemy.sqlalchemyconnectionfield（
user，
active=graphene.boolean（）
return query.filter_by（id=info.root_value.get（'id'））
````
客户端（使用Apollo客户端库）：
首先创建网络接口和客户端实例，然后将它们包装在订阅客户端实例中
``js
从"react dom"导入reactdom
import{apolloprovider}来自'react apollo'
导入apollo client，{createnetworkinterface}来自'apollo client'
导入{subscriptionclient，addgraphqlsubscriptions}来自'subscriptions transport ws'
导入chatapp from'./screens/chatapp'
const networkinterface=createnetworkInterface（{
uri:'http://localhost:5000/graphql'
}）
const wsclient=new subscriptionclient（`ws://localhost:5000/socket`，{
reconnect:true
}）
const networkinterfacewithsubscriptions=addgraphqlsubscriptions（
networkinterface，
wsclient，
）
const client=new apollo client（{
dataidfromobject:o=>；o.id，
networkinterface:networkinterfacewithsubscriptions
}）
<；chatapp/>；
<；apolloprovider>；，
document.getelementbyid（'root'）
）
```
构建一个简单的组件，然后对从初始graphql查询返回的数据对象调用subscribetomore方法
```js
import react from'react'
import{graphql}from'react apollo'
import gql from'graphql tag'
import listbox from'。./components/list box'
const subscription\u query=gql`
subscription newusers{
users（active:true）{
edges{
node{
id
username
}
}
}
}
`
const list\u box\u query=gql`
query诱惑者{
用户（活动：真）{
边{
节点{
id
用户名
}
}
}
}
`
>类chatlistbox扩展react.component{
component将接收props（newprops）{
如果（！newprops.data.loading）{
if（this.subscription）{
返回
}
this.subscription=newprops.data.subscribetomore（{
文档：subscription_query，
updatequery:（previousresult，{subscriptiondata}）=>；{
const newuser=subsscriptiondata.data.users.edges
const newresult={
users:{
edges:[
…previousresult.users.edges，
…newuser
]
}
}
}
返回newresult
}，
onerror:（err）=>；控制台。错误（err）
}
}
}
render（）{
return<；list box data={this.props.data}/>；
}
}
const chatlistboxwithdata=graphql（列表框查询）（chatlistbox）
export default chatlistboxwithdata
```
（正在工作！）
apollographql订阅python的端口，使用gevent websockets和redis
这是python中graphql订阅的实现。它使用apollographql[订阅传输ws]（https://github.com/apollographql/subscriptions-transport-ws）和[graphql订阅]（https://github.com/apollographql/graphql-subscriptions）包作为基础。它目前使用[redis py]（https://github.com/andymccurdy/redis-py）实现pubsub，并使用[gevent websockets]（https://bitbucket.org/noppo/gevent-websocket）实现并发。它还大量使用[syrusakbary/promise]（https://github.com/syrusakbary/promise）python实现来镜像Apollo GraphQL库中的逻辑。
打算与[graphql python]一起使用（https://github.com/graphql-python）/[graphene]（http://graphene python.org/）服务器和[Apollo客户端]（http://dev.apollodata.com/）用于GraphQL。api如下所示，但如果您需要更多信息，请参考上面引用的apollo graphql库，并具体说明其与使用graphql订阅客户端相关的内容。
良好的测试覆盖率。两者都适用于python 2/3。
```````
$pip install graphql订阅
````
redispubsubub（host='localhost'，port=6379，\*args，**kwargs，**kwargs）参数
<<
`````````````````````````````服务器实例url或ip（可选）
-`port`:redis服务器port（可选）
-`args，kwargs`：任何附加的位置和关键字参数都将传递给redis py构造函数（可选）
方法
-`publish（触发器名称，消息）`：触发器名称是订阅或pubsub通道；消息是以b结尾的变异对象或消息作为根值传递给订阅；此方法应在变异解析函数内部调用
-`subscribe（触发器名称，在消息处理程序上，选项）`：触发器名称是订阅或pubsub通道；在消息处理程序上是每次变异时将触发的回调ion；此方法由订阅管理器调用e`method在服务器的第一次订阅期间；在单独的greenlet中运行并调用redis`get_message（）`method在pubsub通道上持续轮询新消息
-`handle_message（message）`：当在订阅通道上接收到消息时由pubsub调用；将检查所有e现有的pubsub订阅，然后为所有匹配项调用"on_message_handler（）"（schema，pubsub，setup_funcs={}）
参数
-`schema`:graphql schema instance（必需）
-`pubsub`:publish、subscribe和unsubscribe方法的任何pubsub实例ds（在本例中是redispubsub类的实例）（必需）
-`setup_funcs`：从订阅名称映射到pubsub通道名称及其筛选函数的设置函数字典；kwargs参数是：`query，operation_name，callback，variables，context，format_error，format_response，args，subscription_name`（可选）
}
}
setup_funcs={new_user'：new_user}
`````
````方法是publish（trigger_name，payload）`：trigger name是订阅或pubsub通道；payload是最终传递给订阅根值的变异对象或消息；methodd在变异解析函数内部调用ribe（query，operation_name，callback，variables，context，format_error，format_response）`：当从WebSocket接收到新订阅时，SubscriptionServer调用。subscriptionserver从graphql订阅查询中分析参数
-`unsubscribe（sub_id）`：sub_id是订阅管理器实例正在跟踪的订阅id--从'subscribe（）方法返回，并由subscriptionserver调用onserver（订阅管理器，websocket，keep_alive=none，on_subscribe=none，on_unsubscribe=none，on_connect=none，on_disconnect=none）
er（必需）。
-`keep_alive`：服务器将向客户端发送keep alive消息的时间段（秒）。（可选）
-`on-subscribe（消息，订阅参数，websocket）`：创建自定义参数的函数，这些参数将在解析此订阅时使用（可选）
-`on-unsubscribe（websocket）`：当客户端取消订阅时调用的函数（可选）
-`on-connect（消息\u-payload，websocket）`：当客户端连接到套接字时将调用的函数，使用来自客户端的消息_payload调用，如果返回值是对象，则其元素将添加到上下文中。返回false或引发异常以拒绝连接。可以回信。（可选）
-`on戋disconnect（websocket）`：当客户端断开连接时调用的函数（可选）
\戋戋方法
-`on戋open（）`：当套接字首次打开时调用；检查正确的订阅协议并初始化keep alive消息
-`on戋close（reason）`：当sockET关闭；取消订阅并删除订阅对象
-`on_message（message）`：为服务器和客户端之间在套接字上交换的所有消息提供主控制流；分析初始消息、检查异常、响应客户端和订阅/取消订阅socket到突变通道，通过pubsub
-`unsubscribe（sub-id）`：从客户端指定的订阅中取消socket
-`timer（）`：向客户端发送保持活动的消息的计时器；在每个socket中单独运行
-`send-init-result（result），send-keep-alive（），send-subscription_u data（sub_u id，payload）、send_u subscription懔u fail（sub懔u id，payload）、send懔u subscription懔u success（sub懔u id）`：向客户端发送不同消息和有效负载的方便方法
r/>从Flask_套接字导入套接字
从Graphql_订阅导入（
SubscriptionManager，
RedisPubSub，
SubscriptionServer
）
app=Flask（
并将其附加到flask app对象
sockets=sockets（app）
实例化pubsub——这将用于"发布"突变
，并将其传递到订阅管理器
pubsub=redispubsub（）
使用graphene或另一个python graphql库创建模式
#此处不显示模型或架构设计，因为其简洁性
schema=graphene.schema（
query=query，
coveration=coveration，
subscription=subscription
）
chema，pubsub）
_websocket经理）
订阅服务器.handle（）
返回[]
#使用gevent webserver可以同时维护多个连接——gevent websocket为每个请求生成一个新的greenlet，并将请求转发到flask
app或socket app，具体取决于geventwebsocket import websocketserv的请求类型er
server=websocketserver（（''，5000），app）
print'服务于主机0.0.0.0:5000…\n'
server.serve_forever（）
````
当然，在服务器上，每次发生变异时（在本例中是redis频道），您都必须"发布"。这看起来像这样（使用graphene/sql炼金术）：
``python
class adduser（graphene.clientidmutation）：
class输入：
username=graphene.string（必需=true）
email=graphene.string（）
ok=graphene.boolean（）
user=graphene.field（lambda:user）
@classmethod
def mutate_and_get_payload（cls，args，context，info）：
u input=args.copy（）
del_input['clientmutationid']
new_user=usermodel（**u input）
db.session.add（new_user）
db.sesession.commit（）
ok=true
发布
如果pubsub.subscriptions:
pubsub.publish（'users'，new_user.as_dict（））
返回adduser（ok=ok，user=new_user）
类订阅（graphene.objecttype）：
users=graphene_sqlalchemy.sqlalchemyconnectionfield（
user，
active=graphene.boolean（）
return query.filter_by（id=info.root_value.get（'id'））
````
客户端（使用Apollo客户端库）：
首先创建网络接口和客户端实例，然后将它们包装在订阅客户端实例中
``js
从"react dom"导入reactdom
import{apolloprovider}来自'react apollo'
导入apollo client，{createnetworkinterface}来自'apollo client'
导入{subscriptionclient，addgraphqlsubscriptions}来自'subscriptions transport ws'
导入chatapp from'./screens/chatapp'
const networkinterface=createnetworkInterface（{
uri:'http://localhost:5000/graphql'
}）
const wsclient=new subscriptionclient（`ws://localhost:5000/socket`，{
reconnect:true
}）
const networkinterfacewithsubscriptions=addgraphqlsubscriptions（
networkinterface，
wsclient，
）
const client=new apollo client（{
dataidfromobject:o=>；o.id，
networkinterface:networkinterfacewithsubscriptions
}）
<；chatapp/>；
<；apolloprovider>；，
document.getelementbyid（'root'）
）
```
构建一个简单的组件，然后对从初始graphql查询返回的数据对象调用subscribetomore方法
```js
import react from'react'
import{graphql}from'react apollo'
import gql from'graphql tag'
import listbox from'。./components/list box'
const subscription\u query=gql`
subscription newusers{
users（active:true）{
edges{
node{
id
username
}
}
}
}
`
const list\u box\u query=gql`
query诱惑者{
用户（活动：真）{
边{
节点{
id
用户名
}
}
}
}
`
>类chatlistbox扩展react.component{
component将接收props（newprops）{
如果（！newprops.data.loading）{
if（this.subscription）{
返回
}
this.subscription=newprops.data.subscribetomore（{
文档：subscription_query，
updatequery:（previousresult，{subscriptiondata}）=>；{
const newuser=subsscriptiondata.data.users.edges
const newresult={
users:{
edges:[
…previousresult.users.edges，
…newuser
]
}
}
}
返回newresult
}，
onerror:（err）=>；控制台。错误（err）
}
}
}
render（）{
return<；list box data={this.props.data}/>；
}
}
const chatlistboxwithdata=graphql（列表框查询）（chatlistbox）
export default chatlistboxwithdata
```
欢迎加入QQ群-->： 979659372
