a ߙfbJ@sldZddlZddlZddlmZmZmZdgZe dZ ddZ d d Z Gd ddZ Gd d d ejZdS)z6 This module defines structured units and quantities. N)UnitUnitBaseUNITYStructuredUnitOcCsJg}|jD]6}|j|d}|jr6||t|gq ||q t|S)z-Recursively extract field names from a dtype.r)namesfieldsappend_names_from_dtypetuple)dtypernameZsubdtyper7lib/python3.9/site-packages/astropy/units/structured.pyr s  r cCsg}|D]}t|tr.t|dkr.||qt|trt|dkrt|dtrt|ddkrt|dtrt|ddkr||dt|dgqt|trt|dkrt|}|ddd|D|gqtd|dqt|S) a[Recursively normalize, inferring upper level names for unadorned tuples. Generally, we want the field names to be organized like dtypes, as in ``(['pv', ('p', 'v')], 't')``. But we automatically infer upper field names if the list is absent from items like ``(('p', 'v'), 't')``, by concatenating the names inside the tuple. rrcSs"g|]}t|tr|dn|qSr) isinstancelist.0irrr 4sz$_normalize_names..zinvalid entry zY. Should be a name, tuple of names, or 2-element list of the form [name, tuple of names].) rstrlenr rr _normalize_namesjoin ValueError)rresultrZ new_tuplerrrr!s2     rcs6eZdZdZd?fdd ZddZeddZd d Zd d Z d dZ ddZ ddZ ddZ d@fdd ZdAddZeddZeddZddZed d!Zefd"d#Zgfd$d%Zgfd&d'Zejgfd(d)ZdBd+d,Zd-d.ZdZd/d0Zd1d2Zd3d4Z d5d6Z!d7d8Z"d9d:Z#d;d<Z$d=d>Z%Z&S)Cra Container for units for a structured Quantity. Parameters ---------- units : unit-like, tuple of unit-like, or `~astropy.units.StructuredUnit` Tuples can be nested. If a `~astropy.units.StructuredUnit` is passed in, it will be returned unchanged unless different names are requested. names : tuple of str, tuple or list; `~numpy.dtype`; or `~astropy.units.StructuredUnit`, optional Field names for the units, possibly nested. Can be inferred from a structured `~numpy.dtype` or another `~astropy.units.StructuredUnit`. For nested tuples, by default the name of the upper entry will be the concatenation of the names of the lower levels. One can pass in a list with the upper-level name and a tuple of lower-level names to avoid this. For tuples, not all levels have to be given; for any level not passed in, default field names of 'f0', 'f1', etc., will be used. Notes ----- It is recommended to initialze the class indirectly, using `~astropy.units.Unit`. E.g., ``u.Unit('AU,AU/day')``. When combined with a structured array to produce a structured `~astropy.units.Quantity`, array field names will take precedence. Generally, passing in ``names`` is needed only if the unit is used unattached to a `~astropy.units.Quantity` and one needs to access its fields. Examples -------- Various ways to initialize a `~astropy.units.StructuredUnit`:: >>> import astropy.units as u >>> su = u.Unit('(AU,AU/day),yr') >>> su Unit("((AU, AU / d), yr)") >>> su.field_names (['f0', ('f0', 'f1')], 'f1') >>> su['f1'] Unit("yr") >>> su2 = u.StructuredUnit(((u.AU, u.AU/u.day), u.yr), names=(('p', 'v'), 't')) >>> su2 == su True >>> su2.field_names (['pv', ('p', 'v')], 't') >>> su3 = u.StructuredUnit((su2['pv'], u.day), names=(['p_v', ('p', 'v')], 't')) >>> su3.field_names (['p_v', ('p', 'v')], 't') >>> su3.keys() ('p_v', 't') >>> su3.values() (Unit("(AU, AU / d)"), Unit("d")) Structured units share most methods with regular units:: >>> su.physical_type ((PhysicalType('length'), PhysicalType({'speed', 'velocity'})), PhysicalType('time')) >>> su.si Unit("((1.49598e+11 m, 1.73146e+06 m / s), 3.15576e+07 s)") Ncsd}|durxt|tr&|jj}|j}nRt|tjr`|js@tdtdd|jD}t |}nt|t sp|f}t |}t|t st |}t|tr|dus|j|kr|S| }n|f}|durt ddtt|D}nt|t|krtdg}t||D]^\}}t|tr0|||d}|d}n&t |}|durVt|trVtd ||qt|}|durtd d|D}tt ||d |_|S) Nz(dtype should be structured, with fields.cSsg|] }|tfqSr) DTYPE_OBJECTrrrrrrz*StructuredUnit.__new__..css|]}d|VqdS)fNrrrrr r"z)StructuredUnit.__new__..z,lengths of units and field names must match.rrzKunits do not match in depth with field names from dtype or structured unit.cSs&g|]}t|tr|dn|tfqSr)rrr r!rrrrsr)rr_unitsr field_namesnpr rrr r rrvaluesrangerziprr super__new__array)clsZunitsrr Z convertedunitrself __class__rrr,{sP            zStructuredUnit.__new__cCsdS)z?When de-serializing, e.g. pickle, start with a blank structure.)rNrr0rrr__getnewargs__szStructuredUnit.__getnewargs__cCstdd|DS)z6Possibly nested tuple of the field names of the parts.css*|]"\}}t|tr||jgn|VqdSN)rrr&)rrr/rrrr$s z-StructuredUnit.field_names..)r itemsr3rrrr&szStructuredUnit.field_namescCst|jjjSr5)rr%r rr3rrr__len__szStructuredUnit.__len__cCs |j|Sr5)r%)r0itemrrr __getitem__szStructuredUnit.__getitem__cCs |jSr5)r%r8r3rrrr(szStructuredUnit.valuescCs |jjjSr5r%r rr3rrrkeysszStructuredUnit.keyscCstt|jjj|jSr5)r r*r%r rr8r3rrrr6szStructuredUnit.itemsccs|jjjEdHdSr5r:r3rrr__iter__szStructuredUnit.__iter__csZttfdd|D|jjd}|durB|||jfSt|j }||_|S)aqApply func recursively. Parameters ---------- func : callable Function to apply to all parts of the structured unit, recursing as needed. cls : type, optional If given, should be a subclass of `~numpy.void`. By default, will return a new `~astropy.units.StructuredUnit` instance. csg|] }|qSrrrpartfuncrrrr"z5StructuredUnit._recursively_apply..rN) r'r-r r(r%r Zviewr+r,r2)r0r@r.Zresultsrr1r?r_recursively_applys z!StructuredUnit._recursively_applyTcCs|rt|tr|d}q|tur0tft|}n0t|trJt|t|kr`td|d|dg}t||D]f\\}}}t|tr| ||j |ddfqrt |}|j }|jdvrt t}| |||jfqrt |S)aGet structured dtype according to value, using our field names. This is useful since ``np.array(value)`` would treat tuples as lower levels of the array, rather than as elements of a structured array. The routine does presume that the type of the first tuple is representative of the rest. Used in ``_get_converter``. For the special value of ``UNITY``, all fields are assumed to be 1.0, and hence this will return an all-float dtype. rzcannot interpret value z for unit .F) enter_listsZiu)rrrrr rr*r6rr _recursively_get_dtyper'r-r kindfloatshape)r0valuerCZdescrrr/r>Z part_dtyperrrrDs&       z%StructuredUnit._recursively_get_dtypecCs|tdS)z*The `StructuredUnit` instance in SI units.sirAoperator attrgetterr3rrrrIszStructuredUnit.sicCs|tdS)z+The `StructuredUnit` instance in cgs units.cgsrJr3rrrrMszStructuredUnit.cgscCs|jtdtdS)N_get_physical_type_idr.)rArK methodcaller Structurer3rrrrNs z$StructuredUnit._get_physical_type_idcCs|jtdtdS)z!Physical types of all the fields. physical_typerO)rArKrLrQr3rrrrRs zStructuredUnit.physical_typecCs|tjd|dS)a\The `StructuredUnit` composed of only irreducible units. Parameters ---------- bases : sequence of `~astropy.units.UnitBase`, optional The bases to decompose into. When not provided, decomposes down to any irreducible units. When provided, the decomposed result will only contain the given units. This will raises a `UnitsError` if it's not possible to do so. Returns ------- `~astropy.units.StructuredUnit` With the unit for each field containing only irreducible units. decompose)bases)rArKrP)r0rTrrrrS$s zStructuredUnit.decomposecCsjz t|}Wnty YdS0t|t|kr6dSt||D]\}}|j||dsHdSqHdS)a`True` if all fields are equivalent to the other's fields. Parameters ---------- other : `~astropy.units.StructuredUnit` The structured unit to compare with, or what can initialize one. equivalencies : list of tuple, optional A list of equivalence pairs to try if the units are not directly convertible. See :ref:`unit_equivalencies`. The list will be applied to all fields. Returns ------- bool F equivalenciesT)r Exceptionrr*r( is_equivalent)r0otherrV self_part other_partrrrrX8s  zStructuredUnit.is_equivalentcsNt|tsj|d}fddt|Dfdd}|S)Nrcsg|]\}}|j|dqS)rU)_get_converter)rrZr[rUrrr[sz1StructuredUnit._get_converter..cs`t|dst||}t|}t|jjD]\}}|||||<q4|jrX|S|dS)Nr r) hasattrr'r-rDZ empty_liker*r rrG)rHrrZ converter_) convertersr0rr converter`s   z0StructuredUnit._get_converter..converter)rtyper2r*r()r0rYrVr`r)r_rVr0rr]Ws  zStructuredUnit._get_convertercCs |tjurt}|j||d|S)aReturn values converted to the specified unit. Parameters ---------- other : `~astropy.units.StructuredUnit` The unit to convert to. If necessary, will be converted to a `~astropy.units.StructuredUnit` using the dtype of ``value``. value : array-like, optional Value(s) in the current unit to be converted to the specified unit. If a sequence, the first element must have entries of the correct type to represent all elements (i.e., not have, e.g., a ``float`` where other elements have ``complex``). If not given, assumed to have 1. in all fields. equivalencies : list of tuple, optional A list of equivalence pairs to try if the units are not directly convertible. See :ref:`unit_equivalencies`. This list is in addition to possible global defaults set by, e.g., `set_enabled_equivalencies`. Use `None` to turn off all equivalencies. Returns ------- values : scalar or array Converted value(s). Raises ------ UnitsError If units are inconsistent rU)r'_NoValuerr])r0rYrHrVrrrtoks zStructuredUnit.togenericcs\fdd|D}t|dkr&dnd}dkrLdd|D}d|d}|d |S) aOutput the unit in the given format as a string. Units are separated by commas. Parameters ---------- format : `astropy.units.format.Base` instance or str The name of a format or a formatter object. If not provided, defaults to the generic format. Notes ----- Structured units can be written to all formats, but can be re-read only with 'generic'. csg|]}|qSr to_stringr=formatrrrr"z,StructuredUnit.to_string..rz({})z({},)latexcSsg|]}|ddqS)rrr=rrrrr"$z, )r(rrhr)r0rhpartsZout_fmtrrgrrfs  zStructuredUnit.to_stringcCs |dS)Nrirer3rrr _repr_latex_szStructuredUnit._repr_latex_csttr2ztddWnty0tYS0ttrdtfdd|D}|j||dStt rrtSzddl m }||dWStytYS0dS) NsilentZ parse_strictc3s|]}|VqdSr5rr=rYrrr$r"z)StructuredUnit.__mul__..r\rQuantity)r/) rrrrWNotImplementedrr r(r2rquantityrr)r0rY new_unitsrrrrpr__mul__s       zStructuredUnit.__mul__cCs ||Sr5)rvr0rYrrr__rmul__szStructuredUnit.__rmul__cshttr2ztddWnty0tYS0ttrdtfdd|D}|j||dStS)Nrnroc3s|]}|VqdSr5rr=rprrr$r"z-StructuredUnit.__truediv__..r\) rrrrWrsrr r(r2)r0rYrurrpr __truediv__s    zStructuredUnit.__truediv__cCs:zddlm}|||dddWSty4tYS0dS)NrrqFT)copyZsubok)rtrrrWrs)r0mrrrrr __rlshift__s   zStructuredUnit.__rlshift__cCs|Sr5rer3rrr__str__szStructuredUnit.__str__cCsd|dS)NzUnit("z")rer3rrr__repr__szStructuredUnit.__repr__cCs4z t|}Wnty"tYS0||kSr5)rrWrsr(rwrrr__eq__s    zStructuredUnit.__eq__cCsBt|t|s2z t|}Wnty0tYS0||kSr5)rrarrWrsr(rwrrr__ne__s    zStructuredUnit.__ne__)N)N)T)rd)'__name__ __module__ __qualname____doc__r,r4propertyr&r7r9r(r;r6r<rArDrIrMrNrRsetrSrXr]r'rbrcrfrmZ__array_ufunc__rvrxryr|r}r~rr __classcell__rrr1rr>sF<<  "     %  c@s eZdZdZddZddZdS)rQaRSingle element structure for physical type IDs, etc. Behaves like a `~numpy.void` and thus mostly like a tuple which can also be indexed with field names, but overrides ``__eq__`` and ``__ne__`` to compare only the contents, not the field names. Furthermore, this way no `FutureWarning` about comparisons is given. cCs t|tjr|}||kSr5rr'voidr8rwrrrrs zStructure.__eq__cCs t|tjr|}||kSr5rrwrrrrs zStructure.__ne__N)rrrrrrrrrrrQs rQ)rrKZnumpyr'corerrr__all__r r r rrrrQrrrrs  4