Ë
|
Kñúh | ã óì d Z dZddlZddlZddlmc mZ ddl m
|
Z
|
m Z ddZ d Z d Zd Zdd Z G d
|
d « Z G d d « Zd Z G d de« Z G d de« Z G d de« Z G d d« ZddZy)zBA collection of functions designed to help I/O with ascii files.
|
|
zrestructuredtext ené N)ÚasbytesÚ asunicodec óR t | « t u r|d}| j |« } | S )a Decode bytes from binary input streams.
|
|
Defaults to decoding from 'latin1'.
|
|
Parameters
|
----------
|
line : str or bytes
|
Line to be decoded.
|
encoding : str
|
Encoding used to decode `line`.
|
|
Returns
|
-------
|
decoded_line : str
|
|
Úlatin1)ÚtypeÚbytesÚdecode)ÚlineÚencodings úEH:\Change_password\venv_build\Lib\site-packages\numpy/lib/_iotools.pyÚ _decode_liner s. ô" DzUÑØ Ð Ø HØ{{8Ó$à Kó c ó: | dz y# t t f$ r Y yw xY w)z2
|
Check whether obj behaves like a string.
|
Ú FT©Ú TypeErrorÚ
|
ValueError©Úobjs r Ú_is_string_liker & s, ðØ bð øô zÐ "ò Ùðúó c ó: | dz y# t t f$ r Y yw xY w)z8
|
Check whether obj behaves like a bytes object.
|
r FTr r s r Ú_is_bytes_liker 1 s, ðØ c ð øô zÐ "ò Ùðúr c óH t fd j xs dD « « S )aµ
|
Returns whether one or several fields of a dtype are nested.
|
|
Parameters
|
----------
|
ndtype : dtype
|
Data-type of a structured array.
|
|
Raises
|
------
|
AttributeError
|
If `ndtype` does not have a `names` attribute.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> dt = np.dtype([('name', 'S4'), ('x', float), ('y', float)])
|
>>> np.lib._iotools.has_nested_fields(dt)
|
False
|
|
c 3 ó@ K | ] }| j d u y w©N)Únames)Ú.0ÚnameÚndtypes r ú <genexpr>z$has_nested_fields.<locals>.<genexpr>R s øè ø ÒM°$vd|×!Ñ!¨Ô-ÑMùs © )Úanyr )r s `r Úhas_nested_fieldsr$ < s ø ô, ÓM¸&¿,¹,Ò:LÈ"ÔMÓ MÐMr c ó | j }|E|r6| j gt t j | j
|
« « z S | j gS g }|D ]1 }| j | }t |d |« }|j |« 3 |S )as
|
Unpack a structured data-type by collapsing nested fields and/or fields
|
with a shape.
|
|
Note that the field names are lost.
|
|
Parameters
|
----------
|
ndtype : dtype
|
The datatype to collapse
|
flatten_base : bool, optional
|
If True, transform a field with a shape into several fields. Default is
|
False.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> dt = np.dtype([('name', 'S4'), ('x', float), ('y', float),
|
... ('block', int, (2, 3))])
|
>>> np.lib._iotools.flatten_dtype(dt)
|
[dtype('S4'), dtype('float64'), dtype('float64'), dtype('int64')]
|
>>> np.lib._iotools.flatten_dtype(dt, flatten_base=True)
|
[dtype('S4'),
|
dtype('float64'),
|
dtype('float64'),
|
dtype('int64'),
|
dtype('int64'),
|
dtype('int64'),
|
dtype('int64'),
|
dtype('int64'),
|
dtype('int64')]
|
|
r ) r ÚbaseÚintÚnpÚprodÚshapeÚfieldsÚ flatten_dtypeÚextend)r Ú flatten_baser ÚtypesÚfieldÚinfoÚflat_dts r r, r, U s ðD LLEØ }Ù ØKK=¤3¤r§w¡w¨v¯|©|Ó'<Ó#=Ñ=Ð =Ø }Ð àØò "EØ== Ñ'DÜ# D¨¡G¨\Ó:GØ LLÕ !ð "ð r c ó: e Zd ZdZd Z d dZd Zd Zd Zd Z y)
|
Ú LineSplittera÷
|
Object to split a string at a given delimiter or at given places.
|
|
Parameters
|
----------
|
delimiter : str, int, or sequence of ints, optional
|
If a string, character used to delimit consecutive fields.
|
If an integer or a sequence of integers, width(s) of each field.
|
comments : str, optional
|
Character used to mark the beginning of a comment. Default is '#'.
|
autostrip : bool, optional
|
Whether to strip each individual field. Default is True.
|
|
c ó fdS )aÕ
|
Wrapper to strip each member of the output of `method`.
|
|
Parameters
|
----------
|
method : function
|
Function that takes a single argument and returns a sequence of
|
strings.
|
|
Returns
|
-------
|
wrapped : function
|
The result of wrapping `method`. `wrapped` takes a single input
|
argument and returns a list of strings that are stripped of
|
white-space.
|
|
c óV | « D cg c] }|j « c}S c c}w r )Ústrip)ÚinputÚ_Úmethods r ú<lambda>z(LineSplitter.autostrip.<locals>.<lambda>§ s ø ±¸³ Ö ?¨AaggiÒ ? ùÒ ?s &r" )Úselfr: s `r Ú autostripzLineSplitter.autostrip s ø ó$ @Ð?r Nc ó8 t |« }t |« }|| _ |t |t « r|xs d }| j }nt |d« r`| j }t j dgt |« z « }t j |« D cg c] \ }}t ||« }}}n1t |« r| j t |« }}n| j d }}|| _ |r | j! |« | _ || _ y || _ || _ y c c}}w )NÚ__iter__r )r ÚcommentsÚ
|
isinstanceÚstrÚ_delimited_splitterÚhasattrÚ_variablewidth_splitterr( ÚcumsumÚlistÚ itertoolsÚpairwiseÚslicer' Ú_fixedwidth_splitterÚ delimiterr= Ú _handymanr ) r< rL r@ r= r rM ÚidxÚiÚjs r Ú__init__zLineSplitter.__init__© s ä Ó+ Ü Ó)à ð Ð ¤*¨Y¼Ô"<Ø!Ò) TIØ ×0Ñ0Iä Y
|
Ô +Ø ×4Ñ4IÜ))QC¤$ y£/Ñ 1Ó2CÜ3<×3EÑ3EÀcÓ3J×K©¨!¨Qq !ÐKIÒKä ^à×-Ñ-¬s°9«~ð "Yð '+×&>Ñ&>À YØ"Ù Ø !^^¨IÓ 6DNð ! ð 'DNØ ùó Ls ÂDc ó¶ | j |j | j « d }|j d« }|sg S |j | j « S )z2Chop off comments, strip, and split at delimiter. r z
|
)r@ Úsplitr7 rL ©r< r
|
s r rC z LineSplitter._delimited_splitterÆ sL à ==Ð $Ø::dmmÓ,¨QÑ/DØzz'Ó"ÙØIØzz$..Ó)Ð)r c ó2 | j |j | j « d }|j d« }|sg S | j }t dt |« |« D cg c] }t |||z « }}|D cg c] }|| c}S c c}w c c}w )Nr z
|
)r@ rS r7 rL ÚrangeÚlenrJ )r< r
|
ÚfixedrO ÚslicesÚss r rK z!LineSplitter._fixedwidth_splitterÏ s Ø ==Ð $Ø::dmmÓ,¨QÑ/DØzz&Ó!ÙØIØÜ/4°Q¼¸D» À5Ó/IÖJ¨!%1u9Õ%ÐJÐJØ!'Ö(AQÒ(Ð(ùò KùÚ(s Á$B Bc ó¦ | j |j | j « d }|sg S | j }|D cg c] }|| c}S c c}w )Nr )r@ rS rL )r< r
|
rY rZ s r rE z$LineSplitter._variablewidth_splitterÙ sL Ø ==Ð $Ø::dmmÓ,¨QÑ/DÙØIØ Ø!'Ö(AQÒ(Ð(ùÒ(s ¿ Ac óL | j t || j « « S r )rM r r rT s r Ú__call__zLineSplitter.__call__á s Ø~~l¨4°· ± Ó ?Ó@Ð@r )Nú#TN)
|
Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__r= rQ rC rK rE r] r" r r r4 r4
s1 ñ ò @ð( @DØ ó!ò:*ò)ò)óAr r4 c ó@ e Zd ZdZdZ ed« Z ddZd dZd dZ y)
|
Ú NameValidatora=
|
Object to validate a list of strings to use as field names.
|
|
The strings are stripped of any non alphanumeric character, and spaces
|
are replaced by '_'. During instantiation, the user can define a list
|
of names to exclude, as well as a list of invalid characters. Names in
|
the exclusion list are appended a '_' character.
|
|
Once an instance has been created, it can be called with a list of
|
names, and a list of valid names will be created. The `__call__`
|
method accepts an optional keyword "default" that sets the default name
|
in case of ambiguity. By default this is 'f', so that names will
|
default to `f0`, `f1`, etc.
|
|
Parameters
|
----------
|
excludelist : sequence, optional
|
A list of names to exclude. This list is appended to the default
|
list ['return', 'file', 'print']. Excluded names are appended an
|
underscore: for example, `file` becomes `file_` if supplied.
|
deletechars : str, optional
|
A string combining invalid characters that must be deleted from the
|
names.
|
case_sensitive : {True, False, 'upper', 'lower'}, optional
|
* If True, field names are case-sensitive.
|
* If False or 'upper', field names are converted to upper case.
|
* If 'lower', field names are converted to lower case.
|
|
The default value is True.
|
replace_space : '_', optional
|
Character(s) used in replacement of white spaces.
|
|
Notes
|
-----
|
Calling an instance of `NameValidator` is the same as calling its
|
method `validate`.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> validator = np.lib._iotools.NameValidator()
|
>>> validator(['file', 'field2', 'with space', 'CaSe'])
|
('file_', 'field2', 'with_space', 'CaSe')
|
|
>>> validator = np.lib._iotools.NameValidator(excludelist=['excl'],
|
... deletechars='q',
|
... case_sensitive=False)
|
>>> validator(['excl', 'field2', 'no_q', 'with space', 'CaSe'])
|
('EXCL', 'FIELD2', 'NO_Q', 'WITH_SPACE', 'CASE')
|
|
)ÚreturnÚfileÚprintz ~!@#$%^&*()-=+~\|]}[{';: /?.>,<Nc ó |g }|j | j « || _ |t | j « }n t |« }|j d« || _ ||du rd | _ || _
|
y |du s|j d« rd | _ || _
|
y |j d« rd | _ || _
|
y d | d
|
}t |« ) Nú"Tc ó | S r r" ©Úxs r r; z(NameValidator.__init__.<locals>.<lambda>- s ¨A r FÚuc ó" | j « S r )Úupperrk s r r; z(NameValidator.__init__.<locals>.<lambda>/ ó ¨A¯G©G«I r Úlc ó" | j « S r )Úlowerrk s r r; z(NameValidator.__init__.<locals>.<lambda>1 rp r z"unrecognized case_sensitive value ú.) r- ÚdefaultexcludelistÚ excludelistÚsetÚdefaultdeletecharsÚaddÚ deletecharsÚcase_converterÚ
|
startswithr Ú replace_space)r< rv rz Úcase_sensitiver} ÚdeleteÚmsgs r rQ zNameValidator.__init__ sã ð Ð Ø KØ×Ñ4×2Ñ2Ô3Ø&Ôà Ð Ü×0Ñ0Ó1FäÓ%FØ
|
|
3Ø!Ôà Ð "¨¸$Ñ(>Ù"-DÔ ð +Õð Ñ%¨.×*CÑ*CÀCÔ*HÙ"5DÔ ð +Õð × &Ñ & sÔ +Ù"5DÔ ð
|
+Õð 7°~Ð6FÀaÐHCÜ S/Ð !r c ó¸ ||yg }t |t « r|g}|0t |« }||k rt |« dg||z
|
z z }n
|
||kD r|d| }| j }| j
|
}| j }| j }g } i }
|
d} |D ]Ä } || « j « } |r| j d|« } dj | D cg c] } | |vs| c} « } | dk( r || z } | |v r| dz } || z } | |v r| dz } n | |v r| dz } |
|
j | d« }|dkD r| j | d|z z « n| j | « |dz |
|
| < Æ t | « S c c} w )a
|
Validate a list of strings as field names for a structured array.
|
|
Parameters
|
----------
|
names : sequence of str
|
Strings to be validated.
|
defaultfmt : str, optional
|
Default format string, used if validating a given string
|
reduces its length to zero.
|
nbfields : integer, optional
|
Final number of validated names, used to expand or shrink the
|
initial list of names.
|
|
Returns
|
-------
|
validatednames : list of str
|
The list of validated field names.
|
|
Notes
|
-----
|
A `NameValidator` instance can be called directly, which is the
|
same as calling `validate`. For examples, see `NameValidator`.
|
|
Nr r ú é r9 z_%d)rA rB rW rG rz rv r{ r} r7 ÚreplaceÚjoinÚgetÚappendÚtuple)r< r Ú
|
defaultfmtÚnbfieldsÚnbnamesrz rv r{ r} ÚvalidatednamesÚseenÚnbemptyÚitemÚcÚcnts r ÚvalidatezNameValidator.validate8 s© ð6 MØÐ ØØEÜ eSÔ !ØIEØ Ð Ü%jGØ(Ò"Ü U r d¨h¸Ñ.@Ñ&AÑAØHÒ$Ø ixÐ(à×&Ñ& Ø×&Ñ& Ø ×,Ñ,Ø ×*Ñ* àØØàò !DÙ! $Ó'×-Ñ-Ó/DÙ Ø|| C¨ Ó7Ø77 tÖD !¨q¸ Ò/CAÒDÓEDØrzØ! GÑ+ØemØqLGØ%¨Ñ/Dð emð 1 ØÑ$Ø Ø((4 Ó#CØQwØ ×%Ñ% d¨U°S©[Ñ&8Õ9à ×%Ñ% dÔ+Ø qDJð% !ô& ^Ó$Ð$ùò Es à E
|
à E
|
c ó* | j |||¬« S )N)r r )r )r< r r r s r r] zNameValidator.__call__~ s Ø}}U¨zÀH}ÓMÐMr )NNNr9 )úf%iN)
|
r_ r` ra rb ru Ú frozensetrx rQ r r] r" r r rd rd å s4 ñ2ðh 3ÐÙ"Ð#IÓJÐà59Ø47ó+ó6D%ôLNr rd c óP | j « } | dk( ry| dk( ryt d« )a
|
Tries to transform a string supposed to represent a boolean to a boolean.
|
|
Parameters
|
----------
|
value : str
|
The string that is transformed to a boolean.
|
|
Returns
|
-------
|
boolval : bool
|
The boolean representation of `value`.
|
|
Raises
|
------
|
ValueError
|
If the string is not 'True' or 'False' (case independent)
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> np.lib._iotools.str2bool('TRUE')
|
True
|
>>> np.lib._iotools.str2bool('false')
|
False
|
|
ÚTRUETÚFALSEFzInvalid boolean)ro r )Úvalues r Ústr2boolr s0 ð8 KKMEØ ØØ 'Ò ØäÐ*Ó+Ð+r c ó e Zd ZdZy)ÚConverterErrorzR
|
Exception raised when an error occurs in a converter for string values.
|
|
N©r_ r` ra rb r" r r r r § ó ñð r r c ó e Zd ZdZy)ÚConverterLockErrorzR
|
Exception raised when an attempt is made to upgrade a locked converter.
|
|
Nr r" r r r r ¯ r r r c ó e Zd ZdZy)ÚConversionWarningzÞ
|
Warning issued when a string converter has a problem.
|
|
Notes
|
-----
|
In `genfromtxt` a `ConversionWarning` is issued if raising exceptions
|
is explicitly suppressed with the "invalid_raise" keyword.
|
|
Nr r" r r r¢ r¢ · s ñð r r¢ c ó6 e Zd ZdZej
|
edfej edfgZ ej ej « j ej ej « j k r e j ej edf« e j ej eej" fej$ eej" dz fej( ej( ej" fej* edfej, eej" fej. eej" dz fej0 edfej4 edfg« e d « Z e d « Z e d « Z e dd
|
« Z e d « Z! dd Z"d Z#d Z$d Z%d Z&d Z'd Z( ddZ)y )ÚStringConverterab
|
Factory class for function transforming a string into another object
|
(int, float).
|
|
After initialization, an instance can be called to transform a string
|
into another object. If the string is recognized as representing a
|
missing value, a default value is returned.
|
|
Attributes
|
----------
|
func : function
|
Function used for the conversion.
|
default : any
|
Default value to return when the input corresponds to a missing
|
value.
|
type : type
|
Type of the output.
|
_status : int
|
Integer representing the order of the conversion.
|
_mapper : sequence of tuples
|
Sequence of tuples (dtype, function, default value) to evaluate in
|
order.
|
_locked : bool
|
Holds `locked` parameter.
|
|
Parameters
|
----------
|
dtype_or_func : {None, dtype, function}, optional
|
If a `dtype`, specifies the input data type, used to define a basic
|
function and a default value for missing data. For example, when
|
`dtype` is float, the `func` attribute is set to `float` and the
|
default value to `np.nan`. If a function, this function is used to
|
convert a string to another object. In this case, it is recommended
|
to give an associated default value as input.
|
default : any, optional
|
Value to return by default, that is, when the string to be
|
converted is flagged as missing. If not given, `StringConverter`
|
tries to supply a reasonable default value.
|
missing_values : {None, sequence of str}, optional
|
``None`` or sequence of strings indicating a missing value. If ``None``
|
then missing values are indicated by empty entries. The default is
|
``None``.
|
locked : bool, optional
|
Whether the StringConverter should be locked to prevent automatic
|
upgrade or not. Default is False.
|
|
Féÿÿÿÿy z???c ó@ t j |« j S )z(Returns the dtype of the input variable.)r( ÚarrayÚdtype©ÚclsÚvals r Ú _getdtypezStringConverter._getdtype
|
s ô xx}×"Ñ"Ð"r c óT t j |« j j S )z4Returns the type of the dtype of the input variable.)r( r§ r¨ r r© s r Ú _getsubdtypez StringConverter._getsubdtype s ô xx}×"Ñ"×'Ñ'Ð'r c óX |j t j k( r|S |j S )z9Returns dtype for datetime64 and type of dtype otherwise.)r r( Ú
|
datetime64)rª r¨ s r Ú _dtypeortypez StringConverter._dtypeortype s# ð :: Ò &ØLØzzÐr Nc ó t |« r/| j j d| j |« ||f« yt |d« rÇt |d t t f« r$|D ] }| j j d|« y|dgt |« z }n5t |« }|j dgt |« t |« z
|
z « t ||« D ]3 \ }}| j j d| j |« ||f« 5 yy)aé
|
Upgrade the mapper of a StringConverter by adding a new function and
|
its corresponding default.
|
|
The input function (or sequence of functions) and its associated
|
default value (if any) is inserted in penultimate position of the
|
mapper. The corresponding type is estimated from the dtype of the
|
default value.
|
|
Parameters
|
----------
|
func : var
|
Function, or sequence of functions
|
|
Examples
|
--------
|
>>> import dateutil.parser
|
>>> import datetime
|
>>> dateparser = dateutil.parser.parse
|
>>> defaultdate = datetime.date(2000, 1, 1)
|
>>> StringConverter.upgrade_mapper(dateparser, default=defaultdate)
|
r¥ Nr? r ) ÚcallableÚ_mapperÚinsertr® rD rA r rG rW r Úzip)rª ÚfuncÚdefaultr9 ÚfctÚdfts r Úupgrade_mapperz StringConverter.upgrade_mapper sû ô2 D>Ø KK× Ñ r C×$4Ñ$4°WÓ$=¸tÀWÐ#MÔ NØ Ü T:Ô &Ü$q'¤E¬4 =Ô1Ø ò .AØKK×&Ñ& r¨1Õ-ð.àØØ &¤3 t£9Ñ,ä w-Ø v¬¨T«´S¸³\Ñ)AÑ BÔCÜ gÓ .ò JSØ ×"Ñ" 2¨×(8Ñ(8¸Ó(=¸sÀCÐ'HÕIñ Jð 'r c ó t | j « D ]! \ }\ }}}|j |k( s||||ffc S t | j « D ]2 \ }\ }}}t j |j |« s+||||ffc S t
|
r )Ú enumerater´ r r( Ú
|
issubdtypeÚ LookupError)rª r¨ rO Údeftyper· Ú default_defs r Ú_find_map_entryz StringConverter._find_map_entryI s ô 09¸¿¹Ó/Eò 7Ñ +AÑ+{ØzzWÓ$Ø7 D¨+Ð6Ð6Ò6ð 7ô
|
09¸¿¹Ó/Eò 7Ñ +AÑ+{Ü}}UZZ¨Õ1Ø7 D¨+Ð6Ð6Ò6ð 7ô Ðr c óÆ t |« | _ |3t | _ d| _ |xs d| _ t j d« }nû d | _ t j |« } | j |« \ | _ \ }}} || | _ n|| _ | j || _ | j | j d d k( r|t! |j t j" « rt j" | _ nBt! |j t j$ « rt j$ | _ nd | _ | d h| _ n>t) |t* « r|j- d
|
« }t/ t1 |« d gz « | _ | j2 | _ | j7 |« | _
|
d| _ || _ y # t $ rf t |« sd}t |t |« z « || _ |$ | j d« }n# t $ r d }Y nw xY w| j |« }Y Ëw xY w# t $ r% || _ | j d \ }}}d| _ Y Ìw xY w) Nr FÚboolzOThe input argument `dtype` is neither a function nor a dtype (got '%s' instead)Ú0r¥ r c ó* t t | « « S r )r' Úfloatrk s r r; z*StringConverter.__init__.<locals>.<lambda> s ¬#¬e°A«h«- r r ú,) rÄ Ú_lockedr r· Ú_statusr¸ r( r¨ r r³ r r r¬ r r¿ r´ Ú
|
issubclassÚuint64Úint64Úmissing_valuesrA rB rS rw rG Ú _strict_callÚ_callingfunctionr± Ú_checkedÚ_initial_default)
|
r< Ú dtype_or_funcr¸ rÎ Úlockedr¨ Úerrmsgr9 r· rÁ s
|
r rQ zStringConverter.__init__W s ô F| à Ð Ü DIØ DLØ"Ò+ eDLÜHHVÓ$Eð 0Ø Ü Ó/ð& +Ø7;×7KÑ7KÈEÓ7RÑ4 Ñ 4q $¨ ð ?Ø#.DLà#*DLð yyÐ Ø ð yyDLL¨O¨AÑ .Ò.Ü ejj¬"¯)©)Ô4Ü "§ ¡ DIÜ §
|
¡
|
¬B¯H©HÔ5Ü "§¡DIá 7DIà Ð !Ø#% $DÕ ä.¬#Ô.Ø!/×!5Ñ!5°cÓ!:Ü"%¤d¨>Ó&:¸b¸TÑ&AÓ"BDÔ à $× 1Ñ 1Ô Ø×%Ñ% eÓ, Ø Ø 'Õ øôq ò 0ä Ô.ð IFä# F¬T°-Ó-@Ñ$@ÓAÐAà ) ð ?ð'Ø"&§)¡)¨C£.øÜ%ò 'Ø"&ð'úà wÓ/ð 0ûô( ò !à & Ø !\\¨"Ñ -
|
4Ø ð !úsH Á G Á$ H2 Ç 6H/Ç7H ÈH/È HÈH/ÈHÈH/È.H/È2*I É I c ó\ | j |« S # t $ r | j cY S w xY wr )r· r r¸ ©r< r s r Ú _loose_callzStringConverter._loose_call s/ ð Ø99UÓ#Ð #øÜò Ø<<Ò ð ús +ª+c ón | j |« }| j t u r$ t j || j ¬« |S |S # t
|
$ r t w xY w# t $ rM |j « | j v r!| j sd| _
|
| j cY S t d| d« w xY w)N)r¨ FzCannot convert string 'ú') r· r' r( r§ r Ú OverflowErrorr r7 rÎ rÊ rÑ r¸ )r< r Ú new_values r rÏ z StringConverter._strict_call¦ s´ ð Að %Ó(Ið
|
yyCÑ ð%ÜHHU¨$¯)©)Õ4ð
|
Ð 9Ð øô %ò %Ü$Ð$ð%ûô ò AØ{{} × 3Ñ 3Ñ3Ø||Ø$)DMØ||Ò#Ü Ð 6°u°g¸QÐ ?Ó@Ð @ð Aús/ #A ¦!A ÁA Á A Á AÁA Á AB4Â$B4c ó$ | j |« S r )rÐ r× s r r] zStringConverter.__call__¿ s Ø×$Ñ$ UÓ+Ð+r c óH | j r d}t |« t | j « }| j }||k( r d}t |« ||dz
|
k r|dz }| j | \ | _ | _ }|| _ | j | j | _ y || _ y )Nz*Converter is locked and cannot be upgradedz*Could not find a valid conversion functionr )
|
rÉ r rW r´ rÊ r r r· rÒ r¸ )r< rÕ Ú
|
_statusmaxrÊ r¸ s r Ú _do_upgradezStringConverter._do_upgrade s à <<ØAFÜ$ VÓ,Ð ,Ü Ó&
|
à,,Ø jÒ ØAFÜ Ó(Ð (Ø z A~Ò %Ø qLGØ(,¯ © °WÑ(=Ñ% 49gØ Ø × Ñ Ð ,Ø ×0Ñ0DLà"DLr c ó d| _ | j |« S # t $ r$ | j « | j |« cY S w xY w)a
|
Find the best converter for a given string, and return the result.
|
|
The supplied string `value` is converted by testing different
|
converters in order. First the `func` method of the
|
`StringConverter` instance is tried, if this fails other available
|
converters are tried. The order in which these other converters
|
are tried is determined by the `_status` attribute of the instance.
|
|
Parameters
|
----------
|
value : str
|
The string to convert.
|
|
Returns
|
-------
|
out : any
|
The result of converting `value` with the appropriate converter.
|
|
T)rÑ rÏ r rà Úupgrader× s r râ zStringConverter.upgradeÖ sK ð* ð 'Ø×$Ñ$ UÓ+Ð +øÜò 'Ø × Ñ Ô Ø<< Ó&Ò &ð 'ús *AÁAc óÈ d| _ t |d« s|f}| j } |D ]
|
} ||« y # t $ r$ | j « | j |« Y y w xY w)NTr? )rÑ rD rÏ r rà Ú iterupgrade)r< r rÏ Ú_ms r rä zStringConverter.iterupgradeò sj Ø ÜujÔ)ØHEØ×(Ñ( ð $Øò !Ù RÕ ñ !øäò $Ø × Ñ Ô Ø × Ñ UÖ #ð $ús ¤4 ´*A!Á A!c óÔ || _ || _ |-|| _ | j | j |« « | _ n2 ||xs d« }| j | j |« « | _ |t « | _ yt j |« s|g}t d |D « « s t d« | j j |« y# t t f$ r d}Y w xY w)a£
|
Set StringConverter attributes directly.
|
|
Parameters
|
----------
|
func : function
|
Conversion function.
|
default : any, optional
|
Value to return by default, that is, when the string to be
|
converted is flagged as missing. If not given,
|
`StringConverter` tries to supply a reasonable default value.
|
testing_value : str, optional
|
A string representing a standard input value of the converter.
|
This string is used to help defining a reasonable default
|
value.
|
missing_values : {sequence of str, None}, optional
|
Sequence of strings indicating a missing value. If ``None``, then
|
the existing `missing_values` are cleared. The default is ``''``.
|
locked : bool, optional
|
Whether the StringConverter should be locked to prevent
|
automatic upgrade or not. Default is False.
|
|
Notes
|
-----
|
`update` takes the same parameters as the constructor of
|
`StringConverter`, except that `func` does not accept a `dtype`
|
whereas `dtype_or_func` in the constructor does.
|
|
NÚ1c 3 ó< K | ] }t |t « y wr )rA rB )r Úvs r r! z)StringConverter.update.<locals>.<genexpr>3 s è ø ÒB¨az !¤S×)ÑBùs z)missing_values must be strings or unicode)r· rÉ r¸ r± r¬ r r r rw rÎ r( ÚiterableÚallÚupdate)r< r· r¸ Ú testing_valuerÎ rÔ Útesters r rì zStringConverter.updateþ sÞ ð> Ø ð Ð Ø"DLØ ×)Ñ)¨$¯.©.¸Ó*AÓBDIð Ù mÒ 2¨sÓ3ð ×)Ñ)¨$¯.©.¸Ó*@ÓADIð Ð !ô #&£%DÕ ä;;~Ô.Ø"0Ð!1ÜÑB°>ÔBÔBÜ Ð KÓLÐLØ × Ñ × &Ñ & ~Õ 6øô zÐ*ò Ø ð ús ¿ C ÃC'Ã&C'r )NNNF)NNr F)*r_ r` ra rb ÚnxrÄ r Úint_r' r´ r¨ ÚitemsizerÍ r r- Úfloat64rÇ ÚnanÚ
|
complex128ÚcomplexÚ
|
longdoubleÚintegerÚfloatingÚcomplexfloatingÚstr_r Úbytes_r Ú classmethodr¬ r® r± r» r rQ rØ rÏ r] rà râ rä rì r" r r r¤ r¤ Ä s ñ.ð^ 5Ð)ØbÐ!ð$Gð
|
rxxÓ×!Ñ! H B§H¡H¨R¯X©XÓ$6×$?Ñ$?Ò?Ø # rÐ*Ô+à NNRZZ ¨¯©Ð/Ø]] G¨R¯V©V°b©[Ð9Ø]] B§M¡M°2·6±6Ð:ð ZZ bÐ)Ø[[ %¨¯©Ð0Ø×'Ñ'¨°"·&±&¸2±+Ð>ð WWi¨Ð/ØYY ¨Ð/ð ô ð ñ#ó ð#ð ñ(ó ð(ð ñ ó ð ð ò&Jó ð&JðP ñ ó ð ð IMØ óG(òR ò Aò2,ò#ò('ò8
|
$ð 8<Ø).ô77r r¤ c óÈ t j | « } |³t di |¤}t |t « r|j d« }| j Vt | j gt |« z « } |||¬« }t j t t ||« « « } | S ||t | j « |¬« | _ | S | j t di |¤}t d t t | j « « D « « }| j |k( r-|dk7 r( |dgt | j « z |¬« | _ | S || j |¬« | _ | S # t $ rp t di |¤}t | « }|dgt | « z }n!t |t « r|j d« } ||||¬« }t j | |d« } Y | S w xY w) aQ
|
Convenience function to create a `np.dtype` object.
|
|
The function processes the input `dtype` and matches it with the given
|
names.
|
|
Parameters
|
----------
|
ndtype : var
|
Definition of the dtype. Can be any string or dictionary recognized
|
by the `np.dtype` function, or a sequence of types.
|
names : str or sequence, optional
|
Sequence of strings to use as field names for a structured dtype.
|
For convenience, `names` can be a string of a comma-separated list
|
of names.
|
defaultfmt : str, optional
|
Format string used to define missing names, such as ``"f%i"``
|
(default) or ``"fields_%02i"``.
|
validationargs : optional
|
A series of optional arguments used to initialize a
|
`NameValidator`.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> np.lib._iotools.easy_dtype(float)
|
dtype('float64')
|
>>> np.lib._iotools.easy_dtype("i4, f8")
|
dtype([('f0', '<i4'), ('f1', '<f8')])
|
>>> np.lib._iotools.easy_dtype("i4, f8", defaultfmt="field_%03i")
|
dtype([('field_000', '<i4'), ('field_001', '<f8')])
|
|
>>> np.lib._iotools.easy_dtype((int, float, float), names="a,b,c")
|
dtype([('a', '<i8'), ('b', '<f8'), ('c', '<f8')])
|
>>> np.lib._iotools.easy_dtype(float, names="a,b,c")
|
dtype([('a', '<f8'), ('b', '<f8'), ('c', '<f8')])
|
|
rÈ )r )r r c 3 ó& K | ] }d | yw)ÚfNr" )r rO s r r! z easy_dtype.<locals>.<genexpr>} s è ø Ò"M¨q Q q c¤7Ñ"Mùs r r )Úformatsr r" )r( r¨ rd rA rB rS r r r rW rG r¶ rV r )r r r Úvalidationargsr r Únumbered_namesr s r Ú
|
easy_dtyper 8 s ðN$MÜ&Ó!ð Ð Ü$Ñ6 ~Ñ6HÜ%¤Ô%Ø CÓ(à||Ð#Ü §¡ ´°E³
|
Ñ :Ó;Ù °:Ô>ܤ$¤s¨5°'Ó':Ó";Ó<ð Mñ (¨¼¸F¿L¹LÓ8IØ3=ô ? ð Mð \\Ð %Ü$Ñ6 ~Ñ6Hä "Ñ"M´E¼#¸f¿l¹lÓ:KÓ4LÔ"MÓ MNØ Ò/°jÀEÒ6IÙ '¨¨¬s°6·<±<Ó/@Ñ(@Ø3=ô ? ð
|
Mñ (¨¯ © ÀÔ L Ø MøôG ò ?Ü Ñ2 >Ñ2Üv;Ø =ØD3v;Ñ&EÜ sÔ #ØKK Ó$EÙ¨¸jÔIÜ f°uÑ=Ó>ð6 MðG?ús E( Å(A5G!Ç G!r )F)Nr )rb Ú __docformat__rH Únumpyr( Únumpy._core.numericÚ_coreÚnumericrï Ú numpy._utilsr r r r r r$ r, r4 rd r Ú Exceptionr r Ú UserWarningr¢ r¤ r r" r r ú<module>r s ðñð & ã ã ß Ð ß +óò2òòNó2-÷`]Añ ]A÷@ZNñ ZNòz",ôJ Yô ô ô ô
|
ô
|
÷q7ñ q7ôh Lr
|
