a ߙfb @sdZddlmZddlZddlZddlmZmZddlmZm Z ddl Z ddl m Z ddlmZdd lmZmZmZmZmZdd lmZdd lmZdd lmZmZgd ZdgdgdZdDddZddZ ddZ!dEddZ"dFddZ#dGdddddgddd d!d"Z$dHd#d$Z%dId&d'Z&dJd(d)Z'dKd*d+Z(dLd.d/Z)dMd0d1Z*d2d3Z+d4d5Z,d6d7Z-d8d9Z.dddddgdddddf d:d;Z/dd?Z1dNd@dAZ2dOdBdCZ3dS)PzU High-level table operations: - join() - setdiff() - hstack() - vstack() - dstack() )deepcopyN) OrderedDictCounter)MappingSequence)metadata)Masked)TableQTableRowColumn MaskedColumn)Quantity) _np_utils)fix_column_nameTableMergeError)joinsetdiffhstackvstackunique join_skycoord join_distanceZscipy)rrwarncCsBt|dj}|ddD]}tj||j|d}q|j|dS)Nrr metadata_conflicts)rmetarmergeupdate)outtablesrZout_metatabler#7lib/python3.9/site-packages/astropy/table/operations.py_merge_table_meta"sr%c Cst|ts|g}t|dkr$tdt|D]\}}t|tr@q,t|trXt|||<q,t|trrt|g||<q,zt|g||<Wq,tt fy}zt d|d|WYd}~q,d}~00q,|S)zl Check that tables is a Table or sequence of Tables. Returns the corresponding list of Tables. rzno values provided to stack.zCannot convert z to table column.N) isinstancerlen ValueError enumerater r rr TypeError)r!iivalerrr#r#r$_get_list_of_tables)s      *r.cs`|dj|ddD]}t|jr|jqtfdd|Dr\tddd|DS) a  From a list of input objects ``objs`` get merged output object class. This is just taken as the deepest subclass. This doesn't handle complicated inheritance schemes, but as a special case, classes which share ``info`` are taken to be compatible. rr Nc3s*|]"}t|jpj|jju VqdSN) issubclass __class__info.0objZ out_classr#r$ Vs  z!_get_out_class..zunmergeable object classes {}cSsg|] }|jjqSr#)r1__name__r3r#r#r$ Yz"_get_out_class..)r1r0anyr(format)Zobjsr5r#r6r$_get_out_classIs    r=search_around_skyc sttrVddlm}zt|WqrtyR}ztd|WYd}~qrd}~00nddlm}|srtdfdd}|S)a Helper function to join on SkyCoord columns using distance matching. This function is intended for use in ``table.join()`` to allow performing a table join where the key columns are both ``SkyCoord`` objects, matched by computing the distance between points and accepting values below ``distance``. The distance cross-matching is done using either `~astropy.coordinates.search_around_sky` or `~astropy.coordinates.search_around_3d`, depending on the value of ``distance_func``. The default is ``'search_around_sky'``. One can also provide a function object for ``distance_func``, in which case it must be a function that follows the same input and output API as `~astropy.coordinates.search_around_sky`. In this case the function will be called with ``(skycoord1, skycoord2, distance)`` as arguments. Parameters ---------- distance : `~astropy.units.Quantity` ['angle', 'length'] Maximum distance between points to be considered a join match. Must have angular or distance units. distance_func : str or function Specifies the function for performing the cross-match based on ``distance``. If supplied as a string this specifies the name of a function in `astropy.coordinates`. If supplied as a function then that function is called directly. Returns ------- join_func : function Function that accepts two ``SkyCoord`` columns (col1, col2) and returns the tuple (ids1, ids2) of pair-matched unique identifiers. Examples -------- This example shows an inner join of two ``SkyCoord`` columns, taking any sources within 0.2 deg to be a match. Note the new ``sc_id`` column which is added and provides a unique source identifier for the matches. >>> from astropy.coordinates import SkyCoord >>> import astropy.units as u >>> from astropy.table import Table, join_skycoord >>> from astropy import table >>> sc1 = SkyCoord([0, 1, 1.1, 2], [0, 0, 0, 0], unit='deg') >>> sc2 = SkyCoord([0.5, 1.05, 2.1], [0, 0, 0], unit='deg') >>> join_func = join_skycoord(0.2 * u.deg) >>> join_func(sc1, sc2) # Associate each coordinate with unique source ID (array([3, 1, 1, 2]), array([4, 1, 2])) >>> t1 = Table([sc1], names=['sc']) >>> t2 = Table([sc2], names=['sc']) >>> t12 = table.join(t1, t2, join_funcs={'sc': join_skycoord(0.2 * u.deg)}) >>> print(t12) # Note new `sc_id` column with the IDs from join_func() sc_id sc_1 sc_2 deg,deg deg,deg ----- ------- -------- 1 1.0,0.0 1.05,0.0 1 1.1,0.0 1.05,0.0 2 2.0,0.0 2.1,0.0 rNz7distance_func must be a function in astropy.coordinates) isfunctionz'distance_func must be a str or functionc s||\}}}}tjt|td}tjt|td}d}t||D]T\} } || dkrh|| || <qF|| dkr|| || <qF||| <||| <|d7}qF||fD](} t| dkD]} || | <|d7}qq||fS)Ndtyper r)npzerosr'intzip flatnonzero) Zsc1Zsc2Zidxs1idxs2Zd2dZd3dids1ids2id_idx1idx2idsidxdistance distance_funcr#r$ join_funcs"     z join_skycoord..join_func) r&strZastropy.coordinatesZ coordinatesgetattrAttributeErrorr(inspectr?)rPrQZcoordsr-r?rRr#rOr$r^sA  " &rc snzddlmWn.ty>}ztd|WYd}~n d}~00durLidurXifdd}|S)aHelper function to join table columns using distance matching. This function is intended for use in ``table.join()`` to allow performing a table join where the key columns are matched by computing the distance between points and accepting values below ``distance``. This numerical "fuzzy" match can apply to 1-D or 2-D columns, where in the latter case the distance is a vector distance. The distance cross-matching is done using `scipy.spatial.cKDTree`. If necessary you can tweak the default behavior by providing ``dict`` values for the ``kdtree_args`` or ``query_args``. Parameters ---------- distance : float or `~astropy.units.Quantity` ['length'] Maximum distance between points to be considered a join match kdtree_args : dict, None Optional extra args for `~scipy.spatial.cKDTree` query_args : dict, None Optional extra args for `~scipy.spatial.cKDTree.query_ball_tree` Returns ------- join_func : function Function that accepts (skycoord1, skycoord2) and returns the tuple (ids1, ids2) of pair-matched unique identifiers. Examples -------- >>> from astropy.table import Table, join_distance >>> from astropy import table >>> c1 = [0, 1, 1.1, 2] >>> c2 = [0.5, 1.05, 2.1] >>> t1 = Table([c1], names=['col']) >>> t2 = Table([c2], names=['col']) >>> t12 = table.join(t1, t2, join_type='outer', join_funcs={'col': join_distance(0.2)}) >>> print(t12) col_id col_1 col_2 ------ ----- ----- 1 1.0 1.05 1 1.1 1.05 2 2.0 2.1 3 0.0 -- 4 -- 0.5 r)cKDTreez(scipy is required to use join_distance()Ncs|jdks|jdkrtdttrF|j}|j}j}nt|}t|}}|jdkrt|j d|_ |jdkr|j d|_ |fi}|fi}|j |fd|i}tj t |t d}tj t |t d}d}t|D]b\} } | D]T} || dkr|| || <q|| dkr8|| || <q||| <||| <|d7}qq||fD],} t| dkD]} || | <|d7}qnq\||fS)Nz4columns for isclose_join must be 1- or 2-dimensionalr r rr@r)ndimr(r&rZto_valueZunitvaluerBZasarrayshapeZquery_ball_treerCr'rDr)rF)Zcol1Zcol2ZdistZkd1Zkd2ZnearsrHrIrJrKrGrLrMrNrWrP kdtree_args query_argsr#r$rRsB            z join_distance..join_func)Z scipy.spatialrW ImportError)rPr_r`excrRr#r^r$rs2 Arinner{col_name}_{table_name}12) keys_left keys_right uniq_col_name table_namesr join_funcsc Cs^t|tst|}t|ts$t|}t} t||||||| || ||d } t| ||g|d| S)a Perform a join of the left table with the right table on specified keys. Parameters ---------- left : `~astropy.table.Table`-like object Left side table in the join. If not a Table, will call ``Table(left)`` right : `~astropy.table.Table`-like object Right side table in the join. If not a Table, will call ``Table(right)`` keys : str or list of str Name(s) of column(s) used to match rows of left and right tables. Default is to use all columns which are common to both tables. join_type : str Join type ('inner' | 'outer' | 'left' | 'right' | 'cartesian'), default is 'inner' keys_left : str or list of str or list of column-like, optional Left column(s) used to match rows instead of ``keys`` arg. This can be be a single left table column name or list of column names, or a list of column-like values with the same lengths as the left table. keys_right : str or list of str or list of column-like, optional Same as ``keys_left``, but for the right side of the join. uniq_col_name : str or None String generate a unique output column name in case of a conflict. The default is '{col_name}_{table_name}'. table_names : list of str or None Two-element list of table names used when generating unique output column names. The default is ['1', '2']. metadata_conflicts : str How to proceed with metadata conflicts. This should be one of: * ``'silent'``: silently pick the last conflicting meta-data value * ``'warn'``: pick the last conflicting meta-data value, but emit a warning (default) * ``'error'``: raise an exception. join_funcs : dict, None Dict of functions to use for matching the corresponding key column(s). See `~astropy.table.join_skycoord` for an example and details. Returns ------- joined_table : `~astropy.table.Table` object New table containing the result of the join operation. )rgrhr)r&r r_joinr%) leftrightkeys join_typergrhrirjrrk col_name_mapr r#r#r$rSs/   rc Cs|dur|j}|df|dffD]2\}}t||j}t|dkrtd||q|jdd}i|_||t t||d<|jdd}i|_||tj t|tj d |d <t ||d |d d }t |d dr|d j} |d| } || } n|g} | S)a Take a set difference of table rows. The row set difference will contain all rows in ``table1`` that are not present in ``table2``. If the keys parameter is not defined, all columns in ``table1`` will be included in the output table. Parameters ---------- table1 : `~astropy.table.Table` ``table1`` is on the left side of the set difference. table2 : `~astropy.table.Table` ``table2`` is on the right side of the set difference. keys : str or list of str Name(s) of column(s) used to match rows of left and right tables. Default is to use all columns in ``table1``. Returns ------- diff_table : `~astropy.table.Table` New table containing the set difference between tables. If the set difference is none, an empty table will be returned. Examples -------- To get a set difference between two tables:: >>> from astropy.table import setdiff, Table >>> t1 = Table({'a': [1, 4, 9], 'b': ['c', 'd', 'f']}, names=('a', 'b')) >>> t2 = Table({'a': [1, 5, 9], 'b': ['c', 'b', 'f']}, names=('a', 'b')) >>> print(t1) a b --- --- 1 c 4 d 9 f >>> print(t2) a b --- --- 1 c 5 b 9 f >>> print(setdiff(t1, t2)) a b --- --- 4 d >>> print(setdiff(t2, t1)) a b --- --- 5 b Ntable1table2rzAThe {} columns are missing from {}, cannot take a set difference.FZ copy_dataZ __index1__r@Z __index2__rmsilent)rprormask)colnamesrBZ setdiff1dr'r(r<copyrZ keep_columnsarangerCuint8rlhasattrrv) rrrsroZtblZtbl_strZ diff_keyst1t2Zt12diffrNZt12_diffr#r#r$rs25         routerc Cst|dt|}t|dkr&|dStdd|D}t|dkrLtd|}t|||}|jD]\}}||}t||f|j dd}z t||f|j dd|_ Wnt y| |}Yn0t t|j } ddg| dd<|jj||| d d qj|S) a Stack columns within tables depth-wise A ``join_type`` of 'exact' means that the tables must all have exactly the same column names (though the order can vary). If ``join_type`` is 'inner' then the intersection of common columns will be the output. A value of 'outer' (default) means the output will have the union of all columns, with table values being masked where no common values are available. Parameters ---------- tables : `~astropy.table.Table` or `~astropy.table.Row` or list thereof Table(s) to stack along depth-wise with the current table Table columns should have same shape and name for depth-wise stacking join_type : str Join type ('inner' | 'exact' | 'outer'), default is 'outer' metadata_conflicts : str How to proceed with metadata conflicts. This should be one of: * ``'silent'``: silently pick the last conflicting meta-data value * ``'warn'``: pick the last conflicting meta-data value, but emit a warning (default) * ``'error'``: raise an exception. Returns ------- stacked_table : `~astropy.table.Table` object New table containing the stacked data from the input tables. Examples -------- To stack two tables along rows do:: >>> from astropy.table import vstack, Table >>> t1 = Table({'a': [1, 2], 'b': [3, 4]}, names=('a', 'b')) >>> t2 = Table({'a': [5, 6], 'b': [7, 8]}, names=('a', 'b')) >>> print(t1) a b --- --- 1 3 2 4 >>> print(t2) a b --- --- 5 7 6 8 >>> print(dstack([t1, t2])) a [2] b [2] ------ ------ 1 .. 5 3 .. 7 2 .. 6 4 .. 8 dstackr rcss|]}t|VqdSr/r')r4r"r#r#r$r7,r:zdstack..z'Table lengths must all match for dstackNrXT)Z validated)_check_join_typer.r'setr(poprcolumnsitemsr]rUZreshaperBry __setitem__Z transpose) r!rprn_rowsZn_rowr namecolZ new_shapeZaxesr#r#r$rs(4      rcCsLt|dt|}t|dkr&|dSt}t||||}t|||d|S)a Stack tables vertically (along rows) A ``join_type`` of 'exact' means that the tables must all have exactly the same column names (though the order can vary). If ``join_type`` is 'inner' then the intersection of common columns will be the output. A value of 'outer' (default) means the output will have the union of all columns, with table values being masked where no common values are available. Parameters ---------- tables : `~astropy.table.Table` or `~astropy.table.Row` or list thereof Table(s) to stack along rows (vertically) with the current table join_type : str Join type ('inner' | 'exact' | 'outer'), default is 'outer' metadata_conflicts : str How to proceed with metadata conflicts. This should be one of: * ``'silent'``: silently pick the last conflicting meta-data value * ``'warn'``: pick the last conflicting meta-data value, but emit a warning (default) * ``'error'``: raise an exception. Returns ------- stacked_table : `~astropy.table.Table` object New table containing the stacked data from the input tables. Examples -------- To stack two tables along rows do:: >>> from astropy.table import vstack, Table >>> t1 = Table({'a': [1, 2], 'b': [3, 4]}, names=('a', 'b')) >>> t2 = Table({'a': [5, 6], 'b': [7, 8]}, names=('a', 'b')) >>> print(t1) a b --- --- 1 3 2 4 >>> print(t2) a b --- --- 5 7 6 8 >>> print(vstack([t1, t2])) a b --- --- 1 3 2 4 5 7 6 8 rr rr)rr.r'r_vstackr%)r!rprrqr r#r#r$rOs5  rcCsNt|dt|}t|dkr&|dSt}t|||||}t|||d|S)a3 Stack tables along columns (horizontally) A ``join_type`` of 'exact' means that the tables must all have exactly the same number of rows. If ``join_type`` is 'inner' then the intersection of rows will be the output. A value of 'outer' (default) means the output will have the union of all rows, with table values being masked where no common values are available. Parameters ---------- tables : `~astropy.table.Table` or `~astropy.table.Row` or list thereof Tables to stack along columns (horizontally) with the current table join_type : str Join type ('inner' | 'exact' | 'outer'), default is 'outer' uniq_col_name : str or None String generate a unique output column name in case of a conflict. The default is '{col_name}_{table_name}'. table_names : list of str or None Two-element list of table names used when generating unique output column names. The default is ['1', '2', ..]. metadata_conflicts : str How to proceed with metadata conflicts. This should be one of: * ``'silent'``: silently pick the last conflicting meta-data value * ``'warn'``: pick the last conflicting meta-data value, but emit a warning (default) * ``'error'``: raise an exception. Returns ------- stacked_table : `~astropy.table.Table` object New table containing the stacked data from the input tables. See Also -------- Table.add_columns, Table.replace_column, Table.update Examples -------- To stack two tables horizontally (along columns) do:: >>> from astropy.table import Table, hstack >>> t1 = Table({'a': [1, 2], 'b': [3, 4]}, names=('a', 'b')) >>> t2 = Table({'c': [5, 6], 'd': [7, 8]}, names=('c', 'd')) >>> print(t1) a b --- --- 1 3 2 4 >>> print(t2) c d --- --- 5 7 6 8 >>> print(hstack([t1, t2])) a b c d --- --- --- --- 1 3 5 7 2 4 6 8 rr rr)rr.r'r_hstackr%)r!rprirjrrqr r#r#r$rs?   rFfirstcCs|dvrtdt|tr |g}|dur0|j}ntt|t|krLtd|ddD]@}||}t|drXt|j rX|std ||| |=qXt|dkrtd| |}|j j}|d kr|dd }n4|d kr|d dd }n|dd t|d k}||S) ae Returns the unique rows of a table. Parameters ---------- input_table : table-like keys : str or list of str Name(s) of column(s) used to create unique rows. Default is to use all columns. keep : {'first', 'last', 'none'} Whether to keep the first or last row for each set of duplicates. If 'none', all rows that are duplicate are removed, leaving only rows that are already unique in the input. Default is 'first'. silent : bool If `True`, masked value column(s) are silently removed from ``keys``. If `False`, an exception is raised when ``keys`` contains masked value column(s). Default is `False`. Returns ------- unique_table : `~astropy.table.Table` object New table containing only the unique rows of ``input_table``. Examples -------- >>> from astropy.table import unique, Table >>> import numpy as np >>> table = Table(data=[[1,2,3,2,3,3], ... [2,3,4,5,4,6], ... [3,4,5,6,7,8]], ... names=['col1', 'col2', 'col3'], ... dtype=[np.int32, np.int32, np.int32]) >>> table col1 col2 col3 int32 int32 int32 ----- ----- ----- 1 2 3 2 3 4 3 4 5 2 5 6 3 4 7 3 6 8 >>> unique(table, keys='col1')
col1 col2 col3 int32 int32 int32 ----- ----- ----- 1 2 3 2 3 4 3 4 5 >>> unique(table, keys=['col1'], keep='last')
col1 col2 col3 int32 int32 int32 ----- ----- ----- 1 2 3 2 5 6 3 6 8 >>> unique(table, keys=['col1', 'col2'])
col1 col2 col3 int32 int32 int32 ----- ----- ----- 1 2 3 2 3 4 2 5 6 3 4 5 3 6 8 >>> unique(table, keys=['col1', 'col2'], keep='none')
col1 col2 col3 int32 int32 int32 ----- ----- ----- 1 2 3 2 3 4 2 5 6 3 6 8 >>> unique(table, keys=['col1'], keep='none')
col1 col2 col3 int32 int32 int32 ----- ----- ----- 1 2 3 )rlastZnonez/'keep' should be one of 'first', 'last', 'none'Nzduplicate key namesrvz^cannot use columns with masked values as keys; remove column '{}' from keys and rerun unique()rzRno column remained in ``keys``; unique() cannot work with masked value key columnsrrr )r(r&rSrwr'rr{rBr;rvr<indexZgroup_bygroupsindicesr~)Z input_tableroruZkeepkeyrZ grouped_tablerr#r#r$rs8[   rc s tfddg}|dur4ddttD}tD]\}}||}|jD]p}|vrv|vr|n@t} | |t fdd| Dr|j |d}||||<qRqqr:z"get_col_name_map..NcSsg|]}t|dqSrY)rSr4r+r#r#r$r9ur:z$get_col_name_map..c3s|]}|jvVqdSr/rw)r4other)rr#r$r7r:z#get_col_name_map..) table_nameZcol_namecSsg|]\}}|dkr|qSrYr#)r4rcountr#r#r$r9r:zgMerging column names resulted in duplicates: {}. Change uniq_col_name or table_names args to fix this.c3s|]}||fVqdSr/r#r4r)rqr#r$r7r:) collections defaultdictranger'r)rwappendlistrr;r<rrrr) rZ common_namesrirjZ col_name_listrNarrayrout_nameZothersZcol_name_countZrepeated_namesr#)rrqrr$get_col_name_mapbs2    rc Csg}|D]\}}ddt||D}dd|D}z t|}Wn<ty~}z$td|d|j|WYd}~n d}~00tdd|D} t| d krtd |d | } | t ||| fq |S) z Find the dtypes descrs resulting from merging the list of arrays' dtypes, using the column name mapping ``col_name_map``. Return a list of descrs for the output. cSs g|]\}}|dur||qSr/r#r4arrrr#r#r$r9r:zget_descrs..cSsg|]}|dur|qSr/r#rr#r#r$r9r:,The '{}' columns have incompatible types: {}rNcss|]}|jddVqdS)r N)r])r4rr#r#r$r7r:zget_descrs..r z Key columns z have different shape) rrE common_dtyperr<_incompat_typesrr'rrr) rrq out_descrsrin_namesZin_colsnamesrAtmeZ uniq_shapesr]r#r#r$ get_descrss$   rc CsVz t|WStjyP}z*td|j}|j|_||WYd}~n d}~00dS)z Use numpy to find the common dtype for a list of columns. Only allow columns within the following fundamental numpy data types: np.bool_, np.object_, np.number, np.character, np.void z Columns have incompatible types N)rrMergeConflictErrorrr)colsr-rr#r#r$rs  rcCsd}g}g}i}i}|D]}||j} ||j} t| t| krPtdt| | D]\} } | jdd} | | jddkrtd| dkrtd|dt|}||| ||<| ||<t | | g}|||f|d7}qZqt|}t j |t||d}|D].}||||d|<|||||d<q |j |d }||}t d g|dd|dd kd gf}t |}||fS) Nrzmismatch in sort cols lengthsr z.mismatch in shape of left vs. right sort arrayr#zsort key column z must be 1-dr@)orderTr)r2Zget_sortable_arraysr' RuntimeErrorrEr]r(rSrrrBemptyZargsortZ concatenaterF)rormrnr+Zsort_keys_dtypesZ sort_keysZ sort_leftZ sort_rightrZleft_sort_colsZright_sort_colsZ left_sort_colZright_sort_colr]Zsort_keyZ dtype_strlen_leftZsortable_tableidx_sortZ sorted_tableZdiffsidxsr#r#r$_get_join_sort_idxssB    ( rcs|jdd}|jdd}|D]\}|||\}}d|jvsZ|jvrldddqFtfdd|D}|j|dd |j|dd q |||fS) zApply join_funcs FrtZ_idNc3s|]}|krn|VqdSr/r#)r4Zorig_keyZid_keyrr#r$r7r:z$_apply_join_funcs..r)rr)rxrrtupleZ add_column)rmrnrorkrRrHrIr#rr$_apply_join_funcs s  rc + s|} d} |dvrtd||dkrxr2td|r>td|jdd}jddtd || <td | <| f| d us| d ur|} }t|| | |\}d urtfd d |jDtd krt d nt t rf|dfdffD]b\}}D]T}||jvr*t d||t ||dr t ||jr t d||q q|d urtfdd |Dstd|dt||\}t|t}}|d ks|d krtdzt|\}}WntytdYn0| d us$| d ur0g| }|t|g||}t|g|}d ddddd|}t||||\}}}}}}t|g}|D]\}} }!|| krq||\}"}#|"rD|#rD||"|#g}$t|$}%t |%jdstd|%j|%j|$|||||<t|||"||#|||d d <qn@|"r`|"|||f\}}&}'}(n$|#r||#||f\}}&}'}(nt d|&||'})|rht |(rht |)trt |)t s|j |)dd})t |)t!rt |)t"st"|)dd})|)j#d fdt|)j#d|(_#t$|(|)j#}(z|)jj%|)|(<Wn<t&yf}*z"td ||)j'j|*WYd }*~*n d }*~*00|)||<qt | t(r| )||S)!aM Perform a join of the left and right Tables on specified keys. Parameters ---------- left : Table Left side table in the join right : Table Right side table in the join keys : str or list of str Name(s) of column(s) used to match rows of left and right tables. Default is to use all columns which are common to both tables. join_type : str Join type ('inner' | 'outer' | 'left' | 'right' | 'cartesian'), default is 'inner' uniq_col_name : str or None String generate a unique output column name in case of a conflict. The default is '{col_name}_{table_name}'. table_names : list of str or None Two-element list of table names used when generating unique output column names. The default is ['1', '2']. col_name_map : empty dict or None If passed as a dict then it will be updated in-place with the mapping of output to input column names. metadata_conflicts : str How to proceed with metadata conflicts. This should be one of: * ``'silent'``: silently pick the last conflicting meta-data value * ``'warn'``: pick the last conflicting meta-data value, but emit a warning (default) * ``'error'``: raise an exception. join_funcs : dict, None Dict of functions to use for matching the corresponding key column(s). See `~astropy.table.join_skycoord` for an example and details. Returns ------- joined_table : `~astropy.table.Table` object New table containing the result of the join operation. Z#__table_cartesian_join_temp_index__)rcrrmrn cartesianzjThe 'join_type' argument should be in 'inner', 'outer', 'left', 'right', or 'cartesian' (got '{}' instead)rz'cannot supply keys for a cartesian joinz-cannot supply join_funcs for a cartesian joinFrtrNc3s|]}|jvr|VqdSr/rr)rnr#r$r7rr:z_join..z/No keys in common between left and right tablesZLeftZRightz&{} table does not have key column {!r}rvz%{} key column {!r} has missing valuesc3s|]}|vVqdSr/r#)r4r)ror#r$r7r:zjoin_funcs keys z must be a subset of join keys z5input tables for join must both have at least one rowz(one or more key columns are not sortabler rXnew_likez-join unavailable for mixin column type(s): {}z*Unexpected column names (maybe one is ""?)rxrYzMjoin requires masking column '{}' but column type {} does not support masking)*r(r<rxrBrz_join_keys_left_rightrrwr'rr&rSr{r;rvallrorrNotImplementedErrorr*rrrZ join_innerr=r2r8rwhereZtaker rrrr]Z broadcast_tomask_val Exceptionr1rr)+rmrnrorprirjrqrrkrgrh _col_name_mapZcartesian_index_nameZ left_origZ right_origrZ arr_labelrrZ len_rightrrrZ int_join_typeZmaskedZn_outZleft_outZ left_maskZ right_outZ right_maskr rrAr]Z left_nameZ right_namercol_clsrZ array_outZ array_maskrr-r#)rornr$rl s,       "             rlc Csdd}|durtd|dus(|dur0td|dur@td|||d}|||d}t|t|krptd d d tt|D}|j||d d }|j||d d }|||fS)anDo processing to handle keys_left / keys_right args for join. This takes the keys_left/right inputs and turns them into a list of left/right columns corresponding to those inputs (which can be column names or column data values). It also generates the list of fake key column names (strings of "1", "2", etc.) that correspond to the input keys. c Sst|tr|g}g}|D]t}t|tr`z|||Wqty\t|d|Yq0qt|t|krt|d|||q|S)Nz table does not have key column z% table has different length from key )r&rSrKeyErrorr(r')ror"Zlabelrrr#r#r$ _keys_to_colss    z,_join_keys_left_right.._keys_to_colsNz7cannot supply join_funcs arg and keys_left / keys_rightz.keys_left and keys_right must both be providedz>keys arg must be None if keys_left and keys_right are suppliedrmrnz3keys_left and keys_right args must have same lengthcSsg|] }|qSr#r#rr#r#r$r9r:z)_join_keys_left_right..F)rrx)r(r'rr1) rmrnrorgrhrkrZ cols_leftZ cols_rightr#r#r$rs  rcCsJt|ts6d}t|tr.|d|d|d7}t||dvrFtddS)zCheck join_type arg in hstack and vstack. This specifically checks for the common mistake of call vstack(t1, t2) instead of vstack([t1, t2]). The subsequent check of ``join_type in ('inner', ..)`` does not raise in this case. z `join_type` arg must be a stringz. Did you accidentally call z(t1, t2, ..) instead of z([t1, t2], ..)?)rcexactrz:`join_type` arg must be one of 'inner', 'exact' or 'outer'N)r&rSr r*r()rpZ func_namemsgr#r#r$rs   rc Csh|}t|dkr|dSttjdd|D}t||}|dkrn|D]}tdd|DrJtdqJd }|d krtd d| D}t|dkrtd d d|D}t |}t |}| D]\} } ddt || D} t | } t | jds td| jz| j| ||| } Wn<tjy^}z td| |j|WYd}~n d}~00d}t | |D]\}}|t|}||jvr||| ||<nt| trt| ts|j| dd} t| trt| tst| dd} z| jj| ||<Wn<ty:}z"td| | jj|WYd}~n d}~00|}qn| || <qt|trd| ||S)a Stack Tables vertically (by rows) A ``join_type`` of 'exact' (default) means that the arrays must all have exactly the same column names (though the order can vary). If ``join_type`` is 'inner' then the intersection of common columns will be the output. A value of 'outer' means the output will have the union of all columns, with array values being masked where no common values are available. Parameters ---------- arrays : list of Tables Tables to stack by rows (vertically) join_type : str Join type ('inner' | 'exact' | 'outer'), default is 'outer' col_name_map : empty dict or None If passed as a dict then it will be updated in-place with the mapping of output to input column names. Returns ------- stacked_table : `~astropy.table.Table` object New table containing the stacked data from the input tables. r rcSsg|] }|jqSr#rr4rr#r#r$r9Sr:z_vstack..rcss|]}|duVqdSr/r#r4xr#r#r$r7Zr:z_vstack..zeInconsistent columns in input arrays (use 'inner' or 'outer' join_type to allow non-matching columns)rrccss,|]$\}}tdd|Dr||fVqdS)css|]}|duVqdSr/r#rr#r#r$r7cr:z$_vstack...N)r)r4rrr#r#r$r7bs z&Input arrays have no columns in commoncSsg|] }t|qSr#rrr#r#r$r9gr:cSs g|]\}}|dur||qSr/r#rr#r#r$r9mr:rz/vstack unavailable for mixin column type(s): {}rNFrzOvstack requires masking column '{}' but column type {} does not support masking)!r'r itertoolschainrvaluesr;rrrsumr=rEr{r2rr<r8rrrrrwr&r rrrrrr1rr)rrprqrrrZlensrr rrrrrr-Zidx0rrrKr#r#r$r1sp            rc s|}|dur"ddtt|D}t|t|kr:tdt|dkrN|dSt|g||}dd|D}|dkrtt|dkrtd d }|d krt|tt|dkrfd d|D}fd d|D}t|}t|}| D]\} } t | ||D]\} } } | durq|| krt |}d|| d<| | |}t |trlt |tsl|j|dd}t |trt |tst|dd}z|jj|| d<Wn<ty}z"td| |jj|WYd}~n d}~00n| | d|}||| <qqt |tr|||S)a" Stack tables horizontally (by columns) A ``join_type`` of 'exact' (default) means that the arrays must all have exactly the same number of rows. If ``join_type`` is 'inner' then the intersection of rows will be the output. A value of 'outer' means the output will have the union of all rows, with array values being masked where no common values are available. Parameters ---------- arrays : List of tables Tables to stack by columns (horizontally) join_type : str Join type ('inner' | 'exact' | 'outer'), default is 'outer' uniq_col_name : str or None String generate a unique output column name in case of a conflict. The default is '{col_name}_{table_name}'. table_names : list of str or None Two-element list of table names used when generating unique output column names. The default is ['1', '2', ..]. Returns ------- stacked_table : `~astropy.table.Table` object New table containing the stacked data from the input tables. NcSsg|]}|dqSrYr#rr#r#r$r9r:z_hstack..z1Number of arrays must match number of table_namesr rcSsg|] }t|qSr#rrr#r#r$r9r:rziInconsistent number of rows in input arrays (use 'inner' or 'outer' join_type to allow non-matching rows)rrccsg|]}|dqSr/r#rZ min_arr_lenr#r$r9r:csg|]}qSr#r#rrr#r$r9r:FrzOhstack requires masking column '{}' but column type {} does not support masking)rr'r(rrrminmaxr=rrErBryr&r rrrr2rrrr<r1r8rr)rrprirjrqrZarr_lensrr rrrrZarr_lenrrr-r#rr$rs^          r)r)r>)NN)Nrc)N)rr)rr)rrdNr)NFr)rdN)rNr)rrdNN)4__doc__rxrrrrrcollections.abcrrZnumpyrBZ astropy.utilsrZastropy.utils.maskedrr"r r r r rZ astropy.unitsrrZnp_utilsrr__all__Z__doctest_requires__r%r.r=rrrrrrrrrrrrrrlrrrrr#r#r#r$sp        u  A ^ ] D N  8%= K4 j