wgK dZddlZddlZddlmZmZmZmZmZm Z m Z m Z ddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZm Z!m"Z#m$Z%m&Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0gdZ1ejdejfjhZ5dZ6dZ7d Z8d Z d Z9d*d Zd*d Zd*dZd*dZ d*dZ"d*dZ$d*dZ&d+dZ:d+dZ;d,dZd-dZ?d.dZ@d.dZAd.dZBdZCdZDdZEdZFd ZGd!ZHd/d"ZId#ZJd+d$ZKd+d%ZLd.d&ZMd'ZNd(ZOd.d)ZPy)0zK This module contains a set of functions for vectorized string operations. N)equal not_equalless less_equalgreater greater_equaladdmultiply) _vec_string)isalphaisdigitisspaceisalnumislowerisupperistitle isdecimal isnumericstr_lenfindrfindindexrindexcount startswithendswith_lstrip_whitespace _lstrip_chars_rstrip_whitespace _rstrip_chars_strip_whitespace _strip_chars_replace_expandtabs_length _expandtabs)+rrrrrrr r r r rrrrrrrrrrrrrrrlstriprstripstripreplace expandtabscenterljustrjustzfillupperlowerswapcase capitalizetitlemoddecodeencode translatect|jjtjr|j dzS|j S)z Helper function that returns the number of characters per field in a string or unicode array. This is to abstract out the fact that for a unicode array this is itemsize / 4. ) issubclassdtypetypenpstr_itemsize)as X/home/mcse/projects/flask/flask-venv/lib/python3.12/site-packages/numpy/_core/strings.py_get_num_charsrBBs2 !'',,(zzQ ::ctj|}|jdk(r|j|jStj|j }t |jtjjr$|jt|jS|jt|jt|S)z Helper function to cast a result back into an array with the appropriate dtype if an object array must be used as an intermediary. r) r=asarraysizeastyper;tolist isinstancedtypes StringDTyper<rB)resultoutput_dtype_likerets rA_to_bytes_or_str_arrayrOMs  #45 {{a}}.4455 **V]]_ %C#))299+@+@Azz$066788 ::3d,223N34GH IIrCcDg}|D]}||S|j||S)a! Helper function for delegating arguments to Python string functions. Many of the Python string operations that have optional arguments do not use 'None' to indicate a default value. In these cases, we need to remove all None arguments, and those following them. )append)argsnewargschks rA _clean_argsrU^s:G ;  N s NrCctj|}tj|}tj|jtjst d|jdtj |d}|jjdk(r||zSt|}tj|tjtj |dz kDr td||z}|jj|j}tj||j|}t!|||S) aQ Return (a * i), that is string multiple concatenation, element-wise. Values in ``i`` of less than 0 are treated as 0 (which yields an empty string). Parameters ---------- a : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype i : array_like, with any integer dtype Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types Examples -------- >>> a = np.array(["a", "b", "c"]) >>> np.strings.multiply(a, 3) array(['aaa', 'bbb', 'ccc'], dtype='>> i = np.array([1, 2, 3]) >>> np.strings.multiply(a, i) array(['a', 'bb', 'ccc'], dtype='>> np.strings.multiply(np.array(['a']), i) array(['a', 'aa', 'aaa'], dtype='>> a = np.array(['a', 'b', 'c', 'd', 'e', 'f']).reshape((2, 3)) >>> np.strings.multiply(a, 3) array([['aaa', 'bbb', 'ccc'], ['ddd', 'eee', 'fff']], dtype='>> np.strings.multiply(a, i) array([['a', 'bb', 'ccc'], ['d', 'ee', 'fff']], dtype='>> a = np.array(["NumPy is a Python library"]) >>> np.strings.find(a, "Python") array([11]) )MAX _find_ufuncr@substartends rArrs!@#cC q#uc **rCc2||nt}t||||S)aj For each element, return the highest index in the string where substring ``sub`` is found, such that ``sub`` is contained in the range [``start``, ``end``). Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype sub : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype The substring to search for. start, end : array_like, with any integer dtype The range to look in, interpreted as in slice notation. Returns ------- y : ndarray Output array of ints See Also -------- str.rfind )rt _rfind_ufuncrvs rArrs 4#cC 3s ++rCc2||nt}t||||S)aM Like `find`, but raises :exc:`ValueError` when the substring is not found. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype sub : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype start, end : array_like, with any integer dtype, optional Returns ------- out : ndarray Output array of ints. See Also -------- find, str.index Examples -------- >>> a = np.array(["Computer Science"]) >>> np.strings.index(a, "Science", start=0, end=None) array([9]) )rt _index_ufuncrvs rArrs 8#cC 3s ++rCc2||nt}t||||S)aY Like `rfind`, but raises :exc:`ValueError` when the substring `sub` is not found. Parameters ---------- a : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype sub : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype start, end : array-like, with any integer dtype, optional Returns ------- out : ndarray Output array of ints. See Also -------- rfind, str.rindex Examples -------- >>> a = np.array(["Computer Science"]) >>> np.strings.rindex(a, "Science", start=0, end=None) array([9]) )rt _rindex_ufuncrvs rArr's :#cC C ,,rCc2||nt}t||||S)a Returns an array with the number of non-overlapping occurrences of substring ``sub`` in the range [``start``, ``end``). Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype sub : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype The substring to search for. start, end : array_like, with any integer dtype The range to look in, interpreted as in slice notation. Returns ------- y : ndarray Output array of ints See Also -------- str.count Examples -------- >>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> c array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.count(c, 'A') array([3, 1, 1]) >>> np.strings.count(c, 'aA') array([3, 1, 0]) >>> np.strings.count(c, 'A', start=1, end=4) array([2, 1, 1]) >>> np.strings.count(c, 'A', start=1, end=3) array([1, 0, 0]) )rt _count_ufuncrvs rArrHs!N#cC 3s ++rCc2||nt}t||||S)aT Returns a boolean array which is `True` where the string element in ``a`` starts with ``prefix``, otherwise `False`. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype prefix : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype start, end : array_like, with any integer dtype With ``start``, test beginning at that position. With ``end``, stop comparing at that position. Returns ------- out : ndarray Output array of bools See Also -------- str.startswith )rt_startswith_ufunc)r@prefixrxrys rArrss 2#cC Qs 33rCc2||nt}t||||S)aN Returns a boolean array which is `True` where the string element in ``a`` ends with ``suffix``, otherwise `False`. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype suffix : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype start, end : array_like, with any integer dtype With ``start``, test beginning at that position. With ``end``, stop comparing at that position. Returns ------- out : ndarray Output array of bools See Also -------- str.endswith Examples -------- >>> s = np.array(['foo', 'bar']) >>> s array(['foo', 'bar'], dtype='>> np.strings.endswith(s, 'ar') array([False, True]) >>> np.strings.endswith(s, 'a', start=1, end=2) array([False, True]) )rt_endswith_ufunc)r@suffixrxrys rArrs!F#cC 1feS 11rCc tt|tjdt ||tj dS)a Calls :meth:`bytes.decode` element-wise. The set of available codecs comes from the Python standard library, and may be extended at runtime. For more information, see the :mod:`codecs` module. Parameters ---------- a : array_like, with ``bytes_`` dtype encoding : str, optional The name of an encoding errors : str, optional Specifies how to handle encoding errors Returns ------- out : ndarray See Also -------- :py:meth:`bytes.decode` Notes ----- The type of the result will depend on the encoding specified. Examples -------- >>> c = np.array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@', ... b'\x81\x82\xc2\xc1\xc2\x82\x81']) >>> c array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@', b'\x81\x82\xc2\xc1\xc2\x82\x81'], dtype='|S7') >>> np.strings.decode(c, encoding='cp037') array(['aAaAaA', ' aA ', 'abBABba'], dtype='r@encodingerrorss rAr5r5s6R "Arzz8[6-JK   rCc tt|tjdt ||tj dS)u5 Calls :meth:`str.encode` element-wise. The set of available codecs comes from the Python standard library, and may be extended at runtime. For more information, see the :mod:`codecs` module. Parameters ---------- a : array_like, with ``StringDType`` or ``str_`` dtype encoding : str, optional The name of an encoding errors : str, optional Specifies how to handle encoding errors Returns ------- out : ndarray See Also -------- str.encode Notes ----- The type of the result will depend on the encoding specified. Examples -------- >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.encode(a, encoding='cp037') array([b'ÁÁÁ', b'@@Á@@', b'‚ÂÁ‚'], dtype='|S7') r6rC)rOr r=rqrUbytes_rs rAr6r6s6L "Arzz8[6-JK # rCctj|}tj|}|jjdk(rBtj|j |j }tj ||}nVt||}|jj|j}tj ||j |}t|||S)ai Return a copy of each string element where all tab characters are replaced by one or more spaces. Calls :meth:`str.expandtabs` element-wise. Return a copy of each string element where all tab characters are replaced by one or more spaces, depending on the current column and the given `tabsize`. The column number is reset to zero after each newline occurring in the string. This doesn't understand other non-printing characters or escape sequences. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array tabsize : int, optional Replace tabs with `tabsize` number of spaces. If not given defaults to 8 spaces. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input type See Also -------- str.expandtabs Examples -------- >>> a = np.array([' Hello world']) >>> np.strings.expandtabs(a, tabsize=4) # doctest: +SKIP array([' Hello world'], dtype='>> c = np.array(['a1b2','1b2a','b2a1','2a1b']); c array(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='>> np.strings.center(c, width=9) array([' a1b2 ', ' 1b2a ', ' b2a1 ', ' 2a1b '], dtype='>> np.strings.center(c, width=9, fillchar='*') array(['***a1b2**', '***1b2a**', '***b2a1**', '***2a1b**'], dtype='>> np.strings.center(c, width=1) array(['a', '1', 'b', '2'], dtype='>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.ljust(c, width=3) array(['aAa', ' a', 'abB'], dtype='>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.rjust(a, width=3) array(['aAa', ' a', 'abB'], dtype='>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> c array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.lstrip(c, 'a') array(['AaAaA', ' aA ', 'bBABba'], dtype='>> np.strings.lstrip(c, 'A') # leaves c unchanged array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> (np.strings.lstrip(c, ' ') == np.strings.lstrip(c, '')).all() np.False_ >>> (np.strings.lstrip(c, ' ') == np.strings.lstrip(c)).all() np.True_ )rrr@charss rAr&r&s"R }!!$$ E ""rCc4| t|St||S)a For each element in `a`, return a copy with the trailing characters removed. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype chars : scalar with the same dtype as ``a``, optional The ``chars`` argument is a string specifying the set of characters to be removed. If ``None``, the ``chars`` argument defaults to removing whitespace. The ``chars`` argument is not a prefix or suffix; rather, all combinations of its values are stripped. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.rstrip Examples -------- >>> c = np.array(['aAaAaA', 'abBABba']) >>> c array(['aAaAaA', 'abBABba'], dtype='>> np.strings.rstrip(c, 'a') array(['aAaAaA', 'abBABb'], dtype='>> np.strings.rstrip(c, 'A') array(['aAaAa', 'abBABba'], dtype='>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> c array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.strip(c) array(['aAaAaA', 'aA', 'abBABba'], dtype='>> np.strings.strip(c, 'a') array(['AaAaA', ' aA ', 'bBABb'], dtype='>> np.strings.strip(c, 'A') array(['aAaAa', ' aA ', 'abBABba'], dtype='>> np.strings.zfill('1', 3) array('001', dtype='>> c = np.array(['a1b c', '1bca', 'bca1']); c array(['a1b c', '1bca', 'bca1'], dtype='>> np.strings.upper(c) array(['A1B C', '1BCA', 'BCA1'], dtype=' JJqME uekk7 33rCcZtj|}t||jdS)a Return an array with the elements converted to lowercase. Call :meth:`str.lower` element-wise. For 8-bit strings, this method is locale-dependent. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.lower Examples -------- >>> c = np.array(['A1B C', '1BCA', 'BCA1']); c array(['A1B C', '1BCA', 'BCA1'], dtype='>> np.strings.lower(c) array(['a1b c', '1bca', 'bca1'], dtype='>> c=np.array(['a1B c','1b Ca','b Ca1','cA1b'],'S5'); c array(['a1B c', '1b Ca', 'b Ca1', 'cA1b'], dtype='|S5') >>> np.strings.swapcase(c) array(['A1b C', '1B cA', 'B cA1', 'Ca1B'], dtype='|S5') r1rrs rAr1r1s%D JJqME uekk: 66rCcZtj|}t||jdS)a Return a copy of ``a`` with only the first character of each element capitalized. Calls :meth:`str.capitalize` element-wise. For byte strings, this method is locale-dependent. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array of strings to capitalize. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.capitalize Examples -------- >>> c = np.array(['a1b2','1b2a','b2a1','2a1b'],'S4'); c array(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='|S4') >>> np.strings.capitalize(c) array(['A1b2', '1b2a', 'B2a1', '2a1b'], dtype='|S4') r2rrs rAr2r2s%D JJqME uekk< 88rCcZtj|}t||jdS)aI Return element-wise title cased version of string or unicode. Title case words start with uppercase characters, all remaining cased characters are lowercase. Calls :meth:`str.title` element-wise. For 8-bit strings, this method is locale-dependent. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.title Examples -------- >>> c=np.array(['a1b c','1b ca','b ca1','ca1b'],'S5'); c array(['a1b c', '1b ca', 'b ca1', 'ca1b'], dtype='|S5') >>> np.strings.title(c) array(['A1B C', '1B Ca', 'B Ca1', 'Ca1B'], dtype='|S5') r3rrs rAr3r3 s%H JJqME uekk7 33rCctj|}|j}tj|t|d|}tj|t|d|}tj|}|jjdk(rt ||||Stj tjj}t||d|}tj|dk|tj||}t||t|t|z zz}|jj|j} tj||j| } t ||||| S)a For each element in ``a``, return a copy of the string with occurrences of substring ``old`` replaced by ``new``. Parameters ---------- a : array_like, with ``bytes_`` or ``str_`` dtype old, new : array_like, with ``bytes_`` or ``str_`` dtype count : array_like, with ``int_`` dtype If the optional argument ``count`` is given, only the first ``count`` occurrences are replaced. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.replace Examples -------- >>> a = np.array(["That is a mango", "Monkeys eat mangos"]) >>> np.strings.replace(a, 'mango', 'banana') array(['That is a banana', 'Monkeys eat bananas'], dtype='>> a = np.array(["The dish is fresh", "This is it"]) >>> np.strings.replace(a, 'is', 'was') array(['The dwash was fresh', 'Thwas was it'], dtype=' ?C --73#> ?C MM% E yy~~S#u--"&&I #sAy 1F XXeaiFE)B CF#,73<'#,+F!GGK99>>";??#4"56I --;#4#4I FC Cc6s 33rCcPtt|tjd|f|S)a Return a string which is the concatenation of the strings in the sequence `seq`. Calls :meth:`str.join` element-wise. Parameters ---------- sep : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype seq : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.join Examples -------- >>> np.strings.join('-', 'osd') # doctest: +SKIP array('o-s-d', dtype='>> np.strings.join(['-', '.'], ['ghc', 'osd']) # doctest: +SKIP array(['g-h-c', 'o.s.d'], dtype=' "CVcV4c ;;rCc Tt|tjd|gt|zS)a For each element in `a`, return a list of the words in the string, using `sep` as the delimiter string. Calls :meth:`str.split` element-wise. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype sep : str or unicode, optional If `sep` is not specified or None, any whitespace string is a separator. maxsplit : int, optional If `maxsplit` is given, at most `maxsplit` splits are done. Returns ------- out : ndarray Array of list objects Examples -------- >>> x = np.array("Numpy is nice!") >>> np.strings.split(x, " ") # doctest: +SKIP array(list(['Numpy', 'is', 'nice!']), dtype=object) # doctest: +SKIP >>> np.strings.split(x, " ", 1) # doctest: +SKIP array(list(['Numpy', 'is nice!']), dtype=object) # doctest: +SKIP See Also -------- str.split, rsplit splitr r=rqrUr@rmaxsplits rA_splitrs+N  2::w H(= = ??rCc Tt|tjd|gt|zS)a For each element in `a`, return a list of the words in the string, using `sep` as the delimiter string. Calls :meth:`str.rsplit` element-wise. Except for splitting from the right, `rsplit` behaves like `split`. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype sep : str or unicode, optional If `sep` is not specified or None, any whitespace string is a separator. maxsplit : int, optional If `maxsplit` is given, at most `maxsplit` splits are done, the rightmost ones. Returns ------- out : ndarray Array of list objects See Also -------- str.rsplit, split Examples -------- >>> a = np.array(['aAaAaA', 'abBABba']) >>> np.strings.rsplit(a, 'A') # doctest: +SKIP array([list(['a', 'a', 'a', '']), # doctest: +SKIP list(['abB', 'Bba'])], dtype=object) # doctest: +SKIP rsplitrrs rA_rsplitrs-P  2::x#X)>!> @@rCcLt|tjdt|S)a For each element in `a`, return a list of the lines in the element, breaking at line boundaries. Calls :meth:`str.splitlines` element-wise. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype keepends : bool, optional Line breaks are not included in the resulting list unless keepends is given and true. Returns ------- out : ndarray Array of list objects See Also -------- str.splitlines splitlinesr)r@keependss rA _splitlinesrs#2  2::|[%: <>> x = np.array(["Numpy is nice!"]) >>> np.strings.partition(x, " ") # doctest: +SKIP array([['Numpy', ' ', 'is nice!']], dtype='>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.rpartition(a, 'A') # doctest: +SKIP array([['aAaAa', 'A', ''], # doctest: +SKIP [' a', 'A', ' '], # doctest: +SKIP ['abB', 'A', 'Bba']], dtype='>> a = np.array(['a1b c', '1bca', 'bca1']) >>> table = a[0].maketrans('abc', '123') >>> deletechars = ' ' >>> np.char.translate(a, table, deletechars) array(['112 3', '1231', '2311'], dtype='r rU)r@table deletecharsrs rAr7r7UsqF JJqME%++""BGG, 5;; eX7 7  KK  Gk+. .   rC)rN)NN)) )N))Q__doc__rdnumpyr=rrrrrrr r rinumpy._core.multiarrayr numpy._core.umathr r rrrrrrrrrrurr{rr}rrrrrrrrrrrr r!r"r#r$r%__all__rrrgrtrBrOrUr4r5r6r*r+r,r-r&r'r(r.r/r0r1r2r3r)rrrrrrr7rCrArs9  /< (bhhrxxJ"";*|=0!+H,<,@-B(,V4:$2N+\(V0,f0If*:Z+:\+#\&#R*"Z!?H 4F 4F#7L#9L%4P44n ;F(?V)@X<:&