[c @`sddlmZmZmZmZddlmZddlmZddl Z ddl Z ddl Z ddl m Z ddlZddlmZyddlmZWnek reZnXdd lmZmZdd lmZdd lmZdd lmZmZdd lm Z ddlm!Z!ddl"m#Z#ddl"m$Z$ddl%m&Z&ddl'm(Z(m)Z)e$j*Z+de,fdYZ-e j.de-dZ/e0ej1ej2ej3ej4ej5ej6ej7ej8ej9ej:ej;g Z<e=dZ>dej?fdYZ@defdYZAde(ej?fdYZBdeBfd YZCd!eCe)ejDfd"YZEdS(#i(tabsolute_importtdivisiontprint_functiontunicode_literalsi(tsix(tzipN(tdeepcopy(tma(tMaskedArrayFutureWarning(tUnittQuantity(t color_print(tMetaData(tBaseColumnInfotdtype_info_name(tdtype_bytes_or_chars(trangei(tgroups(tpprint(tfix_column_name(t_ColumnGetitemShimt_MaskedColumnGetitemShimtStringTruncateWarningcB`seZdZRS(u% Warning class for when a string column is assigned a value that gets truncated because the base (numpy) string length is too short. This does not inherit from AstropyWarning because we want to use stacklevel=2 to show the user where the issue occurred in their code. (t__name__t __module__t__doc__(((s3lib/python2.7/site-packages/astropy/table/column.pyR+sualwayscC`s?ddlm}gt|D]}t|jj|^qS(Ni(tconf(tRRtstrt auto_colnametformat(tn_colsRti((s3lib/python2.7/site-packages/astropy/table/column.pyt _auto_names;scC`st|tr|jS|jj}|jj}d|j_g|j_zt|drg|jn t|}|j|_|rt|pgng|j_x$|jjD]}|j ||qWWd||j_||j_X|S(u Mixin-safe version of Column.copy() (with copy_data=True). Parameters ---------- col : Column or mixin column Input column copy_indices : bool Copy the column ``indices`` attribute Returns ------- col : Copy of input column ucopyN( t isinstancet BaseColumntcopytinfot parent_tabletindicestNonethasattrRt replace_col(tcolt copy_indicesR&R'tnewcoltindex((s3lib/python2.7/site-packages/astropy/table/column.pytcol_copyIs     ' $  t FalseArraycB`s5eZdZdZdZejr3dZnRS(u Boolean mask array that is always False. This is used to create a stub ``mask`` property which is a boolean array of ``False`` used by default for mixin columns and corresponding to the mixin column data shape. The ``mask`` looks like a normal numpy array but an exception will be raised if ``True`` is assigned to any element. The consequences of the limitation are most obvious in the high-level table operations. Parameters ---------- shape : tuple Data shape cC`s%tj|dtjj|}|S(Ntdtype(tnptzerostbooltview(tclstshapetobj((s3lib/python2.7/site-packages/astropy/table/column.pyt__new__s!cC`s@tj|}tj|r<tdj|jjndS(Nu+Cannot set any element of {0} class to True(R2tasarraytanyt ValueErrorRt __class__R(tselftitemtval((s3lib/python2.7/site-packages/astropy/table/column.pyt __setitem__s cC`s|jt|||dS(N(RAtslice(R>tstarttstopR@((s3lib/python2.7/site-packages/astropy/table/column.pyt __setslice__s(RRRR9RARtPY2RE(((s3lib/python2.7/site-packages/astropy/table/column.pyR0ss    t ColumnInfocB`s,eZdZejZeZdddZ RS(u Container for meta information like name, description, format. This is required when the object is used as a mixin column within a table, but can be used as a general way to store meta information. uwarncC`s+|j|||d}|jd||S(u Return a new Column instance which is consistent with the input ``cols`` and has ``length`` rows. This is intended for creating an empty column object whose elements can be set in-place for table operations like join or vstack. Parameters ---------- cols : list List of input columns length : int Length of the output column object metadata_conflicts : str ('warn'|'error'|'silent') How to handle metadata conflicts name : str Output column name Returns ------- col : Column (or subclass) New instance of this class consistent with ``cols`` umetauunituformatu descriptiontlength(umetauunituformatu description(tmerge_cols_attributest _parent_cls(R>tcolsRHtmetadata_conflictstnametattrs((s3lib/python2.7/site-packages/astropy/table/column.pytnew_likes N( RRRR t attr_namestattrs_from_parenttTruet_supports_indexingR(RO(((s3lib/python2.7/site-packages/astropy/table/column.pyRGs R#c B`seZeZd d d d!dd d d d eed ZedZ edZ e j dZ e Z dd edZdZdZd Zd d Zed Zej d Zed ZdZdZedZd eeeedZd eeedZd eedZedZej dZejdZgdZedZdZdZ dZ!edZ"gdZ#dZ$e%dZ&RS("ic C`s|dkr<tj|j|f}tj|d|} nt|trt|drtj|j d|d| } |dkr|j }n|dkr|p|j }n|dkr|j }n| dkrt |j} n|dkr|j}qnt|tr|dkrAtj|d|d| } |j }n$tj|j|d|d| } |dkr|jj }n|dkr|jj }n| dkrt |jj} qnOtj rtj|jdkr|j|}ntj|d|d| } | j|} t|| _|| _ || _ || _ | | _d| _| rwt t|dgng| _x!| jD]}|j|| qW| S(NR1u_nameR$uSuindices(R(R2R1RR3R"R#R)tarraytdatat descriptiontunitRRtmetaRMR ttoR%RRFtchart _encode_strR5Rt_namet _parent_tabletgetattrR'R*(R6RURMR1R7RHRVRWRRXR$R,t self_dataR>R.((s3lib/python2.7/site-packages/astropy/table/column.pyR9sP          $   "     'cC`s|jtjS(N(R5R2tndarray(R>((s3lib/python2.7/site-packages/astropy/table/column.pyRUscC`s!|jdkrdS|jSdS(N(R]R((R>((s3lib/python2.7/site-packages/astropy/table/column.pyR&scC`s.|dkrd|_ntj||_dS(N(R(R]tweakreftref(R>ttable((s3lib/python2.7/site-packages/astropy/table/column.pyR&s  uCcC`s~|dkr0|j}|r0|j|}q0n|j|j}|j|t|trm|j|_n|j ||S(um Return a copy of the current instance. If ``data`` is supplied then a view (reference) of ``data`` is used, and ``copy_data`` is ignored. Parameters ---------- order : {'C', 'F', 'A', 'K'}, optional Controls the memory layout of the copy. 'C' means C-order, 'F' means F-order, 'A' means 'F' if ``a`` is Fortran contiguous, 'C' otherwise. 'K' means match the layout of ``a`` as closely as possible. (Note that this function and :func:numpy.copy are very similar, but have different default values for their order= arguments.) Default is 'C'. data : array, optional If supplied then use a view of ``data`` instead of the instance data. This allows copying the instance attributes and meta. copy_data : bool, optional Make a copy of the internal numpy array instead of using a reference. Default is True. Returns ------- col : Column or MaskedColumn Copy of the current column (same type as original) N( R(RUR$R5R=t__array_finalize__R"t MaskedColumnt_maskt _copy_groups(R>torderRUt copy_datatout((s3lib/python2.7/site-packages/astropy/table/column.pyR$ s    cC`sd }dt||dD}|d }t|tjrHtjntj}|j||x*|jD]\}}t|||qnWd |_ d S( u Restore the internal state of the Column/MaskedColumn for pickling purposes. This requires that the last element of ``state`` is a 5-tuple that has Column-specific state values. u_nameuunituformatu descriptionumetauindicescS`si|]\}}||qS(((t.0RMR@((s3lib/python2.7/site-packages/astropy/table/column.pys >s iN(u_nameuunituformatu descriptionumetauindices( RR"Rt MaskedArrayR2R`t __setstate__titemstsetattrR(R](R>tstatetnamesRNt super_classRMR@((s3lib/python2.7/site-packages/astropy/table/column.pyRm6s $cC`st|tjrtjntj}|j|\}}}|j|j|j|j |j |j f}||f}|||fS(u Return a 3-tuple for pickling a Column. Use the super-class functionality but then add in a 5-tuple of Column-specific values that get used in __setstate__. ( R"RRlR2R`t __reduce__RMRWRRVRXR'(R>Rrtreconstruct_functreconstruct_func_argsRpt column_state((s3lib/python2.7/site-packages/astropy/table/column.pyRsMs $ cC`sy|dkrdStjtt|jrDtt|j|nd|_t|dshg|_n|j |dS(Nuindices( R(RtcallabletsuperR#RdR&R)R't _copy_attrs(R>R8((s3lib/python2.7/site-packages/astropy/table/column.pyRd]s   cC`sktt|j||}|j|jksXt|trc|dk rc|dtkrc|jdS|SdS(u __array_wrap__ is called at the end of every ufunc. Normally, we want a Column object back and do not have to do anything special. But there are two exceptions: 1) If the output shape is different (e.g. for reduction ufuncs like sum() or mean()), a Column still linking to a parent_table makes little sense, so we return the output viewed as the column content (ndarray or MaskedArray). For this case, we use "[()]" to select everything, and to ensure we convert a zero rank array to a scalar. (For some reason np.sum() returns a zero rank scalar array while np.mean() returns a scalar; So the [()] is needed for this case. 2) When the output is created by any function that returns a boolean we also want to consistently return an array rather than a column (see #1446 and #1685) iN((RxR#t__array_wrap__R7R"R(t_comparison_functionsRU(R>tout_arrtcontext((s3lib/python2.7/site-packages/astropy/table/column.pyRzms  cC`s|jS(u* The name of this column. (R\(R>((s3lib/python2.7/site-packages/astropy/table/column.pyRMscC`sJt|}|jdk r=|j}|jj|j|n||_dS(N(RR&R(tcolumnst_rename_columnRMR\(R>R@Rc((s3lib/python2.7/site-packages/astropy/table/column.pyRMs   cC`s|j|jj|jdfS(uArray-interface compliant full description of the column. This returns a 3-tuple (name, type, shape) that can always be used in a structured array dtype definition. i(RMR1RR7(R>((s3lib/python2.7/site-packages/astropy/table/column.pytdescrsc c`sG|jj}x4||ddtdtdtdiD] }|Vq4WdS(u Return an iterator that yields the string-formatted values of this column. Returns ------- str_vals : iterator Column values formatted as strings it show_namet show_unitt show_dtypetoutsN(t _formattert_pformat_col_itertFalse(R>Rtstr_val((s3lib/python2.7/site-packages/astropy/table/column.pyt iter_str_valss c`sGttstdnd }tfd|D}|S( u{Compare the column attributes of ``col`` to this object. The comparison attributes are: ``name``, ``unit``, ``dtype``, ``format``, ``description``, and ``meta``. Parameters ---------- col : Column Comparison column Returns ------- equal : boolean True if all attributes are equal u8Comparison `col` must be a Column or MaskedColumn objectunameuunitudtypeuformatu descriptionumetac3`s-|]#}t|t|kVqdS(N(R^(Rktx(R+R>(s3lib/python2.7/site-packages/astropy/table/column.pys s(unameuunitudtypeuformatu descriptionumeta(R"R#R<tall(R>R+RNtequal((R+R>s3lib/python2.7/site-packages/astropy/table/column.pyt attrs_equals cC`s|jdkrtS|jjS(N(R&R(t FORMATTERt formatter(R>((s3lib/python2.7/site-packages/astropy/table/column.pyRsc C`s=|jj}|||d|d|d|d|\}}|S(uReturn a list of formatted string representation of column values. If no value of ``max_lines`` is supplied then the height of the screen terminal is used to set ``max_lines``. If the terminal height cannot be determined then the default will be determined using the ``astropy.conf.max_lines`` configuration item. If a negative value of ``max_lines`` is supplied then there is no line limit applied. Parameters ---------- max_lines : int Maximum lines of output (header + data rows) show_name : bool Include column name. Default is True. show_unit : bool Include a header row for unit. Default is False. show_dtype : bool Include column dtype. Default is False. html : bool Format the output as an HTML table. Default is False. Returns ------- lines : list List of lines with header and formatted column values RRRthtml(Rt _pformat_col( R>t max_linesRRRRRtlinesR((s3lib/python2.7/site-packages/astropy/table/column.pytpformats "  c C`s|jj}|||d|d|d|\}}|d}x@t|D]2\} } | |krrt| dqJt| qJWdS(u Print a formatted string representation of column values. If no value of ``max_lines`` is supplied then the height of the screen terminal is used to set ``max_lines``. If the terminal height cannot be determined then the default will be determined using the ``astropy.conf.max_lines`` configuration item. If a negative value of ``max_lines`` is supplied then there is no line limit applied. Parameters ---------- max_lines : int Maximum number of values in output show_name : bool Include column name. Default is True. show_unit : bool Include a header row for unit. Default is False. show_dtype : bool Include column dtype. Default is True. RRRun_headeruredN(RRt enumerateR tprint( R>RRRRRRRtn_headerR tline((s3lib/python2.7/site-packages/astropy/table/column.pyRs   cC`s,|jj}||d|d|d|dS(uInteractively browse column with a paging interface. Supported keys:: f, : forward one page b : back one page r : refresh same page n : next row p : previous row < : go to beginning > : go to end q : quit browsing h : print this help Parameters ---------- max_lines : int Maximum number of lines in table output. show_name : bool Include a header row for column names. Default is True. show_unit : bool Include a header row for unit. Default is False. RRRN(Rt _more_tabcol(R>RRRR((s3lib/python2.7/site-packages/astropy/table/column.pytmores cC`s|jS(u The unit associated with this column. May be a string or a `astropy.units.UnitBase` instance. Setting the ``unit`` property does not change the values of the data. To perform a unit conversion, use ``convert_unit_to``. (t_unit(R>((s3lib/python2.7/site-packages/astropy/table/column.pyRW;s cC`s1|dkrd|_nt|dd|_dS(Nt parse_strictusilent(R(RR (R>RW((s3lib/python2.7/site-packages/astropy/table/column.pyRWFs  cC`s d|_dS(N(R(R(R>((s3lib/python2.7/site-packages/astropy/table/column.pyRWMscC`sM|jdkrtdn|jj||jd||j(||_dS(u Converts the values of the column in-place from the current unit to the given unit. To change the unit associated with this column without actually changing the data values, simply set the ``unit`` property. Parameters ---------- new_unit : str or `astropy.units.UnitBase` instance The unit to convert to. equivalencies : list of equivalence pairs, optional A list of equivalence pairs to try if the unit are not directly convertible. See :ref:`unit_equivalencies`. Raises ------ astropy.units.UnitsError If units are inconsistent uNo unit set on columnt equivalenciesN(RWR(R<RYRU(R>tnew_unitR((s3lib/python2.7/site-packages/astropy/table/column.pytconvert_unit_toQs  cC`s+t|ds$tj||_n|jS(Nu_groups(R)Rt ColumnGroupst_groups(R>((s3lib/python2.7/site-packages/astropy/table/column.pyRnscC`stj||S(u Group this column by the specified ``keys`` This effectively splits the column into groups which correspond to unique values of the ``keys`` grouping object. The output is a new `Column` or `MaskedColumn` which contains a copy of this column but sorted by row according to ``keys``. The ``keys`` input to ``group_by`` must be a numpy array with the same length as this column. Parameters ---------- keys : numpy array Key grouping object Returns ------- out : Column New column with groups attribute set accordingly (Rtcolumn_group_by(R>tkeys((s3lib/python2.7/site-packages/astropy/table/column.pytgroup_bytscC`sv|jrBt|jdrrtj|d|jjj|_qrn0t|drrtj|d|jj|_ndS(uA Copy current groups into a copy of self ``out`` u_groupsR'N(R&R)RRRt_indices(R>Rj((s3lib/python2.7/site-packages/astropy/table/column.pyRgs  'cC`stj|jS(N(R2R:t__repr__(R>((s3lib/python2.7/site-packages/astropy/table/column.pyRscC`st|dtd|jddS(u A view of this table column as a `~astropy.units.Quantity` object with units given by the Column's `unit` parameter. R$R1RhuA(R RR1(R>((s3lib/python2.7/site-packages/astropy/table/column.pytquantitys cK`s|jj||S(u Converts this table column to a `~astropy.units.Quantity` object with the requested units. Parameters ---------- unit : `~astropy.units.Unit` or str The unit to convert to (i.e., a valid argument to the :meth:`astropy.units.Quantity.to` method). equivalencies : list of equivalence pairs, optional Equivalencies to use for this conversion. See :meth:`astropy.units.Quantity.to` for more details. Returns ------- quantity : `~astropy.units.Quantity` A quantity object with the contents of this column in the units ``unit``. (RRY(R>RWRtkwargs((s3lib/python2.7/site-packages/astropy/table/column.pyRYscC`sRx0dD](}t||d}t|||qWtt|di|_dS(uA Copy key column attributes from ``obj`` to self unameuunituformatu descriptionumetaN(unameuunituformatu description(R^R(RoRRX(R>R8tattrR@((s3lib/python2.7/site-packages/astropy/table/column.pyRys cC`st|tr!|jd}nt|ts|tjjkrEn{tj|}|jj dkrtj j|dd}t|tjj rtjj |d|j dt }qn|}|S(um Encode anything that is unicode-ish as utf-8. This method is only called for Py3+. uutf-8uUtencodingtmaskR$(R"RtencodetbytesR2RtmaskedR:R1RZRlRTRR(tvaluetarr((s3lib/python2.7/site-packages/astropy/table/column.pyR[s!'N(('RRR RXR(RRRR9tpropertyRUR&tsetterRGR%R$RmRsRdRzRMRRRRRRRRWtdeleterRRRRgRRRYRyt staticmethodR[(((s3lib/python2.7/site-packages/astropy/table/column.pyR#sH   4 ,         '#      tColumnc B`sjeZdZdddddddddeed ZdZedZdZ dZ dZ e j sxe ZndZe j reZnd Zd Ze j rd Znd Zed ZedZedZedZedZedZddZejZejZejZejZej Z ej!Z!ej"Z"ej#Z#ej$Z$RS(u Define a data column for use in a Table object. Parameters ---------- data : list, ndarray or None Column data values name : str Column name and key for reference within Table dtype : numpy.dtype compatible value Data type for column shape : tuple or () Dimensions of a single row element in the column data length : int or 0 Number of row elements in column data description : str or None Full description of column unit : str or None Physical unit format : str or None or function or callable Format string for outputting column values. This can be an "old-style" (``format % value``) or "new-style" (`str.format`) format specification string or a function or any callable object that accepts a single value and returns a string. meta : dict-like or None Meta-data associated with the column Examples -------- A Column can be created in two different ways: - Provide a ``data`` value but not ``shape`` or ``length`` (which are inferred from the data). Examples:: col = Column(data=[1, 2], name='name') # shape=(2,) col = Column(data=[[1, 2], [3, 4]], name='name') # shape=(2, 2) col = Column(data=[1, 2], name='name', dtype=float) col = Column(data=np.array([1, 2]), name='name') col = Column(data=['hello', 'world'], name='name') The ``dtype`` argument can be any value which is an acceptable fixed-size data-type initializer for the numpy.dtype() method. See ``_. Examples include: - Python non-string type (float, int, bool) - Numpy non-string type (e.g. np.float32, np.int64, np.bool) - Numpy.dtype array-protocol type strings (e.g. 'i4', 'f8', 'S15') If no ``dtype`` value is provide then the type is inferred using ``np.array(data)``. - Provide ``length`` and optionally ``shape``, but not ``data`` Examples:: col = Column(name='name', length=5) col = Column(name='name', dtype=int, length=10, shape=(3,4)) The default ``dtype`` is ``np.float64``. The ``shape`` argument is the array shape of a single cell in the column. ic C`st|tr0tj|jr0tdntt|j|d|d|d|d|d|d|d|d |d | d | d |  } | S( Nu;Cannot convert a MaskedColumn with masked value to a ColumnRURMR1R7RHRVRWRRXR$R,( R"ReR2R;Rt TypeErrorRxRR9( R6RURMR1R7RHRVRWRRXR$R,R>((s3lib/python2.7/site-packages/astropy/table/column.pyR9s!'cC`st|t r+|dkr+tdntt|j|||dkrt|jjt j ry|j j |}Wntk rqX||k r|j j |j|qndS(Numasku5cannot set mask value to a column in non-masked Tableuunit(R"RetAttributeErrorRxRt __setattr__t issubclassR1ttypeR2tnumberR&t_convert_col_for_tabletreplace_columnRM(R>R?Rt converted((s3lib/python2.7/site-packages/astropy/table/column.pyR*s$  c C`s|jdkrt|jS|jjg}|jdkrCdn t|j}|jdkrgdn |jd}xd|j fdt |j fd|fd|fd|j fd|j fd t|ffD]4\}}|dk r|jd j ||qqWd d j|d }|rFddlm}||}n|jj|dtdtdtd|\} } |dj| } tjrt| tjr| jd} n| S(Niiunameudtypeushapeuunituformatu descriptionulengthu {0}={1!r}u i(t xml_escapeRRt show_lengthRu uutf-8(tndimtreprR?R=RRWR(RR7RMRR1RRVtlentappendtjointutils.xml.writerRRRRRRFR"t text_typeR( R>Rt descr_valsRWR7RR@RRt data_linesRRj((s3lib/python2.7/site-packages/astropy/table/column.pyt _base_repr_8s0$"       'cC`s|jdtS(NR(RRR(R>((s3lib/python2.7/site-packages/astropy/table/column.pyt _repr_html_ZscC`s|jdtS(NR(RR(R>((s3lib/python2.7/site-packages/astropy/table/column.pyR]scC`sD|jdkrt|jS|jj|\}}dj|S(Niu (RRR?RRR(R>RR((s3lib/python2.7/site-packages/astropy/table/column.pyt __unicode__`scC`stj|jdS(Nuutf-8(RRR(R>((s3lib/python2.7/site-packages/astropy/table/column.pyt __bytes__jscC`stj|d|jj}|jdkr.dStjj|j}t|j}||krt j dj |t ddndS(u{ Emit a warning if any elements of ``value`` will be truncated when ``value`` is assigned to self. R1iNuLtruncated right side string(s) longer than {} character(s) during assignmentt stackleveli( R2t asanyarrayR1RtsizeRZtstr_lentmaxRtwarningstwarnRR(R>Rt value_str_lent self_str_len((s3lib/python2.7/site-packages/astropy/table/column.pyt_check_string_truncateos  cC`stj r.|jjdkr.|j|}nt|jjtjrV|j |n|j j ||t |||j |R.R((s3lib/python2.7/site-packages/astropy/table/column.pyRAs cC`s|jt|||dS(N(RARB(R>RCRDR((s3lib/python2.7/site-packages/astropy/table/column.pyREsc`sJidd6dd6dd6dd6dd6dd6fd}|S(u Make comparison methods which encode the ``other`` object to utf-8 in the case of a bytestring dtype for Py3+. u__eq__u__ne__u__lt__u__gt__u__le__u__ge__c`s}t|tr^|jjdkr^t|tr^|jjdkr^||}}}ntj r|jjdkr|j|}nt|j ||S(NuUuS( R"ReR1tkindRRFRZR[R^RU(R>tothertop(topert swapped_oper(s3lib/python2.7/site-packages/astropy/table/column.pyt_compares !!  ((RR((RRs3lib/python2.7/site-packages/astropy/table/column.pyt _make_compares u__eq__u__ne__u__gt__u__lt__u__ge__u__le__cC`s|jjdkr:tj||dd|}|||R8tvaluesRRURj((s3lib/python2.7/site-packages/astropy/table/column.pyRs  N((%RRRR(RRRR9RRRRRRRFt__str__RRRARERt__eq__t__ne__t__gt__t__lt__t__ge__t__le__RR#RMRWR$RRRRRRY(((s3lib/python2.7/site-packages/astropy/table/column.pyRsH?    "             #       )        RecB`seZdZd d d d d d dd d d d eed ZedZej dZedZ d dZ d ddZ dZ d ZejZejZejZejZejZejZRS( u Define a masked data column for use in a Table object. Parameters ---------- data : list, ndarray or None Column data values name : str Column name and key for reference within Table mask : list, ndarray or None Boolean mask for which True indicates missing or invalid data fill_value : float, int, str or None Value used when filling masked column elements dtype : numpy.dtype compatible value Data type for column shape : tuple or () Dimensions of a single row element in the column data length : int or 0 Number of row elements in column data description : str or None Full description of column unit : str or None Physical unit format : str or None or function or callable Format string for outputting column values. This can be an "old-style" (``format % value``) or "new-style" (`str.format`) format specification string or a function or any callable object that accepts a single value and returns a string. meta : dict-like or None Meta-data associated with the column Examples -------- A MaskedColumn is similar to a Column except that it includes ``mask`` and ``fill_value`` attributes. It can be created in two different ways: - Provide a ``data`` value but not ``shape`` or ``length`` (which are inferred from the data). Examples:: col = MaskedColumn(data=[1, 2], name='name') col = MaskedColumn(data=[1, 2], name='name', mask=[True, False]) col = MaskedColumn(data=[1, 2], name='name', dtype=float, fill_value=99) The ``mask`` argument will be cast as a boolean array and specifies which elements are considered to be missing or invalid. The ``dtype`` argument can be any value which is an acceptable fixed-size data-type initializer for the numpy.dtype() method. See ``_. Examples include: - Python non-string type (float, int, bool) - Numpy non-string type (e.g. np.float32, np.int64, np.bool) - Numpy.dtype array-protocol type strings (e.g. 'i4', 'f8', 'S15') If no ``dtype`` value is provide then the type is inferred using ``np.array(data)``. When ``data`` is provided then the ``shape`` and ``length`` arguments are ignored. - Provide ``length`` and optionally ``shape``, but not ``data`` Examples:: col = MaskedColumn(name='name', length=5) col = MaskedColumn(name='name', dtype=int, length=10, shape=(3,4)) The default ``dtype`` is ``np.float64``. The ``shape`` argument is the array shape of a single cell in the column. icC`sH|dkrEt|dt}|tk rltj|d| }qln'|tjjkr`t}n t|}t|d|d|d|d|d| d| d |d | d| d |  }tj j |d |d |}|dkrt|dddk r|j j |j }n||_ d|_x!|jD]}|j||q*W|S(NumaskR$R1R7RHRMRWRRVRXR,RURu fill_value(R(R^RR2RTRtnomaskRR#RlR9R1Rt fill_valueR&R'R*(R6RURMRRR1R7RHRVRWRRXR$R,R_R>R.((s3lib/python2.7/site-packages/astropy/table/column.pyR9As$    !$  cC`s |jS(N(tget_fill_value(R>((s3lib/python2.7/site-packages/astropy/table/column.pyRrscC`sd|_|j|dS(uSet fill value both in the masked column view and in the parent table if it exists. Setting one or the other alone doesn't work.N(R(t _fill_valuetset_fill_value(R>R@((s3lib/python2.7/site-packages/astropy/table/column.pyRvs cC`s"|jtj}|j|_|S(N(R5RRlR(R>Rj((s3lib/python2.7/site-packages/astropy/table/column.pyRUs cC`s|dkr|j}ntt|j|}|jdk rK|jjnt}|d|jd|d|jd|j d|j dt |j }|S(uReturn a copy of self, with masked values filled with a given value. Parameters ---------- fill_value : scalar; optional The value to use for invalid entries (`None` by default). If `None`, the ``fill_value`` attribute of the array is used instead. Returns ------- filled_column : Column A copy of ``self`` with masked entries replaced by `fill_value` (be it the function argument or the attribute of ``self``). RMRURWRRVRXN( R(RRxRetfilledR&RRMRWRRVRRX(R>RRUt column_clsRj((s3lib/python2.7/site-packages/astropy/table/column.pyRs  !c C`s>|j}|jjdkrFtj|j|dd|}|||R8RRRtself_matnew_datatnew_masktnew_maRj((s3lib/python2.7/site-packages/astropy/table/column.pyRs$        cC`sM|j|jkrId|_|j|jkr9g|_n|j|n|S(N(R=R(R&R'Ry(R>Rj((s3lib/python2.7/site-packages/astropy/table/column.pyt_copy_attrs_slices   cC`stj r.|jjdkr.|j|}nt|jjtjr}tj j |d|jj}|j |j dn|j j||t|tdkrt jj|||n9tj+tjdtt jj|||WdQXdS(NuSR1uuignore(RRFR1RZR[RRR2RRRRRR%RRRR(RlRARtcatch_warningst simplefilter(R>R.R((s3lib/python2.7/site-packages/astropy/table/column.pyRAs  N((RRRR(RRRR9RRRRURRRRAR#RMR$RRRR(((s3lib/python2.7/site-packages/astropy/table/column.pyRes$F   . 9      (Ft __future__RRRRtexternRtextern.six.movesRRRatreR$RtnumpyR2Rt numpy.ma.coreRt ImportErrorR(tunitsR R t utils.consoleR tutils.metadataR tutils.data_infoR Rt utils.miscRRRRRtnp_utilsRt_column_mixinsRRtTableFormatterRt UserWarningRRR!tsettgreatert greater_equaltlesst less_equalt not_equalRtisfinitetisinftisnantsigntsignbitR{RRR/R`R0RGR#RRlRe(((s3lib/python2.7/site-packages/astropy/table/column.pytsN"          ' *)"