
    f jt:                       U d Z ddlmZ ddlZddlmZ ddlmZ ddlm	Z	 i d e
dd	h          d
 e
ddh          d e
dh          d e
dh          d e
dh          d e
ddh          d e
ddh          d e
dh          d e
dh          d e
dh          d e
dh          d e
dh          d e
h d           d! e
d"d#h          d$ e
d%h          d& e
d	h          d' e
d(h           e
d)h           e
d*h           e
d+h           e
d,h           e
d-h           e
d.h           e
d/d0h           e
d1h           e
d1h           e
d2d3h           e
d4h           e
d4h          d5Zd6ed7<   d	dd	d(d)d*d+d,d-dd.dd8Zd9ed:<   dd?Zdd@ZeZi dddAdBdCdDddEdddFdddGdHdId"ddJdKdLd&dMdNdOdPdQdRdSdTdUdVdWdXi dYdZd[d\dd]d^d
d1d_d4d`dadbd)dcd	ddd+ded-dfd,dgdhdidjdkdldmdndodpdqZd9edr<   ddsZdtZduedv<   dwZduedx<   dy fdd}Z ee          Zd6ed~<   ddZi Zd6ed<   e                                D ]K\  ZZ e	e          peZ e
d eD                       Ze                    e e
                      ez  ee<   L eed           Zd6ed<   ddZ ddZ! e
ddh          Z"ded<   ddZ#ddZ$dS )a$  Encoding equivalences and name remapping.

This module defines:

1. **Directional supersets** for accuracy evaluation: detecting a superset
   encoding when the expected encoding is a subset is correct (e.g., detecting
   UTF-8 when expected is ASCII), but not the reverse.

2. **Bidirectional equivalents**: groups of encodings where detecting any
   member when another member was expected is considered correct.  This
   includes UTF-16/UTF-32 endian variants (which encode the same text with
   different byte order) and ISO-2022-JP branch variants (which are
   compatible extensions of the same base encoding).

3. **Preferred superset mapping** for the ``prefer_superset`` API option:
   replaces detected ISO/subset encoding names with their Windows/CP superset
   equivalents that modern software actually uses.

4. **Compatibility names** for the default ``compat_names=True`` mode: maps
   internal Python codec names to the names chardet 5.x/6.x returned,
   preserving backward compatibility for callers that compare encoding
   strings directly.
    )annotationsN)Callable)DetectionDictlookup_encodingASCIIzutf-8cp1252zTIS-620
iso8859-11cp874zISO-8859-11GB2312gb18030GBKBig5	big5hkscscp950	Shift_JIScp932shift_jis_2004zShift-JISX0213zEUC-JPeuc_jis_2004zEUC-JISX0213zEUC-KRcp949CP037cp1140zISO-2022-JP>   iso2022_jp_2iso2022_jp_extiso2022_jp_2004zISO2022-JP-1r   r   zISO2022-JP-3r   z
ISO-8859-1z
ISO-8859-2cp1250cp1251cp1256cp1253cp1255cp1254cp1257z	utf-16-lez	utf-16-bezutf-16z	utf-32-lez	utf-32-bezutf-32)
ISO-8859-5z
ISO-8859-6
ISO-8859-7
ISO-8859-8
ISO-8859-9zISO-8859-13UTF-16z	UTF-16-LEz	UTF-16-BEUTF-32z	UTF-32-LEz	UTF-32-BEdict[str, frozenset[str]]	SUPERSETS)asciieuc_kr	iso8859-1z	iso8859-2	iso8859-5z	iso8859-6	iso8859-7	iso8859-8	iso8859-9r
   z
iso8859-13tis-620dict[str, str]PREFERRED_SUPERSETresultr   mappingreturnc                    |                      d          }t          |t                    r|                     ||          | d<   | S )zGReplace the encoding name using *mapping*, modifying *result* in-place.encoding)get
isinstancestr)r5   r6   encs      hC:\Users\Terasoftware\OneDrive\Desktop\faahhh\fyndo\fyndo\venv\Lib\site-packages\chardet/equivalences.py_remap_encodingr?   l   sB    
**Z
 
 C#s 3$[[c22zM    c                ,    t          | t                    S )a7  Replace the encoding name with its preferred Windows/CP superset.

    Modifies the ``"encoding"`` value in *result* in-place and returns *result*
    for fluent chaining.

    :param result: A detection result dict containing an ``"encoding"`` key.
    :returns: The same *result* dict, modified in-place.
    )r?   r4   r5   s    r>   apply_preferred_supersetrC   t   s     6#5666r@   cp855IBM855cp866IBM866CP949r,   GB18030hzz
HZ-GB-2312
iso2022_krzISO-2022-KRr-   r.   r#   r/   r$   r0   r%   r1   r&   johabJohabzkoi8-rzKOI8-Rzmac-cyrillicMacCyrillicz	mac-romanMacRoman	SHIFT_JISr2   r'   r(   z	utf-8-sigz	UTF-8-SIGzWindows-1251zWindows-1252zWindows-1253zWindows-1254zWindows-1255kz1048KZ1048z	mac-greekMacGreekzmac-iceland
MacIcelandz
mac-latin2	MacLatin2zmac-turkish
MacTurkish_COMPAT_NAMESc                ,    t          | t                    S )a7  Convert internal codec names to chardet 5.x/6.x compatible names.

    Modifies the ``"encoding"`` value in *result* in-place and returns *result*
    for fluent chaining.

    :param result: A detection result dict containing an ``"encoding"`` key.
    :returns: The same *result* dict, modified in-place.
    )r?   rW   rB   s    r>   apply_compat_namesrY      s     6=111r@   ))r   r   r   tuple[tuple[str, ...], ...]BIDIRECTIONAL_GROUPS))skcs)ukrubgbe)msid)nodasvLANGUAGE_EQUIVALENCESc                    | S N )xs    r>   <lambda>rl      s     r@   groups	normalizeCallable[[str], str]c                r    i }| D ]0}t          fd|D                       }|D ]}|| |          <   1|S )zJBuild a lookup: key -> frozenset of all equivalent keys in the same group.c              3  .   K   | ]} |          V  d S ri   rj   ).0nrn   s     r>   	<genexpr>z%_build_group_index.<locals>.<genexpr>   s+      77A99Q<<777777r@   )	frozenset)rm   rn   r5   groupnormednames    `    r>   _build_group_indexry      si    
 )+F - -777777777 	- 	-D&,F99T??##	-Mr@   _LANGUAGE_EQUIVexpectedr<   detectedboolc                V    | |k    rdS t                               |           }|duo||v S )a  Check whether *detected* is an acceptable language for *expected*.

    Returns ``True`` when *expected* and *detected* are the same ISO 639-1
    code, or belong to the same equivalence group in
    :data:`LANGUAGE_EQUIVALENCES`.

    :param expected: Expected ISO 639-1 language code.
    :param detected: Detected ISO 639-1 language code.
    :returns: ``True`` if the languages are equivalent.
    TN)rz   r:   )r{   r|   rv   s      r>   is_language_equivalentr      s>     8 t))E2U!22r@   _NORMALIZED_SUPERSETSc              #  8   K   | ]}t          |          p|V  d S ri   r   )rr   ss     r>   rt   rt   	  s/      DDA**/aDDDDDDr@   c                $    t          |           p| S ri   r   )rs   s    r>   rl   rl     s    oa.@.@.EA r@   )rn   _NORMALIZED_BIDIR
str | Nonec                   | |du S |dS t          |           p|                                 }t          |          p|                                }||k    rdS |t          v r|t          |         v rdS |t          v o|t          |         v S )a  Check whether *detected* is an acceptable answer for *expected*.

    Acceptable means:

    1. Exact match (after normalization), OR
    2. Both belong to the same bidirectional byte-order group, OR
    3. *detected* is a known superset of *expected*.

    :param expected: The expected encoding name, or ``None`` for binary files.
    :param detected: The detected encoding name, or ``None``.
    :returns: ``True`` if the detection is acceptable.
    NFT)r   lowerr   r   )r{   r|   norm_expnorm_dets       r>   
is_correctr     s       4 ux((<HNN,<,<Hx((<HNN,<,<H 8 t $$ 5Fx5P)P t 	)) 	8-h77r@   textc                j    t          j        d|           }d                    d |D                       S )z4NFKD-normalize *text* and strip all combining marks.NFKD c              3  B   K   | ]}t          j        |          |V  d S ri   )unicodedata	combining)rr   cs     r>   rt   z#_strip_combining.<locals>.<genexpr>8  s2      CC+*?*B*BC1CCCCCCr@   )r   rn   join)r   nfkds     r>   _strip_combiningr   5  s5     ..D77CCdCCCCCCr@   )   ¤   €)r   r   zfrozenset[tuple[str, str]]_EQUIVALENT_SYMBOL_PAIRSabc                l    | |k    rdS | |ft           v rdS t          |           t          |          k    S )u   Return True if characters *a* and *b* are functionally equivalent.

    Equivalent means:
    - Same character, OR
    - Same base letter after stripping combining marks, OR
    - An explicitly listed symbol equivalence (e.g. ¤ ↔ €)
    T)r   r   )r   r   s     r>   _chars_equivalentr   E  sH     	Av t	1v)) tA"21"5"555r@   databytesc                   ||du S |dS t          |          p|                                }t          |          p|                                }||k    rdS 	 |                     |          }|                     |          }n# t          t          f$ r Y dS w xY w||k    rdS t          |          t          |          k    rdS t          d t          ||d          D                       S )u  Check whether *detected* produces functionally identical text to *expected*.

    Returns ``True`` when:

    1. *detected* is not ``None`` and both encoding names normalize to the same
       codec, OR
    2. Decoding *data* with both encodings yields identical strings, OR
    3. Every differing character pair is functionally equivalent: same base
       letter after stripping combining marks, or an explicitly listed symbol
       equivalence (e.g. ¤ ↔ €).

    Returns ``False`` if *detected* is ``None``, either encoding is unknown,
    or either encoding cannot decode *data*.

    :param data: The raw byte data that was detected.
    :param expected: The expected encoding name, or ``None`` for binary files.
    :param detected: The detected encoding name, or ``None``.
    :returns: ``True`` if decoding with *detected* yields functionally identical
        text to decoding with *expected*.
    NFTc              3  <   K   | ]\  }}t          ||          V  d S ri   )r   )rr   r   r   s      r>   rt   z*is_equivalent_detection.<locals>.<genexpr>  s1      XX41a A&&XXXXXXr@   )strict)r   r   decodeUnicodeDecodeErrorLookupErrorlenallzip)r   r{   r|   r   r   text_exptext_dets          r>   is_equivalent_detectionr   U  s   .   4 ux((<HNN,<,<Hx((<HNN,<,<H8 t;;x((;;x((,   uu 8 t
8}}H% uXX3xRV3W3W3WXXXXXXs   *B BB)r5   r   r6   r3   r7   r   )r5   r   r7   r   )rm   rZ   rn   ro   r7   r)   )r{   r<   r|   r<   r7   r}   )r{   r   r|   r   r7   r}   )r   r<   r7   r<   )r   r<   r   r<   r7   r}   )r   r   r{   r   r|   r   r7   r}   )%__doc__
__future__r   r   collections.abcr   chardet.pipeliner   chardet.registryr   ru   r*   __annotations__r4   r?   rC   apply_legacy_renamerW   rY   r[   rg   ry   rz   r   r   items_subset
_supersets_key_normedr:   r   r   r   r   r   r   rj   r@   r>   <module>r      sB    0 # " " " " "     $ $ $ $ $ $ * * * * * * , , , , , ,+(YY*+++(yy,011+( 99gY''+( ii$$	+(
 
99i[!!+( II{G,--+( G%5677+( ii!1 233+( ii())+( II~.//+( ii	""+( YYz""+(. 99RRRSS/+(0 II~/?@AA1+(2 II01223+(6 ))XJ''7+(8 ))XJ''9+(: )XJ'')XJ'')XJ'')XJ'')XJ''9hZ(( ik233H:&&H:&&ik233H:&&H:&&U+( +( +(	 + + + +f & &         7 7 7 7 / %!%! X%! X	%!
 W%! H%! h%! y%! 	,%! M%! -%! %! %! %! %!  !%!" W#%!$ h%%! %!& M'%!( )%!* k+%!, y-%!. h/%!0 h1%!2 3%!4 n5%!6 n7%!8 n9%!: n;%!< n=%!@ hA%!B C%!D <E%!F +G%!H <I%! %! % % % %P2 2 2 2,5     6     & '2k
 
 
 
 
 .@-?@U-V-V V V V V3 3 3 3* 46  5 5 5 5$??,, Y YGZ?7##.wDiDDDDDDDG"7";";D))++"N"NQX"X$ 0B/A$E$E0 0 0     
       FD D D D 8Ay8 8     6 6 6 6 .Y .Y .Y .Y .Y .Yr@   