
    el                     :   d Z ddlZddlmZ ddlmZ ddlmZ ddlZ	ddl
ZddlmZmZ ddlmZmZmZmZmZmZmZmZmZmZmZmZmZ dd	lmZmZ dd
l m!Z!m"Z"m#Z#m$Z$ ddl%T  G d d          Z& G d de&          Z' G d de'e          Z( e(            j)        Z*d Z+dS )a  
Helper classes for comparing the equality of two HoloViews objects.

These classes are designed to integrate with unittest.TestCase (see
the tests directory) while making equality testing easily accessible
to the user.

For instance, to test if two Matrix objects are equal you can use:

Comparison.assertEqual(matrix1, matrix2)

This will raise an AssertionError if the two matrix objects are not
equal, including information regarding what exactly failed to match.

Note that this functionality could not be provided using comparison
methods on all objects as comparison operators only return Booleans and
thus would not supply any information regarding *why* two elements are
considered different.
    N)partial)TestCase)	safe_repr)assert_array_almost_equalassert_array_equal   )AdjointLayout	DimensionDimensioned
DynamicMapElementEmpty
GridMatrix	GridSpaceHoloMapLayoutNdLayout	NdOverlayOverlay)CycleOptions)cast_array_to_int64datetime_types	dt_to_intis_float   )*c                   J    e Zd ZdZi ZeZedd            Zedd            Z	dS )ComparisonInterfacea  
    This class is designed to allow equality testing to work
    seamlessly with unittest.TestCase as a mix-in by implementing a
    compatible interface (namely the assertEqual method).

    The assertEqual class method is to be overridden by an instance
    method of the same name when used as a mix-in with TestCase. The
    contents of the equality_type_funcs dictionary is suitable for use
    with TestCase.addTypeEqualityFunc.
    Nc                     ||k    }t          |t                    s$t          |d          r|                                }|s8t	          |           dt	          |           }|                     |p|          dS )z[
        Classmethod equivalent to unittest.TestCase method (longMessage = False.)
        all != N)
isinstanceboolhasattrr!   r   failureException)clsfirstsecondmsgcheckstandardMsgs         <lib/python3.11/site-packages/holoviews/element/comparison.pysimple_equalityz#ComparisonInterface.simple_equality@   s    
 v%&& 	 75%+@+@ 	 IIKKE 	;&u--FF9V3D3DFFK&&s'9k:::	; 	;    c                 l   d}t          |          t          |          u st          |          r]t          |          rN| j                            t          |                    }|%t	          |t
                    rt          | |          }|| j        }| |||           dS  ||||           dS )zD
        Classmethod equivalent to unittest.TestCase method
        Nr*   )typer   equality_type_funcsgetr#   strgetattrr.   )r'   r(   r)   r*   asserters        r-   assertEqualzComparisonInterface.assertEqualM   s    
 ;;$v,,&&8E??&x?O?O&.224;;??H#h,, 6&sH55H*H;HUF#####HUF,,,,,,r/   N)
__name__
__module____qualname____doc__r3   AssertionErrorr&   classmethodr.   r8    r/   r-   r   r   1   sj        	 	 %	; 	; 	; [	; - - - [- - -r/   r   c                      e Zd ZdZ eed          Zed             Zedd            Z	edd            Z
edd	            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd            Zedd             Zedd!            Zedd"            Zedd$            Zedd&            Zedd(            Z edd*            Z!edd,            Z"edd.            Z#edd0            Z$edd2            Z%edd4            Z&edd6            Z'edd8            Z(edd:            Z)edd<            Z*edd>            Z+edd@            Z,eddB            Z-eddD            Z.eddF            Z/eddH            Z0eddJ            Z1eddL            Z2eddN            Z3eddP            Z4eddR            Z5eddT            Z6eddV            Z7eddX            Z8eddZ            Z9edd\            Z:edd^            Z;edd`            Z<eddb            Z=eddd            Z>eddf            Z?eddg            Z@eddi            ZAeddk            ZBeddm            ZCeddo            ZDeddq            ZEedds            ZFeddu            ZGeddv            ZHeddx            ZIeddz            ZJedd|            ZKedd~            ZLedd            ZMed             ZNedd            ZOedd            ZPedd            ZQdS )
Comparisonaa  
    Class used for comparing two HoloViews objects, including complex
    composite objects. Comparisons are available as classmethods, the
    most general being the assertEqual method that is intended to work
    with any input.

    For instance, to test if two Image objects are equal you can use:

    Comparison.assertEqual(matrix1, matrix2)
       )decimalc                 H   | j         | j        t          <   | j         | j        t          j        <   | j         | j        t          j        <   | j        | j        t          <   | j        | j        t          <   | j
        | j        t          <   | j        | j        t          j        <   | j        | j        t          j        j        <   | j        | j        t"          j        <   | j        | j        t(          <   | j        | j        t,          <   | j        | j        t0          <   | j        | j        t4          <   | j        | j        t8          <   | j        | j        t<          <   | j        | j        t@          <   | j!        | j        tD          <   | j#        | j        tH          <   | j%        | j        tL          <   | j'        | j        tP          <   | j)        | j        tT          <   | j+        | j        tX          <   | j-        | j        t\          <   | j/        | j        t`          <   | j1        | j        td          <   | j3        | j        th          <   | j5        | j        tl          <   | j7        | j        tp          <   | j9        | j        tt          <   | j;        | j        tx          <   | j=        | j        t|          <   | j?        | j        t          <   | jA        | j        t          <   | jC        | j        t          <   | jE        | j        t          <   | jG        | j        t          <   | jI        | j        t          <   | jK        | j        t          <   | jG        | j        t          <   | jN        | j        t          <   | jP        | j        t          <   | jR        | j        t          <   | jT        | j        t          <   | jV        | j        t          <   | jX        | j        t          <   | jZ        | j        t          <   | j\        | j        t          <   | j^        | j        t          <   | j`        | j        t          <   | jb        | j        t          <   | jd        | j        t          <   | jf        | j        t          <   | jh        | j        t          <   | jj        | j        t          <   | jl        | j        t          <   | jn        | j        t          <   | jp        | j        t          <   | jr        | j        t          <   | jt        | j        t          <   | jv        | j        t          <   | jx        | j        t          <   | jz        | j        t          <   | j|        | j        t          <   | j~        | j        t          <   | j        | j        t          <   | j        | j        t          <   | j        | j        t          <   | j        | j        t          <   | j        | j        t          <   | j        | j        t          <   | j        S r9   )compare_floatsr3   floatnpfloat32float64compare_listslistcompare_tuplestuplecompare_dictionariesdictcompare_arraysndarraymamasked_arraycompare_dataframepd	DataFramecompare_dimensionsr
   compare_dimensionedr   compare_elementsr   compare_overlaysr   compare_layouttreesr   compare_emptiesr   compare_vlineVLinecompare_hlineHLinecompare_vspanVSpancompare_hspanHSpancompare_splineSplinecompare_arrowArrowcompare_textTextcompare_divDivcompare_pathsPathcompare_contoursContourscompare_polygonsPolygonscompare_boxBoxcompare_ellipseEllipsecompare_boundsBoundscompare_imageImagecompare_rgbRGBcompare_hsvHSVcompare_rasterRastercompare_quadmeshQuadMeshcompare_surfaceSurfacecompare_datasetHeatMapcompare_segmentsSegmentscompare_boxes
RectanglesDatasetcompare_curveCurvecompare_errorbars	ErrorBarscompare_spreadSpreadcompare_areaAreacompare_scatterScattercompare_scatter3d	Scatter3Dcompare_trisurface
TriSurfacecompare_histogram	Histogramcompare_barsBarscompare_spikesSpikescompare_boxwhisker
BoxWhiskercompare_vectorfieldVectorFieldcompare_graphGraphcompare_nodesNodescompare_edgepaths	EdgePathscompare_trimeshTriMeshcompare_itemtables	ItemTablecompare_tablesTablecompare_pointsPointscompare_bivariate	Bivariatecompare_distributionDistributioncompare_hextilesHexTilescompare_gridlayoutr   compare_adjointlayoutsr	   compare_ndoverlaysr   compare_gridsr   r   compare_holomapr   compare_dynamicmapr   compare_optionsr   compare_cyclesr   )r'   s    r-   registerzComparison.registerr   s    140B&030B
+030B
+ 140A%030B& 140H% 8;7I
+7:7I 23 140E- 140F	*030G,030D( 03/C(/2/F'/2/B& 03/@&/2/@&/2/@&/2/@&/2/A'/2/@&/2/?%/2$ 03/@%/2/C)/2/C)/2$/2/B(/2/A' 03/@&/2$/2$/2/A'/2/C)/2/B(/2/B( 03/C)474E
+ 140C(030A&030E	*030B'030@%030C(030E	*030F
+030E	*030@%030B'030F
+030G, 140A&030A&030E	*030C( 140F	*030B&030B' 140E	*030H-030D) 251G)141K.141G	*141B	*252C
+141D(141G
+ 03/B(/2/A&&&r/   Dictionariesc                 >   t          |                                          }t          |                                          }||z  }|r,d|d}|d| dz  }|d| z  }|                     |          |D ]$}|                     ||         ||                    %d S )Nz*Dictionaries have different sets of keys: z

zDictionary 1: 
zDictionary 2: )setkeysr&   r8   )r'   d1d2r*   r   keys2symmetric_diffks           r-   rO   zComparison.compare_dictionaries   s    "''))nnBGGII 	,U~UUUC*B****C(B(((C&&s+++ 	* 	*AOOBqE2a5))))	* 	*r/   Nc                    	 |                      t          |          t          |                     t          ||          D ]\  }}|                      ||           d S # t          $ r}t          |p|d|          |d }~ww xY wNr"   r8   lenzipr>   )r'   l1l2r*   v1v2es          r-   rK   zComparison.compare_lists       	DOOCGGSWW---b"++ ( (BB''''( ( 	D 	D 	D !;2(;(;R(;(;<<!C	D   AA   
B*BBc                    	 |                      t          |          t          |                     t          ||          D ]\  }}|                      ||           d S # t          $ r}t          |p|d|          |d }~ww xY wr   r   )r'   t1t2r*   i1i2r   s          r-   rM   zComparison.compare_tuples   r   r   Floatsc                 4    |                      |||           d S r9   )rQ   )r'   arr1arr2r*   s       r-   rF   zComparison.compare_floats  s     4s+++++r/   Arraysc                    	 |j         j        dk    r"t          |                    d                    }|j         j        dk    r"t          |                    d                    }t	          ||           d S # t
          $ r[ 	 |                     ||           Y d S # t          $ r3}|                     |t          |          dd          z             |d }~ww xY ww xY w)NMzdatetime64[ns]   )
dtypekindr   astyper   	Exceptionassert_array_almost_equal_fnr>   r&   r5   )r'   r   r   r*   r   s        r-   rQ   zComparison.compare_arrays
  s    
	Ez#%%*4;;7G+H+HIIz#%%*4;;7G+H+HIItT***** 	E 	E 	EE00t<<<<<<! E E E**3Q+<==1DE	Es*   A4A8 8
CB
C&.CCCc                    |j                                         }|j                                         }	 t          ||          D ]c\  }}t          |t                    rt          |          }t          |t                    rt          |          }|                     ||           dd S # t          $ rP}|                     d|j                                          d|j                                          d          |d }~ww xY w)NzBoundingBoxes are mismatched: r"   .)	boundslbrtr   r#   r   r   r   r>   r&   )	r'   el1el2r*   lbrt1lbrt2r   r   r   s	            r-   bounds_checkzComparison.bounds_check  s   
!!
!!	|eU++ 9 9Bb.11 '"2Bb.11 '"2B00R88889 9  	| 	| 	|&&'s
HYHY's's_b_i_n_n_p_p's's'sttz{{	|s   A4B* *
D4AC??Dc           	         |j         |j         k    r%|                     d|j          d|j                    |j        |j        k    r%|                     d|j         d|j                   |j                                        }|j                                        }t          |                                          t          |                                          k    rY|                     dt          |                                           dt          |                                                     |                                D ]}|j                            d          |         j        j	        dk    r/|j                            d          |         j        j	        dk    r_	 | 
                    ||         ||         d            # t          $ r%}d|d	}|                     | |          |d }~ww xY wd S )
NzDimension names mismatched: r"   zDimension labels mismatched: z%Dimension parameter sets mismatched: existingCallabler1   zDimension parameter z mismatched: )namer&   labelparamvaluesr   r   objects	__class__r:   r8   r>   )r'   dim1dim2r*   dim1_paramsdim2_paramsr   r   s           r-   rX   zComparison.compare_dimensions,  sE    9	!!&&'`di'`'`UYU^'`'`aaa:##&&'ctz'c'cW[Wa'c'cddd j''))j'')){!!""c+*:*:*<*<&=&===&&  (FsS^ScScSeSeOfOf  (F  (Flop{  qA  qA  qC  qC  mD  mD  (F  (F  G  G  G!!## 	A 	AA
"":..q1;D
RRJ&&z2215?HJVVAAADIIII! A A A?Q???**c=1==99q@A	A 	As   .$G
H G==Hc                     |                      |j        |j        d           |                      |j        |j        d           d S )NzGroup labels mismatched.zLabels mismatched.)r8   groupr   r'   obj1obj2r*   s       r-   compare_labelled_dataz Comparison.compare_labelled_dataF  s>    
DJ0JKKK
DJ0DEEEEEr/   Dimension listsc                     t          |          t          |          k    r|                     | d          t          ||          D ]\  }}|                     ||           d S )Nz mismatched)r   r&   r   r8   )r'   dlist1dlist2r*   r   r   s         r-   compare_dimension_listsz"Comparison.compare_dimension_listsK  st    v;;#f++%%&&#':':':;;;&&)) 	$ 	$FBOOB####	$ 	$r/   c                     |                      ||           |                     |j        |j        d           |                     |j        |j        d           d S )NzValue dimension listzKey dimension list)r  r
  vdimskdimsr  s       r-   rY   zComparison.compare_dimensionedR  sh    !!$---##DJ
$:	< 	< 	<##DJ
$8	: 	: 	: 	: 	:r/   c                 r    |                      ||           |                     |j        |j                   d S r9   )r  r8   datar  s       r-   rZ   zComparison.compare_elementsZ  s6    !!$---	49-----r/   Treesc                    t          |                                          t          |                                          k    r|                     | d          |                                |                                k    r|                     | d          t          |                                |                                          D ]\  }}|                     ||           d S )Nz have mismatched path counts.z have mismatched paths.)r   r   r&   r   r   r8   r'   r   r   r*   element1element2s         r-   compare_treeszComparison.compare_treesd  s    sxxzz??c#((**oo--&&#'L'L'LMMM88::##&&#'F'F'FGGG"%cjjllSZZ\\"B"B 	0 	0HhOOHh////	0 	0r/   c                 b    |                      ||           |                     ||d           d S )NLayoutsr1   rY   r  r'   r   r   r*   s       r-   r\   zComparison.compare_layouttreesm  s9    S)))#s	22222r/   c                 f    t          d ||fD                       s|                     d          d S )Nc              3   @   K   | ]}t          |t                    V  d S r9   )r#   r   ).0els     r-   	<genexpr>z-Comparison.compare_empties.<locals>.<genexpr>t  s,      >>R:b%((>>>>>>r/   z&Compared elements are not both Empty())r!   r&   r  s       r-   r]   zComparison.compare_emptiesr  sG    >>C:>>>>> 	Q&&'OPPP	Q 	Qr/   c                 b    |                      ||           |                     ||d           d S )NOverlaysr1   r  r  s       r-   r[   zComparison.compare_overlaysw  s9    S)))#s
33333r/   
NdMappingsc                    |                                 t                                                    t                                                    k    r|                     | d          t	                                                    t	                                                    k    rffd                                D             }fd                                D             }|                     | dd| dz   d| dz             t                    D ]\  }}|                     ||           d S )	Nz  have different numbers of keys.c                 @    g | ]}|                                 v|S r@   r   )r  r  r   s     r-   
<listcomp>z1Comparison.compare_ndmappings.<locals>.<listcomp>  +    EEEB#((**0D0DR0D0D0Dr/   c                 @    g | ]}|                                 v|S r@   r$  )r  r  r   s     r-   r%  z1Comparison.compare_ndmappings.<locals>.<listcomp>  r&  r/   z have different sets of keys. zIn first, not second z. zIn second, not first: r   )rY   r   r   r&   r   r   r8   )r'   r   r   r*   diff1diff2r  r  s    ``     r-   compare_ndmappingszComparison.compare_ndmappings  sT   S)))sxxzz??c#((**oo--&&#'O'O'OPPPsxxzz??c#((**oo--EEEE#((**EEEEEEEE#((**EEEE&&#'M'M'M)J)J)J)J(K)J%)J)J)J(K L L L #&c3-- 	0 	0HhOOHh////	0 	0r/   HoloMapsc                 `    |                      ||           |                     |||           d S r9   rY   r*  r  s       r-   r   zComparison.compare_holomap  6    S)))sC-----r/   r   c                 `    |                      ||           |                     |||           d S r9   r-  r  s       r-   r   zComparison.compare_dynamicmap  r.  r/   c                    |                      ||           t          |          t          |          k    r|                     d          t          |                                          t          |                                          k    r|                     d          t          ||          D ]\  }}|                     ||           d S )NzLayouts have different sizes.zLayouts have different keys.)rY   r   r&   r   r   r   r8   r  s         r-   r   zComparison.compare_gridlayout  s    S)))s88s3xx&&'FGGGsxxzz??c#((**oo--&&'EFFF"%c3-- 	/ 	/HhOOHX....	/ 	/r/   c                     |                      ||           t          |          t          |          k    r|                     d          t          ||          D ]\  }}|                     ||           d S )Nz"NdOverlays have different lengths.)rY   r   r&   r   r8   )r'   r   r   r*   layer1layer2s         r-   r   zComparison.compare_ndoverlays  s    S)))s88s3xx&&'KLLL #C 	, 	,VVOOFF++++	, 	,r/   c                     |                      ||           t          ||          D ]\  }}|                     ||           d S r9   )rY   r   r8   r  s         r-   r   z!Comparison.compare_adjointlayouts  sU    S)))"%c3-- 	0 	0HhOOHh////	0 	0r/   
Annotationc                 r    |                      ||           |                     |j        |j                   d S r9   )rY   r8   r  r  s       r-   compare_annotationzComparison.compare_annotation  s6    S)))#(+++++r/   ra   c                 6    |                      |||           d S Nr1   r7  r  s       r-   r`   zComparison.compare_hline  #    sCS11111r/   r_   c                 6    |                      |||           d S r9  r:  r  s       r-   r^   zComparison.compare_vline  r;  r/   rc   c                 6    |                      |||           d S r9  r:  r  s       r-   rb   zComparison.compare_vspan  r;  r/   re   c                 6    |                      |||           d S r9  r:  r  s       r-   rd   zComparison.compare_hspan  r;  r/   rg   c                 6    |                      |||           d S r9  r:  r  s       r-   rf   zComparison.compare_spline  r;  r/   ri   c                 6    |                      |||           d S r9  r:  r  s       r-   rh   zComparison.compare_arrow  r;  r/   rk   c                 6    |                      |||           d S r9  r:  r  s       r-   rj   zComparison.compare_text  r;  r/   rm   c                 6    |                      |||           d S r9  r:  r  s       r-   rl   zComparison.compare_div  r;  r/   ro   c                 T   |                      |||           |                                }|                                }t          |          t          |          k    r|                     | d          t	          ||          D ]\  }}|                      ||| d            d S )Nz0 objects do not have a matching number of paths.z data)r   splitr   r&   r   )r'   r   r   r*   paths1paths2p1p2s           r-   rn   zComparison.compare_paths  s    Cc***v;;#f++%%&&#'_'_'_```&&)) 	7 	7FBB36666	7 	7r/   rq   c                 6    |                      |||           d S r9  rn   r  s       r-   rp   zComparison.compare_contours  #    #s,,,,,r/   rs   c                 6    |                      |||           d S r9  rJ  r  s       r-   rr   zComparison.compare_polygons  rK  r/   ru   c                 6    |                      |||           d S r9  rJ  r  s       r-   rt   zComparison.compare_box  rK  r/   rw   c                 6    |                      |||           d S r9  rJ  r  s       r-   rv   zComparison.compare_ellipse  rK  r/   ry   c                 6    |                      |||           d S r9  rJ  r  s       r-   rx   zComparison.compare_bounds  rK  r/   r   c           	      H  	 |                                 j        j        oj        j         		fdj        D             }|	fdj        D             z  }j        d         j        d         k    r+t          d|j        d         j        d         fz            |D ]\  }}}t          j        t                    5  t          j                            ||           	 d d d            M# 1 swxY w Y   |j        |j        k    r(| d|j         d| d| d}|                     |          |j        j        d	v rCt#          |          t#          |          k    r"| d
|j         d}|                     |          |                     |||           d S )Nc                 n    g | ]1}|                     |                                |           f2S ))expandeddimension_valuesr  dr   r   tabulars     r-   r%  z.Comparison.compare_dataset.<locals>.<listcomp>  sZ     . . . c221w2GG//G/DDF . . .r/   c                 n    g | ]1}|                     |                                |           f2S ))flatrS  rU  s     r-   r%  z.Comparison.compare_dataset.<locals>.<listcomp>  sZ     0 0 0 ! s33AG3DD000AAC 0 0 0r/   r   z%%s not of matching length, %d vs. %d. z- columns have different type. First has type z, and second has type r   SUOVz along dimension z not equal.)rY   	interfacegriddedr  r  shaper>   
contextlibsuppressr   rH   testingassert_equalr   pprint_labelr&   r   rL   rQ   )
r'   r   r   r*   dimension_datadimr   r   failure_msgrW  s
    ``      @r-   r   zComparison.compare_dataset  sv   S)))},F1FG. . . . . .#&9. . . 	 0 0 0 0 0 0%(Y0 0 0 	0 9Q<39Q<'' !H$'1sy|#D"E F F F) 	0 	0KCR$Y//  
''B///               x28## F FS- F F&(F F@BF F F  **;777x}&&88tBxx''%("X"X3;K"X"X"XK..{;;; ( ""2r3////!	0 	0s   "C66C:	=C:	r   c                 4    |                      |||           d S r9   r   r  s       r-   r   zComparison.compare_curve,       Cc*****r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_errorbars0  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_spread4  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_area8  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_scatter<  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_scatter3d@  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_trisurfaceD  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_histogramH  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_pointsL  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_vectorfieldQ  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_barsU  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_spikesY  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_boxwhisker]  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_segmentsf  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_boxesj  ri  r/   r   c                     |                      |||           |                     |j        |j        |           |j        s|j        r#|                     |j        |j        |           d S d S r9   )r   r   nodes
_edgepathsr   	edgepathsr  s       r-   r   zComparison.compare_graphr  sy    Cc***#)SY444> 	ES^ 	E!!#-DDDDD	E 	Er/   r   c                 4    |                      |||           d S r9   )r   r  s       r-   r   zComparison.compare_trimeshy       #sC(((((r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_nodes}  ri  r/   c                 4    |                      |||           d S r9   rJ  r  s       r-   r   zComparison.compare_edgepaths  r}  r/   r   c                 t    |                      ||           |                     |j        |j        |           d S r9   )rY   rQ   r  r  s       r-   r   zComparison.compare_raster  s:    S)))38SXs33333r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_quadmesh  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   compare_heatmapzComparison.compare_heatmap  ri  r/   r{   c                 `    |                      ||           |                     |||           d S r9   r   r   r  s       r-   rz   zComparison.compare_image  6    S!!!Cc*****r/   r}   c                 `    |                      ||           |                     |||           d S r9   r  r  s       r-   r|   zComparison.compare_rgb  r  r/   r   c                 `    |                      ||           |                     |||           d S r9   r  r  s       r-   r~   zComparison.compare_hsv  r  r/   r   c                 `    |                      ||           |                     |||           d S r9   r  r  s       r-   r   zComparison.compare_surface  r  r/   c                 8   |                      ||           |j        |j        k    r|                     d          |j        |j        k    r|                     d          d |j        D             d |j        D             k    r|                     d          d S )Nz*ItemTables have different numbers of rows.z-ItemTables have different numbers of columns.c                     g | ]	}|j         
S r@   r   r  rV  s     r-   r%  z1Comparison.compare_itemtables.<locals>.<listcomp>  s    &&&qAF&&&r/   c                     g | ]	}|j         
S r@   r  r  s     r-   r%  z1Comparison.compare_itemtables.<locals>.<listcomp>  s    *E*E*Ea16*E*E*Er/   z%ItemTables have different Dimensions.)rY   rowsr&   colsr  r  s       r-   r   zComparison.compare_itemtables  s    S)))8sx&&'STTT8sx&&'VWWW&&CI&&&*E*E39*E*E*EEE&&'NOOO FEr/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_tables  ri  r/   DFramec                     ddl m} 	  |||           d S # t          $ r }|                     | d|           |d }~ww xY w)Nr   )assert_frame_equalz: )pandas.testingr  r>   r&   )r'   df1df2r*   r  r   s         r-   rU   zComparison.compare_dataframe  sq    555555	=sC((((( 	= 	= 	=&&#}}}}551<	=s    
A ;A r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_distribution  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_bivariate  ri  r/   r   c                 4    |                      |||           d S r9   rh  r  s       r-   r   zComparison.compare_hextiles  ri  r/   c                 >   t          |                                          t          |                                          k    r|                     | d          t          |                                          t          |                                          k    r|                     | d          t          |          t          |          k    r|                     | d          t	          ||          D ]\  }}|                     ||           d S )Nz"s have different numbers of items.zs have different keys.zs have different depths.)r   r   r&   r   r   r8   )r'   r   r   r   r  r  s         r-   _compare_gridszComparison._compare_grids  s     sxxzz??c#((**oo--&&$'R'R'RSSSsxxzz??c#((**oo--&&$'F'F'FGGGs88s3xx&&$'H'H'HIII"%c3-- 	0 	0HhOOHh////	0 	0r/   c                 `    |                      ||           |                     ||d           d S )Nr   )rY   r  r  s       r-   r   zComparison.compare_grids  s6    S)))3[11111r/   c                 F    |                      |j        |j                   d S r9   )r8   kwargs)r'   options1options2r*   s       r-   r   zComparison.compare_options  s     99999r/   c                 F    |                      |j        |j                   d S r9   )r8   r   )r'   cycle1cycle2r*   s       r-   r   zComparison.compare_cycles  s     v}55555r/   )r   r9   )r   )r   )r  )r  )r!  )r+  )r   )r5  )ra   )r_   )rc   )re   )rg   )ri   )rk   )rm   )ro   )rq   )rs   )ru   )rw   )ry   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r   )r{   )r}   )r   )r   )r   )r  )r   )r   )r   )Rr:   r;   r<   r=   r   r   r   r?   r   rO   rK   rM   rF   rQ   r   rX   r  r
  rY   rZ   r  r\   r]   r[   r*  r   r   r   r   r   r7  r`   r^   rb   rd   rf   rh   rj   rl   rn   rp   rr   rt   rv   rx   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  rz   r|   r~   r   r   r   rU   r   r   r   r  r   r   r   r@   r/   r-   rB   rB   c   s	       	 	 $+7+Da#P#P#P j' j' [j'Z 
* 
* 
* [
* D D D [D D D D [D , , , [, E E E [E | | | [|& A A A [A2 F F F [F $ $ $ [$ : : : [: . . . [. 0 0 0 [0 3 3 3 [3 Q Q Q [Q 4 4 4 [4 0 0 0 [0 . . . [.
 . . . [.
 
/ 
/ 
/ [
/ , , , [, 0 0 0 [0 , , , [, 2 2 2 [2 2 2 2 [2 2 2 2 [2 2 2 2 [2 2 2 2 [2 2 2 2 [2 2 2 2 [2 2 2 2 [2 7 7 7 [7 - - - [- - - - [- - - - [- - - - [- - - - [- 0 0 0 [0> + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ E E E [E ) ) ) [) + + + [+ ) ) ) [) 4 4 4 [4 + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ + + + [+ 	P 	P 	P [	P + + + [+ = = = [= + + + [+ + + + [+ + + + [+ 0 0 [0 2 2 2 [2 : : : [: 6 6 6 [6 6 6r/   rB   c                       e Zd ZdZd ZdS )ComparisonTestCasezI
    Class to integrate the Comparison class with unittest.TestCase.
    c                     t          j        | g|R i | t                                          }|                                D ]\  }}|                     ||           d S r9   )r   __init__rB   r   itemsaddTypeEqualityFunc)selfargsr  registryr   vs         r-   r  zComparisonTestCase.__init__  st    $0000000&&((NN$$ 	+ 	+DAq$$Q****	+ 	+r/   N)r:   r;   r<   r=   r  r@   r/   r-   r  r    s-         + + + + +r/   r  c                    t           t          f}t          | |          s%t          dt	          |           j        d          t          ||          s%t          dt	          |          j        d          t          | |           d S )Nz,First argument is not an allowed type but a r   z-Second argument is not an allowed type but a )r   r   r#   	TypeErrorr2   r:   _assert_element_equal)r  r  hv_typess      r-   assert_element_equalr    s     Hh)) ectH~~G^cccdddh)) fdXH_dddeee(H-----r/   ),r=   r_  	functoolsr   unittestr   unittest.utilr   numpyrH   pandasrV   numpy.testingr   r   corer	   r
   r   r   r   r   r   r   r   r   r   r   r   core.optionsr   r   	core.utilr   r   r   r    r   rB   r  r8   r  r  r@   r/   r-   <module>r     s   &                 # # # # # #         G G G G G G G G                              * ) ) ) ) ) ) ) P P P P P P P P P P P P /- /- /- /- /- /- /- /-d\
6 \
6 \
6 \
6 \
6$ \
6 \
6 \
6~	+ 	+ 	+ 	+ 	+X 	+ 	+ 	+ +*,,8 . . . . .r/   