
    Le@              
       Z   d dl Z d dlZd dlmZmZmZmZ d dlZd dl	Z
d dlZddlmZ ddlmZ ddlmZmZmZ d ZddZdd	Z G d
 d          Z G d d          Zedd            Zedd            Z eed          r eej                  ZnddZ ee          Z[ eej                  Z eej                  Z  eej!                  Z"d Z# ee#          Z$eeeeej%        ee e&ej'                  fZ( G d d          Z) G d de)          Z* G d de)          Z+d Z,d Z-dS )    N)BuiltinFunctionTypeBuiltinMethodTypeFunctionType
MethodType   )PandasInterface)	Dimension)flattenresolve_dependent_valueunique_iteratorc                       fd}|S )Nc                 N   t          | d          ot          | t                     }t          | dd           pt          | dd           }|r"|r |fd          S  |fd          S |r) t	          |            | gR i | j                  S  | gR i S )Nindexmap_partitions
map_blocksc                 V     t          |            | gR i | j                  S )Nr   )typer   sargskwargsnumpy_fns    8lib/python3.11/site-packages/holoviews/util/transform.py<lambda>z(_maybe_map.<locals>.fn.<locals>.<lambda>   s?    gd1gghhq&B4&B&B&B6&B&B,-G5 5 5     c                      | gR i S N r   s    r   r   z(_maybe_map.<locals>.fn.<locals>.<lambda>   s!    (DT(D(D(DV(D(D r   r   )hasattr
isinstancelistgetattrr   r   )valuesr   r   series_likemap_fnr   s    ``  r   fnz_maybe_map.<locals>.fn   s   fg..Oz&$7O7O3O&"2D99 6&,55 	 	5 Fv5 5 5 5 5 56 6 6 vDDDDDDEEE 	54<<1$111&11l   
 8F4T444V444r   r   )r   r'   s   ` r   
_maybe_mapr(      s#    5 5 5 5 5$ Ir   c                 x    |t          j        |           n|}|t          j        |           n|}| |z
  ||z
  z  S )aS  Unity-based normalization to scale data into 0-1 range.

        (values - min) / (max - min)

    Args:
        values: Array of values to be normalized
        min (float, optional): Lower bound of normalization range
        max (float, optional): Upper bound of normalization range

    Returns:
        Array of normalized values
    )npminmaxr$   r+   r,   s      r   normr.   $   sA      K"&...SCK"&...SCSLSW%%r   c                 ,   |&t          j        t          j        |                     nt          j        |          }|&t          j        t          j        |                     nt          j        |          }t          j        |           |z
  ||z
  z  S )a_  Unity-based normalization on log scale.
       Apply the same transformation as matplotlib.colors.LogNorm

    Args:
        values: Array of values to be normalized
        min (float, optional): Lower bound of normalization range
        max (float, optional): Upper bound of normalization range

    Returns:
        Array of normalized values
    )r*   logr+   r,   r-   s      r   lognormr1   6   sp     %(K"&
 
 
 RVC[[C$'K"&
 
 
 RVC[[CF6NNS SW--r   c                   (    e Zd ZdZd Z d Zd Zd ZdS )ilocz;Implements integer array indexing for dim expressions.
    c                 <    || _         t          d           | _        d S r   exprslicer   selfdim_exprs     r   __init__ziloc.__init__M       	4[[


r   c                 :    || _         t          | j        |           S r   r   dimr6   r9   r   s     r   __getitem__ziloc.__getitem__Q       
49d###r   c                     t          |t          j        t          j        f          r|j        t          | j                           S |t          | j                           S r   )r!   pdSeries	DataFramer3   r   r   r9   r$   s     r   __call__ziloc.__call__U   sK    fry",788 	?;6tzBBCC1$*==>>r   N__name__
__module____qualname____doc__r;   rA   rH   r   r   r   r3   r3   G   sR          H! ! !$ $ $? ? ? ? ?r   r3   c                   (    e Zd ZdZd Z d Zd Zd ZdS )locz(Implements loc for dim expressions.
    c                 <    || _         t          d           | _        d S r   r5   r8   s     r   r;   zloc.__init__b   r<   r   c                 :    || _         t          | j        |           S r   r>   r@   s     r   rA   zloc.__getitem__f   rB   r   c                 @    |j         t          | j                           S r   )rO   r   r   rG   s     r   rH   zloc.__call__j   s    z1$*==>>r   NrI   r   r   r   rO   rO   \   sR          H! ! !$ $ $? ? ? ? ?r   rO   c                    t          j        |          }|#|dd         t          j        |          dz  z   }nt          j        |          }|j        j        dk    rdnd}t          j        | |dk    rt           j        nd|          }t          |dd         |dd         |          D ]0\  }}}| |k    | |k    z  }||t          j        |          d	         <   1|S )
a  Bins data into declared bins

    Bins data into declared bins. By default each bin is labelled
    with bin center values but an explicit list of bin labels may be
    defined.

    Args:
        values: Array of values to be binned
        bins: List or array containing the bin boundaries
        labels: List of labels to assign to each bin
            If the bins are length N the labels should be length N-1

    Returns:
        Array of binned values
    Ng       @ffloatOdtype   r   )	r*   asarraydiffrY   kind	full_likenanzipwhere)	r$   binslabelsrY   binnedlowerupperlabel	conditions	            r   binri   n   s    " :dD~ss)bgdmmB..F##|(C//GGSE\&Uc\\266tERRRF"49d122h?? / /uee^%8	).rx	""1%&&Mr   c                    t          t          |                     }g }| D ]v}t          |t                     r4|                    |          }|t	          |          k     r	||         }n|}n|                    ||          }|                    |           wt          j        |          }|j	        j
        dv r|                    d          }|S )a  Maps discrete values to supplied categories.

    Replaces discrete values in input array with a fixed set of
    categories defined either as a list or dictionary.

    Args:
        values: Array of values to be categorized
        categories: List or dict of categories to map inputs to
        default: Default value to assign if value not in categories

    Returns:
        Array of categorized values
    )USobject)r"   r   r!   r   lengetappendr*   r[   rY   r]   astype)	r$   
categoriesdefault	uniq_catscatsccat_indcatresults	            r   
categorizerz      s     _V,,--ID 	 	j$'' 	-ooa((GZ(( )..G,,CCZF|J&&x((Mr   isinFc                     t          j        |           } t          j        | |||                              | j                  S )N)assume_uniqueinvert)r*   r[   in1dreshapeshape)elementtest_elementsr}   r~   s       r   _isinr      sB    *W%%ww]  &ww}55	6r   c                      fd| D             S )Nc                     g | ]}|v S r   r   ).0vr$   s     r   
<listcomp>z _python_isin.<locals>.<listcomp>   s    '''AAK'''r   r   )arrayr$   s    `r   _python_isinr      s    ''''''''r   c                       e Zd ZdZi ej        dej        dej        dej        dej	        dej
        dej        dej        d	ej        d
ej        dej        dej        dej        dej        dej        dej        dej        dZedediZedededededede de!dede"de#diZ$e%j&        de%j'        de%j(        d e%j)        d!e%j*        d"e%j+        d#e%j,        d$e%j-        d%e%j.        d&e%j/        d'e%j0        d(e%j1        d)iZ2ej3        dej4        dej5        d*iZ6eee$e2e6gZ7d+d,iZ8d+Z9d-Z:d. Z;d/ Z<d0 Z=e>d1             Z?d2 Z@ fd3ZA fd4ZBd5 ZCdd6ZDeEd7             ZFe>d8             ZGe>d9             ZHe>d:             Z%e>d;             ZId< ZJd= ZKdd>ZLd? ZMd@ ZNdA ZOdB ZPdC ZQdD ZRdE ZSdF ZTdG ZUdH ZVdI ZWdJ ZXdK ZYdL ZZdM Z[dN Z\dO Z]dP Z^dQ Z_dR Z`dS ZadT ZbdU ZcdV ZddW ZedX ZfdY ZgdZ Zhd[ Zid\ Zjd] Zkd^ Zld_ Zmd` Znda ZoddbZpdc Z&dd Z'de Z(df Z)dg Z*dh Z+di Z,dj Z-dk Z.dl Z/dm Z0dn Z1do Z!ddqZqdr Zds Ze>dt             Z"dduZddvZddwZddxZeEdy             Zre>dz             Zsdd|Ztd} Zud~ Zvd Zwd Zxd Zy	 	 ddZzd Z{ xZ|S )r?   a  
    dim transform objects are a way to express deferred transforms on
    Datasets. dim transforms support all mathematical and bitwise
    operators, NumPy ufuncs and methods, and provide a number of
    useful methods for normalizing, binning and categorizing data.
    +&z==z//z>=>z<=z<<<%*z!=|z**z>>-/absroundr.   r1   ri   rz   digitizer{   rq   r3   rO   anyallcumprodcumsumr,   meanr+   sumstdvarr0   log10~numpyr*   Nc                    ddl m} g | _        t          j        | _        |                    dd          | _        t          |t                    rt          |          | _        nyt          |t                    r|| _        n\t          |t          j                  r|| _        n:t          ||          r|j        j        | _        n|j        | _        |j        | _        |r	|d         nd t          t          t          fz             s?t!          fd| j        D                       st%          dt'                    z            | j        |dd          ||                    dd	          d
gz   | _        d S d S )Nr   WidgetcoerceTc              3       K   | ]}|v V  	d S r   r   )r   funcsr'   s     r   	<genexpr>zdim.__init__.<locals>.<genexpr>  s'      AAeAAAAAAr   z1Second argument must be a function, found %s typerZ   reverseF)r   r'   r   r   )panel.widgetsr   opsr*   ndarray_nsro   r   r!   strr	   	dimensionparam	Parametervaluefunction_typesr   
_all_funcs
ValueErrorr   pop)r9   objr   r   r   r'   s        @r   r;   zdim.__init__   s   ((((((:jj400c3 
	&s^^DNNY'' 	 DNNU_-- 	 DNNV$$ 	 Y_DNN ]DNwDH 	aBBB>r>3&#899 =AAAAAAAAA=  "13788"< = = =xDHB&%+ZZ	5%A%A$C $C #D DDHHH >r   c                     | j         S r   )__dict__r9   s    r   __getstate__zdim.__getstate__  s
    }r   c                 :    | j                             |           d S r   )r   update)r9   states     r   __setstate__zdim.__setstate__  s    U#####r   c                     | j         r9| j         d         d                             d          r| j         d         d         S d S d S )NrT   r   accessorr'   )r   ro   r   s    r   _current_accessorzdim._current_accessor  sQ    8 	&X.22:>> 	&8B<%%	& 	& 	& 	&r   c                    | j         r;t          | j         d         d         t                    rd| j         d         d         vrt          d| z            | j         d         }|d         dk    rt	          |t
          t          fi           }nt	          |||          }|                     | j        | j         d d         |gz             S )	NrT   r'   r   r   z|Cannot call method on %r expression. Only methods accessed via namespaces, e.g. dim(...).df or dim(...).xr), can be called. r   )r'   r   r   )r   r   )r   r!   r   r   dictrq   cloner   )r9   r   r   opnew_ops        r   rH   zdim.__call__$  s     	7
48B<+=s C C 	7dhrl8444 / 266 7 7 7 Xb\d8u"sfR@@@FF"4777Fzz$.$(3B3-*@AAAr   c                 ~   t                                          d          }d|vr!t                                          |          S |d         }t                                          d          }|rQ|d         d                             d          r0	 t          ||d         d                   }n# t          $ r d }Y nw xY wd t          |          D             }||v r=|t                                                      vr t          |           | |d	
          S t                                          |          S )Nr   r   r   rT   r   r   r'   c                 <    h | ]}|                     d           |S _
startswith)r   ns_attrs     r   	<setcomp>z'dim.__getattribute__.<locals>.<setcomp>@  s+    PPPg8J8J38O8OP'PPPr   Tr   )super__getattribute__ro   r#   	Exceptiondir__dir__r   )r9   attr	self_dictnsr   extras	__class__s         r   r   zdim.__getattribute__2  s:   GG,,Z88		!!77++D111ugg&&u-- 	3r78$((44 	RR//    	
 QPRPPP6>>d%''//*;*;;;4::dD4888877++D111s   B2 2C Cc           
         | j         }| j        rt          || j                  }d t          |          D             }	 t	          t          t                                                                |z            S # t          $ rQ t	          t          t          t          |                               t          | j
                  z  |z            cY S w xY w)Nc                 <    h | ]}|                     d           |S r   r   )r   r   s     r   r   zdim.__dir__.<locals>.<setcomp>J  s)    GGG4$//#2F2FG$GGGr   )r   r   r#   r   sortedsetr   r   r   r   r   )r9   r   r   r   s      r   r   zdim.__dir__F  s    X! 	5T344BGG3r77GGG	N#eggoo//0069::: 	N 	N 	N#c$t**oo..T]1C1CCfLMMMMM	Ns   <A< <ACCc                 :    t          t          |                     S r   )hashreprr   s    r   __hash__zdim.__hash__P  s    DJJr   c                     |pt          |           }|| j        } ||          }|t          | j                  }||_        |S )zf
        Creates a clone of the dim expression optionally overriding
        the dim and ops.
        )r   r   r"   r   )r9   r   r   dim_typenew_dims        r   r   z	dim.cloneS  sN    
 )tDzzI(9%%;tx..Cr   c                     || j         |<   dS )zs
        Register a custom dim transform function which can from then
        on be referenced by the key.
        N)_custom_funcs)clskeyfunctions      r   registerzdim.registera  s     "*#r   c           
      2   dt           j        v rddlm} nd }i }| j        D ]t}t          |d                   t          |d                                                   z   }t          |d         d          r||d         j        gz  }t          |          }|D ]}|rt          ||          r|j        j        }t          |t                    r|                    |j                   nHt          |t                     r2|j        |j        |j        }}}|rt          ||          r|j        j        }|rt          ||          r|j        j        }|rt          ||          r|j        j        }t          |t          j                  r'|||j        t-          t/          |                    z   <   t          |t          j                  r'|||j        t-          t/          |                    z   <   t          |t          j                  r'|||j        t-          t/          |                    z   <   t          |t          j                  rFt          |j        t          j                  r'|||j        t-          t/          |                    z   <   v|S )Npanelr   r   r   r   r'   r   )sysmodulespanel.widgets.baser   r   r"   r$   r    r   r
   r!   r   r   r?   r   paramsr7   startstopstepr   namer   idownerParameterized)	r9   r   r   r   op_argsop_argr   r   r   s	            r   r   z
dim.paramsi  s|   ck!!1111111F( 	A 	AB2f:&&tBxL,?,?,A,A'B'BBGr$x)) ,BtHN++g&&G! A A 0j88 0#\/Ffc** ?MM&-0000.. ?+1<fk$DU 2*UF";"; 2 % 1 0*T6":": 0#z/ 0*T6":": 0#z/!%99 B<Auz#bii..89!$88 ?:>tyRXX67!$88 ?:>tyRXX67vu77 Av|U-@AAA:@F6;s2f::67/A2 r   c                 8    |                      t                    S N)r   )r   df_dimr   s    r   dfzdim.df      zz6z***r   c                 8    |                      t                    S r   )r   r?   r   s    r   r*   zdim.np  s    zz3z'''r   c                 8    |                      t                    S r   )r   xr_dimr   s    r   xrzdim.xr  r  r   c                 D     t          |           | t          j        g|R  S r   )r   operatorgetitemr@   s     r   rA   zdim.__getitem__  s%    tDzz$ 0959999r   c                 >     t          |           | t                    S r   )r   r   r   s    r   __abs__zdim.__abs__  s    dD#)>)>">r   c                 H    |dn|f} t          |           | t          g|R  S )Nr   r   round_)r9   ndigitsr   s      r   	__round__zdim.__round__  s1    _rr7*tDzz$.....r   c                 H     t          |           | t          j                  S r   )r   r  negr   s    r   __neg__zdim.__neg__      jd4jjx|<<<r   c                 H     t          |           | t          j                  S r   )r   r  not_r   s    r   __not__zdim.__not__  s    jd4jjx}===r   c                 H     t          |           | t          j                  S r   )r   r  invr   s    r   
__invert__zdim.__invert__  s    dD(,!?!??r   c                 H     t          |           | t          j                  S r   )r   r  posr   s    r   __pos__zdim.__pos__  r  r   c                 J     t          |           | t          j        |          S r   r   r  addr9   others     r   __add__zdim.__add__      :4::dHL%+P+P$Pr   c                 J     t          |           | t          j        |          S r   r   r  and_r   s     r   __and__zdim.__and__      :4::dHM5+Q+Q$Qr   c                 J     t          |           | t          j        |          S r   r   r  divr   s     r   __div__zdim.__div__  r#  r   c                 J     t          |           | t          j        |          S r   )r   r  eqr   s     r   __eq__z
dim.__eq__      :4::dHK+O+O$Or   c                 J     t          |           | t          j        |          S r   r   r  floordivr   s     r   __floordiv__zdim.__floordiv__  s    :4::dH<Mu+U+U$Ur   c                 J     t          |           | t          j        |          S r   )r   r  ger   s     r   __ge__z
dim.__ge__  r0  r   c                 J     t          |           | t          j        |          S r   )r   r  gtr   s     r   __gt__z
dim.__gt__  r0  r   c                 J     t          |           | t          j        |          S r   )r   r  ler   s     r   __le__z
dim.__le__  r0  r   c                 J     t          |           | t          j        |          S r   )r   r  ltr   s     r   __lt__z
dim.__lt__  r0  r   c                 J     t          |           | t          j        |          S r   )r   r  lshiftr   s     r   
__lshift__zdim.__lshift__      :4::dHOU+S+S$Sr   c                 J     t          |           | t          j        |          S r   r   r  modr   s     r   __mod__zdim.__mod__  r#  r   c                 J     t          |           | t          j        |          S r   r   r  mulr   s     r   __mul__zdim.__mul__  r#  r   c                 J     t          |           | t          j        |          S r   )r   r  ner   s     r   __ne__z
dim.__ne__  r0  r   c                 J     t          |           | t          j        |          S r   r   r  or_r   s     r   __or__z
dim.__or__  r#  r   c                 J     t          |           | t          j        |          S r   )r   r  rshiftr   s     r   
__rshift__zdim.__rshift__  rD  r   c                 J     t          |           | t          j        |          S r   r   r  powr   s     r   __pow__zdim.__pow__  r#  r   c                 J     t          |           | t          j        |          S r   r   r  subr   s     r   __sub__zdim.__sub__  r#  r   c                 J     t          |           | t          j        |          S r   r   r  truedivr   s     r   __truediv__zdim.__truediv__      :4::dH<Le+T+T$Tr   c                 N     t          |           | t          j        |d          S NT)r   r  r   s     r   __radd__zdim.__radd__  #    :4::dHL%Y]+^+^+^$^r   c                 J     t          |           | t          j        |          S r   r%  r   s     r   __rand__zdim.__rand__  r(  r   c                 N     t          |           | t          j        |d          S re  r*  r   s     r   __rdiv__zdim.__rdiv__  rg  r   c                 N     t          |           | t          j        |d          S re  r2  r   s     r   __rfloordiv__zdim.__rfloordiv__  s$    :4::dH<Mu^b+c+c+c$cr   c                 J     t          |           | t          j        |          S r   )r   r  rlshiftr   s     r   __rlshift__zdim.__rlshift__  rc  r   c                 N     t          |           | t          j        |d          S re  rF  r   s     r   __rmod__zdim.__rmod__  rg  r   c                 N     t          |           | t          j        |d          S re  rJ  r   s     r   __rmul__zdim.__rmul__  rg  r   c                 N     t          |           | t          j        |d          S re  rQ  r   s     r   __ror__zdim.__ror__  rg  r   c                 N     t          |           | t          j        |d          S re  rX  r   s     r   __rpow__zdim.__rpow__  rg  r   c                 J     t          |           | t          j        |          S r   )r   r  rrshiftr   s     r   __rrshift__zdim.__rrshift__  rc  r   c                 N     t          |           | t          j        |d          S re  r\  r   s     r   __rsub__zdim.__rsub__  rg  r   c                 N     t          |           | t          j        |d          S re  r`  r   s     r   __rtruediv__zdim.__rtruediv__  s$    :4::dH<Le]a+b+b+b$br   c                 |    |d         }d |                                 D             } t          |           | |fi |S )Nr   c                     i | ]
\  }}|||S r   r   )r   kr   s      r   
<dictcomp>z'dim.__array_ufunc__.<locals>.<dictcomp>  s    CCC41aQ]!Q]]]r   )itemsr   )r9   r   r   ufuncs       r   __array_ufunc__zdim.__array_ufunc__  sF    QCC6<<>>CCCtDzz$00000r   c                 t    ||t          d           t          |           | t          j        ||          S )Nz One of max or min must be given.)a_mina_max)r   r   r*   clip)r9   r+   r,   s      r   r  zdim.clip  s;    ;3;?@@@tDzz$s#>>>>r   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r   r9   r   r   s      r   r   zdim.any  ,    
T

40Y$0Y0Y0YRX0Y0Y)Yr   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r   r  s      r   r   zdim.all  r  r   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r   r  s      r   r   zdim.cumprod  s,    
T

40^t0^0^0^W]0^0^)^r   c                 v     t          |           | t          j        g|R d|                    dd          i|S )Naxisr   )r   r*   r   r   r  s      r   r   z
dim.cumsum  sY    
T

4 1Ed 1E 1E 1E@F

6RS@T@T1E=C1E 1E *Er   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r,   r  s      r   r,   zdim.max  r  r   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r   r  s      r   r   zdim.mean  s,    
T

40Z40Z0Z0ZSY0Z0Z)Zr   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r+   r  s      r   r+   zdim.min  r  r   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r   r  s      r   r   zdim.sum  r  r   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r   r  s      r   r   zdim.std  r  r   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r   r  s      r   r   zdim.var  r  r   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r0   r  s      r   r0   zdim.log  r  r   c                 J     t          |           | t          j        g|R i |S r   )r   r*   r   r  s      r   r   z	dim.log10  s,    
T

40[D0[0[0[TZ0[0[)[r   c                 B     t          |           | t          |          S )NrX   )r   rq   )r9   rY   s     r   rq   z
dim.astype  s    JDJJtV5$I$I$IIr   r   c                 B     t          |           | t          |          S )N)decimalsr  )r9   r  s     r   r   z	dim.round  s    
T

4((S(S(S!Sr   c                 @     t          |           | t          g|R i |S r   )r   r   r  s      r   r   zdim.digitize  s*    
T

40[D0[0[0[TZ0[0[)[r   c                     |                     dd           r t          |           | t          g|R i |S  t          |           | t          g|R i |S )Nrm   )r   r   python_isinr{   r  s      r   r{   zdim.isin  si    ::h%% 	B4::dKA$AAA&AAAtDzz$6t666v666r   c                      t          |           S r   )r3   r   s    r   r3   zdim.iloc  s    Dzzr   c                 D     t          |           | t          ||          S )a  Bins continuous values.

        Bins continuous using the provided bins and assigns labels
        either computed from each bins center point or from the
        supplied labels.

        Args:
            bins: List or array containing the bin boundaries
            labels: List of labels to assign to each bin
                If the bins are length N the labels should be length N-1
        )rc   )r   ri   )r9   rb   rc   s      r   ri   zdim.bin  s#     tDzz$T&9999r   c                 D     t          |           | t          ||          S )aU  Replaces discrete values with supplied categories

        Replaces discrete values in input array into a fixed set of
        categories defined either as a list or dictionary.

        Args:
            categories: List or dict of categories to map inputs to
            default: Default value to assign if value not in categories
        )rr   rs   )r   rz   )r9   rr   rs   s      r   rz   zdim.categorize  s#     tDzz$
z7SSSSr   c                 d    i }||d         |d         d} t          |           | t          fi |S )zUnity-based normalization log scale.
           Apply the same transformation as matplotlib.colors.LogNorm

        Args:
            limits: tuple of (min, max) defining the normalization range
        Nr   rZ   r+   r,   )r   r1   r9   limitsr   s      r   r1   zdim.lognorm  sD     #AYvay99FtDzz$226222r   c                 d    i }||d         |d         d} t          |           | t          fi |S )zUnity-based normalization to scale data into 0-1 range.

            (values - min) / (max - min)

        Args:
            limits: tuple of (min, max) defining the normalization range
        Nr   rZ   r  )r   r.   r  s      r   r.   zdim.norm  sD     #AYvay99FtDzz$/////r   c                     t          |          }t          |          D ](\  }}t          |t                    r | |          ||<   ) | |d         |g|dd         R i |S )z
        Wrapper to give multidimensional transforms a more intuitive syntax.
        For a custom function 'func' with signature (*args, **kwargs), call as
        dim.pipe(func, *args, **kwargs).
        r   rZ   N)r"   	enumerater!   r   )r   funcr   r   r  args         r   pipezdim.pipe*  sz     Dzzoo 	# 	#FAs#s## ##c((Qs47D648666v666r   c                 8     t          |           | dd          S )z1Casts values to strings or provides str accessor.r   Tr   )r   r   s    r   r   zdim.str7  s!     tDzz$5555r   Fc                    ddl m} t          | j        t          j                  rd}nt          | j        t                    r| j                            |          }nm| j        j        dk    rd}nZ|r| j        n| j        j        }|	                    |          du}t          ||          r|s|j
        	                    |          du}| j        D ]}|                    d          }|s|D ]/}t          |t                    r||                    |          z  }0|                    d          }	|	                                D ]/}
t          |
t                    r||
                    |          z  }0|S )z
        Determines whether the dim transform can be applied to the
        Dataset, i.e. whether all referenced dimensions can be
        resolved.
        r   GraphTr   Nr   r   )r   r  r!   r   r   r   r?   appliesr   get_dimensionnodesr   ro   r$   )r9   datasetstrictr  r  lookupr   r   r  r   kwargs              r   r  zdim.applies>  s    	$#####dneo66 
	JGG,, 	Jn,,W55GG^ C''GG'-FT^^4>3FF++F334?G'5)) J' J!-55f==TI( 
	6 
	6B66&>>D  4 4c3'' 4s{{7333GVVH%%F 6 6eS)) 6u}}W555G6 r   c                     dS )NTr   r9   r  r   s      r   interface_applieszdim.interface_applies_  s    tr   c                 6   |d         }|d         }t          |d                   }| j                            |          }|r5t          ||          r%d|vrt	          |t
          j                  sd |d<   |}t	          |t                    r|                    dd           }g }nd}|g}|D ]W}t	          |t                    r|
                    |||||||	|
          }t          |          }|                    |           Xi }|                                D ]H\  }}t	          |t                    r|
                    |||||||	|
          }t          |          ||<   It          |d         r|d d d         n|          }t          |          }|||||fS )	Nr   r'   r   r  r   Fr   rT   )r   _numpy_funcsro   r    r!   r*   r  r   r   r?   applyr   rp   r  tuple)r9   r   r  dataflatexpandedranges
all_values
keep_indexcomputer  r   r'   r   fn_namer   fn_argsr  	fn_kwargsr  r   s                        r   _resolve_opzdim._resolve_opb  s   &zXbl###''++ 	wtW-- 	V##Jr28,D,D#!%vBb# 	zz*d33HGGHfG 	  	 C#s## iiT8VZ  *#..CNN3	LLNN 	6 	6DAq!S!! GGT8VZ  3155IaLLbm@WTTrT]]AAi7D&(22r   c	                    |t           u s	|t          u r|i k    rd|v rd|v s
 ||g|R  }nt          |t                    rt	          ||d           }	|	6|rdnd}
t          | d|d| d|
 dt          |          j         d	
          |r|	}nM	  |	|i |}nC# t          $ r.}d
|v r|	                    d
            |	|i |}n|Y d }~nd }~ww xY w ||i |}|S )Nr+   r,   	attributemethodz could not be applied to 'z', 'z' z does not exist on z type.r  )
r.   r1   r!   r   r#   AttributeErrorr   rJ   r   r   )r9   r  r  r'   r  r   r   r   dranger  mtypees               r   	_apply_fnzdim._apply_fn  s   DjjbGmm&B,,&Uf__2d$V$$$DDC   	'T2t,,F~'/=X$ E E E E E Ee E E)-d)<E E E    
  !642622DD       ''

6***%vt6v66   2t&v&&Ds   B 
C"$CCc                 R    t          |d          r|r|                                }|S )zz
        Implements conversion of data from namespace specific object,
        e.g. pandas Series to NumPy array.
        r  )r    r  r9   r  
drop_indexr  s       r   _compute_datazdim._compute_data  s/    
 4## 	" 	"<<>>Dr   c                     |S )zr
        Implements coercion of data from current data format to the
        namespace specific datatype.
        r   )r9   r  s     r   _coercezdim._coerce  s	    
 r   Tc	                 V   ddl m}	 |i }| j        }
|>|j        j        r	|
|j        v p'|j        j        o|j                            ||
d           }|                     |          s@t          ||	          r|                     |j
                  st          d| d| d          |                     || j                  sW| j        r(t          d	| d
| j         d|j        j         d          t          d	| d
| j         d|j        j         d          t          ||	          r*|
|j        v r|r|j
        j        d         }
|
|v r|n|j
        }|                     |          }| j        dk    rd}d}n|}|}|
j        dk    r
|j        }d}n|t          |
t(          j                  rt-          |
j        |
j                  }d}nE|r|
n|
j        }|                    |          j        }|j                            ||||||          }| j        D ]n}|                     ||||||||||
  
        \  }}}}}|                    |i           }|                    d|          }|                     ||||||||          }o|o| }| o|}|s|r|                     |||          }|S )a1  Evaluates the transform on the supplied dataset.

        Args:
            dataset: Dataset object to evaluate the expression on
            flat: Whether to flatten the returned array
            expanded: Whether to use the expanded expand values
            ranges: Dictionary for ranges for normalization
            all_values: Whether to evaluate on all values
               Whether to evaluate on all available values, for some
               element types, such as Graphs, this may include values
               not included in the referenced column
           keep_index: For data types that support indexes, whether the index
               should be preserved in the result.
           compute: For data types that support lazy evaluation, whether
               the result should be computed before it is returned.
           strict: Whether to strictly check for dimension matches
               (if False, counts any dimensions with matching names as the same)

        Returns:
            values: NumPy array computed by evaluating the expression
        r   r  NTz)One or more dimensions in the expression z could not resolve on 'zY'. Ensure all dimensions referenced by the expression are present on the supplied object.r   zThe expression z assumes a z#-like API but the dataset contains z data and cannot be coerced.z data and coercion is disabled.r   Fr   )r  r  r  r  combined)r   r  r   	interfacegriddedkdimsmultiisuniquer  r!   r  KeyErrorr  r   r   	namespacedatatyper  r   r  r   r   r#   r   r  r$   r   r  ro   r  r  )r9   r  r  r  r  r  r  r  r  r  r   compute_for_computekeep_index_for_computer  eldimr  r   r'   r  r   r   r   r  r  s                           r   r  z	dim.apply  s   . 	$#####>FN	$.6U9;U o$.4m9J9S9ST[]fhl9m9mpH ||G$$ 	>j%.H.H 	>PTP\P\]d]jPkPk 	> =t = =4;= = = > > > %%gdk%BB 	>{ >  ":4 ": ":dn ": ":AHARA[": ": ": ; ; ; ! "=4 "= "=dn "= "=AHARA["= "= "= > > > gu%% 	IGM))j)#M/2	!*g!5!5gg7=G,,w''>W$$"'%)""")%/">S  <DEE	5?33 		9?IN;;DEE"(<YYinF))&116E$++(+8N ,  D ( 	< 	<B262B2BGT46:&(;V3 3/Bvx ZZr**FZZ
F33F>>'4Wd"((F< <DD+>J
))5g 	A' 	A%%dJ@@Dr   c           	         d| j          d}d}t          | j                  D ]\  }}|dk    rd}n|rd}nd}|d         }t          |t          j                  }|d         r%d	                    d
 |d         D                       nd}|d         }	|}
|	                    dd           }t          |		                                t          j        d                    }	|	r"dd	                    d |	D                       z  nd}	|| j        v r]| j        |d                  }|d         rd|z   }n|dz   }t          d |d         D                       r|                    dd          }n|| j        v r| j        |         }d|z   }nt          |t                     r|}n|j        }|| j        v r| j        |         }d|z   }nOt          |t                     r.|r%|                    d          s|
rdnd}||z   dz   }n|dz   }n|| j        v r| j        |         }|dz   }nt          |t*                    r|d|j        dz   }nt          |t.                    r|d|j        dz   }n|| j        v r| j        |         }|dz   }n|rt!          |          dd         }|                    d           s|                    d          sd|z   }nd!|z   }|t5          t                    v r"d"                    | j        d#         |g          }n|d$z   }|rnJ|r'|                    d%          s|d	z  }|dz  }|	r|d&z  }n!|	r|                    d%          s|d	z  }|d'z  }|dk    rQ| j        rJd|v rF|                    d          }d                    |d |         d(| j        ||d)z   d          g          }|                    ||||	*          }|                    d%          |                    d          z
  dk    r|dz  }| j        sd+| d}|                    d%          |                    d          z
  dk    r|dz  }|S ),N'Fr   z
dim({repr}z{repr}z({repr}r'   r   z, c                 ,    g | ]}t          |          S r   )r   )r   rs     r   r   z dim.__repr__.<locals>.<listcomp>  s    999!d1gg999r    r   r   )r   z%sc                 "    g | ]} d j         | S )z{}={!r})format)r   items     r   r   z dim.__repr__.<locals>.<listcomp>  s#    &R&R&R4'7y'7'>&R&R&Rr   r   z
{args}{fn}z){fn}{args}c              3   @   K   | ]}t          |t                    V  d S r   )r!   r?   )r   as     r   r   zdim.__repr__.<locals>.<genexpr>%  s,      ==az!S))======r   z{args}z({args})z{fn})z.{fn}z).{fn}(z).iloc[]z).loc[   r?   z{fn}(.r   z, {fn}(z
, {kwargs}z{kwargs}z).rZ   )r'   r   r   r   zdim()r   r  r   r!   r*   r  joinr   r   r  r  
itemgetter_binary_funcsr   replace_unary_funcsr   rJ   _builtin_funcsendswithr  r3   r   rO   r   r   r   _namespaces	_accessorr  count)r9   op_reprr   ioprevr'   r  r   r   prev_accessorr  format_stringsepidxs                  r   __repr__zdim.__repr__  s"   'dn'''dh'' T	 T	DAqAvv# ! 4Br28,,E>?iO49999qy999:::RDx[F$Mzz*d33HFLLNN0CA0F0FGGGFW]eTDII&R&R6&R&R&RSSSSceFT''',QtW5Y< 7$0$5MM$($6M==1V9===== P$1$9$9(J$O$OMt(((+B/ &b#&& * GG kG,,,"1"5G$*4KMMC(( 2 7$+$4$4S$9$9S]SbbPS(,S(8(,Y4,,,"/3G$(NMMD)) 2$()@28)@)@)@$@MMC(( 2$()?"()?)?)?$?MM4---"04G$(NMM 	2!"ggadmG OOE22 7dmmC6H6H 7(.(/$#b''))(+$2B72K]1[(\(\$(MM 0 	0(11#66 .%-!X-M 6%5 0(11#66 .%-!Z/M Avv$.vSM-A-A#))#.. "!$3$'t~!#a%&&)) ! !
 $**gG04V + E EG}}S!!GMM#$6$66::3x 	('W'''G==c 2 22Q66sNGr   )NNNr   NN)r   )F)FNNFFTF)}rJ   rK   rL   rM   r  r  r&  r.  r3  r6  r9  r<  rB  r?  rG  rK  rN  rR  rY  rU  r]  ra  r  r   r  r  r.   r1   ri   rz   r   r{   r  rq   r3   rO   r   r*   r   r   r   r   r,   r   r+   r   r   r   r0   r   r  r  r  r  r  r   r  r  r  r;   r   r   propertyr   rH   r   r   r   r   classmethodr   r   r   r  rA   r
  r  r  r  r  r  r"  r'  r,  r/  r4  r7  r:  r=  r@  rC  rH  rL  rO  rS  rV  rZ  r^  rb  rf  ri  rk  rm  rp  rr  rt  rv  rx  r{  r}  r  r  r  r   r  r   r  r  r  r  r  r  r  r  __classcell__r   s   @r   r?   r?      s        2c2#=#2/7{D242!)d24<K2 	T2 $?D2 3;+s2 	c	2 $<	2 /7k4	2
 	c2
 $<2
 082 	c2 $+S2M 5&'2N 	fUL*fVfUM 	rvu

Iry(BFE

rvubfeRVU
'L L#x|S(-ML.J D/KIID D D8  $ $ $ & & X&B B B2 2 2 2 2(N N N N N         * * [* & & X&R + + X+ ( ( X( + + X+: : : ?>>/ / / /
 =<<===???<<< QPPQQQPPPOOOUUUOOOOOOOOOOOOSSSPPPPPPOOOPPPSSSPPPPPPTTT _^^QQQ^^^cccTTT^^^^^^^^^^^^TTT^^^bbb1 1 1
? ? ? ?
 ZYYYYY^^^E E E ZYYZZZYYYYYYYYYYYYYYY[[[ JIISSSS[[[7 7 7
   X: : : :
T 
T 
T 
T
3 
3 
3 
30 0 0 0 
7 
7 [
7 6 6 X6   B  $3 $3 $3L  8     QV5:W W W Wr\ \ \ \ \ \ \r   r?   c                   R     e Zd ZdZdZdZ fdZd Zd Zd Z	e
d             Z xZS )	r   z
    A subclass of dim which provides access to the DataFrame namespace
    along with tab-completion and type coercion allowing the expression
    to be applied on any columnar dataset.
    	dataframerD   c                 d     t                      j        |g|R i | t          j        | _        d S r   )r   r;   rD   rE   r   )r9   r   r   r   r   s       r   r;   zdf_dim.__init__w  s7    .t...v...9r   c                 T    |j         j         o|pt          |j         t                    S r   )r  r  r!   r   r  s      r   r  zdf_dim.interface_applies{  s/    %-- KI:g&7II	Lr   c                     t          |d          r|r|                                }|s|S |r$t          |d          r|                                S |j        S )Nr  to_numpy)r    r  r  r$   r  s       r   r  zdf_dim._compute_data  sd    4## 	" 	"<<>>D 	K 	#wtZ00 	#==??"{r   c                     |                      d          rS t          j        t                    }fd|                                D             }                    |          S )NFr  c                 H    g | ]}j         j        |j        k    |j        S r   )r  r  r  )r   intfcr  s     r   r   z"df_dim._coerce.<locals>.<listcomp>  s:     @ @ @)/5;>> ^>>>r   r  )r  r   concrete_descendentsr   r$   r   )r9   r  pandas_interfaces	datatypess    `  r   r  zdf_dim._coerce  s    !!'%!88 	N!6GG@ @ @ @1B1I1I1K1K @ @ @	}}i}000r   c                      t          |           S r   )rO   r   s    r   rO   z
df_dim.loc  s    4yyr   )rJ   rK   rL   rM   r  r  r;   r  r  r  r
  rO   r  r  s   @r   r   r   l  s          II    L L L  1 1 1   X    r   r   c                   <     e Zd ZdZdZdZ fdZd Zd Zd Z	 xZ
S )r  z
    A subclass of dim which provides access to the xarray DataArray
    namespace along with tab-completion and type coercion allowing
    the expression to be applied on any gridded dataset.
    xarrayr  c                     	 dd l }n# t          $ r t          d          w xY w t                      j        |g|R i | |j        | _        d S )Nr   zKXArray could not be imported, dim().xr requires the xarray to be available.)r  ImportErrorr   r;   	DataArrayr   )r9   r   r   r   r  r   s        r   r;   zxr_dim.__init__  s    	F 	F 	F 	F E F F F	F 	.t...v...<s    "c                 >    |j         j        o|p|j         j        dk    S )Nr  )r  r  r  r  s      r   r  zxr_dim.interface_applies  s*    !) CA7,5A	Dr   c                 d    |r|j         }t          |d          r|r|                                }|S )Nr  )r  r    r  r  s       r   r  zxr_dim._compute_data  s<     	9D4## 	" 	"<<>>Dr   c                 b    |                      |d          r|S |                    dg          S )NFr  r  r  )r  r   )r9   r  s     r   r  zxr_dim._coerce  s8    !!'%!88 	N}}xj}111r   )rJ   rK   rL   rM   r  r  r;   r  r  r  r  r  s   @r   r  r    s~          II         D D D  2 2 2 2 2 2 2r   r  c                    t          | t          t          f          rt          j        |           } t          |t          t          f          rt          j        |          }t          j        dz  }| |z  dz  }t          j        dd          5  t          j        t          j        d|z   t          j        z  dz                      |z  t          j        z  }ddd           n# 1 swxY w Y   ||fS )a*  
    Projects the given longitude, latitude values into Web Mercator
    (aka Pseudo-Mercator or EPSG:3857) coordinates.

    Longitude and latitude can be provided as scalars, Pandas columns,
    or Numpy arrays, and will be returned in the same form.  Lists
    or tuples will be converted to Numpy arrays.

    Args:
        longitude
        latitude

    Returns:
        (easting, northing)

    Examples:
       easting, northing = lon_lat_to_easting_northing(-74,40.71)

       easting, northing = lon_lat_to_easting_northing(
           np.array([-74]),np.array([40.71])
       )

       df=pandas.DataFrame(dict(longitude=np.array([-74]),latitude=np.array([40.71])))
       df.loc[:, 'longitude'], df.loc[:, 'latitude'] = lon_lat_to_easting_northing(
           df.longitude,df.latitude
       )
    Ra      f@ignore)divideinvalidZ        v@N)	r!   r"   r  r*   r   pierrstater0   tan)	longitudelatitudeorigin_shifteastingnorthings        r   lon_lat_to_easting_northingr4    s   8 )dE]++ (HY''	(T5M** &8H%%57?L,&.G	Hh	7	7	7 ! !6FBMRU*U233
 
5!! ! ! ! ! ! ! ! ! ! ! ! ! ! ! Hs   A
C$$C(+C(c                    t          | t          t          f          rt          j        |           } t          |t          t          f          rt          j        |          }t          j        dz  }| dz  |z  }t          j        d          5  t          j        t          j        |t          j        z  |z                      dz  t          j        z  dz
  }ddd           n# 1 swxY w Y   ||fS )a.  
    Projects the given easting, northing values into
    longitude, latitude coordinates.

    easting and northing values are assumed to be in Web Mercator
    (aka Pseudo-Mercator or EPSG:3857) coordinates.

    Args:
        easting
        northing

    Returns:
        (longitude, latitude)
    r%  r&  r'  )r(  r+  r*  N)	r!   r"   r  r*   r   r,  r-  arctanexp)r2  r3  r1  r/  r0  s        r   easting_northing_to_lon_latr8    s     'D%=)) $(7##(T5M** &8H%%57?L%,.I	H	%	%	%  9F8be#l233
 
E               hs   A
C##C'*C'r	  r   )FF).r  r   typesr   r   r   r   r   r*   pandasrD   r   	core.datar   core.dimensionr	   	core.utilr
   r   r   r(   r.   r1   r3   rO   ri   rz   r    r{   r   r   r[   rq   r   r  r   r  r  r   r,   r   r?   r   r  r4  r8  r   r   r   <module>r>     s    



 R R R R R R R R R R R R          ' ' ' ' ' ' & & & & & & I I I I I I I I I I  ,& & & &$. . . ."? ? ? ? ? ? ? ?*? ? ? ? ? ? ? ?$    :    B 72v 
:bgDD6 6 6 6
 :eD:bk""	BJ			BH		( ( ( j&&
 *L$TT"&\\^
 ^
 ^
 ^
 ^
 ^
 ^
 ^
B& & & & &S & & &R"2 "2 "2 "2 "2S "2 "2 "2J' ' 'T    r   