ó šßÈ[c @`sçdZddlmZmZmZmZddlmZddlm Z ddl Z ddl Z ddl m Z ddl mZddlZdd lmZdd lmZd d d ddddddddg Zdefd„ƒYZdefd„ƒYZgZd„Zdefd„ƒYZejeƒdefd„ƒYƒZdefd „ƒYZ d!efd"„ƒYZ!d#„Z"d$„Z#d%efd&„ƒYZ$d'„Z%d(„Z&d)„Z'dd*e&e'd+„Z)d,efd-„ƒYZ*dS(.uJ This module contains helper functions and classes for handling metadata. i(tabsolute_importtdivisiontprint_functiontunicode_literalsi(tsix(twrapsN(t OrderedDict(tdeepcopy(tAstropyWarning(tdtype_bytes_or_charsuMergeConflictErroruMergeConflictWarninguMERGE_STRATEGIESu common_dtypeu MergePlusuMergeNpConcatenateu MergeStrategyuMergeStrategyMetauenable_merge_strategiesumergeuMetaDatatMergeConflictErrorcB`seZRS((t__name__t __module__(((s5lib/python2.7/site-packages/astropy/utils/metadata.pyR stMergeConflictWarningcB`seZRS((R R (((s5lib/python2.7/site-packages/astropy/utils/metadata.pyR sc`sid„‰tjtjtjtjtjf‰t‡‡fd†|Dƒƒ}t|ƒdkr§g|D]}ˆ|ƒj^qe}t dj |ƒƒ}||_ |‚ng|D]!}tj ddˆ|ƒƒ^q®}xat |ƒD]S\}}|jjd krâ|jjdkrdnd t|jƒg||;sN(ttuple(R(Rtnp_types(Rs5lib/python2.7/site-packages/astropy/utils/metadata.pys ;siu"Arrays have incompatible types {0}RuSuUu0t0i(uSuU(Rtbool_tobject_tnumbert charactertvoidtsettlentnameR tformatt_incompat_typestemptyt enumerateRtkindR tarraytstr(tarrst uniq_typesRtincompat_typesttmetit arr_common((RRs5lib/python2.7/site-packages/astropy/utils/metadata.pyt common_dtype&s" $ "    .&tMergeStrategyMetacB`seZdZd„ZRS(uc Metaclass that registers MergeStrategy subclasses into the MERGE_STRATEGIES registry. c `sètt|ƒj||||ƒ}d|krzt|dtƒrz|dj‰tˆƒ‡fd†ƒ}t|ƒ|_nd|krä|d}t|tƒr«|g}nx6t |ƒD]%\}}t j d|||fƒq¸Wn|S(Numergec`s:yˆ|||ƒSWntk r5}t|ƒ‚nXdS(N(t ExceptionR (tclstlefttrightterr(t orig_merge(s5lib/python2.7/site-packages/astropy/utils/metadata.pytmerge`sutypesi( tsuperR/t__new__t isinstancet classmethodt__func__RR6RtreversedtMERGE_STRATEGIEStinsert( tmclsR tbasestmembersR1R6ttypesR2R3((R5s5lib/python2.7/site-packages/astropy/utils/metadata.pyR8Xs!     (R R t__doc__R8(((s5lib/python2.7/site-packages/astropy/utils/metadata.pyR/Rst MergeStrategycB`seZdZeZRS(u^ Base class for defining a strategy for merging metadata from two sources, left and right, into a single output. The primary functionality for the class is the ``merge(cls, left, right)`` class method. This takes ``left`` and ``right`` side arguments and returns a single merged output. The first class attribute is ``types``. This is defined as a list of (left_types, right_types) tuples that indicate for which input types the merge strategy applies. In determining whether to apply this merge strategy to a pair of (left, right) objects, a test is done: ``isinstance(left, left_types) and isinstance(right, right_types)``. For example:: types = [(np.ndarray, np.ndarray), # Two ndarrays (np.ndarray, (list, tuple)), # ndarray and (list or tuple) ((list, tuple), np.ndarray)] # (list or tuple) and ndarray As a convenience, ``types`` can be defined as a single two-tuple instead of a list of two-tuples, e.g. ``types = (np.ndarray, np.ndarray)``. The other class attribute is ``enabled``, which defaults to ``False`` in the base class. By defining a subclass of ``MergeStrategy`` the new merge strategy is automatically registered to be available for use in merging. However, by default the new merge strategy is *not enabled*. This prevents inadvertently changing the behavior of unrelated code that is performing metadata merge operations. In most cases (particularly in library code that others might use) it is recommended to leave custom strategies disabled and use the `~astropy.utils.metadata.enable_merge_strategies` context manager to locally enable the desired strategies. However, if one is confident that the new strategy will not produce unexpected behavior, then one can globally enable it by setting the ``enabled`` class attribute to ``True``. Examples -------- Here we define a custom merge strategy that takes an int or float on the left and right sides and returns a list with the two values. >>> from astropy.utils.metadata import MergeStrategy >>> class MergeNumbersAsList(MergeStrategy): ... types = ((int, float), (int, float)) # (left_types, right_types) ... ... @classmethod ... def merge(cls, left, right): ... return [left, right] (R R RCtFalsetenabled(((s5lib/python2.7/site-packages/astropy/utils/metadata.pyRDts3t MergePluscB`s;eZdZeefeefgZeZed„ƒZ RS(u€ Merge ``left`` and ``right`` objects using the plus operator. This merge strategy is globally enabled by default. cC`s||S(N((R1R2R3((s5lib/python2.7/site-packages/astropy/utils/metadata.pyR6·s( R R RCtlistRRBtTrueRFR:R6(((s5lib/python2.7/site-packages/astropy/utils/metadata.pyRG¯stMergeNpConcatenatecB`s\eZdZejejfejeeffeefejfgZeZ e d„ƒZ RS(u× Merge ``left`` and ``right`` objects using np.concatenate. This merge strategy is globally enabled by default. This will upcast a list or tuple to np.ndarray and the output is always ndarray. cC`sBtj|ƒtj|ƒ}}t||gƒtj||gƒS(N(Rt asanyarrayR.t concatenate(R1R2R3((s5lib/python2.7/site-packages/astropy/utils/metadata.pyR6És( R R RCRtndarrayRHRRBRIRFR:R6(((s5lib/python2.7/site-packages/astropy/utils/metadata.pyRJ¼s cC`st||ƒot||ƒS(N(R9(R2R3R1((s5lib/python2.7/site-packages/astropy/utils/metadata.pyt_both_isinstanceÐscC`s-yt||kƒSWntk r(tSXdS(N(tboolR0RI(R2R3((s5lib/python2.7/site-packages/astropy/utils/metadata.pyt _not_equalÔs t_EnableMergeStrategiescB`s#eZd„Zd„Zd„ZRS(cG`s[||_i|_xBtD]:\}}}t||ƒr|j|j|>> from astropy.utils.metadata import MergeStrategy >>> class MergeNumbersAsList(MergeStrategy): ... types = ((int, float), # left side types ... (int, float)) # right side types ... @classmethod ... def merge(cls, left, right): ... return [left, right] By defining this class the merge strategy is automatically registered to be available for use in merging. However, by default new merge strategies are *not enabled*. This prevents inadvertently changing the behavior of unrelated code that is performing metadata merge operations. In order to use the new merge strategy, use this context manager as in the following example:: >>> from astropy.table import Table, vstack >>> from astropy.utils.metadata import enable_merge_strategies >>> t1 = Table([[1]], names=['a']) >>> t2 = Table([[2]], names=['a']) >>> t1.meta = {'m': 1} >>> t2.meta = {'m': 2} >>> with enable_merge_strategies(MergeNumbersAsList): ... t12 = vstack([t1, t2]) >>> t12.meta['m'] [1, 2] One can supply further merge strategies as additional arguments to the context manager. As a convenience, the enabling operation is actually done by checking whether the registered strategies are subclasses of the context manager arguments. This means one can define a related set of merge strategies and then enable them all at once by enabling the base class. As a trivial example, *all* registered merge strategies can be enabled with:: >>> with enable_merge_strategies(MergeStrategy): ... t12 = vstack([t1, t2]) Parameters ---------- merge_strategies : one or more `~astropy.utils.metadata.MergeStrategy` args Merge strategies that will be enabled. (RQ(RR((s5lib/python2.7/site-packages/astropy/utils/metadata.pytenable_merge_strategiesìs8cC`s(dj|t|ƒt|ƒ|ƒ}|S(NuECannot merge meta key {0!r} types {1!r} and {2!r}, choosing {0}={3!r}(R!R(tkeyR2R3tout((s5lib/python2.7/site-packages/astropy/utils/metadata.pyt_warn_str_func'scC`s%dj|t|ƒt|ƒƒ}|S(Nu1Cannot merge meta key {0!r} types {1!r} and {2!r}(R!R(R_R2R3R`((s5lib/python2.7/site-packages/astropy/utils/metadata.pyt_error_str_func.suwarnc C`sbt||tƒs!tdƒ‚nt|ƒ}x.tj|ƒD]\}}||krkt|ƒ||s@"      ,":    ;   B