IR-e@OdZddlmZddlZddlZddlmZmZm Z dgZ ej dZ dZ d ZGd dZGd d ejZddZdS)z6 This module defines structured units and quantities. ) annotationsN)UNITYUnitUnitBaseStructuredUnitOcg}|jD][}|j|dj}|jr%||t |gF||\t |S)z-Recursively extract field names from a dtype.r)namesfieldsbaseappend_names_from_dtypetuple)dtyper namesubdtypes 8lib/python3.11/site-packages/astropy/units/structured.pyrrsz E <%a(- >  LL$ 1( ; ;< = = = = LL     <<c2g}|D]}t|tr)t|dkr||At|trt|dkrt|dtrt|ddkrft|dt rKt|ddkr2||dt |dgt|t rZt|dkrGt |}dd|D}|||grtd|dt |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. rrcLg|]!}t|tr|dn|"Sr) isinstancelist.0is r z$_normalize_names..8s/TTTQZ4%8%8?QqTTaTTTrzinvalid entry zY. Should be a name, tuple of names, or 2-element list of the form [name, tuple of names].) rstrlenrrr_normalize_namesjoin ValueError)r resultr new_tuples rr#r#!sF dC  SYY]] MM$     tT " " D Q47C((DG q  47E**!DG q  MM47$4T!W$=$=> ? ? ? ? e $ $ TQ(..I77TT)TTTUUD MM4+ , , , ,////  ==rcFeZdZdZd"fd ZdZedZdZdZ dZ d Z d Z d Z d"fd Zd#dZedZedZdZedZefdZgfdZgfdZejgfdZd$dZdZdZdZdZdZ dZ!dZ"dZ#d Z$d!Z%xZ&S)%ra 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 initialize 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)") Ncd}|t|tr|jj}|j}nt|t jrI|jstdt jd|jD}t|}n't|ts|f}t|}t|tsKt|}t|tr$| |j|kr|S| }n|f}|4tdtt|D}n/t|t|krtdg}t!||D]\}}t|t"r|||d}|d}n5t|}|$t|trtd||t'|}|t jd|D}t jt||d |_|S) Nz(dtype should be structured, with fields.c g|] }|tf S) DTYPE_OBJECTrrs rr z*StructuredUnit.__new__..s!O!O!O44"6!O!O!Orc3 K|] }d|V dS)fNr+rs r z)StructuredUnit.__new__..s(==a'a''======rz,lengths of units and field names must match.rrzKunits do not match in depth with field names from dtype or structured unit.cZg|](}t|tr|dn|tf)Sr)rrr,r-s rr z*StructuredUnit.__new__..sD",D$!7!7Ad1ggTLQrr+)rr_unitsr field_namesnpr r%r rrr#rvaluesranger"ziprrsuper__new__array) clsunitsr r convertedunitrself __class__s rr9zStructuredUnit.__new__s  %00 0 *)E28,, 0|Q$%OPPP!O!O5;!O!O!OPP)%00!%//%"HE(//%'' !KKE%00 !=E$5$>$> L  ===5U+<+<=====EE ZZ3u:: % %KLL L eU++ # #JD$$%% s4a))AwDzz$D.)I)I$$?   T " " " "wws## =H %EhuY//77;  rcdS)z?When de-serializing, e.g. pickle, start with a blank structure.)r+Nr+r?s r__getnewargs__zStructuredUnit.__getnewargs__sxrcXtd|DS)z6Possibly nested tuple of the field names of the parts.c3\K|]'\}}t|tr ||jgn|V(dSN)rrr3)rrr>s rr0z-StructuredUnit.field_names..sV  d*4D.)I)I SdD$ % %t      r)ritemsrBs rr3zStructuredUnit.field_namess:  "jjll      rc>t|jjjSrF)r"r2rr rBs r__len__zStructuredUnit.__len__s4;$*+++rc|j|SrF)r2)r?items r __getitem__zStructuredUnit.__getitem__s{4  rc4|jSrF)r2rKrBs rr5zStructuredUnit.valuess{!!!rc$|jjjSrFr2rr rBs rkeyszStructuredUnit.keyss{ &&rctt|jjj|jSrF)rr7r2rr rKrBs rrGzStructuredUnit.itemss0S*0$+2B2B2D2DEEFFFrc#8K|jjjEd{VdSrFrOrBs r__iter__zStructuredUnit.__iter__s,;$**********rcDtfd|D}tj||jjd}||||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. c3.K|]}|VdSrFr+)rpartfuncs rr0z4StructuredUnit._recursively_apply..s+==tT ======rr+) rr5r4r:r2rviewr8r9r@)r?rWr;appliedresultsr&r@s ` r_recursively_applyz!StructuredUnit._recursively_applys====t{{}}=====(7DK$566r: ?<<gm 455 500  rTc|r2t|tr|d}t|t|turtft|z}nKt|tr t|t|krt d|d|dg}t ||D]\\}}}t|tr-| || |dfJtj |}|j }|jdvrtj t}| |||jftj |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_listsiu)rrrr"rr%r7rGrr_recursively_get_dtyper4r:rkindfloatshape)r?valuer^descrrr>rV part_dtypes rr`z%StructuredUnit._recursively_get_dtypesv  !UD)) !aUD)) ! E>>Hs4yy(EEE5)) QSYY#e**-D-DOuOOOOOPP P"%djjllE":": = = LT4$$// = 466t6OOP x~~!Z ?d**!#%J dJ ;<<<<xrcP|tjdS)z*The `StructuredUnit` instance in SI units.sir[operator attrgetterrBs rrhzStructuredUnit.sis#&&x':4'@'@AAArcP|tjdS)z+The `StructuredUnit` instance in cgs units.cgsrirBs rrmzStructuredUnit.cgs$s#&&x':5'A'ABBBrc^|tjdtS)N_get_physical_type_idr;)r[rj methodcaller StructurerBs rroz$StructuredUnit._get_physical_type_id*s0&&  !"9 : : '   rc^|tjdtS)z!Physical types of all the fields. physical_typerp)r[rjrkrrrBs rrtzStructuredUnit.physical_type/s1&&   0 0i'   rcT|tjd|S)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)r[rjrq)r?rws rrvzStructuredUnit.decompose6s)"&&x'<[PU'V'V'VWWWrc6 t|}n#t$rYdSwxYwt|t|krdSt||D]\}}|||sdS dS)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 Exceptionr"r7r5 is_equivalent)r?otherrz self_part other_parts rr|zStructuredUnit.is_equivalentIs  "5))EE   55  t99E " "5%( %G%G   !Iz**:]*SS uu ts   ct|ts|}fdt|Dfd}|S)Nr cDg|]\}}||S)ry)_get_converter)rr~rrzs rr z1StructuredUnit._get_converter..ks@   'J  $ $Z} $ M M   rc&t|ds(tj||}tj|}t |jjD]\}}|||||<|jr|n|dS)Nrr+) hasattrr4r:r` empty_liker7rr rc)rdr&r converter_ convertersr?s r converterz0StructuredUnit._get_converter..converterps5'** L(C(CE(J(JKK]5))F$' (:J$G$G 7 7 j)z%+66t #\966vbz 9r)rtyper@r7r5)r?r}rzrrs` ` @rrzStructuredUnit._get_convertergs%d,, 6NN5N55E    +.t{{}}ellnn+M+M    : : : : : :rcl|tjurt}||||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 ry)r4_NoValuerr)r?r}rdrzs rtozStructuredUnit.to{s;> BK  EFt""5 "FFuMMMrgenericcfd|D}t|dkrdnd}drd|D}d|zdz}|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'. c:g|]}|Sr+ to_string)rrVformats rr z,StructuredUnit.to_string..s%BBBD''BBBrrz({})z({},)latexc"g|] }|dd S)rr+)rrVs rr z,StructuredUnit.to_string..s 222DT!B$Z222r$z, )r5r" startswithrr$)r?rpartsout_fmts ` rrzStructuredUnit.to_strings"CBBBDKKMMBBBIIMM&&w   W % % *22E222EGmc)G~~dii..///rc,|dS)NrrrBs r _repr_latex_zStructuredUnit._repr_latex_s~~g&&&rcttr* tdn#t$r tcYSwxYwtt rDt fd|D}|||SttrtS ddl m }||S#t$r tcYSwxYw)Nsilent parse_strictc3"K|] }|zV dSrFr+rrVr}s rr0z)StructuredUnit.__mul__..'EEtdUlEEEEEErrrQuantity)r>) rr!rr{NotImplementedrrr5r@rquantityr)r?r} new_unitsrs ` r__mul__zStructuredUnit.__mul__s eS ! ! & &U::: & & &%%%% & eX & & 9EEEEt{{}}EEEEEI>>)4>88 8 e^ , , "! ! " * * * * * *8E--- - " " "! ! ! ! "s*>>7C CCc,||SrF)rr?r}s r__rmul__zStructuredUnit.__rmul__s||E"""rcBttr* tdn#t$r tcYSwxYwtt rDt fd|D}|||StS)Nrrc3"K|] }|z V dSrFr+rs rr0z-StructuredUnit.__truediv__..rrr) rr!rr{rrrr5r@)r?r}rs ` r __truediv__zStructuredUnit.__truediv__s eS ! ! & &U::: & & &%%%% & eX & & 9EEEEt{{}}EEEEEI>>)4>88 8s *>>c\ ddlm}|||ddS#t$r tcYSwxYw)NrrFT)copysubok)rrr{r)r?mrs r __rlshift__zStructuredUnit.__rlshift__sY " * * * * * *8At%t<<< < " " "! ! ! ! "s ++c*|SrFrrBs r__str__zStructuredUnit.__str__s~~rc2d|dS)NzUnit("z")rrBs r__repr__zStructuredUnit.__repr__s,((,,,,rc t|}n#t$r tcYSwxYw||kSrF)rr{rr5rs r__eq__zStructuredUnit.__eq__sZ ""5))EE " " "! ! ! ! "{{}} ..s &&ct|t|s( t|}n#t$r tcYSwxYw||kSrF)rrrr{rr5rs r__ne__zStructuredUnit.__ne__sr%d,, & &&u-- & & &%%%% &{{}} ..s/AArF)T)r)'__name__ __module__ __qualname____doc__r9rCpropertyr3rIrLr5rPrGrSr[r`rhrmrortsetrvr|rr4rrrr__array_ufunc__rrrrrrrr __classcell__)r@s@rrrDs;;z@@@@@@D  X ,,,!!!"""'''GGG+++.!!!!FBBXBCCXC      X "ceeXXXX&24<35(!k#N#N#N#NJ00002'''O"""(###   """   ---//////////rceZdZdZdZdZdS)rraRSingle 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. ct|tjr|}||kSrFrr4voidrKrs rrzStructure.__eq__6 eRW % % !JJLLEyy{{e##rct|tjr|}||kSrFrrs rrzStructure.__ne__rrN)rrrrrrr+rrrrrrs<$$$ $$$$$rrrr>UnitBase | StructuredUnitrnp.dtypereturnc4t|tr|Sg}|jD]U}|j|d}|j$|t ||@||Vtt ||jS)a0Make a `StructuredUnit` of one unit, with the structure of a `numpy.dtype`. Parameters ---------- unit : UnitBase The unit that will be filled into the structure. dtype : `numpy.dtype` The structure for the StructuredUnit. Returns ------- StructuredUnit rNr)rrr r r_structured_unit_like_dtyper)r>rr<rrs rrrs $''  E <%a( > % LL4T8DD E E E E LL     %,,ek : : ::r)r>rrrrr)r __future__rrjnumpyr4corerrr__all__rr,rr#rrrrrr+rrrs #"""""''''''''''  rx}}       Fz/z/z/z/z/z/z/z/z $$$$$$$$8;;;;;;r