54
54
rest_version = requests_version ,
55
55
)
56
56
57
- # TODO (numeric enums): This file was generated with the option to
58
- # request that the server respond with enums JSON-encoded as
59
- # numbers. The code below does not implement that functionality yet.
60
-
61
57
62
58
class RegistryRestInterceptor :
63
59
"""Interceptor for Registry.
@@ -74,235 +70,265 @@ class RegistryRestInterceptor:
74
70
75
71
.. code-block:: python
76
72
class MyCustomRegistryInterceptor(RegistryRestInterceptor):
77
- def pre_create_api(request, metadata):
73
+ def pre_create_api(self, request, metadata):
78
74
logging.log(f"Received request: {request}")
79
75
return request, metadata
80
76
81
- def post_create_api(response):
77
+ def post_create_api(self, response):
82
78
logging.log(f"Received response: {response}")
79
+ return response
83
80
84
- def pre_create_api_deployment(request, metadata):
81
+ def pre_create_api_deployment(self, request, metadata):
85
82
logging.log(f"Received request: {request}")
86
83
return request, metadata
87
84
88
- def post_create_api_deployment(response):
85
+ def post_create_api_deployment(self, response):
89
86
logging.log(f"Received response: {response}")
87
+ return response
90
88
91
- def pre_create_api_spec(request, metadata):
89
+ def pre_create_api_spec(self, request, metadata):
92
90
logging.log(f"Received request: {request}")
93
91
return request, metadata
94
92
95
- def post_create_api_spec(response):
93
+ def post_create_api_spec(self, response):
96
94
logging.log(f"Received response: {response}")
95
+ return response
97
96
98
- def pre_create_api_version(request, metadata):
97
+ def pre_create_api_version(self, request, metadata):
99
98
logging.log(f"Received request: {request}")
100
99
return request, metadata
101
100
102
- def post_create_api_version(response):
101
+ def post_create_api_version(self, response):
103
102
logging.log(f"Received response: {response}")
103
+ return response
104
104
105
- def pre_create_artifact(request, metadata):
105
+ def pre_create_artifact(self, request, metadata):
106
106
logging.log(f"Received request: {request}")
107
107
return request, metadata
108
108
109
- def post_create_artifact(response):
109
+ def post_create_artifact(self, response):
110
110
logging.log(f"Received response: {response}")
111
+ return response
111
112
112
- def pre_delete_api(request, metadata):
113
+ def pre_delete_api(self, request, metadata):
113
114
logging.log(f"Received request: {request}")
114
115
return request, metadata
115
116
116
- def pre_delete_api_deployment(request, metadata):
117
+ def pre_delete_api_deployment(self, request, metadata):
117
118
logging.log(f"Received request: {request}")
118
119
return request, metadata
119
120
120
- def pre_delete_api_deployment_revision(request, metadata):
121
+ def pre_delete_api_deployment_revision(self, request, metadata):
121
122
logging.log(f"Received request: {request}")
122
123
return request, metadata
123
124
124
- def post_delete_api_deployment_revision(response):
125
+ def post_delete_api_deployment_revision(self, response):
125
126
logging.log(f"Received response: {response}")
127
+ return response
126
128
127
- def pre_delete_api_spec(request, metadata):
129
+ def pre_delete_api_spec(self, request, metadata):
128
130
logging.log(f"Received request: {request}")
129
131
return request, metadata
130
132
131
- def pre_delete_api_spec_revision(request, metadata):
133
+ def pre_delete_api_spec_revision(self, request, metadata):
132
134
logging.log(f"Received request: {request}")
133
135
return request, metadata
134
136
135
- def post_delete_api_spec_revision(response):
137
+ def post_delete_api_spec_revision(self, response):
136
138
logging.log(f"Received response: {response}")
139
+ return response
137
140
138
- def pre_delete_api_version(request, metadata):
141
+ def pre_delete_api_version(self, request, metadata):
139
142
logging.log(f"Received request: {request}")
140
143
return request, metadata
141
144
142
- def pre_delete_artifact(request, metadata):
145
+ def pre_delete_artifact(self, request, metadata):
143
146
logging.log(f"Received request: {request}")
144
147
return request, metadata
145
148
146
- def pre_get_api(request, metadata):
149
+ def pre_get_api(self, request, metadata):
147
150
logging.log(f"Received request: {request}")
148
151
return request, metadata
149
152
150
- def post_get_api(response):
153
+ def post_get_api(self, response):
151
154
logging.log(f"Received response: {response}")
155
+ return response
152
156
153
- def pre_get_api_deployment(request, metadata):
157
+ def pre_get_api_deployment(self, request, metadata):
154
158
logging.log(f"Received request: {request}")
155
159
return request, metadata
156
160
157
- def post_get_api_deployment(response):
161
+ def post_get_api_deployment(self, response):
158
162
logging.log(f"Received response: {response}")
163
+ return response
159
164
160
- def pre_get_api_spec(request, metadata):
165
+ def pre_get_api_spec(self, request, metadata):
161
166
logging.log(f"Received request: {request}")
162
167
return request, metadata
163
168
164
- def post_get_api_spec(response):
169
+ def post_get_api_spec(self, response):
165
170
logging.log(f"Received response: {response}")
171
+ return response
166
172
167
- def pre_get_api_spec_contents(request, metadata):
173
+ def pre_get_api_spec_contents(self, request, metadata):
168
174
logging.log(f"Received request: {request}")
169
175
return request, metadata
170
176
171
- def post_get_api_spec_contents(response):
177
+ def post_get_api_spec_contents(self, response):
172
178
logging.log(f"Received response: {response}")
179
+ return response
173
180
174
- def pre_get_api_version(request, metadata):
181
+ def pre_get_api_version(self, request, metadata):
175
182
logging.log(f"Received request: {request}")
176
183
return request, metadata
177
184
178
- def post_get_api_version(response):
185
+ def post_get_api_version(self, response):
179
186
logging.log(f"Received response: {response}")
187
+ return response
180
188
181
- def pre_get_artifact(request, metadata):
189
+ def pre_get_artifact(self, request, metadata):
182
190
logging.log(f"Received request: {request}")
183
191
return request, metadata
184
192
185
- def post_get_artifact(response):
193
+ def post_get_artifact(self, response):
186
194
logging.log(f"Received response: {response}")
195
+ return response
187
196
188
- def pre_get_artifact_contents(request, metadata):
197
+ def pre_get_artifact_contents(self, request, metadata):
189
198
logging.log(f"Received request: {request}")
190
199
return request, metadata
191
200
192
- def post_get_artifact_contents(response):
201
+ def post_get_artifact_contents(self, response):
193
202
logging.log(f"Received response: {response}")
203
+ return response
194
204
195
- def pre_list_api_deployment_revisions(request, metadata):
205
+ def pre_list_api_deployment_revisions(self, request, metadata):
196
206
logging.log(f"Received request: {request}")
197
207
return request, metadata
198
208
199
- def post_list_api_deployment_revisions(response):
209
+ def post_list_api_deployment_revisions(self, response):
200
210
logging.log(f"Received response: {response}")
211
+ return response
201
212
202
- def pre_list_api_deployments(request, metadata):
213
+ def pre_list_api_deployments(self, request, metadata):
203
214
logging.log(f"Received request: {request}")
204
215
return request, metadata
205
216
206
- def post_list_api_deployments(response):
217
+ def post_list_api_deployments(self, response):
207
218
logging.log(f"Received response: {response}")
219
+ return response
208
220
209
- def pre_list_apis(request, metadata):
221
+ def pre_list_apis(self, request, metadata):
210
222
logging.log(f"Received request: {request}")
211
223
return request, metadata
212
224
213
- def post_list_apis(response):
225
+ def post_list_apis(self, response):
214
226
logging.log(f"Received response: {response}")
227
+ return response
215
228
216
- def pre_list_api_spec_revisions(request, metadata):
229
+ def pre_list_api_spec_revisions(self, request, metadata):
217
230
logging.log(f"Received request: {request}")
218
231
return request, metadata
219
232
220
- def post_list_api_spec_revisions(response):
233
+ def post_list_api_spec_revisions(self, response):
221
234
logging.log(f"Received response: {response}")
235
+ return response
222
236
223
- def pre_list_api_specs(request, metadata):
237
+ def pre_list_api_specs(self, request, metadata):
224
238
logging.log(f"Received request: {request}")
225
239
return request, metadata
226
240
227
- def post_list_api_specs(response):
241
+ def post_list_api_specs(self, response):
228
242
logging.log(f"Received response: {response}")
243
+ return response
229
244
230
- def pre_list_api_versions(request, metadata):
245
+ def pre_list_api_versions(self, request, metadata):
231
246
logging.log(f"Received request: {request}")
232
247
return request, metadata
233
248
234
- def post_list_api_versions(response):
249
+ def post_list_api_versions(self, response):
235
250
logging.log(f"Received response: {response}")
251
+ return response
236
252
237
- def pre_list_artifacts(request, metadata):
253
+ def pre_list_artifacts(self, request, metadata):
238
254
logging.log(f"Received request: {request}")
239
255
return request, metadata
240
256
241
- def post_list_artifacts(response):
257
+ def post_list_artifacts(self, response):
242
258
logging.log(f"Received response: {response}")
259
+ return response
243
260
244
- def pre_replace_artifact(request, metadata):
261
+ def pre_replace_artifact(self, request, metadata):
245
262
logging.log(f"Received request: {request}")
246
263
return request, metadata
247
264
248
- def post_replace_artifact(response):
265
+ def post_replace_artifact(self, response):
249
266
logging.log(f"Received response: {response}")
267
+ return response
250
268
251
- def pre_rollback_api_deployment(request, metadata):
269
+ def pre_rollback_api_deployment(self, request, metadata):
252
270
logging.log(f"Received request: {request}")
253
271
return request, metadata
254
272
255
- def post_rollback_api_deployment(response):
273
+ def post_rollback_api_deployment(self, response):
256
274
logging.log(f"Received response: {response}")
275
+ return response
257
276
258
- def pre_rollback_api_spec(request, metadata):
277
+ def pre_rollback_api_spec(self, request, metadata):
259
278
logging.log(f"Received request: {request}")
260
279
return request, metadata
261
280
262
- def post_rollback_api_spec(response):
281
+ def post_rollback_api_spec(self, response):
263
282
logging.log(f"Received response: {response}")
283
+ return response
264
284
265
- def pre_tag_api_deployment_revision(request, metadata):
285
+ def pre_tag_api_deployment_revision(self, request, metadata):
266
286
logging.log(f"Received request: {request}")
267
287
return request, metadata
268
288
269
- def post_tag_api_deployment_revision(response):
289
+ def post_tag_api_deployment_revision(self, response):
270
290
logging.log(f"Received response: {response}")
291
+ return response
271
292
272
- def pre_tag_api_spec_revision(request, metadata):
293
+ def pre_tag_api_spec_revision(self, request, metadata):
273
294
logging.log(f"Received request: {request}")
274
295
return request, metadata
275
296
276
- def post_tag_api_spec_revision(response):
297
+ def post_tag_api_spec_revision(self, response):
277
298
logging.log(f"Received response: {response}")
299
+ return response
278
300
279
- def pre_update_api(request, metadata):
301
+ def pre_update_api(self, request, metadata):
280
302
logging.log(f"Received request: {request}")
281
303
return request, metadata
282
304
283
- def post_update_api(response):
305
+ def post_update_api(self, response):
284
306
logging.log(f"Received response: {response}")
307
+ return response
285
308
286
- def pre_update_api_deployment(request, metadata):
309
+ def pre_update_api_deployment(self, request, metadata):
287
310
logging.log(f"Received request: {request}")
288
311
return request, metadata
289
312
290
- def post_update_api_deployment(response):
313
+ def post_update_api_deployment(self, response):
291
314
logging.log(f"Received response: {response}")
315
+ return response
292
316
293
- def pre_update_api_spec(request, metadata):
317
+ def pre_update_api_spec(self, request, metadata):
294
318
logging.log(f"Received request: {request}")
295
319
return request, metadata
296
320
297
- def post_update_api_spec(response):
321
+ def post_update_api_spec(self, response):
298
322
logging.log(f"Received response: {response}")
323
+ return response
299
324
300
- def pre_update_api_version(request, metadata):
325
+ def pre_update_api_version(self, request, metadata):
301
326
logging.log(f"Received request: {request}")
302
327
return request, metadata
303
328
304
- def post_update_api_version(response):
329
+ def post_update_api_version(self, response):
305
330
logging.log(f"Received response: {response}")
331
+ return response
306
332
307
333
transport = RegistryRestTransport(interceptor=MyCustomRegistryInterceptor())
308
334
client = RegistryClient(transport=transport)
0 commit comments