AVh dZddlZddlmZddlmZddlmZddlm Z ddl m Z ddlmZdd l mZdd l mZdd l mZdd lmZdd lmZddlmZddlmZm Z m!Z!ddl"m#Z#edddddddddddddddd d!d"Z$ejJejLed#d$gd%&ed'dd)e#e!e$fd*e'd+e(d,e(d-e'd.e)d/e#e!ejTffd0Z+ed1ejXe+Z-e+j\j^Z0d)e#e!e$fd*e'd+e(d,e(d-e'd.e)d/e#e!ejTffd2Z1ejJejLed3d3d4g&ed4dd)e#e!ejTfd/e#e!ejTffd5Z2ed6ejXe2Z3e2j\j^Z4d)e#e!ejTfd/e#e!ejTffd7Z5ejJejLed8d8d9g&ed9dd)e#e!ejTfd:e(d/e#e!ejTffd;Z6ed<ejXe6Z7e6j\j^Z8d)e#e!ejTfd:e(d/e#e!ejTffd=Z9dd>e#e!ejTfd?e#e!ejtfd@e(dAe)d/e#e!ejTff dBZ;edCejXe;Ze#e!ejTfd?e#e!ejtfd@e(dAe)d/e#e!ejTff dDZ=dd)e#e!ejTfdEe#e!ejTfd/e#e!ej|ffdFZ?edGejXe?Z@d)e#e!ejTfdEe#e!ejTfd/e#e!ej|ffdHZAdd)e#e!ejTfdEe#e!ejTfdIe#e!ejTfdJe(d/e#e!ejTff dKZBedLejXeBZCd)e#e!ejTfdEe#e!ejTfdIe#e!ejTfdJe(d/e#e!ejTff dMZDdd)e#e!ejTfdEe)d/e#e!ej|ffdNZEedOejXeEZFd)e#e!ejTfdEe)d/e#e!ej|ffdPZGdd)e#e!ejTfdEe)dIe)dJe(d/e#e!ejTff dQZHedRejXeHZId)e#e!ejTfdEe)dIe)dJe(d/e#e!ejTff dSZJddTe)dUe)dVe'd/e#e!ejTffdWZKedXejXeKZLdTe)dUe)dVe'd/e#e!ejTffdYZMdd>e#e e!ejTfdAe)d/e#e!ejTffdZZNed[ejXeNZOd>e#e e!ejTfdAe)d/e#e!ejTffd\ZPdd)e#e!ejTfd]e)d/e#e!ejtffd^ZQed_ejXeQZRd)e#e!ejTfd]e)d/e#e!ejtffd`ZSejJejLedadd)e#e!ejTfdbe)d/e#e!ejTffdcZTeddejXeTZUeTj\j^ZVd)e#e!ejTfdbe)d/e#e!ejTffdeZWejdfdgdhgZYediddZZddje#e!ejTfdke#e!eZfdAe)dle)dme)dne'doe(fdpZ[edqejXe[Z\dje#e!ejTfdke#e!eZfdAe)dle)dme)dne'doe(fdrZ]ejdsgdtZ^dd)e#e!ejTfdue#e!ejTfdve(fdwZ_edxejXe_Z`d)e#e!ejTfdue#e!ejTfdve(fdyZaejdzgdtZbdd)e#e!ejTfd{e#e!ejTfd|e'fd}Zced~ejXecZdd)e#e!ejTfd{e#e!ejTfd|e'fdZeejJejLedddg&eddd)e#e!ejTfd/e#e!ejTffdZfedejXefZgefj\j^Zhd)e#e!ejTfd/e#e!ejTffdZidde#e!ejTfde'd/e#e!ejffdZkedejXekZlde#e!ejTfde'd/e#e!ejffdZmejJejLedddg&eddd)e#e!ejTfde'd/e#e!ejffdZnedejXenZoenj\j^Zpd)e#e!ejTfde'd/e#e!ejffdZqejJejLedddg&eddd)e#e!ejTfde'd/e#e!ejffdZredejXerZserj\j^Ztd)e#e!ejTfde'd/e#e!ejffdZuejJejLeddd)e#e!ejTfdbe)d/e#e!ejTffdZvedejXevZwevj\j^Zxd)e#e!ejTfdbe)d/e#e!ejTffdZyedddZzdd)e#e!ejTfde#e!ezfde#e!ezfd]e)d/e#e!ejTff dZ{edejXe{Z|d)e#e!ejTfde#e!ezfde#e!ezfd]e)d/e#e!ejTff dZ}ejdddgZ~edddZddd(e jdfd)e#e!ejTfde)de)de'de(def dZedejXeZd)e#e!ejTfde)de)de'de(def dZejdgdZedddZddd(e jdfd)e#e!ejTfde)de)de'de(def dZedejXeZd)e#e!ejTfde)de)de'de(def dZedddZdde#e!ejtfde#e!efde)de)de'd/e#e!ejTff dZedejXeZde#e!ejtfde#e!efde)de)de'd/e#e!ejTff dZejJejLeddd)e#e!ejtfd/e#e!ejtffdZedejXeZej\j^Zd)e#e!ejtfd/e#e!ejtffdZejJejLeddd)e#e!ejTfde)de)de)de'de(d/e#e!ejTffdZedejXeZej\j^Zd)e#e!ejTfde)de)de)de'de(d/e#e!ejTffdZedddZedddZdd>e#e!ejTfde#e!efde#e!efdAe)d/e#e!ejTff dńZedƫejXeZd>e#e!ejTfde#e!efde#e!efdAe)d/e#e!ejTff dDŽZy)zUPython wrappers around TensorFlow ops. This file is MACHINE GENERATED! Do not edit. N) pywrap_tfe)context)core)execute)dtypes)annotation_types)op_def_registry)ops)op_def_library)deprecated_endpoints)dispatch) tf_export)TypeVarListAny) Annotated TV_AsString_Tz_atypes.BFloat16z _atypes.Boolz_atypes.Complex128z_atypes.Complex64z_atypes.Float32z_atypes.Float64z _atypes.Halfz _atypes.Int16z _atypes.Int32z _atypes.Int64z _atypes.Int8z_atypes.Stringz_atypes.UInt16z_atypes.UInt32z_atypes.UInt64z _atypes.UInt8z_atypes.Variantstrings.as_string as_string)dtypes.as_stringrr)v1rFinput precision scientificshortestwidthfillreturnc>tjxstj}|j}|jr% t j |d||d|d|d|d|d|} | St|||||||fd} | tur| S|d }t/j0|d}|d }t/j2|d}|d }t/j2|d}|d }t/j0|d}|d }t/j4|d} t7j8d||||||| \} } } } | dd} t/j:rd| j=dd| j?dd| jAdd| jAdd| j?dd| jCdf }| jD}t/jFd||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||fd} | tur| St||||||||S#t j$rYtt f$rMt#j$t&d t)||||||| } | t"j*j,ur| cYSwxYw#tt f$rMt#j$t&d t)||||||| } | t"j*j,ur| cYSwxYw)a4Converts each entry in the given tensor to strings. Supports many numeric types and boolean. For Unicode, see the [https://www.tensorflow.org/text/guide/unicode](Working with Unicode text) tutorial. Examples: >>> tf.strings.as_string([3, 2]) >>> tf.strings.as_string([3.1415926, 2.71828], precision=2).numpy() array([b'3.14', b'2.72'], dtype=object) Args: input: A `Tensor`. Must be one of the following types: `float32`, `float64`, `int32`, `uint8`, `int16`, `int8`, `int64`, `bfloat16`, `uint16`, `half`, `uint32`, `uint64`, `complex64`, `complex128`, `bool`, `variant`, `string`. precision: An optional `int`. Defaults to `-1`. The post-decimal precision to use for floating point numbers. Only used if precision > -1. scientific: An optional `bool`. Defaults to `False`. Use scientific notation for floating point numbers. shortest: An optional `bool`. Defaults to `False`. Use shortest representation (either scientific or standard) for floating point numbers. width: An optional `int`. Defaults to `-1`. Pad pre-decimal numbers to this width. Applies to both floating point and integer numbers. Only used if width > -1. fill: An optional `string`. Defaults to `""`. The value to pad if width > -1. If empty, pads with spaces. Another typical value is '0'. String cannot be longer than 1 character. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. AsStringrrrrrN)rrrrrnamectx)rrrrrrr!FT)$_contextr_thread_local_datais_eagerrTFE_Py_FastPathExecute_core_NotOkStatusException_opsraise_from_not_ok_status_FallbackException_dispatcher_for_as_stringNotImplementedas_string_eager_fallback_SymbolicException TypeError ValueError _dispatchr rdict OpDispatcher NOT_SUPPORTED_executemake_int make_boolmake_str_op_def_library_apply_op_helpermust_record_gradient_get_attr_type _get_attr_int_get_attr_boolget_attrinputsrecord_gradient)rrrrrrr!_ctxtld_resulte__op_outputs_attrs _inputs_flats T/home/dcms/DCMS/lib/python3.12/site-packages/tensorflow/python/ops/gen_string_ops.pyrrseT    0h..0$ #\\ 11 j${I|J'5&$Hgn2(  :xdDdLGn$ nI ;7)J!!*l;* H   * 5( ] E   E7 +% \ D   4 ($  )::%9%UDJAq#x QK' ""$3%%c*K ,l  .   ,g(&#,,v2F HF ::L L&'3 (' .I  & &- ##At,,  # #    ) )Z5$ FNg  & % 95t$DJJ  # #  z " "" r4ey+5&+$TC g  ..<< <  D Z    REY)3h$)4A G i,,::: n  sP#G"KH$G??HHI 9I J="AJ=;J=ALLzraw_ops.AsStringc|d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}tj|g|t j t jt jt jt jt jt jt jt jt jt j t j"t j$t j&t j(t j*t j,g\}\}|g} d |d|d|d|d|d|f } tj.d d | | || } tj0rtj2d | | | | \} | S)Nr$rFrrrr%rr&sAsStringrEattrsr"r!r )r:r;r<r=args_to_matching_eager_dtypesfloat32float64int32uint8int16int8int64bfloat16uint16halfuint32uint64 complex64 complex128boolvariantstringrr@rF) rrrrrrr!r"_attr_TrOrNrIs rPr2r2sdI ;7)J!!*l;* H   * 5( ] E   E7 +% \ D   4 ($55ugsW__V]VeVegngtgtv}wDwDFMFSFSU\UaUacjcpcpryrBrBDKDRDRT[T`T`bibpbpryr@r@BIBSBSU\UgUgipiuiuw~wFwFHOHVHVEYZ'8E, +y,  h 6&   [!L#)s ?' ""$ L&'3 (' .zio.decode_base64 decode_base64c tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r&d} |j6} t3j8d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aDecode web-safe base64-encoded strings. Input may or may not have padding at the end. See [EncodeBase64](https://www.tensorflow.org/api_docs/python/tf/io/encode_base64) for padding. Web-safe means that input must use - and _ instead of + and /. Args: input: A `Tensor` of type `string`. Base64 strings to decode. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. DecodeBase64Nr!r"r#rr!)r'rr(r)rr*r+r,r-r.r/_dispatcher_for_decode_base64r1decode_base64_eager_fallbackr3r4r5r6r rjr7r8r9r>r?r:r@rErF rr!rGrHrIrJrKrLrMrNrOs rPrjrjs $    0h..0$ #\\ 11 ndE+g n,, Gn$ n  )::e$0Aq#x QK' ""$ F::L  fg7 (' .W  & &- ##At,,  # #    - $.$ g  & ) d&&  # #  z " "" 2t%d; g  ..<< <  Z    TD9 Gi,,::: n  PC3F4D(DDD E8 EF1AF1/F14AH  H zraw_ops.DecodeBase64ctj|tj}|g}d}t j dd||||}t j rt jd||||\}|S)Ns DecodeBase64rRrSrlr-convert_to_tensorrVrgr:rr@rFrr!r"rOrNrIs rPrprpsp   7%, &   _a #)s ?' ""$  fg7 (' .rizio.encode_base64 encode_base64padc tjxstj}|j}|jr t j |d||d|}|St|||fd}|tur|S|d}t/j0|d} t3j4d|||\}}}} | dd}t/j6r7d|j9df} |j:} t/j<d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)arEncode strings into web-safe base64 format. Refer to [this article](https://en.wikipedia.org/wiki/Base64) for more information on base64 format. Base64 strings may have padding with '=' at the end so that the encoded has length multiple of 4. See Padding section of the link above. Web-safe means that the encoder uses - and _ instead of + and /. Args: input: A `Tensor` of type `string`. Strings to be encoded. pad: An optional `bool`. Defaults to `False`. Bool whether padding is applied at the ends. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. EncodeBase64rxN)rxr!r"r#)rrxr!F)r'rr(r)rr*r+r,r-r.r/_dispatcher_for_encode_base64r1encode_base64_eager_fallbackr3r4r5r6r rwr7r8r9r:r<r>r?r@rCrErF) rrxr!rGrHrIrJrKrLrMrNrOs rPrwrw sG.    0h..0$ #\\ 11 ndE5#7g n,, TT#Gn$ n[ C3&#  )::e49Aq#x QK' ""$S''. /F::L  fg7 (' .]  & &- ##At,,  # #    - #t t%g  & ) St//  # #  z " "" 2t%StD g  ..<< <  & Z    T3TB Gi,,::: n  PDG'E D22E  E E7(E77G$ AG$"G$'AH?=H?zraw_ops.EncodeBase64c&|d}tj|d}tj|tj }|g}d|f}tj dd||||}tjrtjd||||\}|S)NFrxs EncodeBase64rRrSrz r:r<r-rurVrgrr@rF)rrxr!r"rOrNrIs rPr|r|]s[ C3&#   7%, 3<&   _a #)s ?' ""$  fg7 (' .rirEreduction_indices keep_dims separatorc  tjxstj}|j}|jr t j |d|||d|d| }|S|d}tj|d}|d}tj|d}t!j"d|||||\} } } } | dd}tj$rHd| j'dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY-wxYw) a)Joins a string Tensor across the given dimensions. Computes the string join across dimensions in the given string Tensor of shape `[\\(d_0, d_1, ..., d_{n-1}\\)]`. Returns a new Tensor created by joining the input strings with the given separator (default: empty string). Negative indices are counted backwards from the end, with `-1` being equivalent to `n - 1`. If indices are not specified, joins across all dimensions beginning from `n - 1` through `0`. For example: ```python # tensor `a` is [["a", "b"], ["c", "d"]] tf.reduce_join(a, 0) ==> ["ac", "bd"] tf.reduce_join(a, 1) ==> ["ab", "cd"] tf.reduce_join(a, -2) = tf.reduce_join(a, 0) ==> ["ac", "bd"] tf.reduce_join(a, -1) = tf.reduce_join(a, 1) ==> ["ab", "cd"] tf.reduce_join(a, 0, keep_dims=True) ==> [["ac", "bd"]] tf.reduce_join(a, 1, keep_dims=True) ==> [["ab"], ["cd"]] tf.reduce_join(a, 0, separator=".") ==> ["a.c", "b.d"] tf.reduce_join(a, [0, 1]) ==> "acbd" tf.reduce_join(a, [1, 0]) ==> "abcd" tf.reduce_join(a, []) ==> [["a", "b"], ["c", "d"]] tf.reduce_join(a) = tf.reduce_join(a, [1, 0]) ==> "abcd" ``` Args: inputs: A `Tensor` of type `string`. The input to be joined. All reduced indices must have non-zero size. reduction_indices: A `Tensor` of type `int32`. The dimensions to reduce over. Dimensions are reduced in the order specified. Omitting `reduction_indices` is equivalent to passing `[n-1, n-2, ..., 0]`. Negative indices from `-n` to `-1` are supported. keep_dims: An optional `bool`. Defaults to `False`. If `True`, retain reduced dimensions with length `1`. separator: An optional `string`. Defaults to `""`. The separator to use when joining. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. ReduceJoinrrN)rrr!r"Fr%)rErrrr!)r'rr(r)rr*r+r,r-r.r/reduce_join_eager_fallbackr3r:r<r=r>r?r@rCrDrErF)rErrrr!rGrHrIrJrKrLrMrNrOs rP reduce_joinrmsV    0h..0$ #\\ 11 lD&*;[; +gnI  K8)I ;7)'88V7H )YTK!QX QK' ""$3--k:Kll;')F::L lFG5 (' .9  & &- ##At,,  # #    ' #yI  # #   s0DE!-EE! E!%E66F  F zraw_ops.ReduceJoinc|d}tj|d}|d}tj|d}tj|t j }tj|t j}||g}d|d|f}tjdd||||}tjrtjd||||\}|S) NFrr%rs ReduceJoinrRrSr) r:r<r=r-rurVrgrYrr@rF) rErrrr!r"rOrNrIs rPrrsI  K8)I ;7)  ! !&'.. 9&,,-> N+,, K ;&   ]Al#)s ?' ""$ lFG5 (' .ripatterncbtjxstj}|j}|jr t j |d|||}|Stjd|||\}}}} | dd}tj r&d} |j"} tj$d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aCheck if the input matches the regex pattern. The input is a string tensor of any shape. The pattern is a scalar string tensor which is applied to every element of the input tensor. The boolean values (True or False) of the output tensor indicate if the input matches the regex pattern provided. The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax) Examples: >>> tf.strings.regex_full_match(["TF lib", "lib TF"], ".*lib$") >>> tf.strings.regex_full_match(["TF lib", "lib TF"], ".*TF$") Args: input: A `Tensor` of type `string`. A string tensor of the text to be processed. pattern: A `Tensor` of type `string`. A scalar string tensor containing the regular expression to match the input. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. RegexFullMatchNrmrrr!r#)r'rr(r)rr*r+r,r-r.r/regex_full_match_eager_fallbackr3r>r?r:r@rErF rrr!rGrHrIrJrKrLrMrNrOs rPregex_full_matchrs/6    0h..0$ #\\ 11 eW6g n(88wTC!QX QK' ""$ F::L ,9 (' .'  & &- ##At,,  # #    , t//  # #   s0B>>DC,,DD DD.-D.zraw_ops.RegexFullMatchc8tj|tj}tj|tj}||g}d}t j dd||||}t j rt jd||||\}|S)NsRegexFullMatchrRrSrrtrrr!r"rOrNrIs rPrrs   7%  " "7GNN ;'!, &   .,#)s ?' ""$ ,9 (' .rirewritereplace_globalc tjxstj}|j}|jr t j |d||||d|}|S|d}tj|d}tj d|||||\} } } } | dd}tj"r7d| j%df} | j&} tj(d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYwxYw)aReplaces matches of the `pattern` regular expression in `input` with the replacement string provided in `rewrite`. It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax) Args: input: A `Tensor` of type `string`. The text to be processed. pattern: A `Tensor` of type `string`. The regular expression to be matched in the `input` strings. rewrite: A `Tensor` of type `string`. The rewrite string to be substituted for the `pattern` expression where it is matched in the `input` strings. replace_global: An optional `bool`. Defaults to `True`. If True, the replacement is global (that is, all matches of the `pattern` regular expression in each input string are rewritten), otherwise the `rewrite` substitution is only made for the first `pattern` match. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. RegexReplacerN)rr!r"Trrrrr!)r'rr(r)rr*r+r,r-r.r/regex_replace_eager_fallbackr3r:r<r>r?r@rCrErFrrrrr!rGrHrIrJrKrLrMrNrOs rP regex_replacersu,    0h..0$ #\\ 11 ndE7G=MgnN%%n6FG.'88eWg'5DB!QX QK' ""$ 2 23C D EF::L  fg7 (' .1  & &- ##At,,  # #    ) '.t  # #   s0C..D5DD54D59E E! E!zraw_ops.RegexReplacec|d}tj|d}tj|tj }tj|tj }tj|tj }|||g}d|f}tj dd||||}tjrtjd||||\}|S)NTrs RegexReplacerRrSrr rrrrr!r"rOrNrIs rPrrXsN%%n6FG.   7%  " "7GNN ;'  " "7GNN ;''*, n -&   _a #)s ?' ""$  fg7 (' .rictjxstj}|j}|jr t j |d||d|}|Stj|d}tj d|||\}}}} | dd}tj"r7d|j%df} |j&} tj(d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aCheck if the input matches the regex pattern. The input is a string tensor of any shape. The pattern is the regular expression to be matched with every element of the input tensor. The boolean values (True or False) of the output tensor indicate if the input matches the regex pattern provided. The pattern follows the re2 syntax (https://github.com/google/re2/wiki/Syntax) Args: input: A `Tensor` of type `string`. A string tensor of the text to be processed. pattern: A `string`. The regular expression to match the input. name: A name for the operation (optional). Returns: A `Tensor` of type `bool`. StaticRegexFullMatchrN)rr!r"r)r'rr(r)rr*r+r,r-r.r/&static_regex_full_match_eager_fallbackr3r:r=r>r?r@rDrErFrs rPstatic_regex_full_matchrjsR&    0h..0$ #\\ 11 $dE9gGg n   gy 1''88eW4I!QX QK' ""$i0 1F::L  fg? (' .)  & &- ##At,,  # #    3 t77  # #   0C&&D-9DD-,D-1EEEzraw_ops.StaticRegexFullMatchctj|d}tj|tj }|g}d|f}tj dd||||}tjrtjd||||\}|S)NrsStaticRegexFullMatchrRrSr r:r=r-rurVrgrr@rFrs rPrrs   gy 1'   7%, w &   4a #)s ?' ""$  fg? (' .ric htjxstj}|j}|jr! t j |d||d|d|d| }|Stj|d}tj|d}|d}tj|d}t!j"d|||||\} } } } | dd}tj$rYd| j'dd| j'dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYPwxYw) a`Replaces the match of pattern in input with rewrite. It follows the re2 syntax (https://github.com/google/re2/wiki/Syntax) Args: input: A `Tensor` of type `string`. The text to be processed. pattern: A `string`. The regular expression to match the input. rewrite: A `string`. The rewrite to be applied to the matched expression. replace_global: An optional `bool`. Defaults to `True`. If True, the replacement is global, otherwise the replacement is done only on the first match. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. StaticRegexReplacerrrN)rrrr!r"Tr)r'rr(r)rr*r+r,r-r.r/#static_regex_replace_eager_fallbackr3r:r=r<r>r?r@rDrCrErFrs rPstatic_regex_replacers"    0h..0$ #\\ 11 "D%G7,n>gn   gy 1'   gy 1'N%%n6FG.'88E7G-;$H!QX QK' ""$i0)ll9%'7  !124F::L lFG= (' .9  & &- ##At,,  # #    0 ''d>>  # #   s0D>>FE,,FF FF10F1zraw_ops.StaticRegexReplacectj|d}tj|d}|d}tj|d}tj|t j }|g}d|d|d|f}tjdd||||}tjrtjd||||\}|S) NrrTrsStaticRegexReplacerRrSr) r:r=r<r-rurVrgrr@rFrs rPrrs   gy 1'   gy 1'N%%n6FG.   7%, w 74D &   2Al#)s ?' ""$ lFG= (' .ritemplate placeholder summarizec tjxstj}|j}|jr! t j |d||d|d|d| }|S|d}tj|d}|d}tj|d}|d}tj|d}t!j"d||||| \} } } } | dd}tj$rjd | j'd d| j'dd| j'dd| j)df} | j*} tj,d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYiwxYw) aFormats a string template using a list of tensors. Formats a string template using a list of tensors, pretty-printing tensor summaries. Args: inputs: A list of `Tensor` objects. The list of tensors to format into the placeholder string. template: An optional `string`. Defaults to `"%s"`. A string, the template to format tensor summaries into. placeholder: An optional `string`. Defaults to `"%s"`. A string, at each placeholder in the template a subsequent tensor summary will be inserted. summarize: An optional `int`. Defaults to `3`. When formatting the tensor summaries print the first and last summarize entries of each tensor dimension. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. StringFormatrrrN)rrrr!r"%s)rErrrr!r&)r'rr(r)rr*r+r,r-r.r/string_format_eager_fallbackr3r:r=r;r>r?r@rDrBrErF)rErrrr!rGrHrIrJrKrLrMrNrOs rP string_formatrs&    0h..0$ #\\ 11 ndFJ{KwxYw) aJoins the strings in the given list of string tensors into one tensor; with the given separator (default is an empty separator). Examples: >>> s = ["hello", "world", "tensorflow"] >>> tf.strings.join(s, " ") Args: inputs: A list of `Tensor` objects with type `string`. A list of string tensors. The tensors must all have the same shape, or be scalars. Scalars may be mixed in; these will be broadcast to the shape of non-scalar inputs. separator: An optional `string`. Defaults to `""`. string, an optional join separator. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. StringJoinrNrr!r"@Expected list for 'inputs' argument to 'string_join' Op, not %r.r%)rErr!N)r'rr(r)rr*r+r,r-r.r/string_join_eager_fallbackr3 isinstancertupler4lenr:r=r>r?r@rBrDrErF) rErr!rGrHrIrJ_attr_NrKrLrMrNrOs rP string_joinrPs.    0h..0$ #\\ 11 lD&+yBg n FT5M *  $&, - .. K'I ;7)'88VytE!QX QK' ""$3$$S);ll;')F::L lFG5 (' .9  & &- ##At,,  # #    ' IDd<<  # #   s0D**E1=EE10E15FFFzraw_ops.StringJoinct|ttfstd|zt |}|d}t j |d}tj|tj}t|}d|d|f}t jdd||||}t jrt jd||||\}|S) Nrr%rrs StringJoinrRrSr)rrrr4rr:r=r-convert_n_to_tensorrVrgrr@rF)rErr!r"rrOrNrIs rPrrs FT5M *  $&, - .. K'I ;7)  # #FGNN ;&f, +y 1&   ]Al#)s ?' ""$ lFG5 (' .riunitctjxstj}|j}|jr t j |d||d|}|S|d}tj|d}tj d|||\}}}} | dd}tj"r7d|j%df} |j&} tj(d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aString lengths of `input`. Computes the length of each string given in the input tensor. >>> strings = tf.constant(['Hello','TensorFlow', '\U0001F642']) >>> tf.strings.length(strings).numpy() # default counts bytes array([ 5, 10, 4], dtype=int32) >>> tf.strings.length(strings, unit="UTF8_CHAR").numpy() array([ 5, 10, 1], dtype=int32) Args: input: A `Tensor` of type `string`. The strings for which to compute the length for each element. unit: An optional `string` from: `"BYTE", "UTF8_CHAR"`. Defaults to `"BYTE"`. The unit that is counted to compute string length. One of: `"BYTE"` (for the number of bytes in each string) or `"UTF8_CHAR"` (for the number of UTF-8 encoded Unicode code points in each string). Results are undefined if `unit=UTF8_CHAR` and the `input` strings do not contain structurally valid UTF-8. name: A name for the operation (optional). Returns: A `Tensor` of type `int32`. StringLengthrNrr!r"BYTE)rrr!)r'rr(r)rr*r+r,r-r.r/string_length_eager_fallbackr3r:r=r>r?r@rDrErF) rrr!rGrHrIrJrKrLrMrNrOs rP string_lengthrsY2    0h..0$ #\\ 11 ndE649g n \ D   4 ($'88e$T;!QX QK' ""$cll6* +F::L  fg7 (' .-  & &- ##At,,  # #    ) d411  # #   s0C**D1=DD10D15EEEzraw_ops.StringLengthc&|d}tj|d}tj|tj }|g}d|f}tj dd||||}tjrtjd||||\}|S)Nrrs StringLengthrRrSrr)rrr!r"rOrNrIs rPrrs \ D   4 ($   7%, D>&   _a #)s ?' ""$  fg7 (' .riz strings.lowerencodingc tjxstj}|j}|jr t j |d||d|}|St|||fd}|tur|S|d}t/j0|d} t3j4d|||\}}}} | dd}t/j6r7d|j9df} |j:} t/j<d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)a5Converts all uppercase characters into their respective lowercase replacements. Example: >>> tf.strings.lower("CamelCase string and ALL CAPS") Args: input: A `Tensor` of type `string`. The input to be lower-cased. encoding: An optional `string`. Defaults to `""`. Character encoding of `input`. Allowed values are '' and 'utf-8'. Value '' is interpreted as ASCII. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. StringLowerrNrr!r"r#rrr!r%)r'rr(r)rr*r+r,r-r.r/_dispatcher_for_string_lowerr1string_lower_eager_fallbackr3r4r5r6r string_lowerr7r8r9r:r=r>r?r@rDrErF rrr!rGrHrIrJrKrLrMrNrOs rPrrH*    0h..0$ #\\ 11 mT5*h@g n,+ $ $(Gn$ n H   x 4(  )::UXDBAq#x QK' ""$#,,z2 3F::L |VW6 (' .]  & &- ##At,,  # #    , (D "D*g  & ( (499  # #  z " "" "dM g  ..<< <  & Z    DuxdK Gi,,::: n  r}zraw_ops.StringLowerc&|d}tj|d}tj|tj }|g}d|f}tj dd||||}tjrtjd||||\}|S)Nr%rs StringLowerrRrSrrrrr!r"rOrNrIs rPrr? H   x 4(   7%,  !&   ^Q|#)s ?' ""$ |VW6 (' .ri StringNGramsngrams ngrams_splitsTV_StringNGrams_Tsplitsdata data_splitsleft_pad right_pad pad_widthpreserve_short_sequencesc Btjxstj} | j} | jr= t j | d|||d|d|d|d|d|d|} t j| } | Stj |d}t#|t$t&fst)d |z|D cgc]} tj*| d}} tj |d}tj |d}tj*|d}tj,|d}t/j0d||||||||| \}}}}|dd} tj2rd|j5dd|j5dd|j5dd|j5dd|j7dd|j9dd |j;d f}|j<}tj>d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t|||||||||| S#tj$rYwxYwcc} w) aCreates ngrams from ragged string data. This op accepts a ragged tensor with 1 ragged dimension containing only strings and outputs a ragged tensor with 1 ragged dimension containing ngrams of that string, joined along the innermost axis. Args: data: A `Tensor` of type `string`. The values tensor of the ragged string tensor to make ngrams out of. Must be a 1D string tensor. data_splits: A `Tensor`. Must be one of the following types: `int32`, `int64`. The splits tensor of the ragged string tensor to make ngrams out of. separator: A `string`. The string to append between elements of the token. Use "" for no separator. ngram_widths: A list of `ints`. The sizes of the ngrams to create. left_pad: A `string`. The string to use to pad the left side of the ngram sequence. Only used if pad_width != 0. right_pad: A `string`. The string to use to pad the right side of the ngram sequence. Only used if pad_width != 0. pad_width: An `int`. The number of padding elements to add to each side of each sequence. Note that padding will never be greater than 'ngram_widths'-1 regardless of this value. If `pad_width=-1`, then add `max(ngram_widths)-1` elements. preserve_short_sequences: A `bool`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (ngrams, ngrams_splits). ngrams: A `Tensor` of type `string`. ngrams_splits: A `Tensor`. Has the same type as `data_splits`. rr ngram_widthsrrrrN)rrrrrrr!r"IExpected list for 'ngram_widths' argument to 'string_n_grams' Op, not %r.) rrrrrrrrr!Tsplits) r'rr(r)rr*_StringNGramsOutput_maker+r,r-r.r/string_n_grams_eager_fallbackr3r:r=rrrr4r;r<r>r?r@rDrBrCrArErF)rrrrrrrrr!rGrHrIrJ_irKrLrMrNrOs rPstring_n_gramsrUsH    0h..0$ #\\  11 ndD+{I j(K; +E "g $))'2g n ;7) L4- 0  ')5 6 77COOB(##B7O,O   x 4( ;7) ;7)%//0HJde'88T{"+,!)Y"+1I! #!QX QK' ""$3<< 4nll>*Jll:& ll;' ,.H  !;r?r@rCrErF) rrrr!rGrHrIrJrKrLrMrNrOs rP string_splitrsN    0h..0$ #\\ 11 mT5)\:Og"((1g nJ!!*l;*'88Ui",49!QX QK' ""$C..|< =F::L |VW6  $ $W -' ./  & &- ##At,,  # #    ( z$HH  # #   01DE%EEEE--FFzraw_ops.StringSplitc|d}tj|d}tj|tj }tj|tj }||g}d|f}tj dd||||}tjrtjd|||tj|}|S)NTrs StringSplitrrSr) r:r<r-rurVrgrr@rFrr)rrrr!r"rOrNrIs rPrrsJ!!*l;*   7%$$Y?)#, * %&   ^Q|#)s ?' ""$ |VW6  $ $W -' .ri StringSplitV2sepmaxsplitc tjxstj}|j}|jr3 t j |d|||d|}t j|}|S|d}tj |d}t#j$d||||\}}} } | dd}tj&r7d| j)df} | j*} tj,d| | |t j|}|S#tj$r }tj||Yd}~nd}~wtj$rYnwxYw t|||||S#tj$rYwxYw)a?Split elements of `source` based on `sep` into a `SparseTensor`. Let N be the size of source (typically N will be the batch size). Split each element of `source` based on `sep` and return a `SparseTensor` containing the split tokens. Empty tokens are ignored. For example, N = 2, source[0] is 'hello world' and source[1] is 'a b c', then the output will be ``` st.indices = [0, 0; 0, 1; 1, 0; 1, 1; 1, 2] st.shape = [2, 3] st.values = ['hello', 'world', 'a', 'b', 'c'] ``` If `sep` is given, consecutive delimiters are not grouped together and are deemed to delimit empty strings. For example, source of `"1<>2<><>3"` and sep of `"<>"` returns `["1", "2", "", "3"]`. If `sep` is None or an empty string, consecutive whitespace are regarded as a single separator, and the result will contain no empty strings at the startor end if the string has leading or trailing whitespace. Note that the above mentioned behavior matches python's str.split. Args: input: A `Tensor` of type `string`. `1-D` string `Tensor`, the strings to split. sep: A `Tensor` of type `string`. `0-D` string `Tensor`, the delimiter character. maxsplit: An optional `int`. Defaults to `-1`. An `int`. If `maxsplit > 0`, limit of the split of the result. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (indices, values, shape). indices: A `Tensor` of type `int64`. values: A `Tensor` of type `string`. shape: A `Tensor` of type `int64`. rrN)rr!r"r$)rrrr!)r'rr(r)rr*_StringSplitV2Outputrr+r,r-r.r/string_split_v2_eager_fallbackr3r:r;r>r?r@rBrErF) rrrr!rGrHrIrJrKrLrMrNrOs rPstring_split_v2r3s~X    0h..0$ #\\ 11 otUCXGg$**73g nH   x 4('88u#tM!QX QK' ""$#++J7 8F::L vw8 & &w /' .-  & &- ##At,,  # #    + xd>>  # #   rzraw_ops.StringSplitV2c|d}tj|d}tj|tj }tj|tj }||g}d|f}tj dd||||}tjrtjd|||tj|}|S)Nr$rs StringSplitV2rrSr) r:r;r-rurVrgrr@rFrr)rrrr!r"rOrNrIs rPrrs H   x 4(   7% sGNN3#,  !&   -q#)s ?' ""$ vw8 & &w /' .riz strings.strip string_stripc tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r&d} |j6} t3j8d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aStrip leading and trailing whitespaces from the Tensor. Examples: >>> tf.strings.strip(["\nTensorFlow", " The python library "]).numpy() array([b'TensorFlow', b'The python library'], dtype=object) Args: input: A `Tensor` of type `string`. A string `Tensor` of any shape. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. StringStripNrmr#rn)r'rr(r)rr*r+r,r-r.r/_dispatcher_for_string_stripr1string_strip_eager_fallbackr3r4r5r6r rr7r8r9r>r?r:r@rErFrqs rPrrs &    0h..0$ #\\ 11 mT5*g n,+ Gn$ n  )::U/Aq#x QK' ""$ F::L |VW6 (' .W  & &- ##At,,  # #    , $.$ g  & ( d&&  # #  z " "" "dT: g  ..<< <  Z    Du48 Gi,,::: n  rrzraw_ops.StringStripctj|tj}|g}d}t j dd||||}t j rt jd||||\}|S)Ns StringStriprRrSrrtrvs rPrrsp   7%, &   ^Q|#)s ?' ""$ |VW6 (' .ri string_tensor num_bucketsctjxstj}|j}|jr t j |d||d|}|Stj|d}tj d|||\}}}} | dd}tj"r7d|j%df} |j&} tj(d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||S#t j$rYwxYw)aNConverts each string in the input Tensor to its hash mod by a number of buckets. The hash function is deterministic on the content of the string within the process. Note that the hash function may change from time to time. This functionality will be deprecated and it's recommended to use `tf.string_to_hash_bucket_fast()` or `tf.string_to_hash_bucket_strong()`. Args: string_tensor: A `Tensor` of type `string`. num_buckets: An `int` that is `>= 1`. The number of buckets. name: A name for the operation (optional). Returns: A `Tensor` of type `int64`. StringToHashBucketrNrr!r")rrr!)r'rr(r)rr*r+r,r-r.r/$string_to_hash_bucket_eager_fallbackr3r:r;r>r?r@rBrErF) rrr!rGrHrIrJrKrLrMrNrOs rPstring_to_hash_bucketr s[$    0h..0$ #\\ 11 "D-gn!!+}=+'88M*5DB!QX QK' ""$S..}= >F::L lFG= (' .+  & &- ##At,,  # #    1 [tGG  # #   rzraw_ops.StringToHashBucketctj|d}tj|tj }|g}d|f}tj dd||||}tjrtjd||||\}|S)NrsStringToHashBucketrRrSr r:r;r-rurVrgrr@rF)rrr!r"rOrNrIs rPr r s!!+}=+((G-, ; '&   2Al#)s ?' ""$ lFG= (' .rizstrings.to_hash_bucket_faststring_to_hash_bucket_fastc |tjxstj}|j}|jr t j |d||d|}|St|||fd}|tur|St/j0|d} t3j4d|||\}}}} | dd}t/j6r7d|j9df} |j:} t/j<d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)aeConverts each string in the input Tensor to its hash mod by a number of buckets. The hash function is deterministic on the content of the string within the process and will never change. However, it is not suitable for cryptography. This function may be used when CPU time is scarce and inputs are trusted or unimportant. There is a risk of adversaries constructing inputs that all hash to the same bucket. To prevent this problem, use a strong hash function with `tf.string_to_hash_bucket_strong`. Examples: >>> tf.strings.to_hash_bucket_fast(["Hello", "TensorFlow", "2.x"], 3).numpy() array([0, 2, 2]) Args: input: A `Tensor` of type `string`. The strings to assign a hash bucket. num_buckets: An `int` that is `>= 1`. The number of buckets. name: A name for the operation (optional). Returns: A `Tensor` of type `int64`. StringToHashBucketFastrNr r#)rrr!)r'rr(r)rr*r+r,r-r.r/*_dispatcher_for_string_to_hash_bucket_fastr1)string_to_hash_bucket_fast_eager_fallbackr3r4r5r6r rr7r8r9r:r;r>r?r@rBrErF) rrr!rGrHrIrJrKrLrMrNrOs rPrr-sK6    0h..0$ #\\ 11 &e]gn09  T#T+Gn$ n!!+}=+  ):: ;'+-Aq#x QK' ""$S..}= >F::L  ,A (' .c  & &- ##At,,  # #    : +t %t-g  & 6 [t??  # #  z " "" &Du=H6:-< g  ..<< <  ( Z    $b$U;F48+: G i,,::: n  sPD G#ED..EE E3$E33G  AG G #AH;9H;zraw_ops.StringToHashBucketFastctj|d}tj|tj }|g}d|f}tj dd||||}tjrtjd||||\}|S)NrsStringToHashBucketFastrRrSrr )rrr!r"rOrNrIs rPrrs!!+}=+   7%, ; '&   6$0C"& ('""$  ,A (' .rizstrings.to_hash_bucket_strongstring_to_hash_bucket_strongc Ftjxstj}|j}|jr t j |d||d|d|}|St||||fd}|tur|St/j0|d}t3|t4t6fstd|z|Dcgc]}t/j0|d}} t9j:d||||\} } } } | dd}t/j<rHd| j?dd| jAdf} | jB} t/jDd| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||fd}|tur|St|||||S#t j$rYott f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYwcc}w#tt f$rJt#j$t&dt)||||}|t"j*j,ur|cYSwxYw) aCConverts each string in the input Tensor to its hash mod by a number of buckets. The hash function is deterministic on the content of the string within the process. The hash function is a keyed hash function, where attribute `key` defines the key of the hash function. `key` is an array of 2 elements. A strong hash is important when inputs may be malicious, e.g. URLs with additional components. Adversaries could try to make their inputs hash to the same bucket for a denial-of-service attack or to skew the results. A strong hash can be used to make it difficult to find inputs with a skewed hash value distribution over buckets. This requires that the hash function is seeded by a high-entropy (random) "key" unknown to the adversary. The additional robustness comes at a cost of roughly 4x higher compute time than `tf.string_to_hash_bucket_fast`. Examples: >>> tf.strings.to_hash_bucket_strong(["Hello", "TF"], 3, [1, 2]).numpy() array([2, 0]) Args: input: A `Tensor` of type `string`. The strings to assign a hash bucket. num_buckets: An `int` that is `>= 1`. The number of buckets. key: A list of `ints`. The key used to seed the hash function, passed as a list of two uint64 elements. name: A name for the operation (optional). Returns: A `Tensor` of type `int64`. StringToHashBucketStrongrkeyN)rrr!r"r#)rrrr!NExpected list for 'key' argument to 'string_to_hash_bucket_strong' Op, not %r.)#r'rr(r)rr*r+r,r-r.r/,_dispatcher_for_string_to_hash_bucket_strongr1+string_to_hash_bucket_strong_eager_fallbackr3r4r5r6r rr7r8r9r:r;rrrr>r?r@rBrDrErF)rrrr!rGrHrIrJrrKrLrMrNrOs rPrrsJ    0h..0$ #\\ 11 ($}UC!gn0;  S$($0Gn$ n!!+}=+ C$ '  57: ; <<144"  2u %4#4  )::"%[(+$8Aq#x QK' ""$S..}=ull5!#F::L "L&'C (' .o  & &- ##At,,  # #    < +sD *D2g  & 8 [c$HH  # #  z " "" ("d?J7:/G g  ..<< <  ( 5 Z    &Du=H58t-E G i,,::: n  sVE6IIF#/F  F#"F#'GGH?'AH?=H?AJ J z raw_ops.StringToHashBucketStrongctj|d}t|ttfst d|z|Dcgc]}tj|d}}t j|tj}|g}d|d|f}tjdd||||}tjrtjd||||\}|Scc}w)NrrrsStringToHashBucketStrongrRrSr) r:r;rrrr4r-rurVrgrr@rF) rrrr!r"rrOrNrIs rPrrs!!+}=+ C$ '  57: ; <<144"  2u %4#4   7%, ;s 3&   8!$0C"& ('""$ "L&'C (' . 5sCz strings.upperc tjxstj}|j}|jr t j |d||d|}|St|||fd}|tur|S|d}t/j0|d} t3j4d|||\}}}} | dd}t/j6r7d|j9df} |j:} t/j<d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t|||fd}|tur|St||||S#t j$rYtt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw#tt f$rIt#j$t&dt)|||}|t"j*j,ur|cYSwxYw)a5Converts all lowercase characters into their respective uppercase replacements. Example: >>> tf.strings.upper("CamelCase string and ALL CAPS") Args: input: A `Tensor` of type `string`. The input to be upper-cased. encoding: An optional `string`. Defaults to `""`. Character encoding of `input`. Allowed values are '' and 'utf-8'. Value '' is interpreted as ASCII. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. StringUpperrNrr#rr%)r'rr(r)rr*r+r,r-r.r/_dispatcher_for_string_upperr1string_upper_eager_fallbackr3r4r5r6r string_upperr7r8r9r:r=r>r?r@rDrErFrs rPr r rr}zraw_ops.StringUpperc&|d}tj|d}tj|tj }|g}d|f}tj dd||||}tjrtjd||||\}|S)Nr%rs StringUpperrRrSrrrs rPrrdrri TV_Substr_Tposrc tjxstj}|j}|jr t j |d||||d|}|S|d}tj|d}tj d|||||\} } } } | dd}tj"rHd| j%dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rYwxYw)a< Return substrings from `Tensor` of strings. For each string in the input `Tensor`, creates a substring starting at index `pos` with a total length of `len`. If `len` defines a substring that would extend beyond the length of the input string, or if `len` is negative, then as many characters as possible are used. A negative `pos` indicates distance within the string backwards from the end. If `pos` specifies an index which is out of range for any of the input strings, then an `InvalidArgumentError` is thrown. `pos` and `len` must have the same shape, otherwise a `ValueError` is thrown on Op creation. *NOTE*: `Substr` supports broadcasting up to two dimensions. More about broadcasting [here](http://docs.scipy.org/doc/numpy/user/basics.broadcasting.html) --- Examples Using scalar `pos` and `len`: ```python input = [b'Hello', b'World'] position = 1 length = 3 output = [b'ell', b'orl'] ``` Using `pos` and `len` with same shape as `input`: ```python input = [[b'ten', b'eleven', b'twelve'], [b'thirteen', b'fourteen', b'fifteen'], [b'sixteen', b'seventeen', b'eighteen']] position = [[1, 2, 3], [1, 2, 3], [1, 2, 3]] length = [[2, 3, 4], [4, 3, 2], [5, 5, 5]] output = [[b'en', b'eve', b'lve'], [b'hirt', b'urt', b'te'], [b'ixtee', b'vente', b'hteen']] ``` Broadcasting `pos` and `len` onto `input`: ``` input = [[b'ten', b'eleven', b'twelve'], [b'thirteen', b'fourteen', b'fifteen'], [b'sixteen', b'seventeen', b'eighteen'], [b'nineteen', b'twenty', b'twentyone']] position = [1, 2, 3] length = [1, 2, 3] output = [[b'e', b'ev', b'lve'], [b'h', b'ur', b'tee'], [b'i', b've', b'hte'], [b'i', b'en', b'nty']] ``` Broadcasting `input` onto `pos` and `len`: ``` input = b'thirteen' position = [1, 5, 7] length = [3, 2, 1] output = [b'hir', b'ee', b'n'] ``` Raises: * `ValueError`: If the first argument cannot be converted to a Tensor of `dtype string`. * `InvalidArgumentError`: If indices are out of range. * `ValueError`: If `pos` and `len` are not the same shape. Args: input: A `Tensor` of type `string`. Tensor of strings pos: A `Tensor`. Must be one of the following types: `int32`, `int64`. Scalar defining the position of first character in each substring len: A `Tensor`. Must have the same type as `pos`. Scalar defining the number of characters to include in each substring unit: An optional `string` from: `"BYTE", "UTF8_CHAR"`. Defaults to `"BYTE"`. The unit that is used to create the substring. One of: `"BYTE"` (for defining position and length by bytes) or `"UTF8_CHAR"` (for the UTF-8 encoded Unicode code points). The default is `"BYTE"`. Results are undefined if `unit=UTF8_CHAR` and the `input` strings do not contain structurally valid UTF-8. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. SubstrrNrr)rr#rrr!r&)r'rr(r)rr*r+r,r-r.r/substr_eager_fallbackr3r:r=r>r?r@rArDrErF)rr#rrr!rGrHrIrJrKrLrMrNrOs rPsubstrr'vsvN    0h..0$ #\\ 11 heS#vt=g n \ D   4 ($'883CdG!QX QK' ""$3%%c*FCLL4H IF::L ,1 (' .-  & &- ##At,,  # #    " c4T;;  # #   s0C??ED--EE EE21E2zraw_ops.Substrc|d}tj|d}tj||g|tjtj g\}}|\}}t j|tj}|||g}d|d|f} tjdd|| ||} tjrtjd|| | | \} | S)Nrrr&sSubstrrRrSr% r:r=rUrVrYr]r-rurgrr@rF) rr#rrr!r"rh _inputs_TrOrNrIs rPr&r&s \ D   4 ($66Sz3X_XeXeHhi'9*3   7%c", &$ '&   Y,f!$4 1' ""$ ,1 (' .ri UnicodeDecode row_splits char_valuesTV_UnicodeDecode_Tsplitsreplaceinput_encodingerrorsreplacement_charreplace_control_charactersrctjxstj}|j}|jr: t j |d||d|d|d|d|d|} t j| } | Stj |d}|d }tj |d}|d }tj"|d}|d }tj$|d}|t&j(}tj*|d}t-j.d||||||| \} } } } | dd} tj0r{d| j3dd| j3dd| j5dd| j7dd| j9df }| j:}tj<d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||S#tj$rYwxYw) a Decodes each string in `input` into a sequence of Unicode code points. The character codepoints for all strings are returned using a single vector `char_values`, with strings expanded to characters in row-major order. The `row_splits` tensor indicates where the codepoints for each input string begin and end within the `char_values` tensor. In particular, the values for the `i`th string (in row-major order) are stored in the slice `[row_splits[i]:row_splits[i+1]]`. Thus: * `char_values[row_splits[i]+j]` is the Unicode codepoint for the `j`th character in the `i`th string (in row-major order). * `row_splits[i+1] - row_splits[i]` is the number of characters in the `i`th string (in row-major order). Args: input: A `Tensor` of type `string`. The text to be decoded. Can have any shape. Note that the output is flattened to a vector of char values. input_encoding: A `string`. Text encoding of the input strings. This is any of the encodings supported by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`. errors: An optional `string` from: `"strict", "replace", "ignore"`. Defaults to `"replace"`. Error handling policy when there is invalid formatting found in the input. The value of 'strict' will cause the operation to produce a InvalidArgument error on any invalid input formatting. A value of 'replace' (the default) will cause the operation to replace any invalid formatting in the input with the `replacement_char` codepoint. A value of 'ignore' will cause the operation to skip any invalid formatting in the input and produce no corresponding output character. replacement_char: An optional `int`. Defaults to `65533`. The replacement character codepoint to be used in place of any invalid formatting in the input when `errors='replace'`. Any valid unicode codepoint may be used. The default value is the default unicode replacement character is 0xFFFD or U+65533.) replace_control_characters: An optional `bool`. Defaults to `False`. Whether to replace the C0 control characters (00-1F) with the `replacement_char`. Default is false. Tsplits: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (row_splits, char_values). row_splits: A `Tensor` of type `Tsplits`. char_values: A `Tensor` of type `int32`. r+r1r2r3r4rNr1r2r3r4rr!r"r/r0Frr1r2r3r4rr!)r'rr(r)rr*_UnicodeDecodeOutputrr+r,r-r.r/unicode_decode_eager_fallbackr3r:r=r;r<rVr] make_typer>r?r@rDrBrCrArErFrr1r2r3r4rr!rGrHrIrJrKrLrMrNrOs rPunicode_decoder<sdb    0h..0$ #\\  11 otU,$&@) g %**73g n$$^5EF. ^ F   VX .&&&'79KL'!&'112LNjk _mmG   w 2''88u^ &9I4N!(t 5!QX QK' ""$ -= >ll8$&8 23*  !=>   + -F ::L vw8 & &w /' .W  & &- ##At,,  # #    * v+%?$ 00  # #   08GH%HHHH00IIzraw_ops.UnicodeDecodec <tj|d}|d}tj|d}|d}tj|d}|d}tj|d}|tj }tj |d}tj|tj}|g}d|d|d|d|d|f } tjd d || || } tjrtjd || | tj| } | S) Nr1r/r2r0r3Fr4rs UnicodeDecoderrSr+)r:r=r;r<rVr]r:r-rurgrr@rFr8r rr1r2r3r4rr!r"rOrNrIs rPr9r9s($$^5EF. ^ F   VX .&&&'79KL'!&'112LNjk _mmG   w 2'   7%, nh&(Di 2&   -q#)s ?' ""$ vw8 & &w /' .riUnicodeDecodeWithOffsets)r,r-char_to_byte_starts#TV_UnicodeDecodeWithOffsets_Tsplitsctjxstj}|j}|jr: t j |d||d|d|d|d|d|} t j| } | Stj |d}|d }tj |d}|d }tj"|d}|d }tj$|d}|t&j(}tj*|d}t-j.d||||||| \} } } } | dd} tj0r{d| j3dd| j3dd| j5dd| j7dd| j9df }| j:}tj<d||| t j| } | S#tj$r } tj| |Yd} ~ nd} ~ wtj$rYnwxYw t||||||||S#tj$rYwxYw) aw Decodes each string in `input` into a sequence of Unicode code points. The character codepoints for all strings are returned using a single vector `char_values`, with strings expanded to characters in row-major order. Similarly, the character start byte offsets are returned using a single vector `char_to_byte_starts`, with strings expanded in row-major order. The `row_splits` tensor indicates where the codepoints and start offsets for each input string begin and end within the `char_values` and `char_to_byte_starts` tensors. In particular, the values for the `i`th string (in row-major order) are stored in the slice `[row_splits[i]:row_splits[i+1]]`. Thus: * `char_values[row_splits[i]+j]` is the Unicode codepoint for the `j`th character in the `i`th string (in row-major order). * `char_to_bytes_starts[row_splits[i]+j]` is the start byte offset for the `j`th character in the `i`th string (in row-major order). * `row_splits[i+1] - row_splits[i]` is the number of characters in the `i`th string (in row-major order). Args: input: A `Tensor` of type `string`. The text to be decoded. Can have any shape. Note that the output is flattened to a vector of char values. input_encoding: A `string`. Text encoding of the input strings. This is any of the encodings supported by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`. errors: An optional `string` from: `"strict", "replace", "ignore"`. Defaults to `"replace"`. Error handling policy when there is invalid formatting found in the input. The value of 'strict' will cause the operation to produce a InvalidArgument error on any invalid input formatting. A value of 'replace' (the default) will cause the operation to replace any invalid formatting in the input with the `replacement_char` codepoint. A value of 'ignore' will cause the operation to skip any invalid formatting in the input and produce no corresponding output character. replacement_char: An optional `int`. Defaults to `65533`. The replacement character codepoint to be used in place of any invalid formatting in the input when `errors='replace'`. Any valid unicode codepoint may be used. The default value is the default unicode replacement character is 0xFFFD or U+65533.) replace_control_characters: An optional `bool`. Defaults to `False`. Whether to replace the C0 control characters (00-1F) with the `replacement_char`. Default is false. Tsplits: An optional `tf.DType` from: `tf.int32, tf.int64`. Defaults to `tf.int64`. name: A name for the operation (optional). Returns: A tuple of `Tensor` objects (row_splits, char_values, char_to_byte_starts). row_splits: A `Tensor` of type `Tsplits`. char_values: A `Tensor` of type `int32`. char_to_byte_starts: A `Tensor` of type `int64`. r@r1r2r3r4rNr6r/r0Fr7)r'rr(r)rr*_UnicodeDecodeWithOffsetsOutputrr+r,r-r.r/*unicode_decode_with_offsets_eager_fallbackr3r:r=r;r<rVr]r:r>r?r@rDrBrCrArErFr;s rPunicode_decode_with_offsetsrFsgl    0h..0$ #\\  11 ($7G&*<6"Iw 8g 055g>g n$$^5EF. ^ F   VX .&&&'79KL'!&'112LNjk _mmG   w 2''88"%3A+15E?Y,3$ @!QX QK' ""$ -= >ll8$&8 23*  !=>   + -F ::L "L&'C + 1 1' :' .[  & &- ##At,,  # #    7 v+%?$ 00  # #   r=z raw_ops.UnicodeDecodeWithOffsetsc <tj|d}|d}tj|d}|d}tj|d}|d}tj|d}|tj }tj |d}tj|tj}|g}d|d|d|d|d|f } tjd d || || } tjrtjd || | tj| } | S) Nr1r/r2r0r3Fr4rsUnicodeDecodeWithOffsetsrrSr@)r:r=r;r<rVr]r:r-rurgrr@rFrDrr?s rPrErE s,$$^5EF. ^ F   VX .&&&'79KL'!&'112LNjk _mmG   w 2'   7%, nh&(Di 2&   8!$0C"& ('""$ "L&'C + 1 1' :' .riTV_UnicodeEncode_Tsplits input_values input_splitsoutput_encodingc tjxstj}|j}|jr" t j |d|||d|d|d| }|Stj|d}|d}tj|d}|d}tj|d}t!j"d|||||| \} } } } | dd}tj$rjd| j'dd| j'dd| j)dd | j+d f} | j,}tj.d|| ||\}|S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||S#t j$rYgwxYw) a$Encode a tensor of ints into unicode strings. Returns a vector of strings, where `output[i]` is constructed by encoding the Unicode codepoints in `input_values[input_splits[i]:input_splits[i+1]]` using `output_encoding`. --- Example: ``` input_values = [72, 101, 108, 108, 111, 87, 111, 114, 108, 100] input_splits = [0, 5, 10] output_encoding = 'UTF-8' output = ['Hello', 'World'] ``` Args: input_values: A `Tensor` of type `int32`. A 1D tensor containing the unicode codepoints that should be encoded. input_splits: A `Tensor`. Must be one of the following types: `int32`, `int64`. A 1D tensor specifying how the unicode codepoints should be split into strings. In particular, `output[i]` is constructed by encoding the codepoints in the slice `input_values[input_splits[i]:input_splits[i+1]]`. output_encoding: A `string` from: `"UTF-8", "UTF-16-BE", "UTF-32-BE"`. Unicode encoding of the output strings. Valid encodings are: `"UTF-8", "UTF-16-BE", and "UTF-32-BE"`. errors: An optional `string` from: `"ignore", "replace", "strict"`. Defaults to `"replace"`. Error handling policy when there is invalid formatting found in the input. The value of 'strict' will cause the operation to produce a InvalidArgument error on any invalid input formatting. A value of 'replace' (the default) will cause the operation to replace any invalid formatting in the input with the `replacement_char` codepoint. A value of 'ignore' will cause the operation to skip any invalid formatting in the input and produce no corresponding output character. replacement_char: An optional `int`. Defaults to `65533`. The replacement character codepoint to be used in place of any invalid formatting in the input when `errors='replace'`. Any valid unicode codepoint may be used. The default value is the default unicode replacement character is 0xFFFD (U+65533). name: A name for the operation (optional). Returns: A `Tensor` of type `string`. UnicodeEncoder2rKr3N)r2rKr3r!r"r/r0)rIrJrKr2r3r!r)r'rr(r)rr*r+r,r-r.r/unicode_encode_eager_fallbackr3r:r=r;r>r?r@rDrBrArErF)rIrJrKr2r3r!rGrHrIrJrKrLrMrNrOs rPunicode_encoderO7 s^    0h..0$ #\\  11 ot\<!?4Fgn%%o7HI/ ^ F   VX .&&&'79KL'88l)8*:G!QX QK' ""$ X.0All,-/A 23Y  +-F::L vw8 (' .C  & &- ##At,,  # #    *  V)SVY`YfYfhohuhuXx{B{H{H$I -,'' gmmD, -, f/& = B&   -q#)s ?' ""$ vw8 (' .rizstrings.unicode_scriptc tjxstj}|j}|jr t j |d||}|St||fd}|tur|S t/j0d||\}}}}|dd}t3j4r&d} |j6} t3j8d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||fd}|tur|St|||S#t j$rYtt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw#tt f$rHt#j$t&dt)||}|t"j*j,ur|cYSwxYw)aDetermine the script codes of a given tensor of Unicode integer code points. This operation converts Unicode code points to script codes corresponding to each code point. Script codes correspond to International Components for Unicode (ICU) UScriptCode values. See [ICU project docs](http://icu-project.org/apiref/icu4c/uscript_8h.html) for more details on script codes. For an example, see the unicode strings guide on [unicode scripts] (https://www.tensorflow.org/tutorials/load_data/unicode#representing_unicode). Returns -1 (USCRIPT_INVALID_CODE) for invalid codepoints. Output shape will match input shape. Examples: >>> tf.strings.unicode_script([1, 31, 38]) Args: input: A `Tensor` of type `int32`. A Tensor of int32 Unicode code points. name: A name for the operation (optional). Returns: A `Tensor` of type `int32`. UnicodeScriptNrmr#rn)r'rr(r)rr*r+r,r-r.r/_dispatcher_for_unicode_scriptr1unicode_script_eager_fallbackr3r4r5r6r unicode_scriptr7r8r9r>r?r:r@rErFrqs rPrUrU s @    0h..0$ #\\ 11 otU,g n,- Gn$ n  )::u41Aq#x QK' ""$ F::L vw8 (' .W  & &- ##At,,  # #    . $.$ g  & * d&&  # #  z " "" B5t < g  ..<< <  Z    "dT: Gi,,::: n  rrzraw_ops.UnicodeScriptctj|tj}|g}d}t j dd||||}t j rt jd||||\}|S)Ns UnicodeScriptrRrSrR)r-rurVrYr:rr@rFrvs rPrTrT sq   6%, &   -q#)s ?' ""$ vw8 (' .rizstrings.unicode_transcodec tjxstj}|j}|jr% t j |d||d|d|d|d|d|} | St|||||||fd} | tur| St/j0|d}t/j0|d}|d }t/j0|d}|d }t/j2|d}|d }t/j4|d} t7j8d||||||| \} } } } | dd} t/j:r{d| j=dd| j=dd| j=dd| j?dd| jAdf }| jB}t/jDd||| | \} | S#t j$r } tj| |Yd} ~ nd} ~ wt j$rYnwxYw t|||||||fd} | tur| St||||||||S#t j$rYtt f$rMt#j$t&d t)||||||| } | t"j*j,ur| cYSwxYw#tt f$rMt#j$t&d t)||||||| } | t"j*j,ur| cYSwxYw)aTranscode the input text from a source encoding to a destination encoding. The input is a string tensor of any shape. The output is a string tensor of the same shape containing the transcoded strings. Output strings are always valid unicode. If the input contains invalid encoding positions, the `errors` attribute sets the policy for how to deal with them. If the default error-handling policy is used, invalid formatting will be substituted in the output by the `replacement_char`. If the errors policy is to `ignore`, any invalid encoding positions in the input are skipped and not included in the output. If it set to `strict` then any invalid formatting will result in an InvalidArgument error. This operation can be used with `output_encoding = input_encoding` to enforce correct formatting for inputs even if they are already in the desired encoding. If the input is prefixed by a Byte Order Mark needed to determine encoding (e.g. if the encoding is UTF-16 and the BOM indicates big-endian), then that BOM will be consumed and not emitted into the output. If the input encoding is marked with an explicit endianness (e.g. UTF-16-BE), then the BOM is interpreted as a non-breaking-space and is preserved in the output (including always for UTF-8). The end result is that if the input is marked as an explicit endianness the transcoding is faithful to all codepoints in the source. If it is not marked with an explicit endianness, the BOM is not considered part of the string itself but as metadata, and so is not preserved in the output. Examples: >>> tf.strings.unicode_transcode(["Hello", "TensorFlow", "2.x"], "UTF-8", "UTF-16-BE") >>> tf.strings.unicode_transcode(["A", "B", "C"], "US ASCII", "UTF-8").numpy() array([b'A', b'B', b'C'], dtype=object) Args: input: A `Tensor` of type `string`. The text to be processed. Can have any shape. input_encoding: A `string`. Text encoding of the input strings. This is any of the encodings supported by ICU ucnv algorithmic converters. Examples: `"UTF-16", "US ASCII", "UTF-8"`. output_encoding: A `string` from: `"UTF-8", "UTF-16-BE", "UTF-32-BE"`. The unicode encoding to use in the output. Must be one of `"UTF-8", "UTF-16-BE", "UTF-32-BE"`. Multi-byte encodings will be big-endian. errors: An optional `string` from: `"strict", "replace", "ignore"`. Defaults to `"replace"`. Error handling policy when there is invalid formatting found in the input. The value of 'strict' will cause the operation to produce a InvalidArgument error on any invalid input formatting. A value of 'replace' (the default) will cause the operation to replace any invalid formatting in the input with the `replacement_char` codepoint. A value of 'ignore' will cause the operation to skip any invalid formatting in the input and produce no corresponding output character. replacement_char: An optional `int`. Defaults to `65533`. The replacement character codepoint to be used in place of any invalid formatting in the input when `errors='replace'`. Any valid unicode codepoint may be used. The default value is the default unicode replacement character is 0xFFFD or U+65533.) Note that for UTF-8, passing a replacement character expressible in 1 byte, such as ' ', will preserve string alignment to the source since invalid bytes will be replaced with a 1-byte replacement. For UTF-16-BE and UTF-16-LE, any 1 or 2 byte replacement character will preserve byte alignment to the source. replace_control_characters: An optional `bool`. Defaults to `False`. Whether to replace the C0 control characters (00-1F) with the `replacement_char`. Default is false. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. UnicodeTranscoder1rKr2r3r4N)r1rKr2r3r4r!r"r#)rr1rKr2r3r4r!r/r0F)#r'rr(r)rr*r+r,r-r.r/!_dispatcher_for_unicode_transcoder1 unicode_transcode_eager_fallbackr3r4r5r6r unicode_transcoder7r8r9r:r=r;r<r>r?r@rDrBrCrErF)rr1rKr2r3r4r!rGrHrIrJrKrLrMrNrOs rPr[r[ siX    0h..0$ #\\  11  $/?)?Hf,.J" $g nB0 9I"D +,02Gn$ n$$^5EF.%%o7HI/ ^ F   VX .&&&'79KL'!&'112LNjk )::%,;F-=7Q!% 'Aq#x& QK' ""$ -= >.?!@(ll8$&8 23*  !=> @F ::L L&'; (' .c  & &- ##At,,  # #    1 ./6;K $d -.24g  & - )&+%?d   # #  z "  "" r4e7E8G/59IC]-1 $3 g  ..<< <   L Z    RE5C6E-37GA[+/ "1 Gi,,::: n   sP#F8<"J'8G? G&&G?>G?H3 H33J$ AJ$"J$'ALLzraw_ops.UnicodeTranscodec tj|d}tj|d}|d}tj|d}|d}tj|d}|d}tj|d}t j |t j}|g}d|d|d|d|d|f } tjd d || || } tjrtjd || | | \} | S) Nr1rKr/r2r0r3Fr4sUnicodeTranscoderRrSrX) r:r=r;r<r-rurVrgrr@rF) rr1rKr2r3r4r!r"rOrNrIs rPrZrZ s$$^5EF.%%o7HI/ ^ F   VX .&&&'79KL'!&'112LNjk   7%, n.?8V%79I : <&   0!L#)s ?' ""$ L&'; (' .riTV_UnsortedSegmentJoin_Tindices#TV_UnsortedSegmentJoin_Tnumsegments segment_ids num_segmentsc  tjxstj}|j}|jr t j |d||||d|}|S|d}tj|d}tj d|||||\} } } } | dd}tj"rYd| j%dd| j'dd| j'df} | j(} tj*d| | ||\}|S#t j$r }tj||Yd}~nd}~wt j$rYnwxYw t||||||S#t j$rY$wxYw) a}TODO: add doc. Args: inputs: A `Tensor` of type `string`. segment_ids: A `Tensor`. Must be one of the following types: `int32`, `int64`. num_segments: A `Tensor`. Must be one of the following types: `int32`, `int64`. separator: An optional `string`. Defaults to `""`. name: A name for the operation (optional). Returns: A `Tensor` of type `string`. UnsortedSegmentJoinrNrr%)rEr_r`rr!Tindices Tnumsegments)r'rr(r)rr*r+r,r-r.r/$unsorted_segment_join_eager_fallbackr3r:r=r>r?r@rDrArErF)rEr_r`rr!rGrHrIrJrKrLrMrNrOs rPunsorted_segment_joinrf s    0h..0$ #\\ 11 #T6; Y gnI ;7)'88f+,8I$(*!QX QK' ""$3<< 4j  ,n  02F::L |VW> (' .7  & &- ##At,,  # #    1 +|yt  # #   s0DE#D>>EEE,,FFzraw_ops.UnsortedSegmentJoinc<|d}tj|d}tj|g|tjtj g\}\}tj|g|tjtj gtj\}\}t j|tj}|||g}d|d|d|f} tjdd|| ||} tjrtjd|| | | \} | S) Nr%rrcrdsUnsortedSegmentJoinrRrSrbr)) rEr_r`rr!r"_attr_Tindices_attr_TnumsegmentsrOrNrIs rPrere sI ;7)#+#B#BK=RUX_XeXegngtgtWw#x ..;(0(G(GX[^e^k^kmtmzmz]}@G@M@M)N%o|  ! !&'.. 9&+|4, J$ &&   3Q|#)s ?' ""$ |VW> (' .ri)r$FFr$r%N)N)FN)Fr%N)TN)rrrN)r%N)rN)r$N)r/r0N)r/r0FN)__doc__ collectionstensorflow.pythonrtensorflow.python.eagerrr'rr+rr:tensorflow.python.frameworkrrVtensorflow.security.fuzzing.pyr_atypesr _op_def_registryr r-r r>"tensorflow.python.util.deprecationr tensorflow.python.utilr r6 tensorflow.python.util.tf_exportrtypingrrrtyping_extensionsrradd_fallback_dispatch_listadd_type_based_api_dispatcherintrestrStringr to_raw_opr _tf_type_based_dispatcherDispatchr0r2rjrlrorprwrzr{r|Int32rrrBoolrrrrrrrrrrrrrrrrrrrrrrrrr namedtuplerrrrrrrrrrrrrrrrrInt64r rr rrrrrrrrr rrrr"r'r%r&r8r.r]r<r+r9rDrBrFr@rErHrOrMrNrUrRrSrTr[rXrYrZr]r^rfrbrer#rirPrs 67179FK3IC86%%');^MacvyJL]_mo~@OQ`bprBDTVfhxzIK\]  %% ((  0fg()rYsM12rcrQUrfjrx{rFIr\efikrkykyfy\zr*h)&rh )9' ( )B C%??HHIc=.@$Ac_cos|HK[dehjqjxjxex[y: %% (( #5"GHo&@3#67@yQTV]VdVdQdGe@'I)&@D1y/0 1NO - G G P P  #w~~2E(F V_`celeses`sVt  %% (( #5"GHo&H3#67HTHW`adfmftftatWuH'I)&HT1y/0 1NO - G G P P  #w~~2E(F T ajknpwp~p~k~a  O #w~~"56O9UXZaZgZgUgKhOtxOKNOajknpwp~p~k~aOb-Y+ ,^T^^K-H I ygnn1D'EZcdgipivivdvZwEIVYirsvxxFxFsFiG(5Ic7>>&9:5YsT[TbTbObEc5s|~ACJCOCO~OtP5n534^T^^DT5UV 9S'..5H+I T]^acjcqcq^qTr CLMPRYR^R^M^C_ 63#676)CQXQ_Q_L_B`6ktux{B{I{IvIlJ6[_6t}~ACJCQCQ~QtR6p1y/0 1NO  #w~~2E(FQZ[^`g`n`n[nQo{DEHJQJXJXEX{YkoHILNUN\N\I\]$.9S'..-@#A.C._hilnunznziz_{.`Ay!?@PgAhi )C55WZ5ko5ENORT[TbTbObEc5n=Y;<^T^^L`=abygnn9L/MX[fi{PYZ]_f_m_mZmPn&<3<<S<bkloqxqqlcA<|1y/0 1NO 3SUXhqruw~xFxFsFiG.: $s)W^^";<::^ghkmtm{m{h{^|:x-Y+ ,^T^^K-H I ycGNN1J'KX[ktux{B{I{IvIlJ*63#676c6XabegngtgtbtXu6p1y/0 1NO   #w~~2E(F c ajknpwp}p}k}a~   %% (( ?G #w~~"56GGW`adfmftftatWuG)&GR/i-.~t~~l/KL +EENN ygnn1D'E QT dmnqsztBtBoBeC -k,, ! "";_o^Z3#67ZiPSUlPlFmZz}ZX[ZhkZx{ZW[Zx1y/01OP  #w~~2E(FU^_bd{_{U|JMgjwzGJfj4,[++"$ F #w~~"56F9SRYR`R`M`CaFnrFP/i-.~t~~l/KL ygnn1D'ER[\_ahaoao\oRpC .{--"$ J9S'..%89J #w~~J]@^JilJX3 12>4>>/3RS )C4G*HyY\^e^l^lYlOmy|" %% (( ?@An%A #w~~"56AiPSU\UcUcPcFdA&B)&AF/i-.~t~~l/KL +EENN ygnn1D'E U^_bdkdrdr_rUs /33F)G/VY/irsvxyFyFtFjG/b=Y;<^T^^La=bc  #w~~BU8V eh yBCFHOHUHUCUyV  %% (( (.KMi-jk23PiW^^0C&DPSVPfopsu|vCvCqCgDP4l)&PdE#CD^T^^TnEop-G-a-a-j-j* YsGNN?R5S be u~@CELERER@RvS  %% (( *0OQo/pq45` #w~~2E(F`UX`mvwz}D}J}JxJnK`6r)&`DI9%GHXtIuv/K/e/e/n/n,ygnnAT7Udg}FGJLSLYLYGY}Z( %% (( ?G #w~~"56GGW`adfmftftatWuG)&GR/i-.~t~~l/KL +EENN ygnn1D'E QT dmnqsztBtBoBeC  m_oF D)C/0DykAQ7RDYbcfhscsYtD{~DV_`celeses`sVtDL %# $^T^^F%; <3+>!?iPSU`P`FahqruxCsCiDLO_hilnun|n|i|_}".{--=!# ##=P_`ZczbgJQJWJW^bg)C$78g#gVYgvyg]agqIgR3 12>4>>.3QR 33F)GY\fi~A_cnF6#9+"8"88#: '..SUdfu&v#gpHMotbibobovznygnn1D'EnWZncfnDGnjnn~an`I9%GHXsItuiW^^@S6TfisvKNlp{^:##=P_`Y3 +=!>YiX[]uXuNvYJMYVYYvyYOXY\^e^l^lYlOmYv3 12>4>>.3QR  #w}}:L0M]fgjmEhE^FY\fi}@PYZ]_f_m_mZmPn, %% (( #$O)C$67OyQTV]VcVcQcGdO%)&Ob3 12>4>>.3QR !/!I!I!R!R 3 3E)F V_`celerer`rVs  %% (( &'dYsGNN':;dSdcfdordPSdvzdPYZ]_f_m_mZmPnd()&dL9978HY9Z[$5$O$O$X$X!Ic7>>6I,J\_ru@CWZx|LUVY[b[i[iViLj4#**K_^m"n&-.SUdfu&v#0)C,?"@0yY\^}Y}O~0OXY\^AYAOB0NQ0dmnqszsAsAnAdB0d?i =>~t~~Nc?de3;N1O^ghknMiM_N^ghkmPhP^Q^aqz{~@G@N@N{NqOri