chatgraph 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of chatgraph might be problematic. Click here for more details.
- chatgraph/__init__.py +25 -16
- chatgraph/bot/chatbot_model.py +17 -3
- chatgraph/gRPC/gRPCCall.py +30 -3
- chatgraph/pb/router.proto +25 -1
- chatgraph/pb/router_pb2.py +57 -55
- chatgraph/pb/router_pb2_grpc.py +551 -318
- chatgraph/types/end_types.py +22 -8
- chatgraph/types/image.py +92 -0
- chatgraph/types/request_types.py +57 -9
- {chatgraph-0.5.3.dist-info → chatgraph-0.6.1.dist-info}/METADATA +2 -1
- chatgraph-0.6.1.dist-info/RECORD +23 -0
- chatgraph-0.5.3.dist-info/RECORD +0 -22
- {chatgraph-0.5.3.dist-info → chatgraph-0.6.1.dist-info}/LICENSE +0 -0
- {chatgraph-0.5.3.dist-info → chatgraph-0.6.1.dist-info}/WHEEL +0 -0
- {chatgraph-0.5.3.dist-info → chatgraph-0.6.1.dist-info}/entry_points.txt +0 -0
chatgraph/pb/router_pb2_grpc.py
CHANGED
|
@@ -5,29 +5,31 @@ import warnings
|
|
|
5
5
|
|
|
6
6
|
import chatgraph.pb.router_pb2 as router__pb2
|
|
7
7
|
|
|
8
|
-
GRPC_GENERATED_VERSION =
|
|
8
|
+
GRPC_GENERATED_VERSION = "1.73.0"
|
|
9
9
|
GRPC_VERSION = grpc.__version__
|
|
10
10
|
_version_not_supported = False
|
|
11
11
|
|
|
12
12
|
try:
|
|
13
13
|
from grpc._utilities import first_version_is_lower
|
|
14
|
-
|
|
14
|
+
|
|
15
|
+
_version_not_supported = first_version_is_lower(
|
|
16
|
+
GRPC_VERSION, GRPC_GENERATED_VERSION
|
|
17
|
+
)
|
|
15
18
|
except ImportError:
|
|
16
19
|
_version_not_supported = True
|
|
17
20
|
|
|
18
21
|
if _version_not_supported:
|
|
19
22
|
raise RuntimeError(
|
|
20
|
-
f
|
|
21
|
-
+ f
|
|
22
|
-
+ f
|
|
23
|
-
+ f
|
|
24
|
-
+ f
|
|
23
|
+
f"The grpc package installed is at version {GRPC_VERSION},"
|
|
24
|
+
+ f" but the generated code in router_pb2_grpc.py depends on"
|
|
25
|
+
+ f" grpcio>={GRPC_GENERATED_VERSION}."
|
|
26
|
+
+ f" Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}"
|
|
27
|
+
+ f" or downgrade your generated code using grpcio-tools<={GRPC_VERSION}."
|
|
25
28
|
)
|
|
26
29
|
|
|
27
30
|
|
|
28
31
|
class UserStateServiceStub(object):
|
|
29
|
-
"""/// Serviços de Estado do Usuário /////
|
|
30
|
-
"""
|
|
32
|
+
"""/// Serviços de Estado do Usuário /////"""
|
|
31
33
|
|
|
32
34
|
def __init__(self, channel):
|
|
33
35
|
"""Constructor.
|
|
@@ -36,105 +38,129 @@ class UserStateServiceStub(object):
|
|
|
36
38
|
channel: A grpc.Channel.
|
|
37
39
|
"""
|
|
38
40
|
self.InsertUpdateUserState = channel.unary_unary(
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
41
|
+
"/chatbot.UserStateService/InsertUpdateUserState",
|
|
42
|
+
request_serializer=router__pb2.UserState.SerializeToString,
|
|
43
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
44
|
+
_registered_method=True,
|
|
45
|
+
)
|
|
46
|
+
self.SetRoute = channel.unary_unary(
|
|
47
|
+
"/chatbot.UserStateService/SetRoute",
|
|
48
|
+
request_serializer=router__pb2.RouteRequest.SerializeToString,
|
|
49
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
50
|
+
_registered_method=True,
|
|
51
|
+
)
|
|
43
52
|
self.DeleteUserState = channel.unary_unary(
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
53
|
+
"/chatbot.UserStateService/DeleteUserState",
|
|
54
|
+
request_serializer=router__pb2.ChatID.SerializeToString,
|
|
55
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
56
|
+
_registered_method=True,
|
|
57
|
+
)
|
|
48
58
|
self.GetUserState = channel.unary_unary(
|
|
49
|
-
|
|
50
|
-
|
|
51
|
-
|
|
52
|
-
|
|
59
|
+
"/chatbot.UserStateService/GetUserState",
|
|
60
|
+
request_serializer=router__pb2.ChatID.SerializeToString,
|
|
61
|
+
response_deserializer=router__pb2.UserState.FromString,
|
|
62
|
+
_registered_method=True,
|
|
63
|
+
)
|
|
53
64
|
self.GetAllUserStates = channel.unary_unary(
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
65
|
+
"/chatbot.UserStateService/GetAllUserStates",
|
|
66
|
+
request_serializer=router__pb2.Void.SerializeToString,
|
|
67
|
+
response_deserializer=router__pb2.UserStateList.FromString,
|
|
68
|
+
_registered_method=True,
|
|
69
|
+
)
|
|
58
70
|
|
|
59
71
|
|
|
60
72
|
class UserStateServiceServicer(object):
|
|
61
|
-
"""/// Serviços de Estado do Usuário /////
|
|
62
|
-
"""
|
|
73
|
+
"""/// Serviços de Estado do Usuário /////"""
|
|
63
74
|
|
|
64
75
|
def InsertUpdateUserState(self, request, context):
|
|
65
76
|
"""Missing associated documentation comment in .proto file."""
|
|
66
77
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
67
|
-
context.set_details(
|
|
68
|
-
raise NotImplementedError(
|
|
78
|
+
context.set_details("Method not implemented!")
|
|
79
|
+
raise NotImplementedError("Method not implemented!")
|
|
80
|
+
|
|
81
|
+
def SetRoute(self, request, context):
|
|
82
|
+
"""Missing associated documentation comment in .proto file."""
|
|
83
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
84
|
+
context.set_details("Method not implemented!")
|
|
85
|
+
raise NotImplementedError("Method not implemented!")
|
|
69
86
|
|
|
70
87
|
def DeleteUserState(self, request, context):
|
|
71
88
|
"""Missing associated documentation comment in .proto file."""
|
|
72
89
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
73
|
-
context.set_details(
|
|
74
|
-
raise NotImplementedError(
|
|
90
|
+
context.set_details("Method not implemented!")
|
|
91
|
+
raise NotImplementedError("Method not implemented!")
|
|
75
92
|
|
|
76
93
|
def GetUserState(self, request, context):
|
|
77
94
|
"""Missing associated documentation comment in .proto file."""
|
|
78
95
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
79
|
-
context.set_details(
|
|
80
|
-
raise NotImplementedError(
|
|
96
|
+
context.set_details("Method not implemented!")
|
|
97
|
+
raise NotImplementedError("Method not implemented!")
|
|
81
98
|
|
|
82
99
|
def GetAllUserStates(self, request, context):
|
|
83
100
|
"""Missing associated documentation comment in .proto file."""
|
|
84
101
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
85
|
-
context.set_details(
|
|
86
|
-
raise NotImplementedError(
|
|
102
|
+
context.set_details("Method not implemented!")
|
|
103
|
+
raise NotImplementedError("Method not implemented!")
|
|
87
104
|
|
|
88
105
|
|
|
89
106
|
def add_UserStateServiceServicer_to_server(servicer, server):
|
|
90
107
|
rpc_method_handlers = {
|
|
91
|
-
|
|
92
|
-
|
|
93
|
-
|
|
94
|
-
|
|
95
|
-
|
|
96
|
-
|
|
97
|
-
|
|
98
|
-
|
|
99
|
-
|
|
100
|
-
|
|
101
|
-
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
105
|
-
|
|
106
|
-
|
|
107
|
-
|
|
108
|
-
|
|
109
|
-
|
|
110
|
-
|
|
108
|
+
"InsertUpdateUserState": grpc.unary_unary_rpc_method_handler(
|
|
109
|
+
servicer.InsertUpdateUserState,
|
|
110
|
+
request_deserializer=router__pb2.UserState.FromString,
|
|
111
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
112
|
+
),
|
|
113
|
+
"SetRoute": grpc.unary_unary_rpc_method_handler(
|
|
114
|
+
servicer.SetRoute,
|
|
115
|
+
request_deserializer=router__pb2.RouteRequest.FromString,
|
|
116
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
117
|
+
),
|
|
118
|
+
"DeleteUserState": grpc.unary_unary_rpc_method_handler(
|
|
119
|
+
servicer.DeleteUserState,
|
|
120
|
+
request_deserializer=router__pb2.ChatID.FromString,
|
|
121
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
122
|
+
),
|
|
123
|
+
"GetUserState": grpc.unary_unary_rpc_method_handler(
|
|
124
|
+
servicer.GetUserState,
|
|
125
|
+
request_deserializer=router__pb2.ChatID.FromString,
|
|
126
|
+
response_serializer=router__pb2.UserState.SerializeToString,
|
|
127
|
+
),
|
|
128
|
+
"GetAllUserStates": grpc.unary_unary_rpc_method_handler(
|
|
129
|
+
servicer.GetAllUserStates,
|
|
130
|
+
request_deserializer=router__pb2.Void.FromString,
|
|
131
|
+
response_serializer=router__pb2.UserStateList.SerializeToString,
|
|
132
|
+
),
|
|
111
133
|
}
|
|
112
134
|
generic_handler = grpc.method_handlers_generic_handler(
|
|
113
|
-
|
|
135
|
+
"chatbot.UserStateService", rpc_method_handlers
|
|
136
|
+
)
|
|
114
137
|
server.add_generic_rpc_handlers((generic_handler,))
|
|
115
|
-
server.add_registered_method_handlers(
|
|
138
|
+
server.add_registered_method_handlers(
|
|
139
|
+
"chatbot.UserStateService", rpc_method_handlers
|
|
140
|
+
)
|
|
116
141
|
|
|
117
142
|
|
|
118
|
-
|
|
143
|
+
# This class is part of an EXPERIMENTAL API.
|
|
119
144
|
class UserStateService(object):
|
|
120
|
-
"""/// Serviços de Estado do Usuário /////
|
|
121
|
-
"""
|
|
145
|
+
"""/// Serviços de Estado do Usuário /////"""
|
|
122
146
|
|
|
123
147
|
@staticmethod
|
|
124
|
-
def InsertUpdateUserState(
|
|
125
|
-
|
|
126
|
-
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
|
|
130
|
-
|
|
131
|
-
|
|
132
|
-
|
|
133
|
-
|
|
148
|
+
def InsertUpdateUserState(
|
|
149
|
+
request,
|
|
150
|
+
target,
|
|
151
|
+
options=(),
|
|
152
|
+
channel_credentials=None,
|
|
153
|
+
call_credentials=None,
|
|
154
|
+
insecure=False,
|
|
155
|
+
compression=None,
|
|
156
|
+
wait_for_ready=None,
|
|
157
|
+
timeout=None,
|
|
158
|
+
metadata=None,
|
|
159
|
+
):
|
|
134
160
|
return grpc.experimental.unary_unary(
|
|
135
161
|
request,
|
|
136
162
|
target,
|
|
137
|
-
|
|
163
|
+
"/chatbot.UserStateService/InsertUpdateUserState",
|
|
138
164
|
router__pb2.UserState.SerializeToString,
|
|
139
165
|
router__pb2.RequestStatus.FromString,
|
|
140
166
|
options,
|
|
@@ -145,23 +171,56 @@ class UserStateService(object):
|
|
|
145
171
|
wait_for_ready,
|
|
146
172
|
timeout,
|
|
147
173
|
metadata,
|
|
148
|
-
_registered_method=True
|
|
174
|
+
_registered_method=True,
|
|
175
|
+
)
|
|
149
176
|
|
|
150
177
|
@staticmethod
|
|
151
|
-
def
|
|
178
|
+
def SetRoute(
|
|
179
|
+
request,
|
|
180
|
+
target,
|
|
181
|
+
options=(),
|
|
182
|
+
channel_credentials=None,
|
|
183
|
+
call_credentials=None,
|
|
184
|
+
insecure=False,
|
|
185
|
+
compression=None,
|
|
186
|
+
wait_for_ready=None,
|
|
187
|
+
timeout=None,
|
|
188
|
+
metadata=None,
|
|
189
|
+
):
|
|
190
|
+
return grpc.experimental.unary_unary(
|
|
191
|
+
request,
|
|
152
192
|
target,
|
|
153
|
-
|
|
154
|
-
|
|
155
|
-
|
|
156
|
-
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
|
|
160
|
-
|
|
193
|
+
"/chatbot.UserStateService/SetRoute",
|
|
194
|
+
router__pb2.RouteRequest.SerializeToString,
|
|
195
|
+
router__pb2.RequestStatus.FromString,
|
|
196
|
+
options,
|
|
197
|
+
channel_credentials,
|
|
198
|
+
insecure,
|
|
199
|
+
call_credentials,
|
|
200
|
+
compression,
|
|
201
|
+
wait_for_ready,
|
|
202
|
+
timeout,
|
|
203
|
+
metadata,
|
|
204
|
+
_registered_method=True,
|
|
205
|
+
)
|
|
206
|
+
|
|
207
|
+
@staticmethod
|
|
208
|
+
def DeleteUserState(
|
|
209
|
+
request,
|
|
210
|
+
target,
|
|
211
|
+
options=(),
|
|
212
|
+
channel_credentials=None,
|
|
213
|
+
call_credentials=None,
|
|
214
|
+
insecure=False,
|
|
215
|
+
compression=None,
|
|
216
|
+
wait_for_ready=None,
|
|
217
|
+
timeout=None,
|
|
218
|
+
metadata=None,
|
|
219
|
+
):
|
|
161
220
|
return grpc.experimental.unary_unary(
|
|
162
221
|
request,
|
|
163
222
|
target,
|
|
164
|
-
|
|
223
|
+
"/chatbot.UserStateService/DeleteUserState",
|
|
165
224
|
router__pb2.ChatID.SerializeToString,
|
|
166
225
|
router__pb2.RequestStatus.FromString,
|
|
167
226
|
options,
|
|
@@ -172,23 +231,26 @@ class UserStateService(object):
|
|
|
172
231
|
wait_for_ready,
|
|
173
232
|
timeout,
|
|
174
233
|
metadata,
|
|
175
|
-
_registered_method=True
|
|
234
|
+
_registered_method=True,
|
|
235
|
+
)
|
|
176
236
|
|
|
177
237
|
@staticmethod
|
|
178
|
-
def GetUserState(
|
|
179
|
-
|
|
180
|
-
|
|
181
|
-
|
|
182
|
-
|
|
183
|
-
|
|
184
|
-
|
|
185
|
-
|
|
186
|
-
|
|
187
|
-
|
|
238
|
+
def GetUserState(
|
|
239
|
+
request,
|
|
240
|
+
target,
|
|
241
|
+
options=(),
|
|
242
|
+
channel_credentials=None,
|
|
243
|
+
call_credentials=None,
|
|
244
|
+
insecure=False,
|
|
245
|
+
compression=None,
|
|
246
|
+
wait_for_ready=None,
|
|
247
|
+
timeout=None,
|
|
248
|
+
metadata=None,
|
|
249
|
+
):
|
|
188
250
|
return grpc.experimental.unary_unary(
|
|
189
251
|
request,
|
|
190
252
|
target,
|
|
191
|
-
|
|
253
|
+
"/chatbot.UserStateService/GetUserState",
|
|
192
254
|
router__pb2.ChatID.SerializeToString,
|
|
193
255
|
router__pb2.UserState.FromString,
|
|
194
256
|
options,
|
|
@@ -199,23 +261,26 @@ class UserStateService(object):
|
|
|
199
261
|
wait_for_ready,
|
|
200
262
|
timeout,
|
|
201
263
|
metadata,
|
|
202
|
-
_registered_method=True
|
|
264
|
+
_registered_method=True,
|
|
265
|
+
)
|
|
203
266
|
|
|
204
267
|
@staticmethod
|
|
205
|
-
def GetAllUserStates(
|
|
206
|
-
|
|
207
|
-
|
|
208
|
-
|
|
209
|
-
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
|
|
213
|
-
|
|
214
|
-
|
|
268
|
+
def GetAllUserStates(
|
|
269
|
+
request,
|
|
270
|
+
target,
|
|
271
|
+
options=(),
|
|
272
|
+
channel_credentials=None,
|
|
273
|
+
call_credentials=None,
|
|
274
|
+
insecure=False,
|
|
275
|
+
compression=None,
|
|
276
|
+
wait_for_ready=None,
|
|
277
|
+
timeout=None,
|
|
278
|
+
metadata=None,
|
|
279
|
+
):
|
|
215
280
|
return grpc.experimental.unary_unary(
|
|
216
281
|
request,
|
|
217
282
|
target,
|
|
218
|
-
|
|
283
|
+
"/chatbot.UserStateService/GetAllUserStates",
|
|
219
284
|
router__pb2.Void.SerializeToString,
|
|
220
285
|
router__pb2.UserStateList.FromString,
|
|
221
286
|
options,
|
|
@@ -226,12 +291,12 @@ class UserStateService(object):
|
|
|
226
291
|
wait_for_ready,
|
|
227
292
|
timeout,
|
|
228
293
|
metadata,
|
|
229
|
-
_registered_method=True
|
|
294
|
+
_registered_method=True,
|
|
295
|
+
)
|
|
230
296
|
|
|
231
297
|
|
|
232
298
|
class SendMessageStub(object):
|
|
233
|
-
"""/// Serviços de Mensagens /////
|
|
234
|
-
"""
|
|
299
|
+
"""/// Serviços de Mensagens /////"""
|
|
235
300
|
|
|
236
301
|
def __init__(self, channel):
|
|
237
302
|
"""Constructor.
|
|
@@ -240,57 +305,110 @@ class SendMessageStub(object):
|
|
|
240
305
|
channel: A grpc.Channel.
|
|
241
306
|
"""
|
|
242
307
|
self.SendMessage = channel.unary_unary(
|
|
243
|
-
|
|
244
|
-
|
|
245
|
-
|
|
246
|
-
|
|
308
|
+
"/chatbot.SendMessage/SendMessage",
|
|
309
|
+
request_serializer=router__pb2.Message.SerializeToString,
|
|
310
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
311
|
+
_registered_method=True,
|
|
312
|
+
)
|
|
313
|
+
self.SendImage = channel.unary_unary(
|
|
314
|
+
"/chatbot.SendMessage/SendImage",
|
|
315
|
+
request_serializer=router__pb2.FileMessage.SerializeToString,
|
|
316
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
317
|
+
_registered_method=True,
|
|
318
|
+
)
|
|
319
|
+
self.SendFile = channel.unary_unary(
|
|
320
|
+
"/chatbot.SendMessage/SendFile",
|
|
321
|
+
request_serializer=router__pb2.FileMessage.SerializeToString,
|
|
322
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
323
|
+
_registered_method=True,
|
|
324
|
+
)
|
|
325
|
+
self.UploadFile = channel.unary_unary(
|
|
326
|
+
"/chatbot.SendMessage/UploadFile",
|
|
327
|
+
request_serializer=router__pb2.UploadFileRequest.SerializeToString,
|
|
328
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
329
|
+
_registered_method=True,
|
|
330
|
+
)
|
|
247
331
|
|
|
248
332
|
|
|
249
333
|
class SendMessageServicer(object):
|
|
250
|
-
"""/// Serviços de Mensagens /////
|
|
251
|
-
"""
|
|
334
|
+
"""/// Serviços de Mensagens /////"""
|
|
252
335
|
|
|
253
336
|
def SendMessage(self, request, context):
|
|
254
337
|
"""Missing associated documentation comment in .proto file."""
|
|
255
338
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
256
|
-
context.set_details(
|
|
257
|
-
raise NotImplementedError(
|
|
339
|
+
context.set_details("Method not implemented!")
|
|
340
|
+
raise NotImplementedError("Method not implemented!")
|
|
341
|
+
|
|
342
|
+
def SendImage(self, request, context):
|
|
343
|
+
"""Missing associated documentation comment in .proto file."""
|
|
344
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
345
|
+
context.set_details("Method not implemented!")
|
|
346
|
+
raise NotImplementedError("Method not implemented!")
|
|
347
|
+
|
|
348
|
+
def SendFile(self, request, context):
|
|
349
|
+
"""Missing associated documentation comment in .proto file."""
|
|
350
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
351
|
+
context.set_details("Method not implemented!")
|
|
352
|
+
raise NotImplementedError("Method not implemented!")
|
|
353
|
+
|
|
354
|
+
def UploadFile(self, request, context):
|
|
355
|
+
"""Missing associated documentation comment in .proto file."""
|
|
356
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
357
|
+
context.set_details("Method not implemented!")
|
|
358
|
+
raise NotImplementedError("Method not implemented!")
|
|
258
359
|
|
|
259
360
|
|
|
260
361
|
def add_SendMessageServicer_to_server(servicer, server):
|
|
261
362
|
rpc_method_handlers = {
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
363
|
+
"SendMessage": grpc.unary_unary_rpc_method_handler(
|
|
364
|
+
servicer.SendMessage,
|
|
365
|
+
request_deserializer=router__pb2.Message.FromString,
|
|
366
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
367
|
+
),
|
|
368
|
+
"SendImage": grpc.unary_unary_rpc_method_handler(
|
|
369
|
+
servicer.SendImage,
|
|
370
|
+
request_deserializer=router__pb2.FileMessage.FromString,
|
|
371
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
372
|
+
),
|
|
373
|
+
"SendFile": grpc.unary_unary_rpc_method_handler(
|
|
374
|
+
servicer.SendFile,
|
|
375
|
+
request_deserializer=router__pb2.FileMessage.FromString,
|
|
376
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
377
|
+
),
|
|
378
|
+
"UploadFile": grpc.unary_unary_rpc_method_handler(
|
|
379
|
+
servicer.UploadFile,
|
|
380
|
+
request_deserializer=router__pb2.UploadFileRequest.FromString,
|
|
381
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
382
|
+
),
|
|
267
383
|
}
|
|
268
384
|
generic_handler = grpc.method_handlers_generic_handler(
|
|
269
|
-
|
|
385
|
+
"chatbot.SendMessage", rpc_method_handlers
|
|
386
|
+
)
|
|
270
387
|
server.add_generic_rpc_handlers((generic_handler,))
|
|
271
|
-
server.add_registered_method_handlers(
|
|
388
|
+
server.add_registered_method_handlers("chatbot.SendMessage", rpc_method_handlers)
|
|
272
389
|
|
|
273
390
|
|
|
274
|
-
|
|
391
|
+
# This class is part of an EXPERIMENTAL API.
|
|
275
392
|
class SendMessage(object):
|
|
276
|
-
"""/// Serviços de Mensagens /////
|
|
277
|
-
"""
|
|
393
|
+
"""/// Serviços de Mensagens /////"""
|
|
278
394
|
|
|
279
395
|
@staticmethod
|
|
280
|
-
def SendMessage(
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
396
|
+
def SendMessage(
|
|
397
|
+
request,
|
|
398
|
+
target,
|
|
399
|
+
options=(),
|
|
400
|
+
channel_credentials=None,
|
|
401
|
+
call_credentials=None,
|
|
402
|
+
insecure=False,
|
|
403
|
+
compression=None,
|
|
404
|
+
wait_for_ready=None,
|
|
405
|
+
timeout=None,
|
|
406
|
+
metadata=None,
|
|
407
|
+
):
|
|
290
408
|
return grpc.experimental.unary_unary(
|
|
291
409
|
request,
|
|
292
410
|
target,
|
|
293
|
-
|
|
411
|
+
"/chatbot.SendMessage/SendMessage",
|
|
294
412
|
router__pb2.Message.SerializeToString,
|
|
295
413
|
router__pb2.RequestStatus.FromString,
|
|
296
414
|
options,
|
|
@@ -301,12 +419,102 @@ class SendMessage(object):
|
|
|
301
419
|
wait_for_ready,
|
|
302
420
|
timeout,
|
|
303
421
|
metadata,
|
|
304
|
-
_registered_method=True
|
|
422
|
+
_registered_method=True,
|
|
423
|
+
)
|
|
424
|
+
|
|
425
|
+
@staticmethod
|
|
426
|
+
def SendImage(
|
|
427
|
+
request,
|
|
428
|
+
target,
|
|
429
|
+
options=(),
|
|
430
|
+
channel_credentials=None,
|
|
431
|
+
call_credentials=None,
|
|
432
|
+
insecure=False,
|
|
433
|
+
compression=None,
|
|
434
|
+
wait_for_ready=None,
|
|
435
|
+
timeout=None,
|
|
436
|
+
metadata=None,
|
|
437
|
+
):
|
|
438
|
+
return grpc.experimental.unary_unary(
|
|
439
|
+
request,
|
|
440
|
+
target,
|
|
441
|
+
"/chatbot.SendMessage/SendImage",
|
|
442
|
+
router__pb2.FileMessage.SerializeToString,
|
|
443
|
+
router__pb2.RequestStatus.FromString,
|
|
444
|
+
options,
|
|
445
|
+
channel_credentials,
|
|
446
|
+
insecure,
|
|
447
|
+
call_credentials,
|
|
448
|
+
compression,
|
|
449
|
+
wait_for_ready,
|
|
450
|
+
timeout,
|
|
451
|
+
metadata,
|
|
452
|
+
_registered_method=True,
|
|
453
|
+
)
|
|
454
|
+
|
|
455
|
+
@staticmethod
|
|
456
|
+
def SendFile(
|
|
457
|
+
request,
|
|
458
|
+
target,
|
|
459
|
+
options=(),
|
|
460
|
+
channel_credentials=None,
|
|
461
|
+
call_credentials=None,
|
|
462
|
+
insecure=False,
|
|
463
|
+
compression=None,
|
|
464
|
+
wait_for_ready=None,
|
|
465
|
+
timeout=None,
|
|
466
|
+
metadata=None,
|
|
467
|
+
):
|
|
468
|
+
return grpc.experimental.unary_unary(
|
|
469
|
+
request,
|
|
470
|
+
target,
|
|
471
|
+
"/chatbot.SendMessage/SendFile",
|
|
472
|
+
router__pb2.FileMessage.SerializeToString,
|
|
473
|
+
router__pb2.RequestStatus.FromString,
|
|
474
|
+
options,
|
|
475
|
+
channel_credentials,
|
|
476
|
+
insecure,
|
|
477
|
+
call_credentials,
|
|
478
|
+
compression,
|
|
479
|
+
wait_for_ready,
|
|
480
|
+
timeout,
|
|
481
|
+
metadata,
|
|
482
|
+
_registered_method=True,
|
|
483
|
+
)
|
|
484
|
+
|
|
485
|
+
@staticmethod
|
|
486
|
+
def UploadFile(
|
|
487
|
+
request,
|
|
488
|
+
target,
|
|
489
|
+
options=(),
|
|
490
|
+
channel_credentials=None,
|
|
491
|
+
call_credentials=None,
|
|
492
|
+
insecure=False,
|
|
493
|
+
compression=None,
|
|
494
|
+
wait_for_ready=None,
|
|
495
|
+
timeout=None,
|
|
496
|
+
metadata=None,
|
|
497
|
+
):
|
|
498
|
+
return grpc.experimental.unary_unary(
|
|
499
|
+
request,
|
|
500
|
+
target,
|
|
501
|
+
"/chatbot.SendMessage/UploadFile",
|
|
502
|
+
router__pb2.UploadFileRequest.SerializeToString,
|
|
503
|
+
router__pb2.RequestStatus.FromString,
|
|
504
|
+
options,
|
|
505
|
+
channel_credentials,
|
|
506
|
+
insecure,
|
|
507
|
+
call_credentials,
|
|
508
|
+
compression,
|
|
509
|
+
wait_for_ready,
|
|
510
|
+
timeout,
|
|
511
|
+
metadata,
|
|
512
|
+
_registered_method=True,
|
|
513
|
+
)
|
|
305
514
|
|
|
306
515
|
|
|
307
516
|
class TransferStub(object):
|
|
308
|
-
"""/// Serviços de Transfer /////
|
|
309
|
-
"""
|
|
517
|
+
"""/// Serviços de Transfer /////"""
|
|
310
518
|
|
|
311
519
|
def __init__(self, channel):
|
|
312
520
|
"""Constructor.
|
|
@@ -315,105 +523,110 @@ class TransferStub(object):
|
|
|
315
523
|
channel: A grpc.Channel.
|
|
316
524
|
"""
|
|
317
525
|
self.GetAllCampaigns = channel.unary_unary(
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
526
|
+
"/chatbot.Transfer/GetAllCampaigns",
|
|
527
|
+
request_serializer=router__pb2.Void.SerializeToString,
|
|
528
|
+
response_deserializer=router__pb2.CampaignsList.FromString,
|
|
529
|
+
_registered_method=True,
|
|
530
|
+
)
|
|
322
531
|
self.GetCampaignID = channel.unary_unary(
|
|
323
|
-
|
|
324
|
-
|
|
325
|
-
|
|
326
|
-
|
|
532
|
+
"/chatbot.Transfer/GetCampaignID",
|
|
533
|
+
request_serializer=router__pb2.CampaignName.SerializeToString,
|
|
534
|
+
response_deserializer=router__pb2.CampaignDetails.FromString,
|
|
535
|
+
_registered_method=True,
|
|
536
|
+
)
|
|
327
537
|
self.TransferToHuman = channel.unary_unary(
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
|
|
331
|
-
|
|
538
|
+
"/chatbot.Transfer/TransferToHuman",
|
|
539
|
+
request_serializer=router__pb2.TransferToHumanRequest.SerializeToString,
|
|
540
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
541
|
+
_registered_method=True,
|
|
542
|
+
)
|
|
332
543
|
self.TransferToMenu = channel.unary_unary(
|
|
333
|
-
|
|
334
|
-
|
|
335
|
-
|
|
336
|
-
|
|
544
|
+
"/chatbot.Transfer/TransferToMenu",
|
|
545
|
+
request_serializer=router__pb2.TransferToMenuRequest.SerializeToString,
|
|
546
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
547
|
+
_registered_method=True,
|
|
548
|
+
)
|
|
337
549
|
|
|
338
550
|
|
|
339
551
|
class TransferServicer(object):
|
|
340
|
-
"""/// Serviços de Transfer /////
|
|
341
|
-
"""
|
|
552
|
+
"""/// Serviços de Transfer /////"""
|
|
342
553
|
|
|
343
554
|
def GetAllCampaigns(self, request, context):
|
|
344
555
|
"""Missing associated documentation comment in .proto file."""
|
|
345
556
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
346
|
-
context.set_details(
|
|
347
|
-
raise NotImplementedError(
|
|
557
|
+
context.set_details("Method not implemented!")
|
|
558
|
+
raise NotImplementedError("Method not implemented!")
|
|
348
559
|
|
|
349
560
|
def GetCampaignID(self, request, context):
|
|
350
561
|
"""Missing associated documentation comment in .proto file."""
|
|
351
562
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
352
|
-
context.set_details(
|
|
353
|
-
raise NotImplementedError(
|
|
563
|
+
context.set_details("Method not implemented!")
|
|
564
|
+
raise NotImplementedError("Method not implemented!")
|
|
354
565
|
|
|
355
566
|
def TransferToHuman(self, request, context):
|
|
356
567
|
"""Missing associated documentation comment in .proto file."""
|
|
357
568
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
358
|
-
context.set_details(
|
|
359
|
-
raise NotImplementedError(
|
|
569
|
+
context.set_details("Method not implemented!")
|
|
570
|
+
raise NotImplementedError("Method not implemented!")
|
|
360
571
|
|
|
361
572
|
def TransferToMenu(self, request, context):
|
|
362
573
|
"""Missing associated documentation comment in .proto file."""
|
|
363
574
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
364
|
-
context.set_details(
|
|
365
|
-
raise NotImplementedError(
|
|
575
|
+
context.set_details("Method not implemented!")
|
|
576
|
+
raise NotImplementedError("Method not implemented!")
|
|
366
577
|
|
|
367
578
|
|
|
368
579
|
def add_TransferServicer_to_server(servicer, server):
|
|
369
580
|
rpc_method_handlers = {
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
|
|
373
|
-
|
|
374
|
-
|
|
375
|
-
|
|
376
|
-
|
|
377
|
-
|
|
378
|
-
|
|
379
|
-
|
|
380
|
-
|
|
381
|
-
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
385
|
-
|
|
386
|
-
|
|
387
|
-
|
|
388
|
-
|
|
389
|
-
|
|
581
|
+
"GetAllCampaigns": grpc.unary_unary_rpc_method_handler(
|
|
582
|
+
servicer.GetAllCampaigns,
|
|
583
|
+
request_deserializer=router__pb2.Void.FromString,
|
|
584
|
+
response_serializer=router__pb2.CampaignsList.SerializeToString,
|
|
585
|
+
),
|
|
586
|
+
"GetCampaignID": grpc.unary_unary_rpc_method_handler(
|
|
587
|
+
servicer.GetCampaignID,
|
|
588
|
+
request_deserializer=router__pb2.CampaignName.FromString,
|
|
589
|
+
response_serializer=router__pb2.CampaignDetails.SerializeToString,
|
|
590
|
+
),
|
|
591
|
+
"TransferToHuman": grpc.unary_unary_rpc_method_handler(
|
|
592
|
+
servicer.TransferToHuman,
|
|
593
|
+
request_deserializer=router__pb2.TransferToHumanRequest.FromString,
|
|
594
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
595
|
+
),
|
|
596
|
+
"TransferToMenu": grpc.unary_unary_rpc_method_handler(
|
|
597
|
+
servicer.TransferToMenu,
|
|
598
|
+
request_deserializer=router__pb2.TransferToMenuRequest.FromString,
|
|
599
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
600
|
+
),
|
|
390
601
|
}
|
|
391
602
|
generic_handler = grpc.method_handlers_generic_handler(
|
|
392
|
-
|
|
603
|
+
"chatbot.Transfer", rpc_method_handlers
|
|
604
|
+
)
|
|
393
605
|
server.add_generic_rpc_handlers((generic_handler,))
|
|
394
|
-
server.add_registered_method_handlers(
|
|
606
|
+
server.add_registered_method_handlers("chatbot.Transfer", rpc_method_handlers)
|
|
395
607
|
|
|
396
608
|
|
|
397
|
-
|
|
609
|
+
# This class is part of an EXPERIMENTAL API.
|
|
398
610
|
class Transfer(object):
|
|
399
|
-
"""/// Serviços de Transfer /////
|
|
400
|
-
"""
|
|
611
|
+
"""/// Serviços de Transfer /////"""
|
|
401
612
|
|
|
402
613
|
@staticmethod
|
|
403
|
-
def GetAllCampaigns(
|
|
404
|
-
|
|
405
|
-
|
|
406
|
-
|
|
407
|
-
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
|
|
411
|
-
|
|
412
|
-
|
|
614
|
+
def GetAllCampaigns(
|
|
615
|
+
request,
|
|
616
|
+
target,
|
|
617
|
+
options=(),
|
|
618
|
+
channel_credentials=None,
|
|
619
|
+
call_credentials=None,
|
|
620
|
+
insecure=False,
|
|
621
|
+
compression=None,
|
|
622
|
+
wait_for_ready=None,
|
|
623
|
+
timeout=None,
|
|
624
|
+
metadata=None,
|
|
625
|
+
):
|
|
413
626
|
return grpc.experimental.unary_unary(
|
|
414
627
|
request,
|
|
415
628
|
target,
|
|
416
|
-
|
|
629
|
+
"/chatbot.Transfer/GetAllCampaigns",
|
|
417
630
|
router__pb2.Void.SerializeToString,
|
|
418
631
|
router__pb2.CampaignsList.FromString,
|
|
419
632
|
options,
|
|
@@ -424,23 +637,26 @@ class Transfer(object):
|
|
|
424
637
|
wait_for_ready,
|
|
425
638
|
timeout,
|
|
426
639
|
metadata,
|
|
427
|
-
_registered_method=True
|
|
640
|
+
_registered_method=True,
|
|
641
|
+
)
|
|
428
642
|
|
|
429
643
|
@staticmethod
|
|
430
|
-
def GetCampaignID(
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
|
|
435
|
-
|
|
436
|
-
|
|
437
|
-
|
|
438
|
-
|
|
439
|
-
|
|
644
|
+
def GetCampaignID(
|
|
645
|
+
request,
|
|
646
|
+
target,
|
|
647
|
+
options=(),
|
|
648
|
+
channel_credentials=None,
|
|
649
|
+
call_credentials=None,
|
|
650
|
+
insecure=False,
|
|
651
|
+
compression=None,
|
|
652
|
+
wait_for_ready=None,
|
|
653
|
+
timeout=None,
|
|
654
|
+
metadata=None,
|
|
655
|
+
):
|
|
440
656
|
return grpc.experimental.unary_unary(
|
|
441
657
|
request,
|
|
442
658
|
target,
|
|
443
|
-
|
|
659
|
+
"/chatbot.Transfer/GetCampaignID",
|
|
444
660
|
router__pb2.CampaignName.SerializeToString,
|
|
445
661
|
router__pb2.CampaignDetails.FromString,
|
|
446
662
|
options,
|
|
@@ -451,23 +667,26 @@ class Transfer(object):
|
|
|
451
667
|
wait_for_ready,
|
|
452
668
|
timeout,
|
|
453
669
|
metadata,
|
|
454
|
-
_registered_method=True
|
|
670
|
+
_registered_method=True,
|
|
671
|
+
)
|
|
455
672
|
|
|
456
673
|
@staticmethod
|
|
457
|
-
def TransferToHuman(
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
|
|
466
|
-
|
|
674
|
+
def TransferToHuman(
|
|
675
|
+
request,
|
|
676
|
+
target,
|
|
677
|
+
options=(),
|
|
678
|
+
channel_credentials=None,
|
|
679
|
+
call_credentials=None,
|
|
680
|
+
insecure=False,
|
|
681
|
+
compression=None,
|
|
682
|
+
wait_for_ready=None,
|
|
683
|
+
timeout=None,
|
|
684
|
+
metadata=None,
|
|
685
|
+
):
|
|
467
686
|
return grpc.experimental.unary_unary(
|
|
468
687
|
request,
|
|
469
688
|
target,
|
|
470
|
-
|
|
689
|
+
"/chatbot.Transfer/TransferToHuman",
|
|
471
690
|
router__pb2.TransferToHumanRequest.SerializeToString,
|
|
472
691
|
router__pb2.RequestStatus.FromString,
|
|
473
692
|
options,
|
|
@@ -478,23 +697,26 @@ class Transfer(object):
|
|
|
478
697
|
wait_for_ready,
|
|
479
698
|
timeout,
|
|
480
699
|
metadata,
|
|
481
|
-
_registered_method=True
|
|
700
|
+
_registered_method=True,
|
|
701
|
+
)
|
|
482
702
|
|
|
483
703
|
@staticmethod
|
|
484
|
-
def TransferToMenu(
|
|
485
|
-
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
493
|
-
|
|
704
|
+
def TransferToMenu(
|
|
705
|
+
request,
|
|
706
|
+
target,
|
|
707
|
+
options=(),
|
|
708
|
+
channel_credentials=None,
|
|
709
|
+
call_credentials=None,
|
|
710
|
+
insecure=False,
|
|
711
|
+
compression=None,
|
|
712
|
+
wait_for_ready=None,
|
|
713
|
+
timeout=None,
|
|
714
|
+
metadata=None,
|
|
715
|
+
):
|
|
494
716
|
return grpc.experimental.unary_unary(
|
|
495
717
|
request,
|
|
496
718
|
target,
|
|
497
|
-
|
|
719
|
+
"/chatbot.Transfer/TransferToMenu",
|
|
498
720
|
router__pb2.TransferToMenuRequest.SerializeToString,
|
|
499
721
|
router__pb2.RequestStatus.FromString,
|
|
500
722
|
options,
|
|
@@ -505,12 +727,12 @@ class Transfer(object):
|
|
|
505
727
|
wait_for_ready,
|
|
506
728
|
timeout,
|
|
507
729
|
metadata,
|
|
508
|
-
_registered_method=True
|
|
730
|
+
_registered_method=True,
|
|
731
|
+
)
|
|
509
732
|
|
|
510
733
|
|
|
511
734
|
class EndChatStub(object):
|
|
512
|
-
"""/// Serviços de EndChat /////
|
|
513
|
-
"""
|
|
735
|
+
"""/// Serviços de EndChat /////"""
|
|
514
736
|
|
|
515
737
|
def __init__(self, channel):
|
|
516
738
|
"""Constructor.
|
|
@@ -519,89 +741,93 @@ class EndChatStub(object):
|
|
|
519
741
|
channel: A grpc.Channel.
|
|
520
742
|
"""
|
|
521
743
|
self.GetAllTabulations = channel.unary_unary(
|
|
522
|
-
|
|
523
|
-
|
|
524
|
-
|
|
525
|
-
|
|
744
|
+
"/chatbot.EndChat/GetAllTabulations",
|
|
745
|
+
request_serializer=router__pb2.Void.SerializeToString,
|
|
746
|
+
response_deserializer=router__pb2.TabulationsList.FromString,
|
|
747
|
+
_registered_method=True,
|
|
748
|
+
)
|
|
526
749
|
self.GetTabulationID = channel.unary_unary(
|
|
527
|
-
|
|
528
|
-
|
|
529
|
-
|
|
530
|
-
|
|
750
|
+
"/chatbot.EndChat/GetTabulationID",
|
|
751
|
+
request_serializer=router__pb2.TabulationName.SerializeToString,
|
|
752
|
+
response_deserializer=router__pb2.TabulationDetails.FromString,
|
|
753
|
+
_registered_method=True,
|
|
754
|
+
)
|
|
531
755
|
self.EndChat = channel.unary_unary(
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
|
|
535
|
-
|
|
756
|
+
"/chatbot.EndChat/EndChat",
|
|
757
|
+
request_serializer=router__pb2.EndChatRequest.SerializeToString,
|
|
758
|
+
response_deserializer=router__pb2.RequestStatus.FromString,
|
|
759
|
+
_registered_method=True,
|
|
760
|
+
)
|
|
536
761
|
|
|
537
762
|
|
|
538
763
|
class EndChatServicer(object):
|
|
539
|
-
"""/// Serviços de EndChat /////
|
|
540
|
-
"""
|
|
764
|
+
"""/// Serviços de EndChat /////"""
|
|
541
765
|
|
|
542
766
|
def GetAllTabulations(self, request, context):
|
|
543
767
|
"""Missing associated documentation comment in .proto file."""
|
|
544
768
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
545
|
-
context.set_details(
|
|
546
|
-
raise NotImplementedError(
|
|
769
|
+
context.set_details("Method not implemented!")
|
|
770
|
+
raise NotImplementedError("Method not implemented!")
|
|
547
771
|
|
|
548
772
|
def GetTabulationID(self, request, context):
|
|
549
773
|
"""Missing associated documentation comment in .proto file."""
|
|
550
774
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
551
|
-
context.set_details(
|
|
552
|
-
raise NotImplementedError(
|
|
775
|
+
context.set_details("Method not implemented!")
|
|
776
|
+
raise NotImplementedError("Method not implemented!")
|
|
553
777
|
|
|
554
778
|
def EndChat(self, request, context):
|
|
555
779
|
"""Missing associated documentation comment in .proto file."""
|
|
556
780
|
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
557
|
-
context.set_details(
|
|
558
|
-
raise NotImplementedError(
|
|
781
|
+
context.set_details("Method not implemented!")
|
|
782
|
+
raise NotImplementedError("Method not implemented!")
|
|
559
783
|
|
|
560
784
|
|
|
561
785
|
def add_EndChatServicer_to_server(servicer, server):
|
|
562
786
|
rpc_method_handlers = {
|
|
563
|
-
|
|
564
|
-
|
|
565
|
-
|
|
566
|
-
|
|
567
|
-
|
|
568
|
-
|
|
569
|
-
|
|
570
|
-
|
|
571
|
-
|
|
572
|
-
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
|
|
787
|
+
"GetAllTabulations": grpc.unary_unary_rpc_method_handler(
|
|
788
|
+
servicer.GetAllTabulations,
|
|
789
|
+
request_deserializer=router__pb2.Void.FromString,
|
|
790
|
+
response_serializer=router__pb2.TabulationsList.SerializeToString,
|
|
791
|
+
),
|
|
792
|
+
"GetTabulationID": grpc.unary_unary_rpc_method_handler(
|
|
793
|
+
servicer.GetTabulationID,
|
|
794
|
+
request_deserializer=router__pb2.TabulationName.FromString,
|
|
795
|
+
response_serializer=router__pb2.TabulationDetails.SerializeToString,
|
|
796
|
+
),
|
|
797
|
+
"EndChat": grpc.unary_unary_rpc_method_handler(
|
|
798
|
+
servicer.EndChat,
|
|
799
|
+
request_deserializer=router__pb2.EndChatRequest.FromString,
|
|
800
|
+
response_serializer=router__pb2.RequestStatus.SerializeToString,
|
|
801
|
+
),
|
|
578
802
|
}
|
|
579
803
|
generic_handler = grpc.method_handlers_generic_handler(
|
|
580
|
-
|
|
804
|
+
"chatbot.EndChat", rpc_method_handlers
|
|
805
|
+
)
|
|
581
806
|
server.add_generic_rpc_handlers((generic_handler,))
|
|
582
|
-
server.add_registered_method_handlers(
|
|
807
|
+
server.add_registered_method_handlers("chatbot.EndChat", rpc_method_handlers)
|
|
583
808
|
|
|
584
809
|
|
|
585
|
-
|
|
810
|
+
# This class is part of an EXPERIMENTAL API.
|
|
586
811
|
class EndChat(object):
|
|
587
|
-
"""/// Serviços de EndChat /////
|
|
588
|
-
"""
|
|
812
|
+
"""/// Serviços de EndChat /////"""
|
|
589
813
|
|
|
590
814
|
@staticmethod
|
|
591
|
-
def GetAllTabulations(
|
|
592
|
-
|
|
593
|
-
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
|
|
598
|
-
|
|
599
|
-
|
|
600
|
-
|
|
815
|
+
def GetAllTabulations(
|
|
816
|
+
request,
|
|
817
|
+
target,
|
|
818
|
+
options=(),
|
|
819
|
+
channel_credentials=None,
|
|
820
|
+
call_credentials=None,
|
|
821
|
+
insecure=False,
|
|
822
|
+
compression=None,
|
|
823
|
+
wait_for_ready=None,
|
|
824
|
+
timeout=None,
|
|
825
|
+
metadata=None,
|
|
826
|
+
):
|
|
601
827
|
return grpc.experimental.unary_unary(
|
|
602
828
|
request,
|
|
603
829
|
target,
|
|
604
|
-
|
|
830
|
+
"/chatbot.EndChat/GetAllTabulations",
|
|
605
831
|
router__pb2.Void.SerializeToString,
|
|
606
832
|
router__pb2.TabulationsList.FromString,
|
|
607
833
|
options,
|
|
@@ -612,23 +838,26 @@ class EndChat(object):
|
|
|
612
838
|
wait_for_ready,
|
|
613
839
|
timeout,
|
|
614
840
|
metadata,
|
|
615
|
-
_registered_method=True
|
|
841
|
+
_registered_method=True,
|
|
842
|
+
)
|
|
616
843
|
|
|
617
844
|
@staticmethod
|
|
618
|
-
def GetTabulationID(
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
|
|
622
|
-
|
|
623
|
-
|
|
624
|
-
|
|
625
|
-
|
|
626
|
-
|
|
627
|
-
|
|
845
|
+
def GetTabulationID(
|
|
846
|
+
request,
|
|
847
|
+
target,
|
|
848
|
+
options=(),
|
|
849
|
+
channel_credentials=None,
|
|
850
|
+
call_credentials=None,
|
|
851
|
+
insecure=False,
|
|
852
|
+
compression=None,
|
|
853
|
+
wait_for_ready=None,
|
|
854
|
+
timeout=None,
|
|
855
|
+
metadata=None,
|
|
856
|
+
):
|
|
628
857
|
return grpc.experimental.unary_unary(
|
|
629
858
|
request,
|
|
630
859
|
target,
|
|
631
|
-
|
|
860
|
+
"/chatbot.EndChat/GetTabulationID",
|
|
632
861
|
router__pb2.TabulationName.SerializeToString,
|
|
633
862
|
router__pb2.TabulationDetails.FromString,
|
|
634
863
|
options,
|
|
@@ -639,23 +868,26 @@ class EndChat(object):
|
|
|
639
868
|
wait_for_ready,
|
|
640
869
|
timeout,
|
|
641
870
|
metadata,
|
|
642
|
-
_registered_method=True
|
|
871
|
+
_registered_method=True,
|
|
872
|
+
)
|
|
643
873
|
|
|
644
874
|
@staticmethod
|
|
645
|
-
def EndChat(
|
|
646
|
-
|
|
647
|
-
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
|
|
651
|
-
|
|
652
|
-
|
|
653
|
-
|
|
654
|
-
|
|
875
|
+
def EndChat(
|
|
876
|
+
request,
|
|
877
|
+
target,
|
|
878
|
+
options=(),
|
|
879
|
+
channel_credentials=None,
|
|
880
|
+
call_credentials=None,
|
|
881
|
+
insecure=False,
|
|
882
|
+
compression=None,
|
|
883
|
+
wait_for_ready=None,
|
|
884
|
+
timeout=None,
|
|
885
|
+
metadata=None,
|
|
886
|
+
):
|
|
655
887
|
return grpc.experimental.unary_unary(
|
|
656
888
|
request,
|
|
657
889
|
target,
|
|
658
|
-
|
|
890
|
+
"/chatbot.EndChat/EndChat",
|
|
659
891
|
router__pb2.EndChatRequest.SerializeToString,
|
|
660
892
|
router__pb2.RequestStatus.FromString,
|
|
661
893
|
options,
|
|
@@ -666,4 +898,5 @@ class EndChat(object):
|
|
|
666
898
|
wait_for_ready,
|
|
667
899
|
timeout,
|
|
668
900
|
metadata,
|
|
669
|
-
_registered_method=True
|
|
901
|
+
_registered_method=True,
|
|
902
|
+
)
|