All Samples(236855) | Call(235990) | Derive(865) | Import(0)
int(x[, base]) -> integer Convert a string or number to an integer, if possible. A floating point argument will be truncated towards zero (this does not include a string representation of a floating point number!) When converting a string, use the optional base. It is an error to supply a base when converting a non-string. If base is zero, the proper base is guessed based on the string content. If the argument is outside the integer range a long object will be returned instead.
src/s/h/shedskin-HEAD/examples/msp_ss.py shedskin(Download)
def __init__(self, aTimeout=-1, aProlongFactor=-1): # shed skin : change default None arguments
"""init bsl object, don't connect yet"""
if aTimeout == -1: #is None:
self.timeout = DEFAULT_TIMEOUT
else:
self.timeout = aTimeout
if aProlongFactor == -1: #is None:
self.prolongFactor = DEFAULT_PROLONG
self.telosLatch = 0
self.telosI2C = 0
self.protocolMode = MODE_BSL
self.BSLMemAccessWarning = 0 #Default: no warning.
self.slowmode = 0
'aProlongFactor' after transmission of a command to give
plenty of time to the micro controller to finish the command.
Returns zero if the function is successful."""
if DEBUG > 1: sys.stderr.write("* comInit()\n")
self.seqNo = 0
self.reqNo = 0
self.rxPtr = 0
def comDone(self):
"""Closes the used serial port.
This function must be called at the end of a program,
otherwise the serial port might not be released and can not be
used in other programs.
Returns zero if the function is successful."""
if DEBUG > 1: sys.stderr.write("* comDone()")
self.SetRSTpin(1) #disable power
self.SetTESTpin(0) #disable power
self.serialport.close()
def comRxHeader(self):
"""receive header and split data"""
if DEBUG > 1: sys.stderr.write("* comRxHeader()\n")
rxHeader = ord(hdr) & 0xf0;
rxNum = ord(hdr) & 0x0f;
if self.protocolMode == MODE_BSL:
self.reqNo = 0
self.seqNo = 0
rxNum = 0
if DEBUG > 1: sys.stderr.write("* comRxHeader() OK\n")
return rxHeader, rxNum
def comRxFrame(self, rxNum):
if DEBUG > 1: sys.stderr.write("* comRxFrame()\n")
rxFrame = chr(DATA_FRAME | rxNum)
def comRxFrame(self, rxNum):
if DEBUG > 1: sys.stderr.write("* comRxFrame()\n")
rxFrame = chr(DATA_FRAME | rxNum)
if DEBUG > 2: sys.stderr.write(" comRxFrame() header...\n")
rxFramedata = self.serialport.read(3)
if len(rxFramedata) != 3: raise BSLException("Timeout")
rxFrame = rxFrame + rxFramedata
if DEBUG > 3: sys.stderr.write(" comRxFrame() check header...\n")
if rxFrame[1] == chr(0) and rxFrame[2] == rxFrame[3]: #Add. header info. correct?
rxLengthCRC = ord(rxFrame[2]) + 2 #Add CRC-Bytes to length
if DEBUG > 2: sys.stderr.write(" comRxFrame() receiving data, size: %s\n" % rxLengthCRC)
if len(rxFramedata) != rxLengthCRC: raise BSLException("Timeout")
rxFrame = rxFrame + rxFramedata
#Check received frame:
if DEBUG > 3: sys.stderr.write(" comRxFrame() crc check\n")
#rxLength+4: Length with header but w/o CRC:
checksum = self.calcChecksum(rxFrame, ord(rxFrame[2]) + 4)
if rxFrame[ord(rxFrame[2])+4] == chr(0xff & checksum) and \
rxFrame[ord(rxFrame[2])+5] == chr(0xff & (checksum >> 8)): #Checksum correct?
#Frame received correctly (=> send next frame)
if DEBUG > 2: sys.stderr.write("* comRxFrame() OK\n")
return rxFrame
else:
if DEBUG: sys.stderr.write(" comRxFrame() Checksum wrong\n")
else:
if DEBUG: sys.stderr.write(" comRxFrame() Checksum wrong\n")
else:
if DEBUG: sys.stderr.write(" comRxFrame() Header corrupt %r" % rxFrame)
raise BSLException(ERR_COM) #Frame has errors!
def comTxHeader(self, txHeader):
"""send header"""
if DEBUG > 1: sys.stderr.write("* txHeader()\n")
in dataIn (if not a NULL pointer is passed).
In this routine all the necessary protocol stuff is handled.
Returns zero if the function was successful."""
if DEBUG > 1: sys.stderr.write("* comTxRx()\n")
#txFrame = [] # shed skin
rxHeader = 0
rxNum = 0
# shed skin : put chr around (0xff) and (0), or it cannot work (because of string.join below)
if (length % 2) != 0:
#/* Fill with one byte to have even number of bytes to send */
if self.protocolMode == MODE_BSL:
dataOut.append(chr(0xFF)) #fill with 0xFF
else:
dataOut.append(chr(0)) #fill with zero
txFrame = "%c%c%c%c" % (DATA_FRAME | self.seqNo, cmd, len(dataOut), len(dataOut))
self.reqNo = (self.seqNo + 1) % MAX_FRAME_COUNT
txFrame = txFrame + chr((checksum >> 8) & 0xff)
accessAddr = (0x0212 + (checksum^0xffff)) & 0xfffe #0x0212: Address of wCHKSUM
if self.BSLMemAccessWarning and accessAddr < BSL_CRITICAL_ADDR:
sys.stderr.write("WARNING: This command might change data at address %04x or %04x!\n" % (accessAddr, accessAddr + 1))
self.serialport.flushInput() #clear receiving queue
#TODO: Check after each transmitted character,
#TODO: if microcontroller did send a character (probably a NAK!).
for c in txFrame:
self.serialport.write(c)
if DEBUG > 3: sys.stderr.write("\ttx %02x" % ord(c))
if DEBUG > 3: sys.stderr.write("\ttx %02x" % ord(c))
#if self.serialport.inWaiting(): break #abort when BSL replies, probably NAK
else:
if DEBUG > 1: sys.stderr.write( " comTxRx() transmit OK\n")
#Receiving part -------------------------------------------
rxHeader, rxNum = self.comRxHeader() #receive header
if DEBUG > 1: sys.stderr.write(" comTxRx() rxHeader=0x%02x, rxNum=%d, seqNo=%d, reqNo=%s\n" % (rxHeader, rxNum, self.seqNo, self.reqNo))
if rxHeader == DATA_ACK: #acknowledge/OK
if DEBUG > 2: sys.stderr.write(" comTxRx() DATA_ACK\n")
if rxNum == self.reqNo:
self.seqNo = self.reqNo
if DEBUG > 2: sys.stderr.write("* comTxRx() DATA_ACK OK\n")
if DEBUG > 2: sys.stderr.write("* comTxRx() DATA_ACK OK\n")
return #Acknowledge received correctly => next frame
raise BSLException(ERR_FRAME_NUMBER)
elif rxHeader == DATA_NAK: #not acknowledge/error
if DEBUG > 2: sys.stderr.write("* comTxRx() DATA_NAK\n")
raise BSLException(ERR_RX_NAK)
elif rxHeader == DATA_FRAME: #receive data
if DEBUG > 2: sys.stderr.write("* comTxRx() DATA_FRAME\n")
if rxNum == self.reqNo:
rxFrame = self.comRxFrame(rxNum)
return rxFrame
raise BSLException(ERR_FRAME_NUMBER)
elif rxHeader == CMD_FAILED: #Frame ok, but command failed.
if DEBUG > 2: sys.stderr.write("* comTxRx() CMD_FAILED\n")
self.telosBReset(invokeBSL)
return
if DEBUG > 1: sys.stderr.write("* bslReset(invokeBSL=%s)\n" % invokeBSL)
self.SetRSTpin(1) #power suply
self.SetTESTpin(1) #power suply
time.sleep(0.250) #charge capacitor on boot loader hardware
"""
loopcnt = 5 #Max. tries to get synchronization
if DEBUG > 1: sys.stderr.write("* bslSync(wait=%d)\n" % wait)
while wait or loopcnt:
loopcnt = loopcnt - 1 #count down tries
self.serialport.flushInput() #clear input, in case a prog is running
self.serialport.write(chr(BSL_SYNC)) #Send synchronization byte
c = self.serialport.read(1) #read answer
if c == chr(DATA_ACK): #ACk
if DEBUG > 1: sys.stderr.write(" bslSync() OK\n")
return #Sync. successful
elif not c: #timeout
if loopcnt > 4:
if DEBUG > 1:
sys.stderr.write(" bslSync() timeout, retry ...\n")
elif loopcnt == 4:
#nmi may have caused the first reset to be ignored, try again
self.bslReset(0)
self.bslReset(1)
elif loopcnt > 0:
if DEBUG > 1:
sys.stderr.write(" bslSync() timeout, retry ...\n")
else :
if DEBUG > 1:
if DEBUG > 1:
sys.stderr.write(" bslSync() timeout\n")
else: #garbage
if DEBUG > 1: sys.stderr.write(" bslSync() failed (0x%02x), retry ...\n" % ord(c))
raise BSLException(ERR_BSL_SYNC) #Sync. failed
repeated, forever
Parameters return by boot loader are passed via blkin.
"""
if DEBUG > 1: sys.stderr.write("* bslTxRx()\n")
if cmd == BSL_TXBLK:
#Align to even start address
blkout = blkout + chr(0xFF) #Inc. len and fill last byte of blkout with 0xFF
length = length + 1
elif cmd == BSL_RXBLK:
#Align to even start address
if (addr % 2) != 0:
addr = addr - 1 #Decrement address but
for l in lines:
if l[0] != ':': raise BSLException("File Format Error\n")
l = l.strip() #fix CR-LF issues...
length = int(l[1:3],16)
address = int(l[3:7],16)
type = int(l[7:9],16)
check = int(l[-2:],16)
startAddr = currentAddr = address
segmentdata = []
for i in range(length):
segmentdata.append( chr(int(l[9+2*i:11+2*i],16)) )
currentAddr = length + currentAddr
elif type in (0x01, 0x02, 0x03, 0x04, 0x05):
pass
#create a new segment
if segmentdata:
self.segments.append( Segment(startAddr, string.join(segmentdata,'')) )
startAddr = int(l[1:],16)
segmentdata = []
else:
for i in string.split(l):
segmentdata.append(chr(int(i,16)))
def preparePatch(self):
"""prepare to download patch"""
if DEBUG > 1: sys.stderr.write("* preparePatch()\n")
if self.patchLoaded:
#Load PC with 0x0220.
#This will invoke the patched bootstrap loader subroutines.
self.bslTxRx(BSL_LOADPC, #Command: Load PC
def postPatch(self):
"""setup after the patch is loaded"""
if DEBUG > 1: sys.stderr.write("* postPatch()\n")
if self.patchLoaded:
self.BSLMemAccessWarning = 1 #Turn warning back on.
def verifyBlk(self, addr, blkout, action):
"""verify memory against data or 0xff"""
if DEBUG > 1: sys.stderr.write("* verifyBlk()\n")
if action & ACTION_VERIFY or action & ACTION_ERASE_CHECK:
if DEBUG: sys.stderr.write(" Check starting at 0x%04x, %d bytes ... \n" % (addr, len(blkout)))
if DEBUG: sys.stderr.write(" Check starting at 0x%04x, %d bytes ... \n" % (addr, len(blkout)))
self.preparePatch()
blkin = self.bslTxRx(BSL_RXBLK, addr, len(blkout))
self.postPatch()
for i in range(len(blkout)):
if action & ACTION_VERIFY:
sys.stderr.flush()
raise BSLException(ERR_VERIFY_FAILED) #Verify failed!
continue
elif action & ACTION_ERASE_CHECK:
#Compare data in blkin with erase pattern
if blkin[i] != chr(0xff):
sys.stderr.write("Erase Check failed at 0x%04x (0x%02x)\n" % (addr+i, ord(blkin[i])))
sys.stderr.flush()
raise BSLException(ERR_ERASE_CHECK_FAILED) #Erase Check failed!
continue
def programBlk(self, addr, blkout, action):
"""programm a memory block"""
if DEBUG > 1: sys.stderr.write("* programBlk()\n")
def programBlk(self, addr, blkout, action):
"""programm a memory block"""
if DEBUG > 1: sys.stderr.write("* programBlk()\n")
#Check, if specified range is erased
self.verifyBlk(addr, blkout, action & ACTION_ERASE_CHECK)
if action & ACTION_PROGRAM:
if DEBUG: sys.stderr.write(" Program starting at 0x%04x, %i bytes ...\n" % (addr, len(blkout)))
self.preparePatch()
#Program block
self.bslTxRx(BSL_TXBLK, addr, len(blkout), blkout)
self.postPatch()
#Verify block
self.verifyBlk(addr, blkout, action & ACTION_VERIFY)
#segments:
#list of tuples or lists:
#segements = [ (addr1, [d0,d1,d2,...]), (addr2, [e0,e1,e2,...])]
def programData(self, segments, action):
"""programm or verify data"""
if DEBUG > 1: sys.stderr.write("* programData()\n")
def uploadData(self, startaddress, size, wait=0):
"""upload a datablock"""
if DEBUG > 1: sys.stderr.write("* uploadData()\n")
data = ''
pstart = 0
while pstart<size:
length = self.maxData
if pstart+length > size:
length = size - pstart
data = data + self.bslTxRx(BSL_RXBLK,
def txPasswd(self, passwd=None, wait=0):
"""transmit password, default if None is given."""
if DEBUG > 1: sys.stderr.write("* txPassword(%r)\n" % passwd)
if passwd is None:
#Send "standard" password to get access to protected functions.
sys.stderr.write("Transmit default password ...\n")
sys.stderr.flush()
sys.stderr.write('Transmit password ...\n')
sys.stderr.flush()
#send the password
self.bslTxRx(BSL_TXPWORD, #Command: Transmit Password
0xffe0, #Address of interupt vectors
0x0020, #Number of bytes
passwd, #password
self.bslReset(1) #Invoke the boot loader.
for i in range(self.meraseCycles):
if i == 1: sys.stderr.write("Additional Mass Erase Cycles...\n")
self.bslTxRx(BSL_MERAS, #Command: Mass Erase
0xff00, #Any address within flash memory.
0xa506) #Required setting for mass erase!
self.passwd = None #No password file required!
#Read actual bootstrap loader version.
#sys.stderr.write("Reading BSL version ...\n")
blkin = self.bslTxRx(BSL_RXBLK, #Command: Read/Receive Block
0x0ff0, #Start address
16) #No. of bytes to read
# shed skin : use shed skin struct module
#dev_id, bslVerHi, bslVerLo = struct.unpack(">H8xBB4x", blkin[:-2]) #cut away checksum and extract data
dev_id, bslVerHi, bslVerLo = struct.unpack_ints(">H8xBB4x", blkin[:-2]) #cut away checksum and extract data
if self.cpu is None: #cpy type forced?
if deviceids.has_key(dev_id):
self.cpu = deviceids[dev_id] #try to autodectect CPU type
if DEBUG:
#to prepare stack pointer for the following patch.
#This function will lock the protected functions again.
sys.stderr.write("Adjust SP. Load PC with 0x0C22 ...\n")
self.bslTxRx(BSL_LOADPC, #Command: Load PC
0x0C22) #Address to load into PC
#Re-send password to re-gain access to protected functions.
self.txPasswd(self.passwd)
if ((mayuseBSL and speed and self.bslVer < 0x0150) or forceBSL) and replacementBSL is None:
replacementBSL = Memory() #File to program
if self.cpu == F4x:
if DEBUG:
sys.stderr.write("Using built in BSL replacement for F4x devices\n")
sys.stderr.flush()
replacementBSL.loadTIText(cStringIO.StringIO(F4X_BSL)) #parse embedded BSL
else:
if DEBUG:
self.actionDownloadBSL(replacementBSL)
#debug message with the real BSL version in use (may have changed after replacement BSL)
if DEBUG:
sys.stderr.write("Current bootstrap loader version: 0x%04x\n" % (self.bslVer,))
sys.stderr.flush()
segments = Memory() #data to program
segments.loadTIText(cStringIO.StringIO(PATCH)) #parse embedded patch
#program patch
self.programData(segments, ACTION_PROGRAM | ACTION_VERIFY)
self.patchLoaded = 1
else:
if DEBUG:
def actionDownloadBSL(self, bslsegments):
sys.stderr.write("Load new BSL into RAM...\n")
sys.stderr.flush()
self.programData(bslsegments, ACTION_PROGRAM)
sys.stderr.write("Verify new BSL...\n")
sys.stderr.flush()
self.programData(bslsegments, ACTION_VERIFY) #File to verify
#Read startvector of bootstrap loader
#blkin = self.bslTxRx(self.BSL_RXBLK, 0x0300, 2)
#blkin = self.bslTxRx(self.BSL_RXBLK, 0x0220, 2)
# shed skin : __getitem__ ?
#blkin = self.bslTxRx(BSL_RXBLK, bslsegments[0].startaddress, 2)
blkin = self.bslTxRx(BSL_RXBLK, bslsegments.segments[0].startaddress, 2)
sys.stderr.write("Starting new BSL at 0x%04x...\n" % startaddr)
sys.stderr.flush()
self.bslTxRx(BSL_LOADPC, #Command: Load PC
startaddr) #Address to load into PC
#BSL-Bugs should be fixed within "new" BSL
def actionEraseCheck(self):
"""check the erasure of required flash cells."""
sys.stderr.write("Erase Check by file ...\n")
sys.stderr.flush()
if self.data is not None:
self.programData(self.data, ACTION_ERASE_CHECK)
else:
def actionProgram(self):
"""program data into flash memory."""
if self.data is not None:
sys.stderr.write("Program ...\n")
sys.stderr.flush()
self.programData(self.data, ACTION_PROGRAM)
sys.stderr.write("%i bytes programmed.\n" % self.byteCtr)
def actionVerify(self):
"""Verify programmed data"""
if self.data is not None:
sys.stderr.write("Verify ...\n")
sys.stderr.flush()
self.programData(self.data, ACTION_VERIFY)
else:
def actionRun(self, address=0x220):
"""start program at specified address"""
sys.stderr.write("Load PC with 0x%04x ...\n" % address)
sys.stderr.flush()
self.bslTxRx(BSL_LOADPC, #Command: Load PC
address) #Address to load into PC
sys.stderr.write("Changing baudrate to %d ...\n" % baudrate)
sys.stderr.flush()
self.bslTxRx(BSL_CHANGEBAUD, #Command: change baudrate
a, l) #args are coded in adr and len
time.sleep(0.010) #recomended delay
self.serialport.setBaudrate(baudrate)
def actionReadBSLVersion(self):
"""informational output of BSL version number.
(newer MSP430-BSLs only)"""
ans = self.bslTxRx(BSL_TXVERSION, 0) #Command: receive version info
wait = 1
elif o in ("-f", "--framesize"):
try:
maxData = int(a) #try to convert decimal
except ValueError:
sys.stderr.write("framesize must be a valid number\n")
sys.exit(2)
#Make sure that conditions for maxData are met:
#( >= 16 and == n*16 and <= MAX_DATA_BYTES!)
if maxData > MAX_DATA_BYTES:
maxData = MAX_DATA_BYTES
sys.stderr.write( "Max. number of data bytes within one frame set to %i.\n" % maxData)
elif o in ("-m", "--erasecycles"):
try:
meraseCycles = int(a) #try to convert decimal
except ValueError:
sys.stderr.write("erasecycles must be a valid number\n")
sys.exit(2)
reset = 1
elif o in ("-g", "--go"):
try:
goaddr = int(a) #try to convert decimal
except ValueError:
try:
goaddr = int(a[2:],16) #try to convert hex
DEBUG = DEBUG + 1
elif o in ("-u", "--upload"):
try:
startaddr = int(a) #try to convert decimal
except ValueError:
try:
startaddr = int(a,16) #try to convert hex
except ValueError:
sys.stderr.write("upload address must be a valid number\n")
sys.exit(2)
elif o in ("-s", "--size"):
try:
size = int(a)
size = int(a)
except ValueError:
try:
size = int(a,16)
except ValueError:
sys.stderr.write("size must be a valid number\n")
sys.exit(2)
todo = todo_actionReadBSLVersion = 1
elif o in ("-S", "--speed"):
try:
speed = int(a) #try to convert decimal
except ValueError:
sys.stderr.write("speed must be decimal number\n")
sys.exit(2)
src/p/o/pony-build-HEAD/examples/push-cgi-notifier/feedparser.py pony-build(Download)
text = '&#%s;' % ref
else:
if ref[0] == 'x':
c = int(ref[1:], 16)
else:
c = int(ref)
text = unichr(c).encode('utf-8')
def name2cp(k):
import htmlentitydefs
if hasattr(htmlentitydefs, 'name2codepoint'): # requires Python 2.3
return htmlentitydefs.name2codepoint[k]
k = htmlentitydefs.entitydefs[k]
if k.startswith('&#') and k.endswith(';'):
return int(k[2:-1]) # not in latin-1
def _end_width(self):
value = self.pop('width')
try:
value = int(value)
except:
value = 0
if self.inimage:
def _end_height(self):
value = self.pop('height')
try:
value = int(value)
except:
value = 0
if self.inimage:
value = self.pop('itunes_explicit', 0)
self._getContext()['itunes_explicit'] = (value == 'yes') and 1 or 0
if _XML_AVAILABLE:
class _StrictFeedParser(_FeedParserMixin, xml.sax.handler.ContentHandler):
def __init__(self, baseuri, baselang, encoding):
if _debug: sys.stderr.write('trying StrictFeedParser\n')
def _sanitizeHTML(htmlSource, encoding):
p = _HTMLSanitizer(encoding)
p.feed(htmlSource)
data = p.output()
if TIDY_MARKUP:
# loop through list of preferred Tidy interfaces looking for one that's installed,
# then set up a common _tidy function to wrap the interface-specific API.
params = m.groupdict()
ordinal = params.get('ordinal', 0)
if ordinal:
ordinal = int(ordinal)
else:
ordinal = 0
year = params.get('year', '--')
if not year or year == '--':
year = time.gmtime()[0]
elif len(year) == 2:
# ISO 8601 assumes current century, i.e. 93 -> 2093, NOT 1993
year = 100 * int(time.gmtime()[0] / 100) + int(year)
else:
year = int(year)
month = 1
else:
month = time.gmtime()[1]
month = int(month)
day = params.get('day', 0)
if not day:
# see above
else:
day = time.gmtime()[2]
else:
day = int(day)
# special case of the century - is the first year of the 21st century
# 2000 or 2001 ? The debate goes on...
if 'century' in params.keys():
year = (int(params['century']) - 1) * 100 + 1
# in ISO 8601 most fields are optional
for field in ['hour', 'minute', 'second', 'tzhour', 'tzmin']:
if not params.get(field, None):
params[field] = 0
hour = int(params.get('hour', 0))
minute = int(params.get('minute', 0))
params[field] = 0
hour = int(params.get('hour', 0))
minute = int(params.get('minute', 0))
second = int(params.get('second', 0))
# weekday is normalized by mktime(), we can ignore it
weekday = 0
# daylight savings is complex, but not needed for feedparser's purposes
tz = params.get('tz')
if tz and tz != 'Z':
if tz[0] == '-':
tm[3] += int(params.get('tzhour', 0))
tm[4] += int(params.get('tzmin', 0))
elif tz[0] == '+':
tm[3] -= int(params.get('tzhour', 0))
tm[4] -= int(params.get('tzmin', 0))
def _parse_date_nate(dateString):
'''Parse a string according to the Nate 8-bit date format'''
m = _korean_nate_date_re.match(dateString)
if not m: return
hour = int(m.group(5))
ampm = m.group(4)
if (ampm == _korean_pm):
def __extract_date(m):
year = int(m.group('year'))
if year < 100:
year = 100 * int(time.gmtime()[0] / 100) + int(year)
if year < 1000:
return 0, 0, 0
julian = m.group('julian')
if julian:
julian = int(julian)
if month is None:
month = 1
else:
month = int(month)
day = m.group('day')
if day:
day = int(day)
def __extract_time(m):
if not m:
return 0, 0, 0
hours = m.group('hours')
if not hours:
return 0, 0, 0
hours = int(hours)
minutes = int(m.group('minutes'))
seconds = m.group('seconds')
if seconds:
seconds = int(seconds)
return 0
if tzd == 'Z':
return 0
hours = int(m.group('tzdhours'))
minutes = m.group('tzdminutes')
if minutes:
minutes = int(minutes)
def parse(url_file_stream_or_string, etag=None, modified=None, agent=None, referrer=None, handlers=[]):
'''Parse a feed from a URL, file, stream, or string'''
result = FeedParserDict()
result['feed'] = FeedParserDict()
result['entries'] = []
if _XML_AVAILABLE:
result['bozo'] = 0
(result['encoding'], proposed_encoding))
result['encoding'] = proposed_encoding
if not _XML_AVAILABLE:
use_strict_parser = 0
if use_strict_parser:
# initialize the SAX parser
src/b/a/badger-lib-HEAD/packages/pyparsing/docs/examples/sexpParser.py badger-lib(Download)
# define punctuation literals
LPAR, RPAR, LBRK, RBRK, LBRC, RBRC, VBAR = map(Suppress, "()[]{}|")
decimal = Word("123456789",nums).setParseAction(lambda t: int(t[0]))
bytes = Word(printables)
raw = Group(decimal.setResultsName("len") + Suppress(":") + bytes).setParseAction(verifyLen)
token = Word(alphanums + "-./_:*+=")
base64_ = Group(Optional(decimal,default=None).setResultsName("len") + VBAR
+ OneOrMore(Word( alphanums +"+/=" )).setParseAction(lambda t: b64decode("".join(t)))
+ VBAR).setParseAction(verifyLen)
hexadecimal = ("#" + OneOrMore(Word(hexnums)) + "#")\
.setParseAction(lambda t: int("".join(t[1:-1]),16))
src/r/e/reporter-lib-HEAD/packages/pyparsing/docs/examples/sexpParser.py reporter-lib(Download)
# define punctuation literals
LPAR, RPAR, LBRK, RBRK, LBRC, RBRC, VBAR = map(Suppress, "()[]{}|")
decimal = Word("123456789",nums).setParseAction(lambda t: int(t[0]))
bytes = Word(printables)
raw = Group(decimal.setResultsName("len") + Suppress(":") + bytes).setParseAction(verifyLen)
token = Word(alphanums + "-./_:*+=")
base64_ = Group(Optional(decimal,default=None).setResultsName("len") + VBAR
+ OneOrMore(Word( alphanums +"+/=" )).setParseAction(lambda t: b64decode("".join(t)))
+ VBAR).setParseAction(verifyLen)
hexadecimal = ("#" + OneOrMore(Word(hexnums)) + "#")\
.setParseAction(lambda t: int("".join(t[1:-1]),16))
src/b/a/badger-lib-HEAD/packages/pyparsing/examples/sexpParser.py badger-lib(Download)
# define punctuation literals
LPAR, RPAR, LBRK, RBRK, LBRC, RBRC, VBAR = map(Suppress, "()[]{}|")
decimal = Word("123456789",nums).setParseAction(lambda t: int(t[0]))
bytes = Word(printables)
raw = Group(decimal.setResultsName("len") + Suppress(":") + bytes).setParseAction(verifyLen)
token = Word(alphanums + "-./_:*+=")
base64_ = Group(Optional(decimal,default=None).setResultsName("len") + VBAR
+ OneOrMore(Word( alphanums +"+/=" )).setParseAction(lambda t: b64decode("".join(t)))
+ VBAR).setParseAction(verifyLen)
hexadecimal = ("#" + OneOrMore(Word(hexnums)) + "#")\
.setParseAction(lambda t: int("".join(t[1:-1]),16))
src/r/e/reporter-lib-HEAD/packages/pyparsing/examples/sexpParser.py reporter-lib(Download)
# define punctuation literals
LPAR, RPAR, LBRK, RBRK, LBRC, RBRC, VBAR = map(Suppress, "()[]{}|")
decimal = Word("123456789",nums).setParseAction(lambda t: int(t[0]))
bytes = Word(printables)
raw = Group(decimal.setResultsName("len") + Suppress(":") + bytes).setParseAction(verifyLen)
token = Word(alphanums + "-./_:*+=")
base64_ = Group(Optional(decimal,default=None).setResultsName("len") + VBAR
+ OneOrMore(Word( alphanums +"+/=" )).setParseAction(lambda t: b64decode("".join(t)))
+ VBAR).setParseAction(verifyLen)
hexadecimal = ("#" + OneOrMore(Word(hexnums)) + "#")\
.setParseAction(lambda t: int("".join(t[1:-1]),16))
src/p/r/processing.py-HEAD/examples.py/Python/colornames/namethatcolor/NameThatColor.py processing.py(Download)
def rgb(self, color):
"""Given a hex string representing a color, return an object with
values representing red, green, and blue.
"""
return RGB(int(color[1:3], 16),
int(color[3:5], 16),
int(color[5:7], 16))
hue += (4 + (red - green) / delta)
hue /= 6
return HSL(int(hue * 255),
int(saturation * 255),
int(lightness * 255))
src/p/y/PyAMF-HEAD/doc/tutorials/examples/actionscript/google_appengine/simplejson/decoder.py PyAMF(Download)
try:
if len(esc) != 4:
raise ValueError
uni = int(esc, 16)
if 0xd800 <= uni <= 0xdbff and sys.maxunicode > 65535:
msg = "Invalid \\uXXXX\\uXXXX surrogate pair"
if not s[end + 5:end + 7] == '\\u':
raise ValueError
esc2 = s[end + 7:end + 11]
if len(esc2) != 4:
raise ValueError
uni2 = int(esc2, 16)
src/p/l/plplot-HEAD/trunk/examples/python/xw23.py plplot(Download)
deltay = 1./float(nycells[page])
plbox("bcg", deltax, 0, "bcg", deltay, 0)
plcol0(15)
length = int(hi[page],16) - int(lo[page],16)
slice = 0
for y in (0.5+arange(nycells[page]-1,-1,-1))*deltay:
for x in (0.5+arange(nxcells[page]))*deltax:
CommandString = "#[" + str(Type1\ [offset[page]+slice]) + "]" elif page >= 4: CommandString = "#[" + hex(int(lo[page],16)+slice) + "]" plptex(x,y+yoffset,1.,0.,0.5, CommandString) plptex(x,y-yoffset,1.,0.,0.5, "#" +CommandString) slice += 1
elif(page == 15):
plmtex("t", 1.5, 0.5, 0.5,"#<0x10>PLplot Example 23 - Set Font with ##<FCI COMMAND STRING/> constructs")
plschr(0., 0.75)
for i in range(0,FCI_COMBINATIONS):
family_index = i % 5
style_index = (i/5) % 3
weight_index = ((i/5)/3) % 2
src/n/o/notmm-0.4.1/examples/lib/satchmo_utils/unique_id.py notmm(Download)
# Every try must return at least _ID_MIN_LENGTH chars to succeed and is truncated
# to _ID_MAX_LENGTH. All IDs are lowercased.
id = _alnum(email.split('@')[0])
if len(id) >= _ID_MIN_LENGTH:
yield id[:_ID_MAX_LENGTH]
id = _alnum(unicodedata.normalize('NFKD', first_name + last_name).encode('ascii', 'ignore'))
if len(id) >= _ID_MIN_LENGTH:
yield id[:_ID_MAX_LENGTH]
id = _alnum(email, glue='_')
if len(id) >= _ID_MIN_LENGTH:
yield id[:_ID_MAX_LENGTH]
while True:
yield _alnum('%s_%s' % (id[:_ID_MIN_LENGTH], random_string(_ID_MIN_LENGTH, True)))[:_ID_MAX_LENGTH]
#decimal character reference
if decimal:
try:
s = re.sub('&#(\d+);', lambda m: unichr(int(m.group(1))), s)
except:
pass
#hexadecimal character reference
if hexadecimal:
try:
s = re.sub('&#x([\da-fA-F]+);', lambda m: unichr(int(m.group(1), 16)), s)
1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 Next