
    e1                     V   d Z ddlmZ ddlZddlZddlmZmZm	Z	m
Z
 ddlmZmZmZmZ ddlmZ ddlmZmZmZ  G d	 d
          Z G d de	e          Z G d de
eee          Z G d deee          Z ed  e                                            D                       d
gz   ZdS )aA  
Supplies Layer and related classes that allow overlaying of Views,
including Overlay. A Layer is the final extension of View base class
that allows Views to be overlaid on top of each other.

Also supplies ViewMap which is the primary multi-dimensional Map type
for indexing, slicing and animating collections of Views.
    )reduceN   )	DimensionDimensionedViewableElementViewableTree)AdjointLayout
ComposableLayout
Layoutable)UniformNdMapping)dimensioned_streamssanitize_identifierunique_arrayc                       e Zd ZdZd ZdS )Overlayablezp
    Overlayable provides a mix-in class to support the
    mul operation for overlaying multiple elements.
    c                     ddl m} t          |          rGddl m}  fd} || g          }d|_                            d|t                              S t           t                    rt          t                    st          S nt          t                    rJt          t                    s5 fd	                                D             }                    |          S t          t          t          f          rt          t                    st          S 	 t           g          S # t          $ r
 t          cY S w xY w)
z!Overlay object with other object.r   )
DynamicMap)Callablec                      |          }|z  S N )argskwargselementotherselfs      6lib/python3.11/site-packages/holoviews/core/overlay.pydynamic_mulz(Overlayable.__mul__.<locals>.dynamic_mul!   s    +g~%    )inputsTF)shared_datacallbackstreamsc                 $    g | ]\  }}||z  fS r   r   ).0kvr   s      r   
<listcomp>z'Overlayable.__mul__.<locals>.<listcomp>-   s%    CCC6Aq!TAXCCCr    )spacesr   
isinstancer   _is_overlaycloner   Overlayr   NotImplementedr   CompositeOverlayitemsr	   r   NotImplementedError)r   r   r   r   r   r#   r1   s   ``     r   __mul__zOverlayable.__mul__   s    	'&&&&&eZ(( 	&((((((& & & & & &  xT5MBBBH#'H ;;58':5'A'A  C C C $(( &!%99 *))*E#344 &ZO_=`=` &CCCCU[[]]CCC{{5)))EM<#@AA &*UZ\cJdJd &%%&e}---& & & &%%%%&s   *D; ;EEN)__name__
__module____qualname____doc__r3   r   r    r   r   r      s-         & & & & &r    r   c                   4     e Zd ZdZdZ	 	 ddZd	 fd	Z xZS )
r0   zK
    CompositeOverlay provides a common baseclass for Overlay classes.
    TN   Fc                 N    t           dd          pd}t          t                    odcxk    ot                     k     nc }	d  D             v }
t	          |	|
g          st          d          |	r}|
r'                                                               }|)d                                  |         j	        D             } fd|D             } fd|
                                D             }|rR }t                                           |         j	                  D ]}|j        |v r|||j                 z  }||_        nJt          |          d	k    r/t          t          |                                                    }n|d         }|S )
a  Computes and adjoins histogram along specified dimension(s).

        Defaults to first value dimension if present otherwise falls
        back to first key dimension.

        Args:
            dimension: Dimension(s) to compute histogram on,
                Falls back the plot dimensions by default.
            num_bins (int, optional): Number of bins
            bin_range (tuple optional): Lower and upper bounds of bins
            adjoin (bool, optional): Whether to adjoin histogram
            index (int, optional): Index of layer to apply hist to
            show_legend (bool, optional): Show legend in histogram
                (don't show legend by default).

        Returns:
            AdjointLayout of element and histogram or just the
            histogram
        
main_layerNr   c                     g | ]	}|j         
S r   labelr&   els     r   r)   z)CompositeOverlay.hist.<locals>.<listcomp>Y   s    #<#<#<BH#<#<#<r    z>Please supply a suitable index or label for the histogram datac                     g | ]	}|j         
S r   )name)r&   dims     r   r)   z)CompositeOverlay.hist.<locals>.<listcomp>b   s    WWWcWWWr    c           
          i | ]At          fd t                                                    D                       BS )c                 ~    g | ]9\  }\  }}t          |dd           k    s|k    %| |j        dddf:S )Nr>   F)adjoin	dimension	bin_rangenum_binsr   )getattrhist)	r&   ielem_keyelemrH   rC   indexr   rI   s	       r   r)   z4CompositeOverlay.hist.<locals>.<dictcomp>.<listcomp>e   s     	 	 	 (A'$MwtWd'C'Cu'L'LRW[\R\R\ idi $y!) -3  S]R\R\r    )dict	enumerater1   )r&   rC   rH   rO   r   rI   r   s    @r   
<dictcomp>z)CompositeOverlay.hist.<locals>.<dictcomp>d   s     
 
 
   	 	 	 	 	 	 	 	 ,5TZZ\\+B+B	 	 	 	 	
 
 
r    c                 j    i | ]/\  }}|                     |                                         0S ))show_legend)r-   opts)r&   rC   histsr   rT   s      r   rR   z)CompositeOverlay.hist.<locals>.<dictcomp>r   sL     !
 !
 !
U E""''K'@@!
 !
 !
r    r   )rJ   r+   intlenany	TypeErrorkeysrO   valueskdimsr1   reversedrB   r;   r   list)r   rG   rI   rH   rF   rO   rT   r   main_layer_int_index	valid_indvalid_labelhists_per_dimhists_overlay_per_dimlayoutrC   s   ` `` ```       r   rK   zCompositeOverlay.hist?   s   ,  't\4@@EA"5#..KA4J4J4J4JT4J4J4J4JI#<#<t#<#<#<<K	;/00 b `aaa -',$ @'+yy{{'8'8'?'?$WWT[[]];O-P-VWWWI
 
 
 
 
 
 
 
 !
 
 
!
 !
 !
 !
 !
+1133!
 !
 !
  		.F.B C IJJ G G8444#'<SX'FFF 4F^^aD!6!=!=!?!?@@AAFF*1-Fr    c                 t   g }d}| D ]D}||                     d          v r*|                    |                    |                     d}E|s#t                                          |||          S d |D             }|st	          j                    S t	          j        |          }|r|nt          |          S )a  Return the values along the requested dimension.

        Args:
            dimension: The dimension to return values for
            expanded (bool, optional): Whether to expand values
                Whether to return the expanded values, behavior depends
                on the type of data:
                  * Columnar: If false returns unique values
                  * Geometry: If false returns scalar values per geometry
                  * Gridded: If false returns 1D coordinates
            flat (bool, optional): Whether to flatten array

        Returns:
            NumPy array of values along the requested dimension
        FTr=   c                 4    g | ]}|t          |          |S r   )rX   )r&   r(   s     r   r)   z5CompositeOverlay.dimension_values.<locals>.<listcomp>   s#    @@@q}Q}!}}}r    )
dimensionsappenddimension_valuessupernparrayconcatenater   )	r   rG   expandedflatr\   foundr@   vals	__class__s	           r   rj   z!CompositeOverlay.dimension_values   s       	 	BBMMM5555b11)<<=== 	G77++IxFFF@@V@@@ 	8::~f%%7tt\$%7%77r    )Nr9   NTNF)TT)r4   r5   r6   r7   _deep_indexablerK   rj   __classcell__rs   s   @r   r0   r0   8   sm          O:>27A A A AH8 8 8 8 8 8 8 8 8 8r    r0   c                        e Zd ZdZd fd	Zd Zd fd	Zd Zd Ze	d             Z
e
j        d	             Z
e	d
             Zej        d             Ze	d             Ze	d             Zd fd	Z xZS )r.   a  
    An Overlay consists of multiple Elements (potentially of
    heterogeneous type) presented one on top each other with a
    particular z-ordering.

    Overlays along with elements constitute the only valid leaf types of
    a Layout and in fact extend the Layout structure. Overlays are
    constructed using the * operator (building an identical structure
    to the + operator).
    Nc                 x    d| j         d<   || j         d<   || j         d<    t                      j        |fi | d S )NF_fixed_group_label)__dict__rk   __init__)r   r1   groupr>   paramsrs   s        r   r}   zOverlay.__init__   sL    "'h"'h"'h))&)))))r    c                 ^    t          fd|                                 D                       S )z
        Allows transparently slicing the Elements in the Overlay
        to select specific layers in an Overlay use the .get method.
        c                 *    g | ]\  }}||         fS r   r   )r&   r'   r(   keys      r   r)   z'Overlay.__getitem__.<locals>.<listcomp>   s%    ===1AcF===r    )r.   r1   )r   r   s    `r   __getitem__zOverlay.__getitem__   s0    
 ====

===>>>r    c                    t          |t                    rMt          | j                                                  }d|cxk    rt          |          k     rn n||         S |S t                                          ||          S )aP  Get a layer in the Overlay.

        Get a particular layer in the Overlay using its path string
        or an integer index.

        Args:
            identifier: Index or path string of the item to return
            default: Value to return if no item is found

        Returns:
            The indexed layer of the Overlay
        r   )r+   rW   r_   datar\   rX   rk   get)r   
identifierdefaultr\   rs   s       r   r   zOverlay.get   s     j#&& 	$)**,,--FJ,,,,V,,,,,j))ww{{:w///r    c                 H    t          d |                                           S )zu
        Collates any objects in the Overlay resolving any issues
        the recommended nesting structure.
        c                     | |z  S r   r   )xys     r   <lambda>z!Overlay.collate.<locals>.<lambda>   s
    !A# r    )r   r\   r   s    r   collatezOverlay.collate   s    
 oot{{}}555r    c                 $    ddl m }  ||           S )a  Packs Overlay of DynamicMaps into a single DynamicMap that returns an Overlay

        Decollation allows packing an Overlay of DynamicMaps into a single DynamicMap
        that returns an Overlay of simple (non-dynamic) elements. All nested streams
        are lifted to the resulting DynamicMap, and are available in the `streams`
        property.  The `callback` property of the resulting DynamicMap is a pure,
        stateless function of the stream values. To avoid stream parameter name
        conflicts, the resulting DynamicMap is configured with
        positional_stream_args=True, and the callback function accepts stream values
        as positional dict arguments.

        Returns:
            DynamicMap that returns an Overlay
        r   	decollater   r   r   s     r   r   zOverlay.decollate   s$     	)(((((yr    c                 L   | j         r| j         S d | D             }d |D             }d |D             }|r>t          t          |                    }t          t          |                    j        }ng d}}t	          |          dk    r||k    r|S t          |           j        S )Nc                      g | ]}|j         	|S r   )_auxiliary_componentr?   s     r   r)   z!Overlay.group.<locals>.<listcomp>   s     EEE2R-DEBEEEr    c                     h | ]	}|j         
S r   )r~   r?   s     r   	<setcomp>z Overlay.group.<locals>.<setcomp>   s    ...r"(...r    c                 ,    h | ]}t          |          S r   )typer?   s     r   r   z Overlay.group.<locals>.<setcomp>   s    ---bb---r     r   )rz   nextiterr4   rX   r   )r   elementsr\   typesr~   vtypes         r   r~   zOverlay.group   s    ; 	;EEEEE..X...--H--- 	"f&&Ee%%.EEr5Ev;;!L::&&r    c                 b    t          j        |          st          d| d          || _        d S NzSupplied group z contains invalid characters.)r   	allowable
ValueErrorrz   )r   r~   s     r   r~   zOverlay.group   s:    ",U33 	 SuSSSTTTDKKKr    c                     | j         r| j         S d | D             }t          |          dk    rt          t          |                    S dS )Nc                 *    h | ]}|j         	|j        S r   )r   r>   r?   s     r   r   z Overlay.label.<locals>.<setcomp>  s1     2 2 2r02"( 2 2 2r    r   r   )r{   rX   r   r   )r   labelss     r   r>   zOverlay.label  s[    ; 	;2 2T 2 2 2v;;!V%%%2r    c                 b    t          j        |          st          d| d          || _        d S r   )r   r   r   r{   )r   r>   s     r   r>   zOverlay.label  s;    ",U33 	USuSSSTTTr    c                     g }g }| D ]Q}|                                 D ]:}|j        |vr/|                    |           |                    |j                   ;R|S r   )rh   rB   ri   )r   rh   dimension_namesr@   rC   s        r   ddimszOverlay.ddims  sw    
 	5 	5B}} 5 58?22%%c***#**384445 r    c                     t           r   )r2   r   s    r   shapezOverlay.shape  s    !!r    Tc                 \    ||r
| j         |d<    t                      j        |f|||d|S )Nplot_id)r"   new_typelink)_plot_idrk   r-   )r   r   r"   r   r   	overridesrs   s         r   r-   zOverlay.clone"  sA    <D<#'=Ii uww}Tf{XTXff\efffr    )NNNr   )NTNT)r4   r5   r6   r7   r}   r   r   r   r   propertyr~   setterr>   r   r   r-   ru   rv   s   @r   r.   r.      s`       	 	* * * * * *? ? ?0 0 0 0 0 0*6 6 6  $ ' ' X'  \    \    X \  \
   X " " X"g g g g g g g g g gr    r.   c                   h     e Zd ZdZ ej         ed          gdd          ZdZd	 fd	Z	d Z
 xZS )
	NdOverlayz
    An NdOverlay allows a group of NdOverlay to be overlaid together. NdOverlay can
    be indexed out of an overlay and an overlay is an iterable that iterates
    over the contained layers.
    ElementTz<
        List of dimensions the NdOverlay can be indexed by.)r   constantdocNc                 @     t                      j        |fd|i| d S )Nr]   )rk   r}   )r   overlaysr]   r   rs   s       r   r}   zNdOverlay.__init__4  s-    999&99999r    c                 $    ddl m }  ||           S )a  Packs NdOverlay of DynamicMaps into a single DynamicMap that returns an
        NdOverlay

        Decollation allows packing a NdOverlay of DynamicMaps into a single DynamicMap
        that returns an NdOverlay of simple (non-dynamic) elements. All nested streams
        are lifted to the resulting DynamicMap, and are available in the `streams`
        property.  The `callback` property of the resulting DynamicMap is a pure,
        stateless function of the stream values. To avoid stream parameter name
        conflicts, the resulting DynamicMap is configured with
        positional_stream_args=True, and the callback function accepts stream values
        as positional dict arguments.

        Returns:
            DynamicMap that returns an NdOverlay
        r   r   r   r   s     r   r   zNdOverlay.decollate7  s$      	)(((((yr    )NN)r4   r5   r6   r7   paramListr   r]   rt   r}   r   ru   rv   s   @r   r   r   (  s          EJ		) 4 45 K? @ @ @E O: : : : : :      r    r   c                 l    h | ]1\  }}t          |t                    t          |t                    /|2S r   )r+   r   
issubclassr   )r&   _k_vs      r   r   r   K  sT     M M Mvr2!"d++M0:2{0K0KM M M Mr    )r7   	functoolsr   numpyrl   r   rG   r   r   r   r   re   r	   r
   r   r   	ndmappingr   utilr   r   r   r   r0   r.   r   r_   localsr1   __all__r   r    r   <module>r      s               L L L L L L L L L L L L A A A A A A A A A A A A ' ' ' ' ' ' H H H H H H H H H H &  &  &  &  &  &  &  &Fg8 g8 g8 g8 g8
 g8 g8 g8TCg Cg Cg Cg Cgl,j+ Cg Cg CgL         -/?      F $ M M!1!1 M M M N NQ^P_`r    