我们从Python开源项目中，提取了以下47个代码示例，用于说明如何使用types.StringType()。
def read_treasure_from_mongodb(self,start,end): startdate=start enddate=end series={"Time Period":[],"1month":[],"3month":[],"6month":[],"1year":[],"2year":[],"3year":[],"5year":[],"7year":[],"10year":[],"20year":[],"30year":[]} if type(start) is types.StringType: startdate = datetime.datetime.strptime(start, "%Y-%m-%d") if type(end) is types.StringType: enddate=datetime.datetime.strptime(end, "%Y-%m-%d") for treasuredaily in self.treasure['treasure'].find({"Time Period": {"$gte": startdate,"$lt":enddate}}).sort("date"): series["Time Period"].append(treasuredaily["Time Period"]) series["1month"].append(treasuredaily["1month"]) series["3month"].append(treasuredaily["3month"]) series["6month"].append(treasuredaily["6month"]) series["1year"].append(treasuredaily["1year"]) series["2year"].append(treasuredaily["2year"]) series["3year"].append(treasuredaily["3year"]) series["5year"].append(treasuredaily["5year"]) series["7year"].append(treasuredaily["7year"]) series["10year"].append(treasuredaily["10year"]) series["20year"].append(treasuredaily["20year"]) series["30year"].append(treasuredaily["30year"]) totaldata=zip(series["1month"],series["3month"],series["6month"],series["1year"],series["2year"],series["3year"],series["5year"],series["7year"],series["10year"],series["20year"],series["30year"]) df = pd.DataFrame(data=list(totaldata),index=series["Time Period"],columns = ['1month', '3month','6month', '1year', '2year', '3year', '5year', '7year', '10year', '20year', '30year']) return df.sort_index().tz_localize('UTC')
def start_response(self, status, headers,exc_info=None): """'start_response()' callable as specified by PEP 333""" if exc_info: try: if self.headers_sent: # Re-raise original exception if headers sent raise exc_info[0], exc_info[1], exc_info[2] finally: exc_info = None # avoid dangling circular ref elif self.headers is not None: raise AssertionError("Headers already set!") assert type(status) is StringType,"Status must be a string" assert len(status)>=4,"Status must be at least 4 characters" assert int(status[:3]),"Status message must begin w/3-digit code" assert status[3]==" ", "Status message must have a space after code" if __debug__: for name,val in headers: assert type(name) is StringType,"Header names must be strings" assert type(val) is StringType,"Header values must be strings" assert not is_hop_by_hop(name),"Hop-by-hop headers not allowed" self.status = status self.headers = self.headers_class(headers) return self.write
def bytes2int(bytes): """Converts a list of bytes or a string to an integer >>> (128*256 + 64)*256 + + 15 8405007 >>> l = [128, 64, 15] >>> bytes2int(l) 8405007 """ if not (type(bytes) is types.ListType or type(bytes) is types.StringType): raise TypeError("You must pass a string or a list") # Convert byte stream to integer integer = 0 for byte in bytes: integer *= 256 if type(byte) is types.StringType: byte = ord(byte) integer += byte return integer
def str642int(string): """Converts a base64 encoded string into an integer. The chars of this string in in the range '0'-'9','A'-'Z','a'-'z','-','_' >>> str642int('7MyqL') 123456789 """ if not (type(string) is types.ListType or type(string) is types.StringType): raise TypeError("You must pass a string or a list") integer = 0 for byte in string: integer *= 64 if type(byte) is types.StringType: byte = ord(byte) integer += from64(byte) return integer
def __init__(self, name, enumList): self.__doc__ = name lookup = { } reverseLookup = { } i = 0 uniqueNames = [ ] uniqueValues = [ ] for x in enumList: if type(x) == types.TupleType: x, i = x if type(x) != types.StringType: raise EnumException, "enum name is not a string: " + x if type(i) != types.IntType: raise EnumException, "enum value is not an integer: " + i if x in uniqueNames: raise EnumException, "enum name is not unique: " + x if i in uniqueValues: raise EnumException, "enum value is not unique for " + x uniqueNames.append(x) uniqueValues.append(i) lookup[x] = i reverseLookup[i] = x i = i + 1 self.lookup = lookup self.reverseLookup = reverseLookup
def new_looper(a, arg=None): """Helper function for nest() determines what sort of looper to make given a's type""" if isinstance(a,types.TupleType): if len(a) == 2: return RangeLooper(a[0],a[1]) elif len(a) == 3: return RangeLooper(a[0],a[1],a[2]) elif isinstance(a, types.BooleanType): return BooleanLooper(a) elif isinstance(a,types.IntType) or isinstance(a, types.LongType): return RangeLooper(a) elif isinstance(a, types.StringType) or isinstance(a, types.ListType): return ListLooper(a) elif isinstance(a, Looper): return a elif isinstance(a, types.LambdaType): return CalcField(a, arg)
def getValueStrings( val, blnUgly=True ): #Used by joinWithComma function to join list items for SQL queries. #Expects to receive 'valid' types, as this was designed specifically for joining object attributes and nonvalid attributes were pulled. #If the default blnUgly is set to false, then the nonvalid types are ignored and the output will be pretty, but the SQL Insert statement will #probably be wrong. tplStrings = (types.StringType, types.StringTypes ) tplNums = ( types.FloatType, types.IntType, types.LongType, types.BooleanType ) if isinstance( val, tplNums ): return '#num#'+ str( val ) + '#num#' elif isinstance( val, tplStrings ): strDblQuote = '"' return strDblQuote + val + strDblQuote else: if blnUgly == True: return "Error: nonconvertable value passed - value type: %s" % type(val ) else: return None
def __init__(self, name, enumList): self.__doc__ = name lookup = {} reverseLookup = {} i = 0 uniqueNames = [] uniqueValues = [] for x in enumList: if isinstance(x, types.TupleType): x, i = x if not isinstance(x, types.StringType): raise EnumException("enum name is not a string: %r" % x) if not isinstance(i, types.IntType): raise EnumException("enum value is not an integer: %r" % i) if x in uniqueNames: raise EnumException("enum name is not unique: %r" % x) if i in uniqueValues: raise EnumException("enum value is not unique for %r" % x) uniqueNames.append(x) uniqueValues.append(i) lookup[x] = i reverseLookup[i] = x i = i + 1 self.lookup = lookup self.reverseLookup = reverseLookup
def encrypt(self, plaintext, K): """Encrypt a piece of data. :Parameter plaintext: The piece of data to encrypt. :Type plaintext: byte string or long :Parameter K: A random parameter required by some algorithms :Type K: byte string or long :Return: A tuple with two items. Each item is of the same type as the plaintext (string or long). """ wasString=0 if isinstance(plaintext, types.StringType): plaintext=bytes_to_long(plaintext) ; wasString=1 if isinstance(K, types.StringType): K=bytes_to_long(K) ciphertext=self._encrypt(plaintext, K) if wasString: return tuple(map(long_to_bytes, ciphertext)) else: return ciphertext
def decrypt(self, ciphertext): """Decrypt a piece of data. :Parameter ciphertext: The piece of data to decrypt. :Type ciphertext: byte string, long or a 2-item tuple as returned by `encrypt` :Return: A byte string if ciphertext was a byte string or a tuple of byte strings. A long otherwise. """ wasString=0 if not isinstance(ciphertext, types.TupleType): ciphertext=(ciphertext,) if isinstance(ciphertext[0], types.StringType): ciphertext=tuple(map(bytes_to_long, ciphertext)) ; wasString=1 plaintext=self._decrypt(ciphertext) if wasString: return long_to_bytes(plaintext) else: return plaintext
def sign(self, M, K): """Sign a piece of data. :Parameter M: The piece of data to encrypt. :Type M: byte string or long :Parameter K: A random parameter required by some algorithms :Type K: byte string or long :Return: A tuple with two items. """ if (not self.has_private()): raise TypeError('Private key not available in this object') if isinstance(M, types.StringType): M=bytes_to_long(M) if isinstance(K, types.StringType): K=bytes_to_long(K) return self._sign(M, K)
def blind(self, M, B): """Blind a message to prevent certain side-channel attacks. :Parameter M: The message to blind. :Type M: byte string or long :Parameter B: Blinding factor. :Type B: byte string or long :Return: A byte string if M was so. A long otherwise. """ wasString=0 if isinstance(M, types.StringType): M=bytes_to_long(M) ; wasString=1 if isinstance(B, types.StringType): B=bytes_to_long(B) blindedmessage=self._blind(M, B) if wasString: return long_to_bytes(blindedmessage) else: return blindedmessage
def unblind(self, M, B): """Unblind a message after cryptographic processing. :Parameter M: The encoded message to unblind. :Type M: byte string or long :Parameter B: Blinding factor. :Type B: byte string or long """ wasString=0 if isinstance(M, types.StringType): M=bytes_to_long(M) ; wasString=1 if isinstance(B, types.StringType): B=bytes_to_long(B) unblindedmessage=self._unblind(M, B) if wasString: return long_to_bytes(unblindedmessage) else: return unblindedmessage # The following methods will usually be left alone, except for # signature-only algorithms. They both return Boolean values # recording whether this key's algorithm can sign and encrypt.
def __init__(self, file): """ @param file: A string or file object represnting the file to send. """ if isinstance(file, types.StringType): self.file = open(file, 'rb') else: self.file = file self.fileSize = 0 self.bytesSent = 0 self.completed = 0 self.connected = 0 self.targetUser = None self.segmentSize = 2045 self.auth = randint(0, 2**30) self._pendingSend = None # :(
def __getitem__(self, k): """ C{dirdbm[k]} Get the contents of a file in this directory as a string. @type k: str @param k: key to lookup @return: The value associated with C{k} @raise KeyError: Raised when there is no such key """ assert type(k) == types.StringType, AssertionError("DirDBM key must be a string") path = os.path.join(self.dname, self._encode(k)) try: return self._readFile(path) except: raise KeyError, k
def write(self, data): """'write()' callable as specified by PEP 333""" assert type(data) is StringType,"write() argument must be string" if not self.status: raise AssertionError("write() before start_response()") elif not self.headers_sent: # Before the first output, send the stored headers self.bytes_sent = len(data) # make sure we know content-length self.send_headers() else: self.bytes_sent += len(data) # XXX check Content-Length and truncate if too many bytes written? self._write(data) self._flush()
def WriteXML(self, file): """ Dump non-empty contents to the output file, in XML format. """ if not self.loc: return out = SITEURL_XML_PREFIX for attribute in self.__slots__: value = getattr(self, attribute) if value: if type(value) == types.UnicodeType: value = encoder.NarrowText(value, None) elif type(value) != types.StringType: value = str(value) value = xml.sax.saxutils.escape(value) out = out + (' <%s>%s</%s>\n' % (attribute, value, attribute)) out = out + SITEURL_XML_SUFFIX file.write(out) #end def WriteXML #end class URL
def __init__(self, sw, message=None): '''Initialize. sw -- SoapWriter ''' self._indx = 0 MessageInterface.__init__(self, sw) Base.__init__(self) self._dom = DOM self.node = None if type(message) in (types.StringType,types.UnicodeType): self.loadFromString(message) elif isinstance(message, ElementProxy): self.node = message._getNode() else: self.node = message self.processorNss = self.standard_ns.copy() self.processorNss.update(self.reserved_ns)
def WriteTextElement( self, text_elem ) : overrides = Settings() self._RendTextPropertySet ( text_elem.Properties, overrides ) self._RendShadingPropertySet( text_elem.Shading, overrides, 'ch' ) # write the wrapper and then let the custom handler have a go if overrides : self._write( '{%s ' % repr( overrides ) ) # if the data is just a string then we can now write it if isinstance( text_elem.Data, StringType ) : self._write( text_elem.Data or '' ) elif text_elem.Data == TAB : self._write( r'\tab ' ) else : self.WriteCustomElement( self, text_elem.Data ) if overrides : self._write( '}' )
def test_replication_path(self, datastore_id, destinationIp=None, destionationPassphrase=None, destionationPort=None, sourceIp=None, testType=None, request=None): """ Tests the specified replication path on the specified datastore, provide either request or set other params. **Supported on:** VMstore (all versions) Args: datastore_id: Datastore object's UUID destinationIp: Remote IPv4 address of another datastore where replication data is received. destionationPassphrase: Authorization key used on the remote end of this replication link. destionationPort: Remote port of another datastore where replication data is received. sourceIp: Local IPv4 address used by datastore to send replication data. testType: Test to perform request: TestReplicationPath request """ if 'v310.41' in self.version.supportedVersionSet: url = "datastore/%s/testReplicationPath" else: url = "datastore/%s/replicationPath/test" self._update(_get_request_object(locals(), ["self", "datastore_id"], TestReplicationPath), path_params = [datastore_id], resource_url=url, request_class=types.StringType)
def DeleteEvent(self,values): sql = 'insert into {}.{}({}) values('.format(self.databasename,self.tablename,','.join([a[0] for a in self.table_column_list])) for idex,value in enumerate(values): if type(value) is types.StringType: if value == 'Null': sql += '{}'.format(value) else: sql += '"{}"'.format(value) else: sql += '{}'.format(value) if len(values[idex:]) <= 1: sql += ')' else: sql += ',' if _remote_filed._rollback_status: print '{: >21}{}{}'.format('', '-- ', sql) else: self.__tmppack(sql, 2)
