structurize 2.19.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.
- avrotize/__init__.py +64 -0
- avrotize/__main__.py +6 -0
- avrotize/_version.py +34 -0
- avrotize/asn1toavro.py +160 -0
- avrotize/avrotize.py +152 -0
- avrotize/avrotocpp.py +483 -0
- avrotize/avrotocsharp.py +1075 -0
- avrotize/avrotocsv.py +121 -0
- avrotize/avrotodatapackage.py +173 -0
- avrotize/avrotodb.py +1383 -0
- avrotize/avrotogo.py +476 -0
- avrotize/avrotographql.py +197 -0
- avrotize/avrotoiceberg.py +210 -0
- avrotize/avrotojava.py +2156 -0
- avrotize/avrotojs.py +250 -0
- avrotize/avrotojsons.py +481 -0
- avrotize/avrotojstruct.py +345 -0
- avrotize/avrotokusto.py +364 -0
- avrotize/avrotomd.py +137 -0
- avrotize/avrotools.py +168 -0
- avrotize/avrotoparquet.py +208 -0
- avrotize/avrotoproto.py +359 -0
- avrotize/avrotopython.py +624 -0
- avrotize/avrotorust.py +435 -0
- avrotize/avrotots.py +598 -0
- avrotize/avrotoxsd.py +344 -0
- avrotize/cddltostructure.py +1841 -0
- avrotize/commands.json +3337 -0
- avrotize/common.py +834 -0
- avrotize/constants.py +72 -0
- avrotize/csvtoavro.py +132 -0
- avrotize/datapackagetoavro.py +76 -0
- avrotize/dependencies/cpp/vcpkg/vcpkg.json +19 -0
- avrotize/dependencies/typescript/node22/package.json +16 -0
- avrotize/dependency_resolver.py +348 -0
- avrotize/dependency_version.py +432 -0
- avrotize/jsonstoavro.py +2167 -0
- avrotize/jsonstostructure.py +2642 -0
- avrotize/jstructtoavro.py +878 -0
- avrotize/kstructtoavro.py +93 -0
- avrotize/kustotoavro.py +455 -0
- avrotize/parquettoavro.py +157 -0
- avrotize/proto2parser.py +498 -0
- avrotize/proto3parser.py +403 -0
- avrotize/prototoavro.py +382 -0
- avrotize/structuretocddl.py +597 -0
- avrotize/structuretocpp.py +697 -0
- avrotize/structuretocsharp.py +2295 -0
- avrotize/structuretocsv.py +365 -0
- avrotize/structuretodatapackage.py +659 -0
- avrotize/structuretodb.py +1125 -0
- avrotize/structuretogo.py +720 -0
- avrotize/structuretographql.py +502 -0
- avrotize/structuretoiceberg.py +355 -0
- avrotize/structuretojava.py +853 -0
- avrotize/structuretojsons.py +498 -0
- avrotize/structuretokusto.py +639 -0
- avrotize/structuretomd.py +322 -0
- avrotize/structuretoproto.py +764 -0
- avrotize/structuretopython.py +772 -0
- avrotize/structuretorust.py +714 -0
- avrotize/structuretots.py +653 -0
- avrotize/structuretoxsd.py +679 -0
- avrotize/xsdtoavro.py +413 -0
- structurize-2.19.0.dist-info/METADATA +107 -0
- structurize-2.19.0.dist-info/RECORD +70 -0
- structurize-2.19.0.dist-info/WHEEL +5 -0
- structurize-2.19.0.dist-info/entry_points.txt +2 -0
- structurize-2.19.0.dist-info/licenses/LICENSE +201 -0
- structurize-2.19.0.dist-info/top_level.txt +1 -0
avrotize/commands.json
ADDED
|
@@ -0,0 +1,3337 @@
|
|
|
1
|
+
[
|
|
2
|
+
{
|
|
3
|
+
"command": "p2a",
|
|
4
|
+
"description": "Convert Proto schema to Avrotize schema",
|
|
5
|
+
"group": "1_Schemas",
|
|
6
|
+
"function": {
|
|
7
|
+
"name": "avrotize.prototoavro.convert_proto_to_avro",
|
|
8
|
+
"args": {
|
|
9
|
+
"proto_file_path": "input_file_path",
|
|
10
|
+
"avro_schema_path": "output_file_path",
|
|
11
|
+
"namespace": "args.namespace",
|
|
12
|
+
"message_type": "args.message_type",
|
|
13
|
+
"proto_root": "args.proto_root"
|
|
14
|
+
}
|
|
15
|
+
},
|
|
16
|
+
"extensions": [
|
|
17
|
+
".proto"
|
|
18
|
+
],
|
|
19
|
+
"args": [
|
|
20
|
+
{
|
|
21
|
+
"name": "input",
|
|
22
|
+
"type": "str",
|
|
23
|
+
"nargs": "?",
|
|
24
|
+
"help": "Path of the proto file (or read from stdin if omitted)",
|
|
25
|
+
"required": false
|
|
26
|
+
},
|
|
27
|
+
{
|
|
28
|
+
"name": "--out",
|
|
29
|
+
"type": "str",
|
|
30
|
+
"help": "Path to the Avrotize schema file",
|
|
31
|
+
"required": false
|
|
32
|
+
},
|
|
33
|
+
{
|
|
34
|
+
"name": "--proto",
|
|
35
|
+
"type": "str",
|
|
36
|
+
"help": "Deprecated: Path of the proto file (for backcompat)",
|
|
37
|
+
"required": false
|
|
38
|
+
},
|
|
39
|
+
{
|
|
40
|
+
"name": "--namespace",
|
|
41
|
+
"type": "str",
|
|
42
|
+
"help": "Namespace for the Avrotize schema",
|
|
43
|
+
"required": false
|
|
44
|
+
},
|
|
45
|
+
{
|
|
46
|
+
"name": "--message-type",
|
|
47
|
+
"type": "str",
|
|
48
|
+
"help": "Generate the schema for a specific Proto message type and inline all references",
|
|
49
|
+
"required": false
|
|
50
|
+
},
|
|
51
|
+
{
|
|
52
|
+
"name": "--proto-root",
|
|
53
|
+
"type": "str",
|
|
54
|
+
"help": "Root directory for resolving proto imports (useful for buf-style module roots)",
|
|
55
|
+
"required": false
|
|
56
|
+
}
|
|
57
|
+
],
|
|
58
|
+
"suggested_output_file_path": "{input_file_name}.avsc",
|
|
59
|
+
"prompts": []
|
|
60
|
+
},
|
|
61
|
+
{
|
|
62
|
+
"command": "a2p",
|
|
63
|
+
"description": "Convert Avrotize schema to Proto schema",
|
|
64
|
+
"group": "1_Schemas",
|
|
65
|
+
"function": {
|
|
66
|
+
"name": "avrotize.avrotoproto.convert_avro_to_proto",
|
|
67
|
+
"args": {
|
|
68
|
+
"avro_schema_path": "input_file_path",
|
|
69
|
+
"proto_file_path": "output_file_path",
|
|
70
|
+
"naming_mode": "args.naming",
|
|
71
|
+
"allow_optional": "args.allow_optional"
|
|
72
|
+
}
|
|
73
|
+
},
|
|
74
|
+
"extensions": [
|
|
75
|
+
".avsc"
|
|
76
|
+
],
|
|
77
|
+
"args": [
|
|
78
|
+
{
|
|
79
|
+
"name": "input",
|
|
80
|
+
"type": "str",
|
|
81
|
+
"nargs": "?",
|
|
82
|
+
"help": "Path to the Proto file (or read from stdin if omitted)",
|
|
83
|
+
"required": false
|
|
84
|
+
},
|
|
85
|
+
{
|
|
86
|
+
"name": "--out",
|
|
87
|
+
"type": "str",
|
|
88
|
+
"help": "Path to the Avrotize schema file",
|
|
89
|
+
"required": false
|
|
90
|
+
},
|
|
91
|
+
{
|
|
92
|
+
"name": "--avsc",
|
|
93
|
+
"type": "str",
|
|
94
|
+
"help": "Deprecated: Path to the Proto file (for backcompat)",
|
|
95
|
+
"required": false
|
|
96
|
+
},
|
|
97
|
+
{
|
|
98
|
+
"name": "--naming",
|
|
99
|
+
"type": "str",
|
|
100
|
+
"help": "Type naming convention",
|
|
101
|
+
"choices": [
|
|
102
|
+
"snake",
|
|
103
|
+
"camel",
|
|
104
|
+
"pascal"
|
|
105
|
+
],
|
|
106
|
+
"required": false,
|
|
107
|
+
"default": "pascal"
|
|
108
|
+
},
|
|
109
|
+
{
|
|
110
|
+
"name": "--allow-optional",
|
|
111
|
+
"type": "bool",
|
|
112
|
+
"help": "Enable support for 'optional' fields",
|
|
113
|
+
"default": false,
|
|
114
|
+
"required": false
|
|
115
|
+
}
|
|
116
|
+
],
|
|
117
|
+
"suggested_output_file_path": "{input_file_name}-proto",
|
|
118
|
+
"prompts": [
|
|
119
|
+
{
|
|
120
|
+
"name": "--naming",
|
|
121
|
+
"message": "Select type naming convention",
|
|
122
|
+
"choices": [
|
|
123
|
+
"snake",
|
|
124
|
+
"camel",
|
|
125
|
+
"pascal"
|
|
126
|
+
],
|
|
127
|
+
"default": "pascal",
|
|
128
|
+
"required": false
|
|
129
|
+
},
|
|
130
|
+
{
|
|
131
|
+
"name": "--allow-optional",
|
|
132
|
+
"message": "Enable support for 'optional' fields?",
|
|
133
|
+
"type": "bool",
|
|
134
|
+
"default": false,
|
|
135
|
+
"required": false
|
|
136
|
+
}
|
|
137
|
+
]
|
|
138
|
+
},
|
|
139
|
+
{
|
|
140
|
+
"command": "s2p",
|
|
141
|
+
"description": "Convert JSON Structure to Protocol Buffers (.proto)",
|
|
142
|
+
"group": "1_Schemas",
|
|
143
|
+
"function": {
|
|
144
|
+
"name": "avrotize.structuretoproto.convert_structure_to_proto",
|
|
145
|
+
"args": {
|
|
146
|
+
"structure_schema_path": "input_file_path",
|
|
147
|
+
"proto_file_path": "output_file_path",
|
|
148
|
+
"naming_mode": "args.naming_mode",
|
|
149
|
+
"allow_optional": "args.allow_optional"
|
|
150
|
+
}
|
|
151
|
+
},
|
|
152
|
+
"extensions": [
|
|
153
|
+
".struct.json",
|
|
154
|
+
".json"
|
|
155
|
+
],
|
|
156
|
+
"args": [
|
|
157
|
+
{
|
|
158
|
+
"name": "input",
|
|
159
|
+
"type": "str",
|
|
160
|
+
"nargs": "?",
|
|
161
|
+
"help": "Path to the JSON Structure file (or read from stdin if omitted)",
|
|
162
|
+
"required": false
|
|
163
|
+
},
|
|
164
|
+
{
|
|
165
|
+
"name": "--out",
|
|
166
|
+
"type": "str",
|
|
167
|
+
"help": "Output path for the Protocol Buffers .proto files",
|
|
168
|
+
"required": false
|
|
169
|
+
},
|
|
170
|
+
{
|
|
171
|
+
"name": "--struct",
|
|
172
|
+
"type": "str",
|
|
173
|
+
"help": "Deprecated: Path to the JSON Structure file (for backcompat)",
|
|
174
|
+
"required": false
|
|
175
|
+
},
|
|
176
|
+
{
|
|
177
|
+
"name": "--naming-mode",
|
|
178
|
+
"type": "str",
|
|
179
|
+
"help": "Naming convention for message and field names",
|
|
180
|
+
"choices": [
|
|
181
|
+
"pascal",
|
|
182
|
+
"camel",
|
|
183
|
+
"snake"
|
|
184
|
+
],
|
|
185
|
+
"default": "pascal",
|
|
186
|
+
"required": false
|
|
187
|
+
},
|
|
188
|
+
{
|
|
189
|
+
"name": "--allow-optional",
|
|
190
|
+
"type": "bool",
|
|
191
|
+
"help": "Use 'optional' keyword for nullable fields (proto3)",
|
|
192
|
+
"default": false,
|
|
193
|
+
"required": false
|
|
194
|
+
}
|
|
195
|
+
],
|
|
196
|
+
"suggested_output_file_path": "{input_file_name}-proto",
|
|
197
|
+
"prompts": []
|
|
198
|
+
},
|
|
199
|
+
{
|
|
200
|
+
"command": "j2a",
|
|
201
|
+
"description": "Convert JSON schema to Avrotize schema",
|
|
202
|
+
"group": "1_Schemas",
|
|
203
|
+
"function": {
|
|
204
|
+
"name": "avrotize.jsonstoavro.convert_jsons_to_avro",
|
|
205
|
+
"args": {
|
|
206
|
+
"json_schema_file_path": "input_file_path",
|
|
207
|
+
"avro_schema_path": "output_file_path",
|
|
208
|
+
"namespace": "args.namespace",
|
|
209
|
+
"split_top_level_records": "args.split_top_level_records"
|
|
210
|
+
}
|
|
211
|
+
},
|
|
212
|
+
"extensions": [
|
|
213
|
+
".json",
|
|
214
|
+
".jsons"
|
|
215
|
+
],
|
|
216
|
+
"args": [
|
|
217
|
+
{
|
|
218
|
+
"name": "input",
|
|
219
|
+
"type": "str",
|
|
220
|
+
"nargs": "?",
|
|
221
|
+
"help": "Path to the JSON schema file (or read from stdin if omitted)",
|
|
222
|
+
"required": false
|
|
223
|
+
},
|
|
224
|
+
{
|
|
225
|
+
"name": "--out",
|
|
226
|
+
"type": "str",
|
|
227
|
+
"help": "Path to the Avrotize schema file",
|
|
228
|
+
"required": false
|
|
229
|
+
},
|
|
230
|
+
{
|
|
231
|
+
"name": "--jsons",
|
|
232
|
+
"type": "str",
|
|
233
|
+
"help": "Deprecated: Path to the JSON schema file (for backcompat)",
|
|
234
|
+
"required": false
|
|
235
|
+
},
|
|
236
|
+
{
|
|
237
|
+
"name": "--namespace",
|
|
238
|
+
"type": "str",
|
|
239
|
+
"help": "Namespace for the Avrotize schema",
|
|
240
|
+
"required": false
|
|
241
|
+
},
|
|
242
|
+
{
|
|
243
|
+
"name": "--split-top-level-records",
|
|
244
|
+
"type": "bool",
|
|
245
|
+
"help": "Split top-level records into separate files",
|
|
246
|
+
"default": false,
|
|
247
|
+
"required": false
|
|
248
|
+
}
|
|
249
|
+
],
|
|
250
|
+
"suggested_output_file_path": "{input_file_name}.avsc",
|
|
251
|
+
"prompts": [
|
|
252
|
+
{
|
|
253
|
+
"name": "--namespace",
|
|
254
|
+
"message": "Enter the namespace for the Avro schema",
|
|
255
|
+
"type": "str",
|
|
256
|
+
"required": false
|
|
257
|
+
},
|
|
258
|
+
{
|
|
259
|
+
"name": "--split-top-level-records",
|
|
260
|
+
"message": "Split top-level records into separate files?",
|
|
261
|
+
"type": "bool",
|
|
262
|
+
"default": false,
|
|
263
|
+
"required": false
|
|
264
|
+
}
|
|
265
|
+
]
|
|
266
|
+
},
|
|
267
|
+
{
|
|
268
|
+
"command": "a2j",
|
|
269
|
+
"description": "Convert Avrotize schema to JSON schema",
|
|
270
|
+
"group": "1_Schemas",
|
|
271
|
+
"function": {
|
|
272
|
+
"name": "avrotize.avrotojsons.convert_avro_to_json_schema",
|
|
273
|
+
"args": {
|
|
274
|
+
"avro_schema_file": "input_file_path",
|
|
275
|
+
"json_schema_file": "output_file_path",
|
|
276
|
+
"naming_mode": "args.naming"
|
|
277
|
+
}
|
|
278
|
+
},
|
|
279
|
+
"extensions": [
|
|
280
|
+
".avsc"
|
|
281
|
+
],
|
|
282
|
+
"args": [
|
|
283
|
+
{
|
|
284
|
+
"name": "input",
|
|
285
|
+
"type": "str",
|
|
286
|
+
"nargs": "?",
|
|
287
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
288
|
+
"required": false
|
|
289
|
+
},
|
|
290
|
+
{
|
|
291
|
+
"name": "--out",
|
|
292
|
+
"type": "str",
|
|
293
|
+
"help": "Path to the JSON schema file",
|
|
294
|
+
"required": false
|
|
295
|
+
},
|
|
296
|
+
{
|
|
297
|
+
"name": "--avsc",
|
|
298
|
+
"type": "str",
|
|
299
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
300
|
+
"required": false
|
|
301
|
+
},
|
|
302
|
+
{
|
|
303
|
+
"name": "--naming",
|
|
304
|
+
"type": "str",
|
|
305
|
+
"help": "Type naming convention",
|
|
306
|
+
"choices": [
|
|
307
|
+
"snake",
|
|
308
|
+
"camel",
|
|
309
|
+
"pascal",
|
|
310
|
+
"default"
|
|
311
|
+
],
|
|
312
|
+
"required": false,
|
|
313
|
+
"default": "default"
|
|
314
|
+
}
|
|
315
|
+
],
|
|
316
|
+
"suggested_output_file_path": "{input_file_name}.jsons",
|
|
317
|
+
"prompts": []
|
|
318
|
+
},
|
|
319
|
+
{
|
|
320
|
+
"command": "j2s",
|
|
321
|
+
"description": "Convert JSON schema to JSON Structure",
|
|
322
|
+
"group": "1_Schemas",
|
|
323
|
+
"function": {
|
|
324
|
+
"name": "avrotize.jsonstostructure.convert_json_schema_to_structure_files",
|
|
325
|
+
"args": {
|
|
326
|
+
"json_schema_file_path": "input_file_path",
|
|
327
|
+
"structure_schema_path": "output_file_path",
|
|
328
|
+
"root_namespace": "args.namespace"
|
|
329
|
+
}
|
|
330
|
+
},
|
|
331
|
+
"extensions": [
|
|
332
|
+
".json",
|
|
333
|
+
".jsons"
|
|
334
|
+
],
|
|
335
|
+
"args": [
|
|
336
|
+
{
|
|
337
|
+
"name": "input",
|
|
338
|
+
"type": "str",
|
|
339
|
+
"nargs": "?",
|
|
340
|
+
"help": "Path to the JSON schema file (or read from stdin if omitted)",
|
|
341
|
+
"required": false
|
|
342
|
+
},
|
|
343
|
+
{
|
|
344
|
+
"name": "--out",
|
|
345
|
+
"type": "str",
|
|
346
|
+
"help": "Path to the JSON Structure file",
|
|
347
|
+
"required": false
|
|
348
|
+
},
|
|
349
|
+
{
|
|
350
|
+
"name": "--namespace",
|
|
351
|
+
"type": "str",
|
|
352
|
+
"help": "Namespace for the JSON Structure schema",
|
|
353
|
+
"required": false
|
|
354
|
+
},
|
|
355
|
+
{
|
|
356
|
+
"name": "--utility-namespace",
|
|
357
|
+
"type": "str",
|
|
358
|
+
"help": "Namespace for utility types",
|
|
359
|
+
"required": false
|
|
360
|
+
},
|
|
361
|
+
{
|
|
362
|
+
"name": "--root-class-name",
|
|
363
|
+
"type": "str",
|
|
364
|
+
"help": "Name of the root class",
|
|
365
|
+
"default": "document",
|
|
366
|
+
"required": false
|
|
367
|
+
},
|
|
368
|
+
{
|
|
369
|
+
"name": "--preserve-composition",
|
|
370
|
+
"type": "bool",
|
|
371
|
+
"help": "Preserve composition keywords (allOf, oneOf, anyOf)",
|
|
372
|
+
"default": true,
|
|
373
|
+
"required": false
|
|
374
|
+
},
|
|
375
|
+
{
|
|
376
|
+
"name": "--detect-inheritance",
|
|
377
|
+
"type": "bool",
|
|
378
|
+
"help": "Detect inheritance patterns in allOf schemas",
|
|
379
|
+
"default": true,
|
|
380
|
+
"required": false
|
|
381
|
+
},
|
|
382
|
+
{
|
|
383
|
+
"name": "--detect-discriminators",
|
|
384
|
+
"type": "bool",
|
|
385
|
+
"help": "Detect OpenAPI discriminator patterns",
|
|
386
|
+
"default": true,
|
|
387
|
+
"required": false
|
|
388
|
+
},
|
|
389
|
+
{
|
|
390
|
+
"name": "--convert-empty-objects-to-maps",
|
|
391
|
+
"type": "bool",
|
|
392
|
+
"help": "Convert objects with only additionalProperties to maps",
|
|
393
|
+
"default": true,
|
|
394
|
+
"required": false
|
|
395
|
+
}
|
|
396
|
+
],
|
|
397
|
+
"suggested_output_file_path": "{input_file_name}.struct.json",
|
|
398
|
+
"prompts": [
|
|
399
|
+
{
|
|
400
|
+
"name": "--namespace",
|
|
401
|
+
"message": "Enter the namespace for the JSON Structure schema",
|
|
402
|
+
"type": "str",
|
|
403
|
+
"required": false
|
|
404
|
+
},
|
|
405
|
+
{
|
|
406
|
+
"name": "--root-class-name",
|
|
407
|
+
"message": "Enter the name of the root class",
|
|
408
|
+
"type": "str",
|
|
409
|
+
"default": "document",
|
|
410
|
+
"required": false
|
|
411
|
+
}
|
|
412
|
+
]
|
|
413
|
+
},
|
|
414
|
+
{
|
|
415
|
+
"command": "s2j",
|
|
416
|
+
"description": "Convert JSON Structure to JSON Schema",
|
|
417
|
+
"group": "1_Schemas",
|
|
418
|
+
"function": {
|
|
419
|
+
"name": "avrotize.structuretojsons.convert_structure_to_json_schema",
|
|
420
|
+
"args": {
|
|
421
|
+
"structure_file_path": "input_file_path",
|
|
422
|
+
"json_schema_path": "output_file_path"
|
|
423
|
+
}
|
|
424
|
+
},
|
|
425
|
+
"extensions": [
|
|
426
|
+
".struct.json",
|
|
427
|
+
".json"
|
|
428
|
+
],
|
|
429
|
+
"args": [
|
|
430
|
+
{
|
|
431
|
+
"name": "input",
|
|
432
|
+
"type": "str",
|
|
433
|
+
"nargs": "?",
|
|
434
|
+
"help": "Path to the JSON Structure file (or read from stdin if omitted)",
|
|
435
|
+
"required": false
|
|
436
|
+
},
|
|
437
|
+
{
|
|
438
|
+
"name": "--out",
|
|
439
|
+
"type": "str",
|
|
440
|
+
"help": "Path to the JSON Schema file",
|
|
441
|
+
"required": false
|
|
442
|
+
}
|
|
443
|
+
],
|
|
444
|
+
"suggested_output_file_path": "{input_file_name}.schema.json",
|
|
445
|
+
"prompts": []
|
|
446
|
+
},
|
|
447
|
+
{
|
|
448
|
+
"command": "x2a",
|
|
449
|
+
"description": "Convert XSD schema to Avrotize schema",
|
|
450
|
+
"group": "1_Schemas",
|
|
451
|
+
"function": {
|
|
452
|
+
"name": "avrotize.xsdtoavro.convert_xsd_to_avro",
|
|
453
|
+
"args": {
|
|
454
|
+
"xsd_path": "input_file_path",
|
|
455
|
+
"avro_path": "output_file_path",
|
|
456
|
+
"namespace": "args.namespace"
|
|
457
|
+
}
|
|
458
|
+
},
|
|
459
|
+
"extensions": [
|
|
460
|
+
".xsd"
|
|
461
|
+
],
|
|
462
|
+
"args": [
|
|
463
|
+
{
|
|
464
|
+
"name": "input",
|
|
465
|
+
"type": "str",
|
|
466
|
+
"nargs": "?",
|
|
467
|
+
"help": "Path to the XSD schema file (or read from stdin if omitted)",
|
|
468
|
+
"required": false
|
|
469
|
+
},
|
|
470
|
+
{
|
|
471
|
+
"name": "--out",
|
|
472
|
+
"type": "str",
|
|
473
|
+
"help": "Path to the Avrotize schema file",
|
|
474
|
+
"required": false
|
|
475
|
+
},
|
|
476
|
+
{
|
|
477
|
+
"name": "--xsd",
|
|
478
|
+
"type": "str",
|
|
479
|
+
"help": "Deprecated: Path to the XSD schema file (for backcompat)",
|
|
480
|
+
"required": false
|
|
481
|
+
},
|
|
482
|
+
{
|
|
483
|
+
"name": "--namespace",
|
|
484
|
+
"type": "str",
|
|
485
|
+
"help": "Namespace for the Avrotize schema",
|
|
486
|
+
"required": false
|
|
487
|
+
}
|
|
488
|
+
],
|
|
489
|
+
"suggested_output_file_path": "{input_file_name}.avsc",
|
|
490
|
+
"prompts": [
|
|
491
|
+
{
|
|
492
|
+
"name": "--namespace",
|
|
493
|
+
"message": "Enter the namespace for the Avro schema",
|
|
494
|
+
"type": "str",
|
|
495
|
+
"required": false
|
|
496
|
+
}
|
|
497
|
+
]
|
|
498
|
+
},
|
|
499
|
+
{
|
|
500
|
+
"command": "a2x",
|
|
501
|
+
"description": "Convert Avrotize schema to XSD schema",
|
|
502
|
+
"group": "1_Schemas",
|
|
503
|
+
"function": {
|
|
504
|
+
"name": "avrotize.avrotoxsd.convert_avro_to_xsd",
|
|
505
|
+
"args": {
|
|
506
|
+
"avro_schema_path": "input_file_path",
|
|
507
|
+
"xml_file_path": "output_file_path",
|
|
508
|
+
"target_namespace": "args.namespace"
|
|
509
|
+
}
|
|
510
|
+
},
|
|
511
|
+
"extensions": [
|
|
512
|
+
".avsc"
|
|
513
|
+
],
|
|
514
|
+
"args": [
|
|
515
|
+
{
|
|
516
|
+
"name": "input",
|
|
517
|
+
"type": "str",
|
|
518
|
+
"nargs": "?",
|
|
519
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
520
|
+
"required": false
|
|
521
|
+
},
|
|
522
|
+
{
|
|
523
|
+
"name": "--out",
|
|
524
|
+
"type": "str",
|
|
525
|
+
"help": "Path to the XSD schema file",
|
|
526
|
+
"required": false
|
|
527
|
+
},
|
|
528
|
+
{
|
|
529
|
+
"name": "--avsc",
|
|
530
|
+
"type": "str",
|
|
531
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
532
|
+
"required": false
|
|
533
|
+
},
|
|
534
|
+
{
|
|
535
|
+
"name": "--namespace",
|
|
536
|
+
"type": "str",
|
|
537
|
+
"help": "Target namespace for the XSD schema",
|
|
538
|
+
"required": false
|
|
539
|
+
}
|
|
540
|
+
],
|
|
541
|
+
"suggested_output_file_path": "{input_file_name}.xsd",
|
|
542
|
+
"prompts": [
|
|
543
|
+
{
|
|
544
|
+
"name": "--namespace",
|
|
545
|
+
"message": "Enter the target namespace for the XSD schema (optional)",
|
|
546
|
+
"type": "str",
|
|
547
|
+
"required": false
|
|
548
|
+
}
|
|
549
|
+
]
|
|
550
|
+
},
|
|
551
|
+
{
|
|
552
|
+
"command": "a2k",
|
|
553
|
+
"description": "Convert Avrotize schema to Kusto table schemas",
|
|
554
|
+
"group": "4_RTDB",
|
|
555
|
+
"function": {
|
|
556
|
+
"name": "avrotize.avrotokusto.convert_avro_to_kusto",
|
|
557
|
+
"args": {
|
|
558
|
+
"avro_schema_path": "input_file_path",
|
|
559
|
+
"kusto_file_path": "output_file_path",
|
|
560
|
+
"kusto_uri": "args.kusto_uri",
|
|
561
|
+
"kusto_database": "args.kusto_database",
|
|
562
|
+
"avro_record_type": "args.record_type",
|
|
563
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns",
|
|
564
|
+
"emit_cloudevents_dispatch_table": "args.emit_cloudevents_dispatch"
|
|
565
|
+
}
|
|
566
|
+
},
|
|
567
|
+
"extensions": [
|
|
568
|
+
".avsc"
|
|
569
|
+
],
|
|
570
|
+
"args": [
|
|
571
|
+
{
|
|
572
|
+
"name": "input",
|
|
573
|
+
"type": "str",
|
|
574
|
+
"nargs": "?",
|
|
575
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
576
|
+
"required": false
|
|
577
|
+
},
|
|
578
|
+
{
|
|
579
|
+
"name": "--out",
|
|
580
|
+
"type": "str",
|
|
581
|
+
"help": "Path to the Kusto table",
|
|
582
|
+
"required": false
|
|
583
|
+
},
|
|
584
|
+
{
|
|
585
|
+
"name": "--avsc",
|
|
586
|
+
"type": "str",
|
|
587
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
588
|
+
"required": false
|
|
589
|
+
},
|
|
590
|
+
{
|
|
591
|
+
"name": "--kusto-uri",
|
|
592
|
+
"type": "str",
|
|
593
|
+
"help": "Kusto Cluster URI to apply the generated schema to.",
|
|
594
|
+
"required": false
|
|
595
|
+
},
|
|
596
|
+
{
|
|
597
|
+
"name": "--kusto-database",
|
|
598
|
+
"type": "str",
|
|
599
|
+
"help": "Kusto database name to apply the generated schema to",
|
|
600
|
+
"required": false
|
|
601
|
+
},
|
|
602
|
+
{
|
|
603
|
+
"name": "--record-type",
|
|
604
|
+
"type": "str",
|
|
605
|
+
"help": "Record type in the Avrotize schema",
|
|
606
|
+
"required": false
|
|
607
|
+
},
|
|
608
|
+
{
|
|
609
|
+
"name": "--emit-cloudevents-columns",
|
|
610
|
+
"type": "bool",
|
|
611
|
+
"help": "Add CloudEvents columns to the Kusto table",
|
|
612
|
+
"default": false,
|
|
613
|
+
"required": false
|
|
614
|
+
},
|
|
615
|
+
{
|
|
616
|
+
"name": "--emit-cloudevents-dispatch",
|
|
617
|
+
"type": "bool",
|
|
618
|
+
"help": "Emit a _cloudevents_dispatch ingestion table and update policies for each generated table",
|
|
619
|
+
"required": false
|
|
620
|
+
}
|
|
621
|
+
],
|
|
622
|
+
"suggested_output_file_path": "{input_file_name}.kql",
|
|
623
|
+
"prompts": [
|
|
624
|
+
{
|
|
625
|
+
"name": "--kusto-uri",
|
|
626
|
+
"message": "Enter the Kusto Cluster URI (optional)",
|
|
627
|
+
"type": "str",
|
|
628
|
+
"required": false
|
|
629
|
+
},
|
|
630
|
+
{
|
|
631
|
+
"name": "--kusto-database",
|
|
632
|
+
"message": "Enter the Kusto database name (optional)",
|
|
633
|
+
"type": "str",
|
|
634
|
+
"required": false
|
|
635
|
+
},
|
|
636
|
+
{
|
|
637
|
+
"name": "--emit-cloudevents-columns",
|
|
638
|
+
"message": "Add CloudEvents columns to the Kusto table?",
|
|
639
|
+
"type": "bool",
|
|
640
|
+
"default": false,
|
|
641
|
+
"required": false
|
|
642
|
+
},
|
|
643
|
+
{
|
|
644
|
+
"name": "--emit-cloudevents-dispatch",
|
|
645
|
+
"message": "Emit a _cloudevents_dispatch ingestion table and update policies?",
|
|
646
|
+
"type": "bool",
|
|
647
|
+
"default": false,
|
|
648
|
+
"required": false
|
|
649
|
+
}
|
|
650
|
+
]
|
|
651
|
+
},
|
|
652
|
+
{
|
|
653
|
+
"command": "k2a",
|
|
654
|
+
"description": "Convert Kusto schema to Avrotize schema",
|
|
655
|
+
"group": "1_Schemas",
|
|
656
|
+
"function": {
|
|
657
|
+
"name": "avrotize.kustotoavro.convert_kusto_to_avro",
|
|
658
|
+
"args": {
|
|
659
|
+
"kusto_uri": "args.kusto_uri",
|
|
660
|
+
"kusto_database": "args.kusto_database",
|
|
661
|
+
"table_name": "args.table_name",
|
|
662
|
+
"avro_namespace": "args.namespace",
|
|
663
|
+
"avro_schema_file": "output_file_path",
|
|
664
|
+
"emit_cloudevents": "args.emit_cloudevents",
|
|
665
|
+
"emit_cloudevents_xregistry": "args.emit_xregistry"
|
|
666
|
+
}
|
|
667
|
+
},
|
|
668
|
+
"extensions": [
|
|
669
|
+
".kusto"
|
|
670
|
+
],
|
|
671
|
+
"args": [
|
|
672
|
+
{
|
|
673
|
+
"name": "input",
|
|
674
|
+
"type": "str",
|
|
675
|
+
"nargs": "?",
|
|
676
|
+
"help": "Kusto file",
|
|
677
|
+
"required": false
|
|
678
|
+
},
|
|
679
|
+
{
|
|
680
|
+
"name": "--out",
|
|
681
|
+
"type": "str",
|
|
682
|
+
"help": "Path to the Avrotize schema file",
|
|
683
|
+
"required": false
|
|
684
|
+
},
|
|
685
|
+
{
|
|
686
|
+
"name": "--kusto-uri",
|
|
687
|
+
"type": "str",
|
|
688
|
+
"help": "Kusto Cluster URI",
|
|
689
|
+
"required": false
|
|
690
|
+
},
|
|
691
|
+
{
|
|
692
|
+
"name": "--kusto-database",
|
|
693
|
+
"type": "str",
|
|
694
|
+
"help": "Kusto database",
|
|
695
|
+
"required": false
|
|
696
|
+
},
|
|
697
|
+
{
|
|
698
|
+
"name": "--table-name",
|
|
699
|
+
"type": "str",
|
|
700
|
+
"help": "Kusto table name",
|
|
701
|
+
"required": false
|
|
702
|
+
},
|
|
703
|
+
{
|
|
704
|
+
"name": "--namespace",
|
|
705
|
+
"type": "str",
|
|
706
|
+
"help": "Namespace for the Avrotize schema",
|
|
707
|
+
"required": false
|
|
708
|
+
},
|
|
709
|
+
{
|
|
710
|
+
"name": "--emit-cloudevents",
|
|
711
|
+
"type": "bool",
|
|
712
|
+
"help": "Emit CloudEvents declarations for each table",
|
|
713
|
+
"required": false
|
|
714
|
+
},
|
|
715
|
+
{
|
|
716
|
+
"name": "--emit-xregistry",
|
|
717
|
+
"type": "bool",
|
|
718
|
+
"help": "Emit an xRegistry manifest with CloudEvents declarations for each table instead of a single Avrotize schema",
|
|
719
|
+
"required": false
|
|
720
|
+
}
|
|
721
|
+
],
|
|
722
|
+
"suggested_output_file_path": "{kusto_database}.avsc",
|
|
723
|
+
"prompts": [
|
|
724
|
+
{
|
|
725
|
+
"name": "--namespace",
|
|
726
|
+
"message": "Enter the namespace for the Avro schema",
|
|
727
|
+
"type": "str",
|
|
728
|
+
"required": false
|
|
729
|
+
},
|
|
730
|
+
{
|
|
731
|
+
"name": "--emit-cloudevents",
|
|
732
|
+
"message": "Emit CloudEvents declarations for each table?",
|
|
733
|
+
"type": "bool",
|
|
734
|
+
"default": false,
|
|
735
|
+
"required": false
|
|
736
|
+
},
|
|
737
|
+
{
|
|
738
|
+
"name": "--emit-xregistry",
|
|
739
|
+
"message": "Emit an xRegistry manifest with CloudEvents declarations?",
|
|
740
|
+
"type": "bool",
|
|
741
|
+
"default": false,
|
|
742
|
+
"required": false
|
|
743
|
+
}
|
|
744
|
+
],
|
|
745
|
+
"skip_input_file_handling": true
|
|
746
|
+
},
|
|
747
|
+
{
|
|
748
|
+
"command": "a2sql",
|
|
749
|
+
"description": "Convert Avrotize schema to SQL schema",
|
|
750
|
+
"group": "5_SQL",
|
|
751
|
+
"function": {
|
|
752
|
+
"name": "avrotize.avrotodb.convert_avro_to_sql",
|
|
753
|
+
"args": {
|
|
754
|
+
"avro_schema_path": "input_file_path",
|
|
755
|
+
"dbscript_file_path": "output_file_path",
|
|
756
|
+
"db_dialect": "args.dialect",
|
|
757
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
758
|
+
}
|
|
759
|
+
},
|
|
760
|
+
"extensions": [
|
|
761
|
+
".avsc"
|
|
762
|
+
],
|
|
763
|
+
"args": [
|
|
764
|
+
{
|
|
765
|
+
"name": "input",
|
|
766
|
+
"type": "str",
|
|
767
|
+
"nargs": "?",
|
|
768
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
769
|
+
"required": false
|
|
770
|
+
},
|
|
771
|
+
{
|
|
772
|
+
"name": "--out",
|
|
773
|
+
"type": "str",
|
|
774
|
+
"help": "Path to the SQL table",
|
|
775
|
+
"required": false
|
|
776
|
+
},
|
|
777
|
+
{
|
|
778
|
+
"name": "--avsc",
|
|
779
|
+
"type": "str",
|
|
780
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
781
|
+
"required": false
|
|
782
|
+
},
|
|
783
|
+
{
|
|
784
|
+
"name": "--dialect",
|
|
785
|
+
"type": "str",
|
|
786
|
+
"help": "SQL dialect (database type)",
|
|
787
|
+
"choices": [
|
|
788
|
+
"mysql",
|
|
789
|
+
"mariadb",
|
|
790
|
+
"postgres",
|
|
791
|
+
"sqlserver",
|
|
792
|
+
"oracle",
|
|
793
|
+
"sqlite",
|
|
794
|
+
"bigquery",
|
|
795
|
+
"snowflake",
|
|
796
|
+
"redshift",
|
|
797
|
+
"db2"
|
|
798
|
+
],
|
|
799
|
+
"required": true
|
|
800
|
+
},
|
|
801
|
+
{
|
|
802
|
+
"name": "--emit-cloudevents-columns",
|
|
803
|
+
"type": "bool",
|
|
804
|
+
"help": "Add CloudEvents columns to the SQL table",
|
|
805
|
+
"default": false,
|
|
806
|
+
"required": false
|
|
807
|
+
}
|
|
808
|
+
],
|
|
809
|
+
"suggested_output_file_path": "{input_file_name}.sql",
|
|
810
|
+
"prompts": [
|
|
811
|
+
{
|
|
812
|
+
"name": "--dialect",
|
|
813
|
+
"message": "Select the SQL dialect",
|
|
814
|
+
"choices": [
|
|
815
|
+
"mysql",
|
|
816
|
+
"mariadb",
|
|
817
|
+
"postgres",
|
|
818
|
+
"sqlserver",
|
|
819
|
+
"oracle",
|
|
820
|
+
"sqlite",
|
|
821
|
+
"bigquery",
|
|
822
|
+
"snowflake",
|
|
823
|
+
"redshift",
|
|
824
|
+
"db2"
|
|
825
|
+
],
|
|
826
|
+
"default": "mysql",
|
|
827
|
+
"required": true
|
|
828
|
+
},
|
|
829
|
+
{
|
|
830
|
+
"name": "--emit-cloudevents-columns",
|
|
831
|
+
"message": "Add CloudEvents columns to the SQL table?",
|
|
832
|
+
"type": "bool",
|
|
833
|
+
"default": false,
|
|
834
|
+
"required": false
|
|
835
|
+
}
|
|
836
|
+
]
|
|
837
|
+
},
|
|
838
|
+
{
|
|
839
|
+
"command": "struct2sql",
|
|
840
|
+
"description": "Convert JSON Structure schema to SQL schema",
|
|
841
|
+
"group": "5_SQL",
|
|
842
|
+
"function": {
|
|
843
|
+
"name": "avrotize.structuretodb.convert_structure_to_sql",
|
|
844
|
+
"args": {
|
|
845
|
+
"structure_schema_path": "input_file_path",
|
|
846
|
+
"dbscript_file_path": "output_file_path",
|
|
847
|
+
"db_dialect": "args.dialect",
|
|
848
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
849
|
+
}
|
|
850
|
+
},
|
|
851
|
+
"extensions": [
|
|
852
|
+
".jstruct",
|
|
853
|
+
".struct.json"
|
|
854
|
+
],
|
|
855
|
+
"args": [
|
|
856
|
+
{
|
|
857
|
+
"name": "input",
|
|
858
|
+
"type": "str",
|
|
859
|
+
"nargs": "?",
|
|
860
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
861
|
+
"required": false
|
|
862
|
+
},
|
|
863
|
+
{
|
|
864
|
+
"name": "--out",
|
|
865
|
+
"type": "str",
|
|
866
|
+
"help": "Path to the SQL table",
|
|
867
|
+
"required": false
|
|
868
|
+
},
|
|
869
|
+
{
|
|
870
|
+
"name": "--dialect",
|
|
871
|
+
"type": "str",
|
|
872
|
+
"help": "SQL dialect (database type)",
|
|
873
|
+
"choices": [
|
|
874
|
+
"mysql",
|
|
875
|
+
"mariadb",
|
|
876
|
+
"postgres",
|
|
877
|
+
"sqlserver",
|
|
878
|
+
"oracle",
|
|
879
|
+
"sqlite",
|
|
880
|
+
"bigquery",
|
|
881
|
+
"snowflake",
|
|
882
|
+
"redshift",
|
|
883
|
+
"db2"
|
|
884
|
+
],
|
|
885
|
+
"required": true
|
|
886
|
+
},
|
|
887
|
+
{
|
|
888
|
+
"name": "--emit-cloudevents-columns",
|
|
889
|
+
"type": "bool",
|
|
890
|
+
"help": "Add CloudEvents columns to the SQL table",
|
|
891
|
+
"default": false,
|
|
892
|
+
"required": false
|
|
893
|
+
}
|
|
894
|
+
],
|
|
895
|
+
"suggested_output_file_path": "{input_file_name}.sql",
|
|
896
|
+
"prompts": []
|
|
897
|
+
},
|
|
898
|
+
{
|
|
899
|
+
"command": "a2mongo",
|
|
900
|
+
"description": "Convert Avrotize schema to MongoDB schema",
|
|
901
|
+
"group": "6_NoSQL",
|
|
902
|
+
"function": {
|
|
903
|
+
"name": "avrotize.avrotodb.convert_avro_to_nosql",
|
|
904
|
+
"args": {
|
|
905
|
+
"avro_schema_path": "input_file_path",
|
|
906
|
+
"nosql_file_path": "output_file_path",
|
|
907
|
+
"nosql_dialect": "mongodb",
|
|
908
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
909
|
+
}
|
|
910
|
+
},
|
|
911
|
+
"extensions": [
|
|
912
|
+
".avsc"
|
|
913
|
+
],
|
|
914
|
+
"args": [
|
|
915
|
+
{
|
|
916
|
+
"name": "input",
|
|
917
|
+
"type": "str",
|
|
918
|
+
"nargs": "?",
|
|
919
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
920
|
+
"required": false
|
|
921
|
+
},
|
|
922
|
+
{
|
|
923
|
+
"name": "--out",
|
|
924
|
+
"type": "str",
|
|
925
|
+
"help": "Path to the MongoDB schemas",
|
|
926
|
+
"required": true
|
|
927
|
+
},
|
|
928
|
+
{
|
|
929
|
+
"name": "--emit-cloudevents-columns",
|
|
930
|
+
"type": "bool",
|
|
931
|
+
"help": "Add CloudEvents columns to the MongoDB schema",
|
|
932
|
+
"default": false,
|
|
933
|
+
"required": false
|
|
934
|
+
}
|
|
935
|
+
],
|
|
936
|
+
"suggested_output_file_path": "{input_file_name}.json",
|
|
937
|
+
"prompts": [
|
|
938
|
+
{
|
|
939
|
+
"name": "--emit-cloudevents-columns",
|
|
940
|
+
"message": "Add CloudEvents columns to the MongoDB schema?",
|
|
941
|
+
"type": "bool",
|
|
942
|
+
"default": false
|
|
943
|
+
}
|
|
944
|
+
]
|
|
945
|
+
},
|
|
946
|
+
{
|
|
947
|
+
"command": "a2pq",
|
|
948
|
+
"description": "Convert Avrotize schema to Parquet or Iceberg schema",
|
|
949
|
+
"group": "3_Datalake",
|
|
950
|
+
"function": {
|
|
951
|
+
"name": "avrotize.avrotoparquet.convert_avro_to_parquet",
|
|
952
|
+
"args": {
|
|
953
|
+
"avro_schema_path": "input_file_path",
|
|
954
|
+
"parquet_file_path": "output_file_path",
|
|
955
|
+
"avro_record_type": "args.record_type",
|
|
956
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
957
|
+
}
|
|
958
|
+
},
|
|
959
|
+
"extensions": [
|
|
960
|
+
".avsc"
|
|
961
|
+
],
|
|
962
|
+
"args": [
|
|
963
|
+
{
|
|
964
|
+
"name": "input",
|
|
965
|
+
"type": "str",
|
|
966
|
+
"nargs": "?",
|
|
967
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
968
|
+
"required": false
|
|
969
|
+
},
|
|
970
|
+
{
|
|
971
|
+
"name": "--out",
|
|
972
|
+
"type": "str",
|
|
973
|
+
"help": "Path to the Parquet file",
|
|
974
|
+
"required": false
|
|
975
|
+
},
|
|
976
|
+
{
|
|
977
|
+
"name": "--avsc",
|
|
978
|
+
"type": "str",
|
|
979
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
980
|
+
"required": false
|
|
981
|
+
},
|
|
982
|
+
{
|
|
983
|
+
"name": "--record-type",
|
|
984
|
+
"type": "str",
|
|
985
|
+
"help": "Record type in the Avrotize schema",
|
|
986
|
+
"required": false
|
|
987
|
+
},
|
|
988
|
+
{
|
|
989
|
+
"name": "--emit-cloudevents-columns",
|
|
990
|
+
"type": "bool",
|
|
991
|
+
"help": "Add CloudEvents columns to the Parquet file",
|
|
992
|
+
"default": false,
|
|
993
|
+
"required": false
|
|
994
|
+
}
|
|
995
|
+
],
|
|
996
|
+
"suggested_output_file_path": "{input_file_name}.parquet",
|
|
997
|
+
"prompts": [
|
|
998
|
+
{
|
|
999
|
+
"name": "--emit-cloudevents-columns",
|
|
1000
|
+
"message": "Add CloudEvents columns to the Parquet file?",
|
|
1001
|
+
"type": "bool",
|
|
1002
|
+
"default": false
|
|
1003
|
+
}
|
|
1004
|
+
]
|
|
1005
|
+
},
|
|
1006
|
+
{
|
|
1007
|
+
"command": "a2ib",
|
|
1008
|
+
"description": "Convert Avrotize schema to Iceberg schema",
|
|
1009
|
+
"group": "3_Datalake",
|
|
1010
|
+
"function": {
|
|
1011
|
+
"name": "avrotize.avrotoiceberg.convert_avro_to_iceberg",
|
|
1012
|
+
"args": {
|
|
1013
|
+
"avro_schema_path": "input_file_path",
|
|
1014
|
+
"output_path": "output_file_path",
|
|
1015
|
+
"avro_record_type": "args.record_type",
|
|
1016
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
1017
|
+
}
|
|
1018
|
+
},
|
|
1019
|
+
"extensions": [
|
|
1020
|
+
".avsc"
|
|
1021
|
+
],
|
|
1022
|
+
"args": [
|
|
1023
|
+
{
|
|
1024
|
+
"name": "input",
|
|
1025
|
+
"type": "str",
|
|
1026
|
+
"nargs": "?",
|
|
1027
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
1028
|
+
"required": false
|
|
1029
|
+
},
|
|
1030
|
+
{
|
|
1031
|
+
"name": "--out",
|
|
1032
|
+
"type": "str",
|
|
1033
|
+
"help": "Path to the Iceberg schema",
|
|
1034
|
+
"required": false
|
|
1035
|
+
},
|
|
1036
|
+
{
|
|
1037
|
+
"name": "--record-type",
|
|
1038
|
+
"type": "str",
|
|
1039
|
+
"help": "Record type in the Avrotize schema",
|
|
1040
|
+
"required": false
|
|
1041
|
+
},
|
|
1042
|
+
{
|
|
1043
|
+
"name": "--emit-cloudevents-columns",
|
|
1044
|
+
"type": "bool",
|
|
1045
|
+
"help": "Add CloudEvents columns to the Iceberg schema",
|
|
1046
|
+
"default": false,
|
|
1047
|
+
"required": false
|
|
1048
|
+
}
|
|
1049
|
+
],
|
|
1050
|
+
"suggested_output_file_path": "{input_file_name}.iceberg",
|
|
1051
|
+
"prompts": [
|
|
1052
|
+
{
|
|
1053
|
+
"name": "--emit-cloudevents-columns",
|
|
1054
|
+
"message": "Add CloudEvents columns to the Iceberg schema?",
|
|
1055
|
+
"type": "bool",
|
|
1056
|
+
"default": false
|
|
1057
|
+
}
|
|
1058
|
+
]
|
|
1059
|
+
},
|
|
1060
|
+
{
|
|
1061
|
+
"command": "s2ib",
|
|
1062
|
+
"description": "Convert JSON Structure to Iceberg schema",
|
|
1063
|
+
"group": "3_Datalake",
|
|
1064
|
+
"function": {
|
|
1065
|
+
"name": "avrotize.structuretoiceberg.convert_structure_to_iceberg",
|
|
1066
|
+
"args": {
|
|
1067
|
+
"structure_schema_path": "input_file_path",
|
|
1068
|
+
"output_path": "output_file_path",
|
|
1069
|
+
"structure_record_type": "args.record_type",
|
|
1070
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
1071
|
+
}
|
|
1072
|
+
},
|
|
1073
|
+
"extensions": [".struct.json", ".json"],
|
|
1074
|
+
"args": [
|
|
1075
|
+
{
|
|
1076
|
+
"name": "input",
|
|
1077
|
+
"type": "str",
|
|
1078
|
+
"nargs": "?",
|
|
1079
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
1080
|
+
"required": false
|
|
1081
|
+
},
|
|
1082
|
+
{
|
|
1083
|
+
"name": "--out",
|
|
1084
|
+
"type": "str",
|
|
1085
|
+
"help": "Path to the Iceberg schema",
|
|
1086
|
+
"required": false
|
|
1087
|
+
},
|
|
1088
|
+
{
|
|
1089
|
+
"name": "--record-type",
|
|
1090
|
+
"type": "str",
|
|
1091
|
+
"help": "Record type in the JSON Structure schema",
|
|
1092
|
+
"required": false
|
|
1093
|
+
},
|
|
1094
|
+
{
|
|
1095
|
+
"name": "--emit-cloudevents-columns",
|
|
1096
|
+
"type": "bool",
|
|
1097
|
+
"help": "Add CloudEvents columns to the Iceberg schema",
|
|
1098
|
+
"default": false,
|
|
1099
|
+
"required": false
|
|
1100
|
+
}
|
|
1101
|
+
],
|
|
1102
|
+
"suggested_output_file_path": "{input_file_name}.iceberg",
|
|
1103
|
+
"prompts": [
|
|
1104
|
+
{
|
|
1105
|
+
"name": "--emit-cloudevents-columns",
|
|
1106
|
+
"message": "Add CloudEvents columns to the Iceberg schema?",
|
|
1107
|
+
"type": "bool",
|
|
1108
|
+
"default": false
|
|
1109
|
+
}
|
|
1110
|
+
]
|
|
1111
|
+
},
|
|
1112
|
+
{
|
|
1113
|
+
"command": "pq2a",
|
|
1114
|
+
"description": "Convert Parquet schema to Avrotize schema",
|
|
1115
|
+
"group": "1_Schemas",
|
|
1116
|
+
"function": {
|
|
1117
|
+
"name": "avrotize.parquettoavro.convert_parquet_to_avro",
|
|
1118
|
+
"args": {
|
|
1119
|
+
"parquet_file_path": "input_file_path",
|
|
1120
|
+
"avro_file_path": "output_file_path",
|
|
1121
|
+
"namespace": "args.namespace"
|
|
1122
|
+
}
|
|
1123
|
+
},
|
|
1124
|
+
"extensions": [
|
|
1125
|
+
".parquet"
|
|
1126
|
+
],
|
|
1127
|
+
"args": [
|
|
1128
|
+
{
|
|
1129
|
+
"name": "input",
|
|
1130
|
+
"type": "str",
|
|
1131
|
+
"nargs": "?",
|
|
1132
|
+
"help": "Path to the Parquet file (or read from stdin if omitted)",
|
|
1133
|
+
"required": false
|
|
1134
|
+
},
|
|
1135
|
+
{
|
|
1136
|
+
"name": "--out",
|
|
1137
|
+
"type": "str",
|
|
1138
|
+
"help": "Path to the Avrotize schema file",
|
|
1139
|
+
"required": false
|
|
1140
|
+
},
|
|
1141
|
+
{
|
|
1142
|
+
"name": "--parquet",
|
|
1143
|
+
"type": "str",
|
|
1144
|
+
"help": "Deprecated: Path to the Parquet file (for backcompat)",
|
|
1145
|
+
"required": false
|
|
1146
|
+
},
|
|
1147
|
+
{
|
|
1148
|
+
"name": "--namespace",
|
|
1149
|
+
"type": "str",
|
|
1150
|
+
"help": "Namespace for the Avrotize schema",
|
|
1151
|
+
"required": false
|
|
1152
|
+
}
|
|
1153
|
+
],
|
|
1154
|
+
"suggested_output_file_path": "{input_file_name}.avsc",
|
|
1155
|
+
"prompts": [
|
|
1156
|
+
{
|
|
1157
|
+
"name": "--namespace",
|
|
1158
|
+
"message": "Enter the namespace for the Avro schema",
|
|
1159
|
+
"type": "str",
|
|
1160
|
+
"required": false
|
|
1161
|
+
}
|
|
1162
|
+
]
|
|
1163
|
+
},
|
|
1164
|
+
{
|
|
1165
|
+
"command": "asn2a",
|
|
1166
|
+
"description": "Convert ASN.1 schema to Avrotize schema",
|
|
1167
|
+
"group": "1_Schemas",
|
|
1168
|
+
"function": {
|
|
1169
|
+
"name": "avrotize.asn1toavro.convert_asn1_to_avro",
|
|
1170
|
+
"args": {
|
|
1171
|
+
"asn1_spec_list": "input_file_path",
|
|
1172
|
+
"avro_file_path": "output_file_path"
|
|
1173
|
+
}
|
|
1174
|
+
},
|
|
1175
|
+
"extensions": [
|
|
1176
|
+
".asn1"
|
|
1177
|
+
],
|
|
1178
|
+
"args": [
|
|
1179
|
+
{
|
|
1180
|
+
"name": "input",
|
|
1181
|
+
"type": "str",
|
|
1182
|
+
"nargs": "?",
|
|
1183
|
+
"help": "Path(s) to the ASN.1 schema file(s) (or read from stdin if omitted)",
|
|
1184
|
+
"required": false
|
|
1185
|
+
},
|
|
1186
|
+
{
|
|
1187
|
+
"name": "--out",
|
|
1188
|
+
"type": "str",
|
|
1189
|
+
"help": "Path to the Avrotize schema file",
|
|
1190
|
+
"required": false
|
|
1191
|
+
},
|
|
1192
|
+
{
|
|
1193
|
+
"name": "--asn",
|
|
1194
|
+
"type": "str",
|
|
1195
|
+
"nargs": "+",
|
|
1196
|
+
"help": "Deprecated: Path(s) to the ASN.1 schema file(s) (for backcompat)",
|
|
1197
|
+
"required": false
|
|
1198
|
+
}
|
|
1199
|
+
],
|
|
1200
|
+
"suggested_output_file_path": "{input_file_name}.avsc",
|
|
1201
|
+
"prompts": []
|
|
1202
|
+
},
|
|
1203
|
+
{
|
|
1204
|
+
"command": "kstruct2a",
|
|
1205
|
+
"description": "Convert Kafka Struct to Avrotize schema",
|
|
1206
|
+
"group": "1_Schemas",
|
|
1207
|
+
"function": {
|
|
1208
|
+
"name": "avrotize.kstructtoavro.convert_kafka_struct_to_avro_schema",
|
|
1209
|
+
"args": {
|
|
1210
|
+
"kafka_schema_file_path": "input_file_path",
|
|
1211
|
+
"avro_file_path": "output_file_path"
|
|
1212
|
+
}
|
|
1213
|
+
},
|
|
1214
|
+
"extensions": [
|
|
1215
|
+
".kstruct"
|
|
1216
|
+
],
|
|
1217
|
+
"args": [
|
|
1218
|
+
{
|
|
1219
|
+
"name": "input",
|
|
1220
|
+
"type": "str",
|
|
1221
|
+
"nargs": "?",
|
|
1222
|
+
"help": "Path to the Kafka Struct file (or read from stdin if omitted)",
|
|
1223
|
+
"required": false
|
|
1224
|
+
},
|
|
1225
|
+
{
|
|
1226
|
+
"name": "--out",
|
|
1227
|
+
"type": "str",
|
|
1228
|
+
"help": "Path to the Avrotize schema file",
|
|
1229
|
+
"required": false
|
|
1230
|
+
},
|
|
1231
|
+
{
|
|
1232
|
+
"name": "--kstruct",
|
|
1233
|
+
"type": "str",
|
|
1234
|
+
"help": "Deprecated: Path to the Kafka Struct file (for backcompat)",
|
|
1235
|
+
"required": false
|
|
1236
|
+
}
|
|
1237
|
+
],
|
|
1238
|
+
"suggested_output_file_path": "{input_file_name}.avsc",
|
|
1239
|
+
"prompts": []
|
|
1240
|
+
},
|
|
1241
|
+
{
|
|
1242
|
+
"command": "a2cs",
|
|
1243
|
+
"description": "Convert Avrotize schema to C# classes",
|
|
1244
|
+
"group": "2_ProgLanguages",
|
|
1245
|
+
"function": {
|
|
1246
|
+
"name": "avrotize.avrotocsharp.convert_avro_to_csharp",
|
|
1247
|
+
"args": {
|
|
1248
|
+
"avro_schema_path": "input_file_path",
|
|
1249
|
+
"cs_file_path": "output_file_path",
|
|
1250
|
+
"avro_annotation": "args.avro_annotation",
|
|
1251
|
+
"system_text_json_annotation": "args.system_text_json_annotation",
|
|
1252
|
+
"newtonsoft_json_annotation": "args.newtonsoft_json_annotation",
|
|
1253
|
+
"system_xml_annotation": "args.system_xml_annotation",
|
|
1254
|
+
"pascal_properties": "args.pascal_properties",
|
|
1255
|
+
"base_namespace": "args.namespace"
|
|
1256
|
+
}
|
|
1257
|
+
},
|
|
1258
|
+
"extensions": [
|
|
1259
|
+
".avsc"
|
|
1260
|
+
],
|
|
1261
|
+
"args": [
|
|
1262
|
+
{
|
|
1263
|
+
"name": "input",
|
|
1264
|
+
"type": "str",
|
|
1265
|
+
"nargs": "?",
|
|
1266
|
+
"help": "Path to the Kafka Struct file (or read from stdin if omitted)",
|
|
1267
|
+
"required": false
|
|
1268
|
+
},
|
|
1269
|
+
{
|
|
1270
|
+
"name": "--out",
|
|
1271
|
+
"type": "str",
|
|
1272
|
+
"help": "Path to the Avrotize schema file",
|
|
1273
|
+
"required": false
|
|
1274
|
+
},
|
|
1275
|
+
{
|
|
1276
|
+
"name": "--avsc",
|
|
1277
|
+
"type": "str",
|
|
1278
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
1279
|
+
"required": false
|
|
1280
|
+
},
|
|
1281
|
+
{
|
|
1282
|
+
"name": "--namespace",
|
|
1283
|
+
"type": "str",
|
|
1284
|
+
"help": "C# project name",
|
|
1285
|
+
"required": false
|
|
1286
|
+
},
|
|
1287
|
+
{
|
|
1288
|
+
"name": "--avro-annotation",
|
|
1289
|
+
"type": "bool",
|
|
1290
|
+
"help": "Use Avro annotations",
|
|
1291
|
+
"default": false,
|
|
1292
|
+
"required": false
|
|
1293
|
+
},
|
|
1294
|
+
{
|
|
1295
|
+
"name": "--system_text_json_annotation",
|
|
1296
|
+
"type": "bool",
|
|
1297
|
+
"help": "Use System.Text.Json annotations",
|
|
1298
|
+
"default": false,
|
|
1299
|
+
"required": false
|
|
1300
|
+
},
|
|
1301
|
+
{
|
|
1302
|
+
"name": "--system-xml-annotation",
|
|
1303
|
+
"type": "bool",
|
|
1304
|
+
"help": "Use System.Xml annotations",
|
|
1305
|
+
"default": false,
|
|
1306
|
+
"required": false
|
|
1307
|
+
},
|
|
1308
|
+
{
|
|
1309
|
+
"name": "--newtonsoft-json-annotation",
|
|
1310
|
+
"type": "bool",
|
|
1311
|
+
"help": "Use Newtonsoft.Json annotations",
|
|
1312
|
+
"default": false,
|
|
1313
|
+
"required": false
|
|
1314
|
+
},
|
|
1315
|
+
{
|
|
1316
|
+
"name": "--pascal-properties",
|
|
1317
|
+
"type": "bool",
|
|
1318
|
+
"help": "Use PascalCase properties",
|
|
1319
|
+
"default": false,
|
|
1320
|
+
"required": false
|
|
1321
|
+
}
|
|
1322
|
+
],
|
|
1323
|
+
"suggested_output_file_path": "{input_file_name}-cs",
|
|
1324
|
+
"prompts": [
|
|
1325
|
+
{
|
|
1326
|
+
"name": "--namespace",
|
|
1327
|
+
"message": "Enter the C# root namespace for the project",
|
|
1328
|
+
"type": "str",
|
|
1329
|
+
"default": "{input_file_name}-cs",
|
|
1330
|
+
"required": false
|
|
1331
|
+
},
|
|
1332
|
+
{
|
|
1333
|
+
"name": "--avro-annotation",
|
|
1334
|
+
"message": "Use Avro annotations?",
|
|
1335
|
+
"type": "bool",
|
|
1336
|
+
"default": false,
|
|
1337
|
+
"required": false
|
|
1338
|
+
},
|
|
1339
|
+
{
|
|
1340
|
+
"name": "--system_text_json_annotation",
|
|
1341
|
+
"message": "Use System.Text.Json annotations?",
|
|
1342
|
+
"type": "bool",
|
|
1343
|
+
"default": false,
|
|
1344
|
+
"required": false
|
|
1345
|
+
},
|
|
1346
|
+
{
|
|
1347
|
+
"name": "--pascal-properties",
|
|
1348
|
+
"message": "Use PascalCase properties?",
|
|
1349
|
+
"type": "bool",
|
|
1350
|
+
"default": false,
|
|
1351
|
+
"required": false
|
|
1352
|
+
}
|
|
1353
|
+
]
|
|
1354
|
+
},
|
|
1355
|
+
{
|
|
1356
|
+
"command": "s2cs",
|
|
1357
|
+
"description": "Convert JSON Structure to C# classes",
|
|
1358
|
+
"group": "2_ProgLanguages",
|
|
1359
|
+
"function": {
|
|
1360
|
+
"name": "avrotize.structuretocsharp.convert_structure_to_csharp",
|
|
1361
|
+
"args": {
|
|
1362
|
+
"structure_schema_path": "input_file_path",
|
|
1363
|
+
"cs_file_path": "output_file_path",
|
|
1364
|
+
"system_text_json_annotation": "args.system_text_json_annotation",
|
|
1365
|
+
"newtonsoft_json_annotation": "args.newtonsoft_json_annotation",
|
|
1366
|
+
"system_xml_annotation": "args.system_xml_annotation",
|
|
1367
|
+
"pascal_properties": "args.pascal_properties",
|
|
1368
|
+
"base_namespace": "args.namespace",
|
|
1369
|
+
"project_name": "args.project_name"
|
|
1370
|
+
}
|
|
1371
|
+
},
|
|
1372
|
+
"extensions": [
|
|
1373
|
+
".struct.json",
|
|
1374
|
+
".json"
|
|
1375
|
+
],
|
|
1376
|
+
"args": [
|
|
1377
|
+
{
|
|
1378
|
+
"name": "input",
|
|
1379
|
+
"type": "str",
|
|
1380
|
+
"nargs": "?",
|
|
1381
|
+
"help": "Path to the JSON Structure file (or read from stdin if omitted)",
|
|
1382
|
+
"required": false
|
|
1383
|
+
},
|
|
1384
|
+
{
|
|
1385
|
+
"name": "--out",
|
|
1386
|
+
"type": "str",
|
|
1387
|
+
"help": "Output path for the C# classes",
|
|
1388
|
+
"required": false
|
|
1389
|
+
},
|
|
1390
|
+
{
|
|
1391
|
+
"name": "--struct",
|
|
1392
|
+
"type": "str",
|
|
1393
|
+
"help": "Deprecated: Path to the JSON Structure file (for backcompat)",
|
|
1394
|
+
"required": false
|
|
1395
|
+
},
|
|
1396
|
+
{
|
|
1397
|
+
"name": "--namespace",
|
|
1398
|
+
"type": "str",
|
|
1399
|
+
"help": "C# root namespace",
|
|
1400
|
+
"required": false
|
|
1401
|
+
},
|
|
1402
|
+
{
|
|
1403
|
+
"name": "--project-name",
|
|
1404
|
+
"type": "str",
|
|
1405
|
+
"help": "C# project name",
|
|
1406
|
+
"required": false
|
|
1407
|
+
},
|
|
1408
|
+
{
|
|
1409
|
+
"name": "--system_text_json_annotation",
|
|
1410
|
+
"type": "bool",
|
|
1411
|
+
"help": "Use System.Text.Json annotations",
|
|
1412
|
+
"default": false,
|
|
1413
|
+
"required": false
|
|
1414
|
+
},
|
|
1415
|
+
{
|
|
1416
|
+
"name": "--system-xml-annotation",
|
|
1417
|
+
"type": "bool",
|
|
1418
|
+
"help": "Use System.Xml annotations",
|
|
1419
|
+
"default": false,
|
|
1420
|
+
"required": false
|
|
1421
|
+
},
|
|
1422
|
+
{
|
|
1423
|
+
"name": "--newtonsoft-json-annotation",
|
|
1424
|
+
"type": "bool",
|
|
1425
|
+
"help": "Use Newtonsoft.Json annotations",
|
|
1426
|
+
"default": false,
|
|
1427
|
+
"required": false
|
|
1428
|
+
},
|
|
1429
|
+
{
|
|
1430
|
+
"name": "--pascal-properties",
|
|
1431
|
+
"type": "bool",
|
|
1432
|
+
"help": "Use PascalCase properties",
|
|
1433
|
+
"default": false,
|
|
1434
|
+
"required": false
|
|
1435
|
+
}
|
|
1436
|
+
],
|
|
1437
|
+
"suggested_output_file_path": "{input_file_name}-cs",
|
|
1438
|
+
"prompts": [
|
|
1439
|
+
{
|
|
1440
|
+
"name": "--namespace",
|
|
1441
|
+
"message": "Enter the C# root namespace for the project",
|
|
1442
|
+
"type": "str",
|
|
1443
|
+
"default": "{input_file_name}",
|
|
1444
|
+
"required": false
|
|
1445
|
+
},
|
|
1446
|
+
{
|
|
1447
|
+
"name": "--project-name",
|
|
1448
|
+
"message": "Enter the C# project name",
|
|
1449
|
+
"type": "str",
|
|
1450
|
+
"default": "{input_file_name}",
|
|
1451
|
+
"required": false
|
|
1452
|
+
},
|
|
1453
|
+
{
|
|
1454
|
+
"name": "--system_text_json_annotation",
|
|
1455
|
+
"message": "Use System.Text.Json annotations?",
|
|
1456
|
+
"type": "bool",
|
|
1457
|
+
"default": false,
|
|
1458
|
+
"required": false
|
|
1459
|
+
},
|
|
1460
|
+
{
|
|
1461
|
+
"name": "--pascal-properties",
|
|
1462
|
+
"message": "Use PascalCase properties?",
|
|
1463
|
+
"type": "bool",
|
|
1464
|
+
"default": false,
|
|
1465
|
+
"required": false
|
|
1466
|
+
}
|
|
1467
|
+
]
|
|
1468
|
+
},
|
|
1469
|
+
{
|
|
1470
|
+
"command": "a2java",
|
|
1471
|
+
"description": "Convert Avrotize schema to Java classes",
|
|
1472
|
+
"group": "2_ProgLanguages",
|
|
1473
|
+
"function": {
|
|
1474
|
+
"name": "avrotize.avrotojava.convert_avro_to_java",
|
|
1475
|
+
"args": {
|
|
1476
|
+
"avro_schema_path": "input_file_path",
|
|
1477
|
+
"java_file_path": "output_file_path",
|
|
1478
|
+
"package_name": "args.package",
|
|
1479
|
+
"avro_annotation": "args.avro_annotation",
|
|
1480
|
+
"jackson_annotation": "args.jackson_annotation",
|
|
1481
|
+
"pascal_properties": "args.pascal_properties"
|
|
1482
|
+
}
|
|
1483
|
+
},
|
|
1484
|
+
"extensions": [
|
|
1485
|
+
".avsc"
|
|
1486
|
+
],
|
|
1487
|
+
"args": [
|
|
1488
|
+
{
|
|
1489
|
+
"name": "input",
|
|
1490
|
+
"type": "str",
|
|
1491
|
+
"nargs": "?",
|
|
1492
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
1493
|
+
"required": false
|
|
1494
|
+
},
|
|
1495
|
+
{
|
|
1496
|
+
"name": "--out",
|
|
1497
|
+
"type": "str",
|
|
1498
|
+
"help": "Output path for the Java classes",
|
|
1499
|
+
"required": true
|
|
1500
|
+
},
|
|
1501
|
+
{
|
|
1502
|
+
"name": "--avsc",
|
|
1503
|
+
"type": "str",
|
|
1504
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
1505
|
+
"required": false
|
|
1506
|
+
},
|
|
1507
|
+
{
|
|
1508
|
+
"name": "--package",
|
|
1509
|
+
"type": "str",
|
|
1510
|
+
"help": "Java package name",
|
|
1511
|
+
"required": false
|
|
1512
|
+
},
|
|
1513
|
+
{
|
|
1514
|
+
"name": "--avro-annotation",
|
|
1515
|
+
"type": "bool",
|
|
1516
|
+
"help": "Use Avro annotations",
|
|
1517
|
+
"default": false,
|
|
1518
|
+
"required": false
|
|
1519
|
+
},
|
|
1520
|
+
{
|
|
1521
|
+
"name": "--jackson-annotation",
|
|
1522
|
+
"type": "bool",
|
|
1523
|
+
"help": "Use Jackson annotations",
|
|
1524
|
+
"default": false,
|
|
1525
|
+
"required": false
|
|
1526
|
+
},
|
|
1527
|
+
{
|
|
1528
|
+
"name": "--pascal-properties",
|
|
1529
|
+
"type": "bool",
|
|
1530
|
+
"help": "Use PascalCase properties",
|
|
1531
|
+
"default": false,
|
|
1532
|
+
"required": false
|
|
1533
|
+
}
|
|
1534
|
+
],
|
|
1535
|
+
"suggested_output_file_path": "{input_file_name}-java",
|
|
1536
|
+
"prompts": [
|
|
1537
|
+
{
|
|
1538
|
+
"name": "--avro-annotation",
|
|
1539
|
+
"message": "Use Avro annotations?",
|
|
1540
|
+
"type": "bool",
|
|
1541
|
+
"default": false
|
|
1542
|
+
},
|
|
1543
|
+
{
|
|
1544
|
+
"name": "--jackson-annotation",
|
|
1545
|
+
"message": "Use Jackson annotations?",
|
|
1546
|
+
"type": "bool",
|
|
1547
|
+
"default": false
|
|
1548
|
+
},
|
|
1549
|
+
{
|
|
1550
|
+
"name": "--pascal-properties",
|
|
1551
|
+
"message": "Use PascalCase properties?",
|
|
1552
|
+
"type": "bool",
|
|
1553
|
+
"default": false
|
|
1554
|
+
}
|
|
1555
|
+
]
|
|
1556
|
+
},
|
|
1557
|
+
{
|
|
1558
|
+
"command": "a2py",
|
|
1559
|
+
"description": "Convert Avrotize schema to Python classes",
|
|
1560
|
+
"group": "2_ProgLanguages",
|
|
1561
|
+
"function": {
|
|
1562
|
+
"name": "avrotize.avrotopython.convert_avro_to_python",
|
|
1563
|
+
"args": {
|
|
1564
|
+
"avro_schema_path": "input_file_path",
|
|
1565
|
+
"py_file_path": "output_file_path",
|
|
1566
|
+
"package_name": "args.package",
|
|
1567
|
+
"dataclasses_json_annotation": "args.dataclasses_json_annotation",
|
|
1568
|
+
"avro_annotation": "args.avro_annotation"
|
|
1569
|
+
}
|
|
1570
|
+
},
|
|
1571
|
+
"extensions": [
|
|
1572
|
+
".avsc"
|
|
1573
|
+
],
|
|
1574
|
+
"args": [
|
|
1575
|
+
{
|
|
1576
|
+
"name": "input",
|
|
1577
|
+
"type": "str",
|
|
1578
|
+
"nargs": "?",
|
|
1579
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
1580
|
+
"required": false
|
|
1581
|
+
},
|
|
1582
|
+
{
|
|
1583
|
+
"name": "--out",
|
|
1584
|
+
"type": "str",
|
|
1585
|
+
"help": "Output path for the Python classes",
|
|
1586
|
+
"required": true
|
|
1587
|
+
},
|
|
1588
|
+
{
|
|
1589
|
+
"name": "--avsc",
|
|
1590
|
+
"type": "str",
|
|
1591
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
1592
|
+
"required": false
|
|
1593
|
+
},
|
|
1594
|
+
{
|
|
1595
|
+
"name": "--package",
|
|
1596
|
+
"type": "str",
|
|
1597
|
+
"help": "Python package name",
|
|
1598
|
+
"required": false
|
|
1599
|
+
},
|
|
1600
|
+
{
|
|
1601
|
+
"name": "--dataclasses-json-annotation",
|
|
1602
|
+
"type": "bool",
|
|
1603
|
+
"help": "Use dataclasses-json annotations",
|
|
1604
|
+
"default": false,
|
|
1605
|
+
"required": false
|
|
1606
|
+
},
|
|
1607
|
+
{
|
|
1608
|
+
"name": "--avro-annotation",
|
|
1609
|
+
"type": "bool",
|
|
1610
|
+
"help": "Use Avro annotations",
|
|
1611
|
+
"default": false,
|
|
1612
|
+
"required": false
|
|
1613
|
+
}
|
|
1614
|
+
],
|
|
1615
|
+
"suggested_output_file_path": "{input_file_name}-py",
|
|
1616
|
+
"prompts": [
|
|
1617
|
+
{
|
|
1618
|
+
"name": "--dataclasses-json-annotation",
|
|
1619
|
+
"message": "Use dataclasses-json annotations?",
|
|
1620
|
+
"type": "bool",
|
|
1621
|
+
"default": false
|
|
1622
|
+
},
|
|
1623
|
+
{
|
|
1624
|
+
"name": "--avro-annotation",
|
|
1625
|
+
"message": "Use apache_avro annotations?",
|
|
1626
|
+
"type": "bool",
|
|
1627
|
+
"default": false
|
|
1628
|
+
}
|
|
1629
|
+
]
|
|
1630
|
+
},
|
|
1631
|
+
{
|
|
1632
|
+
"command": "s2py",
|
|
1633
|
+
"description": "Convert JSON Structure to Python classes",
|
|
1634
|
+
"group": "2_ProgLanguages",
|
|
1635
|
+
"function": {
|
|
1636
|
+
"name": "avrotize.structuretopython.convert_structure_to_python",
|
|
1637
|
+
"args": {
|
|
1638
|
+
"structure_schema_path": "input_file_path",
|
|
1639
|
+
"py_file_path": "output_file_path",
|
|
1640
|
+
"package_name": "args.package",
|
|
1641
|
+
"dataclasses_json_annotation": "args.dataclasses_json_annotation",
|
|
1642
|
+
"avro_annotation": "args.avro_annotation"
|
|
1643
|
+
}
|
|
1644
|
+
},
|
|
1645
|
+
"extensions": [
|
|
1646
|
+
".struct.json",
|
|
1647
|
+
".json"
|
|
1648
|
+
],
|
|
1649
|
+
"args": [
|
|
1650
|
+
{
|
|
1651
|
+
"name": "input",
|
|
1652
|
+
"type": "str",
|
|
1653
|
+
"nargs": "?",
|
|
1654
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
1655
|
+
"required": false
|
|
1656
|
+
},
|
|
1657
|
+
{
|
|
1658
|
+
"name": "--out",
|
|
1659
|
+
"type": "str",
|
|
1660
|
+
"help": "Output path for the Python classes",
|
|
1661
|
+
"required": true
|
|
1662
|
+
},
|
|
1663
|
+
{
|
|
1664
|
+
"name": "--package",
|
|
1665
|
+
"type": "str",
|
|
1666
|
+
"help": "Python package name",
|
|
1667
|
+
"required": false
|
|
1668
|
+
},
|
|
1669
|
+
{
|
|
1670
|
+
"name": "--dataclasses-json-annotation",
|
|
1671
|
+
"type": "bool",
|
|
1672
|
+
"help": "Use dataclasses-json annotations",
|
|
1673
|
+
"default": false,
|
|
1674
|
+
"required": false
|
|
1675
|
+
},
|
|
1676
|
+
{
|
|
1677
|
+
"name": "--avro-annotation",
|
|
1678
|
+
"type": "bool",
|
|
1679
|
+
"help": "Add Avro binary serialization support with embedded Structure schema",
|
|
1680
|
+
"default": false,
|
|
1681
|
+
"required": false
|
|
1682
|
+
}
|
|
1683
|
+
],
|
|
1684
|
+
"suggested_output_file_path": "{input_file_name}-py",
|
|
1685
|
+
"prompts": [
|
|
1686
|
+
{
|
|
1687
|
+
"name": "--dataclasses-json-annotation",
|
|
1688
|
+
"message": "Use dataclasses-json annotations?",
|
|
1689
|
+
"type": "bool",
|
|
1690
|
+
"default": false
|
|
1691
|
+
}
|
|
1692
|
+
]
|
|
1693
|
+
},
|
|
1694
|
+
{
|
|
1695
|
+
"command": "s2cpp",
|
|
1696
|
+
"description": "Convert JSON Structure to C++ classes",
|
|
1697
|
+
"group": "2_ProgLanguages",
|
|
1698
|
+
"function": {
|
|
1699
|
+
"name": "avrotize.structuretocpp.convert_structure_to_cpp",
|
|
1700
|
+
"args": {
|
|
1701
|
+
"structure_schema_path": "input_file_path",
|
|
1702
|
+
"output_dir": "output_file_path",
|
|
1703
|
+
"namespace": "args.namespace",
|
|
1704
|
+
"json_annotation": "args.json_annotation"
|
|
1705
|
+
}
|
|
1706
|
+
},
|
|
1707
|
+
"extensions": [".struct.json", ".json"],
|
|
1708
|
+
"args": [
|
|
1709
|
+
{
|
|
1710
|
+
"name": "input",
|
|
1711
|
+
"type": "str",
|
|
1712
|
+
"nargs": "?",
|
|
1713
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
1714
|
+
"required": false
|
|
1715
|
+
},
|
|
1716
|
+
{
|
|
1717
|
+
"name": "--out",
|
|
1718
|
+
"type": "str",
|
|
1719
|
+
"help": "Output path for the C++ classes",
|
|
1720
|
+
"required": true
|
|
1721
|
+
},
|
|
1722
|
+
{
|
|
1723
|
+
"name": "--namespace",
|
|
1724
|
+
"type": "str",
|
|
1725
|
+
"help": "C++ root namespace",
|
|
1726
|
+
"required": false
|
|
1727
|
+
},
|
|
1728
|
+
{
|
|
1729
|
+
"name": "--json-annotation",
|
|
1730
|
+
"type": "bool",
|
|
1731
|
+
"help": "Include JSON serialization support",
|
|
1732
|
+
"default": true,
|
|
1733
|
+
"required": false
|
|
1734
|
+
}
|
|
1735
|
+
],
|
|
1736
|
+
"suggested_output_file_path": "{input_file_name}-cpp",
|
|
1737
|
+
"prompts": [
|
|
1738
|
+
{
|
|
1739
|
+
"name": "--json-annotation",
|
|
1740
|
+
"message": "Include JSON serialization support?",
|
|
1741
|
+
"type": "bool",
|
|
1742
|
+
"default": true
|
|
1743
|
+
}
|
|
1744
|
+
]
|
|
1745
|
+
},
|
|
1746
|
+
{
|
|
1747
|
+
"command": "s2csv",
|
|
1748
|
+
"description": "Convert JSON Structure to CSV schema",
|
|
1749
|
+
"group": "1_Schemas",
|
|
1750
|
+
"function": {
|
|
1751
|
+
"name": "avrotize.structuretocsv.convert_structure_to_csv_schema",
|
|
1752
|
+
"args": {
|
|
1753
|
+
"structure_schema_path": "input_file_path",
|
|
1754
|
+
"csv_schema_path": "output_file_path"
|
|
1755
|
+
}
|
|
1756
|
+
},
|
|
1757
|
+
"extensions": [".struct.json", ".json"],
|
|
1758
|
+
"args": [
|
|
1759
|
+
{
|
|
1760
|
+
"name": "input",
|
|
1761
|
+
"type": "str",
|
|
1762
|
+
"nargs": "?",
|
|
1763
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
1764
|
+
"required": false
|
|
1765
|
+
},
|
|
1766
|
+
{
|
|
1767
|
+
"name": "--out",
|
|
1768
|
+
"type": "str",
|
|
1769
|
+
"help": "Output path for the CSV schema file",
|
|
1770
|
+
"required": false
|
|
1771
|
+
}
|
|
1772
|
+
],
|
|
1773
|
+
"suggested_output_file_path": "{input_file_name}.csv.json",
|
|
1774
|
+
"prompts": []
|
|
1775
|
+
},
|
|
1776
|
+
{
|
|
1777
|
+
"command": "s2rust",
|
|
1778
|
+
"description": "Convert JSON Structure to Rust classes",
|
|
1779
|
+
"group": "2_ProgLanguages",
|
|
1780
|
+
"function": {
|
|
1781
|
+
"name": "avrotize.structuretorust.convert_structure_to_rust",
|
|
1782
|
+
"args": {
|
|
1783
|
+
"structure_schema_path": "input_file_path",
|
|
1784
|
+
"rust_file_path": "output_file_path",
|
|
1785
|
+
"package_name": "args.package",
|
|
1786
|
+
"serde_annotation": "args.json_annotation"
|
|
1787
|
+
}
|
|
1788
|
+
},
|
|
1789
|
+
"extensions": [".struct.json", ".json"],
|
|
1790
|
+
"args": [
|
|
1791
|
+
{
|
|
1792
|
+
"name": "input",
|
|
1793
|
+
"type": "str",
|
|
1794
|
+
"nargs": "?",
|
|
1795
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
1796
|
+
"required": false
|
|
1797
|
+
},
|
|
1798
|
+
{
|
|
1799
|
+
"name": "--out",
|
|
1800
|
+
"type": "str",
|
|
1801
|
+
"help": "Output path for the Rust classes",
|
|
1802
|
+
"required": true
|
|
1803
|
+
},
|
|
1804
|
+
{
|
|
1805
|
+
"name": "--package",
|
|
1806
|
+
"type": "str",
|
|
1807
|
+
"help": "Rust package name",
|
|
1808
|
+
"required": false
|
|
1809
|
+
},
|
|
1810
|
+
{
|
|
1811
|
+
"name": "--json-annotation",
|
|
1812
|
+
"type": "bool",
|
|
1813
|
+
"help": "Use Serde JSON annotations",
|
|
1814
|
+
"default": false,
|
|
1815
|
+
"required": false
|
|
1816
|
+
}
|
|
1817
|
+
],
|
|
1818
|
+
"suggested_output_file_path": "{input_file_name}-rust",
|
|
1819
|
+
"prompts": [
|
|
1820
|
+
{
|
|
1821
|
+
"name": "--package",
|
|
1822
|
+
"message": "Enter the Rust package name (optional)",
|
|
1823
|
+
"type": "str",
|
|
1824
|
+
"required": false
|
|
1825
|
+
},
|
|
1826
|
+
{
|
|
1827
|
+
"name": "--json-annotation",
|
|
1828
|
+
"message": "Use Serde JSON annotations?",
|
|
1829
|
+
"type": "bool",
|
|
1830
|
+
"default": false
|
|
1831
|
+
}
|
|
1832
|
+
]
|
|
1833
|
+
},
|
|
1834
|
+
{
|
|
1835
|
+
"command": "s2ts",
|
|
1836
|
+
"description": "Convert JSON Structure to TypeScript classes",
|
|
1837
|
+
"group": "2_ProgLanguages",
|
|
1838
|
+
"function": {
|
|
1839
|
+
"name": "avrotize.structuretots.convert_structure_to_typescript",
|
|
1840
|
+
"args": {
|
|
1841
|
+
"structure_schema_path": "input_file_path",
|
|
1842
|
+
"ts_file_path": "output_file_path",
|
|
1843
|
+
"package_name": "args.package",
|
|
1844
|
+
"typedjson_annotation": "args.typedjson_annotation",
|
|
1845
|
+
"avro_annotation": "args.avro_annotation"
|
|
1846
|
+
}
|
|
1847
|
+
},
|
|
1848
|
+
"extensions": [".struct.json", ".json"],
|
|
1849
|
+
"args": [
|
|
1850
|
+
{
|
|
1851
|
+
"name": "input",
|
|
1852
|
+
"type": "str",
|
|
1853
|
+
"nargs": "?",
|
|
1854
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
1855
|
+
"required": false
|
|
1856
|
+
},
|
|
1857
|
+
{
|
|
1858
|
+
"name": "--out",
|
|
1859
|
+
"type": "str",
|
|
1860
|
+
"help": "Output path for the TypeScript classes",
|
|
1861
|
+
"required": true
|
|
1862
|
+
},
|
|
1863
|
+
{
|
|
1864
|
+
"name": "--package",
|
|
1865
|
+
"type": "str",
|
|
1866
|
+
"help": "TypeScript package name",
|
|
1867
|
+
"required": false
|
|
1868
|
+
},
|
|
1869
|
+
{
|
|
1870
|
+
"name": "--typedjson-annotation",
|
|
1871
|
+
"type": "bool",
|
|
1872
|
+
"help": "Use TypedJSON annotations",
|
|
1873
|
+
"default": false,
|
|
1874
|
+
"required": false
|
|
1875
|
+
},
|
|
1876
|
+
{
|
|
1877
|
+
"name": "--avro-annotation",
|
|
1878
|
+
"type": "bool",
|
|
1879
|
+
"help": "Add Avro binary serialization support with embedded Structure schema",
|
|
1880
|
+
"default": false,
|
|
1881
|
+
"required": false
|
|
1882
|
+
}
|
|
1883
|
+
],
|
|
1884
|
+
"suggested_output_file_path": "{input_file_name}-ts",
|
|
1885
|
+
"prompts": [
|
|
1886
|
+
{
|
|
1887
|
+
"name": "--typedjson-annotation",
|
|
1888
|
+
"message": "Use TypedJSON annotations?",
|
|
1889
|
+
"type": "bool",
|
|
1890
|
+
"default": false
|
|
1891
|
+
}
|
|
1892
|
+
]
|
|
1893
|
+
},
|
|
1894
|
+
{
|
|
1895
|
+
"command": "s2java",
|
|
1896
|
+
"description": "Convert JSON Structure to Java classes",
|
|
1897
|
+
"group": "2_ProgLanguages",
|
|
1898
|
+
"function": {
|
|
1899
|
+
"name": "avrotize.structuretojava.convert_structure_to_java",
|
|
1900
|
+
"args": {
|
|
1901
|
+
"structure_schema_path": "input_file_path",
|
|
1902
|
+
"java_file_path": "output_file_path",
|
|
1903
|
+
"package_name": "args.package",
|
|
1904
|
+
"pascal_properties": "args.pascal_properties",
|
|
1905
|
+
"jackson_annotation": "args.jackson_annotation"
|
|
1906
|
+
}
|
|
1907
|
+
},
|
|
1908
|
+
"extensions": [".struct.json", ".json"],
|
|
1909
|
+
"args": [
|
|
1910
|
+
{
|
|
1911
|
+
"name": "input",
|
|
1912
|
+
"type": "str",
|
|
1913
|
+
"nargs": "?",
|
|
1914
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
1915
|
+
"required": false
|
|
1916
|
+
},
|
|
1917
|
+
{
|
|
1918
|
+
"name": "--out",
|
|
1919
|
+
"type": "str",
|
|
1920
|
+
"help": "Output path for the Java classes",
|
|
1921
|
+
"required": true
|
|
1922
|
+
},
|
|
1923
|
+
{
|
|
1924
|
+
"name": "--package",
|
|
1925
|
+
"type": "str",
|
|
1926
|
+
"help": "Java package name",
|
|
1927
|
+
"required": false
|
|
1928
|
+
},
|
|
1929
|
+
{
|
|
1930
|
+
"name": "--jackson-annotation",
|
|
1931
|
+
"type": "bool",
|
|
1932
|
+
"help": "Use Jackson annotations for JSON serialization",
|
|
1933
|
+
"default": true,
|
|
1934
|
+
"required": false
|
|
1935
|
+
},
|
|
1936
|
+
{
|
|
1937
|
+
"name": "--pascal-properties",
|
|
1938
|
+
"type": "bool",
|
|
1939
|
+
"help": "Use PascalCase for property names",
|
|
1940
|
+
"default": false,
|
|
1941
|
+
"required": false
|
|
1942
|
+
}
|
|
1943
|
+
],
|
|
1944
|
+
"suggested_output_file_path": "{input_file_name}-java",
|
|
1945
|
+
"prompts": [
|
|
1946
|
+
{
|
|
1947
|
+
"name": "--package",
|
|
1948
|
+
"message": "Enter the Java package name",
|
|
1949
|
+
"type": "str",
|
|
1950
|
+
"default": "{input_file_name}",
|
|
1951
|
+
"required": false
|
|
1952
|
+
},
|
|
1953
|
+
{
|
|
1954
|
+
"name": "--jackson-annotation",
|
|
1955
|
+
"message": "Use Jackson annotations?",
|
|
1956
|
+
"type": "bool",
|
|
1957
|
+
"default": true
|
|
1958
|
+
}
|
|
1959
|
+
]
|
|
1960
|
+
},
|
|
1961
|
+
{
|
|
1962
|
+
"command": "s2go",
|
|
1963
|
+
"description": "Convert JSON Structure to Go structs",
|
|
1964
|
+
"group": "2_ProgLanguages",
|
|
1965
|
+
"function": {
|
|
1966
|
+
"name": "avrotize.structuretogo.convert_structure_to_go",
|
|
1967
|
+
"args": {
|
|
1968
|
+
"structure_schema_path": "input_file_path",
|
|
1969
|
+
"go_file_path": "output_file_path",
|
|
1970
|
+
"package_name": "args.package",
|
|
1971
|
+
"json_annotation": "args.json_annotation",
|
|
1972
|
+
"avro_annotation": "args.avro_annotation",
|
|
1973
|
+
"package_site": "args.package_site",
|
|
1974
|
+
"package_username": "args.package_username"
|
|
1975
|
+
}
|
|
1976
|
+
},
|
|
1977
|
+
"extensions": [".struct.json", ".json"],
|
|
1978
|
+
"args": [
|
|
1979
|
+
{
|
|
1980
|
+
"name": "input",
|
|
1981
|
+
"type": "str",
|
|
1982
|
+
"nargs": "?",
|
|
1983
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
1984
|
+
"required": false
|
|
1985
|
+
},
|
|
1986
|
+
{
|
|
1987
|
+
"name": "--out",
|
|
1988
|
+
"type": "str",
|
|
1989
|
+
"help": "Output path for the Go structs",
|
|
1990
|
+
"required": true
|
|
1991
|
+
},
|
|
1992
|
+
{
|
|
1993
|
+
"name": "--package",
|
|
1994
|
+
"type": "str",
|
|
1995
|
+
"help": "Go package name",
|
|
1996
|
+
"required": false
|
|
1997
|
+
},
|
|
1998
|
+
{
|
|
1999
|
+
"name": "--json-annotation",
|
|
2000
|
+
"type": "bool",
|
|
2001
|
+
"help": "Add JSON struct tags for encoding/json",
|
|
2002
|
+
"default": false,
|
|
2003
|
+
"required": false
|
|
2004
|
+
},
|
|
2005
|
+
{
|
|
2006
|
+
"name": "--avro-annotation",
|
|
2007
|
+
"type": "bool",
|
|
2008
|
+
"help": "Add Avro struct tags",
|
|
2009
|
+
"default": false,
|
|
2010
|
+
"required": false
|
|
2011
|
+
},
|
|
2012
|
+
{
|
|
2013
|
+
"name": "--package-site",
|
|
2014
|
+
"type": "str",
|
|
2015
|
+
"help": "Package site for Go module (e.g., github.com)",
|
|
2016
|
+
"default": "github.com",
|
|
2017
|
+
"required": false
|
|
2018
|
+
},
|
|
2019
|
+
{
|
|
2020
|
+
"name": "--package-username",
|
|
2021
|
+
"type": "str",
|
|
2022
|
+
"help": "Username/organization for Go module",
|
|
2023
|
+
"default": "username",
|
|
2024
|
+
"required": false
|
|
2025
|
+
}
|
|
2026
|
+
],
|
|
2027
|
+
"suggested_output_file_path": "{input_file_name}-go",
|
|
2028
|
+
"prompts": [
|
|
2029
|
+
{
|
|
2030
|
+
"name": "--package",
|
|
2031
|
+
"message": "Enter the Go package name",
|
|
2032
|
+
"type": "str",
|
|
2033
|
+
"default": "{input_file_name}",
|
|
2034
|
+
"required": false
|
|
2035
|
+
},
|
|
2036
|
+
{
|
|
2037
|
+
"name": "--json-annotation",
|
|
2038
|
+
"message": "Add JSON struct tags?",
|
|
2039
|
+
"type": "bool",
|
|
2040
|
+
"default": false
|
|
2041
|
+
}
|
|
2042
|
+
]
|
|
2043
|
+
},
|
|
2044
|
+
{
|
|
2045
|
+
"command": "struct2gql",
|
|
2046
|
+
"description": "Convert JSON Structure schema to GraphQL schema",
|
|
2047
|
+
"group": "1_Schemas",
|
|
2048
|
+
"function": {
|
|
2049
|
+
"name": "avrotize.structuretographql.convert_structure_to_graphql",
|
|
2050
|
+
"args": {
|
|
2051
|
+
"structure_schema_path": "input_file_path",
|
|
2052
|
+
"graphql_schema_path": "output_file_path"
|
|
2053
|
+
}
|
|
2054
|
+
},
|
|
2055
|
+
"extensions": [
|
|
2056
|
+
".struct.json",
|
|
2057
|
+
".json"
|
|
2058
|
+
],
|
|
2059
|
+
"args": [
|
|
2060
|
+
{
|
|
2061
|
+
"name": "input",
|
|
2062
|
+
"type": "str",
|
|
2063
|
+
"nargs": "?",
|
|
2064
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
2065
|
+
"required": false
|
|
2066
|
+
},
|
|
2067
|
+
{
|
|
2068
|
+
"name": "--out",
|
|
2069
|
+
"type": "str",
|
|
2070
|
+
"help": "Path to the GraphQL schema file",
|
|
2071
|
+
"required": false
|
|
2072
|
+
}
|
|
2073
|
+
],
|
|
2074
|
+
"suggested_output_file_path": "{input_file_name}.graphql",
|
|
2075
|
+
"prompts": []
|
|
2076
|
+
},
|
|
2077
|
+
{
|
|
2078
|
+
"command": "a2ts",
|
|
2079
|
+
"description": "Convert Avrotize schema to TypeScript classes",
|
|
2080
|
+
"group": "2_ProgLanguages",
|
|
2081
|
+
"function": {
|
|
2082
|
+
"name": "avrotize.avrotots.convert_avro_to_typescript",
|
|
2083
|
+
"args": {
|
|
2084
|
+
"avro_schema_path": "input_file_path",
|
|
2085
|
+
"js_dir_path": "output_file_path",
|
|
2086
|
+
"package_name": "args.package",
|
|
2087
|
+
"avro_annotation": "args.avro_annotation",
|
|
2088
|
+
"typedjson_annotation": "args.typedjson_annotation"
|
|
2089
|
+
}
|
|
2090
|
+
},
|
|
2091
|
+
"extensions": [
|
|
2092
|
+
".avsc"
|
|
2093
|
+
],
|
|
2094
|
+
"args": [
|
|
2095
|
+
{
|
|
2096
|
+
"name": "input",
|
|
2097
|
+
"type": "str",
|
|
2098
|
+
"nargs": "?",
|
|
2099
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2100
|
+
"required": false
|
|
2101
|
+
},
|
|
2102
|
+
{
|
|
2103
|
+
"name": "--out",
|
|
2104
|
+
"type": "str",
|
|
2105
|
+
"help": "Output path for the TypeScript classes",
|
|
2106
|
+
"required": true
|
|
2107
|
+
},
|
|
2108
|
+
{
|
|
2109
|
+
"name": "--avsc",
|
|
2110
|
+
"type": "str",
|
|
2111
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
2112
|
+
"required": false
|
|
2113
|
+
},
|
|
2114
|
+
{
|
|
2115
|
+
"name": "--package",
|
|
2116
|
+
"type": "str",
|
|
2117
|
+
"help": "TypeScript package name",
|
|
2118
|
+
"required": false
|
|
2119
|
+
},
|
|
2120
|
+
{
|
|
2121
|
+
"name": "--avro-annotation",
|
|
2122
|
+
"type": "bool",
|
|
2123
|
+
"help": "Use Avro annotations",
|
|
2124
|
+
"default": false,
|
|
2125
|
+
"required": false
|
|
2126
|
+
},
|
|
2127
|
+
{
|
|
2128
|
+
"name": "--typedjson-annotation",
|
|
2129
|
+
"type": "bool",
|
|
2130
|
+
"help": "Use TypedJSON annotations",
|
|
2131
|
+
"default": false,
|
|
2132
|
+
"required": false
|
|
2133
|
+
}
|
|
2134
|
+
],
|
|
2135
|
+
"suggested_output_file_path": "{input_file_name}-ts",
|
|
2136
|
+
"prompts": [
|
|
2137
|
+
{
|
|
2138
|
+
"name": "--avro-annotation",
|
|
2139
|
+
"message": "Use Avro annotations?",
|
|
2140
|
+
"type": "bool",
|
|
2141
|
+
"default": false
|
|
2142
|
+
},
|
|
2143
|
+
{
|
|
2144
|
+
"name": "--typedjson-annotation",
|
|
2145
|
+
"message": "Use TypedJSON annotations?",
|
|
2146
|
+
"type": "bool",
|
|
2147
|
+
"default": false
|
|
2148
|
+
}
|
|
2149
|
+
]
|
|
2150
|
+
},
|
|
2151
|
+
{
|
|
2152
|
+
"command": "a2js",
|
|
2153
|
+
"description": "Convert Avrotize schema to JavaScript classes",
|
|
2154
|
+
"group": "2_ProgLanguages",
|
|
2155
|
+
"function": {
|
|
2156
|
+
"name": "avrotize.avrotojs.convert_avro_to_javascript",
|
|
2157
|
+
"args": {
|
|
2158
|
+
"avro_schema_path": "input_file_path",
|
|
2159
|
+
"js_dir_path": "output_file_path",
|
|
2160
|
+
"package_name": "args.package",
|
|
2161
|
+
"avro_annotation": "args.avro_annotation"
|
|
2162
|
+
}
|
|
2163
|
+
},
|
|
2164
|
+
"extensions": [
|
|
2165
|
+
".avsc"
|
|
2166
|
+
],
|
|
2167
|
+
"args": [
|
|
2168
|
+
{
|
|
2169
|
+
"name": "input",
|
|
2170
|
+
"type": "str",
|
|
2171
|
+
"nargs": "?",
|
|
2172
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2173
|
+
"required": false
|
|
2174
|
+
},
|
|
2175
|
+
{
|
|
2176
|
+
"name": "--out",
|
|
2177
|
+
"type": "str",
|
|
2178
|
+
"help": "Output path for the JavaScript classes",
|
|
2179
|
+
"required": true
|
|
2180
|
+
},
|
|
2181
|
+
{
|
|
2182
|
+
"name": "--avsc",
|
|
2183
|
+
"type": "str",
|
|
2184
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
2185
|
+
"required": false
|
|
2186
|
+
},
|
|
2187
|
+
{
|
|
2188
|
+
"name": "--package",
|
|
2189
|
+
"type": "str",
|
|
2190
|
+
"help": "JavaScript package name",
|
|
2191
|
+
"required": false
|
|
2192
|
+
},
|
|
2193
|
+
{
|
|
2194
|
+
"name": "--avro-annotation",
|
|
2195
|
+
"type": "bool",
|
|
2196
|
+
"help": "Use Avro annotations",
|
|
2197
|
+
"default": false,
|
|
2198
|
+
"required": false
|
|
2199
|
+
}
|
|
2200
|
+
],
|
|
2201
|
+
"suggested_output_file_path": "{input_file_name}-js",
|
|
2202
|
+
"prompts": [
|
|
2203
|
+
{
|
|
2204
|
+
"name": "--avro-annotation",
|
|
2205
|
+
"message": "Use Avro annotations?",
|
|
2206
|
+
"type": "bool",
|
|
2207
|
+
"default": false
|
|
2208
|
+
}
|
|
2209
|
+
]
|
|
2210
|
+
},
|
|
2211
|
+
{
|
|
2212
|
+
"command": "a2cpp",
|
|
2213
|
+
"description": "Convert Avrotize schema to C++ classes",
|
|
2214
|
+
"group": "2_ProgLanguages",
|
|
2215
|
+
"function": {
|
|
2216
|
+
"name": "avrotize.avrotocpp.convert_avro_to_cpp",
|
|
2217
|
+
"args": {
|
|
2218
|
+
"avro_schema_path": "input_file_path",
|
|
2219
|
+
"output_dir": "output_file_path",
|
|
2220
|
+
"namespace": "args.namespace",
|
|
2221
|
+
"avro_annotation": "args.avro_annotation",
|
|
2222
|
+
"json_annotation": "args.json_annotation"
|
|
2223
|
+
}
|
|
2224
|
+
},
|
|
2225
|
+
"extensions": [
|
|
2226
|
+
".avsc"
|
|
2227
|
+
],
|
|
2228
|
+
"args": [
|
|
2229
|
+
{
|
|
2230
|
+
"name": "input",
|
|
2231
|
+
"type": "str",
|
|
2232
|
+
"nargs": "?",
|
|
2233
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2234
|
+
"required": false
|
|
2235
|
+
},
|
|
2236
|
+
{
|
|
2237
|
+
"name": "--out",
|
|
2238
|
+
"type": "str",
|
|
2239
|
+
"help": "Output path for the C++ classes",
|
|
2240
|
+
"required": true
|
|
2241
|
+
},
|
|
2242
|
+
{
|
|
2243
|
+
"name": "--avsc",
|
|
2244
|
+
"type": "str",
|
|
2245
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
2246
|
+
"required": false
|
|
2247
|
+
},
|
|
2248
|
+
{
|
|
2249
|
+
"name": "--namespace",
|
|
2250
|
+
"type": "str",
|
|
2251
|
+
"help": "C++ namespace",
|
|
2252
|
+
"required": false
|
|
2253
|
+
},
|
|
2254
|
+
{
|
|
2255
|
+
"name": "--avro-annotation",
|
|
2256
|
+
"type": "bool",
|
|
2257
|
+
"help": "Use Avro annotations",
|
|
2258
|
+
"default": false,
|
|
2259
|
+
"required": false
|
|
2260
|
+
},
|
|
2261
|
+
{
|
|
2262
|
+
"name": "--json-annotation",
|
|
2263
|
+
"type": "bool",
|
|
2264
|
+
"help": "Use JSON annotations",
|
|
2265
|
+
"default": false,
|
|
2266
|
+
"required": false
|
|
2267
|
+
}
|
|
2268
|
+
],
|
|
2269
|
+
"suggested_output_file_path": "{input_file_name}-cpp",
|
|
2270
|
+
"prompts": [
|
|
2271
|
+
{
|
|
2272
|
+
"name": "--namespace",
|
|
2273
|
+
"message": "Enter the root namespace for the C++ classes (optional)",
|
|
2274
|
+
"type": "str",
|
|
2275
|
+
"default": "{input_file_name}",
|
|
2276
|
+
"required": false
|
|
2277
|
+
},
|
|
2278
|
+
{
|
|
2279
|
+
"name": "--avro-annotation",
|
|
2280
|
+
"message": "Use Avro annotations?",
|
|
2281
|
+
"type": "bool",
|
|
2282
|
+
"default": false
|
|
2283
|
+
},
|
|
2284
|
+
{
|
|
2285
|
+
"name": "--json-annotation",
|
|
2286
|
+
"message": "Use JSON annotations?",
|
|
2287
|
+
"type": "bool",
|
|
2288
|
+
"default": false
|
|
2289
|
+
}
|
|
2290
|
+
]
|
|
2291
|
+
},
|
|
2292
|
+
{
|
|
2293
|
+
"command": "a2go",
|
|
2294
|
+
"description": "Convert Avrotize schema to Go classes",
|
|
2295
|
+
"group": "2_ProgLanguages",
|
|
2296
|
+
"function": {
|
|
2297
|
+
"name": "avrotize.avrotogo.convert_avro_to_go",
|
|
2298
|
+
"args": {
|
|
2299
|
+
"avro_schema_path": "input_file_path",
|
|
2300
|
+
"go_file_path": "output_file_path",
|
|
2301
|
+
"package_name": "args.package",
|
|
2302
|
+
"avro_annotation": "args.avro_annotation",
|
|
2303
|
+
"json_annotation": "args.json_annotation",
|
|
2304
|
+
"package_site": "args.package_site",
|
|
2305
|
+
"package_username": "args.package_username"
|
|
2306
|
+
}
|
|
2307
|
+
},
|
|
2308
|
+
"extensions": [
|
|
2309
|
+
".avsc"
|
|
2310
|
+
],
|
|
2311
|
+
"args": [
|
|
2312
|
+
{
|
|
2313
|
+
"name": "input",
|
|
2314
|
+
"type": "str",
|
|
2315
|
+
"nargs": "?",
|
|
2316
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2317
|
+
"required": false
|
|
2318
|
+
},
|
|
2319
|
+
{
|
|
2320
|
+
"name": "--out",
|
|
2321
|
+
"type": "str",
|
|
2322
|
+
"help": "Output path for the Go classes",
|
|
2323
|
+
"required": true
|
|
2324
|
+
},
|
|
2325
|
+
{
|
|
2326
|
+
"name": "--avsc",
|
|
2327
|
+
"type": "str",
|
|
2328
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
2329
|
+
"required": false
|
|
2330
|
+
},
|
|
2331
|
+
{
|
|
2332
|
+
"name": "--package",
|
|
2333
|
+
"type": "str",
|
|
2334
|
+
"help": "Go package name",
|
|
2335
|
+
"required": false
|
|
2336
|
+
},
|
|
2337
|
+
{
|
|
2338
|
+
"name": "--package-site",
|
|
2339
|
+
"type": "str",
|
|
2340
|
+
"help": "Go package site",
|
|
2341
|
+
"required": false
|
|
2342
|
+
},
|
|
2343
|
+
{
|
|
2344
|
+
"name": "--package-username",
|
|
2345
|
+
"type": "str",
|
|
2346
|
+
"help": "Go package username",
|
|
2347
|
+
"required": false
|
|
2348
|
+
},
|
|
2349
|
+
{
|
|
2350
|
+
"name": "--avro-annotation",
|
|
2351
|
+
"type": "bool",
|
|
2352
|
+
"help": "Use Avro annotations",
|
|
2353
|
+
"default": false,
|
|
2354
|
+
"required": false
|
|
2355
|
+
},
|
|
2356
|
+
{
|
|
2357
|
+
"name": "--json-annotation",
|
|
2358
|
+
"type": "bool",
|
|
2359
|
+
"help": "Use JSON annotations",
|
|
2360
|
+
"default": false,
|
|
2361
|
+
"required": false
|
|
2362
|
+
}
|
|
2363
|
+
],
|
|
2364
|
+
"suggested_output_file_path": "{input_file_name}-go",
|
|
2365
|
+
"prompts": [
|
|
2366
|
+
{
|
|
2367
|
+
"name": "--avro-annotation",
|
|
2368
|
+
"message": "Use Avro annotations?",
|
|
2369
|
+
"type": "bool",
|
|
2370
|
+
"default": false
|
|
2371
|
+
},
|
|
2372
|
+
{
|
|
2373
|
+
"name": "--json-annotation",
|
|
2374
|
+
"message": "Use JSON annotations?",
|
|
2375
|
+
"type": "bool",
|
|
2376
|
+
"default": false
|
|
2377
|
+
},
|
|
2378
|
+
{
|
|
2379
|
+
"name": "--package",
|
|
2380
|
+
"message": "Enter the Go package name (optional)",
|
|
2381
|
+
"type": "str",
|
|
2382
|
+
"required": false
|
|
2383
|
+
},
|
|
2384
|
+
{
|
|
2385
|
+
"name": "--package-site",
|
|
2386
|
+
"message": "Enter the Go package site (optional)",
|
|
2387
|
+
"type": "str",
|
|
2388
|
+
"required": false
|
|
2389
|
+
},
|
|
2390
|
+
{
|
|
2391
|
+
"name": "--package-username",
|
|
2392
|
+
"message": "Enter the Go package username (optional)",
|
|
2393
|
+
"type": "str",
|
|
2394
|
+
"required": false
|
|
2395
|
+
}
|
|
2396
|
+
]
|
|
2397
|
+
},
|
|
2398
|
+
{
|
|
2399
|
+
"command": "a2rust",
|
|
2400
|
+
"description": "Convert Avrotize schema to Rust classes",
|
|
2401
|
+
"group": "2_ProgLanguages",
|
|
2402
|
+
"function": {
|
|
2403
|
+
"name": "avrotize.avrotorust.convert_avro_to_rust",
|
|
2404
|
+
"args": {
|
|
2405
|
+
"avro_schema_path": "input_file_path",
|
|
2406
|
+
"rust_file_path": "output_file_path",
|
|
2407
|
+
"package_name": "args.package",
|
|
2408
|
+
"avro_annotation": "args.avro_annotation",
|
|
2409
|
+
"serde_annotation": "args.json_annotation"
|
|
2410
|
+
}
|
|
2411
|
+
},
|
|
2412
|
+
"extensions": [
|
|
2413
|
+
".avsc"
|
|
2414
|
+
],
|
|
2415
|
+
"args": [
|
|
2416
|
+
{
|
|
2417
|
+
"name": "input",
|
|
2418
|
+
"type": "str",
|
|
2419
|
+
"nargs": "?",
|
|
2420
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2421
|
+
"required": false
|
|
2422
|
+
},
|
|
2423
|
+
{
|
|
2424
|
+
"name": "--out",
|
|
2425
|
+
"type": "str",
|
|
2426
|
+
"help": "Output path for the Rust classes",
|
|
2427
|
+
"required": true
|
|
2428
|
+
},
|
|
2429
|
+
{
|
|
2430
|
+
"name": "--avsc",
|
|
2431
|
+
"type": "str",
|
|
2432
|
+
"help": "Deprecated: Path to the Avrotize schema file (for backcompat)",
|
|
2433
|
+
"required": false
|
|
2434
|
+
},
|
|
2435
|
+
{
|
|
2436
|
+
"name": "--package",
|
|
2437
|
+
"type": "str",
|
|
2438
|
+
"help": "Rust package name",
|
|
2439
|
+
"required": false
|
|
2440
|
+
},
|
|
2441
|
+
{
|
|
2442
|
+
"name": "--avro-annotation",
|
|
2443
|
+
"type": "bool",
|
|
2444
|
+
"help": "Use Avro annotations",
|
|
2445
|
+
"default": false,
|
|
2446
|
+
"required": false
|
|
2447
|
+
},
|
|
2448
|
+
{
|
|
2449
|
+
"name": "--json-annotation",
|
|
2450
|
+
"type": "bool",
|
|
2451
|
+
"help": "Use JSON annotations",
|
|
2452
|
+
"default": false,
|
|
2453
|
+
"required": false
|
|
2454
|
+
}
|
|
2455
|
+
],
|
|
2456
|
+
"suggested_output_file_path": "{input_file_name}-rust",
|
|
2457
|
+
"prompts": [
|
|
2458
|
+
{
|
|
2459
|
+
"name": "--package",
|
|
2460
|
+
"message": "Enter the Rust package name (optional)",
|
|
2461
|
+
"type": "str",
|
|
2462
|
+
"required": false
|
|
2463
|
+
},
|
|
2464
|
+
{
|
|
2465
|
+
"name": "--avro-annotation",
|
|
2466
|
+
"message": "Use Avro annotations?",
|
|
2467
|
+
"type": "bool",
|
|
2468
|
+
"default": false
|
|
2469
|
+
},
|
|
2470
|
+
{
|
|
2471
|
+
"name": "--json-annotation",
|
|
2472
|
+
"message": "Use JSON annotations?",
|
|
2473
|
+
"type": "bool",
|
|
2474
|
+
"default": false
|
|
2475
|
+
}
|
|
2476
|
+
]
|
|
2477
|
+
},
|
|
2478
|
+
{
|
|
2479
|
+
"command": "a2dp",
|
|
2480
|
+
"description": "Convert Avrotize schema to Datapackage schema",
|
|
2481
|
+
"group": "1_Schemas",
|
|
2482
|
+
"function": {
|
|
2483
|
+
"name": "avrotize.avrotodatapackage.convert_avro_to_datapackage",
|
|
2484
|
+
"args": {
|
|
2485
|
+
"avro_schema_path": "input_file_path",
|
|
2486
|
+
"datapackage_path": "output_file_path",
|
|
2487
|
+
"avro_record_type": "args.record_type"
|
|
2488
|
+
}
|
|
2489
|
+
},
|
|
2490
|
+
"extensions": [
|
|
2491
|
+
".avsc"
|
|
2492
|
+
],
|
|
2493
|
+
"args": [
|
|
2494
|
+
{
|
|
2495
|
+
"name": "input",
|
|
2496
|
+
"type": "str",
|
|
2497
|
+
"nargs": "?",
|
|
2498
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2499
|
+
"required": false
|
|
2500
|
+
},
|
|
2501
|
+
{
|
|
2502
|
+
"name": "--out",
|
|
2503
|
+
"type": "str",
|
|
2504
|
+
"help": "Output path for the Datapackage schema",
|
|
2505
|
+
"required": false
|
|
2506
|
+
},
|
|
2507
|
+
{
|
|
2508
|
+
"name": "--record-type",
|
|
2509
|
+
"type": "str",
|
|
2510
|
+
"help": "Record type in the Avrotize schema",
|
|
2511
|
+
"required": false
|
|
2512
|
+
}
|
|
2513
|
+
],
|
|
2514
|
+
"suggested_output_file_path": "{input_file_name}.json",
|
|
2515
|
+
"prompts": [
|
|
2516
|
+
{
|
|
2517
|
+
"name": "--record-type",
|
|
2518
|
+
"message": "Enter the record type in the Avro schema (optional)",
|
|
2519
|
+
"type": "str",
|
|
2520
|
+
"required": false
|
|
2521
|
+
}
|
|
2522
|
+
]
|
|
2523
|
+
},
|
|
2524
|
+
{
|
|
2525
|
+
"command": "s2dp",
|
|
2526
|
+
"description": "Convert JSON Structure schema to Datapackage schema",
|
|
2527
|
+
"group": "1_Schemas",
|
|
2528
|
+
"function": {
|
|
2529
|
+
"name": "avrotize.structuretodatapackage.convert_structure_to_datapackage",
|
|
2530
|
+
"args": {
|
|
2531
|
+
"structure_schema_path": "input_file_path",
|
|
2532
|
+
"datapackage_path": "output_file_path",
|
|
2533
|
+
"structure_record_type": "args.record_type"
|
|
2534
|
+
}
|
|
2535
|
+
},
|
|
2536
|
+
"extensions": [
|
|
2537
|
+
".struct.json",
|
|
2538
|
+
".json"
|
|
2539
|
+
],
|
|
2540
|
+
"args": [
|
|
2541
|
+
{
|
|
2542
|
+
"name": "input",
|
|
2543
|
+
"type": "str",
|
|
2544
|
+
"nargs": "?",
|
|
2545
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
2546
|
+
"required": false
|
|
2547
|
+
},
|
|
2548
|
+
{
|
|
2549
|
+
"name": "--out",
|
|
2550
|
+
"type": "str",
|
|
2551
|
+
"help": "Output path for the Datapackage schema",
|
|
2552
|
+
"required": false
|
|
2553
|
+
},
|
|
2554
|
+
{
|
|
2555
|
+
"name": "--record-type",
|
|
2556
|
+
"type": "str",
|
|
2557
|
+
"help": "Record type in the JSON Structure schema",
|
|
2558
|
+
"required": false
|
|
2559
|
+
}
|
|
2560
|
+
],
|
|
2561
|
+
"suggested_output_file_path": "{input_file_name}.datapackage.json",
|
|
2562
|
+
"prompts": [
|
|
2563
|
+
{
|
|
2564
|
+
"name": "--record-type",
|
|
2565
|
+
"message": "Enter the record type in the JSON Structure schema (optional)",
|
|
2566
|
+
"type": "str",
|
|
2567
|
+
"required": false
|
|
2568
|
+
}
|
|
2569
|
+
]
|
|
2570
|
+
},
|
|
2571
|
+
{
|
|
2572
|
+
"command": "a2md",
|
|
2573
|
+
"description": "Convert Avrotize schema to Markdown documentation",
|
|
2574
|
+
"group": "7_Utility",
|
|
2575
|
+
"function": {
|
|
2576
|
+
"name": "avrotize.avrotomd.convert_avro_to_markdown",
|
|
2577
|
+
"args": {
|
|
2578
|
+
"avro_schema_path": "input_file_path",
|
|
2579
|
+
"markdown_path": "output_file_path"
|
|
2580
|
+
}
|
|
2581
|
+
},
|
|
2582
|
+
"extensions": [
|
|
2583
|
+
".avsc"
|
|
2584
|
+
],
|
|
2585
|
+
"args": [
|
|
2586
|
+
{
|
|
2587
|
+
"name": "input",
|
|
2588
|
+
"type": "str",
|
|
2589
|
+
"nargs": "?",
|
|
2590
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2591
|
+
"required": false
|
|
2592
|
+
},
|
|
2593
|
+
{
|
|
2594
|
+
"name": "--out",
|
|
2595
|
+
"type": "str",
|
|
2596
|
+
"help": "Output path for the Markdown documentation",
|
|
2597
|
+
"required": false
|
|
2598
|
+
}
|
|
2599
|
+
],
|
|
2600
|
+
"suggested_output_file_path": "{input_file_name}.md",
|
|
2601
|
+
"prompts": []
|
|
2602
|
+
},
|
|
2603
|
+
{
|
|
2604
|
+
"command": "pcf",
|
|
2605
|
+
"description": "Create the Parsing Canonical Form (PCF) of an Avrotize schema",
|
|
2606
|
+
"group": "7_Utility",
|
|
2607
|
+
"function": {
|
|
2608
|
+
"name": "avrotize.avrotools.avsc_to_pcf",
|
|
2609
|
+
"args": {
|
|
2610
|
+
"schema_file": "input_file_path"
|
|
2611
|
+
}
|
|
2612
|
+
},
|
|
2613
|
+
"extensions": [
|
|
2614
|
+
".avsc"
|
|
2615
|
+
],
|
|
2616
|
+
"args": [
|
|
2617
|
+
{
|
|
2618
|
+
"name": "input",
|
|
2619
|
+
"type": "str",
|
|
2620
|
+
"nargs": "?",
|
|
2621
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2622
|
+
"required": false
|
|
2623
|
+
}
|
|
2624
|
+
],
|
|
2625
|
+
"prompts": []
|
|
2626
|
+
},
|
|
2627
|
+
{
|
|
2628
|
+
"command": "csv2a",
|
|
2629
|
+
"description": "Convert CSV file to Avrotize schema",
|
|
2630
|
+
"group": "1_Schemas",
|
|
2631
|
+
"function": {
|
|
2632
|
+
"name": "avrotize.csvtoavro.convert_csv_to_avro",
|
|
2633
|
+
"args": {
|
|
2634
|
+
"csv_file_path": "input_file_path",
|
|
2635
|
+
"avro_file_path": "output_file_path",
|
|
2636
|
+
"namespace": "args.namespace"
|
|
2637
|
+
}
|
|
2638
|
+
},
|
|
2639
|
+
"extensions": [
|
|
2640
|
+
".csv"
|
|
2641
|
+
],
|
|
2642
|
+
"args": [
|
|
2643
|
+
{
|
|
2644
|
+
"name": "input",
|
|
2645
|
+
"type": "str",
|
|
2646
|
+
"nargs": "?",
|
|
2647
|
+
"help": "Path to the CSV file (or read from stdin if omitted)",
|
|
2648
|
+
"required": false
|
|
2649
|
+
},
|
|
2650
|
+
{
|
|
2651
|
+
"name": "--out",
|
|
2652
|
+
"type": "str",
|
|
2653
|
+
"help": "Path to the Avrotize schema file",
|
|
2654
|
+
"required": false
|
|
2655
|
+
},
|
|
2656
|
+
{
|
|
2657
|
+
"name": "--namespace",
|
|
2658
|
+
"type": "str",
|
|
2659
|
+
"help": "Namespace for the Avrotize schema",
|
|
2660
|
+
"required": false
|
|
2661
|
+
}
|
|
2662
|
+
],
|
|
2663
|
+
"suggested_output_file_path": "{input_file_name}.avsc",
|
|
2664
|
+
"prompts": [
|
|
2665
|
+
{
|
|
2666
|
+
"name": "--namespace",
|
|
2667
|
+
"message": "Enter the namespace for the Avro schema",
|
|
2668
|
+
"type": "str",
|
|
2669
|
+
"required": false
|
|
2670
|
+
}
|
|
2671
|
+
]
|
|
2672
|
+
},
|
|
2673
|
+
{
|
|
2674
|
+
"command": "a2cassandra",
|
|
2675
|
+
"description": "Convert Avrotize schema to Cassandra schema",
|
|
2676
|
+
"group": "5_SQL",
|
|
2677
|
+
"function": {
|
|
2678
|
+
"name": "avrotize.avrotodb.convert_avro_to_sql",
|
|
2679
|
+
"args": {
|
|
2680
|
+
"avro_schema_path": "input_file_path",
|
|
2681
|
+
"dbscript_file_path": "output_file_path",
|
|
2682
|
+
"db_dialect": "cassandra",
|
|
2683
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
2684
|
+
}
|
|
2685
|
+
},
|
|
2686
|
+
"extensions": [
|
|
2687
|
+
".avsc"
|
|
2688
|
+
],
|
|
2689
|
+
"args": [
|
|
2690
|
+
{
|
|
2691
|
+
"name": "input",
|
|
2692
|
+
"type": "str",
|
|
2693
|
+
"nargs": "?",
|
|
2694
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2695
|
+
"required": false
|
|
2696
|
+
},
|
|
2697
|
+
{
|
|
2698
|
+
"name": "--out",
|
|
2699
|
+
"type": "str",
|
|
2700
|
+
"help": "Path to the Cassandra schema file",
|
|
2701
|
+
"required": true
|
|
2702
|
+
},
|
|
2703
|
+
{
|
|
2704
|
+
"name": "--emit-cloudevents-columns",
|
|
2705
|
+
"type": "bool",
|
|
2706
|
+
"help": "Add CloudEvents columns to the Cassandra schema",
|
|
2707
|
+
"default": false,
|
|
2708
|
+
"required": false
|
|
2709
|
+
}
|
|
2710
|
+
],
|
|
2711
|
+
"suggested_output_file_path": "{input_file_name}.cql",
|
|
2712
|
+
"prompts": [
|
|
2713
|
+
{
|
|
2714
|
+
"name": "--emit-cloudevents-columns",
|
|
2715
|
+
"message": "Add CloudEvents columns to the Cassandra schema?",
|
|
2716
|
+
"type": "bool",
|
|
2717
|
+
"default": false
|
|
2718
|
+
}
|
|
2719
|
+
]
|
|
2720
|
+
},
|
|
2721
|
+
{
|
|
2722
|
+
"command": "struct2cassandra",
|
|
2723
|
+
"description": "Convert JSON Structure schema to Cassandra schema",
|
|
2724
|
+
"group": "5_SQL",
|
|
2725
|
+
"function": {
|
|
2726
|
+
"name": "avrotize.structuretodb.convert_structure_to_sql",
|
|
2727
|
+
"args": {
|
|
2728
|
+
"structure_schema_path": "input_file_path",
|
|
2729
|
+
"dbscript_file_path": "output_file_path",
|
|
2730
|
+
"db_dialect": "cassandra",
|
|
2731
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
2732
|
+
}
|
|
2733
|
+
},
|
|
2734
|
+
"extensions": [
|
|
2735
|
+
".jstruct",
|
|
2736
|
+
".struct.json"
|
|
2737
|
+
],
|
|
2738
|
+
"args": [
|
|
2739
|
+
{
|
|
2740
|
+
"name": "input",
|
|
2741
|
+
"type": "str",
|
|
2742
|
+
"nargs": "?",
|
|
2743
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
2744
|
+
"required": false
|
|
2745
|
+
},
|
|
2746
|
+
{
|
|
2747
|
+
"name": "--out",
|
|
2748
|
+
"type": "str",
|
|
2749
|
+
"help": "Path to the Cassandra schema file",
|
|
2750
|
+
"required": false
|
|
2751
|
+
},
|
|
2752
|
+
{
|
|
2753
|
+
"name": "--emit-cloudevents-columns",
|
|
2754
|
+
"type": "bool",
|
|
2755
|
+
"help": "Add CloudEvents columns",
|
|
2756
|
+
"default": false,
|
|
2757
|
+
"required": false
|
|
2758
|
+
}
|
|
2759
|
+
],
|
|
2760
|
+
"suggested_output_file_path": "{input_file_name}.cql",
|
|
2761
|
+
"prompts": []
|
|
2762
|
+
},
|
|
2763
|
+
{
|
|
2764
|
+
"command": "a2dynamodb",
|
|
2765
|
+
"description": "Convert Avrotize schema to DynamoDB schema",
|
|
2766
|
+
"group": "6_NoSQL",
|
|
2767
|
+
"function": {
|
|
2768
|
+
"name": "avrotize.avrotodb.convert_avro_to_nosql",
|
|
2769
|
+
"args": {
|
|
2770
|
+
"avro_schema_path": "input_file_path",
|
|
2771
|
+
"nosql_file_path": "output_file_path",
|
|
2772
|
+
"nosql_dialect": "dynamodb",
|
|
2773
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
2774
|
+
}
|
|
2775
|
+
},
|
|
2776
|
+
"extensions": [
|
|
2777
|
+
".avsc"
|
|
2778
|
+
],
|
|
2779
|
+
"args": [
|
|
2780
|
+
{
|
|
2781
|
+
"name": "input",
|
|
2782
|
+
"type": "str",
|
|
2783
|
+
"nargs": "?",
|
|
2784
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2785
|
+
"required": false
|
|
2786
|
+
},
|
|
2787
|
+
{
|
|
2788
|
+
"name": "--out",
|
|
2789
|
+
"type": "str",
|
|
2790
|
+
"help": "Path to the DynamoDB schema file",
|
|
2791
|
+
"required": true
|
|
2792
|
+
},
|
|
2793
|
+
{
|
|
2794
|
+
"name": "--emit-cloudevents-columns",
|
|
2795
|
+
"type": "bool",
|
|
2796
|
+
"help": "Add CloudEvents columns to the DynamoDB schema",
|
|
2797
|
+
"default": false,
|
|
2798
|
+
"required": false
|
|
2799
|
+
}
|
|
2800
|
+
],
|
|
2801
|
+
"suggested_output_file_path": "{input_file_name}.json",
|
|
2802
|
+
"prompts": [
|
|
2803
|
+
{
|
|
2804
|
+
"name": "--emit-cloudevents-columns",
|
|
2805
|
+
"message": "Add CloudEvents columns to the DynamoDB schema?",
|
|
2806
|
+
"type": "bool",
|
|
2807
|
+
"default": false
|
|
2808
|
+
}
|
|
2809
|
+
]
|
|
2810
|
+
},
|
|
2811
|
+
{
|
|
2812
|
+
"command": "a2es",
|
|
2813
|
+
"description": "Convert Avrotize schema to Elasticsearch schema",
|
|
2814
|
+
"group": "6_NoSQL",
|
|
2815
|
+
"function": {
|
|
2816
|
+
"name": "avrotize.avrotodb.convert_avro_to_nosql",
|
|
2817
|
+
"args": {
|
|
2818
|
+
"avro_schema_path": "input_file_path",
|
|
2819
|
+
"nosql_file_path": "output_file_path",
|
|
2820
|
+
"nosql_dialect": "elasticsearch",
|
|
2821
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
2822
|
+
}
|
|
2823
|
+
},
|
|
2824
|
+
"extensions": [
|
|
2825
|
+
".avsc"
|
|
2826
|
+
],
|
|
2827
|
+
"args": [
|
|
2828
|
+
{
|
|
2829
|
+
"name": "input",
|
|
2830
|
+
"type": "str",
|
|
2831
|
+
"nargs": "?",
|
|
2832
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2833
|
+
"required": false
|
|
2834
|
+
},
|
|
2835
|
+
{
|
|
2836
|
+
"name": "--out",
|
|
2837
|
+
"type": "str",
|
|
2838
|
+
"help": "Path to the Elasticsearch schema file",
|
|
2839
|
+
"required": true
|
|
2840
|
+
},
|
|
2841
|
+
{
|
|
2842
|
+
"name": "--emit-cloudevents-columns",
|
|
2843
|
+
"type": "bool",
|
|
2844
|
+
"help": "Add CloudEvents columns to the Elasticsearch schema",
|
|
2845
|
+
"default": false,
|
|
2846
|
+
"required": false
|
|
2847
|
+
}
|
|
2848
|
+
],
|
|
2849
|
+
"suggested_output_file_path": "{input_file_name}.json",
|
|
2850
|
+
"prompts": [
|
|
2851
|
+
{
|
|
2852
|
+
"name": "--emit-cloudevents-columns",
|
|
2853
|
+
"message": "Add CloudEvents columns to the Elasticsearch schema?",
|
|
2854
|
+
"type": "bool",
|
|
2855
|
+
"default": false
|
|
2856
|
+
}
|
|
2857
|
+
]
|
|
2858
|
+
},
|
|
2859
|
+
{
|
|
2860
|
+
"command": "a2couchdb",
|
|
2861
|
+
"description": "Convert Avrotize schema to CouchDB schema",
|
|
2862
|
+
"group": "6_NoSQL",
|
|
2863
|
+
"function": {
|
|
2864
|
+
"name": "avrotize.avrotodb.convert_avro_to_nosql",
|
|
2865
|
+
"args": {
|
|
2866
|
+
"avro_schema_path": "input_file_path",
|
|
2867
|
+
"nosql_file_path": "output_file_path",
|
|
2868
|
+
"nosql_dialect": "couchdb",
|
|
2869
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
2870
|
+
}
|
|
2871
|
+
},
|
|
2872
|
+
"extensions": [
|
|
2873
|
+
".avsc"
|
|
2874
|
+
],
|
|
2875
|
+
"args": [
|
|
2876
|
+
{
|
|
2877
|
+
"name": "input",
|
|
2878
|
+
"type": "str",
|
|
2879
|
+
"nargs": "?",
|
|
2880
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2881
|
+
"required": false
|
|
2882
|
+
},
|
|
2883
|
+
{
|
|
2884
|
+
"name": "--out",
|
|
2885
|
+
"type": "str",
|
|
2886
|
+
"help": "Path to the CouchDB schema file",
|
|
2887
|
+
"required": true
|
|
2888
|
+
},
|
|
2889
|
+
{
|
|
2890
|
+
"name": "--emit-cloudevents-columns",
|
|
2891
|
+
"type": "bool",
|
|
2892
|
+
"help": "Add CloudEvents columns to the CouchDB schema",
|
|
2893
|
+
"default": false,
|
|
2894
|
+
"required": false
|
|
2895
|
+
}
|
|
2896
|
+
],
|
|
2897
|
+
"suggested_output_file_path": "{input_file_name}.json",
|
|
2898
|
+
"prompts": [
|
|
2899
|
+
{
|
|
2900
|
+
"name": "--emit-cloudevents-columns",
|
|
2901
|
+
"message": "Add CloudEvents columns to the CouchDB schema?",
|
|
2902
|
+
"type": "bool",
|
|
2903
|
+
"default": false
|
|
2904
|
+
}
|
|
2905
|
+
]
|
|
2906
|
+
},
|
|
2907
|
+
{
|
|
2908
|
+
"command": "a2neo4j",
|
|
2909
|
+
"description": "Convert Avrotize schema to Neo4j schema",
|
|
2910
|
+
"group": "6_NoSQL",
|
|
2911
|
+
"function": {
|
|
2912
|
+
"name": "avrotize.avrotodb.convert_avro_to_nosql",
|
|
2913
|
+
"args": {
|
|
2914
|
+
"avro_schema_path": "input_file_path",
|
|
2915
|
+
"nosql_file_path": "output_file_path",
|
|
2916
|
+
"nosql_dialect": "neo4j",
|
|
2917
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
2918
|
+
}
|
|
2919
|
+
},
|
|
2920
|
+
"extensions": [
|
|
2921
|
+
".avsc"
|
|
2922
|
+
],
|
|
2923
|
+
"args": [
|
|
2924
|
+
{
|
|
2925
|
+
"name": "input",
|
|
2926
|
+
"type": "str",
|
|
2927
|
+
"nargs": "?",
|
|
2928
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2929
|
+
"required": false
|
|
2930
|
+
},
|
|
2931
|
+
{
|
|
2932
|
+
"name": "--out",
|
|
2933
|
+
"type": "str",
|
|
2934
|
+
"help": "Path to the Neo4j schema file",
|
|
2935
|
+
"required": true
|
|
2936
|
+
},
|
|
2937
|
+
{
|
|
2938
|
+
"name": "--emit-cloudevents-columns",
|
|
2939
|
+
"type": "bool",
|
|
2940
|
+
"help": "Add CloudEvents columns to the Neo4j schema",
|
|
2941
|
+
"default": false,
|
|
2942
|
+
"required": false
|
|
2943
|
+
}
|
|
2944
|
+
],
|
|
2945
|
+
"suggested_output_file_path": "{input_file_name}.cypher",
|
|
2946
|
+
"prompts": [
|
|
2947
|
+
{
|
|
2948
|
+
"name": "--emit-cloudevents-columns",
|
|
2949
|
+
"message": "Add CloudEvents columns to the Neo4j schema?",
|
|
2950
|
+
"type": "bool",
|
|
2951
|
+
"default": false
|
|
2952
|
+
}
|
|
2953
|
+
]
|
|
2954
|
+
},
|
|
2955
|
+
{
|
|
2956
|
+
"command": "a2firebase",
|
|
2957
|
+
"description": "Convert Avrotize schema to Firebase schema",
|
|
2958
|
+
"group": "6_NoSQL",
|
|
2959
|
+
"function": {
|
|
2960
|
+
"name": "avrotize.avrotodb.convert_avro_to_nosql",
|
|
2961
|
+
"args": {
|
|
2962
|
+
"avro_schema_path": "input_file_path",
|
|
2963
|
+
"nosql_file_path": "output_file_path",
|
|
2964
|
+
"nosql_dialect": "firebase",
|
|
2965
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
2966
|
+
}
|
|
2967
|
+
},
|
|
2968
|
+
"extensions": [
|
|
2969
|
+
".avsc"
|
|
2970
|
+
],
|
|
2971
|
+
"args": [
|
|
2972
|
+
{
|
|
2973
|
+
"name": "input",
|
|
2974
|
+
"type": "str",
|
|
2975
|
+
"nargs": "?",
|
|
2976
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
2977
|
+
"required": false
|
|
2978
|
+
},
|
|
2979
|
+
{
|
|
2980
|
+
"name": "--out",
|
|
2981
|
+
"type": "str",
|
|
2982
|
+
"help": "Path to the Firebase schema file",
|
|
2983
|
+
"required": true
|
|
2984
|
+
},
|
|
2985
|
+
{
|
|
2986
|
+
"name": "--emit-cloudevents-columns",
|
|
2987
|
+
"type": "bool",
|
|
2988
|
+
"help": "Add CloudEvents columns to the Firebase schema",
|
|
2989
|
+
"default": false,
|
|
2990
|
+
"required": false
|
|
2991
|
+
}
|
|
2992
|
+
],
|
|
2993
|
+
"suggested_output_file_path": "{input_file_name}.json",
|
|
2994
|
+
"prompts": [
|
|
2995
|
+
{
|
|
2996
|
+
"name": "--emit-cloudevents-columns",
|
|
2997
|
+
"message": "Add CloudEvents columns to the Firebase schema?",
|
|
2998
|
+
"type": "bool",
|
|
2999
|
+
"default": false
|
|
3000
|
+
}
|
|
3001
|
+
]
|
|
3002
|
+
},
|
|
3003
|
+
{
|
|
3004
|
+
"command": "a2cosmos",
|
|
3005
|
+
"description": "Convert Avrotize schema to CosmosDB schema",
|
|
3006
|
+
"group": "6_NoSQL",
|
|
3007
|
+
"function": {
|
|
3008
|
+
"name": "avrotize.avrotodb.convert_avro_to_nosql",
|
|
3009
|
+
"args": {
|
|
3010
|
+
"avro_schema_path": "input_file_path",
|
|
3011
|
+
"nosql_file_path": "output_file_path",
|
|
3012
|
+
"nosql_dialect": "cosmosdb",
|
|
3013
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
3014
|
+
}
|
|
3015
|
+
},
|
|
3016
|
+
"extensions": [
|
|
3017
|
+
".avsc"
|
|
3018
|
+
],
|
|
3019
|
+
"args": [
|
|
3020
|
+
{
|
|
3021
|
+
"name": "input",
|
|
3022
|
+
"type": "str",
|
|
3023
|
+
"nargs": "?",
|
|
3024
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
3025
|
+
"required": false
|
|
3026
|
+
},
|
|
3027
|
+
{
|
|
3028
|
+
"name": "--out",
|
|
3029
|
+
"type": "str",
|
|
3030
|
+
"help": "Path to the CosmosDB schema file",
|
|
3031
|
+
"required": true
|
|
3032
|
+
},
|
|
3033
|
+
{
|
|
3034
|
+
"name": "--emit-cloudevents-columns",
|
|
3035
|
+
"type": "bool",
|
|
3036
|
+
"help": "Add CloudEvents columns to the CosmosDB schema",
|
|
3037
|
+
"default": false,
|
|
3038
|
+
"required": false
|
|
3039
|
+
}
|
|
3040
|
+
],
|
|
3041
|
+
"suggested_output_file_path": "{input_file_name}.json",
|
|
3042
|
+
"prompts": [
|
|
3043
|
+
{
|
|
3044
|
+
"name": "--emit-cloudevents-columns",
|
|
3045
|
+
"message": "Add CloudEvents columns to the CosmosDB schema?",
|
|
3046
|
+
"type": "bool",
|
|
3047
|
+
"default": false
|
|
3048
|
+
}
|
|
3049
|
+
]
|
|
3050
|
+
},
|
|
3051
|
+
{
|
|
3052
|
+
"command": "a2hbase",
|
|
3053
|
+
"description": "Convert Avrotize schema to HBase schema",
|
|
3054
|
+
"group": "6_NoSQL",
|
|
3055
|
+
"function": {
|
|
3056
|
+
"name": "avrotize.avrotodb.convert_avro_to_nosql",
|
|
3057
|
+
"args": {
|
|
3058
|
+
"avro_schema_path": "input_file_path",
|
|
3059
|
+
"nosql_file_path": "output_file_path",
|
|
3060
|
+
"nosql_dialect": "hbase",
|
|
3061
|
+
"emit_cloudevents_columns": "args.emit_cloudevents_columns"
|
|
3062
|
+
}
|
|
3063
|
+
},
|
|
3064
|
+
"extensions": [
|
|
3065
|
+
".avsc"
|
|
3066
|
+
],
|
|
3067
|
+
"args": [
|
|
3068
|
+
{
|
|
3069
|
+
"name": "input",
|
|
3070
|
+
"type": "str",
|
|
3071
|
+
"nargs": "?",
|
|
3072
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
3073
|
+
"required": false
|
|
3074
|
+
},
|
|
3075
|
+
{
|
|
3076
|
+
"name": "--out",
|
|
3077
|
+
"type": "str",
|
|
3078
|
+
"help": "Path to the HBase schema file",
|
|
3079
|
+
"required": true
|
|
3080
|
+
},
|
|
3081
|
+
{
|
|
3082
|
+
"name": "--emit-cloudevents-columns",
|
|
3083
|
+
"type": "bool",
|
|
3084
|
+
"help": "Add CloudEvents columns to the HBase schema",
|
|
3085
|
+
"default": false,
|
|
3086
|
+
"required": false
|
|
3087
|
+
}
|
|
3088
|
+
],
|
|
3089
|
+
"suggested_output_file_path": "{input_file_name}.json",
|
|
3090
|
+
"prompts": [
|
|
3091
|
+
{
|
|
3092
|
+
"name": "--emit-cloudevents-columns",
|
|
3093
|
+
"message": "Add CloudEvents columns to the HBase schema?",
|
|
3094
|
+
"type": "bool",
|
|
3095
|
+
"default": false
|
|
3096
|
+
}
|
|
3097
|
+
]
|
|
3098
|
+
},
|
|
3099
|
+
{
|
|
3100
|
+
"command": "s2a",
|
|
3101
|
+
"description": "Convert JSON structure to Avrotize schema",
|
|
3102
|
+
"group": "1_Schemas",
|
|
3103
|
+
"function": {
|
|
3104
|
+
"name": "avrotize.jstructtoavro.convert_json_structure_to_avro",
|
|
3105
|
+
"args": {
|
|
3106
|
+
"structure_file": "input_file_path",
|
|
3107
|
+
"avro_file": "output_file_path"
|
|
3108
|
+
}
|
|
3109
|
+
},
|
|
3110
|
+
"extensions": [
|
|
3111
|
+
".struct.json",
|
|
3112
|
+
".json"
|
|
3113
|
+
],
|
|
3114
|
+
"args": [
|
|
3115
|
+
{
|
|
3116
|
+
"name": "input",
|
|
3117
|
+
"type": "str",
|
|
3118
|
+
"nargs": "?",
|
|
3119
|
+
"help": "Path to the JSON structure file (or read from stdin if omitted)",
|
|
3120
|
+
"required": false
|
|
3121
|
+
},
|
|
3122
|
+
{
|
|
3123
|
+
"name": "--out",
|
|
3124
|
+
"type": "str",
|
|
3125
|
+
"help": "Path to the Avrotize schema file",
|
|
3126
|
+
"required": false
|
|
3127
|
+
}
|
|
3128
|
+
],
|
|
3129
|
+
"suggested_output_file_path": "{input_file_name}.avsc",
|
|
3130
|
+
"prompts": []
|
|
3131
|
+
},
|
|
3132
|
+
{
|
|
3133
|
+
"command": "a2s",
|
|
3134
|
+
"description": "Convert Avrotize schema to JSON structure",
|
|
3135
|
+
"group": "1_Schemas",
|
|
3136
|
+
"function": {
|
|
3137
|
+
"name": "avrotize.avrotojstruct.convert_avro_to_json_structure",
|
|
3138
|
+
"args": {
|
|
3139
|
+
"avro_schema_file": "input_file_path",
|
|
3140
|
+
"json_structure_file": "output_file_path",
|
|
3141
|
+
"naming_mode": "args.naming",
|
|
3142
|
+
"avro_encoding": "args.avro_encoding"
|
|
3143
|
+
}
|
|
3144
|
+
},
|
|
3145
|
+
"extensions": [
|
|
3146
|
+
".avsc"
|
|
3147
|
+
],
|
|
3148
|
+
"args": [
|
|
3149
|
+
{
|
|
3150
|
+
"name": "input",
|
|
3151
|
+
"type": "str",
|
|
3152
|
+
"nargs": "?",
|
|
3153
|
+
"help": "Path to the Avrotize schema file (or read from stdin if omitted)",
|
|
3154
|
+
"required": false
|
|
3155
|
+
},
|
|
3156
|
+
{
|
|
3157
|
+
"name": "--out",
|
|
3158
|
+
"type": "str",
|
|
3159
|
+
"help": "Path to the JSON structure file",
|
|
3160
|
+
"required": false
|
|
3161
|
+
},
|
|
3162
|
+
{
|
|
3163
|
+
"name": "--naming",
|
|
3164
|
+
"type": "str",
|
|
3165
|
+
"help": "Type naming convention",
|
|
3166
|
+
"choices": [
|
|
3167
|
+
"snake",
|
|
3168
|
+
"camel",
|
|
3169
|
+
"pascal",
|
|
3170
|
+
"default"
|
|
3171
|
+
],
|
|
3172
|
+
"required": false,
|
|
3173
|
+
"default": "default"
|
|
3174
|
+
},
|
|
3175
|
+
{
|
|
3176
|
+
"name": "--avro-encoding",
|
|
3177
|
+
"type": "bool",
|
|
3178
|
+
"help": "Enable Avro encoding for unions",
|
|
3179
|
+
"default": false,
|
|
3180
|
+
"required": false
|
|
3181
|
+
}
|
|
3182
|
+
],
|
|
3183
|
+
"suggested_output_file_path": "{input_file_name}.struct.json",
|
|
3184
|
+
"prompts": []
|
|
3185
|
+
},
|
|
3186
|
+
{
|
|
3187
|
+
"command": "s2x",
|
|
3188
|
+
"description": "Convert JSON Structure to XSD schema",
|
|
3189
|
+
"group": "1_Schemas",
|
|
3190
|
+
"function": {
|
|
3191
|
+
"name": "avrotize.structuretoxsd.convert_structure_to_xsd",
|
|
3192
|
+
"args": {
|
|
3193
|
+
"structure_schema_path": "input_file_path",
|
|
3194
|
+
"xml_file_path": "output_file_path",
|
|
3195
|
+
"target_namespace": "args.namespace"
|
|
3196
|
+
}
|
|
3197
|
+
},
|
|
3198
|
+
"extensions": [".struct.json", ".json"],
|
|
3199
|
+
"args": [
|
|
3200
|
+
{
|
|
3201
|
+
"name": "input",
|
|
3202
|
+
"type": "str",
|
|
3203
|
+
"nargs": "?",
|
|
3204
|
+
"help": "Path to the JSON Structure file (or read from stdin if omitted)",
|
|
3205
|
+
"required": false
|
|
3206
|
+
},
|
|
3207
|
+
{
|
|
3208
|
+
"name": "--out",
|
|
3209
|
+
"type": "str",
|
|
3210
|
+
"help": "Path to the XSD schema file",
|
|
3211
|
+
"required": false
|
|
3212
|
+
},
|
|
3213
|
+
{
|
|
3214
|
+
"name": "--struct",
|
|
3215
|
+
"type": "str",
|
|
3216
|
+
"help": "Deprecated: Path to the JSON Structure file (for backcompat)",
|
|
3217
|
+
"required": false
|
|
3218
|
+
},
|
|
3219
|
+
{
|
|
3220
|
+
"name": "--namespace",
|
|
3221
|
+
"type": "str",
|
|
3222
|
+
"help": "Target namespace for the XSD schema",
|
|
3223
|
+
"required": false
|
|
3224
|
+
}
|
|
3225
|
+
],
|
|
3226
|
+
"suggested_output_file_path": "{input_file_name}.xsd",
|
|
3227
|
+
"prompts": []
|
|
3228
|
+
},
|
|
3229
|
+
{
|
|
3230
|
+
"command": "s2cddl",
|
|
3231
|
+
"description": "Convert JSON Structure to CDDL schema",
|
|
3232
|
+
"group": "1_Schemas",
|
|
3233
|
+
"function": {
|
|
3234
|
+
"name": "avrotize.structuretocddl.convert_structure_to_cddl_files",
|
|
3235
|
+
"args": {
|
|
3236
|
+
"structure_schema_path": "input_file_path",
|
|
3237
|
+
"cddl_file_path": "output_file_path"
|
|
3238
|
+
}
|
|
3239
|
+
},
|
|
3240
|
+
"extensions": [".struct.json", ".json"],
|
|
3241
|
+
"args": [
|
|
3242
|
+
{
|
|
3243
|
+
"name": "input",
|
|
3244
|
+
"type": "str",
|
|
3245
|
+
"nargs": "?",
|
|
3246
|
+
"help": "Path to the JSON Structure file (or read from stdin if omitted)",
|
|
3247
|
+
"required": false
|
|
3248
|
+
},
|
|
3249
|
+
{
|
|
3250
|
+
"name": "--out",
|
|
3251
|
+
"type": "str",
|
|
3252
|
+
"help": "Path to the CDDL schema file",
|
|
3253
|
+
"required": false
|
|
3254
|
+
}
|
|
3255
|
+
],
|
|
3256
|
+
"suggested_output_file_path": "{input_file_name}.cddl",
|
|
3257
|
+
"prompts": []
|
|
3258
|
+
},
|
|
3259
|
+
{
|
|
3260
|
+
"command": "struct2md",
|
|
3261
|
+
"description": "Convert JSON Structure schema to Markdown documentation",
|
|
3262
|
+
"group": "7_Utility",
|
|
3263
|
+
"function": {
|
|
3264
|
+
"name": "avrotize.structuretomd.convert_structure_to_markdown",
|
|
3265
|
+
"args": {
|
|
3266
|
+
"structure_schema_path": "input_file_path",
|
|
3267
|
+
"markdown_path": "output_file_path"
|
|
3268
|
+
}
|
|
3269
|
+
},
|
|
3270
|
+
"extensions": [
|
|
3271
|
+
".struct.json"
|
|
3272
|
+
],
|
|
3273
|
+
"args": [
|
|
3274
|
+
{
|
|
3275
|
+
"name": "input",
|
|
3276
|
+
"type": "str",
|
|
3277
|
+
"nargs": "?",
|
|
3278
|
+
"help": "Path to the JSON Structure schema file (or read from stdin if omitted)",
|
|
3279
|
+
"required": false
|
|
3280
|
+
},
|
|
3281
|
+
{
|
|
3282
|
+
"name": "--out",
|
|
3283
|
+
"type": "str",
|
|
3284
|
+
"help": "Output path for the Markdown documentation",
|
|
3285
|
+
"required": false
|
|
3286
|
+
}
|
|
3287
|
+
],
|
|
3288
|
+
"suggested_output_file_path": "{input_file_name}.md",
|
|
3289
|
+
"prompts": []
|
|
3290
|
+
},
|
|
3291
|
+
{
|
|
3292
|
+
"command": "cddl2s",
|
|
3293
|
+
"description": "Convert CDDL schema to JSON Structure",
|
|
3294
|
+
"group": "1_Schemas",
|
|
3295
|
+
"function": {
|
|
3296
|
+
"name": "avrotize.cddltostructure.convert_cddl_to_structure_files",
|
|
3297
|
+
"args": {
|
|
3298
|
+
"cddl_file_path": "input_file_path",
|
|
3299
|
+
"structure_schema_path": "output_file_path",
|
|
3300
|
+
"namespace": "args.namespace"
|
|
3301
|
+
}
|
|
3302
|
+
},
|
|
3303
|
+
"extensions": [
|
|
3304
|
+
".cddl"
|
|
3305
|
+
],
|
|
3306
|
+
"args": [
|
|
3307
|
+
{
|
|
3308
|
+
"name": "input",
|
|
3309
|
+
"type": "str",
|
|
3310
|
+
"nargs": "?",
|
|
3311
|
+
"help": "Path to the CDDL schema file (or read from stdin if omitted)",
|
|
3312
|
+
"required": false
|
|
3313
|
+
},
|
|
3314
|
+
{
|
|
3315
|
+
"name": "--out",
|
|
3316
|
+
"type": "str",
|
|
3317
|
+
"help": "Path to the JSON Structure file",
|
|
3318
|
+
"required": false
|
|
3319
|
+
},
|
|
3320
|
+
{
|
|
3321
|
+
"name": "--namespace",
|
|
3322
|
+
"type": "str",
|
|
3323
|
+
"help": "Namespace for the JSON Structure schema",
|
|
3324
|
+
"required": false
|
|
3325
|
+
}
|
|
3326
|
+
],
|
|
3327
|
+
"suggested_output_file_path": "{input_file_name}.struct.json",
|
|
3328
|
+
"prompts": [
|
|
3329
|
+
{
|
|
3330
|
+
"name": "--namespace",
|
|
3331
|
+
"message": "Enter the namespace for the JSON Structure schema",
|
|
3332
|
+
"type": "str",
|
|
3333
|
+
"required": false
|
|
3334
|
+
}
|
|
3335
|
+
]
|
|
3336
|
+
}
|
|
3337
|
+
]
|