o 2h3 @sdZddlZddlmZmZmZmZmZmZddl m Z m Z gdZ dZ dedefd d Zd edefd d ZdedefddZdededeefddZd edefddZdedefddZdedefddZdeedee dede fd d!ZeeeeeefZdede fd"d#Zdedefd$d%Zd&eed'eeefdefd(d)Zd*eedeeeed+fffd,d-Z d1d*ededeeeee ffd/d0Z!dS)2zBA functionally equivalent parser of the numpy.einsum input parser.N)AnyDictIteratorListSequenceTuple) ArrayTypeTensorShapeType) is_valid_einsum_charhas_valid_einsum_chars_only get_symbol get_shapegen_unused_symbolsconvert_to_valid_einsum_charsalpha_canonicalizefind_output_strfind_output_shapepossibly_convert_to_numpyparse_einsum_input4abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZxreturncCs|tvp|dvS)uCheck if the character ``x`` is valid for numpy einsum. **Examples:** ```python is_valid_einsum_char("a") #> True is_valid_einsum_char("Ǵ") #> False ``` z,->.)_einsum_symbols_base)rrL/var/www/html/chatgem/venv/lib/python3.10/site-packages/opt_einsum/parser.pyr s r einsum_strcCsttt|S)uCheck if ``einsum_str`` contains only valid characters for numpy einsum. **Examples:** ```python has_valid_einsum_chars_only("abAZ") #> True has_valid_einsum_chars_only("Över") #> False ``` )allmapr )rrrrr )s r icCs0|dkrt|S|dkrt|dSt|dS)u<Get the symbol corresponding to int ``i`` - runs through the usual 52 letters before resorting to unicode characters, starting at ``chr(192)`` and skipping surrogates. **Examples:** ```python get_symbol(2) #> 'c' get_symbol(200) #> 'Ŕ' get_symbol(20000) #> '京' ``` 4ii)rchr)rrrrr 9s   r usednccsJd}}||kr#t|}|d7}||vrq|V|d7}||ks dSdS)zGenerate ``n`` symbols that are not already in ``used``. **Examples:** ```python list(oe.parser.gen_unused_symbols("abd", 2)) #> ['c', 'e'] ``` rNr )r"r#rcntsrrrrSs rcs>tt|td}ddt|Ddfdd|DS)uConvert the str ``einsum_str`` to contain only the alphabetic characters valid for numpy einsum. If there are too many symbols, let the backend throw an error. Examples: -------- >>> oe.parser.convert_to_valid_einsum_chars("Ĥěļļö") 'cbdda' z,->cSi|] \}}|t|qSrr%).0rrrrr qz1convert_to_valid_einsum_chars..c3|] }||VqdSNgetr)rreplacerrr rz0convert_to_valid_einsum_chars..)sortedset enumeratejoin)rsymbolsrr2rrfs requationcsHi|D]}|dvr q|vrtt|<qdfdd|DS)uAlpha convert an equation in an order-independent canonical way. Examples: -------- >>> oe.parser.alpha_canonicalize("dcba") 'abcd' >>> oe.parser.alpha_canonicalize("Ĥěļļö") 'abccd' z.,->r,c3r-r.r/r1renamerrr4r5z%alpha_canonicalize..)r lenr9)r;namerr<rrus r subscriptscs,|dddfddttDS)aUFind the output string for the inputs ``subscripts`` under canonical einstein summation rules. That is, repeated indices are summed over by default. Examples: -------- >>> oe.parser.find_output_str("ab,bc") 'ac' >>> oe.parser.find_output_str("a,b") 'ab' >>> oe.parser.find_output_str("a,a,b,b") '' ,r,c3s"|] }|dkr|VqdS)r$N)count)r)r'tmp_subscriptsrrr4s z"find_output_str..)replacer9r6r7)r@rrCrrs  rinputsshapesoutputcstfdd|DS)aPFind the output shape for given inputs, shapes and output string, taking into account broadcasting. Examples: -------- >>> oe.parser.find_output_shape(["ab", "bc"], [(2, 3), (3, 4)], "ac") (2, 4) # Broadcasting is accounted for >>> oe.parser.find_output_shape(["a", "a"], [(4, ), (1, )], "a") (4,) c3s6|]tddtfddDDVqdS)css$|] \}}|dkr||VqdS)rNr)r)shapelocrrrr4s"z.find_output_shape...csg|]}|qSr)findr1crr sz/find_output_shape...N)maxzip)r)rFrGrLrr4s4z$find_output_shape..)tuple)rFrGrHrrQrrs rcCst|dr|jSt|trdSt|tr9g}t|tr5t|ts5|t||d}t|tr5t|tr t|Std|d)aGet the shape of the array-like object `x`. If `x` is not array-like, raise an error. Array-like objects are those that have a `shape` attribute, are sequences of BaseTypes, or are BaseTypes. BaseTypes are defined as `bool`, `int`, `float`, `complex`, `str`, and `bytes`. rIrrzCannot determine the shape of z5, can only determine the shape of array-like objects.) hasattrrI isinstance _BaseTypesrappendr>rR ValueError)rrIrrrr s   r cCs<t|dszddl}Wn tytdw||S|S)aUConvert things without a 'shape' to ndarrays, but leave everything else. Examples: -------- >>> oe.parser.possibly_convert_to_numpy(5) array(5) >>> oe.parser.possibly_convert_to_numpy([5, 3]) array([5, 3]) >>> oe.parser.possibly_convert_to_numpy(np.array([5, 3])) array([5, 3]) # Any class with a shape is passed through >>> class Shape: ... def __init__(self, shape): ... self.shape = shape ... >>> myshape = Shape((5, 5)) >>> oe.parser.possibly_convert_to_numpy(myshape) <__main__.Shape object at 0x10f850710> rIrNzinumpy is required to convert non-array objects to arrays. This function will be deprecated in the future.)rSnumpyModuleNotFoundError asanyarray)rnprrrrs    rold_sub symbol_mapcCs0d}|D]}|tur|d7}q|||7}q|S)aConvert user custom subscripts list to subscript string according to `symbol_map`. Examples: -------- >>> oe.parser.convert_subscripts(['abc', 'def'], {'abc':'a', 'def':'b'}) 'ab' >>> oe.parser.convert_subscripts([Ellipsis, object], {object:'a'}) '...a' r,...)Ellipsis)r\r]new_subr'rrrconvert_subscriptss   raoperands.cst|}g}g}tt|dD]}||d||dqt|r+|dnd}zttj|}| t ddt t |DWn t yRt dwdfd d |D}|durn|d 7}|t|7}|t|fS) z5Convert 'interleaved' input to standard einsum input.rNcSr(rr%)r)idxsymbolrrrr*r+z-convert_interleaved_input..ziFor this input type lists must contain either Ellipsis or hashable and comparable object (e.g. int, str).rAc3s|]}t|VqdSr.)ra)r)subr]rrr4z,convert_interleaved_input..->)listranger>rVpopr7 itertoolschain from_iterablediscardr_r8r6 TypeErrorr9rarR)rb tmp_operands operand_listsubscript_list_ output_list symbol_setr@rrhrconvert_interleaved_inputs*   ryFcCs6t|dkr tdt|dtr3|ddd}|r,tdd|ddDr,td |dd}nt|\}}|r>|}nd d |D}d |vsMd |vrh|d dkpZ|d dk}|sd|ddkrhtdd|vrA|dddddd}dt |t dd|D}d}d|vr| d\}} | d} d} n| d} d} t | D][\} } d| vr| ddks| ddkrtd|| dkrd}nt t|| dt| d}||kr|}|dkrtd|dkr| dd| | <q| d|| d| | <qd| }|dkrd}n|| d}| r(|d| d|7}nt |}dtt|t|}|d||7}d|vrN| d\}}n|t |}}|D] }||dkritd|d||vrvtd|dqWt| dt|krtdt| ddt|d|||fS)ayA reproduction of einsum c side einsum parsing in python. Parameters: operands: Intakes the same inputs as `contract_path`, but NOT the keyword args. The only supported keyword argument is: shapes: Whether ``parse_einsum_input`` should assume arrays (the default) or array shapes have been supplied. Returns: input_strings: Parsed input strings output_string: Parsed output string operands: The operands to use in the numpy contraction Examples: The operand list is simplified to reduce printing: ```python >>> a = np.random.rand(4, 4) >>> b = np.random.rand(4, 4, 4) >>> parse_einsum_input(('...a,...a->...', a, b)) ('za,xza', 'xz', [a, b]) >>> parse_einsum_input((a, [Ellipsis, 0], b, [Ellipsis, 0])) ('za,xza', 'xz', [a, b]) ``` rzNo input operands r,css|]}t|dVqdS)rIN)rSr)orrrr4Briz%parse_einsum_input..r$Nzwshapes is set to True but given at least one operand looks like an array (at least one operand has a shape attribute). cSsg|]}t|qSr)r r{rrrrNNsz&parse_einsum_input..->rjz%Subscripts can only contain one '->'..rAcss|]}t|VqdSr.)r>r1rrrr4YsTFr^zInvalid Ellipses.rzEllipses lengths do not match.zOutput character 'z(' appeared more than once in the output.z' did not appear in the inputzNumber of einsum subscripts, z+, must be equal to the number of operands, )r>rWrTstrrEanyryrBr9rrOsplitr8rr6r7)rbrGr@operand_shapesinvalidr" ellipse_indslongest input_tmp output_subsplit_subscriptsout_subnumrg ellipse_count out_ellipseoutput_subscript normal_indsinput_subscriptscharrrrr!s            r)F)"__doc__rntypingrrrrrropt_einsum.typingrr __all__rrboolr r intr rrrrrfloatcomplexbytesrUr rraryrrrrrs( ""%&*%