ó ¦–Õ\c@`sJddlmZmZmZddlmZddlZddlmZmZddl m Z ddl Z ddl m Z mZddlZddlmZmZmZddlZddlZddlZddlZddlZddlmZddlZddlZy<dd lmZmZmZm Z m!Z!dd l"m#Z#WnIe$k r“dd l%mZmZmZm Z m!Z!dd l&m#Z#nXdd l%m'Z'm(Z(m)Z)ddl*Z+d d l,m-Z-ddl,m.Z.ddl/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8ddl9m:Z:ddl;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZIddlJmKZKmLZLmMZMmNZNmOZOddlPmQZQddlRmRZRmSZSddl,mTZTmPZPddlUmUZUddlVmWZWddlXmYZYmZZZd dl[m\Z\m]Z]d dl^m_Z_m`Z`d dl6m6Z6e.jaiidd6d d!6d"6ƒeDd#ƒZbeDd$ƒZceDd%ƒZdebjeefe+jgfe+jhƒecjeefe+jgfe+jiƒedjeefe+jgfe+jjƒd&ekfd'„ƒYZlemend(„Zoemend)„Zpemend*„Zqd d+lrmsZsmtZtd,„Zueoenenevemend-„Zwenend.„Zxgd/„Zyd0end1„Zzd2„Z{d3„Z|d4„Z}emenemevd5„Z~d6„Zd7„Z€d8jƒZ‚d9e0fd:„ƒYZƒd;„Z„enenenend<„Z…end=„Z†d>„Z‡d?enevememend@„ZˆenenenendA„Z‰enenevemevdB„ZŠdC„Z‹endD„ZŒenenfidE„ZdF„ZŽdG„ZdH„ZevdI„Z‘devdJ„ZhdK„Z’dL„Z“dM„Z”emenevevendN„Z•endO„Z–dP„Z—dQ„Z˜dR„Z™dS„ZšdT„Z›dU„ZœdV„ZendW„Zžee+jŸƒdX„ƒZŸdY„Z dZ„Z”d[„Z¢d\„Z£d]„Z¤dd^„Z„dd_„Z¦d`„Z§da„ZØdb„Z©dc„ZŖdd„Z«de„Z¬df„Z­dg„Z®dh„ZÆdi„Z°dj„Z±ddk„Z²dldm„Z³dS(ni(tabsolute_importtdivisiontprint_function(tbisectN(tpartialtwraps(tproduct(tNumbertIntegral(taddtgetitemtmul(tLock(t partitiontconcattfirsttgroupbyt accumulate(tpluck(tmaptreducet frequenciesi(tchunki(tconfig(tDaskMethodsMixinttokenizet dont_optimizetcompute_as_if_collectiontpersisttis_dask_collection(tbroadcast_dimensionstsubs(t globalmethod(tndeepmaptignoringtconcretet is_integert IndexCallabletfuncnamet derived_fromtSerializableLocktDispatchtfactorst parse_bytest has_keywordtMtndimlist(tunicodet zip_longesttIterabletIteratortMapping(tquote(tdelayedtDelayed(tthreadedtcore(tsizeof(tHighLevelGraph(t get_mappertget_fs_token_paths(t _Recursert_make_sliced_dtype(t slice_arraytreplace_ellipsis(t blockwiset128MiBs chunk-sizeisrechunk-thresholdtarrayt concatenatet tensordotteinsumtPerformanceWarningcB`seZdZRS(s> A warning given when bad chunking may cause poor performance (t__name__t __module__t__doc__(((s.lib/python2.7/site-packages/dask/array/core.pyRGAscC`sĀt|tƒrntd„|Dƒƒrntd„|Dƒƒ}td„|Dƒƒ}t||d|d|ƒ|S|r|jƒnz&||}|r¦tj|ƒ}nWd|r½|jƒnX|S(Ncs`s|]}|dkVqdS(N(tNone(t.0tx((s.lib/python2.7/site-packages/dask/array/core.pys Fscs`s!|]}|dk r|VqdS(N(RK(RLRM((s.lib/python2.7/site-packages/dask/array/core.pys Gscs`s?|]5}t|tƒs|dkr*dn tddƒVqdS(N(t isinstanceRRKtslice(RLRM((s.lib/python2.7/site-packages/dask/array/core.pys Hstasarraytlock(RNttupletanytgettertacquiretnpRPtrelease(tatbRPRQtb2tb3tc((s.lib/python2.7/site-packages/dask/array/core.pyRTEs%    cC`st||d|d|ƒS(s A simple wrapper around ``getter``. Used to indicate to the optimization passes that the backend doesn't support fancy indexing. RPRQ(RT(RXRYRPRQ((s.lib/python2.7/site-packages/dask/array/core.pytgetter_nofancyXscC`st||d|d|ƒS(sÜ A getter function that optimizations feel comfortable inlining Slicing operations with this function may be inlined into a graph, such as in the following rewrite **Before** >>> a = x[:10] # doctest: +SKIP >>> b = a + 1 # doctest: +SKIP >>> c = a * 2 # doctest: +SKIP **After** >>> b = x[:10] + 1 # doctest: +SKIP >>> c = x[:10] * 2 # doctest: +SKIP This inlining can be relevant to operations when running off of disk. RPRQ(RT(RXRYRPRQ((s.lib/python2.7/site-packages/dask/array/core.pyt getter_inlineas(toptimizet fuse_slicecC`s‡g|D]#}tttd|d ƒƒ^q}t|Œ}t|Œ}gt||ƒD]+\}}td„t||ƒDƒƒ^qXS(s§ Translate chunks tuple to a set of slices in product order >>> slices_from_chunks(((2, 2), (3, 3, 3))) # doctest: +NORMALIZE_WHITESPACE [(slice(0, 2, None), slice(0, 3, None)), (slice(0, 2, None), slice(3, 6, None)), (slice(0, 2, None), slice(6, 9, None)), (slice(2, 4, None), slice(0, 3, None)), (slice(2, 4, None), slice(3, 6, None)), (slice(2, 4, None), slice(6, 9, None))] ii’’’’cs`s(|]\}}t|||ƒVqdS(N(RO(RLtstdim((s.lib/python2.7/site-packages/dask/array/core.pys ˆs(i(tlistRR RtzipRR(tchunkstbdstcumdimstshapeststartststarttshape((s.lib/python2.7/site-packages/dask/array/core.pytslices_from_chunkszs 0  c C`są|p |}t||d|ƒ}tt|gg|D]}tt|ƒƒ^q4Œƒ} t|ƒ} |tjk r«| s€|r«g| D]} ||| ||f^q‡} n"g| D]} ||| f^q²} tt | | ƒƒS(sž Dask getting various chunks from an array-like >>> getem('X', chunks=(2, 3), shape=(4, 6)) # doctest: +SKIP {('X', 0, 0): (getter, 'X', (slice(0, 2), slice(0, 3))), ('X', 1, 0): (getter, 'X', (slice(2, 4), slice(0, 3))), ('X', 1, 1): (getter, 'X', (slice(2, 4), slice(3, 6))), ('X', 0, 1): (getter, 'X', (slice(0, 2), slice(3, 6)))} >>> getem('X', chunks=((2, 2), (3, 3))) # doctest: +SKIP {('X', 0, 0): (getter, 'X', (slice(0, 2), slice(0, 3))), ('X', 1, 0): (getter, 'X', (slice(2, 4), slice(0, 3))), ('X', 1, 1): (getter, 'X', (slice(2, 4), slice(3, 6))), ('X', 0, 1): (getter, 'X', (slice(0, 2), slice(3, 6)))} tdtype( tnormalize_chunksRcRtrangetlenRltoperatorR tdictRd( tarrReR Rktout_nameRQRPRmRftkeystslicesRMtvalues((s.lib/python2.7/site-packages/dask/array/core.pytgetemŒs 7 +"cK`sR|rt||ƒ}n|r0t||ƒ}nttttj|||ƒƒS(s† Dot product of many aligned chunks >>> x = np.array([[1, 2], [1, 2]]) >>> y = np.array([[10, 20], [10, 20]]) >>> dotmany([x, x, x], [y, y, y]) array([[ 90, 180], [ 90, 180]]) Optionally pass in functions to apply to the left and right chunks >>> dotmany([x, x, x], [y, y, y], rightfunc=np.transpose) array([[150, 150], [150, 150]]) (RtsumRRVtdot(tAtBtleftfunct rightfunctkwargs((s.lib/python2.7/site-packages/dask/array/core.pytdotmany«s cC`s­t|tƒrt|ƒ}nt|ttfƒs7|St|ƒdkrug|D]}t|d|dƒ^qP}ntjtt |dd„ƒƒƒ}||d|dƒS(sß Recursively Concatenate nested lists of arrays along axes Each entry in axes corresponds to each level of the nested list. The length of axes should correspond to the level of nesting of arrays. >>> x = np.array([[1, 2], [3, 4]]) >>> _concatenate2([x, x], axes=[0]) array([[1, 2], [3, 4], [1, 2], [3, 4]]) >>> _concatenate2([x, x], axes=[1]) array([[1, 2, 1, 2], [3, 4, 3, 4]]) >>> _concatenate2([[x, x], [x, x]], axes=[0, 1]) array([[1, 2, 1, 2], [3, 4, 3, 4], [1, 2, 1, 2], [3, 4, 3, 4]]) Supports Iterators >>> _concatenate2(iter([x, x]), axes=[1]) array([[1, 2, 1, 2], [3, 4, 3, 4]]) itaxestkeycS`s|jS(N(t__array_priority__(RM((s.lib/python2.7/site-packages/dask/array/core.pytćttaxisi( RNR2RcRRRpt _concatenate2tconcatenate_lookuptdispatchttypetmax(tarraysRRXRD((s.lib/python2.7/site-packages/dask/array/core.pyR‡Įs,$RmcC`s:g|D]:}t|tƒr;tjd |jd|jƒn|^q}y,tjddƒ|||Ž}WdQXWn|tk rń}tj ƒ\} } } dj t j | ƒƒ} |rŹdj d|ƒnd} dj || t|ƒ| ƒ}nXd}|dk rt|ƒ‚n|dkr&|jStd „|DƒƒS( s‘ Tries to infer output dtype of ``func`` for a small set of input arguments. Parameters ---------- func: Callable Function for which output dtype is to be determined args: List of array like Arguments to the function, which would usually be used. Only attributes ``ndim`` and ``dtype`` are used. kwargs: dict Additional ``kwargs`` to the ``func`` funcname: String Name of calling function to improve potential error messages suggest_dtype: None/False or String If not ``None`` adds suggestion to potential error message to specify a dtype via the specified kwarg. Defaults to ``'dtype'``. nout: None or Int ``None`` if function returns single output, integer if many. Deafults to ``None``. Returns ------- : dtype or List of dtype One or many dtypes (depending on ``nout``) iRmtalltignoreNR…s@Please specify the dtype explicitly using the `{dtype}` kwarg. sv`dtype` inference failed in `{0}`. {1}Original error is below: ------------------------ {2} Traceback: --------- {3}cs`s|]}|jVqdS(N(Rm(RLte((s.lib/python2.7/site-packages/dask/array/core.pys s(i(RNtArrayRVtonestndimRmterrstatet Exceptiontsystexc_infotjoint tracebackt format_tbtformattreprRKt ValueErrorRR(tfunctargsRR&t suggest_dtypetnoutRMtoRtexc_typet exc_valuet exc_tracebackttbtsuggesttmsg((s.lib/python2.7/site-packages/dask/array/core.pytapply_infer_dtypeēs D cC`sŠt|ƒr|St|tƒr;tjd|ƒr;t|ƒSt|tƒrft|ƒdkrft|ƒSt|ƒdkr‚t|ƒS|SdS(s? Normalize user provided arguments to blockwise or map_blocks We do a few things: 1. If they are string literals that might collide with blockwise_token then we quote them 2. IF they are large (as defined by sizeof) then we put them into the graph on their own by using dask.delayed s_\d+i g€„.AN( RRNtstrtretmatchR5RcRpR9(RM((s.lib/python2.7/site-packages/dask/array/core.pyt normalize_arg s ! !  c#`s6 t|ƒs.d}t|t|ƒjƒ‚n|jdd ƒ}|jdd ƒ}|rntjdƒ|}nd|p€t|ƒt |||Žf}|jdd ƒ}|jdd ƒ}|jdgƒ‰|jd d ƒ‰i}t ˆt ƒr’ˆg‰nt ˆt ƒrˆg‰ng|D]} t | t ƒr!| ^q!} g|D]I} t | t ƒr†| t t| jƒƒd d d …fn | d f^qI} | rŠt ttd „| Dƒƒƒƒd d d …} nd#} t|d ƒrņd|d >> import dask.array as da >>> x = da.arange(6, chunks=3) >>> x.map_blocks(lambda x: x * 2).compute() array([ 0, 2, 4, 6, 8, 10]) The ``da.map_blocks`` function can also accept multiple arrays. >>> d = da.arange(5, chunks=2) >>> e = da.arange(5, chunks=2) >>> f = map_blocks(lambda a, b: a + b**2, d, e) >>> f.compute() array([ 0, 2, 6, 12, 20]) If the function changes shape of the blocks then you must provide chunks explicitly. >>> y = x.map_blocks(lambda x: x[::2], chunks=((2, 2),)) You have a bit of freedom in specifying chunks. If all of the output chunk sizes are the same, you can provide just that chunk size as a single tuple. >>> a = da.arange(18, chunks=(6,)) >>> b = a.map_blocks(lambda x: x[:3], chunks=(3,)) If the function changes the dimension of the blocks you must specify the created or destroyed dimensions. >>> b = a.map_blocks(lambda x: x[None, :, None], chunks=(1, 6, 1), ... new_axis=[0, 2]) If ``chunks`` is specified but ``new_axis`` is not, then it is inferred to add the necessary number of axes on the left. Map_blocks aligns blocks by block positions without regard to shape. In the following example we have two arrays with the same number of blocks but with different shape and chunk sizes. >>> x = da.arange(1000, chunks=(100,)) >>> y = da.arange(100, chunks=(10,)) The relevant attribute to match is numblocks. >>> x.numblocks (10,) >>> y.numblocks (10,) If these match (up to broadcasting rules) then we can map arbitrary functions across blocks >>> def func(a, b): ... return np.array([a.max(), b.max()]) >>> da.map_blocks(func, x, y, chunks=(2,), dtype='i8') dask.array >>> _.compute() array([ 99, 9, 199, 19, 299, 29, 399, 39, 499, 49, 599, 59, 699, 69, 799, 79, 899, 89, 999, 99]) Your block function get information about where it is in the array by accepting a special ``block_info`` keyword argument. >>> def func(block, block_info=None): ... pass This will receive the following information: >>> block_info # doctest: +SKIP {0: {'shape': (1000,), 'num-chunks': (10,), 'chunk-location': (4,), 'array-location': [(400, 500)]}, None: {'shape': (1000,), 'num-chunks': (10,), 'chunk-location': (4,), 'array-location': [(400, 500)], 'chunk-shape': (100,), 'dtype': dtype('float64')}} For each argument and keyword arguments that are dask arrays (the positions of which are the first index), you will receive the shape of the full array, the number of chunks of the full array in each dimension, the chunk location (for example the fourth chunk over in the first dimension), and the array location (for example the slice corresponding to ``40:50``). The same information is provided for the output, with the key ``None``, plus the shape and dtype that should be returned. These features can be combined to synthesize an array from scratch, for example: >>> def func(block_info=None): ... loc = block_info[None]['array-location'][0] ... return np.arange(loc[0], loc[1]) >>> da.map_blocks(func, chunks=((4, 4),), dtype=np.float_) dask.array >>> _.compute() array([0, 1, 2, 3, 4, 5, 6, 7]) You may specify the key name prefix of the resulting task in the graph with the optional ``token`` keyword argument. >>> x.map_blocks(lambda x: x + 1, name='increment') # doctest: +SKIP dask.array s~First argument must be callable function, not %s Usage: da.map_blocks(function, x) or: da.map_blocks(function, x, y, z)tnamettokens8The token= keyword to map_blocks has been moved to name=s%s-%sRmRet drop_axistnew_axisNi’’’’cs`s|]}|jVqdS(N(R’(RLRX((s.lib/python2.7/site-packages/dask/array/core.pys ćstblock_idt__block_id_dummy__t block_infot__block_info_dummy__t map_blocksc3`s'|]\}}|ˆkr|VqdS(N((RLtiRM(RÆ(s.lib/python2.7/site-packages/dask/array/core.pys ņsis-New_axis values do not fill in all dimensionstnew_axesRDt align_arraysis1Provided chunks have {0} dims, expected {1} dims.s>Dimension {0} has {1} blocks, chunks specified with {2} blocksc3`s'|]\}}|ˆkr|VqdS(N((RLR¶RM(R°(s.lib/python2.7/site-packages/dask/array/core.pys Bsc3`s5|]+\}}ˆˆ|dkr)|ndVqdS(iiN((RLtijtj(R¶t num_chunks(s.lib/python2.7/site-packages/dask/array/core.pys MsRks num-chunkssarray-locationschunk-locationc3`s&|]\}}ˆj||VqdS(N(Re(RLR¹Rŗ(tout(s.lib/python2.7/site-packages/dask/array/core.pys Yss chunk-shape((i(i(i(/tcallablet TypeErrorRŠRHtpopRKtwarningstwarnR&RRNRRRRRoR’R‹R,RØt enumerateRpRctsortedtinsertRœRAtTruetFalseRtdasktlayersR­RrtitemstcopytdskRt numblocksRšRdtappendRnt_chunksReRVtcumsumRk(#RRžRR§R­R®RmReR·RXtarrstargpairstout_indtoriginal_kwargstaxtnRĖtktvvtvR‚ttasktchunks2R\tnbRiRhtargt out_startstold_ktinfoRktarr_kR¹Rŗ((RÆR¶R°R»R¼s.lib/python2.7/site-packages/dask/array/core.pyRµ6sš   (  (S2   %0   $    !+ - - ) ) %  E  A  cG`s.|s dSt|ƒdkr$|dSttt|ƒƒ}g|D]}d|t|ƒ|^q@}g}x·t|ƒD]©}g|D]}||^q„}td„|Dƒƒr¹|}n%g|D]}|dkrĄ|^qĄ}tt|ƒƒdkrtdt|ƒƒ‚n|j|dƒqwWt |ƒS( s] Construct a chunks tuple that broadcasts many chunks tuples >>> a = ((5, 5),) >>> b = ((5, 5),) >>> broadcast_chunks(a, b) ((5, 5),) >>> a = ((10, 10, 10), (5, 5),) >>> b = ((5, 5),) >>> broadcast_chunks(a, b) ((10, 10, 10), (5, 5)) >>> a = ((10, 10, 10), (5, 5),) >>> b = ((1,), (5, 5),) >>> broadcast_chunks(a, b) ((10, 10, 10), (5, 5)) >>> a = ((10, 10, 10), (5, 5),) >>> b = ((3, 3,), (5, 5),) >>> broadcast_chunks(a, b) Traceback (most recent call last): ... ValueError: Chunks do not align: [(10, 10, 10), (3, 3)] iics`s|]}|dkVqdS(iN(i((RLR\((s.lib/python2.7/site-packages/dask/array/core.pys ‰ssChunks do not align: %s((i((i(i( RpR‹RRoRtsetRœR©RĶRR(tchunkssRÕR\tchunkss2tresultR¶tstep1tstep2((s.lib/python2.7/site-packages/dask/array/core.pytbroadcast_chunksgs + %c `s.t|tƒr$|g}|g}ntd„|DƒƒrItdƒ‚nt|ƒt|ƒkr†tdt|ƒt|ƒfƒ‚nt|tƒs”|d kr­|g}nt|ƒdkrät|ƒdkrä|t|ƒ9}nt|ƒt|ƒkr*tdt|ƒt|ƒt|ƒfƒ‚ntjg|D]}|j ƒ^q7Œ}tj |t t j g|D]}|jƒ^qkƒƒƒ}g|D]$}t||j|j|jƒ^q“} g} g} g} x~|D]v}t|tƒr$| j|jƒ| j|jƒƒ| j|j ƒƒqÖt|ƒr?tdƒ‚qÖ| j|ƒqÖWtj| Œ} tj | | ƒ} |o{| } gtt|ƒƒD]}ttjƒƒ^q‘}tjgt| | ||ƒD]0\}}}}t|||||| |ƒ^qĖŒ}t |jƒƒ}tj|| |ƒ}|rŃ|‰|rØg|D]}t||ƒ^qD}t||Ž}tjg|D]}|j ^q{Œ}t!|||ƒ‰nt‡fd†t||ƒDƒƒ}|Sdttjƒƒ}tji||6|ƒ}t||ƒ}|r&|j"|d S|Sd S( sŲ Store dask arrays in array-like objects, overwrite data in target This stores dask arrays into object that supports numpy-style setitem indexing. It stores values chunk by chunk so that it does not have to fill up memory. For best performance you can align the block size of the storage target with the block size of your array. If your data fits in memory then you may prefer calling ``np.array(myarray)`` instead. Parameters ---------- sources: Array or iterable of Arrays targets: array-like or Delayed or iterable of array-likes and/or Delayeds These should support setitem syntax ``target[10:20] = ...`` lock: boolean or threading.Lock, optional Whether or not to lock the data stores while storing. Pass True (lock each file individually), False (don't lock) or a particular ``threading.Lock`` object to be shared among all writes. regions: tuple of slices or list of tuples of slices Each ``region`` tuple in ``regions`` should be such that ``target[region].shape = source.shape`` for the corresponding source and target in sources and targets, respectively. If this is a tuple, the contents will be assumed to be slices, so do not provide a tuple of tuples. compute: boolean, optional If true compute immediately, return ``dask.delayed.Delayed`` otherwise return_stored: boolean, optional Optionally return the stored result (default False). Examples -------- >>> x = ... # doctest: +SKIP >>> import h5py # doctest: +SKIP >>> f = h5py.File('myfile.hdf5') # doctest: +SKIP >>> dset = f.create_dataset('/data', shape=x.shape, ... chunks=x.chunks, ... dtype='f8') # doctest: +SKIP >>> store(x, dset) # doctest: +SKIP Alternatively store many arrays at the same time >>> store([x, y, z], [dset1, dset2, dset3]) # doctest: +SKIP cs`s|]}t|tƒ VqdS(N(RNR(RLRa((s.lib/python2.7/site-packages/dask/array/core.pys Éss&All sources must be dask array objectss1Different number of sources [%d] and targets [%d]isCDifferent number of sources [%d] and targets [%d] than regions [%d]s5Targets must be either Delayed objects or array-likesc3`s4|]*\}}tˆd||j|jƒVqdS(s load-store-%sN(RReRm(RLRatt(tload_store_dsk(s.lib/python2.7/site-packages/dask/array/core.pys ssstore-N(#RNRRSRœRpRRRKR:tmerget__dask_graph__t__dask_optimize__RcR8tflattent __dask_keys__R­ReRmR6RĶR‚textendRR¾RoR©tuuidtuuid1Rdt insert_to_oocRuRRĒtretrieve_from_ooctcompute(tsourcesttargetsRQtregionsRōt return_storedRRt sources_dsktsources2ttargets2t targets_keyst targets_dskt load_storedt_ttoksRaRčtrttokt store_dskt store_keysRÖt store_dlydst store_dsk_2RäR­RĖ((Rés.lib/python2.7/site-packages/dask/array/core.pytstore“sx2   $((11    1L"%  cC`s|dkrtdƒ‚n|dkr6tdƒ‚ntjt|ƒƒs`tjt|ƒƒrytd||fƒ‚nttt|ƒƒstdƒ‚nttt|ƒƒsĮtdƒ‚nt tt |ƒƒ}t tt |ƒƒ}t d„t ||ƒDƒƒS(s” >>> blockdims_from_blockshape((10, 10), (4, 3)) ((4, 4, 2), (3, 3, 3, 1)) >>> blockdims_from_blockshape((10, 0), (4, 0)) ((4, 4, 2), (0,)) s$Must supply chunks= keyword arguments#Must supply shape= keyword arguments4Array chunk sizes are unknown. shape: %s, chunks: %ss!chunks can only contain integers.s shape can only contain integers.cs`sM|]C\}}|rA|f||||r:||fndndVqdS(iN((i((RLtdtbd((s.lib/python2.7/site-packages/dask/array/core.pys 1sN( RKR¾RVtisnanRyRœRRR$RRtintRd(RkRe((s.lib/python2.7/site-packages/dask/array/core.pytblockdims_from_blockshapes  * cC`sb|st|ƒS|}x?t|ttfƒrWt|ƒdkrJt|ƒS|d}qWt|ƒS(Nii(t concatenate3RNRRRcRptunpack_singleton(tresultstresults2((s.lib/python2.7/site-packages/dask/array/core.pytfinalize6s  sŃ You must specify a chunks= keyword argument. This specifies the chunksize of your array blocks. See the following documentation page for details: https://docs.dask.org/en/latest/array-creation.html#chunks RcB`s…eZdZd‰ZdŠd„Zd„Zd„Zd „Zd „Z d „Z e e d d de ƒZeejƒZd„Zd„Zed„ƒZed„ƒZed„ƒZed„ƒZed„ƒZd„Zd„ZeeedƒZd„Zd„Zd„Z ed„ƒZ!ed„ƒZ"ed„ƒZ#ed„ƒZ$ed „ƒZ%e%j&d!„ƒZ%d"Z'dŠd#„Z(d$„Z)ed%„ƒZ*e+e,ƒd&„ƒZ,d'„Z-dŠdŠd(„Z.d)„Z/e/Z0d*„Z1d+„Z2e2Z3d,„Z4d-„Z5d.„Z6d/„Z7d0„Z8ed1„ƒZ9d2„Z:ed3„ƒZ;e<e=j>ƒd4„ƒZ?ed5„ƒZ@ed6„ƒZAe<e=j>ƒd7„ƒZBe<e=j>ƒd8„ƒZCeCZDe<e=j>ƒd9„ƒZEe<e=j>ƒd:„ƒZFd;dŠd<„ZGd;dŠd=„ZHd>„ZId?„ZJd@„ZKdA„ZLdB„ZMdC„ZNdD„ZOdE„ZPdF„ZQdG„ZRdH„ZSdI„ZTdJ„ZUdK„ZVdL„ZWdM„ZXdN„ZYdO„ZZdP„Z[dQ„Z\dR„Z]dS„Z^dT„Z_dU„Z`dV„ZadW„ZbdX„ZcdY„ZddZ„Zed[„Zfd\„Zgd]„Zhd^„Zid_„Zjd`„Zkda„Zldb„Zmdc„Zndd„Zoe<e=j>ƒdŠepdŠdŠde„ƒZqe<e=j>ƒdŠepdŠdŠdf„ƒZre<e=j>ƒdŠepdŠdŠdg„ƒZse<e=j>ƒdŠepdŠdŠdh„ƒZte<e=j>ƒdŠdŠdŠdi„ƒZue<e=j>ƒdŠdŠdŠdj„ƒZve<e=j>ƒdŠdŠepdŠdŠdk„ƒZwe<e=j>ƒdldldmdŠdn„ƒZxe<e=j>ƒdŠdŠepdŠdŠdo„ƒZye<e=j>ƒdŠdŠepdŠdŠdp„ƒZze<e=j>ƒdŠdŠepdldŠdŠdq„ƒZ{e<e=j>ƒdŠdŠepdldŠdŠdr„ƒZ|dŠdŠepdldŠdŠds„Z}e+e~ƒdt„ƒZ~dŠedu„Z€dŠdŠdv„ZdŠdŠdw„Z‚e<e=j>ƒdŠdx„ƒZƒdŠdŠdy„Z„edz„ƒZ…ed{„ƒZ†d|„Z‡e<e=j>ƒdŠdŠd}„ƒZˆd~d„Z‰e<e=j>ƒd€„ƒZŠe<e=j>ƒdld„ƒZ‹d‚„ZŒdƒ„Zed„„ZŽe<e=j>ƒdŠd…„ƒZe<e=j>ƒd†„ƒZd‡„Z‘dˆ„Z’RS(‹s Parallel Dask Array A parallel nd-array comprised of many numpy arrays arranged in a grid. This constructor is for advanced uses only. For normal use see the ``da.from_array`` function. Parameters ---------- dask : dict Task dependency graph name : string Name of array in dask shape : tuple of ints Shape of the entire array chunks: iterable of tuples block sizes along each dimension See Also -------- dask.array.from_array RĒt_namet _cached_keysRĪRmc C`stt|ƒj|ƒ}t|tƒs-t‚t|tƒsWtj||ddƒ}n||_||_ |dkr„t dƒ‚nt j |ƒ|_ t||d|j ƒ|_|jdkrĻt tƒ‚nx;tjddƒD]'}||ƒ}|dk rā|}qāqāW|S(Nt dependenciess'You must specify the dtype of the arrayRmt array_plugins(((tsuperRt__new__RNR3tAssertionErrorR:tfrom_collectionsRĒR­RKRœRVRmRnRĪtCHUNKS_NONE_ERROR_MESSAGERtget( tclsRĒR­ReRmRktselftpluginRä((s.lib/python2.7/site-packages/dask/array/core.pyRes"      cC`s"t|j|j|j|jffS(N(RRĒR­ReRm(R((s.lib/python2.7/site-packages/dask/array/core.pyt __reduce__{scC`s|jS(N(RĒ(R((s.lib/python2.7/site-packages/dask/array/core.pyRė~scC`s |jfS(N(R­(R((s.lib/python2.7/site-packages/dask/array/core.pyt__dask_layers__sc`s_|jdk r|jS|j|j|j‰‰‰‡‡‡‡fd†‰ˆƒ|_}|S(Nc`sšˆsˆfgSt|ƒ}|dtˆƒkrfgtˆ|ƒD]}ˆf||f^qC}n0gtˆ|ƒD]}ˆ||fŒ^qw}|S(Ni(RpRo(RžtindR¶Rä(ReRuR­RĢ(s.lib/python2.7/site-packages/dask/array/core.pyRuŠs  40(RRKR­ReRĢ(RRä((ReRuR­RĢs.lib/python2.7/site-packages/dask/array/core.pyRī„s  cC`s|jS(N(R­(R((s.lib/python2.7/site-packages/dask/array/core.pyt__dask_tokenize__—sR‚tarray_optimizetfalseycC`s tdfS(N((R(R((s.lib/python2.7/site-packages/dask/array/core.pyt__dask_postcompute__žscC`st|j|j|jffS(N(RR­ReRm(R((s.lib/python2.7/site-packages/dask/array/core.pyt__dask_postpersist__”scC`sttt|jƒƒS(N(RRRRpRe(R((s.lib/python2.7/site-packages/dask/array/core.pyRĢ¤scC`stt|jdƒS(Ni(RR RĢ(R((s.lib/python2.7/site-packages/dask/array/core.pyt npartitionsØscC`sttt|jƒƒS(N(RRRRyRe(R((s.lib/python2.7/site-packages/dask/array/core.pyRk¬scC`std„|jDƒƒS(Ncs`s|]}t|ƒVqdS(N(R‹(RLR\((s.lib/python2.7/site-packages/dask/array/core.pys ²s(RRRe(R((s.lib/python2.7/site-packages/dask/array/core.pyt chunksize°scC`stjddd|jƒS(NRkRm((RVtemptyRm(R((s.lib/python2.7/site-packages/dask/array/core.pyt_meta“scC`s|jS(N(RĪ(R((s.lib/python2.7/site-packages/dask/array/core.pyt _get_chunksøscC`stdt|ƒƒ‚dS(NsSCan not set chunks directly Please use the rechunk method instead: x.rechunk(%s)(R¾R©(RRe((s.lib/python2.7/site-packages/dask/array/core.pyt _set_chunks»sschunks propertycC`s)|jstdƒ‚nt|jdƒS(Nslen() of unsized objecti(ReR¾Ry(R((s.lib/python2.7/site-packages/dask/array/core.pyt__len__Ās c O`s||jddƒ}x1||D]%}t|tjttfƒstSqW|dkr|tjkr~ddlm}|||ŽS|j dk r³ddl m }|||j ||ŽS|j dkr ddlm} yt| |jƒ} Wntk rütSX| ||ŽSt|||ŽSn[|dkrtddlm} yt| |jƒ} Wntk rctSX| j||ŽStSdS( NR¼t__call__i(tmatmul(t apply_gufunc(tufunctouter((RRNRVtndarrayRRtNotImplementedR/troutinest signatureRKtgufuncR0R R…R1tgetattrRHtAttributeErrortelemwiseR2( Rt numpy_ufunctmethodtinputsRR¼RMR/R0R1tda_ufunc((s.lib/python2.7/site-packages/dask/array/core.pyt__array_ufunc__Ēs<      cC`sBt|jƒ}|jjddƒd}d||j|j|fS(s® >>> import dask.array as da >>> da.ones((10, 10), chunks=(5, 5), dtype='i4') dask.array<..., shape=(10, 10), dtype=int32, chunksize=(5, 5)> t-iis0dask.array<%s, shape=%s, dtype=%s, chunksize=%s>(R©R(R­trsplitRkRm(RR(R­((s.lib/python2.7/site-packages/dask/array/core.pyt__repr__ėscC`s t|jƒS(N(RpRk(R((s.lib/python2.7/site-packages/dask/array/core.pyR’÷scC`stt|jdƒS(s Number of elements in array i(RR Rk(R((s.lib/python2.7/site-packages/dask/array/core.pytsizeūscC`s|j|jjS(s Number of bytes in array (RCRmtitemsize(R((s.lib/python2.7/site-packages/dask/array/core.pytnbytesscC`s |jjS(s& Length of one array element in bytes (RmRD(R((s.lib/python2.7/site-packages/dask/array/core.pyRDscC`s|jS(N(R(R((s.lib/python2.7/site-packages/dask/array/core.pyR­ scC`s||_d|_dS(N(RRKR(Rtval((s.lib/python2.7/site-packages/dask/array/core.pyR­s i cK`s[|jƒ}|r3|j|kr3|j|ƒ}nt|tjƒsWtj|ƒ}n|S(N(RōRmtastypeRNRVR3RC(RRmRRM((s.lib/python2.7/site-packages/dask/array/core.pyt __array__s  cC`sddlj}xF|jjdƒdD].}yt||ƒ}Wq&tk rStSXq&Wt||jƒsntSt||jƒ}||krtS|||ŽS(Nit.i( t dask.arrayRCRItsplitR8R9R4thasattrRH(RRttypesRžRtmodulet submoduletda_func((s.lib/python2.7/site-packages/dask/array/core.pyt__array_function__s   cC`stS(N(R:(R((s.lib/python2.7/site-packages/dask/array/core.pyt _elemwise,scK`s;t|g|g|}|jdtƒr7|d}n|S(NRųi(RRRĘ(RttargetRR((s.lib/python2.7/site-packages/dask/array/core.pyR0s cK`st||||S(sd Store array in HDF5 file >>> x.to_hdf5('myfile.hdf5', '/x') # doctest: +SKIP Optionally provide arguments as though to ``h5py.File.create_dataset`` >>> x.to_hdf5('myfile.hdf5', '/x', compression='lzf', shuffle=True) # doctest: +SKIP See Also -------- da.store h5py.File.create_dataset (tto_hdf5(RtfilenametdatapathR((s.lib/python2.7/site-packages/dask/array/core.pyRT9scC`s&ddlm}||d|d|ƒS(sm Convert dask Array to dask Dataframe Parameters ---------- columns: list or string list of column names if DataFrame, single string if Series index : dask.dataframe.Index, optional An optional *dask* Index to use for the output Series or DataFrame. The default output index depends on whether the array has any unknown chunks. If there are any unknown chunks, the output has ``None`` for all the divisions (one per chunk). If all the chunks are known, a default index with known divsions is created. Specifying ``index`` can be useful if you're conforming a Dask Array to an existing dask Series or DataFrame, and you would like the indices to match. See Also -------- dask.dataframe.from_dask_array i(tfrom_dask_arraytcolumnstindex(t dataframeRW(RRXRYRW((s.lib/python2.7/site-packages/dask/array/core.pytto_dask_dataframeIscC`sA|jdkr-tdj|jjƒƒ‚nt|jƒƒSdS(Nis>The truth value of a {0} is ambiguous. Use a.any() or a.all().(RCRœRšt __class__RHtboolRō(R((s.lib/python2.7/site-packages/dask/array/core.pyt__bool__cs cC`s2|jdkrtdƒ‚n||jƒƒSdS(Nis7Only length-1 arrays can be converted to Python scalars(RCR¾Rō(Rt cast_type((s.lib/python2.7/site-packages/dask/array/core.pyt _scalarfuncmscC`s |jtƒS(N(R`R (R((s.lib/python2.7/site-packages/dask/array/core.pyt__int__tscC`s |jtƒS(N(R`tfloat(R((s.lib/python2.7/site-packages/dask/array/core.pyt __float__yscC`s |jtƒS(N(R`tcomplex(R((s.lib/python2.7/site-packages/dask/array/core.pyt __complex__|scC`s¬ddlm}t|tƒr’t|tƒrL|jdkrLtdƒ‚n||||ƒ}|j|_|j|_|j|_|j |_ |St dt |ƒƒ‚dS(Ni(twheres+boolean index array should have 1 dimensions%Item assignment with %s not supported( R5RfRNRR’RœRmRĒR­ReRĪtNotImplementedErrorRŠ(RR‚tvalueRfty((s.lib/python2.7/site-packages/dask/array/core.pyt __setitem__s    c C`slt|ttfƒs@t|tƒr|rtd„|Dƒƒrt|ttfƒre|j|}nt|j|ƒ}|jrķtt|j |j t |jƒƒƒ}|j t d„|jDƒƒ}|j t|d|jd|d|ƒS|j t|d|ƒSnt|t ƒs!|f}nddlm}m}m}|||jƒ}|jh} x0|D](} t| tƒrb| j| jƒqbqbWtd„|Dƒƒr¼|||ƒ\}}ntd „|Dƒƒrź|||ƒ\}}ntd „|Dƒƒr|Sd t||ƒ} t| |j|j |ƒ\} }tj| | d |gƒ} t| | |d|jƒS( Ncs`s$|]}t|ttfƒVqdS(N(RNR©R/(RLR¶((s.lib/python2.7/site-packages/dask/array/core.pys ’scs`s|]}|fVqdS(N((RLR¶((s.lib/python2.7/site-packages/dask/array/core.pys šsRmReR°i(tnormalize_indextslice_with_int_dask_arraytslice_with_bool_dask_arraycs`s0|]&}t|tƒo'|jjdkVqdS(tiuN(RNRRmtkind(RLR¶((s.lib/python2.7/site-packages/dask/array/core.pys «scs`s-|]#}t|tƒo$|jtkVqdS(N(RNRRmR](RLR¶((s.lib/python2.7/site-packages/dask/array/core.pys ­scs`s0|]&}t|tƒo'|tdƒkVqdS(N(RNRORK(RLR¶((s.lib/python2.7/site-packages/dask/array/core.pys °ssgetitem-R(RNR©R/RcRRmR>RkRoR’RpReRRRµR tbasetslicingRkRlRmR­RR RSRR?R:R(RRYtdtR°ReRkRlRmtindex2RR¶R¼RĖtgraph((s.lib/python2.7/site-packages/dask/array/core.pyt __getitem__Žs< (     !cC`sŖt|tƒs|f}ntd„|DƒƒrItdj|ƒƒ‚ntd„|Dƒƒrtd„t||jƒDƒƒr…|Stdj|ƒƒ‚nt||ŒS(Ncs`s|]}|dkVqdS(N(RK(RLRÖ((s.lib/python2.7/site-packages/dask/array/core.pys ¼ss?vindex does not support indexing with None (np.newaxis), got {}cs`s|]}t|tƒVqdS(N(RNRO(RLRÖ((s.lib/python2.7/site-packages/dask/array/core.pys Ąscs`s<|]2\}}|j|ƒtd|ƒj|ƒkVqdS(iN(tindicesRO(RLRÖR((s.lib/python2.7/site-packages/dask/array/core.pys Įss®vindex requires at least one non-slice to vectorize over when the slices are not over the entire array (i.e, x[:]). Use normal slicing instead when only using slices. Got: {}( RNRRRSt IndexErrorRšRRdRkt_vindex(RR‚((s.lib/python2.7/site-packages/dask/array/core.pyRx¹s  cC`s t|jƒS(sTVectorized indexing with broadcasting. This is equivalent to numpy's advanced indexing, using arrays that are broadcast against each other. This allows for pointwise indexing: >>> x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) >>> x = from_array(x, chunks=2) >>> x.vindex[[0, 1, 2], [0, 1, 2]].compute() array([1, 5, 9]) Mixed basic/advanced indexing with slices/arrays is also supported. The order of dimensions in the result follows those proposed for ndarray.vindex [1]_: the subspace spanned by arrays is followed by all slices. Note: ``vindex`` provides more general functionality than standard indexing, but it also has fewer optimizations and can be significantly slower. _[1]: https://github.com/numpy/numpy/pull/6256 (R%Rx(R((s.lib/python2.7/site-packages/dask/array/core.pytvindexĖsc`srddlm}t|tƒs+|f}ntd„|DƒƒdkrVtdƒ‚ntd„|Dƒƒr{tdƒ‚n|||jƒ}td„|Dƒƒ}dt||ƒ‰t j |j ƒd t ƒ|‰td „t |j|ƒDƒƒ}ttg|D]}tt|ƒƒ^qŒƒ}‡‡fd †|Dƒ}tjˆ|d |gƒ}t|ˆ||jƒS( Ni(Rkcs`s'|]}t|tjtfƒVqdS(N(RNRVR3Rc(RLR!((s.lib/python2.7/site-packages/dask/array/core.pys čss!Can only slice with a single listcs`s|]}|dkVqdS(N(RK(RLR!((s.lib/python2.7/site-packages/dask/array/core.pys źss0Slicing with np.newaxis or None is not supportedcs`s7|]-}t|tƒr+t||dƒn|VqdS(iN(RNRRO(RLRÖ((s.lib/python2.7/site-packages/dask/array/core.pys ķssblocks-Rmcs`s4|]*\}}ttj|ƒ|jƒƒVqdS(N(RRRVRCttolist(RLR\R¶((s.lib/python2.7/site-packages/dask/array/core.pys ōsc`s0i|]&}tˆ|jƒƒˆf|“qS((RRRz(RLR‚(R­tnew_keys(s.lib/python2.7/site-packages/dask/array/core.pys łs R(RqRkRNRRRyRœRSRĢRRVRCRītobjectRdReRcRRoRpR:RRRm(RRYRkReR\RutlayerRt((R­R{s.lib/python2.7/site-packages/dask/array/core.pyt_blocksäs$    1cC`s t|jƒS(sƒ Slice an array by blocks This allows blockwise slicing of a Dask array. You can perform normal Numpy-style slicing but now rather than slice elements of the array you slice along blocks so, for example, ``x.blocks[0, ::2]`` produces a new dask array with every other block in the first row of blocks. You can index blocks in any way that could index a numpy array of shape equal to the number of blocks in each dimension, (available as array.numblocks). The dimension of the output array will be the same as the dimension of this array, even if integer indices are passed. This does not support slicing with ``np.newaxis`` or multiple lists. Examples -------- >>> import dask.array as da >>> x = da.arange(10, chunks=2) >>> x.blocks[0].compute() array([0, 1]) >>> x.blocks[:3].compute() array([0, 1, 2, 3, 4, 5]) >>> x.blocks[::2].compute() array([0, 1, 4, 5, 8, 9]) >>> x.blocks[[-1, 0]].compute() array([8, 9, 0, 1]) Returns ------- A Dask array (R%R~(R((s.lib/python2.7/site-packages/dask/array/core.pytblocksžs cC`s=ddlm}|||d|jdf|jdffƒS(Ni(RERi(R5RER’(RtotherRE((s.lib/python2.7/site-packages/dask/array/core.pyRz s cC`s|S(N((R((s.lib/python2.7/site-packages/dask/array/core.pyR{&scC`s |jƒS(N(t transpose(R((s.lib/python2.7/site-packages/dask/array/core.pytT*scG`saddlm}|sd}n2t|ƒdkrQt|dtƒrQ|d}n||d|ƒS(Ni(RiR(R5RRKRpRNR1(RRR((s.lib/python2.7/site-packages/dask/array/core.pyR.s  % cC`sddlm}||ƒS(Ni(travel(R5Rƒ(RRƒ((s.lib/python2.7/site-packages/dask/array/core.pyRƒ7scC`sddlm}|||ƒS(Ni(tchoose(R5R„(RtchoicesR„((s.lib/python2.7/site-packages/dask/array/core.pyR„>scG`sPddlm}t|ƒdkrCt|dtƒ rC|d}n|||ƒS(Ni(treshapei(R†RpRNR(RRkR†((s.lib/python2.7/site-packages/dask/array/core.pyR†Cs& i’’’’cC`s)ddlm}|||d|d|ƒS(sFThe top k elements of an array. See ``da.topk`` for docstringi(ttopkR†t split_every(t reductionsR‡(RRÖR†RˆR‡((s.lib/python2.7/site-packages/dask/array/core.pyR‡JscC`s)ddlm}|||d|d|ƒS(sXThe indices of the top k elements of an array. See ``da.argtopk`` for docstringi(targtopkR†Rˆ(R‰RŠ(RRÖR†RˆRŠ((s.lib/python2.7/site-packages/dask/array/core.pyRŠQscK`sÉt|ƒddh}|r:tdjt|ƒƒƒ‚n|jddƒ}tj|ƒ}|j|krn|Stj|j|d|ƒsŖtdj|j||ƒƒ‚n|jt j d|d||S(s÷Copy of the array, cast to a specified type. Parameters ---------- dtype : str or dtype Typecode or data-type to which the array is cast. casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional Controls what kind of data casting may occur. Defaults to 'unsafe' for backwards compatibility. * 'no' means the data types should not be cast at all. * 'equiv' means only byte-order changes are allowed. * 'safe' means only casts which can preserve values are allowed. * 'same_kind' means only safe casts or casts within a kind, like float64 to float32, are allowed. * 'unsafe' means any data conversions may be done. copy : bool, optional By default, astype always returns a newly allocated array. If this is set to False and the `dtype` requirement is satisfied, the input array is returned instead of a copy. tcastingRŹs;astype does not take the following keyword arguments: {0!s}tunsafesACannot cast array from {0!r} to {1!r} according to the rule {2!r}Rmt astype_dtype( RįR¾RšRcRRVRmtcan_castRµRRG(RRmRtextraR‹((s.lib/python2.7/site-packages/dask/array/core.pyRGXs  cC`sttj|ƒS(N(R:Rqtabs(R((s.lib/python2.7/site-packages/dask/array/core.pyt__abs__scC`sttj||ƒS(N(R:RqR (RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__add__‚scC`sttj||ƒS(N(R:RqR (RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__radd__…scC`sttj||ƒS(N(R:Rqtand_(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__and__ˆscC`sttj||ƒS(N(R:RqR”(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__rand__‹scC`sttj||ƒS(N(R:Rqtdiv(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__div__ŽscC`sttj||ƒS(N(R:RqR—(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__rdiv__‘scC`sttj||ƒS(N(R:Rqteq(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__eq__”scC`sttj||ƒS(N(R:Rqtgt(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__gt__—scC`sttj||ƒS(N(R:Rqtge(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__ge__šscC`sttj|ƒS(N(R:Rqtinvert(R((s.lib/python2.7/site-packages/dask/array/core.pyt __invert__scC`sttj||ƒS(N(R:Rqtlshift(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt __lshift__ scC`sttj||ƒS(N(R:RqR¢(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt __rlshift__£scC`sttj||ƒS(N(R:Rqtlt(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__lt__¦scC`sttj||ƒS(N(R:Rqtle(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__le__©scC`sttj||ƒS(N(R:Rqtmod(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__mod__¬scC`sttj||ƒS(N(R:RqR©(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__rmod__ÆscC`sttj||ƒS(N(R:RqR (RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__mul__²scC`sttj||ƒS(N(R:RqR (RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__rmul__µscC`sttj||ƒS(N(R:Rqtne(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__ne__øscC`sttj|ƒS(N(R:Rqtneg(R((s.lib/python2.7/site-packages/dask/array/core.pyt__neg__»scC`sttj||ƒS(N(R:Rqtor_(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__or__¾scC`s|S(N((R((s.lib/python2.7/site-packages/dask/array/core.pyt__pos__ĮscC`sttj||ƒS(N(R:RqR²(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__ror__ÄscC`sttj||ƒS(N(R:Rqtpow(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__pow__ĒscC`sttj||ƒS(N(R:RqR¶(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__rpow__ŹscC`sttj||ƒS(N(R:Rqtrshift(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt __rshift__ĶscC`sttj||ƒS(N(R:RqR¹(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt __rrshift__ŠscC`sttj||ƒS(N(R:Rqtsub(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__sub__ÓscC`sttj||ƒS(N(R:RqR¼(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__rsub__ÖscC`sttj||ƒS(N(R:Rqttruediv(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt __truediv__ŁscC`sttj||ƒS(N(R:RqRæ(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt __rtruediv__ÜscC`sttj||ƒS(N(R:Rqtfloordiv(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt __floordiv__ßscC`sttj||ƒS(N(R:RqRĀ(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt __rfloordiv__āscC`sttj||ƒS(N(R:Rqtxor(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__xor__åscC`sttj||ƒS(N(R:RqRÅ(RR€((s.lib/python2.7/site-packages/dask/array/core.pyt__rxor__čscC`sddlm}|||ƒS(Ni(R/(R5R/(RR€R/((s.lib/python2.7/site-packages/dask/array/core.pyt __matmul__ėscC`sddlm}|||ƒS(Ni(R/(R5R/(RR€R/((s.lib/python2.7/site-packages/dask/array/core.pyt __rmatmul__ļsc C`s2ddlm}||d|d|d|d|ƒS(Ni(RSR†tkeepdimsRˆR¼(R‰RS(RR†RŹRˆR¼RS((s.lib/python2.7/site-packages/dask/array/core.pyRSósc C`s2ddlm}||d|d|d|d|ƒS(Ni(RR†RŹRˆR¼(R‰R(RR†RŹRˆR¼R((s.lib/python2.7/site-packages/dask/array/core.pyRłsc C`s2ddlm}||d|d|d|d|ƒS(Ni(tminR†RŹRˆR¼(R‰RĖ(RR†RŹRˆR¼RĖ((s.lib/python2.7/site-packages/dask/array/core.pyRĖ’sc C`s2ddlm}||d|d|d|d|ƒS(Ni(R‹R†RŹRˆR¼(R‰R‹(RR†RŹRˆR¼R‹((s.lib/python2.7/site-packages/dask/array/core.pyR‹scC`s,ddlm}||d|d|d|ƒS(Ni(targminR†RˆR¼(R‰RĢ(RR†RˆR¼RĢ((s.lib/python2.7/site-packages/dask/array/core.pyRĢ scC`s,ddlm}||d|d|d|ƒS(Ni(targmaxR†RˆR¼(R‰RĶ(RR†RˆR¼RĶ((s.lib/python2.7/site-packages/dask/array/core.pyRĶsc C`s8ddlm}||d|d|d|d|d|ƒS(Ni(RyR†RmRŹRˆR¼(R‰Ry(RR†RmRŹRˆR¼Ry((s.lib/python2.7/site-packages/dask/array/core.pyRysiic C`s2ddlm}||d|d|d|d|ƒS(Ni(ttracetoffsettaxis1taxis2Rm(R‰RĪ(RRĻRŠRŃRmRĪ((s.lib/python2.7/site-packages/dask/array/core.pyRĪsc C`s8ddlm}||d|d|d|d|d|ƒS(Ni(tprodR†RmRŹRˆR¼(R‰RŅ(RR†RmRŹRˆR¼RŅ((s.lib/python2.7/site-packages/dask/array/core.pyRŅ!sc C`s8ddlm}||d|d|d|d|d|ƒS(Ni(tmeanR†RmRŹRˆR¼(R‰RÓ(RR†RmRŹRˆR¼RÓ((s.lib/python2.7/site-packages/dask/array/core.pyRÓ(scC`s>ddlm}||d|d|d|d|d|d|ƒS( Ni(tstdR†RmRŹtddofRˆR¼(R‰RŌ(RR†RmRŹRÕRˆR¼RŌ((s.lib/python2.7/site-packages/dask/array/core.pyRŌ/s!cC`s>ddlm}||d|d|d|d|d|d|ƒS( Ni(tvarR†RmRŹRÕRˆR¼(R‰RÖ(RR†RmRŹRÕRˆR¼RÖ((s.lib/python2.7/site-packages/dask/array/core.pyRÖ6s!c C`sAddlm}|||d|d|d|d|d|d|ƒS( sBCalculate the nth centralized moment. Parameters ---------- order : int Order of the moment that is returned, must be >= 2. axis : int, optional Axis along which the central moment is computed. The default is to compute the moment of the flattened array. dtype : data-type, optional Type to use in computing the moment. For arrays of integer type the default is float64; for arrays of float types it is the same as the array type. keepdims : bool, optional If this is set to True, the axes which are reduced are left in the result as dimensions with size one. With this option, the result will broadcast correctly against the original array. ddof : int, optional "Delta Degrees of Freedom": the divisor used in the calculation is N - ddof, where N represents the number of elements. By default ddof is zero. Returns ------- moment : ndarray References ---------- .. [1] Pebay, Philippe (2008), "Formulas for Robust, One-Pass Parallel Computation of Covariances and Arbitrary-Order Statistical Moments" (PDF), Technical Report SAND2008-6212, Sandia National Laboratories i(tmomentR†RmRŹRÕRˆR¼(R‰R×( RtorderR†RmRŹRÕRˆR¼R×((s.lib/python2.7/site-packages/dask/array/core.pyR×=s$cO`st||||ŽS(N(Rµ(RRRžR((s.lib/python2.7/site-packages/dask/array/core.pyRµescK`s)ddlm}|||||||S(sź Map a function over blocks of the array with some overlap We share neighboring zones between blocks of the array, then map a function, then trim away the neighboring strips. Parameters ---------- func: function The function to apply to each extended block depth: int, tuple, or dict The number of elements that each block should share with its neighbors If a tuple or dict then this can be different per axis boundary: str, tuple, dict How to handle the boundaries. Values include 'reflect', 'periodic', 'nearest', 'none', or any constant value like 0 or np.nan trim: bool Whether or not to trim ``depth`` elements from each block after calling the map function. Set this to False if your mapping function already does this for you **kwargs: Other keyword arguments valid in ``map_blocks`` Examples -------- >>> x = np.array([1, 1, 2, 3, 3, 3, 2, 1, 1]) >>> x = from_array(x, chunks=5) >>> def derivative(x): ... return x - np.roll(x, 1) >>> y = x.map_overlap(derivative, depth=1, boundary=0) >>> y.compute() array([ 1, 0, 1, 1, 0, 0, -1, -1, 0]) >>> import dask.array as da >>> x = np.arange(16).reshape((4, 4)) >>> d = da.from_array(x, chunks=(2, 2)) >>> d.map_overlap(lambda x: x + x.size, depth=1).compute() array([[16, 17, 18, 19], [20, 21, 22, 23], [24, 25, 26, 27], [28, 29, 30, 31]]) >>> func = lambda x: x + x.size >>> depth = {0: 1, 1: 1} >>> boundary = {0: 'reflect', 1: 'none'} >>> d.map_overlap(func, depth, boundary).compute() # doctest: +NORMALIZE_WHITESPACE array([[12, 13, 14, 15], [16, 17, 18, 19], [20, 21, 22, 23], [24, 25, 26, 27]]) i(t map_overlap(toverlapRŁ(RRtdepthtboundaryttrimRRŁ((s.lib/python2.7/site-packages/dask/array/core.pyRŁis5cC`s&ddlm}||||d|ƒS(s See da.cumsum for docstring i(RĻR¼(R‰RĻ(RR†RmR¼RĻ((s.lib/python2.7/site-packages/dask/array/core.pyRĻ”scC`s&ddlm}||||d|ƒS(s See da.cumprod for docstring i(tcumprodR¼(R‰RŽ(RR†RmR¼RŽ((s.lib/python2.7/site-packages/dask/array/core.pyRŽ¦scC`sddlm}|||ƒS(Ni(tsqueeze(R5Rß(RR†Rß((s.lib/python2.7/site-packages/dask/array/core.pyRß«scC`s#ddlm}|||||ƒS(s See da.rechunk for docstring i(trechunk(R…Rą(RRet thresholdtblock_size_limitRą((s.lib/python2.7/site-packages/dask/array/core.pyRą°scC`sddlm}||ƒS(Ni(treal(R1Rć(RRć((s.lib/python2.7/site-packages/dask/array/core.pyRćµscC`sddlm}||ƒS(Ni(timag(R1Rä(RRä((s.lib/python2.7/site-packages/dask/array/core.pyRäŗscC`sddlm}||ƒS(Ni(tconj(R1Rå(RRå((s.lib/python2.7/site-packages/dask/array/core.pyRåæscC`s ddlm}||||ƒS(Ni(tclip(R1Rę(RRĖR‹Rę((s.lib/python2.7/site-packages/dask/array/core.pyRęĆstCc `sÓtj|ƒ}|jj|j‰|dkrb|jd t‡fd†|jdDƒƒf}nL|dkr¢t‡fd†|jdDƒƒf|jd}n tdƒ‚|jtj|d |d |d |ƒS( sŠ Get a view of the array as a new data type Parameters ---------- dtype: The dtype by which to view the array order: string 'C' or 'F' (Fortran) ordering This reinterprets the bytes of the array under a new dtype. If that dtype does not have the same size as the original array then the shape will change. Beware that both numpy and dask.array can behave oddly when taking shape-changing views of arrays under Fortran ordering. Under some versions of NumPy this function will fail when taking shape-changing views of Fortran ordered arrays if the first dimension has chunks of size one. Rēi’’’’c3`s|]}t|ˆƒVqdS(N(t ensure_int(RLR\(tmult(s.lib/python2.7/site-packages/dask/array/core.pys ąstFc3`s|]}t|ˆƒVqdS(N(Rč(RLR\(Ré(s.lib/python2.7/site-packages/dask/array/core.pys ćsiisOrder must be one of 'C' or 'F'RŲRmRe( RVRmRDReRRRœRµRtview(RRmRŲRe((Rés.lib/python2.7/site-packages/dask/array/core.pyRėČs  # cC`s ddlm}||||ƒS(Ni(tswapaxes(R5Rģ(RRŠRŃRģ((s.lib/python2.7/site-packages/dask/array/core.pyRģėscC`s ddlm}||d|ƒS(Ni(troundtdecimals(R5Rķ(RRīRķ((s.lib/python2.7/site-packages/dask/array/core.pyRķšscC`sB|jdkr|jtjƒSt|j|j|j|jƒSdS(sS Copy array. This is a no-op for dask.arrays, which are immutable iN( R'RµR-RŹRRĒR­ReRm(R((s.lib/python2.7/site-packages/dask/array/core.pyRŹõscC`s |jƒ}||t|ƒ<|S(N(RŹtid(RtmemoR\((s.lib/python2.7/site-packages/dask/array/core.pyt __deepcopy__žs c`s‰|jƒ}|jƒ‰|rX|jˆ|ƒ‰d|j}tj|ˆddƒ‰nt|j‡fd†|ƒ}tj |dt ƒS(sOConvert into an array of ``dask.delayed`` objects, one per chunk. Parameters ---------- optimize_graph : bool, optional If True [default], the graph is optimized before converting into ``dask.delayed`` objects. See Also -------- dask.array.from_delayed sdelayed-Rc`s t|ˆƒS(N(R6(RÖ(Rt(s.lib/python2.7/site-packages/dask/array/core.pyR„R…Rm(( RīRėRģR­R:RR!R’RVRCR|(Rtoptimize_graphRuR­tL((Rts.lib/python2.7/site-packages/dask/array/core.pyt to_delayeds   cC`s#ddlm}|||d|ƒS(Ni(trepeatR†(tcreationRõ(RtrepeatsR†Rõ((s.lib/python2.7/site-packages/dask/array/core.pyRõscC`sddlm}||ƒS(Ni(tnonzero(R5Rų(RRų((s.lib/python2.7/site-packages/dask/array/core.pyRųscO`st|||ŽS(s©Save array to the zarr storage format See https://zarr.readthedocs.io for details about the format. See function ``to_zarr()`` for parameters. (tto_zarr(RRžR((s.lib/python2.7/site-packages/dask/array/core.pyRł#scO`s#ddlm}|||||ŽS(sĄSave array to the TileDB storage manager See function ``to_tiledb()`` for argument documentation. See https://docs.tiledb.io for details about the format and engine. i(t to_tiledb(t tiledb_ioRś(RturiRžRRś((s.lib/python2.7/site-packages/dask/array/core.pyRś,s(RĒRRRĪRmN(“RHRIRJt __slots__RKRRRėR RīR"R R_RRģt staticmethodR7Rt__dask_scheduler__R%R&tpropertyRĢR'RkR(R*R+R,ReR-R?RBR’RCRERDR­tsetterRƒRHRQRRRRRTR[R^t __nonzero__R`Rat__long__RcReRjRuRxRyR~RR'RVR3RzR{R‚RRƒRķR„R†R‡RŠRGR‘R’R“R•R–R˜R™R›RRŸR”R£R¤R¦RØRŖR«R¬R­RÆR±R³R“RµR·RøRŗR»R½R¾RĄRĮRĆRÄRĘRĒRČRÉRĘRSRRĖR‹RĢRĶRyRĪRŅRÓRŌRÖR×RµRÅRŁRĻRŽRßRąRćRäRåRęRėRģRķRŹRńRōRõRųRłRś(((s.lib/python2.7/site-packages/dask/array/core.pyRKs4             $           +  "  '                                                        '8    #     cC`s/t|ƒ}||kr+td|ƒ‚n|S(NsCould not coerce %f to integer(R Rœ(tfR¶((s.lib/python2.7/site-packages/dask/array/core.pyRč7s  c`sÅ|r+t|tjƒ r+tj|ƒ}nˆdkrFttƒ‚ntˆtƒrdtˆƒ‰ntˆtt fƒrˆft |ƒ‰ntˆt ƒrÉt‡fd†t t |ƒƒDƒƒ‰ntˆtj ƒrźˆjƒ‰nˆ r |r td„|Dƒƒr dt |ƒ‰n|rlt |ƒdkrlt ˆƒdkrltd„ˆDƒƒrlˆf‰n|r£t ˆƒt |ƒkr£tdˆ|fƒ‚ndˆks»dˆkrŻtd„tˆ|ƒDƒƒ‰nxrˆD]j}t|t ƒrä|d krät|ƒ}|dkr&|}qN||krNtd ||fƒ‚qNqäqäWtd „ˆDƒƒ‰td „ˆDƒƒr™tˆ||||ƒ‰n|dk rĒtd „tˆ|ƒDƒƒ‰nˆrž|dk ržtd„t|ˆƒDƒdƒ‰nx#ˆD]}|stdƒ‚qqW|dk r±t ˆƒt |ƒkrmtdt |ƒt ˆƒfƒ‚ntd„tttˆƒ|ƒDƒƒs±tdˆ|fƒ‚q±ntd„ˆDƒƒS(s Normalize chunks to tuple of tuples This takes in a variety of input types and information and produces a full tuple-of-tuples result for chunks, suitable to be passed to Array or rechunk or any other operation that creates a Dask array. Parameters ---------- chunks: tuple, int, dict, or string The chunks to be normalized. See examples below for more details shape: Tuple[int] The shape of the array limit: int (optional) The maximum block size to target in bytes, if freedom is given to choose dtype: np.dtype previous_chunks: Tuple[Tuple[int]] optional Chunks from a previous array that we should use for inspiration when rechunking auto dimensions. If not provided but auto-chunking exists then auto-dimensions will prefer square-like chunk shapes. Examples -------- Specify uniform chunk sizes >>> normalize_chunks((2, 2), shape=(5, 6)) ((2, 2, 1), (2, 2, 2)) Also passes through fully explicit tuple-of-tuples >>> normalize_chunks(((2, 2, 1), (2, 2, 2)), shape=(5, 6)) ((2, 2, 1), (2, 2, 2)) Cleans up lists to tuples >>> normalize_chunks([[2, 2], [3, 3]]) ((2, 2), (3, 3)) Expands integer inputs 10 -> (10, 10) >>> normalize_chunks(10, shape=(30, 5)) ((10, 10, 10), (5,)) Expands dict inputs >>> normalize_chunks({0: 2, 1: 3}, shape=(6, 6)) ((2, 2, 2), (3, 3)) The values -1 and None get mapped to full size >>> normalize_chunks((5, -1), shape=(10, 10)) ((5, 5), (10,)) Use the value "auto" to automatically determine chunk sizes along certain dimensions. This uses the ``limit=`` and ``dtype=`` keywords to determine how large to make the chunks. The term "auto" can be used anywhere an integer can be used. See array chunking documentation for more information. >>> normalize_chunks(("auto",), shape=(20,), limit=5, dtype='uint8') ((5, 5, 5, 5),) You can also use byte sizes (see ``dask.utils.parse_bytes``) in place of "auto" to ask for a particular size >>> normalize_chunks("1kiB", shape=(2000,), dtype='float32') ((250, 250, 250, 250, 250, 250, 250, 250),) Respects null dimensions >>> normalize_chunks((), shape=(0, 0)) ((0,), (0,)) c3`s!|]}ˆj|dƒVqdS(N(RRK(RLR¶(Re(s.lib/python2.7/site-packages/dask/array/core.pys ’scs`s|]}|dkVqdS(iN((RLRa((s.lib/python2.7/site-packages/dask/array/core.pys •siics`s$|]}t|ttfƒVqdS(N(RNRR©(RLR\((s.lib/python2.7/site-packages/dask/array/core.pys ™ssNChunks and shape must be of the same length/dimension. Got chunks=%s, shape=%si’’’’cs`s9|]/\}}|dks'|dkr-|n|VqdS(i’’’’N(RK(RLR\Ra((s.lib/python2.7/site-packages/dask/array/core.pys ”stautosDOnly one consistent value of limit or chunk is allowed.Used %s != %scs`s6|],}t|tƒr*|dkr*dn|VqdS(RN(RNR©(RLR\((s.lib/python2.7/site-packages/dask/array/core.pys Æscs`s|]}|dkVqdS(RN((RLR\((s.lib/python2.7/site-packages/dask/array/core.pys ±scs`s3|])\}}|ddhkr'|n|VqdS(i’’’’N(RK(RLR\Ra((s.lib/python2.7/site-packages/dask/array/core.pys µscs`sH|]>\}}t|ttfƒs9t|f|fƒn|fVqdS(N(RNRRRcR (RLRaR\((s.lib/python2.7/site-packages/dask/array/core.pys ¹ssZEmpty tuples are not allowed in chunks. Express zero length dimensions with 0(s) in chunkssLInput array has %d dimensions but the supplied chunks has only %d dimensionscs`s?|]5\}}||kp6tj|ƒp6tj|ƒVqdS(N(tmathR (RLR\Ra((s.lib/python2.7/site-packages/dask/array/core.pys Ęss6Chunks do not add up to shape. Got chunks=%s, shape=%scs`s%|]}td„|DƒƒVqdS(cs`s0|]&}tj|ƒs$t|ƒn|VqdS(N(RR R (RLRM((s.lib/python2.7/site-packages/dask/array/core.pys ĖsN(RR(RLR\((s.lib/python2.7/site-packages/dask/array/core.pys ĖsN(i((i((RNRVRmRKRœRRcRRRR©RpRrRoR3RzRRdR+RSt auto_chunksRyR(ReRktlimitRmtprevious_chunksR\tparsed((Res.lib/python2.7/site-packages/dask/array/core.pyRn>sjK +#* "           c`sNˆdk r%td„ˆDƒƒ‰nt|ƒ}d„t|ƒDƒ}|sWt|ƒS|dkrutjdƒ}nt|tƒr“t|ƒ}n|dkr®t dƒ‚n|j rĘt dƒ‚nxot|ƒt|ƒD]W}t|t ƒrt j|ƒs%t|tƒrŻt j|ƒjƒrŻtdƒ‚qŻqŻWtd|ƒ}t jg|D]3}|dkrTt|t ƒr{|n t|ƒ^qTƒ}ˆr•‡fd †|Dƒ} g} xŽt|ƒD]€\} } tˆ| ƒ} t| jƒd d „ƒ\}}|dkr2|tˆ| ƒd kr2| j|ƒqæ| j| ƒqæW||j|t jt| jƒƒƒ}d }tƒ}xå||ks—||krc|}t|ƒ}xŠt|ƒD]|}| ||dt|ƒ}|||kr|j|ƒ|||9}||||<| |=q¶t|| |ƒ| |ēscS`s(h|]\}}|dkr|’qS(R((RLR¶R\((s.lib/python2.7/site-packages/dask/array/core.pys ės sarray.chunk-sizes%DType must be known for auto-chunkingsiCan not use auto rechunking with object dtype. We are unable to estimate the size in bytes of object datasCCan not perform automatic rechunking with unknown (nan) chunk sizesiRc`s&i|]}tjˆ|ƒ|“qS((RVtmedian(RLRX(R (s.lib/python2.7/site-packages/dask/array/core.pys s R‚cS`s|dS(Ni((tkv((s.lib/python2.7/site-packages/dask/array/core.pyR„R…iiN(RKRRRcRĀRRRNR©R+R¾t hasobjectRgRRVR RSRœR‹RŅRRÉRpRĶRDRwRįRĆtremovetround_toR(ReRkRRmR tautosRMtcst largest_blockRät ideal_shapeR¶Ratchunk_frequenciestmodetcountt multipliertlast_multipliert last_autosRXtproposedRÖRŲRCtsmall((R s.lib/python2.7/site-packages/dask/array/core.pyRĪsx        $ @!&*     . )  c`sgˆ|krWy$t‡fd†t|ƒDƒƒSWqctk rStdtˆƒƒSXn ˆ||SdS(sų Return a chunk dimension that is close to an even multiple or factor We want values for c that are nicely aligned with s. If c is smaller than s then we want the largest factor of s that is less than the desired chunk size, but not less than half, which is too much. If no such factor exists then we just go with the original chunk size and accept an uneven chunk at the end. If c is larger than s then we want the largest multiple of s that is still smaller than c. c3`s5|]+}ˆd|ko$ˆknr|VqdS(iN((RLR(R\(s.lib/python2.7/site-packages/dask/array/core.pys MsiN(R‹R*RœR (R\Ra((R\s.lib/python2.7/site-packages/dask/array/core.pyR>s $ Rc C`sŚt|tttftjƒr1tj|ƒ}nt|dd ƒ}t ||j d|j d|ƒ}|d t fkr¢t ||ƒ}d|} |pœd|}n/|tkrĖdttjƒƒ} }n|} |t krétƒ}nt|ƒtjkr2td„|Dƒƒr2i||fd|j6} n|d kr~t|ƒtjkrf| rftj}q~|rut}q~t}nt| |d|d |j d |d |d |d|j ƒ} || | >> x = h5py.File('...')['/data/path'] # doctest: +SKIP >>> a = da.from_array(x, chunks=(1000, 1000)) # doctest: +SKIP If your underlying datastore does not support concurrent reads then include the ``lock=True`` keyword argument or ``lock=mylock`` if you want multiple arrays to coordinate around the same lock. >>> a = da.from_array(x, chunks=(1000, 1000), lock=True) # doctest: +SKIP If your underlying datastore has a ``.chunks`` attribute (as h5py and zarr datasets do) then a multiple of that chunk shape will be used if you do not provide a chunk shape. >>> a = da.from_array(x, chunks='auto') # doctest: +SKIP >>> a = da.from_array(x, chunks='100 MiB') # doctest: +SKIP >>> a = da.from_array(x) # doctest: +SKIP ReRmR sarray-original-sarray-cs`s!|]}t|ƒdkVqdS(iN(Rp(RLR\((s.lib/python2.7/site-packages/dask/array/core.pys ¦siR RkRtRQRPN(i(RNRcRRt memoryviewRVt ScalarTypeRCR8RKRnRkRmRÅRRĘR©RšRńR(RŠR3RR’RqR RTR]RxR( RMReR­RQRPtfancyR R R®t original_nameRĖ((s.lib/python2.7/site-packages/dask/array/core.pyt from_arrayTs<:       +      c K`s)ddl}|pi}t||jƒr3|}nt|tƒr¬t|dd|ƒ\}} } t| ƒdksxt‚t|| dƒ} |j| dtd||}n$|} |j| dtd||}|dk rā|n|j }|dkrdt |||||}nt ||d |ƒS( s+Load array from the zarr storage format See https://zarr.readthedocs.io for details about the format. Parameters ---------- url: Zarr Array or str or MutableMapping Location of the data. A URL can include a protocol specifier like s3:// for remote data. Can also be any MutableMapping instance, which should be serializable if used in multiple processes. component: str or None If the location is a zarr group rather than an array, this is the subcomponent that should be loaded, something like ``'foo/bar'``. storage_options: dict Any additional parameters for the storage backend (ignored for local paths) chunks: tuple of ints or tuples of ints Passed to ``da.from_array``, allows setting the chunks on initialisation, if the chunking scheme in the on-disc dataset is not optimal for the calculations to follow. name : str, optional An optional keyname for the array. Defaults to hashing the input kwargs: passed to ``zarr.Array``. iNtrbtstorage_optionsit read_onlytpaths from-zarr-R­( tzarrRNRR©R<RpRR;RÅRKReRR ( turlt componentR"ReR­RR%tztfstfs_tokenR$tmapper((s.lib/python2.7/site-packages/dask/array/core.pyt from_zarr»s    ! cK`sšddl}t||jƒr—|} t| jt|jfƒrfdtjddƒkrftdƒ‚n|j | j ƒ}|j| dt d|d |ƒSt |j ƒsµt d ƒ‚n|p¾i}t|tƒrt|d d |ƒ\} } } t| ƒd kst‚t| | dƒ} n|} g|j D]}|d^q,}|jd|jd|d|jd| d|d||} |j| dt d|d |ƒS(sēSave array to the zarr storage format See https://zarr.readthedocs.io for details about the format. Parameters ---------- arr: dask.array Data to store url: Zarr Array or str or MutableMapping Location of the data. A URL can include a protocol specifier like s3:// for remote data. Can also be any MutableMapping instance, which should be serializable if used in multiple processes. component: str or None If the location is a zarr group rather than an array, this is the subcomponent that should be created/over-written. storage_options: dict Any additional parameters for the storage backend (ignored for local paths) overwrite: bool If given array already exists, overwrite=False will cause an error, where overwrite=True will replace the existing data. compute, return_stored: see ``store()`` kwargs: passed to the ``zarr.create()`` function, e.g., compression options iNt distributedt schedulerR…sGCannot store into in memory Zarr Array using the Distributed Scheduler.RQRōRųs\Attempt to save array to zarr with irregular chunking, please call `arr.rechunk(...)` first.R!R"iRkReRmRR$t overwrite(R%RNRRRrt DictStoreRRt RuntimeErrorRąReRĘt_check_regular_chunksRœR©R<RpRR;tcreateRkRm(RsR&R'R"R/RōRųRR%R(R)R*R$R+R\Re((s.lib/python2.7/site-packages/dask/array/core.pyRłēs.   !cC`sex^|D]V}t|ƒdkr%qntt|d ƒƒdkrEtS|d|dkrtSqWtS(sÖCheck if the chunks are regular "Regular" in this context means that along every axis, the chunks all have the same size, except the last one, which may be smaller Parameters ---------- chunkset: tuple of tuples of ints From the ``.chunks`` attribute of an ``Array`` Returns ------- True if chunkset passes, else False Examples -------- >>> import dask.array as da >>> arr = da.zeros(10, chunks=(5, )) >>> _check_regular_chunks(arr.chunks) True >>> arr = da.zeros(10, chunks=((3, 3, 3, 1), )) >>> _check_regular_chunks(arr.chunks) True >>> arr = da.zeros(10, chunks=((3, 1, 3, 3), )) >>> _check_regular_chunks(arr.chunks) False ii’’’’i(RpRįRĘRÅ(tchunksetRe((s.lib/python2.7/site-packages/dask/array/core.pyR2# s c C`sÅddlm}m}t||ƒ rDt|dƒrD||ƒ}n|p]dt|||ƒ}i|j|fdt|ƒ6}td„|Dƒƒ}t j ||d|gƒ}t ||||ƒS(s! Create a dask array from a dask delayed value This routine is useful for constructing dask arrays in an ad-hoc fashion using dask delayed, particularly when combined with stack and concatenate. The dask array will consist of a single chunk. Examples -------- >>> from dask import delayed >>> value = delayed(np.ones)(5) >>> array = from_delayed(value, (5,), float) >>> array dask.array >>> array.compute() array([1., 1., 1., 1., 1.]) i(R5R6R‚s from-value-cs`s|]}|fVqdS(N((RLR((s.lib/python2.7/site-packages/dask/array/core.pys b sR(i( t dask.delayedR5R6RNRLRR‚RpRRR:RR( RhRkRmR­R5R6RĖReRt((s.lib/python2.7/site-packages/dask/array/core.pyt from_delayedK s!cC`s|pdt|||||ƒ}|s.|rCt|||Ž}ni|f|fdt|ƒ6}td„|Dƒƒ}t||||ƒS(s; Create dask array in a single block by calling a function Calling the provided function with func(*args, **kwargs) should return a NumPy array of the indicated shape and dtype. Examples -------- >>> a = from_func(np.arange, (3,), dtype='i8', args=(3,)) >>> a.compute() array([0, 1, 2]) This works particularly well when coupled with dask.array functions like concatenate and stack: >>> arrays = [from_func(np.array, (), dtype='i8', args=(n,)) for n in range(5)] >>> stack(arrays).compute() array([0, 1, 2, 3, 4]) s from_func-ics`s|]}|fVqdS(N((RLR¶((s.lib/python2.7/site-packages/dask/array/core.pys  s(i(RRRpRRR(RRkRmR­RžRRĖRe((s.lib/python2.7/site-packages/dask/array/core.pyt from_funci s " !c C`s“t|ƒsd Stg|D]}t|ƒdkr|^qƒ}t|ƒdkr]t|ƒSt|ƒdkrt|dtƒStjttt|ƒƒƒrÆt d|ƒ‚ntttt|ƒƒƒdkrāt d|ƒ‚ng|D]}t |ƒddd…^qé}tt|ƒƒ}d}g}x{||kr©t d„|Dƒƒ}|j |ƒx;|D]3} | dc|8<| ddkre| j ƒqeqeW||7}q/Wt|ƒS( só Find the common block dimensions from the list of block dimensions Currently only implements the simplest possible heuristic: the common block-dimension is the only one that does not span fully span a dimension. This is a conservative choice that allows us to avoid potentially very expensive rechunking. Assumes that each element of the input block dimensions has all the same sum (i.e., that they correspond to dimensions of the same size). Examples -------- >>> common_blockdim([(3,), (2, 1)]) (2, 1) >>> common_blockdim([(1, 2), (2, 1)]) (1, 1, 1) >>> common_blockdim([(2, 2), (3, 1)]) # doctest: +SKIP Traceback (most recent call last): ... ValueError: Chunks do not align iiR‚s"Arrays chunk sizes are unknown: %ss"Chunks do not add up to same valueNi’’’’cs`s|]}|dVqdS(i’’’’N((RLR\((s.lib/python2.7/site-packages/dask/array/core.pys ŗ s((RSRįRpRR‹RVR RyRRœRcRĖRĶRæRR( t blockdimsRtnon_trivial_dimstntdtrchunksttotalR¶R¼tmR\((s.lib/python2.7/site-packages/dask/array/core.pytcommon_blockdim… s0 1 ! ,  c `s|sigfSgtd|ƒD]0\‰}|dk rDtˆƒnˆ|f^q }tt|ƒƒ}|jdtƒ}t|Œ\‰‰td„ˆDƒƒr²itˆƒfSt‡fd†ˆDƒƒrt‡fd†ˆDƒƒrt tˆdˆdj ƒƒˆfSg|D]-\‰}|dk r6ˆj nˆ|f^q}d„|Dƒ}t ||dt ƒ‰td „|Dƒƒ}tjtttˆjƒƒƒƒ} |rä| rä| |d krätjd | |td d ƒng‰x™|D]‘\‰}|dkrˆjˆƒqńt‡‡fd†t|ƒDƒƒ} | ˆj krutˆj ƒruˆjˆj| ƒƒqńˆjˆƒqńWˆˆfS(sŒ Unify chunks across a sequence of arrays Parameters ---------- *args: sequence of Array, index pairs Sequence like (x, 'ij', y, 'jk', z, 'i') Examples -------- >>> import dask.array as da >>> x = da.ones(10, chunks=((5, 2, 3),)) >>> y = da.ones(10, chunks=((2, 3, 5),)) >>> chunkss, arrays = unify_chunks(x, 'i', y, 'i') >>> chunkss {'i': (2, 3, 2, 3)} >>> x = da.ones((100, 10), chunks=(20, 5)) >>> y = da.ones((10, 100), chunks=(4, 50)) >>> chunkss, arrays = unify_chunks(x, 'ij', y, 'jk', 'constant', None) >>> chunkss # doctest: +SKIP {'k': (50, 50), 'i': (20, 20, 20, 20, 20), 'j': (4, 1, 3, 2)} >>> unify_chunks(0, None) ({}, [0]) Returns ------- chunkss : dict Map like {index: chunks}. arrays : list List of rechunked arrays. See Also -------- common_blockdim iRĮcs`s|]}|dkVqdS(N(RK(RLR!((s.lib/python2.7/site-packages/dask/array/core.pys ō sc3`s|]}|ˆdkVqdS(iN((RLR!(tinds(s.lib/python2.7/site-packages/dask/array/core.pys ö sc3`s%|]}|jˆdjkVqdS(iN(Re(RLRX(RŒ(s.lib/python2.7/site-packages/dask/array/core.pys ö sicS`s1i|]'\}}|dk r|j|j“qS(N(RKReR­(RLRXR!((s.lib/python2.7/site-packages/dask/array/core.pys ś s  t consolidatecs`s*|] \}}|dk r|jVqdS(N(RKR'(RLRÜR!((s.lib/python2.7/site-packages/dask/array/core.pys si s+Increasing number of chunks by factor of %dt stacklevelic3`s^|]T\}}ˆj|dkr,ˆ|n)tjtˆ|ƒƒsRˆj|ndVqdS(iN(RkRVR RyRK(RLRÕRŗ(RXRā(s.lib/python2.7/site-packages/dask/array/core.pys sN(R RKt asanyarrayRcRRRÅRdRRrReR­RR>R‹RVRŅRRpRwRĄRĮRGRĶRRRĀRą( RžRR!targindsRĮR¶tnameindst blockdim_dictt max_partstnpartsRe((RXRŒRāR?s.lib/python2.7/site-packages/dask/array/core.pyt unify_chunksÅ s>& C8$:   $  cC`sLxEt|ttfƒrGy|d}Wqtttfk rCPqXqW|S(sŸ >>> unpack_singleton([[[[1]]]]) 1 >>> unpack_singleton(np.array(np.datetime64('2000-01-01'))) array('2000-01-01', dtype='datetime64[D]') i(RNRcRRRwR¾tKeyError(RM((s.lib/python2.7/site-packages/dask/array/core.pyR s  c `sĮd„‰d„}tdd„ƒ}d}t}xÕ|j|ƒD]Ä\}}}t|ƒtkrtdj||ƒƒƒ‚n|s”t|ƒ} n.t|ƒdkr@t|ƒd} t }nq@|dk rž|| kržt dj|| ||ƒƒƒ‚n| }q@W|rt d ƒ‚n|j |d t d t ƒ}|j |d d „d tƒ} t|| ƒ‰ˆ|} |j |d ‡‡fd †d t ƒ}|j |d ‡fd†dd„d| ƒS(s& Assemble an nd-array from nested lists of blocks. Blocks in the innermost lists are concatenated along the last dimension (-1), then these are concatenated along the second-last dimension (-2), and so on until the outermost list is reached Blocks can be of any dimension, but will not be broadcasted using the normal rules. Instead, leading axes of size 1 are inserted, to make ``block.ndim`` the same for all blocks. This is primarily useful for working with scalars, and means that code like ``block([v, 1])`` is valid, where ``v.ndim == 1``. When the nested list is two levels deep, this allows block matrices to be constructed from their components. Parameters ---------- arrays : nested list of array_like or scalars (but not tuples) If passed a single ndarray or scalar (a nested list of depth 0), this is returned unmodified (and not copied). Elements shapes must match along the appropriate axes (without broadcasting), but leading 1s will be prepended to the shape as necessary to make the dimensions match. allow_unknown_chunksizes: bool Allow unknown chunksizes, such as come from converting from dask dataframes. Dask.array is unable to verify that chunks line up. If data comes from differently aligned sources then this can cause unexpected results. Returns ------- block_array : ndarray The array assembled from the given blocks. The dimensionality of the output is equal to the greatest of: * the dimensionality of all the inputs * the depth to which the input list is nested Raises ------ ValueError * If list depths are mismatched - for instance, ``[[a, b], c]`` is illegal, and should be spelt ``[[a, b], [c]]`` * If lists are empty - for instance, ``[[a, b], []]`` See Also -------- concatenate : Join a sequence of arrays together. stack : Stack arrays in sequence along a new dimension. hstack : Stack arrays in sequence horizontally (column wise). vstack : Stack arrays in sequence vertically (row wise). dstack : Stack arrays in sequence depth wise (along third dimension). vsplit : Split array into a list of multiple sub-arrays vertically. Notes ----- When called with only scalars, ``block`` is equivalent to an ndarray call. So ``block([[1, 2], [3, 4]])`` is equivalent to ``array([[1, 2], [3, 4]])``. This function does not enforce that the blocks lie on a fixed grid. ``block([[a, b], [c, d]])`` is not restricted to arrays of the form:: AAAbb AAAbb cccDD But is also allowed to produce, for some ``a, b, c, d``:: AAAbb AAAbb cDDDD Since concatenation happens along the last axis first, `block` is _not_ capable of producing the following directly:: AAAbb cccbb cccDD Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is equivalent to ``block([[A, B, ...], [p, q, ...]])``. cS`s5t|ƒ}t||jdƒ}|d|tfS(Ni(N(RBR‹R’RKtEllipsis(RMR’tdiff((s.lib/python2.7/site-packages/dask/array/core.pyt atleast_ndƒ s cS`sddjd„|DƒƒS(NRŒR…cs`s|]}dj|ƒVqdS(s[{}]N(Rš(RLR¶((s.lib/python2.7/site-packages/dask/array/core.pys ‰ s(R—(RY((s.lib/python2.7/site-packages/dask/array/core.pyt format_indexˆ st recurse_ifcS`st|ƒtkS(N(RŠRc(RM((s.lib/python2.7/site-packages/dask/array/core.pyR„‹ R…s{} is a tuple. Only lists can be used to arrange blocks, and np.block does not allow implicit conversion from tuple to ndarray.iiscList depths are mismatched. First element was at depth {}, but there is an element at depth {} ({})sLists cannot be emptytf_maptf_reducecS`s|jS(N(R’(txi((s.lib/python2.7/site-packages/dask/array/core.pyR„æ R…c`s ˆ|ˆƒS(N((RQ(RLR’(s.lib/python2.7/site-packages/dask/array/core.pyR„Ź R…c`stt|ƒd|dˆƒS(NR†tallow_unknown_chunksizes(RDRc(txsR†(RR(s.lib/python2.7/site-packages/dask/array/core.pyR„Ń s tf_kwargscS`std|dƒS(NR†i(Rr(R†((s.lib/python2.7/site-packages/dask/array/core.pyR„Ö R…R†N(R=RKRĘtwalkRŠRRR¾RšRpRÅRœt map_reduceRBRcR‹( RŒRRRMtrect list_ndimt any_emptyRYRhtenteringt curr_deptht elem_ndimt first_axis((RRRLR’s.lib/python2.7/site-packages/dask/array/core.pytblock& sX]          c `sŅtˆƒ}tˆdjƒ}ˆdkr8|ˆ‰nˆ|krcd}t||ˆfƒ‚n|dkrwˆdS| r t‡‡fd†t|ƒDƒƒ r tttjˆdjƒƒrćtdt ˆdjƒƒ‚ntdgˆD]}|j^qšƒ‚ngt|ƒD]}t t|ƒƒ^q}x)t |ƒD]\}} |d | ˆ>> import dask.array as da >>> import numpy as np >>> data = [from_array(np.ones((4, 4)), chunks=(2, 2)) ... for i in range(3)] >>> x = da.concatenate(data, axis=0) >>> x.shape (12, 4) >>> da.concatenate(data, axis=1).shape (4, 12) Result is a new dask Array See Also -------- stack isXAxis must be less than than number of dimensions Data has %d dimensions, but got axis=%dic3`s:|]0‰ˆˆkp1t‡‡fd†ˆDƒƒVqdS(c3`s-|]#}|jˆˆdjˆkVqdS(iN(Rk(RLRM(R¶tseq(s.lib/python2.7/site-packages/dask/array/core.pys  sN(R(RL(R†R_(R¶s.lib/python2.7/site-packages/dask/array/core.pys  ssnTried to concatenate arrays with unknown shape %s. To force concatenation pass allow_unknown_chunksizes=True.sShapes do not align: %sRĮs concatenate-iRRm((!RpRkRœRRoRSRRVR R©RcRĀRRdRHRĘReRyRR RmRįRt promote_typesRGR­RRRRrR:RR(R_R†RRRÕR’R§RMR¶R?R!tuc_argsR’RXRfR Retcum_dimst seq_dtypesRrtnamesR­RuR‚RwRĖRt((R†R_s.lib/python2.7/site-packages/dask/array/core.pyRDŪ sL*     (+5<% 7ycC`s‰d}|r| r|}n|r/|jƒnz?|dk rTtj|ƒ||>> a = np.ones((5, 6)) >>> b = np.empty(a.shape) >>> load_store_chunk(a, b, (slice(None), slice(None)), False, False, False) N(RKRURVRBRW(RMR¼RYRQRųRžRä((s.lib/python2.7/site-packages/dask/array/core.pytload_store_chunk@ s     cC`st|||||tƒS(N(ReRĘ(RMR¼RYRQRų((s.lib/python2.7/site-packages/dask/array/core.pyt store_chunkn scC`std|||ttƒS(N(ReRKRÅ(R¼RYRQ((s.lib/python2.7/site-packages/dask/array/core.pyt load_chunkr sc `sēˆtkrtƒ‰nt|jƒ}|rRg|D]}t||ƒ^q4}nd|pjttjƒƒ‰t‰d‰ˆr¦|r¦dˆ‰t ‰ˆ|f‰n‡‡‡‡‡‡fd†t t j |j ƒƒ|ƒDƒ} | S(s7 Creates a Dask graph for storing chunks from ``arr`` in ``out``. Parameters ---------- arr: da.Array A dask array out: array-like Where to store results too. lock: Lock-like or bool, optional Whether to lock or with what (default is ``True``, which means a ``threading.Lock`` instance). region: slice-like, optional Where in ``out`` to store ``arr``'s results (default is ``None``, meaning all of ``out``). return_stored: bool, optional Whether to return ``out`` (default is ``False``, meaning ``None`` is returned). load_stored: bool, optional Whether to handling loading from ``out`` at the same time. Ignored if ``return_stored`` is not ``True``. (default is ``False``, meaning defer to ``return_stored``). tok: str, optional Token to use when naming keys Examples -------- >>> import dask.array as da >>> d = da.ones((5, 6), chunks=(2, 3)) >>> a = np.empty(d.shape) >>> insert_to_ooc(d, a) # doctest: +SKIP sstore-%ssload-%sc`s@i|]6\}}ˆ|ˆ|ˆˆfˆˆf|d“qS(i((RLRčtslc(RžRRQR­R¼Rų(s.lib/python2.7/site-packages/dask/array/core.pys © s ((RÅR RlReR`R©RšRńRfReRdR8RķRī( RsR¼RQtregionRųRžRRvRhRĖ((RžRRQR­R¼Rųs.lib/python2.7/site-packages/dask/array/core.pyRņv s#  %  "c`s6ˆsd„|Dƒ‰n‡‡fd†|Dƒ}|S(sM Creates a Dask graph for loading stored ``keys`` from ``dsk``. Parameters ---------- keys: Sequence A sequence containing Dask graph keys to load dsk_pre: Mapping A Dask graph corresponding to a Dask Array before computation dsk_post: Mapping, optional A Dask graph corresponding to a Dask Array after computation Examples -------- >>> import dask.array as da >>> d = da.ones((5, 6), chunks=(2, 3)) >>> a = np.empty(d.shape) >>> g = insert_to_ooc(d, a) >>> retrieve_from_ooc(g.keys(), g) # doctest: +SKIP cS`si|]}||“qS(((RLRÖ((s.lib/python2.7/site-packages/dask/array/core.pys Ē s c`sEi|];}tˆ|fˆ|dd!d|df|d“qS(ii’’’’sload-ii(Rg(RLRÖ(tdsk_posttdsk_pre(s.lib/python2.7/site-packages/dask/array/core.pys Ź s ((RuRkRjtload_dsk((RjRks.lib/python2.7/site-packages/dask/array/core.pyRó° s  cK`sÆt|tƒr|St|dƒr,|jƒSt|ttfƒrftd„|Dƒƒrft|ƒ}n-tt|ddƒt ƒs“t j |ƒ}nt |d|jdt|S(s7Convert the input to a dask array. Parameters ---------- a : array-like Input data, in any form that can be converted to a dask array. Returns ------- out : dask array Dask array interpretation of a. Examples -------- >>> import dask.array as da >>> import numpy as np >>> x = np.arange(3) >>> da.asarray(x) dask.array >>> y = [[1, 2, 3], [4, 5, 6]] >>> da.asarray(y) dask.array t to_dask_arraycs`s|]}t|tƒVqdS(N(RNR(RLR¶((s.lib/python2.7/site-packages/dask/array/core.pys ī sRkReR N(RNRRLRmRcRRRStstackR8RKR1RVRPR RkR^(RXR((s.lib/python2.7/site-packages/dask/array/core.pyRPŃ s +cC`sęt|tƒr|St|dƒr,|jƒSt|dƒr`t|ƒjjdƒr`t|jƒSt|t t fƒršt d„|Dƒƒršt |ƒ}n-tt |dd ƒtƒsĒtj|ƒ}nt|d|jdtdtƒS( s‹Convert the input to a dask array. Subclasses of ``np.ndarray`` will be passed through as chunks unchanged. Parameters ---------- a : array-like Input data, in any form that can be converted to a dask array. Returns ------- out : dask array Dask array interpretation of a. Examples -------- >>> import dask.array as da >>> import numpy as np >>> x = np.arange(3) >>> da.asanyarray(x) dask.array >>> y = [[1, 2, 3], [4, 5, 6]] >>> da.asanyarray(y) dask.array Rmtdatasxarray.cs`s|]}t|tƒVqdS(N(RNR(RLR¶((s.lib/python2.7/site-packages/dask/array/core.pys  sRkReR RPN(RNRRLRmRŠRIt startswithRBRoRcRRRSRnR8RKR1RVR RkR^RĘ(RX((s.lib/python2.7/site-packages/dask/array/core.pyRBõ s ' +cC`s~t|ddƒ}t|tƒ p5td„|Dƒƒ}tj|ƒp}|p}t|tjƒp}t|tjƒo}|j dkS(s» >>> is_scalar_for_elemwise(42) True >>> is_scalar_for_elemwise('foo') True >>> is_scalar_for_elemwise(True) True >>> is_scalar_for_elemwise(np.array(42)) True >>> is_scalar_for_elemwise([1, 2, 3]) True >>> is_scalar_for_elemwise(np.array([1, 2, 3])) False >>> is_scalar_for_elemwise(from_array(np.array(0), chunks=())) False >>> is_scalar_for_elemwise(np.dtype('i4')) True Rkcs`s|]}t|ƒVqdS(N(R(RLRM((s.lib/python2.7/site-packages/dask/array/core.pys 6 siN( R8RKRNR1RSRVtisscalarRmR3R’(RÜt maybe_shapetshape_condition((s.lib/python2.7/site-packages/dask/array/core.pytis_scalar_for_elemwise sc`sėt|ƒdkr|dSg}xøtddtt|ƒŒD]›}tj|ƒjƒrctj‰n!d|krudn tj|ƒ‰t‡fd†|DƒƒrŹt dj dj tt |ƒƒƒƒ‚n|j ˆƒq<Wtt|ƒƒS(s2 Determines output shape from broadcasting arrays. Parameters ---------- shapes : tuples The shapes of the arguments. Returns ------- output_shape : tuple Raises ------ ValueError If the input shapes cannot be successfully broadcast together. iit fillvaluei’’’’c3`s7|]-}|dddˆgko.tj|ƒ VqdS(i’’’’iiN(RVR (RLR¶(Rb(s.lib/python2.7/site-packages/dask/array/core.pys X ss8operands could not be broadcast together with shapes {0}t (RpR0RtreversedRVR RStnanR‹RœRšR—R©RĶRR(RhR¼tsizes((Rbs.lib/python2.7/site-packages/dask/array/core.pytbroadcast_shapes> s" ! !c O`sĖ|jddƒ}tddgƒj|ƒsqd}t||jttt|ƒtddgƒƒƒfƒ‚ng|D]0}t|t t fƒr¢t j |ƒn|^qx}g}xL|D]D}t |ddƒ}td„|Dƒƒrņd}n|j|ƒq»Wg|D]!} t| tƒr%| nd^q }tt|Œƒ} t t| ƒƒddd…} t} d|kr|d} n—g|D]@}t|ƒsĀt jdtd |jƒd|jƒn|^qˆ}yt||id d tƒ} Wntk rtSXtd „|Dƒƒ} |jddƒpId t|ƒt|| |Œf}t d| d|dt|ƒj!dƒƒ}| r™| |d<||d>> elemwise(add, x, y) # doctest: +SKIP >>> elemwise(sin, x) # doctest: +SKIP See Also -------- blockwise R¼R­Rms3%s does not take the following keyword arguments %sRkcs`s|]}t|ƒVqdS(N(R(RLRM((s.lib/python2.7/site-packages/dask/array/core.pys w sNi’’’’iR:RŸcs`s+|]!}t|ƒ o"|jdkVqdS(iN(RtR’(RLRX((s.lib/python2.7/site-packages/dask/array/core.pys “ ss%s-%sR®R’t enforce_dtypetenforce_dtype_functioncs`sI|]?}|t|ƒs:tt|jƒddd…ƒndfVqdS(Ni’’’’(RtRRRoR’RK(RLRX((s.lib/python2.7/site-packages/dask/array/core.pys ž s((((i(&RæRKRįt issupersetR¾RHR©RĆRNRcRRRVRPR8RSRĶR1RpRzRoRĘRtR)R‹R’RmRØR”R4RR&RRrtstript_enforce_dtypeRARt handle_out(topRžRR¼R§RXRhRÜRkRatout_ndimt expr_indstneed_enforce_dtypeRrtvalsR­tblockwise_kwargsRä((s.lib/python2.7/site-packages/dask/array/core.pyR:_ sH>=  .  J *       cC`s t|tƒrXt|ƒdkr.|d}qXt|ƒdkrOtdƒ‚qXd}nt|tƒr×|j|jkr¤tdt|jƒt|jƒfƒ‚n|j |_ |j |_ |j |_ |j |_ n2|dk rdt|ƒj}t|ƒ‚n|SdS(s{ Handle out parameters If out is a dask.array then this overwrites the contents of that array with the result iis(The out parameter is not fully supportedsEMismatched shapes between result and out parameter. out=%s, result=%ssOThe out parameter is not fully supported. Received type %s, expected Dask ArrayN(RNRRRpRgRKRRkRœR©ReRĪRĒRmR­RŠRH(R¼RäR§((s.lib/python2.7/site-packages/dask/array/core.pyR€¦ s(  %    cO`s|jdƒ}|jdƒ}|||Ž}t|dƒr||jkr|tkrtj||ddƒs tdt|ƒt|ƒt|jƒfƒ‚ntj |ƒrĮ|j |ƒ}qy|j |dt ƒ}Wqt k rü|j |ƒ}qXn|S(s6Calls a function and converts its result to the given dtype. The parameters have deliberately been given unwieldy names to avoid clashes with keyword arguments consumed by blockwise A dtype of `object` is treated as a special case and not enforced, because it is used as a dummy value in some places when the result will not be a block in an Array. Parameters ---------- enforce_dtype : dtype Result dtype enforce_dtype_function : callable The wrapped function, which will be passed the remaining arguments R{R|RmR‹t same_kinds`Inferred dtype from function %r was %r but got %r, which can't be cast using casting='same_kind'RŹ( RæRLRmR|RVRŽRœR&R©RqRGRĘR¾(RžRRmtfunctionRä((s.lib/python2.7/site-packages/dask/array/core.pyRÄ s*+ cC`s\t|ƒ}t|ƒ}|j|krF|dksB||jkrF|St|ƒ|j}|dks‹td„t|||jƒDƒƒr§t d|j|fƒ‚n|dkrśtd„|| Dƒƒtd„t|j|j||ƒDƒƒ}n|t ||d|j d|jƒ}xXt|j||ƒD]@\}}||kr2|dkr2t d |j|fƒ‚q2q2Wd t |||ƒ}i}t d „|DƒŒ}x}d „|DƒD]k\} } td „t|j| |ƒDƒƒ} |jf| } |f| } tj| t| ƒf|| s s%cannot broadcast shape %s to shape %scs`s|]}|fVqdS(N((RLRa((s.lib/python2.7/site-packages/dask/array/core.pys  scs`s3|])\}}}|dkr$|n|fVqdS(iN((RLR RŠR‰((s.lib/python2.7/site-packages/dask/array/core.pys  sRmR isqcannot broadcast chunks %s to chunks %s: new chunks must either be along a new dimension or a dimension of size 1s broadcast_to-cs`s|]}t|ƒVqdS(N(RĀ(RLRf((s.lib/python2.7/site-packages/dask/array/core.pys " scs`s|]}t|ŒVqdS(N(Rd(RLtec((s.lib/python2.7/site-packages/dask/array/core.pys # scs`s-|]#\}}|dkr!dn|VqdS(iiN(i((RLR R¶((s.lib/python2.7/site-packages/dask/array/core.pys $ sRN(i(RPRRRkRKReRpR’RSRdRœRnRmRRR­RVt broadcast_toR4R:RR(RMRkRetndim_newtold_bdtnew_bdR­RĖtenumerated_chunkst new_indext chunk_shapet old_indextold_keytnew_keyRt((s.lib/python2.7/site-packages/dask/array/core.pyRŒģ s<  *  ' #   c`s¶t|jdtƒƒ}|r$tnt‰t‡fd†|Dƒƒ}|r[tdƒ‚ntd„|DƒŒ}td„|DƒŒ}g|D]}t |d|d|ƒ^qŽ}|S(Ntsubokc3`s|]}ˆ|ƒVqdS(N((RLR(tto_array(s.lib/python2.7/site-packages/dask/array/core.pys 3 ss(unsupported keyword argument(s) providedcs`s|]}|jVqdS(N(Rk(RLR((s.lib/python2.7/site-packages/dask/array/core.pys 8 scs`s|]}|jVqdS(N(Re(RLR((s.lib/python2.7/site-packages/dask/array/core.pys 9 sRkRe( R]RæRĘRBRPRRR¾RzRēRŒ(RžRR–RkReRRä((R—s.lib/python2.7/site-packages/dask/array/core.pytbroadcast_arrays. s+c`s9‡‡fd†}ttƒdˆj|_WdQX|S(s“ Offsets inputs by offset >>> double = lambda x: x * 2 >>> f = offset_func(double, (10,)) >>> f(1) 22 >>> f(300) 620 c`s"ttt|ˆƒƒ}ˆ|ŒS(N(RcRR (Ržtargs2(RRĻ(s.lib/python2.7/site-packages/dask/array/core.pyt_offsetJ stoffset_N(R"R”RH(RRĻRžRš((RRĻs.lib/python2.7/site-packages/dask/array/core.pyt offset_func@ s  cC`s|s dSg}d}d„}xct|ttfƒr„|jtg|D]}|t|ƒƒ|^qGƒƒ|d}|d7}q"Wt|ƒS(s` Chunks tuple from nested list of arrays >>> x = np.array([1, 2]) >>> chunks_from_arrays([x, x]) ((2, 2),) >>> x = np.array([[1, 2]]) >>> chunks_from_arrays([[x], [x]]) ((1, 1), (2,)) >>> x = np.array([[1, 2]]) >>> chunks_from_arrays([[x, x]]) ((1,), (2, 2)) >>> chunks_from_arrays([1, 1]) ((1, 1),) icS`s$y |jSWntk rdSXdS(Ni(i(RkR9(RM((s.lib/python2.7/site-packages/dask/array/core.pyRkk s  i((RNRcRRRĶt deepfirst(RŒRäRbRkRX((s.lib/python2.7/site-packages/dask/array/core.pytchunks_from_arraysT s 6 cC`s+t|ttfƒs|St|dƒSdS(sa First element in a nested list >>> deepfirst([[[1, 2], [3, 4]], [5, 6], [7, 8]]) 1 iN(RNRcRRR(R_((s.lib/python2.7/site-packages/dask/array/core.pyRx scC`sAt|ƒtkr9tt|ƒgtt|dƒƒƒSdSdS(s Get the shape of nested list iN((RŠRcRRRpt shapelist(RX((s.lib/python2.7/site-packages/dask/array/core.pyRŸ„ s'cC`sgt|ƒdkrt|ƒStt|ƒ|dƒ}gt||ƒD]}t|d|ƒ^qFSdS(sh Reshape iterator to nested shape >>> reshapelist((2, 3), range(6)) [[0, 1, 2], [3, 4, 5]] iiN(RpRcR R t reshapelist(RkR_RÕtpart((s.lib/python2.7/site-packages/dask/array/core.pyR Œ s cC`sļt|ƒt|ƒkr'tdƒ‚n|dkrBtdƒ‚nt|ƒtt|ƒƒkrotdƒ‚nt|ƒd}t|ƒ}gt||ƒD]+}||krĮ||j|ƒnd^qœ}tt j |ƒƒ}t ||ƒS(sŚ Permute axes of nested list >>> transposelist([[1,1,1],[1,1,1]], [2,1]) [[[1, 1], [1, 1], [1, 1]]] >>> transposelist([[1,1,1],[1,1,1]], [2,1], extradims=1) [[[[1], [1]], [[1], [1]], [[1], [1]]]] s2Length of axes should equal depth of nested arraysis`newdims` should be positives`axes` should be uniquei( RpR.RœRįR‹RŸRoRYRcR8RķR (RŒRt extradimsR’RkR¶tnewshapeRä((s.lib/python2.7/site-packages/dask/array/core.pyt transposelist™ s   Bc `stˆƒ}tˆdjƒ}|dkr<||d}n||kratd||fƒ‚nt‡fd†ˆDƒƒsūtjtjgˆD]}|j^qƒˆdjkƒd}tdj|dˆdj|ddˆ|djƒƒ‚ntt |ƒƒ‰tt ‡fd†ˆDƒƒƒ}t |Œ\}‰t tj gˆD]}|j^qQƒ} gˆD]}|j| ƒ^qp‰ttd„ˆDƒƒƒdks³t‚ˆdj| d |fˆdj|} gˆD]}|j^qå} dt| |ƒ} tt| gg| D]} t t| ƒƒ^q Œƒ}g|D]6}| ||df|d|d!||d ^qK}g|D]G}t|td d d ƒf|dtd d d ƒf||f^qŽ}tt||ƒƒ}tj| |d ˆƒ}t|| | d | ƒS(sb Stack arrays along a new axis Given a sequence of dask arrays, form a new dask array by stacking them along a new dimension (axis=0 by default) Examples -------- Create slices >>> import dask.array as da >>> import numpy as np >>> data = [from_array(np.ones((4, 4)), chunks=(2, 2)) ... for i in range(3)] >>> x = da.stack(data, axis=0) >>> x.shape (3, 4, 4) >>> da.stack(data, axis=1).shape (4, 3, 4) >>> da.stack(data, axis=-1).shape (4, 4, 3) Result is a new dask Array See Also -------- concatenate iisZAxis must not be greater than number of dimensions Data has %d dimensions, but got axis=%dc3`s%|]}|jˆdjkVqdS(iN(Rk(RLRM(R_(s.lib/python2.7/site-packages/dask/array/core.pys Ū sscStacked arrays must have the same shape. The first {0} had shape {1}, while array {2} has shape {3}c3`s|]}|ˆfVqdS(N((RLRM(R!(s.lib/python2.7/site-packages/dask/array/core.pys å scs`s|]}|jVqdS(N(Re(RLRX((s.lib/python2.7/site-packages/dask/array/core.pys ė ssstack-iRRm(iN(N(RpRkRœRRVRfRBRšRcRoRRHRR`RmRGRįRReR­RRR RORKRrRdR:RR(R_R†RÕR’RMtidxRaR’RXRrReRdR­R RuR‚R=tinpRwR}Rt((R!R_s.lib/python2.7/site-packages/dask/array/core.pyRn± s>"   ?   "("(+7@Qc C`set|ƒ}|stjdƒSttj|dttfƒdd„ƒ}tj t |ƒƒtj k r’t |ƒ}t |dtt|jƒƒƒSt|ƒ}|sØ|St|ƒ}ttt|ƒƒ}d„}tjd|d|t|ƒƒƒ}xhtt|ƒtj|ƒƒD]H\}} t| d ƒrSx | j|krO| d } q3Wn| ||>> x = np.array([[1, 2]]) >>> concatenate3([[x, x, x], [x, x, x]]) array([[1, 2, 1, 2, 1, 2], [1, 2, 1, 2, 1, 2]]) >>> concatenate3([[x, x], [x, x], [x, x]]) array([[1, 2, 1, 2], [1, 2, 1, 2], [1, 2, 1, 2]]) it containerR‚cS`st|ddƒS(NRƒi(R8(RM((s.lib/python2.7/site-packages/dask/array/core.pyR„R…RcS`s*y |jSWntk r%t|ƒSXdS(N(RmR9RŠ(RM((s.lib/python2.7/site-packages/dask/array/core.pyRms  RkRmR’.N(N.(R#RVR)R‹R8RķRcRRRˆR‰RŠRDRR‡RoR’R.RžRRyRRdRlRLRK( RŒtadvancedRMR’ReRkRmRäR„Rs((s.lib/python2.7/site-packages/dask/array/core.pyR ž s*       $+cC`sft|ƒt|ƒkr'tdƒ‚ntdt|ƒjt|ƒdƒ}tt||d|ƒƒS(s, Recursively call np.concatenate along axes s2Length of axes should equal depth of nested arraysiiR¢(RpR.RœR‹RR’R R¤(RŒRR¢((s.lib/python2.7/site-packages/dask/array/core.pytconcatenate_axes0s&c O`s\t|ƒdkr2t|dtƒr2|d}n\t|ƒdkr‚t|dtƒr‚t|dtƒr‚i|d|d6}n tdƒ‚|jdtƒ}ddl}|j |ƒ›}g|j ƒD]h\}}|j |d|j d|j d|tkr'tg|jD]} | d^qƒn||^qĖ} tt|jƒƒ| ƒWdQXdS( s« Store arrays in HDF5 file This saves several dask arrays into several datapaths in an HDF5 file. It creates the necessary datasets and handles clean file opening/closing. >>> da.to_hdf5('myfile.hdf5', '/x', x) # doctest: +SKIP or >>> da.to_hdf5('myfile.hdf5', {'/x': x, '/y': y}) # doctest: +SKIP Optionally provide arguments as though to ``h5py.File.create_dataset`` >>> da.to_hdf5('myfile.hdf5', '/x', x, compression='lzf', shuffle=True) # doctest: +SKIP This can also be used as a method on a single Array >>> x.to_hdf5('myfile.hdf5', '/x') # doctest: +SKIP See Also -------- da.store h5py.File.create_dataset iiis/Please provide {'/data/path': array} dictionaryReNRkRm(RpRNRrR©RRœRæRÅth5pytFileRÉtrequire_datasetRkRmRRReRRcRw( RURžRRoReRŖRtdpRMR\tdsets((s.lib/python2.7/site-packages/dask/array/core.pyRT9s%   xcC`sšg}d}}t|ƒt|ƒ}xg|||kr||dk rg|j||ƒ|d7}q)|j||ƒ|d7}|d7}q)Wt|ƒS(sK >>> interleave_none([0, None, 2, None], [1, 3]) (0, 1, 2, 3) iiN(RpRKRĶRR(RXRYRäR¶RŗRÕ((s.lib/python2.7/site-packages/dask/array/core.pytinterleave_nonefs   cC`s||ftd„|DƒƒS(sE >>> keyname('x', 3, [None, None, 0, 2]) ('x', 3, 0, 2) cs`s!|]}|dk r|VqdS(N(RK(RLRÖ((s.lib/python2.7/site-packages/dask/array/core.pys €s(RR(R­R¶tokey((s.lib/python2.7/site-packages/dask/array/core.pytkeynamezscG`s“t|j|ƒ}g}g}x‹t|ƒD]}\}}t|tƒrV|j|ƒq+t|tƒrˆ|j|ƒ|jtdƒƒq+|jtdƒƒ|j|ƒq+Wt|ƒ}t|ƒ}||}i}xĮtt ||j ƒƒD]§\}\}}t|tƒsķt j |dt ƒ}|jjdkrDtdƒ‚n||k|| kBjƒr}td|||fƒ‚n||;}|||>> x = np.arange(56).reshape((7, 8)) >>> x array([[ 0, 1, 2, 3, 4, 5, 6, 7], [ 8, 9, 10, 11, 12, 13, 14, 15], [16, 17, 18, 19, 20, 21, 22, 23], [24, 25, 26, 27, 28, 29, 30, 31], [32, 33, 34, 35, 36, 37, 38, 39], [40, 41, 42, 43, 44, 45, 46, 47], [48, 49, 50, 51, 52, 53, 54, 55]]) >>> d = from_array(x, chunks=(3, 4)) >>> result = _vindex(d, [0, 1, 6, 0], [0, 1, 0, 7]) >>> result.compute() array([ 0, 9, 48, 7]) RŹRYs4vindex does not support indexing with boolean arrayssNvindex key has entries out of bounds for indexing along axis %s of size %s: %rN(R@R’RĀRNRRĶRORKRRRdRkRVRCRÅRmRoRwRSt _vindex_array(RMtindexestnonfancy_indexestreduced_indexesR¶R!t array_indexesRC((s.lib/python2.7/site-packages/dask/array/core.pyRxƒs8    + c`sŖytj|jƒŒ}Wn@tk r[djd„|jƒDƒƒ}td|ƒ‚nX|dj}tt||ƒƒ}gt ˆj ƒD].}||kr¶||j ƒj ƒnd^qŽ}|jdgˆj t|ƒƒg|D]$}|dk rt|ƒn|^qź}gˆjD]} tttd| ƒƒ^q} gt|| ƒD]\}} |dk rS| ^qS} t|ƒ‰tˆ|ƒ‰dˆ} tƒ}xÜttg|D]}|dk rµ|^qµŒƒD]©\}}gt| |ƒD]%\} }tj| |dƒd^qó}gtt||ƒƒD]$\}\}}|| ||^q4}|j|t|ƒt|ƒfƒq×Wgt|ˆjƒD]\}} |dkr—| ^q—}|jd|rŁt|ƒfndƒt|ƒ}|rRtd|ƒ‰td„ˆjƒDƒƒ‰ttgt|ˆjƒD]9\}} |dkrftt t| ƒƒƒndg^q6Œƒ‰g|D]'}|dkr£tddƒnd^q‚‰d ˆ‰t‡‡‡‡‡‡fd †tˆƒDƒƒ}|j‡‡‡fd †ˆDƒƒt t!j"| |d ˆgƒ| |ˆj#ƒ}|j$||jdƒSdd l%m&}|tt't(|ƒƒd|dˆj#d| ƒ}|j$||jdƒS(s+Point wise indexing with only NumPy Arrays.Rvcs`s|]}t|jƒVqdS(N(R©Rk(RLRX((s.lib/python2.7/site-packages/dask/array/core.pys ĆssLshape mismatch: indexing arrays could not be broadcast together with shapes is vindex-merge-trightics`s'|]\}}|r||fVqdS(N((RLRÖRŲ((s.lib/python2.7/site-packages/dask/array/core.pys ęss vindex-slice-c3`s|]w\}}ˆD]d}tˆ||ƒttˆjft||ƒtˆtttdˆ|ƒŒƒƒfˆffVqqdS(iN(R±t_vindex_transposet _vindex_sliceR­RÆRcRdR(RLR¶R‚R°(R†t full_slicesR­t other_blockst per_blockRM(s.lib/python2.7/site-packages/dask/array/core.pys šs c 3`s…|]{}tdˆd|ƒtgˆD]}ttdˆ|ƒƒ^q&gttˆƒƒD]}tˆ||ƒ^q[ffVqdS(s vindex-merge-iN(R±t _vindex_mergeRcRRoRp(RLR°R‚R¶(R­R¼R®(s.lib/python2.7/site-packages/dask/array/core.pys ųsR(R)ReRmR­N(i(i()RVR˜RwRœR—RwRkRrRdRoR’RƒRzRKRļRpRcReRR t _get_axisRRĀt searchsortedRĶRRRÄRRÉRROtupdateRR:RRmR†twrapR)RRy(RMt dict_indexestbroadcast_indexest shapes_strtbroadcast_shapetlookupR¶t flat_indexesRYR\tboundsRYtbounds2RttpointsR„R!t block_idxRÖRŗt inblock_idxReRĖt result_1dR)((R†RŗR­R»R¼R®RMs.lib/python2.7/site-packages/dask/array/core.pyR²¼s\  A!1/4   >8=&7%  U4  -cC`svt|ƒ}g|D]*}|dkr4tddƒndg^q}tjd|ƒ}|t|ƒ}|jjdƒS(sP Get axis along which point-wise slicing results lie This is mostly a hack because I can't figure out NumPy's rule on this and can't be bothered to go reading. >>> _get_axis([[1, 2], None, [1, 2], None]) 0 >>> _get_axis([None, [1, 2], [1, 2], None]) 1 >>> _get_axis([None, None, [1, 2], [1, 2]]) 2 iiiN(i(RpRKRORVR)RRRkRY(R³R’R¶RMtx2((s.lib/python2.7/site-packages/dask/array/core.pyR¾ s 7cC`sBg|D]'}t|tƒr"|n t|ƒ^q}|t|ƒS(s' Pull out point-wise slices from block (RNRORcRR(R^RŹtp((s.lib/python2.7/site-packages/dask/array/core.pyR¹!s4cC`s@|gtt|ƒƒtt|d|jƒƒ}|j|ƒS(s8 Rotate block so that points are on the first dimension i(RcRoR’R(R^R†R((s.lib/python2.7/site-packages/dask/array/core.pyRø's3c C`sźttt|ƒƒ}t|ƒ}ttt|ƒƒ}t|djƒ}||d>> locations = [0], [2, 1] >>> values = [np.array([[1, 2, 3]]), ... np.array([[10, 20, 30], [40, 50, 60]])] >>> _vindex_merge(locations, values) array([[ 1, 2, 3], [40, 50, 60], [10, 20, 30]]) iRmN(RcRRyRpRkRRRmRVR)RoR’RORKRd( t locationsRwRÕRkRmRMR¶R!tlocRF((s.lib/python2.7/site-packages/dask/array/core.pyR½-s     + c `s$t‡fd†t|jƒDƒƒ}|j|ƒ}tjjˆƒsVtjˆƒni|d6|jd6ˆd6}t tjj ˆdƒdƒ}t j ||ƒWdQXdt tjƒƒ‰‡‡fd †ttj|jƒƒƒDƒ}tjˆ|d |gƒ}tt|t|ƒƒdS( s_ Write dask array to a stack of .npy files This partitions the dask.array along one axis and stores each block along that axis as a single .npy file in the specified directory Examples -------- >>> x = da.ones((5, 10, 10), chunks=(2, 4, 4)) # doctest: +SKIP >>> da.to_npy_stack('data/', x, axis=0) # doctest: +SKIP $ tree data/ data/ |-- 0.npy |-- 1.npy |-- 2.npy |-- info The ``.npy`` files store numpy arrays for ``x[0:2], x[2:4], and x[4:5]`` respectively, as is specified by the chunk size along the zeroth axis. The info file stores the dtype, chunks, and axis information of the array. You can load these stacks with the ``da.from_npy_stack`` function. >>> y = da.from_npy_stack('data/') # doctest: +SKIP See Also -------- from_npy_stack c3`s6|],\}}|ˆkr!|n t|ƒfVqdS(N(Ry(RLR¶R\(R†(s.lib/python2.7/site-packages/dask/array/core.pys msReRmR†RßtwbNs to-npy-stack-c`sDi|]:\}}tjtjjˆd|ƒ|fˆ|f“qS(s%d.npy(RVtsavetosR$R—(RLR¶R‚(tdirnameR­(s.lib/python2.7/site-packages/dask/array/core.pys zs R(RRRĀReRąRŌR$texiststmkdirRmtopenR—tpickletdumpR©RšRńR8RķRīR:RRRRc( RÕRMR†RetxxtmetaRRĖRt((R†RÕR­s.lib/python2.7/site-packages/dask/array/core.pyt to_npy_stackNs!Rc C`sttjj|dƒdƒ}tj|ƒ}WdQX|d}|d}|d}d|}tt|gg|D]}tt |ƒƒ^qqŒƒ} gtt ||ƒƒD]+} t jtjj|d| ƒ|f^q¬} t t | | ƒƒ} t | |||ƒS( sķ Load dask array from stack of npy files See ``da.to_npy_stack`` for docstring Parameters ---------- dirname: string Directory of .npy files mmap_mode: (None or 'r') Read data in memory map mode RßR!NRmReR†sfrom-npy-stack-%ss%d.npy(RŲRŌR$R—RŁtloadRcRRoRpRVRrRdR( RÕt mmap_modeRRßRmReR†R­R\RuR¶RwRĖ((s.lib/python2.7/site-packages/dask/array/core.pytfrom_npy_stacks !    7E(“t __future__RRRRRŹt functoolsRRt itertoolsRRtnumbersRRRqR R R RŌRŖR•R˜RŁt threadingR RšRĄtcytoolzR RRRRtcytoolz.curriedRt ImportErrorttoolzt toolz.curriedRRRtnumpyRVR…RRRpRRRRRRRARRtcontextR tutilsR!R"R#R$R%R&R'R(R)R*R+R,R-R.t compatibilityR/R0R1R2R3R8R4R5R6R7R9thighlevelgraphR:t bytes.coreR;R<t numpy_compatR=R>RqR?R@tupdate_defaultsRˆttensordot_lookupt einsum_lookuptregisterR|R3RDRERFtWarningRGRÅRKRTR]R^t optimizationR_R`RlRĘRxR€R‡RØR¬RµRēRR RR~RRRčRnRRR R,RłR2R6R7R>RHRR^ReRfRgRņRóRPRBRtRzR:R€RRŒR˜RœRžRRŸR R¤RnR R©RTRÆR±RxR²R¾R¹RøR½RŻRą(((s.lib/python2.7/site-packages/dask/array/core.pytsü          ( ( .^(        &9  ’2 ,  ˆ   ’’’ļ    p  f,; (  @ Q  µe .  9 ! $ ) ! G  ( B  $   M 2 -  9 Q    ! 3