tidevec 0.1.0__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.
- tidevec/__init__.py +20 -0
- tidevec/client.py +602 -0
- tidevec/cortexdb_pb2.py +123 -0
- tidevec/cortexdb_pb2_grpc.py +635 -0
- tidevec/tidevec_pb2.py +123 -0
- tidevec/tidevec_pb2_grpc.py +635 -0
- tidevec-0.1.0.dist-info/METADATA +159 -0
- tidevec-0.1.0.dist-info/RECORD +9 -0
- tidevec-0.1.0.dist-info/WHEEL +4 -0
|
@@ -0,0 +1,635 @@
|
|
|
1
|
+
# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
|
|
2
|
+
"""Client and server classes corresponding to protobuf-defined services."""
|
|
3
|
+
import grpc
|
|
4
|
+
import warnings
|
|
5
|
+
|
|
6
|
+
from . import tidevec_pb2 as tidevec__pb2
|
|
7
|
+
|
|
8
|
+
GRPC_GENERATED_VERSION = '1.81.1'
|
|
9
|
+
GRPC_VERSION = grpc.__version__
|
|
10
|
+
_version_not_supported = False
|
|
11
|
+
|
|
12
|
+
try:
|
|
13
|
+
from grpc._utilities import first_version_is_lower
|
|
14
|
+
_version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
|
|
15
|
+
except ImportError:
|
|
16
|
+
_version_not_supported = True
|
|
17
|
+
|
|
18
|
+
if _version_not_supported:
|
|
19
|
+
raise RuntimeError(
|
|
20
|
+
f'The grpc package installed is at version {GRPC_VERSION},'
|
|
21
|
+
+ ' but the generated code in tidevec_pb2_grpc.py depends on'
|
|
22
|
+
+ f' grpcio>={GRPC_GENERATED_VERSION}.'
|
|
23
|
+
+ f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
|
|
24
|
+
+ f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
|
|
25
|
+
)
|
|
26
|
+
|
|
27
|
+
|
|
28
|
+
class TideVecStub:
|
|
29
|
+
"""================================================================
|
|
30
|
+
TideVec gRPC Service — single source of truth for all SDKs
|
|
31
|
+
Compiled to: C++ / Python / Go / Java
|
|
32
|
+
================================================================
|
|
33
|
+
|
|
34
|
+
"""
|
|
35
|
+
|
|
36
|
+
def __init__(self, channel):
|
|
37
|
+
"""Constructor.
|
|
38
|
+
|
|
39
|
+
Args:
|
|
40
|
+
channel: A grpc.Channel.
|
|
41
|
+
"""
|
|
42
|
+
self.CreateCollection = channel.unary_unary(
|
|
43
|
+
'/tidevec.v1.TideVec/CreateCollection',
|
|
44
|
+
request_serializer=tidevec__pb2.CreateCollectionRequest.SerializeToString,
|
|
45
|
+
response_deserializer=tidevec__pb2.CreateCollectionResponse.FromString,
|
|
46
|
+
_registered_method=True)
|
|
47
|
+
self.DropCollection = channel.unary_unary(
|
|
48
|
+
'/tidevec.v1.TideVec/DropCollection',
|
|
49
|
+
request_serializer=tidevec__pb2.DropCollectionRequest.SerializeToString,
|
|
50
|
+
response_deserializer=tidevec__pb2.DropCollectionResponse.FromString,
|
|
51
|
+
_registered_method=True)
|
|
52
|
+
self.GetCollection = channel.unary_unary(
|
|
53
|
+
'/tidevec.v1.TideVec/GetCollection',
|
|
54
|
+
request_serializer=tidevec__pb2.GetCollectionRequest.SerializeToString,
|
|
55
|
+
response_deserializer=tidevec__pb2.GetCollectionResponse.FromString,
|
|
56
|
+
_registered_method=True)
|
|
57
|
+
self.ListCollections = channel.unary_unary(
|
|
58
|
+
'/tidevec.v1.TideVec/ListCollections',
|
|
59
|
+
request_serializer=tidevec__pb2.ListCollectionsRequest.SerializeToString,
|
|
60
|
+
response_deserializer=tidevec__pb2.ListCollectionsResponse.FromString,
|
|
61
|
+
_registered_method=True)
|
|
62
|
+
self.UpdateTemporal = channel.unary_unary(
|
|
63
|
+
'/tidevec.v1.TideVec/UpdateTemporal',
|
|
64
|
+
request_serializer=tidevec__pb2.UpdateTemporalRequest.SerializeToString,
|
|
65
|
+
response_deserializer=tidevec__pb2.UpdateTemporalResponse.FromString,
|
|
66
|
+
_registered_method=True)
|
|
67
|
+
self.Upsert = channel.unary_unary(
|
|
68
|
+
'/tidevec.v1.TideVec/Upsert',
|
|
69
|
+
request_serializer=tidevec__pb2.UpsertRequest.SerializeToString,
|
|
70
|
+
response_deserializer=tidevec__pb2.UpsertResponse.FromString,
|
|
71
|
+
_registered_method=True)
|
|
72
|
+
self.Delete = channel.unary_unary(
|
|
73
|
+
'/tidevec.v1.TideVec/Delete',
|
|
74
|
+
request_serializer=tidevec__pb2.DeleteRequest.SerializeToString,
|
|
75
|
+
response_deserializer=tidevec__pb2.DeleteResponse.FromString,
|
|
76
|
+
_registered_method=True)
|
|
77
|
+
self.BatchUpsert = channel.stream_unary(
|
|
78
|
+
'/tidevec.v1.TideVec/BatchUpsert',
|
|
79
|
+
request_serializer=tidevec__pb2.UpsertRequest.SerializeToString,
|
|
80
|
+
response_deserializer=tidevec__pb2.UpsertResponse.FromString,
|
|
81
|
+
_registered_method=True)
|
|
82
|
+
self.Search = channel.unary_unary(
|
|
83
|
+
'/tidevec.v1.TideVec/Search',
|
|
84
|
+
request_serializer=tidevec__pb2.SearchRequest.SerializeToString,
|
|
85
|
+
response_deserializer=tidevec__pb2.SearchResponse.FromString,
|
|
86
|
+
_registered_method=True)
|
|
87
|
+
self.BatchSearch = channel.unary_unary(
|
|
88
|
+
'/tidevec.v1.TideVec/BatchSearch',
|
|
89
|
+
request_serializer=tidevec__pb2.BatchSearchRequest.SerializeToString,
|
|
90
|
+
response_deserializer=tidevec__pb2.BatchSearchResponse.FromString,
|
|
91
|
+
_registered_method=True)
|
|
92
|
+
self.SearchStream = channel.unary_stream(
|
|
93
|
+
'/tidevec.v1.TideVec/SearchStream',
|
|
94
|
+
request_serializer=tidevec__pb2.SearchRequest.SerializeToString,
|
|
95
|
+
response_deserializer=tidevec__pb2.SearchResult.FromString,
|
|
96
|
+
_registered_method=True)
|
|
97
|
+
self.AddEdges = channel.unary_unary(
|
|
98
|
+
'/tidevec.v1.TideVec/AddEdges',
|
|
99
|
+
request_serializer=tidevec__pb2.AddEdgesRequest.SerializeToString,
|
|
100
|
+
response_deserializer=tidevec__pb2.AddEdgesResponse.FromString,
|
|
101
|
+
_registered_method=True)
|
|
102
|
+
self.Health = channel.unary_unary(
|
|
103
|
+
'/tidevec.v1.TideVec/Health',
|
|
104
|
+
request_serializer=tidevec__pb2.HealthRequest.SerializeToString,
|
|
105
|
+
response_deserializer=tidevec__pb2.HealthResponse.FromString,
|
|
106
|
+
_registered_method=True)
|
|
107
|
+
|
|
108
|
+
|
|
109
|
+
class TideVecServicer:
|
|
110
|
+
"""================================================================
|
|
111
|
+
TideVec gRPC Service — single source of truth for all SDKs
|
|
112
|
+
Compiled to: C++ / Python / Go / Java
|
|
113
|
+
================================================================
|
|
114
|
+
|
|
115
|
+
"""
|
|
116
|
+
|
|
117
|
+
def CreateCollection(self, request, context):
|
|
118
|
+
"""---- Collections ----
|
|
119
|
+
"""
|
|
120
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
121
|
+
context.set_details('Method not implemented!')
|
|
122
|
+
raise NotImplementedError('Method not implemented!')
|
|
123
|
+
|
|
124
|
+
def DropCollection(self, request, context):
|
|
125
|
+
"""Missing associated documentation comment in .proto file."""
|
|
126
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
127
|
+
context.set_details('Method not implemented!')
|
|
128
|
+
raise NotImplementedError('Method not implemented!')
|
|
129
|
+
|
|
130
|
+
def GetCollection(self, request, context):
|
|
131
|
+
"""Missing associated documentation comment in .proto file."""
|
|
132
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
133
|
+
context.set_details('Method not implemented!')
|
|
134
|
+
raise NotImplementedError('Method not implemented!')
|
|
135
|
+
|
|
136
|
+
def ListCollections(self, request, context):
|
|
137
|
+
"""Missing associated documentation comment in .proto file."""
|
|
138
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
139
|
+
context.set_details('Method not implemented!')
|
|
140
|
+
raise NotImplementedError('Method not implemented!')
|
|
141
|
+
|
|
142
|
+
def UpdateTemporal(self, request, context):
|
|
143
|
+
"""Missing associated documentation comment in .proto file."""
|
|
144
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
145
|
+
context.set_details('Method not implemented!')
|
|
146
|
+
raise NotImplementedError('Method not implemented!')
|
|
147
|
+
|
|
148
|
+
def Upsert(self, request, context):
|
|
149
|
+
"""---- Vectors ----
|
|
150
|
+
"""
|
|
151
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
152
|
+
context.set_details('Method not implemented!')
|
|
153
|
+
raise NotImplementedError('Method not implemented!')
|
|
154
|
+
|
|
155
|
+
def Delete(self, request, context):
|
|
156
|
+
"""Missing associated documentation comment in .proto file."""
|
|
157
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
158
|
+
context.set_details('Method not implemented!')
|
|
159
|
+
raise NotImplementedError('Method not implemented!')
|
|
160
|
+
|
|
161
|
+
def BatchUpsert(self, request_iterator, context):
|
|
162
|
+
"""client streaming
|
|
163
|
+
"""
|
|
164
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
165
|
+
context.set_details('Method not implemented!')
|
|
166
|
+
raise NotImplementedError('Method not implemented!')
|
|
167
|
+
|
|
168
|
+
def Search(self, request, context):
|
|
169
|
+
"""---- Search ----
|
|
170
|
+
"""
|
|
171
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
172
|
+
context.set_details('Method not implemented!')
|
|
173
|
+
raise NotImplementedError('Method not implemented!')
|
|
174
|
+
|
|
175
|
+
def BatchSearch(self, request, context):
|
|
176
|
+
"""Missing associated documentation comment in .proto file."""
|
|
177
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
178
|
+
context.set_details('Method not implemented!')
|
|
179
|
+
raise NotImplementedError('Method not implemented!')
|
|
180
|
+
|
|
181
|
+
def SearchStream(self, request, context):
|
|
182
|
+
"""server streaming
|
|
183
|
+
"""
|
|
184
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
185
|
+
context.set_details('Method not implemented!')
|
|
186
|
+
raise NotImplementedError('Method not implemented!')
|
|
187
|
+
|
|
188
|
+
def AddEdges(self, request, context):
|
|
189
|
+
"""---- Graph ----
|
|
190
|
+
"""
|
|
191
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
192
|
+
context.set_details('Method not implemented!')
|
|
193
|
+
raise NotImplementedError('Method not implemented!')
|
|
194
|
+
|
|
195
|
+
def Health(self, request, context):
|
|
196
|
+
"""---- Health ----
|
|
197
|
+
"""
|
|
198
|
+
context.set_code(grpc.StatusCode.UNIMPLEMENTED)
|
|
199
|
+
context.set_details('Method not implemented!')
|
|
200
|
+
raise NotImplementedError('Method not implemented!')
|
|
201
|
+
|
|
202
|
+
|
|
203
|
+
def add_TideVecServicer_to_server(servicer, server):
|
|
204
|
+
rpc_method_handlers = {
|
|
205
|
+
'CreateCollection': grpc.unary_unary_rpc_method_handler(
|
|
206
|
+
servicer.CreateCollection,
|
|
207
|
+
request_deserializer=tidevec__pb2.CreateCollectionRequest.FromString,
|
|
208
|
+
response_serializer=tidevec__pb2.CreateCollectionResponse.SerializeToString,
|
|
209
|
+
),
|
|
210
|
+
'DropCollection': grpc.unary_unary_rpc_method_handler(
|
|
211
|
+
servicer.DropCollection,
|
|
212
|
+
request_deserializer=tidevec__pb2.DropCollectionRequest.FromString,
|
|
213
|
+
response_serializer=tidevec__pb2.DropCollectionResponse.SerializeToString,
|
|
214
|
+
),
|
|
215
|
+
'GetCollection': grpc.unary_unary_rpc_method_handler(
|
|
216
|
+
servicer.GetCollection,
|
|
217
|
+
request_deserializer=tidevec__pb2.GetCollectionRequest.FromString,
|
|
218
|
+
response_serializer=tidevec__pb2.GetCollectionResponse.SerializeToString,
|
|
219
|
+
),
|
|
220
|
+
'ListCollections': grpc.unary_unary_rpc_method_handler(
|
|
221
|
+
servicer.ListCollections,
|
|
222
|
+
request_deserializer=tidevec__pb2.ListCollectionsRequest.FromString,
|
|
223
|
+
response_serializer=tidevec__pb2.ListCollectionsResponse.SerializeToString,
|
|
224
|
+
),
|
|
225
|
+
'UpdateTemporal': grpc.unary_unary_rpc_method_handler(
|
|
226
|
+
servicer.UpdateTemporal,
|
|
227
|
+
request_deserializer=tidevec__pb2.UpdateTemporalRequest.FromString,
|
|
228
|
+
response_serializer=tidevec__pb2.UpdateTemporalResponse.SerializeToString,
|
|
229
|
+
),
|
|
230
|
+
'Upsert': grpc.unary_unary_rpc_method_handler(
|
|
231
|
+
servicer.Upsert,
|
|
232
|
+
request_deserializer=tidevec__pb2.UpsertRequest.FromString,
|
|
233
|
+
response_serializer=tidevec__pb2.UpsertResponse.SerializeToString,
|
|
234
|
+
),
|
|
235
|
+
'Delete': grpc.unary_unary_rpc_method_handler(
|
|
236
|
+
servicer.Delete,
|
|
237
|
+
request_deserializer=tidevec__pb2.DeleteRequest.FromString,
|
|
238
|
+
response_serializer=tidevec__pb2.DeleteResponse.SerializeToString,
|
|
239
|
+
),
|
|
240
|
+
'BatchUpsert': grpc.stream_unary_rpc_method_handler(
|
|
241
|
+
servicer.BatchUpsert,
|
|
242
|
+
request_deserializer=tidevec__pb2.UpsertRequest.FromString,
|
|
243
|
+
response_serializer=tidevec__pb2.UpsertResponse.SerializeToString,
|
|
244
|
+
),
|
|
245
|
+
'Search': grpc.unary_unary_rpc_method_handler(
|
|
246
|
+
servicer.Search,
|
|
247
|
+
request_deserializer=tidevec__pb2.SearchRequest.FromString,
|
|
248
|
+
response_serializer=tidevec__pb2.SearchResponse.SerializeToString,
|
|
249
|
+
),
|
|
250
|
+
'BatchSearch': grpc.unary_unary_rpc_method_handler(
|
|
251
|
+
servicer.BatchSearch,
|
|
252
|
+
request_deserializer=tidevec__pb2.BatchSearchRequest.FromString,
|
|
253
|
+
response_serializer=tidevec__pb2.BatchSearchResponse.SerializeToString,
|
|
254
|
+
),
|
|
255
|
+
'SearchStream': grpc.unary_stream_rpc_method_handler(
|
|
256
|
+
servicer.SearchStream,
|
|
257
|
+
request_deserializer=tidevec__pb2.SearchRequest.FromString,
|
|
258
|
+
response_serializer=tidevec__pb2.SearchResult.SerializeToString,
|
|
259
|
+
),
|
|
260
|
+
'AddEdges': grpc.unary_unary_rpc_method_handler(
|
|
261
|
+
servicer.AddEdges,
|
|
262
|
+
request_deserializer=tidevec__pb2.AddEdgesRequest.FromString,
|
|
263
|
+
response_serializer=tidevec__pb2.AddEdgesResponse.SerializeToString,
|
|
264
|
+
),
|
|
265
|
+
'Health': grpc.unary_unary_rpc_method_handler(
|
|
266
|
+
servicer.Health,
|
|
267
|
+
request_deserializer=tidevec__pb2.HealthRequest.FromString,
|
|
268
|
+
response_serializer=tidevec__pb2.HealthResponse.SerializeToString,
|
|
269
|
+
),
|
|
270
|
+
}
|
|
271
|
+
generic_handler = grpc.method_handlers_generic_handler(
|
|
272
|
+
'tidevec.v1.TideVec', rpc_method_handlers)
|
|
273
|
+
server.add_generic_rpc_handlers((generic_handler,))
|
|
274
|
+
server.add_registered_method_handlers('tidevec.v1.TideVec', rpc_method_handlers)
|
|
275
|
+
|
|
276
|
+
|
|
277
|
+
# This class is part of an EXPERIMENTAL API.
|
|
278
|
+
class TideVec:
|
|
279
|
+
"""================================================================
|
|
280
|
+
TideVec gRPC Service — single source of truth for all SDKs
|
|
281
|
+
Compiled to: C++ / Python / Go / Java
|
|
282
|
+
================================================================
|
|
283
|
+
|
|
284
|
+
"""
|
|
285
|
+
|
|
286
|
+
@staticmethod
|
|
287
|
+
def CreateCollection(request,
|
|
288
|
+
target,
|
|
289
|
+
options=(),
|
|
290
|
+
channel_credentials=None,
|
|
291
|
+
call_credentials=None,
|
|
292
|
+
insecure=False,
|
|
293
|
+
compression=None,
|
|
294
|
+
wait_for_ready=None,
|
|
295
|
+
timeout=None,
|
|
296
|
+
metadata=None):
|
|
297
|
+
return grpc.experimental.unary_unary(
|
|
298
|
+
request,
|
|
299
|
+
target,
|
|
300
|
+
'/tidevec.v1.TideVec/CreateCollection',
|
|
301
|
+
tidevec__pb2.CreateCollectionRequest.SerializeToString,
|
|
302
|
+
tidevec__pb2.CreateCollectionResponse.FromString,
|
|
303
|
+
options,
|
|
304
|
+
channel_credentials,
|
|
305
|
+
insecure,
|
|
306
|
+
call_credentials,
|
|
307
|
+
compression,
|
|
308
|
+
wait_for_ready,
|
|
309
|
+
timeout,
|
|
310
|
+
metadata,
|
|
311
|
+
_registered_method=True)
|
|
312
|
+
|
|
313
|
+
@staticmethod
|
|
314
|
+
def DropCollection(request,
|
|
315
|
+
target,
|
|
316
|
+
options=(),
|
|
317
|
+
channel_credentials=None,
|
|
318
|
+
call_credentials=None,
|
|
319
|
+
insecure=False,
|
|
320
|
+
compression=None,
|
|
321
|
+
wait_for_ready=None,
|
|
322
|
+
timeout=None,
|
|
323
|
+
metadata=None):
|
|
324
|
+
return grpc.experimental.unary_unary(
|
|
325
|
+
request,
|
|
326
|
+
target,
|
|
327
|
+
'/tidevec.v1.TideVec/DropCollection',
|
|
328
|
+
tidevec__pb2.DropCollectionRequest.SerializeToString,
|
|
329
|
+
tidevec__pb2.DropCollectionResponse.FromString,
|
|
330
|
+
options,
|
|
331
|
+
channel_credentials,
|
|
332
|
+
insecure,
|
|
333
|
+
call_credentials,
|
|
334
|
+
compression,
|
|
335
|
+
wait_for_ready,
|
|
336
|
+
timeout,
|
|
337
|
+
metadata,
|
|
338
|
+
_registered_method=True)
|
|
339
|
+
|
|
340
|
+
@staticmethod
|
|
341
|
+
def GetCollection(request,
|
|
342
|
+
target,
|
|
343
|
+
options=(),
|
|
344
|
+
channel_credentials=None,
|
|
345
|
+
call_credentials=None,
|
|
346
|
+
insecure=False,
|
|
347
|
+
compression=None,
|
|
348
|
+
wait_for_ready=None,
|
|
349
|
+
timeout=None,
|
|
350
|
+
metadata=None):
|
|
351
|
+
return grpc.experimental.unary_unary(
|
|
352
|
+
request,
|
|
353
|
+
target,
|
|
354
|
+
'/tidevec.v1.TideVec/GetCollection',
|
|
355
|
+
tidevec__pb2.GetCollectionRequest.SerializeToString,
|
|
356
|
+
tidevec__pb2.GetCollectionResponse.FromString,
|
|
357
|
+
options,
|
|
358
|
+
channel_credentials,
|
|
359
|
+
insecure,
|
|
360
|
+
call_credentials,
|
|
361
|
+
compression,
|
|
362
|
+
wait_for_ready,
|
|
363
|
+
timeout,
|
|
364
|
+
metadata,
|
|
365
|
+
_registered_method=True)
|
|
366
|
+
|
|
367
|
+
@staticmethod
|
|
368
|
+
def ListCollections(request,
|
|
369
|
+
target,
|
|
370
|
+
options=(),
|
|
371
|
+
channel_credentials=None,
|
|
372
|
+
call_credentials=None,
|
|
373
|
+
insecure=False,
|
|
374
|
+
compression=None,
|
|
375
|
+
wait_for_ready=None,
|
|
376
|
+
timeout=None,
|
|
377
|
+
metadata=None):
|
|
378
|
+
return grpc.experimental.unary_unary(
|
|
379
|
+
request,
|
|
380
|
+
target,
|
|
381
|
+
'/tidevec.v1.TideVec/ListCollections',
|
|
382
|
+
tidevec__pb2.ListCollectionsRequest.SerializeToString,
|
|
383
|
+
tidevec__pb2.ListCollectionsResponse.FromString,
|
|
384
|
+
options,
|
|
385
|
+
channel_credentials,
|
|
386
|
+
insecure,
|
|
387
|
+
call_credentials,
|
|
388
|
+
compression,
|
|
389
|
+
wait_for_ready,
|
|
390
|
+
timeout,
|
|
391
|
+
metadata,
|
|
392
|
+
_registered_method=True)
|
|
393
|
+
|
|
394
|
+
@staticmethod
|
|
395
|
+
def UpdateTemporal(request,
|
|
396
|
+
target,
|
|
397
|
+
options=(),
|
|
398
|
+
channel_credentials=None,
|
|
399
|
+
call_credentials=None,
|
|
400
|
+
insecure=False,
|
|
401
|
+
compression=None,
|
|
402
|
+
wait_for_ready=None,
|
|
403
|
+
timeout=None,
|
|
404
|
+
metadata=None):
|
|
405
|
+
return grpc.experimental.unary_unary(
|
|
406
|
+
request,
|
|
407
|
+
target,
|
|
408
|
+
'/tidevec.v1.TideVec/UpdateTemporal',
|
|
409
|
+
tidevec__pb2.UpdateTemporalRequest.SerializeToString,
|
|
410
|
+
tidevec__pb2.UpdateTemporalResponse.FromString,
|
|
411
|
+
options,
|
|
412
|
+
channel_credentials,
|
|
413
|
+
insecure,
|
|
414
|
+
call_credentials,
|
|
415
|
+
compression,
|
|
416
|
+
wait_for_ready,
|
|
417
|
+
timeout,
|
|
418
|
+
metadata,
|
|
419
|
+
_registered_method=True)
|
|
420
|
+
|
|
421
|
+
@staticmethod
|
|
422
|
+
def Upsert(request,
|
|
423
|
+
target,
|
|
424
|
+
options=(),
|
|
425
|
+
channel_credentials=None,
|
|
426
|
+
call_credentials=None,
|
|
427
|
+
insecure=False,
|
|
428
|
+
compression=None,
|
|
429
|
+
wait_for_ready=None,
|
|
430
|
+
timeout=None,
|
|
431
|
+
metadata=None):
|
|
432
|
+
return grpc.experimental.unary_unary(
|
|
433
|
+
request,
|
|
434
|
+
target,
|
|
435
|
+
'/tidevec.v1.TideVec/Upsert',
|
|
436
|
+
tidevec__pb2.UpsertRequest.SerializeToString,
|
|
437
|
+
tidevec__pb2.UpsertResponse.FromString,
|
|
438
|
+
options,
|
|
439
|
+
channel_credentials,
|
|
440
|
+
insecure,
|
|
441
|
+
call_credentials,
|
|
442
|
+
compression,
|
|
443
|
+
wait_for_ready,
|
|
444
|
+
timeout,
|
|
445
|
+
metadata,
|
|
446
|
+
_registered_method=True)
|
|
447
|
+
|
|
448
|
+
@staticmethod
|
|
449
|
+
def Delete(request,
|
|
450
|
+
target,
|
|
451
|
+
options=(),
|
|
452
|
+
channel_credentials=None,
|
|
453
|
+
call_credentials=None,
|
|
454
|
+
insecure=False,
|
|
455
|
+
compression=None,
|
|
456
|
+
wait_for_ready=None,
|
|
457
|
+
timeout=None,
|
|
458
|
+
metadata=None):
|
|
459
|
+
return grpc.experimental.unary_unary(
|
|
460
|
+
request,
|
|
461
|
+
target,
|
|
462
|
+
'/tidevec.v1.TideVec/Delete',
|
|
463
|
+
tidevec__pb2.DeleteRequest.SerializeToString,
|
|
464
|
+
tidevec__pb2.DeleteResponse.FromString,
|
|
465
|
+
options,
|
|
466
|
+
channel_credentials,
|
|
467
|
+
insecure,
|
|
468
|
+
call_credentials,
|
|
469
|
+
compression,
|
|
470
|
+
wait_for_ready,
|
|
471
|
+
timeout,
|
|
472
|
+
metadata,
|
|
473
|
+
_registered_method=True)
|
|
474
|
+
|
|
475
|
+
@staticmethod
|
|
476
|
+
def BatchUpsert(request_iterator,
|
|
477
|
+
target,
|
|
478
|
+
options=(),
|
|
479
|
+
channel_credentials=None,
|
|
480
|
+
call_credentials=None,
|
|
481
|
+
insecure=False,
|
|
482
|
+
compression=None,
|
|
483
|
+
wait_for_ready=None,
|
|
484
|
+
timeout=None,
|
|
485
|
+
metadata=None):
|
|
486
|
+
return grpc.experimental.stream_unary(
|
|
487
|
+
request_iterator,
|
|
488
|
+
target,
|
|
489
|
+
'/tidevec.v1.TideVec/BatchUpsert',
|
|
490
|
+
tidevec__pb2.UpsertRequest.SerializeToString,
|
|
491
|
+
tidevec__pb2.UpsertResponse.FromString,
|
|
492
|
+
options,
|
|
493
|
+
channel_credentials,
|
|
494
|
+
insecure,
|
|
495
|
+
call_credentials,
|
|
496
|
+
compression,
|
|
497
|
+
wait_for_ready,
|
|
498
|
+
timeout,
|
|
499
|
+
metadata,
|
|
500
|
+
_registered_method=True)
|
|
501
|
+
|
|
502
|
+
@staticmethod
|
|
503
|
+
def Search(request,
|
|
504
|
+
target,
|
|
505
|
+
options=(),
|
|
506
|
+
channel_credentials=None,
|
|
507
|
+
call_credentials=None,
|
|
508
|
+
insecure=False,
|
|
509
|
+
compression=None,
|
|
510
|
+
wait_for_ready=None,
|
|
511
|
+
timeout=None,
|
|
512
|
+
metadata=None):
|
|
513
|
+
return grpc.experimental.unary_unary(
|
|
514
|
+
request,
|
|
515
|
+
target,
|
|
516
|
+
'/tidevec.v1.TideVec/Search',
|
|
517
|
+
tidevec__pb2.SearchRequest.SerializeToString,
|
|
518
|
+
tidevec__pb2.SearchResponse.FromString,
|
|
519
|
+
options,
|
|
520
|
+
channel_credentials,
|
|
521
|
+
insecure,
|
|
522
|
+
call_credentials,
|
|
523
|
+
compression,
|
|
524
|
+
wait_for_ready,
|
|
525
|
+
timeout,
|
|
526
|
+
metadata,
|
|
527
|
+
_registered_method=True)
|
|
528
|
+
|
|
529
|
+
@staticmethod
|
|
530
|
+
def BatchSearch(request,
|
|
531
|
+
target,
|
|
532
|
+
options=(),
|
|
533
|
+
channel_credentials=None,
|
|
534
|
+
call_credentials=None,
|
|
535
|
+
insecure=False,
|
|
536
|
+
compression=None,
|
|
537
|
+
wait_for_ready=None,
|
|
538
|
+
timeout=None,
|
|
539
|
+
metadata=None):
|
|
540
|
+
return grpc.experimental.unary_unary(
|
|
541
|
+
request,
|
|
542
|
+
target,
|
|
543
|
+
'/tidevec.v1.TideVec/BatchSearch',
|
|
544
|
+
tidevec__pb2.BatchSearchRequest.SerializeToString,
|
|
545
|
+
tidevec__pb2.BatchSearchResponse.FromString,
|
|
546
|
+
options,
|
|
547
|
+
channel_credentials,
|
|
548
|
+
insecure,
|
|
549
|
+
call_credentials,
|
|
550
|
+
compression,
|
|
551
|
+
wait_for_ready,
|
|
552
|
+
timeout,
|
|
553
|
+
metadata,
|
|
554
|
+
_registered_method=True)
|
|
555
|
+
|
|
556
|
+
@staticmethod
|
|
557
|
+
def SearchStream(request,
|
|
558
|
+
target,
|
|
559
|
+
options=(),
|
|
560
|
+
channel_credentials=None,
|
|
561
|
+
call_credentials=None,
|
|
562
|
+
insecure=False,
|
|
563
|
+
compression=None,
|
|
564
|
+
wait_for_ready=None,
|
|
565
|
+
timeout=None,
|
|
566
|
+
metadata=None):
|
|
567
|
+
return grpc.experimental.unary_stream(
|
|
568
|
+
request,
|
|
569
|
+
target,
|
|
570
|
+
'/tidevec.v1.TideVec/SearchStream',
|
|
571
|
+
tidevec__pb2.SearchRequest.SerializeToString,
|
|
572
|
+
tidevec__pb2.SearchResult.FromString,
|
|
573
|
+
options,
|
|
574
|
+
channel_credentials,
|
|
575
|
+
insecure,
|
|
576
|
+
call_credentials,
|
|
577
|
+
compression,
|
|
578
|
+
wait_for_ready,
|
|
579
|
+
timeout,
|
|
580
|
+
metadata,
|
|
581
|
+
_registered_method=True)
|
|
582
|
+
|
|
583
|
+
@staticmethod
|
|
584
|
+
def AddEdges(request,
|
|
585
|
+
target,
|
|
586
|
+
options=(),
|
|
587
|
+
channel_credentials=None,
|
|
588
|
+
call_credentials=None,
|
|
589
|
+
insecure=False,
|
|
590
|
+
compression=None,
|
|
591
|
+
wait_for_ready=None,
|
|
592
|
+
timeout=None,
|
|
593
|
+
metadata=None):
|
|
594
|
+
return grpc.experimental.unary_unary(
|
|
595
|
+
request,
|
|
596
|
+
target,
|
|
597
|
+
'/tidevec.v1.TideVec/AddEdges',
|
|
598
|
+
tidevec__pb2.AddEdgesRequest.SerializeToString,
|
|
599
|
+
tidevec__pb2.AddEdgesResponse.FromString,
|
|
600
|
+
options,
|
|
601
|
+
channel_credentials,
|
|
602
|
+
insecure,
|
|
603
|
+
call_credentials,
|
|
604
|
+
compression,
|
|
605
|
+
wait_for_ready,
|
|
606
|
+
timeout,
|
|
607
|
+
metadata,
|
|
608
|
+
_registered_method=True)
|
|
609
|
+
|
|
610
|
+
@staticmethod
|
|
611
|
+
def Health(request,
|
|
612
|
+
target,
|
|
613
|
+
options=(),
|
|
614
|
+
channel_credentials=None,
|
|
615
|
+
call_credentials=None,
|
|
616
|
+
insecure=False,
|
|
617
|
+
compression=None,
|
|
618
|
+
wait_for_ready=None,
|
|
619
|
+
timeout=None,
|
|
620
|
+
metadata=None):
|
|
621
|
+
return grpc.experimental.unary_unary(
|
|
622
|
+
request,
|
|
623
|
+
target,
|
|
624
|
+
'/tidevec.v1.TideVec/Health',
|
|
625
|
+
tidevec__pb2.HealthRequest.SerializeToString,
|
|
626
|
+
tidevec__pb2.HealthResponse.FromString,
|
|
627
|
+
options,
|
|
628
|
+
channel_credentials,
|
|
629
|
+
insecure,
|
|
630
|
+
call_credentials,
|
|
631
|
+
compression,
|
|
632
|
+
wait_for_ready,
|
|
633
|
+
timeout,
|
|
634
|
+
metadata,
|
|
635
|
+
_registered_method=True)
|