AVhdZddlZddlZddlZddlZddlmZddlm Z ddl m Z ddl m Z ddl m Z ddl mZdd l mZdd l mZdd l mZdd l mZdd l mZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!ddl"m#Z#ddl$m%Z%ddl&m'Z'GddZ(GddZ)GddZ*e'd Gd!d Z+d"Z,d#Z-e'd$ej\d%Gd&d$ej^Z0e!jbe!jde0ejfjhGd'd(e#jjZ6ejne+e0jpd)*y)+z2TensorArray: a dynamically sized array of Tensors.N) struct_pb2)context) constant_op)dtypes) errors_impl)ops)tensor) tensor_shape) tensor_util) type_spec)type_spec_registry) array_ops)array_ops_stack)control_flow_util)gen_control_flow_ops)gen_data_flow_ops)list_ops)math_ops) tf_logging)nested_structure_coder)trace) tf_should_use) tf_exportcleZdZdZ ddZedZedZedZedZ dZ e jd Z d Zdd Zdd Zdd ZddZddZddZej,ddZej,ddZej,ddZddZej,ddZy)_GraphTensorArrayz)Graph-mode implementation of TensorArray.Nc  | r td|5t|tjst d|dt |d|  td|  td| td| | td |  td d |xsd _tjj_ | _ | rg_ nd_ tj g___t%j&| d ||g5 ||_| td|_nu  fd} | rSt%j,d5t%j.dd 5| \__ddddddn| \__dddy#1swY/xYw#1swYxYw#1swYyxYw)aConstructs a graph mode TensorArray. Args: dtype: (required) data type of the TensorArray. size: (optional) int32 scalar `Tensor`: the size of the TensorArray. Required if handle is not provided. dynamic_size: (optional) Python bool: If true, writes to the TensorArray can grow the TensorArray past its initial size. Default: False. clear_after_read: Boolean (optional, default: True). If True, clear TensorArray values after reading them. This disables read-many semantics, but allows early release of memory. tensor_array_name: (optional) Python string: the name of the TensorArray. This is used when creating the TensorArray handle. If this value is set, handle should be None. handle: (optional) A `Tensor` handle to an existing TensorArray. If this is set, tensor_array_name should be None. Only supported in graph mode. flow: (optional) A float `Tensor` scalar coming from an existing `TensorArray.flow`. Only supported in graph mode. infer_shape: (optional, default: True) If True, shape inference is enabled. In this case, all elements must have the same shape. element_shape: (optional, default: None) A `TensorShape` object specifying the shape constraints of each of the elements of the TensorArray. Need not be fully defined. colocate_with_first_write_call: If `True`, the TensorArray will be colocated on the same device as the Tensor used on its first write (write operations include `write`, `unstack`, and `split`). If `False`, the TensorArray will be placed on the device determined by the device context available during its initialization. name: A name for the operation (optional). Raises: ValueError: if both handle and tensor_array_name are provided. TypeError: if handle is provided but is not a Tensor. NzPCannot provide both `handle` and `tensor_array_name` arguments at the same time.z+Expected `handle` to be a Tensor, but got `z ` of type ` ` instead.z;Argument `size` must be provided if handle is not provided.zECannot provide both a `handle` and `size` arguments at the same time.zLCannot provide both `handle` and `element_shape` arguments at the same time.zKCannot provide both `handle` and `dynamic_size` arguments at the same time.zOCannot provide both `handle` and `clear_after_read` arguments at the same time.TF TensorArrayz,flow must not be None if handle is not None.c RtjjS)zCreate the TensorArray op.)dtypesize element_shapeidentical_element_shapes dynamic_sizeclear_after_readtensor_array_namename)rtensor_array_v3 _dynamic_size)r%r r" infer_shapescopeselfr!r&sV/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/tensor_array_ops.pycreatez*_GraphTensorArray.__init__..creates4"22)'2--/ 1 )ignore_existing) ValueError isinstance tensor_libTensor TypeErrortyper)ras_dtype base_dtype_dtype_colocate_with_first_write_call_colocate_withr as_shape_element_shape _infer_shape_sizer name_scope_handle_flowdevice colocate_with)r,r r!r$r%r&handleflowr*r"colocate_with_first_write_callr'r.r+s``` `` `` @r-__init__z_GraphTensorArray.__init__8sA\/   *VZ5F5F"G  7x@6l^: ' ((~$,  G II d. + ,, m7   l6   .:   %.D//%(33DK ,JD(%d d (00?@D#DDJ mfdD-A B.e   <IJ J   *zz$ 0!2!24!N 0'-x $DL$* 0 0 0&,X "$, 5... 0 0 0 0/..s=(AG*GGGGG GG GG&c|jSNrBr,s r-rFz_GraphTensorArray.flow ::r/c|jSrJr9rLs r-r z_GraphTensorArray.dtype ;;r/c|jSrJrArLs r-rEz_GraphTensorArray.handles <<r/c |jdSNrr=rLs r-r"z_GraphTensorArray.element_shape   q !!r/c|j|jstd|d|jd|jr)|jj ||j d<yya Changes the element shape of the array given a shape to merge with. Args: shape: A `TensorShape` object to merge with. Raises: ValueError: if the provided shape is incompatible with the current element shape of the `TensorArray`. zInconsistent shapes: saw z but expected  rNis_compatible_withr"r1r> merge_withr=r,shapes r-_check_element_shapez&_GraphTensorArray._check_element_shaped  # #D$6$6 7 t113 44 #11<r=_implementation)r,rprFr'g_handle unused_flowgs r-gradz_GraphTensorArray.grads  | YYd /$,, @   T\\ * 1 F F<<4!I+  % %xj 1 @##D?$ @ ++))+0  2,0+>+>( @ @s< D#=D D&AD . D#D D  D D##D,ctj|j||j|j|}|j r(|j |j dj|S)rh)rEindexrqr r'r)rtensor_array_read_v3rArBr9r= set_shapedimsr,r}r'rds r-readz_GraphTensorArray.readsZ  2 2|| kk   E   ood))!,112 Lr/c tj|d|j||g5tj||jd}t ||j|j |j|j|5tj|j|||j|}dddt|cdddS#1swYxYw#1swYyxYw)rhTensorArrayWriterdpreferred_dtyper')rEr}rdrqr'N) rr@rAconvert_to_tensorr9 _check_dtypesr_r^rertensor_array_write_v3rBrkr,r}rdr'flow_outs r-writez_GraphTensorArray.writes 04<<2N O 4## 7>$ 2T\\N C HNN1diik: F   t'9'9 JJ " //;55djjAB,,112 3 s$#D B!C7$ D 7D <D  DcD|jr|jd}ntjd}tj|j ||j |j||}|jr)|jdg|jjz|S)rhrN)rEindicesrqr r'r") r=r unknown_shapertensor_array_gather_v3rArBr9r"rr)r,rr'r"rds r-rz_GraphTensorArray.gather-s ))!,m"006m  4 4|| kk #  %E  ootft116667 Lr/c tj|j|j|j||j dd\}}|j rd}|j rFtj|j}|!|j d||j dz}|j|g|j jddz|S)rhN)rErqr r'element_shape_except0r) rtensor_array_concat_v3rArBr9r"r>r rr!rr)r,r'rd_dim0r!s r-concatz_GraphTensorArray.concat>s 77|| kk "004 6HE1   d  ))$))+6   2 21 5 A**1--$ ootft1166qr::; Lr/ctj|d|j|g5tj|d}|j t jd|||cdddS#1swYyxYw)rhTensorArrayUnstackr)rrdr'N)rr@rArr^scatterrr)r,rdr' num_elementss r-unstackz_GraphTensorArray.unstackOsn 2T\\54I JK__U+A.l \\..L1TKKKKs AA..A7c  tj|d|j||g5tj||jd}t ||jt js|j|jdd|j|5tj|j|||j|}dddt|cdddS#1swYxYw#1swYyxYw)rhTensorArrayScatterrdrrN)rErrdrqr')rr@rArr9rrexecuting_eagerlyr_r^rertensor_array_scatter_v3rBrkr,rrdr'rs r-rz_GraphTensorArray.scatterWs 2ug6 84## 7rr@rtensor_list_reserverBr:r;) r,r r!r$r%r&rErFr*r"rGr'r+s r-rHz_GraphTensorArrayV2.__init__sjH >>&%DDJ  tZ.. /4::3O  B4::,O   |  P  D,  M  M5    //%(33DK (00?@D#D od| < 11'   ,0D(Ds 5)D55D>c|jSrJrKrLs r-rFz_GraphTensorArrayV2.flowrMr/c|jSrJrOrLs r-r z_GraphTensorArrayV2.dtyperPr/c |jdSrTrUrLs r-r"z!_GraphTensorArrayV2.element_shaperVr/cyrJrrLs r-rEz_GraphTensorArrayV2.handles r/c|j|jstd|d|jd|jr)|jj ||j d<yyrXrZr]s r-r_z(_GraphTensorArrayV2._check_element_shaper`r/cXtj|j}t||Srgrirls r-rjz_GraphTensorArrayV2.identityrmr/ct)zNot supported.NotImplementedErrorr,rprFr's r-r{z_GraphTensorArrayV2.grads  r/ctj|d|j|g5tj|j||j |j |}|cdddS#1swYyxYw)rhTensorArrayV2Read) input_handler}rr"r'N)rr@rBrtensor_list_get_itemr9r"rs r-rz_GraphTensorArrayV2.readsc 1DJJ3F G++zz ** e s :A((A1ctj|d|j||g5tj||jd}t ||j|j |jtj|j|||j|}t||cdddS#1swYyxYw)rhTensorArrayV2Writerdr)rr}itemresize_if_index_out_of_boundsr'N) rr@rBrr9rr_r^rtensor_list_set_itemr)rkrs r-rz_GraphTensorArrayV2.write(s 2TZZ4N O 4## 7>Cctj|d|j||g5tj||jd}t ||jt j|tj}tjstj|}|jjs|q|jre|j!|j#k(rD|j%t'j(|dgj+|jddt-j.|||j0|}t3||cdddS#1swYyxYw)rhrrdrNrr)r rr"r')rr@rBrr9rrrrrrrr rr^rrrr_r rrrtensor_list_splitr"rkrs r-rz_GraphTensorArrayV2.split}s) 04::ug2N O4## 7r r<r=r:r7r8r9r)_clear_after_read_previously_read_indicesr2r EagerTensornumpyr _tensor_array) r,r r!r$r%r&rErFr*r"rGr'rs r-rHz_EagerTensorArray.__init__sF  $  / 00 | / 00DL%%av||D+ID(//%(33DK%.D!1!9#?O $&D!$( ZZ\d(-d 41$4D4s/ Dc|jS)zBFor compatibility; flows are not meaningful when eager is enabled.rKrLs r-rFz_EagerTensorArray.flows ::r/c|jSrJrOrLs r-r z_EagerTensorArray.dtyperPr/c|jS)zDFor compatibility; handles are not meaningful when eager is enabled.rRrLs r-rEz_EagerTensorArray.handles <<r/c|jSrJrUrLs r-r"z_EagerTensorArray.element_shapes   r/c"|jSrg)parentrLs r-rjz_EagerTensorArray.identitys ;;=r/ctd)NzTensorArray.grad is not supported when executing eagerly; eager's gradient implementation does not use/need this function to compute gradients of operations that use TensorArrays.rrs r-r{z_EagerTensorArray.grads  9 ::r/c (~t|tjr|j}|dkrt j ddd|z|t |jk\r/t j ddd|t |jfz|j|}|9||jvrt jddd|z|j|}|jr*d|j|<|jj||S)rhrNz8Reading from negative indices (index %d) is not allowed.z2Tried to read from index %d but array size is: %d zzCould not read index %d twice because it was cleared after a previous read (perhaps try setting clear_after_read = false?)) r2rrrrOutOfRangeErrorlenrrInvalidArgumentError _maybe_zerorrb)r,r}r'r s r-rz_EagerTensorArray.reads %)kkme qy  ' '  Du L NN D&&''  ' ' J #d(() *+ ,,   &F ~ $// /.. $ N    !!%( "&d ##**51 Mr/c t|tjr|j}|dkrt j ddd|zt |j}||k\rY|jst j ddd||fz|jjdt||z dzDt|tjs"tj||jd}|j|jk7rFt jddd |jjd |jjd |j j#|j$s&t'd |j$d |j d|j(r*|j j+|j$|_||j|<y)aWrites `value` into index named by `index`. Args: index: 0-D. int32 scalar with the index to write to. value: N-D. Tensor of type `dtype`. The `Tensor` to write to `index`. Raises: errors_impl.InvalidArgumentError: `value` dtype does not match dtype. errors_impl.OutOfRangeError: `index` is out of bounds. ValueError: shape of `value` is not consistent with inferred shape. rNz6Writing to negative indices (index %d) is not allowed.zGTried to write to index %d but array is not resizeable and size is: %d c3 K|]}dywrJr).0rs r- z+_EagerTensorArray._write..AsFFs rrdrzTensorArray dtype is z! but Op is trying to write dtype rYzIncompatible shape for value (z ), expected ())r2rrrrrr rr)extendrrr9r r r'r=r[r^r1r>r\)r,r}rdr!s r-_writez_EagerTensorArray._write%s%)kkme qy  ' '  BU J LL t!! "D }   )) $   &' ' FeEDL14D.EFF eS__ -## 7  T%8%8: ;;  //::5;;Gd %Dur/cH~|j|||jSrg)rrr,r}rdr's r-rz_EagerTensorArray.writeWs KKu ;;=r/c|j|}|:tj|j|jx}|j|<|S)N)r^r )rrzerosr=r9)r,ixvals r-r z_EagerTensorArray._maybe_zero]sK   R C {%.__##4;;&88cD  r " Jr/c|jr4tt|jD]}|j||js]|jj rCt jtjdg|jz||jSt j|j||jS)rhr)r'r ) rrr r r=is_fully_definedrrnpndarrayr9)r,r'rs r-rz_EagerTensorArray.stackds c$,,-."    $"5"5"F"F"H  " " **aS4... /d$++OO " "   4t{{<>> ta = tf.TensorArray(tf.float32, size=0, dynamic_size=True, clear_after_read=False) >>> ta = ta.write(0, 10) >>> ta = ta.write(1, 20) >>> ta = ta.write(2, 30) >>> >>> ta.read(0) >>> ta.read(1) >>> ta.read(2) >>> ta.stack() Example 2: Fibonacci sequence algorithm that writes in a loop then returns. >>> @tf.function ... def fibonacci(n): ... ta = tf.TensorArray(tf.float32, size=0, dynamic_size=True) ... ta = ta.unstack([0., 1.]) ... ... for i in range(2, n): ... ta = ta.write(i, ta.read(i - 1) + ta.read(i - 2)) ... ... return ta.stack() >>> >>> fibonacci(7) Example 3: A simple loop interacting with a `tf.Variable`. >>> v = tf.Variable(1) >>> @tf.function ... def f(x): ... ta = tf.TensorArray(tf.int32, size=0, dynamic_size=True) ... for i in tf.range(x): ... v.assign_add(i) ... ta = ta.write(i, v) ... return ta.stack() >>> f(5) NTc tjr&||jtjk7rt } nS||jtjk(s't jtjrt} nt} | ||||||||| | |  |_ tj||j_y)aConstruct a new TensorArray or wrap an existing TensorArray handle. A note about the parameter `name`: The name of the `TensorArray` (even if passed in) is uniquified: each time a new `TensorArray` is created at runtime it is assigned its own name for the duration of the run. This avoids name collisions if a `TensorArray` is created within a `while_loop`. Args: dtype: (required) data type of the TensorArray. size: (optional) int32 scalar `Tensor`: the size of the TensorArray. Required if handle is not provided. dynamic_size: (optional) Python bool: If true, writes to the TensorArray can grow the TensorArray past its initial size. Default: False. clear_after_read: Boolean (optional, default: True). If True, clear TensorArray values after reading them. This disables read-many semantics, but allows early release of memory. tensor_array_name: (optional) Python string: the name of the TensorArray. This is used when creating the TensorArray handle. If this value is set, handle should be None. handle: (optional) A `Tensor` handle to an existing TensorArray. If this is set, tensor_array_name should be None. Only supported in graph mode. flow: (optional) A float `Tensor` scalar coming from an existing `TensorArray.flow`. Only supported in graph mode. infer_shape: (optional, default: True) If True, shape inference is enabled. In this case, all elements must have the same shape. element_shape: (optional, default: None) A `TensorShape` object specifying the shape constraints of each of the elements of the TensorArray. Need not be fully defined. colocate_with_first_write_call: If `True`, the TensorArray will be colocated on the same device as the Tensor used on its first write (write operations include `write`, `unstack`, and `split`). If `False`, the TensorArray will be placed on the device determined by the device context available during its initialization. name: A name for the operation (optional). Raises: ValueError: if both handle and tensor_array_name are provided. TypeError: if handle is provided but is not a Tensor. N) r!r$r%r&rErFr*r"rGr')rrr rrrrEnableControlFlowV2rget_default_graphrrrwweakrefrefr) r,r r!r$r%r&rErFr*r"rGr'implementations r-rHzTensorArray.__init__ sj !!# v~~5 )n  tzzV^^;  / /0E0E0G H*n(n) !)+ #'E  D#*++d"3Dr/c.|jjS)z@The flow `Tensor` forcing ops leading to this TensorArray state.)rwrBrLs r-rFzTensorArray.flow[s    % %%r/c.|jjS)z"The data type of this TensorArray.)rwr9rLs r-r zTensorArray.dtype`    & &&r/c.|jjS)z!The reference to the TensorArray.)rwrErLs r-rEzTensorArray.handleer9r/c.|jjS)z5The `tf.TensorShape` of elements in this TensorArray.)rwr"rLs r-r"zTensorArray.element_shapej    - --r/c.|jjS)zrLs r-r>zTensorArray._infer_shapets    , ,,r/c6|jjS)a#Returns a TensorArray with the same content and properties. Returns: A new TensorArray object with flow that ensures the control dependencies from the contexts will become control dependencies for writes, reads, etc. Use this object for all subsequent operations. )rwrjrLs r-rjzTensorArray.identity{s    ( ( **r/c>|jj|||S)N)rFr')rwr{rs r-r{zTensorArray.grads    $ $V$T $ BBr/c<|jj||S)zRead the value at location `index` in the TensorArray. Args: index: 0-D. int32 tensor with the index to read from. name: A name for the operation (optional). Returns: The tensor at index `index`. rs)rwr)r,r}r's r-rzTensorArray.reads     $ $U $ 66r/) warn_in_eagerc>|jj|||S)aWrite `value` into index `index` of the TensorArray. Args: index: 0-D. int32 scalar with the index to write to. value: N-D. Tensor of type `dtype`. The Tensor to write to this index. name: A name for the operation (optional). Returns: A new TensorArray object with flow that ensures the write occurs. Use this object for all subsequent operations. Raises: ValueError: if there are more writers than specified. rs)rwrrs r-rzTensorArray.writes"    % %eU % >>r/c:|jj|S)aReturn the values in the TensorArray as a stacked `Tensor`. All of the values must have been written and their shapes must all match. If input shapes have rank-`R`, then output shape will have rank-`(R+1)`. For example: >>> ta = tf.TensorArray(tf.int32, size=3) >>> ta = ta.write(0, tf.constant([1, 2])) >>> ta = ta.write(1, tf.constant([3, 4])) >>> ta = ta.write(2, tf.constant([5, 6])) >>> ta.stack() Args: name: A name for the operation (optional). Returns: All the tensors in the TensorArray stacked into one tensor. rs)rwrrs r-rzTensorArray.stacks4    % %4 % 00r/c<|jj||S)aReturn selected values in the TensorArray as a packed `Tensor`. All of selected values must have been written and their shapes must all match. Args: indices: A `1-D` `Tensor` taking values in `[0, max_value)`. If the `TensorArray` is not dynamic, `max_value=size()`. name: A name for the operation (optional). Returns: The tensors in the `TensorArray` selected by `indices`, packed into one tensor. rs)rwr)r,rr's r-rzTensorArray.gathers     & &wT & ::r/c:|jj|S)ajReturn the values in the TensorArray as a concatenated `Tensor`. All of the values must have been written, their ranks must match, and and their shapes must all match for all dimensions except the first. Args: name: A name for the operation (optional). Returns: All the tensors in the TensorArray concatenated into one tensor. rs)rwrrs r-rzTensorArray.concats    & &D & 11r/c<|jj||S)aUnstack the values of a `Tensor` in the TensorArray. If input value shapes have rank-`R`, then the output TensorArray will contain elements whose shapes are rank-`(R-1)`. Args: value: (N+1)-D. Tensor of type `dtype`. The Tensor to unstack. name: A name for the operation (optional). Returns: A new TensorArray object with flow that ensures the unstack occurs. Use this object for all subsequent operations. Raises: ValueError: if the shape inference fails. rs)rwr)r,rdr's r-rzTensorArray.unstacks $    ' 'D ' 99r/c>|jj|||S)aScatter the values of a `Tensor` in specific indices of a `TensorArray`. Args: indices: A `1-D` `Tensor` taking values in `[0, max_value)`. If the `TensorArray` is not dynamic, `max_value=size()`. value: (N+1)-D. Tensor of type `dtype`. The Tensor to unpack. name: A name for the operation (optional). Returns: A new TensorArray object with flow that ensures the scatter occurs. Use this object for all subsequent operations. Raises: ValueError: if the shape inference fails. rs)rwr)r,rrdr's r-rzTensorArray.scatters""    ' 'T ' BBr/c>|jj|||S)aSplit the values of a `Tensor` into the TensorArray. Args: value: (N+1)-D. Tensor of type `dtype`. The Tensor to split. lengths: 1-D. int32 vector with the lengths to use when splitting `value` along its first dimension. name: A name for the operation (optional). Returns: A new TensorArray object with flow that ensures the split occurs. Use this object for all subsequent operations. Raises: ValueError: if the shape inference fails. rs)rwr)r,rdrr's r-rzTensorArray.splits""    % %eW4 % @@r/c:|jj|S)z#Return the size of the TensorArray.rs)rwr!rs r-r!zTensorArray.sizes    $ $$ $ //r/c:|jj|S)zClose the current TensorArray.rs)rwrrs r-rzTensorArray.closes    % %4 % 00r/ct|SrJ)TensorArrayTraceType)r,rs r-__tf_tracing_type__zTensorArray.__tf_tracing_type__$s  %%r/rrrJ)rrrrrHrrFr rEr"r$r>rjr{rrrrrrrrrrr!rrNrr/r-rrs];~ $!%!.2O4b & & ' ' ' ' . . . . - - +C 7#=""6?7?"18;" 2"":#:&""C#C$""A#A$0""1#1&r/ct|tr |jn|}tjsBt|t s2t jtjr tdt|j|j||j|j}|j}|j|_|j |_|j"|_|j$|_|S)z.Builds a TensorArray with a new `flow` tensor.a2Attempting to build a graph-mode TF2-style TensorArray from either an eager-mode TensorArray or a TF1-style TensorArray. This is not currently supported. You may be attempting to capture a TensorArray inside a tf.function or tf.data map function. Instead, construct a new TensorArray inside the function.rt)r2rrwrrrrr2rr3rr rEr>r:r)r?r;r=)old_tarFimplnew_tanew_impls r-rkrk(s%/v{$C& $  " " $ t0 1--c.C.C.EF !0 11  JJ [[ ##%)%I%I  K&  # #(--(::(. //( //( -r/c |j|k7retjdj|t |jt |dj t jyy)NzError: Input value {} has dtype {}, but expected dtype {}. This leads to undefined behavior and will be an error in future versions of TensorFlow. Traceback: {})r loggingerrorformatstrjoin traceback format_stack)rdr s r-rrJsY [[E MMFFLfS-s5zggi4467G9:r/TensorArraySpecztf.TensorArraySpecceZdZdZgdZedZdejddfdZ dZ d Z d Z d Z ed Zd ZdZedZdZdZdZy)r]z*Type specification for a `tf.TensorArray`.r=r9r)r>ctSrJrrLs r-zTensorArraySpec.Zs[r/NFTctj||_tj||_||_||_y)a>Constructs a type specification for a `tf.TensorArray`. Args: element_shape: The shape of each element in the `TensorArray`. dtype: Data type of the `TensorArray`. dynamic_size: Whether the `TensorArray` can grow past its initial size. infer_shape: Whether shape inference is enabled. N)r r<r=rr7r9r)r>)r,r"r r$r*s r-rHzTensorArraySpec.__init__\s7'// >D//%(DK%D#Dr/ct|txr4|j|jk(xr|j|jk(SrJ)r2r]r9r)r,others r- is_subtype_ofzTensorArraySpec.is_subtype_ofns? uo . 6 KK5<< ' 6   %"5"5 57r/cLtd|Dsyjjd|D}|ytfd|Dsytfd|Dsyjxrtd|D}t |j j |S)zReturns the most specific supertype of `self` and `others`. Args: others: A Sequence of `TypeSpec`. Returns `None` if a supertype does not exist. c3<K|]}t|tywrJ)r2r]rrfs r-rzATensorArraySpec.most_specific_common_supertype..}sFez%1FsFc34K|]}|jywrJrUrjs r-rzATensorArraySpec.most_specific_common_supertype..sF2!&F2Nc3PK|]}j|jk(ywrJrOrrfr,s r-rzATensorArraySpec.most_specific_common_supertype..s?ut{{ell*?#&c3PK|]}j|jk(ywrJ)r)rns r-rzATensorArraySpec.most_specific_common_supertype..s"MUt!!U%8%88Mroc34K|]}|jywrJ)r>rjs r-rzATensorArraySpec.most_specific_common_supertype..s,0$,0rl)allr=most_specific_common_supertyper>r]r9r))r,others common_shaper*s` r-rsz.TensorArraySpec.most_specific_common_supertypets FvF F &&EEF2*0F22L  ?? ?  MfM M ##0,0(.,0)0K <d6H6H& ((r/cRt|tjstj|}t|txrg|j j |j xr@|jj |jxr|j|jk(SrJ) r2r TypeSpectype_spec_from_valuer]r9r[r=r)res r-r[z"TensorArraySpec.is_compatible_withs eY// 0,,U3e uo . 6 KK * *5<< 8 6    2 253G3G H 6   %"5"5 57r/c^|j|j|j|jfSrJr_rLs r- _serializezTensorArraySpec._serializes,   d.@.@    r/cLtjgtjgSrJr3 TensorSpecrrrLs r-_component_specsz TensorArraySpec._component_specss  ! !"fnn 5 66r/ct|ts#tdjt ||j 4|j j tjk(r |j gStjd5tj|j|j}ddd|gS#1swYgSxYw)N1Expected value to be a TensorArray, but got: `{}`convert_tensor_arrayr)r2rr5rXr6rFr rrrr@rrrr")r,rdrFs r-_to_componentszTensorArraySpec._to_componentss e[ ) IPP u+  zz%**"2"2fnn"Djj\ >>0 1E//;;=0C0CEEVmEVms 0CCct|j|d|j|j}|jg|j _|S)Nr)r rFr$r*)rr9r)r>r=rw)r, tensor_listrets r-_from_componentsz TensorArraySpec._from_componentssL kk ^''%%  'C +/*=*=)>C& Jr/ct|ts#tdjt |t |j |j|j|jS)Nr)r r"r$r*) r2rr5rXr6r]r r"r$r>)rds r- from_valuezTensorArraySpec.from_values_ e[ ) IPP u+  kk))''&&  ((r/c|jSrJrOrLs r-_to_legacy_output_typesz'TensorArraySpec._to_legacy_output_types ;;r/ctj|j|jgj |j SrJ)r rr)r>rr=rLs r-_to_legacy_output_shapesz(TensorArraySpec._to_legacy_output_shapess;  $ $d&8&8$:K:K&' ((3 D4G4G(HJr/ctSrJrarLs r-_to_legacy_output_classesz)TensorArraySpec._to_legacy_output_classess r/)rrrr __slots__r value_typerfloat32rHrgrsr[rzr~rr staticmethodrrrrrr/r-r]r]Ss3K)01*"^^! $$7 (: 7 7 7   ( (J r/cFeZdZdZdZdZdZdZdZdZ dZ d Z d Z y ) rMz$Represents TraceType of TensorArray.c||_yrJ_valuercs r-rHzTensorArrayTraceType.__init__s DKr/c ||k(SrJrres r-rgz"TensorArrayTraceType.is_subtype_ofs 5=r/c4tfd|DrSdS)Nc3(K|] }|k( ywrJrrns r-rzFTensorArrayTraceType.most_specific_common_supertype..s8tu}8s)rr)r,typess` r-rsz3TensorArrayTraceType.most_specific_common_supertypes8%884BdBr/c|jSrJr)r,placeholder_contexts r-placeholder_valuez&TensorArrayTraceType.placeholder_valuerr/cLtjgtjgSrJr|rLs r-flattenzTensorArrayTraceType.flattens  ! !"fnn 5 66r/ct|SrJ)next)r,r's r- from_tensorsz!TensorArrayTraceType.from_tensorss =r/ct|tjstSt|tsy|j |j uS)NF)r2r TraceTypeNotImplementedrMrres r-__eq__zTensorArrayTraceType.__eq__s9 eU__ -  e1 2  ;;%,, &&r/c,t|jSrJ)idrrLs r-__hash__zTensorArrayTraceType.__hash__s dkk?r/cN|jjd|jdS)Nz(value=r) __class__rrrLs r-__repr__zTensorArrayTraceType.__repr__s$nn%% &gdkk_A >>r/N) rrrrrHrgrsrrrrrrrr/r-rMrMs3,C7 '?r/rMT)allow_subclass)9rrr[r4rrtensorflow.core.protobufrtensorflow.python.eagerrtensorflow.python.frameworkrrrrr r3r r r r tensorflow.python.opsrrrrrrrtensorflow.python.platformrrVtensorflow.python.saved_modelrtensorflow.python.typesrtensorflow.python.utilr tensorflow.python.util.tf_exportrrrrrrkrregisterrwr]register_codecBuiltInTypeSpecCodec TypeSpecProtoTENSOR_ARRAY_SPECrrM'register_type_spec_from_value_converterrrr/r-rsY9/+3.3+<431:+1363**<@)06 Y(Y(x L1L1daaP  =Y&Y&Y&x D: 12~i((~3~B&%%///11CC$?5??$?R2 11++DBr/