3
���h�� �
@ s< d dl mZ d dlZd dlZd dlZd dlZd dlZddl m
Z
ddl m Z ddl m Z ddl m
Z
ddlmZmZmZmZ dd l mZmZmZ d dlZyd dljZW n ek
r� Y nX d"d d
�Z dd� Z dd� Z d#dd�Z dd� Z G dd� de
j!e
j"�Z#e j$e#� G dd� de#�Z%dd� Z&d d � Z'd d � Z(d d!� Z)dS )$� )� timedeltaN� )�common)�indexing)�ops)�utils)�
basestring� OrderedDict�zip�dask_array_type)�PandasIndexAdapter�orthogonally_indexable�LazyIntegerRangeTFc C s |rt | d�r| j} t| ttjf�s�t | d�rnt | d�sBt | d�rnt| jt| d| j�t| dd�t| dd��} n�t| t �r�y t| � } W q� t
k
r� t
d��Y q�X nPt j | �r�tg | �} n:t| d d�dk r�t| j
| �} n |dk r�t|| �} nt
d
��n|�r| jd d �} | S )
a� Convert an object into an Variable
- If the object is already an `Variable`, return it.
- If the object is a `DataArray`, return it if `strict=False` or return
its variable if `strict=True`.
- Otherwise, if the object has 'dims' and 'data' attributes, convert
it into a new `Variable`.
- If all else fails, attempt to convert the object into an `Variable` by
unpacking it into the arguments for `Variable.__init__`.
�variable�dims�data�values�attrsN�encodingz(cannot convert argument into an Variable�namez cannot infer Variable dimensionsF)�deep)�hasattrr �
isinstance�Variable�xr� DataArrayr �getattrr �tuple� TypeErrorr Z is_scalarr �copy)�obj�key�strictr � r# �4/tmp/pip-build-5_djhm0z/xray/xarray/core/variable.py� as_variable s.
r% c C s t | t|��S )zo
This is equivalent to np.arange(size), but waits to create the array until
its actually accessed.
)�
Coordinater )�dim�sizer# r# r$ �default_index_coordinateB s r) c C s t | tj�rt| �S | S )z�
Put pandas.Index and numpy.ndarray arguments in adapter objects to ensure
they can be indexed properly.
NumpyArrayAdapter, PandasIndexAdapter and LazilyIndexedArray should
all pass through unmodified.
)r �pd�Indexr )r r# r# r$ �_maybe_wrap_dataJ s r, c C s� |r t | dd�dkr t| �S t| t�r*| S t| tj�r>t| �S t| t�rRtj| �} t| tj �rlt
j | j d�} t| t
�r�t
jt | d| �d�} t| d� s�t| d� s�t| t
jt
jt
j t
jf�r�t
j| �} t | d| �} t| t
jj��r*t
jj| �}|j� �r tj| j�\}}t
j| |d�} || |< n
t
j| �} t| t
j��r�| jjd k�rRtj | �} n6| jjd
k�rnt
j| d �} n| jjd k�r�t
j| d
�} t| �S )a� Prepare and wrap data to put in a Variable.
- If data does not have the necessary attributes, convert it to ndarray.
- If data has dtype=datetime64, ensure that it has ns precision. If it's a
pandas.Timestamp, convert it to datetime64.
- If data is already a pandas or xarray object (other than an Index), just
use the values.
Finally, wrap it up with an adapter if necessary.
�ndimr �ns�value�dtype�shaper )r0 �O�Mzdatetime64[ns]�mztimedelta64[ns]) r r, r r r* r+ r r Ztuple_to_0darrayZ Timestamp�np�
datetime64r/ r � timedelta64r Zstring_Zunicode_�asarray�maZ MaskedArrayZ getmaskarray�anyr �_maybe_promoter0 �ndarray�kindZ_possibly_convert_objects)r �fastpath�maskr0 �
fill_valuer# r# r$ �as_compatible_dataW s@
rA c C s` t j| �} | jdkr\| jjdkr*| j� } n2| jjdkrDt j| d�} n| jjdkr\t j| d�} | S )a Return the given values as a numpy array, or as an individual item if
it's a 0-dimensional object array or datetime64.
Importantly, this function does not copy data if it is already an ndarray -
otherwise, it will not be possible to update Variable values in place.
r r2 r3 r. r4 )r5 r8 r- r0 r= �itemr6 r7 )r r# r# r$ �_as_array_or_item� s
rC c @ sb e Zd ZdZdudd�Zedd� �Zedd � �Zed
d � �Zed d
� �Z edd� �Z
e
j dd� �Z
dd� Z edd� �Z
dd� Zdd� Zdd� Zedd � �Zej d d � �Zd d � Zd d!� Zd"d#� Zed$d%� �Zd&d'� Zej d(d%� �Zd)d*� Zd+d,� Zd-d.� Zed/d0� �Zej d1d0� �Zed2d3� �Zej d4d3� �Zdvd6d7�Z d8d9� Z dwd:d;�Z dZ ed<d=� �Z e!j"� Z#dxd>d?�Z$d@dA� Z%dBdC� Z&dDdE� Z'dFdG� Z(dHdI� Z)dJdK� Z*dydLdM�Z+dzdNdO�Z,dPdQ� Z-dRdS� Z.dTdU� Z/dVdW� Z0dXdY� Z1dZd[� Z2d{d\d]�Z3e4d|d_d`��Z5dadb� Z6dcdd� Z7dedf� Z8dgdh� Z9edidj� �Z:edkdl� �Z;d}dmdn�Z<e=dodp� �Z>e=d~dqdr��Z?e=dsdt� �Z@dS )r a� A netcdf-like variable consisting of dimensions, data and attributes
which describe a single Array. A single Variable object is not fully
described outside the context of its parent Dataset (if you want such a
fully described object, use a DataArray instead).
The main functional difference between Variables and numpy arrays is that
numerical operations on Variables implement array broadcasting by dimension
name. For example, adding an Variable with dimensions `('time',)` to
another Variable with dimensions `('space',)` results in a new Variable
with dimensions `('time', 'space')`. Furthermore, numpy reduce operations
like ``mean`` or ``sum`` are overwritten to take a "dimension" argument
instead of an "axis".
Variables are light-weight objects used as the building block for datasets.
They are more primitive objects, so operations with them provide marginally
higher performance than using DataArrays. However, manipulating data in the
form of a Dataset or DataArray should almost always be preferred, because
they can use more complete metadata in context of coordinate labels.
NFc C sF t ||d�| _| j|�| _d| _d| _|dk r4|| _|dk rB|| _dS )a�
Parameters
----------
dims : str or sequence of str
Name(s) of the the data dimension(s). Must be either a string (only
for 1D data) or a sequence of strings with length equal to the
number of dimensions.
data : array_like
Data array which supports numpy-like data access.
attrs : dict_like or None, optional
Attributes to assign to the new variable. If None (default), an
empty attribute dictionary is initialized.
encoding : dict_like or None, optional
Dictionary specifying how to encode this array's data into a
serialized format like netCDF4. Currently used keys (for netCDF)
include '_FillValue', 'scale_factor', 'add_offset' and 'dtype'.
Well behaviored code to serialize a Variable should ignore
unrecognized encoding items.
)r> N)rA �_data�_parse_dimensions�_dims�_attrs� _encodingr r )�selfr r r r r> r# r# r$ �__init__� s zVariable.__init__c C s | j jS )N)rD r0 )rI r# r# r$ r0 � s zVariable.dtypec C s | j jS )N)rD r1 )rI r# r# r$ r1 � s zVariable.shapec C s | j | jj S )N)r( r0 �itemsize)rI r# r# r$ �nbytes� s zVariable.nbytesc C s t | jtjtf�S )N)r rD r5 r< r )rI r# r# r$ �
_in_memory� s zVariable._in_memoryc C s t | jt�r| jS | jS d S )N)r rD r r )rI r# r# r$ r � s z
Variable.datac C s& t |�}|j| jkr td��|| _d S )Nz0replacement data must match the Variable's shape)rA r1 �
ValueErrorrD )rI r r# r# r$ r � s
c C s& t | jtjtf�s tj| j�| _| jS )N)r rD r5 r< r r8 )rI r# r# r$ � _data_cached� s zVariable._data_cachedc C s
t | j�S )N)r
rD )rI r# r# r$ �_indexable_data s zVariable._indexable_datac C s | j � | S )aA Manually trigger loading of this variable's data from disk or a
remote source into memory and return this variable.
Normally, it should not be necessary to call this method in user code,
because all xarray functions should either work on deferred data or
load data automatically.
)rO )rI r# r# r$ �load s z
Variable.loadc C s t jdtdd� | j� S )NzGthe Variable method `load_data` has been deprecated; use `load` instead� )�
stacklevel)�warnings�warn�
FutureWarningrQ )rI r# r# r$ � load_data s
zVariable.load_datac C s | j � | jS )z7Always cache data as an in-memory array before pickling)rO �__dict__)rI r# r# r$ � __getstate__ s zVariable.__getstate__c C s t | j� �S )z&The variable's data as a numpy.ndarray)rC rO )rI r# r# r$ r s zVariable.valuesc C s
|| _ d S )N)r )rI r r# r# r$ r " s c C s t | j| j| j| jdd�S )z.Return this variable as a base xarray.VariableT)r r> )r r rD rG rH )rI r# r# r$ � to_variable& s zVariable.to_variablec C s t | j| j| j| jdd�S )z,Return this variable as an xarray.CoordinateT)r r> )r& r rD rG rH )rI r# r# r$ �to_coord+ s zVariable.to_coordc C s | j � j� S )z'Convert this variable to a pandas.Index)r[ �to_index)rI r# r# r$ r\ 0 s zVariable.to_indexc C s | j S )zITuple of dimension names with which this variable is associated.
)rF )rI r# r# r$ r 4 s z
Variable.dimsc C s< t |t�r|f}t|�}t|�| jkr8td|| jf ��|S )NzQdimensions %s must have the same length as the number of data dimensions, ndim=%s)r r r �lenr- rN )rI r r# r# r$ rE : s
zVariable._parse_dimensionsc C s | j |�| _d S )N)rE rF )rI r/ r# r# r$ r D s c s* t j� �r"t� fdd�| jD ��S � S d S )Nc 3 s | ]}� j |td ��V qd S )N)�get�slice)�.0r' )r! r# r$ � <genexpr>J s z.Variable._item_key_to_tuple.<locals>.<genexpr>)r � is_dict_liker r )rI r! r# )r! r$ �_item_key_to_tupleH s
zVariable._item_key_to_tuplec C s� | j |�}tj|| j�}tdd� t|| j�D ��}| j| }t|d�rh|jt |�ks�t
|jt |�f��nt |�dks�t
t |���t | �||| j | j
dd�S )a
Return a new Array object whose contents are consistent with
getting the provided key from the underlying data.
NB. __getitem__ and __setitem__ implement "orthogonal indexing" like
netCDF4-python, where the key can only include integers, slices
(including `Ellipsis`) and 1d arrays, each of which are applied
orthogonally along their respective dimensions.
The difference does not matter in most cases unless you are using
numpy's "fancy indexing," which can otherwise result in data arrays
whose shapes is inconsistent (or just uninterpretable with) with the
variable's dimensions.
If you really want to do indexing like `x[x > 0]`, manipulate the numpy
array `x.values` directly.
c s s& | ] \}}t |ttjf�s|V qd S )N)r �intr5 �integer)r` �kr' r# r# r$ ra a s z'Variable.__getitem__.<locals>.<genexpr>r- r T)r> )rc r Zexpanded_indexerr- r r
r rP r r] �AssertionError�typerG rH )rI r! r r r# r# r$ � __getitem__N s
"zVariable.__getitem__c C s6 | j |�}t| jt�r td��t| j� �}|||< dS )z�__setitem__ is overloaded to access the underlying numpy values with
orthogonal indexing.
See __getitem__ for more details.
z�this variable's data is stored in a dask array, which does not support item assignment. To assign to this variable, you must first load it into memory explicitly using the .load_data() method or accessing its .values attribute.N)rc r rD r r r
rO )rI r! r/ r r# r# r$ � __setitem__l s
zVariable.__setitem__c C s | j dkrt� | _ | j S )z9Dictionary of local attributes on this variable.
N)rG r )rI r# r# r$ r | s
zVariable.attrsc C s t |�| _d S )N)r rG )rI r/ r# r# r$ r � s c C s | j dkri | _ | j S )z2Dictionary of encodings on this variable.
N)rH )rI r# r# r$ r � s
zVariable.encodingc C s0 yt |�| _W n tk
r* td��Y nX d S )Nz)encoding must be castable to a dictionary)�dictrH rN )rI r/ r# r# r$ r � s Tc C s@ |r t | jt� r | jj� }n| j}t| �| j|| j| jdd�S )z�Returns a copy of this object.
If `deep=True`, the data array is loaded into memory and copied onto
the new object. Dimensions, attributes and encodings are always copied.
T)r> ) r r r r rD rh r rG rH )rI r r r# r# r$ r � s
z
Variable.copyc C s | j dd�S )NF)r )r )rI r# r# r$ �__copy__� s zVariable.__copy__c C s | j dd�S )NT)r )r )rI �memor# r# r$ � __deepcopy__� s zVariable.__deepcopy__c C s t | jdd�S )zYBlock dimensions for this array's data or None if it's not a dask
array.
�chunksN)r rD )rI r# r# r$ ro � s zVariable.chunksc s� ddl j}tj� �r.t�fdd�� j� D ��� � dkrB�jp@�j� �j}t ||j
�r`|j � �}n8tj� �r�t � fdd�t
�j�D ��� |j|� ||d�}t���j|�j�jdd�S ) a� Coerce this array's data into a dask arrays with the given chunks.
If this variable is a non-dask array, it will be converted to dask
array. If it's a dask array, it will be rechunked to the given chunk
sizes.
If neither chunks is not provided for one or more dimensions, chunk
sizes along that dimension will not be updated; non-dask arrays will be
converted into dask arrays with a single block.
Parameters
----------
chunks : int, tuple or dict, optional
Chunk sizes along each dimension, e.g., ``5``, ``(5, 5)`` or
``{'x': 5, 'y': 5}``.
name : str, optional
Used to generate the name for this array in the internal dask
graph. Does not need not be unique.
lock : optional
Passed on to :py:func:`dask.array.from_array`, if the array is not
already as dask array.
Returns
-------
chunked : xarray.Variable
r Nc 3 s | ]\}}� j |�|fV qd S )N)� get_axis_num)r` r' �chunk)rI r# r$ ra � s z!Variable.chunk.<locals>.<genexpr>c 3 s | ]\}}� j ||�V qd S )N)r^ )r` �n�s)ro r# r$ ra � s )r �lockT)r> )�
dask.array�arrayr rb rk �itemsro r1 rD r �Array�rechunkr � enumerateZ
from_arrayrh r rG rH )rI ro r rt �dar r# )ro rI r$ rq � s
zVariable.chunkc sj � fdd�|D �}|r"t d| ��td�g� j }x*t� j�D ] \}}||kr>|| ||< q>W � t|� S )al Return a new array indexed along the specified dimension(s).
Parameters
----------
**indexers : {dim: indexer, ...}
Keyword arguments with names matching dimensions and values given
by integers, slice objects or arrays.
Returns
-------
obj : Array object
A new Array with the selected data and dimensions. In general,
the new variable's data will be a view of this variable's data,
unless numpy fancy indexing was triggered by using an array
indexer, in which case the data will be a copy.
c s g | ]}|� j kr|�qS r# )r )r` rf )rI r# r$ �
<listcomp>� s z!Variable.isel.<locals>.<listcomp>zdimensions %r do not existN)rN r_ r- rz r r )rI Zindexers�invalidr! �ir' r# )rI r$ �isel� s z
Variable.iselc C s( | j |�}|dkr td | �}n |dk r6t| d �}ntd �}| td �f| |f j}tj| j�\}}t| j�}tt |�|| �||< t
|t �r�t|j �} || f| |< t
jtj| d�}
ntj}
|
|||d�} |dkr�| |g} n|| g} tj| |�}
t
|
t ��r|
j| jj �}
t| �| j|
| jdd�S )Nr )ro )r0 T)r> )rp r_ r r r; r0 �listr1 �min�absr r ro � functools�partialr{ �fullr5 r � concatenatery rh r rG )rI r' �count�axisZkeepZ trimmed_datar0 r@ r1 ro r� Znans�arraysr r# r# r$ �_shift_one_dim s.
zVariable._shift_one_dimc K s* | }x |j � D ]\}}|j||�}qW |S )a�
Return a new Variable with shifted data.
Parameters
----------
**shifts : keyword arguments of the form {dim: offset}
Integer offset to shift along each of the given dimensions.
Positive offsets shift to the right; negative offsets shift to the
left.
Returns
-------
shifted : Variable
Variable with the same dimensions and attributes but shifted data.
)rw r� )rI �shifts�resultr' r� r# r# r$ �shift0 s zVariable.shiftc s� �j |�� |�j� ; }|dkr:t| d �td | �g}n
td �g}� �fdd�|D �}tj|� �}t|t�r||j�jj �}t
���j |�j dd�S )Nr c s& g | ] }�t d �f� |f j�qS )N)r_ r )r` �idx)r� rI r# r$ r| N s z*Variable._roll_one_dim.<locals>.<listcomp>T)r> )
rp r1 r_ r r� r r ry r ro rh r rG )rI r' r� �indicesr� r r# )r� rI r$ �
_roll_one_dimE s
zVariable._roll_one_dimc K s* | }x |j � D ]\}}|j||�}qW |S )a�
Return a new Variable with rolld data.
Parameters
----------
**shifts : keyword arguments of the form {dim: offset}
Integer offset to roll along each of the given dimensions.
Positive offsets roll to the right; negative offsets roll to the
left.
Returns
-------
shifted : Variable
Variable with the same dimensions and attributes but rolled data.
)rw r� )rI r� r� r' r� r# r# r$ �roll[ s z
Variable.rollc G sN t |�dkr | jddd� }| j|�}tj| j|�}t| �||| j| jdd�S )a� Return a new Variable object with transposed dimensions.
Parameters
----------
*dims : str, optional
By default, reverse the dimensions. Otherwise, reorder the
dimensions to this order.
Returns
-------
transposed : Variable
The returned object has transposed data and dimensions with the
same attributes as the original.
Notes
-----
Although this operation returns a view of this variable's data, it is
not lazy -- the data will be fully loaded.
See Also
--------
numpy.transpose
r Nr T)r> ���) r] r rp r � transposer rh rG rH )rI r Zaxesr r# r# r$ r� p s
zVariable.transposec C s t t| j| j��}tj| ||�S )a� Return a new Variable object with squeezed data.
Parameters
----------
dim : None or str or tuple of str, optional
Selects a subset of the length one dimensions. If a dimension is
selected with length greater than one, an error is raised. If
None, all length one dimensions are squeezed.
Returns
-------
squeezed : Variable
This array, but with with all or a subset of the dimensions of
length 1 removed.
Notes
-----
Although this operation returns a view of this variable's data, it is
not lazy -- the data will be fully loaded.
See Also
--------
numpy.squeeze
)rk r
r r1 r �squeeze)rI r' r r# r# r$ r� � s zVariable.squeezec s� t |t�r|g}|dkr*tj|�r*|j� }t| j�t|� }|rHtd��t| j��t�fdd�|D ��| j }|dk r�t t
||��� � fdd�|D �}t j | j
|�}n| j
d t|�| j }t||| j| jdd�}|j|� S )
a� Return a new variable with expanded dimensions.
When possible, this operation does not copy this variable's data.
Parameters
----------
dims : str or sequence of str or dict
Dimensions to include on the new variable. If a dict, values are
used to provide the sizes of new dimensions; otherwise, new
dimensions are inserted with length 1.
Returns
-------
Variable
Nz8new dimensions must be a superset of existing dimensionsc 3 s | ]}|� kr|V qd S )Nr# )r` �d)� self_dimsr# r$ ra � s z'Variable.expand_dims.<locals>.<genexpr>c s g | ] }� | �qS r# r# )r` r� )�dims_mapr# r$ r| � s z(Variable.expand_dims.<locals>.<listcomp>T)r> )N)r r r rb r �setr rN r rk r
r Z broadcast_tor r] r- r rG rH r� )rI r r1 Z missing_dimsZ
expanded_dimsZ tmp_shapeZ
expanded_dataZ expanded_varr# )r� r� r$ � expand_dims� s&
zVariable.expand_dimsc s� t � �t | j�ks td� ��|| jkr0td��t� �dkrH| jdd�S � fdd�| jD �}|t� � }| j|� }|jd t|�� d }|jj |�}|jd t|�� |f }t
||| j | j d d
�S )
Nz invalid existing dimensions: %szIcannot create a new dimension with the same name as an existing dimensionr F)r c s g | ]}|� kr|�qS r# r# )r` r� )r r# r$ r| � s z(Variable._stack_once.<locals>.<listcomp>r T)r> r� )r� )
r� r rN r] r r� r� r1 r �reshaper rG rH ) rI r �new_dim�
other_dims� dim_order� reordered� new_shape�new_data�new_dimsr# )r r$ � _stack_once� s
zVariable._stack_oncec K s* | }x |j � D ]\}}|j||�}qW |S )as
Stack any number of existing dimensions into a single new dimension.
New dimensions will be added at the end, and the order of the data
along each new dimension will be in contiguous (C) order.
Parameters
----------
**dimensions : keyword arguments of the form new_name=(dim1, dim2, ...)
Names of new dimensions, and the existing dimensions that they
replace.
Returns
-------
stacked : Variable
Variable with the same attributes but stacked data.
See also
--------
Variable.unstack
)rw r� )rI �
dimensionsr� r� r r# r# r$ �stack� s zVariable.stackc s� t |j� �}t |j� �}� | jkr.td� ��t|�j| j�rFtd��| j� �}tj |�| j
| krltd��� fdd�| jD �}|� g }| j |� }|j
d t |�� | } |j
j| �}
|jd t |�� | } t| |
| j| jdd�S )Nz invalid existing dimension: %szIcannot create a new dimension with the same name as an existing dimensionzOthe product of the new dimension sizes must equal the size of the old dimensionc s g | ]}|� kr|�qS r# r# )r` r� )�old_dimr# r$ r| s z*Variable._unstack_once.<locals>.<listcomp>T)r> )r �keysr r rN r� � intersectionrp r5 �prodr1 r� r] r r� r rG rH ) rI r r� Z
new_dim_namesZ
new_dim_sizesr� r� r� r� r� r� r� r# )r� r$ �
_unstack_once s"
zVariable._unstack_oncec K s* | }x |j � D ]\}}|j||�}qW |S )au
Unstack an existing dimension into multiple new dimensions.
New dimensions will be added at the end, and the order of the data
along each new dimension will be in contiguous (C) order.
Parameters
----------
**dimensions : keyword arguments of the form old_dim={dim1: size1, ...}
Names of existing dimensions, and the new dimensions and sizes that they
map to.
Returns
-------
unstacked : Variable
Variable with the same attributes but unstacked data.
See also
--------
Variable.stack
)rw r� )rI r� r� r� r r# r# r$ �unstack s zVariable.unstackc C s
| j |�S )N)Z_fillna)rI r/ r# r# r$ �fillna; s zVariable.fillnac C s
| j |�S )N)Z_where)rI Zcondr# r# r$ �where> s zVariable.wherec
s� |dk r|dk rt d��|dk r*| j|�}||r6| jn| jfd|i|��}|dkr\t| j�ntj|�| j � � fdd�t| j �D �}|r�| j
nd} t ||| d�S )a� Reduce this array by applying `func` along some dimension(s).
Parameters
----------
func : function
Function which can be called in the form
`func(x, axis=axis, **kwargs)` to return the result of reducing an
np.ndarray over an integer valued axis.
dim : str or sequence of str, optional
Dimension(s) over which to apply `func`.
axis : int or sequence of int, optional
Axis(es) over which to apply `func`. Only one of the 'dim'
and 'axis' arguments can be supplied. If neither are supplied, then
the reduction is calculated over the flattened array (by calling
`func(x)` without an axis argument).
keep_attrs : bool, optional
If True, the variable's attributes (`attrs`) will be copied from
the original object to the new one. If False (default), the new
object will be returned without attributes.
**kwargs : dict
Additional keyword arguments passed on to `func`.
Returns
-------
reduced : Array
Array with summarized data and the indicated dimension(s)
removed.
Nz-cannot supply both 'axis' and 'dim' argumentsr� c s g | ]\}}|� kr|�qS r# r# )r` rr r' )� removed_axesr# r$ r| i s z#Variable.reduce.<locals>.<listcomp>)r ) rN rp r r �ranger- r5 Z
atleast_1drz r rG r )
rI �funcr' r� Z
keep_attrsZ
allow_lazy�kwargsr r r r# )r� r$ �reduceA s
zVariable.reduce�
concat_dimc C s� t |t�s|j\}t|�}|d }dd� |D �}||jkrt|j|�}|j}|dkrbtj||d�} q�tj|||d�} n d}|f|j }tj||d�} t |j
�}
|s�x.|D ]&} | j|jkr�t d��t j
|
| j
� q�W | || |
�S )ao Concatenate variables along a new or existing dimension.
Parameters
----------
variables : iterable of Array
Arrays to stack together. Each variable is expected to have
matching dimensions and shape except for along the stacked
dimension.
dim : str or DataArray, optional
Name of the dimension to stack along. This can either be a new
dimension name, in which case it is added along axis=0, or an
existing dimension name, in which case the location of the
dimension is unchanged. Where to insert the new dimension is
determined by the first variable.
positions : None or list of integer arrays, optional
List of integer arrays which specifies the integer positions to which
to assign each dataset along the concatenated dimension. If not
supplied, objects are concatenated in the provided order.
shortcut : bool, optional
This option is used internally to speed-up groupby operations.
If `shortcut` is True, some checks of internal consistency between
arrays to concatenate are skipped.
Returns
-------
stacked : Variable
Concatenated Variable formed by stacking all the supplied variables
along the given dimension.
r c S s g | ]
}|j �qS r# )r )r` �vr# r# r$ r| � s z#Variable.concat.<locals>.<listcomp>N)r� zinconsistent dimensions)r r r r� rp r r� Zinterleaved_concatr� r r rN r Zremove_incompatible_items) �cls� variablesr' Z positionsZshortcutZ first_varr� r� r r r �varr# r# r$ �concatp s*
zVariable.concatc C s | j |j kptj| j|j�S )N)rD r Z array_equivr )rI �otherr# r# r$ � _data_equals� s zVariable._data_equalsc C s@ t |d|�}y| j|jko"| j|�S ttfk
r: dS X dS )aP True if two Variables have the same dimensions and values;
otherwise False.
Variables can still be equal (like pandas objects) if they have NaN
values in the same locations.
This method is necessary because `v1 == v2` for Variables
does element-wise comparisions (like numpy.ndarrays).
r FN)r r r� r �AttributeError)rI r� r# r# r$ �equals� s
zVariable.equalsc C s6 yt | |�\} }W n ttfk
r* dS X | j|�S )z�True if two Variables have the values after being broadcast against
each other; otherwise False.
Variables can still be equal (like pandas objects) if they have NaN
values in the same locations.
F)�broadcast_variablesrN r� r� )rI r� r# r# r$ �broadcast_equals� s
zVariable.broadcast_equalsc C s8 yt j| j|j�o| j|�S ttfk
r2 dS X dS )z1Like equals, but also checks attributes.
FN)r Z
dict_equivr r� r r� )rI r� r# r# r$ � identical� s
zVariable.identicalc C s t | �| j| jj| j�S )N)rh r r �realrG )rI r# r# r$ r� � s z
Variable.realc C s t | �| j| jj| j�S )N)rh r r �imagrG )rI r# r# r$ r� � s z
Variable.imagc C s t | j|�S )N)r r )rI r �contextr# r# r$ �__array_wrap__� s zVariable.__array_wrap__c s t j� �� fdd��}|S )Nc s | j � | jf|�|��S )N)r� r )rI �argsr� )�fr# r$ r� � s z Variable._unary_op.<locals>.func)r� �wraps)r� r� r# )r� r$ � _unary_op� s zVariable._unary_opc s t j� �� �fdd��}|S )Nc sL t |tjtjf�rtS t| |�\}}}�s4� ||�n� ||�}t||�}|S )N)r r r �Dataset�NotImplemented�_broadcast_compat_datar )rI r� � self_data�
other_datar r� r� )r� � reflexiver# r$ r� � s
z!Variable._binary_op.<locals>.func)r� r� )r� r� Zignored_kwargsr� r# )r� r� r$ �
_binary_op� s
zVariable._binary_opc s t j� �� fdd��}|S )Nc sF t |tj�rtd��t| |�\}}}|| jkr6td��� ||�| _| S )Nz+cannot add a Dataset to a Variable in-placez0dimensions cannot change for in-place operations)r r r� r r� r rN r )rI r� r� r� r )r� r# r$ r� � s
z)Variable._inplace_binary_op.<locals>.func)r� r� )r� r� r# )r� r$ �_inplace_binary_op� s
zVariable._inplace_binary_op)NNF)T)N)NNF)N)N)NNFF)r� NF)N)F)A�__name__�
__module__� __qualname__�__doc__rJ �propertyr0 r1 rL rM r �setterrO rP rQ rW rY r rZ r[ r\ r rE rc ri rj r r r rl rn �__hash__ro � itertoolsr� Z_array_counterrq r r� r� r� r� r� r� r� r� r� r� r� r� r� r� � classmethodr� r� r� r� r� r� r� r� � staticmethodr� r� r� r# r# r# r$ r � s�
0(
)
. ?
r c sv e Zd ZdZd� fdd� Zdd� Zdd � Zd
d � Zdd
d�Zdd� Z dd� Z
dd� Z e dd� �Z
e
jdd� �Z
� ZS )r& a� Wrapper around pandas.Index that adds xarray specific functionality.
The most important difference is that Coordinate objects must always have a
name, which is the dimension along which they index values.
Coordinates must always be 1-dimensional. In addition to Variable methods
and properties (attributes, encoding, broadcasting), they support some
pandas.Index methods directly (e.g., get_indexer), even though pandas does
not (yet) support duck-typing for indexes.
NFc s8 t t| �j|||||� | jdkr4tdt| �j ��d S )Nr z %s objects must be 1-dimensional)�superr& rJ r- rN rh r� )rI r r r r r> )� __class__r# r$ rJ s
zCoordinate.__init__c C s t | jt�st| j�| _| jS )N)r rD r )rI r# r# r$ rO s zCoordinate._data_cachedc C s\ | j |�}| j| }t|d� s*|jdkr<tf || j| j�S t| �| j|| j| jdd�S d S )Nr- r T)r> ) rc rP r r- r rG rH rh r )rI r! r r# r# r$ ri $ s
zCoordinate.__getitem__c C s t dt| �j ��d S )Nz %s values cannot be modified)r rh r� )rI r! r/ r# r# r$ rj - s zCoordinate.__setitem__Tc C s. |r t | �n| j}t| �| j|| j| jdd�S )z�Returns a copy of this object.
If `deep=True`, the values array is loaded into memory and copied onto
the new object. Dimensions, attributes and encodings are always copied.
T)r> )r rD rh r rG rH )rI r r r# r# r$ r 0 s zCoordinate.copyc C s | j � j|j � �S )N)r\ r� )rI r� r# r# r$ r� < s zCoordinate._data_equalsc C s | S )z,Return this variable as an xarray.Coordinater# )rI r# r# r$ r[ ? s zCoordinate.to_coordc C s4 | j dkst�| j� j}t|tj�s0|j| j�}|S )z'Convert this variable to a pandas.Indexr ) r- rg rO rv r r* Z
MultiIndexZ set_namesr )rI �indexr# r# r$ r\ C s
zCoordinate.to_indexc C s
| j d S )Nr )r )rI r# r# r$ r M s zCoordinate.namec C s t d��d S )Nz)cannot modify name of Coordinate in-place)r� )rI r/ r# r# r$ r Q s )NNF)T)r� r� r� r� rJ rO ri rj r r� r[ r\ r� r r� �
__classcell__r# r# )r� r$ r& s
r& c C s� t � }x�| D ]~}|j}tt|��t|�k r:tdt|� ��xNt||j�D ]>\}}||krb|||< qH|| |krHtd||| |ff ��qHW q W |S )Nz3broadcasting cannot handle duplicate dimensions: %rzRoperands cannot be broadcast together with mismatched lengths for dimension %r: %s)r r r] r� rN r� r
r1 )r� Zall_dimsr� Zvar_dimsr� rs r# r# r$ �
_unified_dimsV s
r� c s" t t| ��� t � fdd�| D ��S )Nc 3 s& | ] }|j � kr|j� �n|V qd S )N)r r� )r` r� )r r# r$ ra j s z._broadcast_compat_variables.<locals>.<genexpr>)r r� )r� r# )r r$ �_broadcast_compat_variablesh s r� c s( t | �� t� ��t� �fdd�| D ��S )a� Given any number of variables, return variables with matching dimensions
and broadcast data.
The data on the returned variables will be a view of the data on the
corresponding original arrays, but dimensions will be reordered and
inserted so that both broadcast arrays have the same dimensions. The new
dimensions are sorted in order of appearence in the first variable's
dimensions followed by the second variable's dimensions.
c 3 s& | ] }|j �kr|j� �n|V qd S )N)r r� )r` r� )r� �
dims_tupler# r$ ra z s z&broadcast_variables.<locals>.<genexpr>)r� r )r� r# )r� r� r$ r� n s
r� c sR t � fdd�dD ��r8t| � �\}}|j}|j}|j}n| j}� }| j}|||fS )Nc 3 s | ]}t � |�V qd S )N)r )r` �attr)r� r# r$ ra s z)_broadcast_compat_data.<locals>.<genexpr>r r r1 r )r r r1 r )�allr� r r )rI r� Znew_selfZ new_otherr� r� r r# )r� r$ r� ~ s
r� )NTF)F)*�datetimer r� r� rT Znumpyr5 Zpandasr* � r r r r Zpycompatr r r
r r r
r Zxarrayr ru rv r{ � ImportErrorr% r) r, rA rC Z
AbstractArrayZNdimSizeLenMixinr Z!inject_all_ops_and_reduce_methodsr& r� r� r� r� r# r# r# r$ �<module> sD
)
> e
J |