Coverage for /pythoncovmergedfiles/medio/medio/usr/local/lib/python3.8/site-packages/tensorflow/python/ops/gen_experimental_dataset_ops.py: 6%

1"""Python wrappers around TensorFlow ops. 

2 

3This file is MACHINE GENERATED! Do not edit. 

4""" 

5 

6import collections 

7 

8from tensorflow.python import pywrap_tfe as pywrap_tfe 

9from tensorflow.python.eager import context as _context 

10from tensorflow.python.eager import core as _core 

11from tensorflow.python.eager import execute as _execute 

12from tensorflow.python.framework import dtypes as _dtypes 

13from tensorflow.security.fuzzing.py import annotation_types as _atypes 

14 

15from tensorflow.python.framework import op_def_registry as _op_def_registry 

16from tensorflow.python.framework import ops as _ops 

17from tensorflow.python.framework import op_def_library as _op_def_library 

18from tensorflow.python.util.deprecation import deprecated_endpoints 

19from tensorflow.python.util import dispatch as _dispatch 

20from tensorflow.python.util.tf_export import tf_export 

21 

22from typing import TypeVar 

23 

24def assert_cardinality_dataset(input_dataset, cardinality, output_types, output_shapes, name=None): 

25 r"""TODO: add doc. 

26 

27 Args: 

28 input_dataset: A `Tensor` of type `variant`. 

29 cardinality: A `Tensor` of type `int64`. 

30 output_types: A list of `tf.DTypes` that has length `>= 1`. 

31 output_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`) that has length `>= 1`. 

32 name: A name for the operation (optional). 

33 

34 Returns: 

35 A `Tensor` of type `variant`. 

36 """ 

37 _ctx = _context._context or _context.context() 

38 tld = _ctx._thread_local_data 

39 if tld.is_eager: 

40 try: 

41 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

42 _ctx, "AssertCardinalityDataset", name, input_dataset, cardinality, 

43 "output_types", output_types, "output_shapes", output_shapes) 

44 return _result 

45 except _core._NotOkStatusException as e: 

46 _ops.raise_from_not_ok_status(e, name) 

47 except _core._FallbackException: 

48 pass 

49 try: 

50 return assert_cardinality_dataset_eager_fallback( 

51 input_dataset, cardinality, output_types=output_types, 

52 output_shapes=output_shapes, name=name, ctx=_ctx) 

53 except _core._SymbolicException: 

54 pass # Add nodes to the TensorFlow graph. 

55 # Add nodes to the TensorFlow graph. 

56 if not isinstance(output_types, (list, tuple)): 

57 raise TypeError( 

58 "Expected list for 'output_types' argument to " 

59 "'assert_cardinality_dataset' Op, not %r." % output_types) 

60 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

61 if not isinstance(output_shapes, (list, tuple)): 

62 raise TypeError( 

63 "Expected list for 'output_shapes' argument to " 

64 "'assert_cardinality_dataset' Op, not %r." % output_shapes) 

65 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

66 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

67 "AssertCardinalityDataset", input_dataset=input_dataset, 

68 cardinality=cardinality, 

69 output_types=output_types, 

70 output_shapes=output_shapes, name=name) 

71 _result = _outputs[:] 

72 if _execute.must_record_gradient(): 

73 _attrs = ("output_types", _op.get_attr("output_types"), "output_shapes", 

74 _op.get_attr("output_shapes")) 

75 _inputs_flat = _op.inputs 

76 _execute.record_gradient( 

77 "AssertCardinalityDataset", _inputs_flat, _attrs, _result) 

78 _result, = _result 

79 return _result 

80 

81AssertCardinalityDataset = tf_export("raw_ops.AssertCardinalityDataset")(_ops.to_raw_op(assert_cardinality_dataset)) 

82 

83 

84def assert_cardinality_dataset_eager_fallback(input_dataset, cardinality, output_types, output_shapes, name, ctx): 

85 if not isinstance(output_types, (list, tuple)): 

86 raise TypeError( 

87 "Expected list for 'output_types' argument to " 

88 "'assert_cardinality_dataset' Op, not %r." % output_types) 

89 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

90 if not isinstance(output_shapes, (list, tuple)): 

91 raise TypeError( 

92 "Expected list for 'output_shapes' argument to " 

93 "'assert_cardinality_dataset' Op, not %r." % output_shapes) 

94 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

95 input_dataset = _ops.convert_to_tensor(input_dataset, _dtypes.variant) 

96 cardinality = _ops.convert_to_tensor(cardinality, _dtypes.int64) 

97 _inputs_flat = [input_dataset, cardinality] 

98 _attrs = ("output_types", output_types, "output_shapes", output_shapes) 

99 _result = _execute.execute(b"AssertCardinalityDataset", 1, 

100 inputs=_inputs_flat, attrs=_attrs, ctx=ctx, 

101 name=name) 

102 if _execute.must_record_gradient(): 

103 _execute.record_gradient( 

104 "AssertCardinalityDataset", _inputs_flat, _attrs, _result) 

105 _result, = _result 

106 return _result 

107 

108 

109def assert_next_dataset(input_dataset, transformations, output_types, output_shapes, name=None): 

110 r"""A transformation that asserts which transformations happen next. 

111 

112 This transformation checks whether the camel-case names (i.e. "FlatMap", not 

113 "flat_map") of the transformations following this transformation match the list 

114 of names in the `transformations` argument. If there is a mismatch, the 

115 transformation raises an exception. 

116 

117 The check occurs when iterating over the contents of the dataset, which 

118 means that the check happens *after* any static optimizations are applied 

119 to the dataset graph. 

120 

121 Args: 

122 input_dataset: A `Tensor` of type `variant`. 

123 A variant tensor representing the input dataset. 

124 `AssertNextDataset` passes through the outputs of its input dataset. 

125 transformations: A `Tensor` of type `string`. 

126 A `tf.string` vector `tf.Tensor` identifying the transformations that are 

127 expected to happen next. 

128 output_types: A list of `tf.DTypes` that has length `>= 1`. 

129 output_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`) that has length `>= 1`. 

130 name: A name for the operation (optional). 

131 

132 Returns: 

133 A `Tensor` of type `variant`. 

134 """ 

135 _ctx = _context._context or _context.context() 

136 tld = _ctx._thread_local_data 

137 if tld.is_eager: 

138 try: 

139 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

140 _ctx, "AssertNextDataset", name, input_dataset, transformations, 

141 "output_types", output_types, "output_shapes", output_shapes) 

142 return _result 

143 except _core._NotOkStatusException as e: 

144 _ops.raise_from_not_ok_status(e, name) 

145 except _core._FallbackException: 

146 pass 

147 try: 

148 return assert_next_dataset_eager_fallback( 

149 input_dataset, transformations, output_types=output_types, 

150 output_shapes=output_shapes, name=name, ctx=_ctx) 

151 except _core._SymbolicException: 

152 pass # Add nodes to the TensorFlow graph. 

153 # Add nodes to the TensorFlow graph. 

154 if not isinstance(output_types, (list, tuple)): 

155 raise TypeError( 

156 "Expected list for 'output_types' argument to " 

157 "'assert_next_dataset' Op, not %r." % output_types) 

158 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

159 if not isinstance(output_shapes, (list, tuple)): 

160 raise TypeError( 

161 "Expected list for 'output_shapes' argument to " 

162 "'assert_next_dataset' Op, not %r." % output_shapes) 

163 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

164 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

165 "AssertNextDataset", input_dataset=input_dataset, 

166 transformations=transformations, 

167 output_types=output_types, 

168 output_shapes=output_shapes, name=name) 

169 _result = _outputs[:] 

170 if _execute.must_record_gradient(): 

171 _attrs = ("output_types", _op.get_attr("output_types"), "output_shapes", 

172 _op.get_attr("output_shapes")) 

173 _inputs_flat = _op.inputs 

174 _execute.record_gradient( 

175 "AssertNextDataset", _inputs_flat, _attrs, _result) 

176 _result, = _result 

177 return _result 

178 

179AssertNextDataset = tf_export("raw_ops.AssertNextDataset")(_ops.to_raw_op(assert_next_dataset)) 

180 

181 

182def assert_next_dataset_eager_fallback(input_dataset, transformations, output_types, output_shapes, name, ctx): 

183 if not isinstance(output_types, (list, tuple)): 

184 raise TypeError( 

185 "Expected list for 'output_types' argument to " 

186 "'assert_next_dataset' Op, not %r." % output_types) 

187 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

188 if not isinstance(output_shapes, (list, tuple)): 

189 raise TypeError( 

190 "Expected list for 'output_shapes' argument to " 

191 "'assert_next_dataset' Op, not %r." % output_shapes) 

192 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

193 input_dataset = _ops.convert_to_tensor(input_dataset, _dtypes.variant) 

194 transformations = _ops.convert_to_tensor(transformations, _dtypes.string) 

195 _inputs_flat = [input_dataset, transformations] 

196 _attrs = ("output_types", output_types, "output_shapes", output_shapes) 

197 _result = _execute.execute(b"AssertNextDataset", 1, inputs=_inputs_flat, 

198 attrs=_attrs, ctx=ctx, name=name) 

199 if _execute.must_record_gradient(): 

200 _execute.record_gradient( 

201 "AssertNextDataset", _inputs_flat, _attrs, _result) 

202 _result, = _result 

203 return _result 

204 

205 

206def assert_prev_dataset(input_dataset, transformations, output_types, output_shapes, name=None): 

207 r"""A transformation that asserts which transformations happened previously. 

208 

209 This transformation checks the names and, optionally, the attribute name-value 

210 pairs in the `transformations` argument against those of the transformations 

211 that preceded this transformation. If there is a mismatch, the transformation 

212 raises an exception. 

213 

214 The check occurs when iterating over the contents of the dataset, which 

215 means that the check happens *after* any static optimizations are applied 

216 to the dataset graph. 

217 

218 Args: 

219 input_dataset: A `Tensor` of type `variant`. 

220 A variant tensor representing the input dataset. 

221 `AssertPrevDataset` passes through the outputs of its input dataset. 

222 transformations: A `Tensor` of type `string`. 

223 A `tf.string` vector `tf.Tensor` identifying the transformations, with optional 

224 attribute name-value pairs, that are expected to have happened previously. 

225 output_types: A list of `tf.DTypes` that has length `>= 1`. 

226 output_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`) that has length `>= 1`. 

227 name: A name for the operation (optional). 

228 

229 Returns: 

230 A `Tensor` of type `variant`. 

231 """ 

232 _ctx = _context._context or _context.context() 

233 tld = _ctx._thread_local_data 

234 if tld.is_eager: 

235 try: 

236 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

237 _ctx, "AssertPrevDataset", name, input_dataset, transformations, 

238 "output_types", output_types, "output_shapes", output_shapes) 

239 return _result 

240 except _core._NotOkStatusException as e: 

241 _ops.raise_from_not_ok_status(e, name) 

242 except _core._FallbackException: 

243 pass 

244 try: 

245 return assert_prev_dataset_eager_fallback( 

246 input_dataset, transformations, output_types=output_types, 

247 output_shapes=output_shapes, name=name, ctx=_ctx) 

248 except _core._SymbolicException: 

249 pass # Add nodes to the TensorFlow graph. 

250 # Add nodes to the TensorFlow graph. 

251 if not isinstance(output_types, (list, tuple)): 

252 raise TypeError( 

253 "Expected list for 'output_types' argument to " 

254 "'assert_prev_dataset' Op, not %r." % output_types) 

255 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

256 if not isinstance(output_shapes, (list, tuple)): 

257 raise TypeError( 

258 "Expected list for 'output_shapes' argument to " 

259 "'assert_prev_dataset' Op, not %r." % output_shapes) 

260 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

261 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

262 "AssertPrevDataset", input_dataset=input_dataset, 

263 transformations=transformations, 

264 output_types=output_types, 

265 output_shapes=output_shapes, name=name) 

266 _result = _outputs[:] 

267 if _execute.must_record_gradient(): 

268 _attrs = ("output_types", _op.get_attr("output_types"), "output_shapes", 

269 _op.get_attr("output_shapes")) 

270 _inputs_flat = _op.inputs 

271 _execute.record_gradient( 

272 "AssertPrevDataset", _inputs_flat, _attrs, _result) 

273 _result, = _result 

274 return _result 

275 

276AssertPrevDataset = tf_export("raw_ops.AssertPrevDataset")(_ops.to_raw_op(assert_prev_dataset)) 

277 

278 

279def assert_prev_dataset_eager_fallback(input_dataset, transformations, output_types, output_shapes, name, ctx): 

280 if not isinstance(output_types, (list, tuple)): 

281 raise TypeError( 

282 "Expected list for 'output_types' argument to " 

283 "'assert_prev_dataset' Op, not %r." % output_types) 

284 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

285 if not isinstance(output_shapes, (list, tuple)): 

286 raise TypeError( 

287 "Expected list for 'output_shapes' argument to " 

288 "'assert_prev_dataset' Op, not %r." % output_shapes) 

289 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

290 input_dataset = _ops.convert_to_tensor(input_dataset, _dtypes.variant) 

291 transformations = _ops.convert_to_tensor(transformations, _dtypes.string) 

292 _inputs_flat = [input_dataset, transformations] 

293 _attrs = ("output_types", output_types, "output_shapes", output_shapes) 

294 _result = _execute.execute(b"AssertPrevDataset", 1, inputs=_inputs_flat, 

295 attrs=_attrs, ctx=ctx, name=name) 

296 if _execute.must_record_gradient(): 

297 _execute.record_gradient( 

298 "AssertPrevDataset", _inputs_flat, _attrs, _result) 

299 _result, = _result 

300 return _result 

301 

302 

303def auto_shard_dataset(input_dataset, num_workers, index, output_types, output_shapes, auto_shard_policy=0, num_replicas=0, name=None): 

304 r"""Creates a dataset that shards the input dataset. 

305 

306 Creates a dataset that shards the input dataset by num_workers, returning a 

307 sharded dataset for the index-th worker. This attempts to automatically shard 

308 a dataset by examining the Dataset graph and inserting a shard op before the 

309 inputs to a reader Dataset (e.g. CSVDataset, TFRecordDataset). 

310 

311 This dataset will throw a NotFound error if we cannot shard the dataset 

312 automatically. 

313 

314 Args: 

315 input_dataset: A `Tensor` of type `variant`. 

316 A variant tensor representing the input dataset. 

317 num_workers: A `Tensor` of type `int64`. 

318 A scalar representing the number of workers to distribute this dataset across. 

319 index: A `Tensor` of type `int64`. 

320 A scalar representing the index of the current worker out of num_workers. 

321 output_types: A list of `tf.DTypes` that has length `>= 1`. 

322 output_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`) that has length `>= 1`. 

323 auto_shard_policy: An optional `int`. Defaults to `0`. 

324 num_replicas: An optional `int`. Defaults to `0`. 

325 name: A name for the operation (optional). 

326 

327 Returns: 

328 A `Tensor` of type `variant`. 

329 """ 

330 _ctx = _context._context or _context.context() 

331 tld = _ctx._thread_local_data 

332 if tld.is_eager: 

333 try: 

334 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

335 _ctx, "AutoShardDataset", name, input_dataset, num_workers, index, 

336 "auto_shard_policy", auto_shard_policy, "output_types", output_types, 

337 "output_shapes", output_shapes, "num_replicas", num_replicas) 

338 return _result 

339 except _core._NotOkStatusException as e: 

340 _ops.raise_from_not_ok_status(e, name) 

341 except _core._FallbackException: 

342 pass 

343 try: 

344 return auto_shard_dataset_eager_fallback( 

345 input_dataset, num_workers, index, 

346 auto_shard_policy=auto_shard_policy, output_types=output_types, 

347 output_shapes=output_shapes, num_replicas=num_replicas, name=name, 

348 ctx=_ctx) 

349 except _core._SymbolicException: 

350 pass # Add nodes to the TensorFlow graph. 

351 # Add nodes to the TensorFlow graph. 

352 if not isinstance(output_types, (list, tuple)): 

353 raise TypeError( 

354 "Expected list for 'output_types' argument to " 

355 "'auto_shard_dataset' Op, not %r." % output_types) 

356 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

357 if not isinstance(output_shapes, (list, tuple)): 

358 raise TypeError( 

359 "Expected list for 'output_shapes' argument to " 

360 "'auto_shard_dataset' Op, not %r." % output_shapes) 

361 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

362 if auto_shard_policy is None: 

363 auto_shard_policy = 0 

364 auto_shard_policy = _execute.make_int(auto_shard_policy, "auto_shard_policy") 

365 if num_replicas is None: 

366 num_replicas = 0 

367 num_replicas = _execute.make_int(num_replicas, "num_replicas") 

368 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

369 "AutoShardDataset", input_dataset=input_dataset, 

370 num_workers=num_workers, index=index, 

371 output_types=output_types, 

372 output_shapes=output_shapes, 

373 auto_shard_policy=auto_shard_policy, 

374 num_replicas=num_replicas, name=name) 

375 _result = _outputs[:] 

376 if _execute.must_record_gradient(): 

377 _attrs = ("auto_shard_policy", _op._get_attr_int("auto_shard_policy"), 

378 "output_types", _op.get_attr("output_types"), "output_shapes", 

379 _op.get_attr("output_shapes"), "num_replicas", 

380 _op._get_attr_int("num_replicas")) 

381 _inputs_flat = _op.inputs 

382 _execute.record_gradient( 

383 "AutoShardDataset", _inputs_flat, _attrs, _result) 

384 _result, = _result 

385 return _result 

386 

387AutoShardDataset = tf_export("raw_ops.AutoShardDataset")(_ops.to_raw_op(auto_shard_dataset)) 

388 

389 

390def auto_shard_dataset_eager_fallback(input_dataset, num_workers, index, output_types, output_shapes, auto_shard_policy, num_replicas, name, ctx): 

391 if not isinstance(output_types, (list, tuple)): 

392 raise TypeError( 

393 "Expected list for 'output_types' argument to " 

394 "'auto_shard_dataset' Op, not %r." % output_types) 

395 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

396 if not isinstance(output_shapes, (list, tuple)): 

397 raise TypeError( 

398 "Expected list for 'output_shapes' argument to " 

399 "'auto_shard_dataset' Op, not %r." % output_shapes) 

400 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

401 if auto_shard_policy is None: 

402 auto_shard_policy = 0 

403 auto_shard_policy = _execute.make_int(auto_shard_policy, "auto_shard_policy") 

404 if num_replicas is None: 

405 num_replicas = 0 

406 num_replicas = _execute.make_int(num_replicas, "num_replicas") 

407 input_dataset = _ops.convert_to_tensor(input_dataset, _dtypes.variant) 

408 num_workers = _ops.convert_to_tensor(num_workers, _dtypes.int64) 

409 index = _ops.convert_to_tensor(index, _dtypes.int64) 

410 _inputs_flat = [input_dataset, num_workers, index] 

411 _attrs = ("auto_shard_policy", auto_shard_policy, "output_types", 

412 output_types, "output_shapes", output_shapes, "num_replicas", num_replicas) 

413 _result = _execute.execute(b"AutoShardDataset", 1, inputs=_inputs_flat, 

414 attrs=_attrs, ctx=ctx, name=name) 

415 if _execute.must_record_gradient(): 

416 _execute.record_gradient( 

417 "AutoShardDataset", _inputs_flat, _attrs, _result) 

418 _result, = _result 

419 return _result 

420 

421 

422def bytes_produced_stats_dataset(input_dataset, tag, output_types, output_shapes, name=None): 

423 r"""Records the bytes size of each element of `input_dataset` in a StatsAggregator. 

424 

425 Args: 

426 input_dataset: A `Tensor` of type `variant`. 

427 tag: A `Tensor` of type `string`. 

428 output_types: A list of `tf.DTypes` that has length `>= 1`. 

429 output_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`) that has length `>= 1`. 

430 name: A name for the operation (optional). 

431 

432 Returns: 

433 A `Tensor` of type `variant`. 

434 """ 

435 _ctx = _context._context or _context.context() 

436 tld = _ctx._thread_local_data 

437 if tld.is_eager: 

438 try: 

439 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

440 _ctx, "BytesProducedStatsDataset", name, input_dataset, tag, 

441 "output_types", output_types, "output_shapes", output_shapes) 

442 return _result 

443 except _core._NotOkStatusException as e: 

444 _ops.raise_from_not_ok_status(e, name) 

445 except _core._FallbackException: 

446 pass 

447 try: 

448 return bytes_produced_stats_dataset_eager_fallback( 

449 input_dataset, tag, output_types=output_types, 

450 output_shapes=output_shapes, name=name, ctx=_ctx) 

451 except _core._SymbolicException: 

452 pass # Add nodes to the TensorFlow graph. 

453 # Add nodes to the TensorFlow graph. 

454 if not isinstance(output_types, (list, tuple)): 

455 raise TypeError( 

456 "Expected list for 'output_types' argument to " 

457 "'bytes_produced_stats_dataset' Op, not %r." % output_types) 

458 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

459 if not isinstance(output_shapes, (list, tuple)): 

460 raise TypeError( 

461 "Expected list for 'output_shapes' argument to " 

462 "'bytes_produced_stats_dataset' Op, not %r." % output_shapes) 

463 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

464 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

465 "BytesProducedStatsDataset", input_dataset=input_dataset, tag=tag, 

466 output_types=output_types, 

467 output_shapes=output_shapes, name=name) 

468 _result = _outputs[:] 

469 if _execute.must_record_gradient(): 

470 _attrs = ("output_types", _op.get_attr("output_types"), "output_shapes", 

471 _op.get_attr("output_shapes")) 

472 _inputs_flat = _op.inputs 

473 _execute.record_gradient( 

474 "BytesProducedStatsDataset", _inputs_flat, _attrs, _result) 

475 _result, = _result 

476 return _result 

477 

478BytesProducedStatsDataset = tf_export("raw_ops.BytesProducedStatsDataset")(_ops.to_raw_op(bytes_produced_stats_dataset)) 

479 

480 

481def bytes_produced_stats_dataset_eager_fallback(input_dataset, tag, output_types, output_shapes, name, ctx): 

482 if not isinstance(output_types, (list, tuple)): 

483 raise TypeError( 

484 "Expected list for 'output_types' argument to " 

485 "'bytes_produced_stats_dataset' Op, not %r." % output_types) 

486 output_types = [_execute.make_type(_t, "output_types") for _t in output_types] 

487 if not isinstance(output_shapes, (list, tuple)): 

488 raise TypeError( 

489 "Expected list for 'output_shapes' argument to " 

490 "'bytes_produced_stats_dataset' Op, not %r." % output_shapes) 

491 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

492 input_dataset = _ops.convert_to_tensor(input_dataset, _dtypes.variant) 

493 tag = _ops.convert_to_tensor(tag, _dtypes.string) 

494 _inputs_flat = [input_dataset, tag] 

495 _attrs = ("output_types", output_types, "output_shapes", output_shapes) 

496 _result = _execute.execute(b"BytesProducedStatsDataset", 1, 

497 inputs=_inputs_flat, attrs=_attrs, ctx=ctx, 

498 name=name) 

499 if _execute.must_record_gradient(): 

500 _execute.record_gradient( 

501 "BytesProducedStatsDataset", _inputs_flat, _attrs, _result) 

502 _result, = _result 

503 return _result 

504 

505 

506def csv_dataset(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, output_shapes, name=None): 

507 r"""TODO: add doc. 

508 

509 Args: 

510 filenames: A `Tensor` of type `string`. 

511 compression_type: A `Tensor` of type `string`. 

512 buffer_size: A `Tensor` of type `int64`. 

513 header: A `Tensor` of type `bool`. 

514 field_delim: A `Tensor` of type `string`. 

515 use_quote_delim: A `Tensor` of type `bool`. 

516 na_value: A `Tensor` of type `string`. 

517 select_cols: A `Tensor` of type `int64`. 

518 record_defaults: A list of `Tensor` objects with types from: `float32`, `float64`, `int32`, `int64`, `string`. 

519 output_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`) that has length `>= 1`. 

520 name: A name for the operation (optional). 

521 

522 Returns: 

523 A `Tensor` of type `variant`. 

524 """ 

525 _ctx = _context._context or _context.context() 

526 tld = _ctx._thread_local_data 

527 if tld.is_eager: 

528 try: 

529 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

530 _ctx, "CSVDataset", name, filenames, compression_type, buffer_size, 

531 header, field_delim, use_quote_delim, na_value, select_cols, 

532 record_defaults, "output_shapes", output_shapes) 

533 return _result 

534 except _core._NotOkStatusException as e: 

535 _ops.raise_from_not_ok_status(e, name) 

536 except _core._FallbackException: 

537 pass 

538 try: 

539 return csv_dataset_eager_fallback( 

540 filenames, compression_type, buffer_size, header, field_delim, 

541 use_quote_delim, na_value, select_cols, record_defaults, 

542 output_shapes=output_shapes, name=name, ctx=_ctx) 

543 except _core._SymbolicException: 

544 pass # Add nodes to the TensorFlow graph. 

545 # Add nodes to the TensorFlow graph. 

546 if not isinstance(output_shapes, (list, tuple)): 

547 raise TypeError( 

548 "Expected list for 'output_shapes' argument to " 

549 "'csv_dataset' Op, not %r." % output_shapes) 

550 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

551 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

552 "CSVDataset", filenames=filenames, compression_type=compression_type, 

553 buffer_size=buffer_size, header=header, 

554 field_delim=field_delim, 

555 use_quote_delim=use_quote_delim, na_value=na_value, 

556 select_cols=select_cols, 

557 record_defaults=record_defaults, 

558 output_shapes=output_shapes, name=name) 

559 _result = _outputs[:] 

560 if _execute.must_record_gradient(): 

561 _attrs = ("output_types", _op.get_attr("output_types"), "output_shapes", 

562 _op.get_attr("output_shapes")) 

563 _inputs_flat = _op.inputs 

564 _execute.record_gradient( 

565 "CSVDataset", _inputs_flat, _attrs, _result) 

566 _result, = _result 

567 return _result 

568 

569CSVDataset = tf_export("raw_ops.CSVDataset")(_ops.to_raw_op(csv_dataset)) 

570 

571 

572def csv_dataset_eager_fallback(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, output_shapes, name, ctx): 

573 if not isinstance(output_shapes, (list, tuple)): 

574 raise TypeError( 

575 "Expected list for 'output_shapes' argument to " 

576 "'csv_dataset' Op, not %r." % output_shapes) 

577 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

578 _attr_output_types, record_defaults = _execute.convert_to_mixed_eager_tensors(record_defaults, ctx) 

579 filenames = _ops.convert_to_tensor(filenames, _dtypes.string) 

580 compression_type = _ops.convert_to_tensor(compression_type, _dtypes.string) 

581 buffer_size = _ops.convert_to_tensor(buffer_size, _dtypes.int64) 

582 header = _ops.convert_to_tensor(header, _dtypes.bool) 

583 field_delim = _ops.convert_to_tensor(field_delim, _dtypes.string) 

584 use_quote_delim = _ops.convert_to_tensor(use_quote_delim, _dtypes.bool) 

585 na_value = _ops.convert_to_tensor(na_value, _dtypes.string) 

586 select_cols = _ops.convert_to_tensor(select_cols, _dtypes.int64) 

587 _inputs_flat = [filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols] + list(record_defaults) 

588 _attrs = ("output_types", _attr_output_types, "output_shapes", 

589 output_shapes) 

590 _result = _execute.execute(b"CSVDataset", 1, inputs=_inputs_flat, 

591 attrs=_attrs, ctx=ctx, name=name) 

592 if _execute.must_record_gradient(): 

593 _execute.record_gradient( 

594 "CSVDataset", _inputs_flat, _attrs, _result) 

595 _result, = _result 

596 return _result 

597 

598 

599def csv_dataset_v2(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, exclude_cols, output_shapes, name=None): 

600 r"""TODO: add doc. 

601 

602 Args: 

603 filenames: A `Tensor` of type `string`. 

604 compression_type: A `Tensor` of type `string`. 

605 buffer_size: A `Tensor` of type `int64`. 

606 header: A `Tensor` of type `bool`. 

607 field_delim: A `Tensor` of type `string`. 

608 use_quote_delim: A `Tensor` of type `bool`. 

609 na_value: A `Tensor` of type `string`. 

610 select_cols: A `Tensor` of type `int64`. 

611 record_defaults: A list of `Tensor` objects with types from: `float32`, `float64`, `int32`, `int64`, `string`. 

612 exclude_cols: A `Tensor` of type `int64`. 

613 output_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`) that has length `>= 1`. 

614 name: A name for the operation (optional). 

615 

616 Returns: 

617 A `Tensor` of type `variant`. 

618 """ 

619 _ctx = _context._context or _context.context() 

620 tld = _ctx._thread_local_data 

621 if tld.is_eager: 

622 try: 

623 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

624 _ctx, "CSVDatasetV2", name, filenames, compression_type, buffer_size, 

625 header, field_delim, use_quote_delim, na_value, select_cols, 

626 record_defaults, exclude_cols, "output_shapes", output_shapes) 

627 return _result 

628 except _core._NotOkStatusException as e: 

629 _ops.raise_from_not_ok_status(e, name) 

630 except _core._FallbackException: 

631 pass 

632 try: 

633 return csv_dataset_v2_eager_fallback( 

634 filenames, compression_type, buffer_size, header, field_delim, 

635 use_quote_delim, na_value, select_cols, record_defaults, 

636 exclude_cols, output_shapes=output_shapes, name=name, ctx=_ctx) 

637 except _core._SymbolicException: 

638 pass # Add nodes to the TensorFlow graph. 

639 # Add nodes to the TensorFlow graph. 

640 if not isinstance(output_shapes, (list, tuple)): 

641 raise TypeError( 

642 "Expected list for 'output_shapes' argument to " 

643 "'csv_dataset_v2' Op, not %r." % output_shapes) 

644 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

645 _, _, _op, _outputs = _op_def_library._apply_op_helper( 

646 "CSVDatasetV2", filenames=filenames, 

647 compression_type=compression_type, 

648 buffer_size=buffer_size, header=header, 

649 field_delim=field_delim, 

650 use_quote_delim=use_quote_delim, na_value=na_value, 

651 select_cols=select_cols, 

652 record_defaults=record_defaults, 

653 exclude_cols=exclude_cols, 

654 output_shapes=output_shapes, name=name) 

655 _result = _outputs[:] 

656 if _execute.must_record_gradient(): 

657 _attrs = ("output_types", _op.get_attr("output_types"), "output_shapes", 

658 _op.get_attr("output_shapes")) 

659 _inputs_flat = _op.inputs 

660 _execute.record_gradient( 

661 "CSVDatasetV2", _inputs_flat, _attrs, _result) 

662 _result, = _result 

663 return _result 

664 

665CSVDatasetV2 = tf_export("raw_ops.CSVDatasetV2")(_ops.to_raw_op(csv_dataset_v2)) 

666 

667 

668def csv_dataset_v2_eager_fallback(filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols, record_defaults, exclude_cols, output_shapes, name, ctx): 

669 if not isinstance(output_shapes, (list, tuple)): 

670 raise TypeError( 

671 "Expected list for 'output_shapes' argument to " 

672 "'csv_dataset_v2' Op, not %r." % output_shapes) 

673 output_shapes = [_execute.make_shape(_s, "output_shapes") for _s in output_shapes] 

674 _attr_output_types, record_defaults = _execute.convert_to_mixed_eager_tensors(record_defaults, ctx) 

675 filenames = _ops.convert_to_tensor(filenames, _dtypes.string) 

676 compression_type = _ops.convert_to_tensor(compression_type, _dtypes.string) 

677 buffer_size = _ops.convert_to_tensor(buffer_size, _dtypes.int64) 

678 header = _ops.convert_to_tensor(header, _dtypes.bool) 

679 field_delim = _ops.convert_to_tensor(field_delim, _dtypes.string) 

680 use_quote_delim = _ops.convert_to_tensor(use_quote_delim, _dtypes.bool) 

681 na_value = _ops.convert_to_tensor(na_value, _dtypes.string) 

682 select_cols = _ops.convert_to_tensor(select_cols, _dtypes.int64) 

683 exclude_cols = _ops.convert_to_tensor(exclude_cols, _dtypes.int64) 

684 _inputs_flat = [filenames, compression_type, buffer_size, header, field_delim, use_quote_delim, na_value, select_cols] + list(record_defaults) + [exclude_cols] 

685 _attrs = ("output_types", _attr_output_types, "output_shapes", 

686 output_shapes) 

687 _result = _execute.execute(b"CSVDatasetV2", 1, inputs=_inputs_flat, 

688 attrs=_attrs, ctx=ctx, name=name) 

689 if _execute.must_record_gradient(): 

690 _execute.record_gradient( 

691 "CSVDatasetV2", _inputs_flat, _attrs, _result) 

692 _result, = _result 

693 return _result 

694 

695 

696def choose_fastest_branch_dataset(input_dataset, ratio_numerator, ratio_denominator, other_arguments, num_elements_per_branch, branches, other_arguments_lengths, output_types, output_shapes, name=None): 

697 r"""TODO: add doc. 

698 

699 Args: 

700 input_dataset: A `Tensor` of type `variant`. 

701 ratio_numerator: A `Tensor` of type `int64`. 

702 ratio_denominator: A `Tensor` of type `int64`. 

703 other_arguments: A list of `Tensor` objects. 

704 num_elements_per_branch: An `int` that is `>= 1`. 

705 branches: A list of functions decorated with @Defun that has length `>= 1`. 

706 other_arguments_lengths: A list of `ints` that has length `>= 1`. 

707 output_types: A list of `tf.DTypes` that has length `>= 1`. 

708 output_shapes: A list of shapes (each a `tf.TensorShape` or list of `ints`) that has length `>= 1`. 

709 name: A name for the operation (optional). 

710 

711 Returns: 

712 A `Tensor` of type `variant`. 

713 """ 

714 _ctx = _context._context or _context.context() 

715 tld = _ctx._thread_local_data 

716 if tld.is_eager: 

717 try: 

718 _result = pywrap_tfe.TFE_Py_FastPathExecute( 

719 _ctx, "ChooseFastestBranchDataset", name, input_dataset, 

720 ratio_numerator, ratio_denominator, other_arguments, 

721 "num_elements_per_branch", num_elements_per_branch, "branches", 

722 branches, "other_arguments_lengths", other_arguments_lengths, 

723 "output_types", output_types, "output_shapes", output_shapes) 

724 return _result 

725 except _core._NotOkStatusException as e: 

726 _ops.raise_from_not_ok_status(e, name) 

727 except _core._FallbackException: 

728 pass 

729 try: 

730 return choose_fastest_branch_dataset_eager_fallback( 

731 input_dataset, ratio_numerator, ratio_denominator, other_arguments, 

732 num_elements_per_branch=num_elements_per_branch, branches=branches, 

733 other_arguments_lengths=other_arguments_lengths, 

734 output_types=output_types, output_shapes=output_shapes, name=name, 

735 ctx=_ctx) 

736 except _core._SymbolicException: 

737 pass # Add nodes to the TensorFlow graph. 

738 # Add nodes to the TensorFlow graph. 

739 num_elements_per_branch = _execute.make_int(num_elements_per_branch, "num_elements_per_branch") 

740 if not isinstance(branches, (list, tuple)): 

741 raise TypeError( 

742 "Expected list for 'branches' argument to " 

743 "'choose_fastest_branch_dataset' Op, not %r." % branches) 

744 if not isinstance(other_arguments_lengths, (list, tuple)): 

745 raise TypeError( 

746 "Expected list for 'other_arguments_lengths' argument to " 

747 "'choose_fastest_branch_dataset' Op, not %r." % other_arguments_lengths) 

748 other_arguments_lengths = [_execute.make_int(_i, "other_arguments_lengths") for _i in other_arguments_lengths] 

749 if not isinstance(output_types, (list, tuple)): 

750 raise TypeError(