d7dZddlZddlZddlZddlZddlmZddlm Z ddl Z ddl m Z dZ eZ iZ iZ ejdZd Zd Zd Zd Zd ZdZGddeZGddeZGddeZGddeZGddeZGddeZ GddeZ!dZ"e"edZ#e"edZ$e"ed Z%e"ed!Z&e"e dZ'e"e dZ(e"e d Z)e"e d!Z*e+ed"r e"e!dZ,e"e!d Z-e"e!d!Z.e+ed#r e"e!d$Z/e+ed%r e"e!d&Z0Gd'd(eZ1Gd)d*e1eZ2e2xZ3xZ4Z5e+ed+re2Z6e+ed,re2Z7Gd-d.eZ8Gd/d0e8Z9Gd1d2e8Z:Gd3d4eZ;Gd5d6eZ<Gd7d8Z=Gd9d:e=Z>Gd;dZ?Gd=d>e>Z@Gd?d@e>ZAdS)Az-Atom classes for describing dataset contents.NSizeType)Enum) FlavorWarningreStructuredTextz^([a-z]+)([0-9]*)$ct|}|std|z|\}}d}|r6t |}t |d\}}|rtd|z||fS)a\Split a PyTables type into a PyTables kind and an item size. Returns a tuple of (kind, itemsize). If no item size is present in the type (in the form of a precision), the returned item size is None:: >>> split_type('int32') ('int', 4) >>> split_type('string') ('string', None) >>> split_type('int20') Traceback (most recent call last): ... ValueError: precision must be a multiple of 8: 20 >>> split_type('foo bar') Traceback (most recent call last): ... ValueError: malformed type: 'foo bar' zmalformed type: %rNz%precision must be a multiple of 8: %d)_type_rematch ValueErrorgroupsintdivmod)typer kind precisionitemsize remainders +lib/python3.11/site-packages/tables/atom.py split_typer%s* NN4 E 6-4555llnnOD)H* NN $Y22)  *D()** * ( c Rt|}td|d|d|dS)Ninvalid item size for kind ````: z; it must be one of ``z``)sortedr )rr itemsizesisizess r_invalid_itemsize_errorrHs; I  F :xxx1 2 22rc>t|d}|d|fd}|S)z2Return a constructor for an abstract `Atom` class.rc|jtvsJ t|j|}n4#t$r't|j|t|jwxYw||_||||dSN)ratom_mapKeyErrorr __class____init__)selfrshapedflt atomclasss rr'z%_abstract_atom_init..__init__TsyH$$$$ ? +H5II ? ? ?)$)X*249*=?? ? ?#4-----s +1A)r)deftypedefvalue defitemsizer's r_abstract_atom_initr/Os8W%%a(K +2H.... OrcXt|tjtfr|dkrt d|z|f} t |}n #t $rt d|wxYwt|dkrt d|t d|DS)zCCheck that the `shape` is safe to be used and return it as a tuple.rz&shape value must be greater than 0: %dz&shape must be an integer or sequence: z)shapes with rank > 32 are not supported: c34K|]}t|VdSr#r.0ss r z#_normalize_shape..ts(,,!,,,,,,r) isinstancenpintegerrr tuple TypeErrorlenr)s r_normalize_shaper>`s%"*c*++ 199E$%&& &$e  $$$i 5#$$ $$  5zzB A A ACC C ,,e,,, , ,,s AA+c|d}|j} tj||}nP#t$rCtj|}|j|jkrtj||j}YnwxYw|jdkr|d}|S)z8Return `value` as a valid default of NumPy type `dtype`.Nrdtyper!)baser8arrayr r))valuerA basedtypedefaultrCs r_normalize_defaultrGws  } I8(5 222 888 ;)/ ) ) (5 777 8}"+ Ns$A A10A1cfd}|S)aHDispatch comparisons to a method of the *other* object. Returns a new *rich comparison* method which dispatches calls to the method `other_method_name` of the *other* object. If there is no such method in the object, ``False`` is returned. This is part of the implementation of a double dispatch pattern. c` t|}n#t$rYdSwxYw||S)NF)getattrAttributeError)r(other other_methodother_method_names rdispatched_cmpz'_cmp_dispatcher..dispatched_cmpsL "5*;<>> atom1 = StringAtom(itemsize=10) # same as ``atom2`` >>> atom2 = Atom.from_kind('string', 10) # same as ``atom1`` >>> atom3 = IntAtom() >>> atom1 == 'foo' False >>> atom1 == atom2 True >>> atom2 != atom1 False >>> atom1 == atom3 False >>> atom3 != atom2 True cJ|j}|d|dS)zReturn the atom class prefix.Nrg)rarfind)r\cnames rprefixz Atom.prefix$s( )ekk&)))**rr!Nct|trt|tjs2|tjvrt d|tj|}|tj||f|S)aCreate an Atom from a NumPy scalar type sctype. Optional shape and default value may be specified as the shape and dflt arguments, respectively. Information in the sctype not represented in an Atom is ignored:: >>> import numpy as np >>> Atom.from_sctype(np.int16, shape=(2, 2)) Int16Atom(shape=(2, 2), dflt=0) >>> Atom.from_sctype('S5', dflt='hello') Traceback (most recent call last): ... ValueError: unknown NumPy scalar type: 'S5' >>> Atom.from_sctype('float64') Float64Atom(shape=(), dflt=0.0) zunknown NumPy scalar type: ) r7r issubclassr8generic sctypeDictr from_dtyperA)r\sctyper)r*s r from_sctypezAtom.from_sctype*s|(64(( +VRZ00 +R]** !Iv!I!IJJJ]6*F~~bh77>>>rc|j}|jrtd|z|jdkrtd|z|jdkr$|j}|d||j|S|jdkratjdt|jdz}t||j vs Jd |d||j|S| |j |j|S) aCreate an Atom from a NumPy dtype. An optional default value may be specified as the dflt argument. Information in the dtype not represented in an Atom is ignored:: >>> import numpy as np >>> Atom.from_dtype(np.dtype((np.int16, (2, 2)))) Int16Atom(shape=(2, 2), dflt=0) >>> Atom.from_dtype(np.dtype('float64')) Float64Atom(shape=(), dflt=0.0) Note: for easier use in Python 3, where all strings lead to the Unicode dtype, this dtype will also generate a StringAtom. Since this is only viable for strings that are castable as ascii, a warning is issued. >>> Atom.from_dtype(np.dtype('U20')) # doctest: +SKIP Atom.py:392: FlavorWarning: support for unicode type is very limited, and only works for strings that can be cast as ascii StringAtom(itemsize=20, shape=(), dflt=b'') z)compound data types are not supported: %rr!z'nested data types are not supported: %rSstringUz^support for unicode type is very limited, and only works for strings that can be cast as asciiz)something went wrong in handling unicode.) rBnamesr r)rr from_kindwarningswarnrstr from_typer])r\rAr*rErs rrpzAtom.from_dtypeEs2J ? &H$%&& & ?b F$%&& & >S  )H==8U[$GG G ^s " " MM' ) ) )!)Q.Hx==IM111;211==8U[$GG G}}Y^U[$???rc|tvrtd|t|\}}|||||S)aCreate an Atom from a PyTables type. Optional shape and default value may be specified as the shape and dflt arguments, respectively:: >>> Atom.from_type('bool') BoolAtom(shape=(), dflt=False) >>> Atom.from_type('int16', shape=(2, 2)) Int16Atom(shape=(2, 2), dflt=0) >>> Atom.from_type('string40', dflt='hello') Traceback (most recent call last): ... ValueError: unknown type: 'string40' >>> Atom.from_type('Float64') Traceback (most recent call last): ... ValueError: unknown type: 'Float64' zunknown type: )rYr rry)r\rr)r*rrs rr}zAtom.from_typetsO, y 6d6677 7#D))h}}T8UD999rcd|i}|tvrtd||dvrtd|z|:|tvrtd|zt|}t|\}}t|}t |dr|}||d<n||vrt |||||}|||d <|d i|S) aCreate an Atom from a PyTables kind. Optional item size, shape and default value may be specified as the itemsize, shape and dflt arguments, respectively. Bear in mind that not all atoms support a default item size:: >>> Atom.from_kind('int', itemsize=2, shape=(2, 2)) Int16Atom(shape=(2, 2), dflt=0) >>> Atom.from_kind('int', shape=(2, 2)) Int32Atom(shape=(2, 2), dflt=0) >>> Atom.from_kind('int', shape=1) Int32Atom(shape=(1,), dflt=0) >>> Atom.from_kind('string', dflt=b'hello') Traceback (most recent call last): ... ValueError: no default item size for kind ``string`` >>> Atom.from_kind('Float') Traceback (most recent call last): ... ValueError: unknown kind: 'Float' Moreover, some kinds with atypical constructor signatures are not supported; you need to use the proper constructor:: >>> Atom.from_kind('enum') #doctest: +ELLIPSIS Traceback (most recent call last): ... ValueError: the ``enum`` kind is not supported... r)zunknown kind: )enumzHthe ``%s`` kind is not supported; please use the appropriate constructorNz$no default item size for kind ``%s``rrr*r!)r$r rXrr[r) r\rrr)r*kwargsr`kdatar+s rryzAtom.from_kinds"F5! x  6d6677 7 8  F#$%% %  ,,, !G#'"()))%d+E'..ND( 5& ! ! (I!)F:  u$$-dHeDDDhI  !F6Ny""6"""rc|jjS)z Total size in bytes of the atom.)rArr(s rsizez Atom.sizesz""rcht|jj|jjjddzS)z,String type to be used in numpy.rec.array().rN)r|rAr)rBrs r recarrtypezAtom.recarrtypes,4:#$$tz':122'>>>rc*t|jS)zDThe number of dimensions of the atom. .. versionadded:: 2.4)r<r)rs rndimz Atom.ndims 4:rc$t|dstd|jjzt |x|_} t d|D}tj||fx|_} t|||_ dS)Nrz=``%s`` is an abstract class; please use one of its subclassesc34K|]}t|VdSr#)rr3s rr6z Atom.__init__..s(..1A......r) r[NotImplementedErrorr&rar>r)r:r8rArGr*)r(nptyper)r*npshaperAs rr'z Atom.__init__stV$$ A%'I(,(?'@AA A.e444 U?.......Xvw&7888 UB&tU33   rcd|jd|j}t|jjds d|jd|}|jjd|dS)Nzshape=, dflt=rUz itemsize=z, ())r)r*r[r&rra)r(argss r__repr__z Atom.__repr__se8 884988t~. :: 76t}6666D.)33D3333r_is_equal_to_atomc.|| Sr#)__eq__)r(rLs r__ne__z Atom.__ne__s;;u%%%%rc n|}|||jdi|S)aGet a copy of the atom, possibly overriding some arguments. Constructor arguments to be overridden must be passed as keyword arguments:: >>> atom1 = Int32Atom(shape=12) >>> atom2 = atom1.copy() >>> print(atom1) Int32Atom(shape=(12,), dflt=0) >>> print(atom2) Int32Atom(shape=(12,), dflt=0) >>> atom1 is atom2 False >>> atom3 = atom1.copy(shape=(2, 2)) >>> print(atom3) Int32Atom(shape=(2, 2), dflt=0) >>> atom1.copy(foobar=42) #doctest: +ELLIPSIS Traceback (most recent call last): ... TypeError: ...__init__() got an unexpected keyword argument 'foobar' r!)_get_init_argsupdater&)r(overridenewargss rcopyz Atom.copy s?.%%''x   t~(((((rctjj}|j}d|D}fd|DS)zGet a dictionary of instance constructor arguments. This implementation works on classes which use the same names for both constructor arguments and instance attributes. c4g|]\}}|j|ju|Sr!)rPOSITIONAL_OR_KEYWORD)r4argps r z'Atom._get_init_args..1s5666Q6Q444444rc>i|]}|dk|t|Sr)rJ)r4rr(s r z'Atom._get_init_args..4s*IIIC3&==WT3''===r)inspect signaturer' parametersitems)r(rrrs` rrzAtom._get_init_args(se%dm44 ) 66*"2"2"4"4666JIII4IIIIrc|j|jkoA|j|jko1|j|jko!tj|j|jkS))Is this object equal to the given `atom`?)rr)rr8allr*r(atoms rrzAtom._is_equal_to_atom6sQ TY&34:+C3MT]23F49 122 4r)r!Nr#)Nr!N)rarbrcrd classmethodrkrrrpr}rypropertyrrrr'rrPrrrrrr!rrrgrgs\\|++[+ ???[?4,@,@,@[,@\:::[:4A#A#A#[A#F##X#??X?X 0444 _0 1 1F&&&)))6 J J J44444rrg) metaclassc@eZdZdZdZdZdZedZdefdZ dS) StringAtomzjDefines an atom of type string. The item size is the *maximum* length in characters of strings. rurc$|jjjSz*Size in bytes of a sigle item in the atom.rArBrrs rrzStringAtom.itemsizeIz''rr!ct|drt|dkrtddd|dt|d|z||dS)NrUrrrurz; it must be a positive integerzS%d)r[rr rgr'r(rr)r*s rr'zStringAtom.__init__Nsox++ 5s8}}q/@/@* ((((455 5 dEH,eT:::::rN) rarbrcrdrr _defvaluerrr'r!rrrr>sc D DI ((X((* ;;;;;;rrc2eZdZdZdZdZdZdZdZdefdZ dS) BoolAtomzDefines an atom of type bool.boolrbool8Fr!cJt||j||dSr#rgr'rr(r)r*s rr'zBoolAtom.__init___" dDIud33333rN) rarbrcrdrrrrTrr'r!rrrrVsL'' DH DHIi444444rrc:eZdZdZdZdZdZdZeeeZ dS)IntAtomz5Defines an atom of a signed integral type (int kind).rTint32rN rarbrcrdrsignedrTrr/r'r!rrrrcs:?? D FHI""8Y77HHHrrc:eZdZdZdZdZdZdZeeeZ dS)UIntAtomz9Defines an atom of an unsigned integral type (uint kind).uintFuint32rNrr!rrrrms:CC D FHI""8Y77HHHrrc6eZdZdZdZdZdZeeeZdS) FloatAtomz6Defines an atom of a floating point type (float kind).floatfloat64N rarbrcrdrrTrr/r'r!rrrrws5@@ DHI""8Y77HHHrrcd||dzfz}|}||d|zd}d|jfd}||d<td|z|f|S) zMCreate a numeric atom class with the given `baseclass` and an `itemsize`.%s%dr zDefines an atom of type ``%s``.)rrrdr!cJt||j||dSr#rrs rr'z'_create_numeric_class..__init__rrr'z%sAtom)rklowerrr) baseclassrrkr` classdictr's r_create_numeric_classrsy''))8a<8 8F LLNNE%u=EGGI i&94444$Ij 6!I< ; ;;rrwr float16float96 float128cteZdZdZdZdZdZddgZedZ e de de e d r*e d ed e e d r*e d ed d efdZdS) ComplexAtomaDefines an atom of kind complex. Allowed item sizes are 8 (single precision) and 16 (double precision). This class must be used instead of more concrete ones to avoid confusions with numarray-like precision specifications used in PyTables 1.X. complex complex128yr rc$|jjjSrrrs rrzComplexAtom.itemsizerr complex64 complex192 complex256r1r!c||jvrtd||jd|j|dzfz|_t||j||dS)Nrrr )_isizesrrrrgr'rs rr'zComplexAtom.__init__sZ 4< ' '))Xt|LL LdiA66  dDIud33333rN)rarbrcrdrrTrrrrrYrZr[r8appendr'r!rrrrs DHI"gG ((X( MM+ MM,wr<   l###rwr<   l###r') 444444rrc(eZdZdZdejfdZdS)_ComplexErrorAtomz:Reminds the user to stop using the old complex atom names.r!c td)Nzto avoid confusions with PyTables 1.X complex atom names, please use ``ComplexAtom(itemsize=N)``, where N=8 for single precision complex atoms, and N=16 for double precision complex atoms)r;rs rr'z_ComplexErrorAtom.__init__s :;; ;rN)rarbrcrdrrr'r!rrrrs6DDk&;;;;;;;rrrrc6eZdZdZdZdZdZeeeZdS)TimeAtoma5Defines an atom of time type (time kind). There are two distinct supported types of time: a 32 bit integer value and a 64 bit floating point value. Both of them reflect the number of seconds since the Unix epoch. This atom has the property of being stored using the HDF5 time datatypes. timetime32rNrr!rrrrs; DHI""8Y77HHHrrc*eZdZdZdZdZdZdefdZdS) Time32AtomzDefines an atom of type time32.rwrrr!c@t|d||dS)Nrrgr'rs rr'zTime32Atom.__init__s  dGUD11111rNrarbrcrdrrrr'r!rrrrsB))H DIi222222rrc*eZdZdZdZdZdZdefdZdS) Time64AtomzDefines an atom of type time64.r time64rr!c@t|d||dS)Nrrrs rr'zTime64Atom.__init__s  dIud33333rNrr!rrrrsB))H DIi444444rrcleZdZdZdZdZedZdZdZ dZ dZ d d Z d Z ed Zd S)EnumAtomad Description of an atom of an enumerated type. Instances of this class describe the atom type used to store enumerated values. Those values belong to an enumerated type, defined by the first argument (enum) in the constructor of the atom, which accepts the same kinds of arguments as the Enum class (see :ref:`EnumClassDescr`). The enumerated type is stored in the enum attribute of the atom. A default value must be specified as the second argument (dflt) in the constructor; it must be the *name* (a string) of one of the enumerated values in the enumerated type. When the atom is created, the corresponding concrete value is broadcast and stored in the dflt attribute (setting different default values for items in a multidimensional atom is not supported yet). If the name does not match any value in the enumerated type, a KeyError is raised. Another atom must be specified as the base argument in order to determine the base type used for storing the values of enumerated values in memory and disk. This *storage atom* is kept in the base attribute of the created atom. As a shorthand, you may specify a PyTables type instead of the storage atom, implying that this has a scalar shape. The storage atom should be able to represent each and every concrete value in the enumeration. If it is not, a TypeError is raised. The default value of the storage atom is ignored. The type attribute of enumerated atoms is always enum. Enumerated atoms also support comparisons with other objects:: >>> enum = ['T0', 'T1', 'T2'] >>> atom1 = EnumAtom(enum, 'T0', 'int8') # same as ``atom2`` >>> atom2 = EnumAtom(enum, 'T0', Int8Atom()) # same as ``atom1`` >>> atom3 = EnumAtom(enum, 'T0', 'int16') >>> atom4 = Int8Atom() >>> atom1 == enum False >>> atom1 == atom2 True >>> atom2 != atom1 False >>> atom1 == atom3 False >>> atom1 == atom4 False >>> atom4 != atom1 True Examples -------- The next C enum construction:: enum myEnum { T0, T1, T2 }; would correspond to the following PyTables declaration:: >>> my_enum_atom = EnumAtom(['T0', 'T1', 'T2'], 'T0', 'int32') Please note the dflt argument with a value of 'T0'. Since the concrete value matching T0 is unknown right now (we have not used explicit concrete values), using the name is the only option left for defining a default value for the atom. The chosen representation of values for this enumerated atom uses unsigned 32-bit integers, which surely wastes quite a lot of memory. Another size could be selected by using the base argument (this time with a full-blown storage atom):: >>> my_enum_atom = EnumAtom(['T0', 'T1', 'T2'], 'T0', UInt8Atom()) You can also define multidimensional arrays for data elements:: >>> my_enum_atom = EnumAtom( ... ['T0', 'T1', 'T2'], 'T0', base='uint32', shape=(3,2)) for 3x2 arrays of uint32. rc$|jjjSz+Size in bytes of a single item in the atom.rrs rrzEnumAtom.itemsizedrrc|jdkrtd|z|j}d|jD} t j|}n#t $rtdwxYw t j||j}n#t $rtdwxYw|jdd|jkrtd | | krtd |jjd vrtd t|jdkrtd dS)zCheck the `base` storage atom.rz4can not use an enumerated atom as a storage atom: %rcg|]\}}|Sr!r!)r4r]rDs rrz'EnumAtom._checkbase..ss999mtUE999rz(concrete values are not uniformly-shapedr@zIstorage atom type is incompatible with concrete values in the enumerationrNzLstorage atom shape does not match that of concrete values in the enumerationzHstorage atom type lacks precision for concrete values in the enumeration)iuz@only integer concrete values are supported for the moment, sorryz?only scalar concrete values are supported for the moment, sorry) rr;rArr8rCr rBr)tolistrr<)r(rBrEpyvalues npgenvaluesnpvaluess r _checkbasezEnumAtom._checkbaseis 9  46:;<< < J 99ty999 H(8,,KK H H HFGG G H Bx 9>BBBHH B B BABB B B >!""  0 0ABB B ??   2 2 4 4 4 4ABB B > j 0 0%'LMM M x~   " "%'LMM M # "sA A&*BB cPt|j|j|j|jS)z3Get a dictionary of instance constructor arguments.)rr*rBr))dictr_defnamerBr)rs rrzEnumAtom._get_init_argss,$*666 6rcdS)rFr!rs rrzEnumAtom._is_equal_to_atoms urc|j|jkoA|j|jko1tj|j|jko|j|jkS)z-Is this object equal to the given `enumatom`?)rr)r8rr*rB)r(enumatoms r_is_equal_to_enumatomzEnumAtom._is_equal_to_enumatomsQ X]*/tzX^/K/F49 566/I. 0rr!ct|tst|}||_t|trt|}||||_||}||_gg}}|D]/\}} | || | 0|jj } ||_ tj || j|_t|| ||dS)Nr@)r7rrr|rgr}rrBr rrA_namesr8rC_valuesr') r(rr*rBr)rFrxvaluesr]rDrEs rr'zEnumAtom.__init__s$%% ::D dC  (>>$''D  t* Bv! ! !MT5 LL    MM% IO  xin===  dIug66666rc Hd|jd|jd|jd|jd S)NzEnumAtom(enum=rz, base=z, shape=r)rr rBr)rs rrzEnumAtom.__repr__s1999dmmmTYYY D ErrNr!)rarbrcrdrrrrrrrrr'rrPrr!rrrrsSSv D D ((X(!M!M!MF666  00077774EEE_4 5 5FFFrrcFeZdZdZdZdZdZdZedZ d dZ d Z dS) ReferenceAtomzSDefines an atom of type object to read references. This atom is read-only. referenceobjectNoneTypeNc$|jjjSrrrs rrzReferenceAtom.itemsizerrr!cTt||j||jdSr#)rgr'rr)r(r)s rr'zReferenceAtom.__init__s$ dDIudn=====rcd|jdS)NzReferenceAtom(shape=rr=rs rrzReferenceAtom.__repr__s3dj3333rr) rarbrcrdrrrTrrrr'rr!rrrrsp D DHI ((X(>>>>44444rrc$eZdZdZdZdZdZdS) PseudoAtomaPseudo-atoms can only be used in ``VLArray`` nodes. They can be recognised because they also have `kind`, `type` and `shape` attributes, but no `size`, `itemsize` or `dflt` ones. Instead, they have a `base` atom which defines the elements used for storage. c d|jjzS)Nz%s())r&rars rrzPseudoAtom.__repr__s///rct)z1Convert an `object_` into an array of base atoms.rr(object_s rtoarrayzPseudoAtom.toarray "!rct)z0Convert an `array` of base atoms into an object.r"r(rCs r fromarrayzPseudoAtom.fromarrayr&rN)rarbrcrdrr%r)r!rrrrsK000""" """""rrc"eZdZdZdZdZdZdS) _BufferedAtomz@Pseudo-atom which stores data as a buffer (flat array of uints).r!c||}tj||jjt |}|S)NbufferrAr)) _tobufferr8ndarrayrBrAr<)r(r$buffer_rCs rr%z_BufferedAtom.toarray s?..)) '!$W/// rct)z#Convert an `object_` into a buffer.r"r#s rr/z_BufferedAtom._tobufferr&rN)rarbrcrdr)r%r/r!rrr+r+s=JJ E """""rr+c:eZdZdZdZdZeZdZdZ dS) VLStringAtomuDefines an atom of type ``vlstring``. This class describes a *row* of the VLArray class, rather than an atom. It differs from the StringAtom class in that you can only add *one instance of it to one specific row*, i.e. the :meth:`VLArray.append` method only accepts one object when the base atom is of this type. This class stores bytestrings. It does not make assumptions on the encoding of the string, and raw bytes are stored as is. To store a string you will need to *explicitly* convert it to a bytestring before you can save them:: >>> s = 'A unicode string: hbar = ℏ' >>> bytestring = s.encode('utf-8') >>> VLArray.append(bytestring) # doctest: +SKIP For full Unicode support, using VLUnicodeAtom (see :ref:`VLUnicodeAtom`) is recommended. Variable-length string atoms do not accept parameters and they cause the reads of rows to always return Python bytestrings. You can regard vlstring atoms as an easy way to save generic variable length strings. vlstringct|trtjdtn't|t st d|tj|S)Nz6Storing non bytestrings in VLStringAtom is deprecated.object is not a string: ) r7r|rzr{DeprecationWarningbytesr;r8string_r#s rr/zVLStringAtom._tobuffer3sp gs # # D M(); = = = =GU++ DBwBBCC Cz'"""rc*|Sr#)tobytesr(s rr)zVLStringAtom.fromarray;s}}rN rarbrcrdrr UInt8AtomrBr/r)r!rrr4r4sS2 D D 9;;D###rr4c@eZdZdZdZdZeZdZdZ dZ dS) VLUnicodeAtoma0Defines an atom of type vlunicode. This class describes a *row* of the VLArray class, rather than an atom. It is very similar to VLStringAtom (see :ref:`VLStringAtom`), but it stores Unicode strings (using 32-bit characters a la UCS-4, so all strings of the same length also take up the same space). This class does not make assumptions on the encoding of plain input strings. Plain strings are supported as long as no character is out of the ASCII set; otherwise, you will need to *explicitly* convert them to Unicode before you can save them. Variable-length Unicode atoms do not accept parameters and they cause the reads of rows to always return Python Unicode strings. You can regard vlunicode atoms as an easy way to save variable length Unicode strings. vlunicodecVt|trtjdtn't|t st d|t |}tj|d}tj ||j j t|S)N3Storing bytestrings in VLUnicodeAtom is deprecated.r7rvr@r-) r7r9rzr{r8r|r;r8rCr0rBrAr<)r(r$ustruarrs rr%zVLUnicodeAtom.toarray]s gu % % D M(); = = = =GS)) DBwBBCC C7||xC(((ztyc$iiAAA Arct|trtjdtn't|t st d|tj|S)NrCr7) r7r9rzr{r8r|r;r8unicode_r#s rr/zVLUnicodeAtom._tobufferhsr gu % % D M(); = = = =GS)) DBwBBCC C{7###rct|}|dkrdS|d|zS)NrzU%d)r<viewitem)r(rClengths rr)zVLUnicodeAtom.fromarrayss=U Q;;2zz%&.))..000rN) rarbrcrdrr UInt32AtomrBr%r/r)r!rrr@r@?se$ D D :<>>-----rrO)Brdrerrznumpyr8utilsr misc.enumrrQ exceptionsr __docformat__setrYr$rXcompiler rrr/r>rGrPrrRrgrrrrrrInt8Atom Int16Atom Int32Atom Int64Atomr> UInt16AtomrM UInt64Atomr[ Float16Atom Float32Atom Float64Atom Float96Atom Float128Atomrr Complex32Atom Complex64AtomComplex128AtomComplex192AtomComplex256Atomrrrrrrr+r4r@rOr!rrrns33  %%%%%%" 9 CEE : 2:+ , ,   F222"---..&!0!0!0!0!0t!0!0!0Hv4v4v4v4v4Xv4v4v4v4r ;;;;;;;;0 4 4 4 4 4t 4 4 488888d88888888t88888888888 < < < ! ! , , ! !'1 - - ! !'1 - - ! !'1 - - ! !(A . . " "8Q / / " "8Q / / " "8Q / /  72y6'' 155K##Iq11 ##Iq11  72y7'' 266K 72z8((B77L(4(4(4(4(4$(4(4(4V;;;;; t;;;;2CB B  72|'&N 72|'&N 8 8 8 8 8t 8 8 8 2222222244444444w6w6w6w6w6tw6w6w6@44444D444P""""""""."""""J""""'''''='''T8181818181M818181v----------r