SF.net SVN: geany: [2677] trunk

Tue Jun 10 16:39:24 UTC 2008

Revision: 2677
          http://geany.svn.sourceforge.net/geany/?rev=2677&view=rev
Author:   eht16
Date:     2008-06-10 09:39:17 -0700 (Tue, 10 Jun 2008)

Log Message:
-----------
Add create_py_tags.py to create a global tags file for Python (thanks to Dominic Hopf).
Add generated Python tags file (Python 2.5).

Modified Paths:
--------------
    trunk/ChangeLog
    trunk/Makefile.am
    trunk/src/symbols.c

Added Paths:
-----------
    trunk/data/python.tags
    trunk/scripts/create_py_tags.py

Modified: trunk/ChangeLog
===================================================================

--- trunk/ChangeLog	2008-06-10 16:18:08 UTC (rev 2676)
+++ trunk/ChangeLog	2008-06-10 16:39:17 UTC (rev 2677)
@@ -6,6 +6,11 @@
  * tagmanager/python.c:
    Fix endless loop when there are two triple strings on one line
    inside a multiline string.
+ * Makefile.am, data/python.tags, scripts/create_py_tags.py,
+   src/symbols.c:
+   Add create_py_tags.py to create a global tags file for Python
+   (thanks to Dominic Hopf).
+   Add generated Python tags file (Python 2.5).
 
 
 2008-06-10  Nick Treleaven  <nick(dot)treleaven(at)btinternet(dot)com>

Modified: trunk/Makefile.am
===================================================================
--- trunk/Makefile.am	2008-06-10 16:18:08 UTC (rev 2676)
+++ trunk/Makefile.am	2008-06-10 16:39:17 UTC (rev 2677)
@@ -13,6 +13,7 @@
 SYS_DATA_FILES = \
 	data/global.tags \
 	data/php.tags \
+	data/python.tags \
 	data/latex.tags \
 	data/pascal.tags \
 	data/html_entities.tags \
@@ -58,6 +59,7 @@
 	$(mkinstalldirs) $(DESTDIR)$(pkgdatadir); \
 	$(INSTALL_DATA) $(srcdir)/data/global.tags $(DESTDIR)$(pkgdatadir); \
 	$(INSTALL_DATA) $(srcdir)/data/php.tags $(DESTDIR)$(pkgdatadir); \
+	$(INSTALL_DATA) $(srcdir)/data/python.tags $(DESTDIR)$(pkgdatadir); \
 	$(INSTALL_DATA) $(srcdir)/data/pascal.tags $(DESTDIR)$(pkgdatadir); \
 	$(INSTALL_DATA) $(srcdir)/data/latex.tags $(DESTDIR)$(pkgdatadir); \
 	$(INSTALL_DATA) $(srcdir)/data/html_entities.tags $(DESTDIR)$(pkgdatadir); \

Added: trunk/data/python.tags
===================================================================
--- trunk/data/python.tags	                        (rev 0)
+++ trunk/data/python.tags	2008-06-10 16:39:17 UTC (rev 2677)
@@ -0,0 +1,2599 @@
+# Automatically generated file - do not edit (created on Tue Jun 10 18:27:52 2008)
+AbstractHTTPHandler\xCC1\xCD(BaseHandler)
+AbstractWriter\xCC1\xCD(NullWriter)
+AddPackagePath\xCC128\xCD(packagename, path)
+AddressList\xCC1\xCD(AddrlistClass)
+AmbiguousOptionError\xCC1\xCD(BadOptionError)
+ArgumentDescriptor\xCC1\xCD(object)
+AudioDev\xCC128\xCD()
+BabylMailbox\xCC1\xCD(_Mailbox)
+BabylMessage\xCC1\xCD(Message)
+Babyl\xCC1\xCD(_singlefileMailbox)
+BackgroundBrowser\xCC1\xCD(GenericBrowser)
+BadOptionError\xCC1\xCD(OptParseError)
+BadStatusLine\xCC1\xCD(HTTPException)
+BadZipfile\xCC1\xCD(Exception)
+BaseBrowser\xCC1\xCD(object)
+BaseCookie\xCC1\xCD(dict)
+BaseHTTPRequestHandler\xCC1\xCD(SocketServer.StreamRequestHandler)
+BaseResult\xCC1\xCD(tuple)
+BaseSet\xCC1\xCD(object)
+BasicModuleImporter\xCC1\xCD(_Verbose)
+BasicModuleLoader\xCC1\xCD(_Verbose)
+BdbQuit\xCC1\xCD(Exception)
+BoundedQueue\xCC1\xCD(_Verbose)
+BoundedSemaphore\xCC128\xCD(*args, **kwargs)
+BsdDbShelf\xCC1\xCD(Shelf)
+BufferedIncrementalDecoder\xCC1\xCD(IncrementalDecoder)
+BufferedIncrementalEncoder\xCC1\xCD(IncrementalEncoder)
+BuiltinImporter\xCC1\xCD(Importer)
+CGIHTTPRequestHandler\xCC1\xCD(SimpleHTTPServer.SimpleHTTPRequestHandler)
+CGIXMLRPCRequestHandler\xCC1\xCD(SimpleXMLRPCDispatcher)
+CacheFTPHandler\xCC1\xCD(FTPHandler)
+Calendar\xCC1\xCD(object)
+CalledProcessError\xCC1\xCD(Exception)
+CannotSendHeader\xCC1\xCD(ImproperConnectionState)
+CannotSendRequest\xCC1\xCD(ImproperConnectionState)
+Clamped\xCC1\xCD(DecimalException)
+Class\xCC1\xCD(SymbolTable)
+CodecInfo\xCC1\xCD(tuple)
+CompressionError\xCC1\xCD(TarError)
+Condition\xCC128\xCD(*args, **kwargs)
+ConfigParser\xCC1\xCD(RawConfigParser)
+ConsumerThread\xCC1\xCD(Thread)
+ContentTooShortError\xCC1\xCD(IOError)
+Context\xCC1\xCD(object)
+ConversionError\xCC1\xCD(Error)
+ConversionSyntax\xCC1\xCD(InvalidOperation)
+CookieError\xCC1\xCD(Exception)
+DatagramRequestHandler\xCC1\xCD(BaseRequestHandler)
+DbfilenameShelf\xCC1\xCD(Shelf)
+DebuggingServer\xCC1\xCD(SMTPServer)
+DecimalException\xCC1\xCD(ArithmeticError)
+Decimal\xCC1\xCD(object)
+DefaultCookiePolicy\xCC1\xCD(CookiePolicy)
+Dict\xCC1\xCD(_InternalDict)
+DivisionByZero\xCC1\xCD(DecimalException, ZeroDivisionError)
+DivisionImpossible\xCC1\xCD(InvalidOperation)
+DivisionUndefined\xCC1\xCD(InvalidOperation, ZeroDivisionError)
+DocHandler\xCC1\xCD(BaseHTTPServer.BaseHTTPRequestHandler)
+DocServer\xCC1\xCD(BaseHTTPServer.HTTPServer)
+DocXMLRPCRequestHandler\xCC1\xCD(SimpleXMLRPCRequestHandler)
+DumbWriter\xCC1\xCD(NullWriter)
+DuplicateSectionError\xCC1\xCD(Error)
+Elinks\xCC1\xCD(UnixBrowser)
+Empty\xCC1\xCD(Exception)
+EncodedFile\xCC128\xCD(file, data_encoding, file_encoding=None, errors='strict')
+EndOfBlock\xCC1\xCD(Exception)
+ErrorDuringImport\xCC1\xCD(Exception)
+Error\xCC1\xCD(Exception)
+Etiny\xCC128\xCD(self)
+Etop\xCC128\xCD(self)
+Event\xCC128\xCD(*args, **kwargs)
+ExFileObject\xCC1\xCD(object)
+ExitNow\xCC1\xCD(Exception)
+ExternalClashError\xCC1\xCD(Error)
+ExtractError\xCC1\xCD(TarError)
+FTPHandler\xCC1\xCD(BaseHandler)
+FakeSocket\xCC1\xCD(SharedSocketClient)
+FancyModuleLoader\xCC1\xCD(ModuleLoader)
+FancyURLopener\xCC1\xCD(URLopener)
+FileCookieJar\xCC1\xCD(CookieJar)
+FileDelegate\xCC1\xCD(FileBase)
+FileHandler\xCC1\xCD(BaseHandler)
+FileHeader\xCC128\xCD(self)
+FileWrapper\xCC1\xCD(FileBase)
+ForkingTCPServer\xCC1\xCD(ForkingMixIn, TCPServer)
+ForkingUDPServer\xCC1\xCD(ForkingMixIn, UDPServer)
+FormContentDict\xCC1\xCD(UserDict.UserDict)
+FormContent\xCC1\xCD(FormContentDict)
+FormatError\xCC1\xCD(Error)
+Full\xCC1\xCD(Exception)
+FunctionTestCase\xCC1\xCD(TestCase)
+Function\xCC1\xCD(SymbolTable)
+GNUTranslations\xCC1\xCD(NullTranslations)
+Galeon\xCC1\xCD(UnixBrowser)
+GeneratorContextManager\xCC1\xCD(object)
+GenericBrowser\xCC1\xCD(BaseBrowser)
+GetoptError\xCC1\xCD(Exception)
+GopherError\xCC1\xCD(URLError)
+GopherHandler\xCC1\xCD(BaseHandler)
+Grail\xCC1\xCD(BaseBrowser)
+HTMLCalendar\xCC1\xCD(Calendar)
+HTMLDoc\xCC1\xCD(Doc)
+HTMLParseError\xCC1\xCD(sgmllib.SGMLParseError)
+HTMLParser\xCC1\xCD(sgmllib.SGMLParser)
+HTMLRepr\xCC1\xCD(Repr)
+HTTP11\xCC1\xCD(HTTP)
+HTTPBasicAuthHandler\xCC1\xCD(AbstractBasicAuthHandler, BaseHandler)
+HTTPCookieProcessor\xCC1\xCD(BaseHandler)
+HTTPDefaultErrorHandler\xCC1\xCD(BaseHandler)
+HTTPDigestAuthHandler\xCC1\xCD(BaseHandler, AbstractDigestAuthHandler)
+HTTPErrorProcessor\xCC1\xCD(BaseHandler)
+HTTPError\xCC1\xCD(URLError, addinfourl)
+HTTPException\xCC1\xCD(Exception)
+HTTPHandler\xCC1\xCD(AbstractHTTPHandler)
+HTTPMessage\xCC1\xCD(mimetools.Message)
+HTTPPasswordMgrWithDefaultRealm\xCC1\xCD(HTTPPasswordMgr)
+HTTPRedirectHandler\xCC1\xCD(BaseHandler)
+HTTPSConnection\xCC1\xCD(HTTPConnection)
+HTTPSHandler\xCC1\xCD(AbstractHTTPHandler)
+HTTPServer\xCC1\xCD(SocketServer.TCPServer)
+HTTPS\xCC1\xCD(HTTP)
+Hooks\xCC1\xCD(_Verbose)
+HtmlDiff\xCC1\xCD(object)
+IMAP4_SSL\xCC1\xCD(IMAP4)
+IMAP4_stream\xCC1\xCD(IMAP4)
+ISEOF\xCC128\xCD(x)
+ISNONTERMINAL\xCC128\xCD(x)
+ISTERMINAL\xCC128\xCD(x)
+IS_CHARACTER_JUNK\xCC128\xCD(ch, ws=" \t")
+IS_LINE_JUNK\xCC128\xCD(line, pat=re.compile(r"\s*#?\s*$").match)
+IllegalMonthError\xCC1\xCD(ValueError)
+IllegalWeekdayError\xCC1\xCD(ValueError)
+ImmutableSet\xCC1\xCD(BaseSet)
+ImproperConnectionState\xCC1\xCD(HTTPException)
+IncompleteRead\xCC1\xCD(HTTPException)
+IncrementalDecoder\xCC1\xCD(object)
+IncrementalEncoder\xCC1\xCD(object)
+IndentedHelpFormatter\xCC1\xCD(HelpFormatter)
+Inexact\xCC1\xCD(DecimalException)
+Int2AP\xCC128\xCD(num)
+IntegerArithmenticTestCase\xCC1\xCD(unittest.TestCase)
+InteractiveConsole\xCC1\xCD(InteractiveInterpreter)
+Internaldate2tuple\xCC128\xCD(resp)
+InternetConfig\xCC1\xCD(BaseBrowser)
+InterpFormContentDict\xCC1\xCD(SvFormContentDict)
+InterpolationDepthError\xCC1\xCD(InterpolationError)
+InterpolationError\xCC1\xCD(Error)
+InterpolationMissingOptionError\xCC1\xCD(InterpolationError)
+InterpolationSyntaxError\xCC1\xCD(InterpolationError)
+InvalidContext\xCC1\xCD(InvalidOperation)
+InvalidOperation\xCC1\xCD(DecimalException)
+InvalidURL\xCC1\xCD(HTTPException)
+IterableUserDict\xCC1\xCD(UserDict)
+KeyedRef\xCC1\xCD(ref)
+Konqueror\xCC1\xCD(BaseBrowser)
+LOWU32\xCC128\xCD(i)
+LargeZipFile\xCC1\xCD(Exception)
+LoadError\xCC1\xCD(IOError)
+LocaleHTMLCalendar\xCC1\xCD(HTMLCalendar)
+LocaleTextCalendar\xCC1\xCD(TextCalendar)
+LocaleTime\xCC1\xCD(object)
+MHMessage\xCC1\xCD(Message)
+MMDFMessage\xCC1\xCD(_mboxMMDFMessage)
+MMDF\xCC1\xCD(_mboxMMDF)
+MacOSX\xCC1\xCD(BaseBrowser)
+MaildirMessage\xCC1\xCD(Message)
+Maildir\xCC1\xCD(Mailbox)
+MailmanProxy\xCC1\xCD(PureProxy)
+MathServer\xCC1\xCD(SimpleXMLRPCServer)
+Message\xCC1\xCD(email.Message.Message)
+MissingSectionHeaderError\xCC1\xCD(ParsingError)
+MmdfMailbox\xCC1\xCD(_Mailbox)
+MockThreading\xCC1\xCD(object)
+ModuleImporter\xCC1\xCD(BasicModuleImporter)
+ModuleLoader\xCC1\xCD(BasicModuleLoader)
+Morsel\xCC1\xCD(dict)
+Mozilla\xCC1\xCD(UnixBrowser)
+MutableString\xCC1\xCD(UserString)
+NNTPDataError\xCC1\xCD(NNTPError)
+NNTPError\xCC1\xCD(Exception)
+NNTPPermanentError\xCC1\xCD(NNTPError)
+NNTPProtocolError\xCC1\xCD(NNTPError)
+NNTPReplyError\xCC1\xCD(NNTPError)
+NNTPTemporaryError\xCC1\xCD(NNTPError)
+NannyNag\xCC1\xCD(Exception)
+NetrcParseError\xCC1\xCD(Exception)
+NoOptionError\xCC1\xCD(Error)
+NoSectionError\xCC1\xCD(Error)
+NoSuchMailboxError\xCC1\xCD(Error)
+NotANumber\xCC1\xCD(ValueError)
+NotConnected\xCC1\xCD(HTTPException)
+NotEmptyError\xCC1\xCD(Error)
+OpcodeInfo\xCC1\xCD(object)
+Opera\xCC1\xCD(UnixBrowser)
+OptParseError\xCC1\xCD(Exception)
+OptionConflictError\xCC1\xCD(OptionError)
+OptionError\xCC1\xCD(OptParseError)
+OptionGroup\xCC1\xCD(OptionContainer)
+OptionParser\xCC1\xCD(OptionContainer)
+OptionValueError\xCC1\xCD(OptParseError)
+OutputString\xCC128\xCD(self, attrs=None)
+Overflow\xCC1\xCD(Inexact, Rounded)
+POP3_SSL\xCC1\xCD(POP3)
+ParseFlags\xCC128\xCD(resp)
+ParseResult\xCC1\xCD(BaseResult)
+ParsingError\xCC1\xCD(Error)
+PickleError\xCC1\xCD(Exception)
+PicklingError\xCC1\xCD(PickleError)
+PlistWriter\xCC1\xCD(DumbXMLWriter)
+Plist\xCC1\xCD(_InternalDict)
+Popen4\xCC1\xCD(Popen3)
+Popen\xCC1\xCD(object)
+PortableUnixMailbox\xCC1\xCD(UnixMailbox)
+ProducerThread\xCC1\xCD(Thread)
+Profile\xCC1\xCD(_lsprof.Profiler)
+ProxyBasicAuthHandler\xCC1\xCD(AbstractBasicAuthHandler, BaseHandler)
+ProxyDigestAuthHandler\xCC1\xCD(BaseHandler, AbstractDigestAuthHandler)
+ProxyHandler\xCC1\xCD(BaseHandler)
+PureProxy\xCC1\xCD(SMTPServer)
+PyCompileError\xCC1\xCD(Exception)
+PyZipFile\xCC1\xCD(ZipFile)
+Quitter\xCC1\xCD(object)
+RExec\xCC1\xCD(ihooks._Verbose)
+RHooks\xCC1\xCD(ihooks.Hooks)
+RLock\xCC128\xCD(*args, **kwargs)
+Random\xCC1\xCD(_random.Random)
+ReadError\xCC1\xCD(TarError)
+ReplacePackage\xCC128\xCD(oldname, newname)
+ResponseNotReady\xCC1\xCD(ImproperConnectionState)
+RestrictedConsole\xCC1\xCD(code.InteractiveConsole)
+Rounded\xCC1\xCD(DecimalException)
+SMTPAuthenticationError\xCC1\xCD(SMTPResponseException)
+SMTPChannel\xCC1\xCD(asynchat.async_chat)
+SMTPConnectError\xCC1\xCD(SMTPResponseException)
+SMTPDataError\xCC1\xCD(SMTPResponseException)
+SMTPException\xCC1\xCD(Exception)
+SMTPHeloError\xCC1\xCD(SMTPResponseException)
+SMTPRecipientsRefused\xCC1\xCD(SMTPException)
+SMTPResponseException\xCC1\xCD(SMTPException)
+SMTPSenderRefused\xCC1\xCD(SMTPResponseException)
+SMTPServerDisconnected\xCC1\xCD(SMTPException)
+SMTPServer\xCC1\xCD(asyncore.dispatcher)
+SSLFile\xCC1\xCD(SharedSocketClient)
+S_IFMT\xCC128\xCD(mode)
+S_IMODE\xCC128\xCD(mode)
+S_ISBLK\xCC128\xCD(mode)
+S_ISCHR\xCC128\xCD(mode)
+S_ISDIR\xCC128\xCD(mode)
+S_ISFIFO\xCC128\xCD(mode)
+S_ISLNK\xCC128\xCD(mode)
+S_ISREG\xCC128\xCD(mode)
+S_ISSOCK\xCC128\xCD(mode)
+SafeConfigParser\xCC1\xCD(ConfigParser)
+Semaphore\xCC128\xCD(*args, **kwargs)
+SerialCookie\xCC1\xCD(BaseCookie)
+ServerHTMLDoc\xCC1\xCD(pydoc.HTMLDoc)
+Shelf\xCC1\xCD(UserDict.DictMixin)
+SimpleCookie\xCC1\xCD(BaseCookie)
+SimpleHTTPRequestHandler\xCC1\xCD(BaseHTTPServer.BaseHTTPRequestHandler)
+SimpleXMLRPCRequestHandler\xCC1\xCD(BaseHTTPServer.BaseHTTPRequestHandler)
+SmartCookie\xCC1\xCD(BaseCookie)
+SplitResult\xCC1\xCD(BaseResult)
+StackObject\xCC1\xCD(object)
+StopTokenizing\xCC1\xCD(Exception)
+StreamError\xCC1\xCD(TarError)
+StreamReader\xCC1\xCD(Codec)
+StreamRequestHandler\xCC1\xCD(BaseRequestHandler)
+StreamWriter\xCC1\xCD(Codec)
+SubMessage\xCC1\xCD(Message)
+Subnormal\xCC1\xCD(DecimalException)
+SvFormContentDict\xCC1\xCD(FormContentDict)
+SystemRandom\xCC1\xCD(Random)
+TCPServer\xCC1\xCD(BaseServer)
+TarError\xCC1\xCD(Exception)
+TarFile\xCC1\xCD(object)
+TarInfo\xCC1\xCD(object)
+TextCalendar\xCC1\xCD(Calendar)
+TextDoc\xCC1\xCD(Doc)
+TextRepr\xCC1\xCD(Repr)
+ThreadingTCPServer\xCC1\xCD(ThreadingMixIn, TCPServer)
+ThreadingUDPServer\xCC1\xCD(ThreadingMixIn, UDPServer)
+ThreadingUnixDatagramServer\xCC1\xCD(ThreadingMixIn, UnixDatagramServer)
+ThreadingUnixStreamServer\xCC1\xCD(ThreadingMixIn, UnixStreamServer)
+Thread\xCC1\xCD(_Verbose)
+Time2Internaldate\xCC128\xCD(date_time)
+TimeRE\xCC1\xCD(dict)
+Timer\xCC128\xCD(*args, **kwargs)
+TitledHelpFormatter\xCC1\xCD(HelpFormatter)
+TokenError\xCC1\xCD(Exception)
+UDPServer\xCC1\xCD(TCPServer)
+URLError\xCC1\xCD(IOError)
+URLopener\xCC1\xCD(urllib.FancyURLopener)
+UUID\xCC1\xCD(object)
+Underflow\xCC1\xCD(Inexact, Rounded, Subnormal)
+UnimplementedFileMode\xCC1\xCD(HTTPException)
+UnixBrowser\xCC1\xCD(BaseBrowser)
+UnixDatagramServer\xCC1\xCD(UDPServer)
+UnixMailbox\xCC1\xCD(_Mailbox)
+UnixStreamServer\xCC1\xCD(TCPServer)
+UnknownHandler\xCC1\xCD(BaseHandler)
+UnknownProtocol\xCC1\xCD(HTTPException)
+UnknownTransferEncoding\xCC1\xCD(HTTPException)
+UnpicklingError\xCC1\xCD(PickleError)
+WeakKeyDictionary\xCC1\xCD(UserDict.UserDict)
+WeakValueDictionary\xCC1\xCD(UserDict.UserDict)
+WichmannHill\xCC1\xCD(Random)
+WindowsDefault\xCC1\xCD(BaseBrowser)
+ZipInfo\xCC1\xCD(object)
+abort\xCC128\xCD(self)
+abs__file__\xCC128\xCD()
+abspath\xCC128\xCD(path)
+accept\xCC128\xCD(self)
+acct\xCC128\xCD(self, password)
+acquire\xCC128\xCD(self, blocking=1)
+activeCount\xCC128\xCD()
+addError\xCC128\xCD(self, test, err)
+addFailure\xCC128\xCD(self, test, err)
+addObject\xCC128\xCD(self, value)
+addSuccess\xCC128\xCD(self, test)
+addTests\xCC128\xCD(self, tests)
+addTest\xCC128\xCD(self, test)
+addToZip\xCC128\xCD(zf, path, zippath)
+add_channel\xCC128\xCD(self, map=None)
+add_cookie_header\xCC128\xCD(self, request)
+add_data\xCC128\xCD(self, data)
+add_extension\xCC128\xCD(module, name, code)
+add_fallback\xCC128\xCD(self, fallback)
+add_flag\xCC128\xCD(self, flag)
+add_flowing_data\xCC128\xCD(self, data)
+add_folder\xCC128\xCD(self, folder)
+add_handler\xCC128\xCD(self, handler)
+add_header\xCC128\xCD(self, key, val)
+add_hor_rule\xCC128\xCD(self, *args, **kw)
+add_label_data\xCC128\xCD(self, format, counter, blankline=None)
+add_label\xCC128\xCD(self, label)
+add_line_break\xCC128\xCD(self)
+add_literal_data\xCC128\xCD(self, data)
+add_module\xCC128\xCD(self, name)
+add_option_group\xCC128\xCD(self, *args, **kwargs)
+add_options\xCC128\xCD(self, option_list)
+add_option\xCC128\xCD(self, *args, **kwargs)
+add_parent\xCC128\xCD(self, parent)
+add_password\xCC128\xCD(self, realm, uri, user, passwd)
+add_section\xCC128\xCD(self, section)
+add_sequence\xCC128\xCD(self, sequence)
+add_suffix\xCC128\xCD(self, suffix, importFunc)
+add_type\xCC128\xCD(self, type, ext, strict=True)
+add_unredirected_header\xCC128\xCD(self, key, val)
+addclosehook\xCC1\xCD(addbase)
+addcontinue\xCC128\xCD(self, key, more)
+addfile\xCC128\xCD(self, tarinfo, fileobj=None)
+addheader\xCC128\xCD(self, key, value)
+addinfourl\xCC1\xCD(addbase)
+addinfo\xCC1\xCD(addbase)
+addpackage\xCC128\xCD(sitedir, name, known_paths)
+addpair\xCC128\xCD(self, xlo, xhi)
+address_string\xCC128\xCD(self)
+addsitedir\xCC128\xCD(sitedir, known_paths=None)
+addsitepackages\xCC128\xCD(known_paths)
+adjusted\xCC128\xCD(self)
+aliasmbcs\xCC128\xCD()
+allmethods\xCC128\xCD(cl)
+allowance\xCC128\xCD(self, filename)
+allowed_domains\xCC128\xCD(self)
+anchor_bgn\xCC128\xCD(self, href, name, type)
+anchor_end\xCC128\xCD(self)
+annotate\xCC128\xCD(head, list)
+any_missing_maybe\xCC128\xCD(self)
+any_missing\xCC128\xCD(self)
+apop\xCC128\xCD(self, user, secret)
+append\xCC128\xCD(self, lineno, line)
+applies_to\xCC128\xCD(self, filename)
+apropos\xCC128\xCD(key)
+architecture\xCC128\xCD(executable=sys.executable,bits='',linkage='')
+artcmd\xCC128\xCD(self, line, file=None)
+article\xCC128\xCD(self, id)
+asBase64\xCC128\xCD(self, maxlinelength=76)
+as_tuple\xCC128\xCD(self)
+assert_line_data\xCC128\xCD(self, flag=1)
+assure_pickle_consistency\xCC128\xCD(verbose=False)
+async_chat\xCC1\xCD(asyncore.dispatcher)
+atof\xCC128\xCD(string, func=float)
+atoi\xCC128\xCD(str)
+atol\xCC128\xCD(*args)
+attr_matches\xCC128\xCD(self, text)
+authenticate\xCC128\xCD(self, mechanism, authobject)
+authenticators\xCC128\xCD(self, host)
+b16decode\xCC128\xCD(s, casefold=False)
+b16encode\xCC128\xCD(s)
+b32decode\xCC128\xCD(s, casefold=False, map01=None)
+b32encode\xCC128\xCD(s)
+b64decode\xCC128\xCD(s, altchars=None)
+b64encode\xCC128\xCD(s, altchars=None)
+basename\xCC128\xCD(p)
+beginElement\xCC128\xCD(self, element)
+begin_array\xCC128\xCD(self, attrs)
+begin_dict\xCC128\xCD(self, attrs)
+begin\xCC128\xCD(self)
+betavariate\xCC128\xCD(self, alpha, beta)
+bigsection\xCC128\xCD(self, title, *args)
+bind_textdomain_codeset\xCC128\xCD(domain, codeset=None)
+bindtextdomain\xCC128\xCD(domain, localedir=None)
+bind\xCC128\xCD(self, addr)
+binhex\xCC128\xCD(inp, out)
+bisect_left\xCC128\xCD(a, x, lo=0, hi=None)
+bisect_right\xCC128\xCD(a, x, lo=0, hi=None)
+blocked_domains\xCC128\xCD(self)
+bltinlink\xCC128\xCD(name)
+body\xCC128\xCD(self, id, file=None)
+bold\xCC128\xCD(self, text)
+bp_commands\xCC128\xCD(self,frame)
+bpprint\xCC128\xCD(self, out=None)
+break_anywhere\xCC128\xCD(self, frame)
+break_here\xCC128\xCD(self, frame)
+build_opener\xCC128\xCD(*handlers)
+bz2open\xCC128\xCD(cls, name, mode="r", fileobj=None, compresslevel=9)
+c2py\xCC128\xCD(plural)
+calc_chksums\xCC128\xCD(buf)
+calcsize\xCC128\xCD(fmt)
+callback\xCC128\xCD(path, modname, desc, modules=modules)
+call\xCC128\xCD(*popenargs, **kwargs)
+can_fetch\xCC128\xCD(self, useragent, url)
+cancel\xCC128\xCD(self, event)
+canonical\xCC128\xCD(self, context=None)
+canonic\xCC128\xCD(self, filename)
+capability\xCC128\xCD(self)
+capitalize\xCC128\xCD(s)
+capwords\xCC128\xCD(s, sep=None)
+center\xCC128\xCD(s, width)
+charset\xCC128\xCD(self)
+check_builtin\xCC128\xCD(option, opt, value)
+check_cache\xCC128\xCD(self)
+check_call\xCC128\xCD(*popenargs, **kwargs)
+check_choice\xCC128\xCD(option, opt, value)
+check_for_whole_start_tag\xCC128\xCD(self, i)
+check_values\xCC128\xCD(self, values, args)
+check_value\xCC128\xCD(self, opt, value)
+checkcache\xCC128\xCD(filename=None)
+checkfuncname\xCC128\xCD(b, frame)
+checkline\xCC128\xCD(self, filename, lineno)
+check\xCC128\xCD(self)
+chmod\xCC128\xCD(self, tarinfo, targetpath)
+choice\xCC128\xCD(self, seq)
+choose_boundary\xCC128\xCD()
+chown\xCC128\xCD(self, tarinfo, targetpath)
+classify_class_attrs\xCC128\xCD(cls)
+classlink\xCC128\xCD(self, object, modname)
+classname\xCC128\xCD(object, modname)
+cleanup\xCC128\xCD(self)
+clean\xCC128\xCD(self)
+clear_all_breaks\xCC128\xCD(self)
+clear_all_file_breaks\xCC128\xCD(self, filename)
+clear_bpbynumber\xCC128\xCD(self, arg)
+clear_break\xCC128\xCD(self, filename, lineno)
+clear_cache\xCC128\xCD()
+clear_cdata_mode\xCC128\xCD(self)
+clear_expired_cookies\xCC128\xCD(self)
+clear_extension_cache\xCC128\xCD()
+clear_flags\xCC128\xCD(self)
+clear_memo\xCC128\xCD(self)
+clear_session_cookies\xCC128\xCD(self)
+clearcache\xCC128\xCD()
+clear\xCC128\xCD(self, domain=None, path=None, name=None)
+clone\xCC128\xCD(self)
+close_all\xCC128\xCD(map=None)
+close_data\xCC128\xCD(self)
+close_request\xCC128\xCD(self, request)
+close_when_done\xCC128\xCD(self)
+close\xCC128\xCD(self)
+closing\xCC1\xCD(object)
+cmdloop\xCC128\xCD(self, intro=None)
+cmpfiles\xCC128\xCD(a, b, common, shallow=1)
+collapse\xCC128\xCD(self)
+collect_children\xCC128\xCD(self)
+collect_incoming_data\xCC128\xCD(self, data)
+columnize\xCC128\xCD(self, list, displaywidth=80)
+commonprefix\xCC128\xCD(m)
+communicate\xCC128\xCD(self, input=None)
+compact_traceback\xCC128\xCD()
+compare_signal\xCC128\xCD(self, other, context=None)
+compare_total_mag\xCC128\xCD(self, other)
+compare_total\xCC128\xCD(self, other)
+compare\xCC128\xCD(self, other, context=None)
+compile_command\xCC128\xCD(source, filename="<input>", symbol="single")
+compile_path\xCC128\xCD(skip_curdir=1, maxlevels=0, force=0, quiet=0)
+compile\xCC128\xCD(file, cfile=None, dfile=None, doraise=False)
+complete_help\xCC128\xCD(self, *args)
+completedefault\xCC128\xCD(self, *ignored)
+completenames\xCC128\xCD(self, text, *ignored)
+complete\xCC128\xCD(self, text, state)
+connect_ftp\xCC128\xCD(self, user, passwd, host, port, dirs)
+connect\xCC128\xCD(self, address)
+constructor\xCC128\xCD(object)
+contains\xCC128\xCD(self, x)
+contextmanager\xCC128\xCD(func)
+convert_value\xCC128\xCD(self, opt, value)
+convert\xCC128\xCD(mo)
+copy2\xCC128\xCD(src, dst)
+copy_abs\xCC128\xCD(self)
+copy_decimal\xCC128\xCD(self, a)
+copy_except\xCC128\xCD(self, src, exceptions)
+copy_negate\xCC128\xCD(self)
+copy_none\xCC128\xCD(self, src)
+copy_only\xCC128\xCD(self, src, names)
+copy_sign\xCC128\xCD(self, other)
+copybinary\xCC128\xCD(input, output)
+copyfileobj\xCC128\xCD(fsrc, fdst, length=16*1024)
+copyfile\xCC128\xCD(src, dst)
+copyliteral\xCC128\xCD(input, output)
+copymessage\xCC128\xCD(self, n, tofolder, ton)
+copymode\xCC128\xCD(src, dst)
+copystat\xCC128\xCD(src, dst)
+copytree\xCC128\xCD(src, dst, symlinks=False)
+copy\xCC128\xCD(x)
+countTestCases\xCC128\xCD(self)
+count\xCC128\xCD(s, *args)
+cram\xCC128\xCD(text, maxlen)
+createTests\xCC128\xCD(self)
+create_decimal\xCC128\xCD(self, num='0')
+create_socket\xCC128\xCD(self, family, type)
+create_stats\xCC128\xCD(self)
+createmessage\xCC128\xCD(self, n, txt)
+create\xCC128\xCD(self, mailbox)
+currency\xCC128\xCD(val, symbol=True, grouping=False, international=False)
+currentThread\xCC128\xCD()
+data\xCC128\xCD(self,msg)
+date_time_string\xCC128\xCD(self, timestamp=None)
+date\xCC128\xCD(self)
+ddpop\xCC128\xCD(self, bl=0)
+debug\xCC128\xCD(self, flag)
+decode_long\xCC128\xCD(data)
+decodestring\xCC128\xCD(s)
+decode\xCC128\xCD(input, output)
+decreasing_size\xCC128\xCD(a, b)
+decref\xCC128\xCD(self)
+dedent\xCC128\xCD(self)
+deepcopy\xCC128\xCD(x, memo=None, _nil=[])
+deepvalues\xCC128\xCD(mapping)
+def_op\xCC128\xCD(name, op)
+defaultFile\xCC128\xCD(self)
+defaultTestResult\xCC128\xCD(self)
+default_getpass\xCC128\xCD(prompt='Password: ', stream=None)
+default_path\xCC128\xCD(self)
+defaults\xCC128\xCD(self)
+default\xCC128\xCD(self, line)
+deg_to_rad\xCC128\xCD(deg)
+del_channel\xCC128\xCD(self, map=None)
+deleteMe\xCC128\xCD(self)
+deleteacl\xCC128\xCD(self, mailbox, who)
+deletefolder\xCC128\xCD(self, name)
+delete\xCC128\xCD(self, filename)
+dele\xCC128\xCD(self, which)
+demo\xCC128\xCD()
+deque\xCC1\xCD(list)
+describe\xCC128\xCD(thing)
+descriptions\xCC128\xCD(self, group_pattern)
+description\xCC128\xCD(self, group)
+destinsrc\xCC128\xCD(src, dst)
+destroy\xCC128\xCD(self)
+determine_parent\xCC128\xCD(self, globals)
+dgettext\xCC128\xCD(domain, message)
+dialect\xCC1\xCD(Dialect)
+difference_update\xCC128\xCD(self, other)
+difference\xCC128\xCD(self, other)
+digest\xCC128\xCD(self)
+dirname\xCC128\xCD(p)
+disable_interspersed_args\xCC128\xCD(self)
+disable\xCC128\xCD(self)
+disassemble\xCC128\xCD(co, lasti=-1)
+discard_buffers\xCC128\xCD(self)
+discard\xCC128\xCD(self, key)
+dispatch_call\xCC128\xCD(self, frame, arg)
+dispatch_exception\xCC128\xCD(self, frame, arg)
+dispatch_line\xCC128\xCD(self, frame)
+dispatch_return\xCC128\xCD(self, frame, arg)
+dispatcher_with_send\xCC1\xCD(dispatcher)
+distb\xCC128\xCD(tb=None)
+divide_int\xCC128\xCD(self, a, b)
+divide\xCC128\xCD(self, a, b)
+divmod\xCC128\xCD(self, a, b)
+dngettext\xCC128\xCD(domain, msgid1, msgid2, n)
+do_EOF\xCC128\xCD(self, arg)
+do_GET\xCC128\xCD(self)
+do_HEAD\xCC128\xCD(self)
+do_POST\xCC128\xCD(self)
+do_alias\xCC128\xCD(self, arg)
+do_args\xCC128\xCD(self, arg)
+do_base\xCC128\xCD(self, attrs)
+do_break\xCC128\xCD(self, arg, temporary = 0)
+do_br\xCC128\xCD(self, attrs)
+do_clear\xCC128\xCD(self, arg)
+do_commands\xCC128\xCD(self, arg)
+do_condition\xCC128\xCD(self, arg)
+do_continue\xCC128\xCD(self, arg)
+do_dd\xCC128\xCD(self, attrs)
+do_debug\xCC128\xCD(self, arg)
+do_disable\xCC128\xCD(self, arg)
+do_down\xCC128\xCD(self, arg)
+do_dt\xCC128\xCD(self, attrs)
+do_enable\xCC128\xCD(self, arg)
+do_help\xCC128\xCD(self, arg)
+do_hr\xCC128\xCD(self, attrs)
+do_ignore\xCC128\xCD(self,arg)
+do_img\xCC128\xCD(self, attrs)
+do_isindex\xCC128\xCD(self, attrs)
+do_jump\xCC128\xCD(self, arg)
+do_link\xCC128\xCD(self, attrs)
+do_list\xCC128\xCD(self, arg)
+do_li\xCC128\xCD(self, attrs)
+do_longs\xCC128\xCD(opts, opt, longopts, args)
+do_meta\xCC128\xCD(self, attrs)
+do_nextid\xCC128\xCD(self, attrs)
+do_next\xCC128\xCD(self, arg)
+do_open\xCC128\xCD(self, http_class, req)
+do_plaintext\xCC128\xCD(self, attrs)
+do_pp\xCC128\xCD(self, arg)
+do_p\xCC128\xCD(self, attrs)
+do_quit\xCC128\xCD(self, arg)
+do_request_\xCC128\xCD(self, request)
+do_return\xCC128\xCD(self, arg)
+do_retval\xCC128\xCD(self, arg)
+do_shorts\xCC128\xCD(opts, optstring, shortopts, args)
+do_step\xCC128\xCD(self, arg)
+do_tbreak\xCC128\xCD(self, arg)
+do_unalias\xCC128\xCD(self, arg)
+do_up\xCC128\xCD(self, arg)
+do_whatis\xCC128\xCD(self, arg)
+do_where\xCC128\xCD(self, arg)
+docclass\xCC128\xCD(self, object, name=None, mod=None)
+docdata\xCC128\xCD(self, object, name=None, mod=None, cl=None)
+docmd\xCC128\xCD(self, cmd, args="")
+docmodule\xCC128\xCD(self, object, name=None, mod=None, *ignored)
+docother\xCC128\xCD(self, object, name=None, mod=None, *ignored)
+docproperty\xCC128\xCD(self, object, name=None, mod=None, cl=None)
+docroutine\xCC128\xCD(self, object, name=None, mod=None, cl=None)
+docserver\xCC128\xCD(self, server_name, package_documentation, methods)
+document\xCC128\xCD(self, object, name=None, *args)
+dolog\xCC128\xCD(fmt, *args)
+domain_match\xCC128\xCD(A, B)
+domain_return_ok\xCC128\xCD(self, domain, request)
+done\xCC128\xCD(self)
+dump_address_pair\xCC128\xCD(pair)
+dump_stats\xCC128\xCD(self, file)
+dumps\xCC128\xCD(obj, protocol=None)
+dump\xCC128\xCD(self, obj)
+dup2\xCC128\xCD(self, fd)
+eff_request_host\xCC128\xCD(request)
+effective\xCC128\xCD(file, line, frame)
+ehlo\xCC128\xCD(self, name='')
+emptyline\xCC128\xCD(self)
+empty\xCC128\xCD(self)
+enable_interspersed_args\xCC128\xCD(self)
+enable\xCC128\xCD(self)
+encode_cram_md5\xCC128\xCD(challenge, user, password)
+encode_long\xCC128\xCD(x)
+encode_plain\xCC128\xCD(user, password)
+encodestring\xCC128\xCD(s)
+encode\xCC128\xCD(input, output)
+endElement\xCC128\xCD(self, element)
+end_address\xCC128\xCD(self)
+end_array\xCC128\xCD(self)
+end_a\xCC128\xCD(self)
+end_blockquote\xCC128\xCD(self)
+end_body\xCC128\xCD(self)
+end_b\xCC128\xCD(self)
+end_cite\xCC128\xCD(self)
+end_code\xCC128\xCD(self)
+end_data\xCC128\xCD(self)
+end_date\xCC128\xCD(self)
+end_dict\xCC128\xCD(self)
+end_dir\xCC128\xCD(self)
+end_dl\xCC128\xCD(self)
+end_em\xCC128\xCD(self)
+end_false\xCC128\xCD(self)
+end_h1\xCC128\xCD(self)
+end_h2\xCC128\xCD(self)
+end_h3\xCC128\xCD(self)
+end_h4\xCC128\xCD(self)
+end_h5\xCC128\xCD(self)
+end_h6\xCC128\xCD(self)
+end_headers\xCC128\xCD(self)
+end_head\xCC128\xCD(self)
+end_html\xCC128\xCD(self)
+end_integer\xCC128\xCD(self)
+end_i\xCC128\xCD(self)
+end_kbd\xCC128\xCD(self)
+end_key\xCC128\xCD(self)
+end_listing\xCC128\xCD(self)
+end_marker\xCC128\xCD(self, str)
+end_menu\xCC128\xCD(self)
+end_ol\xCC128\xCD(self)
+end_paragraph\xCC128\xCD(self, blankline)
+end_pre\xCC128\xCD(self)
+end_real\xCC128\xCD(self)
+end_samp\xCC128\xCD(self)
+end_string\xCC128\xCD(self)
+end_strong\xCC128\xCD(self)
+end_title\xCC128\xCD(self)
+end_true\xCC128\xCD(self)
+end_tt\xCC128\xCD(self)
+end_ul\xCC128\xCD(self)
+end_var\xCC128\xCD(self)
+end_xmp\xCC128\xCD(self)
+endheaders\xCC128\xCD(self)
+endswith\xCC128\xCD(self, suffix, start=0, end=sys.maxint)
+endtransfer\xCC128\xCD(self)
+ensure_fromlist\xCC128\xCD(self, m, fromlist, recursive=0)
+ensure_value\xCC128\xCD(self, attr, value)
+enterabs\xCC128\xCD(self, time, priority, action, argument)
+enter\xCC128\xCD(self, delay, priority, action, argument)
+enumerate\xCC128\xCD()
+equal\xCC128\xCD(self, other)
+error_leader\xCC128\xCD(self, infile=None, lineno=None)
+error_perm\xCC1\xCD(Error)
+error_proto\xCC1\xCD(Error)
+error_reply\xCC1\xCD(Error)
+error_temp\xCC1\xCD(Error)
+error\xCC1\xCD(Exception)
+errprint\xCC128\xCD(*args)
+escape_path\xCC128\xCD(path)
+escape\xCC128\xCD(s, quote=None)
+excel_tab\xCC1\xCD(excel)
+excel\xCC1\xCD(Dialect)
+execRcLines\xCC128\xCD(self)
+execle\xCC128\xCD(file, *args)
+execlpe\xCC128\xCD(file, *args)
+execlp\xCC128\xCD(file, *args)
+execl\xCC128\xCD(file, *args)
+execsitecustomize\xCC128\xCD()
+executable\xCC128\xCD(path)
+execvpe\xCC128\xCD(file, args, env)
+execvp\xCC128\xCD(file, args)
+exists\xCC128\xCD(path)
+exit\xCC128\xCD(self, status=0, msg=None)
+expand_default\xCC128\xCD(self, option)
+expand_prog_name\xCC128\xCD(self, s)
+expand_tabs\xCC128\xCD(line)
+expandtabs\xCC128\xCD(s, tabsize=8)
+expanduser\xCC128\xCD(path)
+expandvars\xCC128\xCD(path)
+expand\xCC128\xCD(self)
+expect\xCC128\xCD(self, list, timeout=None)
+expn\xCC128\xCD(self, address)
+export_add\xCC128\xCD(self, x, y)
+expovariate\xCC128\xCD(self, lambd)
+expunge\xCC128\xCD(self)
+extend_path\xCC128\xCD(path, name)
+extend\xCC128\xCD(self, other)
+extract_cookies\xCC128\xCD(self, response, request)
+extract_stack\xCC128\xCD(f=None, limit = None)
+extract_tb\xCC128\xCD(tb, limit = None)
+extractall\xCC128\xCD(self, path=".", members=None)
+extractfile\xCC128\xCD(self, member)
+extract\xCC128\xCD(s)
+failIfAlmostEqual\xCC128\xCD(self, first, second, places=7, msg=None)
+failIfEqual\xCC128\xCD(self, first, second, msg=None)
+failIf\xCC128\xCD(self, expr, msg=None)
+failUnlessAlmostEqual\xCC128\xCD(self, first, second, places=7, msg=None)
+failUnlessEqual\xCC128\xCD(self, first, second, msg=None)
+failUnlessRaises\xCC128\xCD(self, excClass, callableObj, *args, **kwargs)
+failUnless\xCC128\xCD(self, expr, msg=None)
+fail\xCC128\xCD(self, object, name=None, *args)
+feed\xCC128\xCD(self, data)
+fetch\xCC128\xCD(self, message_set, message_parts)
+file_dispatcher\xCC1\xCD(dispatcher)
+file_module_function_of\xCC128\xCD(self, frame)
+file_open\xCC128\xCD(self, req)
+filelineno\xCC128\xCD()
+filemode\xCC128\xCD(mode)
+filename\xCC128\xCD()
+fileno\xCC128\xCD(self)
+fileopen\xCC128\xCD(self, file)
+file\xCC128\xCD(self)
+fill_rawq\xCC128\xCD(self)
+fill\xCC128\xCD(self, text)
+filter\xCC128\xCD(names, pat)
+findTestCases\xCC128\xCD(module, prefix='test', sortUsing=cmp, suiteClass=TestSuite)
+find_all_submodules\xCC128\xCD(self, m)
+find_builtin_module\xCC128\xCD(self, name)
+find_class\xCC128\xCD(self, module, name)
+find_executable_linenos\xCC128\xCD(filename)
+find_function\xCC128\xCD(funcname, filename)
+find_head_package\xCC128\xCD(self, parent, name)
+find_lines_from_code\xCC128\xCD(code, strs)
+find_lines\xCC128\xCD(code, strs)
+find_loader\xCC128\xCD(fullname)
+find_longest_match\xCC128\xCD(self, alo, ahi, blo, bhi)
+find_module_in_dir\xCC128\xCD(self, name, dir)
+find_module\xCC128\xCD(self, name, path = None)
+find_prefix_at_end\xCC128\xCD(haystack, needle)
+find_strings\xCC128\xCD(filename)
+find_user_password\xCC128\xCD(self, realm, authuri)
+findall\xCC128\xCD(pattern, string, flags=0)
+finditer\xCC128\xCD(pattern, string, flags=0)
+findlabels\xCC128\xCD(code)
+findlinestarts\xCC128\xCD(code)
+findmatch\xCC128\xCD(caps, MIMEtype, key='view', filename="/dev/null", plist=[])
+findparam\xCC128\xCD(name, plist)
+findsource\xCC128\xCD(object)
+find\xCC128\xCD(domain, localedir=None, languages=None, all=0)
+finish_request\xCC128\xCD(self, request, client_address)
+finish\xCC128\xCD(self)
+first\xCC128\xCD(self)
+fixup\xCC128\xCD((name, kind, cls, value))
+flags\xCC128\xCD(self, *which)
+flush_softspace\xCC128\xCD(self)
+flushheaders\xCC128\xCD(self)
+flush\xCC128\xCD(self)
+fnmatchcase\xCC128\xCD(name, pat)
+fnmatch\xCC128\xCD(name, pat)
+forget\xCC128\xCD(self)
+fork\xCC128\xCD()
+format_counter\xCC128\xCD(self, format, counter)
+format_description\xCC128\xCD(self, description)
+format_epilog\xCC128\xCD(self, epilog)
+format_exception_only\xCC128\xCD(etype, value)
+format_exception\xCC128\xCD(etype, value, tb, limit = None)
+format_exc\xCC128\xCD(limit=None)
+format_heading\xCC128\xCD(self, heading)
+format_help\xCC128\xCD(self, formatter)
+format_letter\xCC128\xCD(self, case, counter)
+format_list\xCC128\xCD(extracted_list)
+format_option_help\xCC128\xCD(self, formatter)
+format_option_strings\xCC128\xCD(self, option)
+format_option\xCC128\xCD(self, option)
+format_roman\xCC128\xCD(self, case, counter)
+format_stack_entry\xCC128\xCD(self, frame_lineno, lprefix=': ')
+format_stack\xCC128\xCD(f=None, limit=None)
+format_string\xCC128\xCD(f, val, grouping=False)
+format_tb\xCC128\xCD(tb, limit = None)
+format_usage\xCC128\xCD(self, usage)
+format_witnesses\xCC128\xCD(w)
+formatdate\xCC128\xCD(timeval=None)
+formatday\xCC128\xCD(self, day, weekday, width)
+formatmonthname\xCC128\xCD(self, theyear, themonth, width, withyear=True)
+formatmonth\xCC128\xCD(self, theyear, themonth, w=0, l=0)
+formatstring\xCC128\xCD(cols, colwidth=_colwidth, spacing=_spacing)
+formattree\xCC128\xCD(self, tree, modname, parent=None)
+formatvalue\xCC128\xCD(self, object)
+formatwarning\xCC128\xCD(message, category, filename, lineno)
+formatweekday\xCC128\xCD(self, day, width)
+formatweekheader\xCC128\xCD(self, width)
+formatweek\xCC128\xCD(self, theweek, width)
+formatyearpage\xCC128\xCD(self, theyear, width=3, css='calendar.css', encoding=None)
+formatyear\xCC128\xCD(self, theyear, w=2, l=1, c=6, m=3)
+format\xCC128\xCD(cols, colwidth=_colwidth, spacing=_spacing)
+found_terminator\xCC128\xCD(self)
+fragment\xCC128\xCD(self)
+fromBase64\xCC128\xCD(cls, data)
+fromFile\xCC128\xCD(cls, pathOrFile)
+frombuf\xCC128\xCD(cls, buf)
+fromkeys\xCC128\xCD(cls, iterable, value=None)
+fromlist\xCC128\xCD(self, list)
+fromstring\xCC128\xCD(self, data)
+ftp_open\xCC128\xCD(self, req)
+ftpcp\xCC128\xCD(source, sourcename, target, targetname = '', type = 'I')
+ftperrors\xCC128\xCD()
+fullmodname\xCC128\xCD(path)
+full\xCC128\xCD(self)
+gammavariate\xCC128\xCD(self, alpha, beta)
+gauss\xCC128\xCD(self, mu, sigma)
+generate_html_documentation\xCC128\xCD(self)
+generate_tokens\xCC128\xCD(readline)
+genops\xCC128\xCD(pickle)
+get1\xCC128\xCD(name, object=object, filter=filter)
+get2\xCC128\xCD(name, get1=get1)
+getData\xCC128\xCD(self)
+getDescription\xCC128\xCD(self, test)
+getName\xCC128\xCD(self)
+getTestCaseNames\xCC128\xCD(self, testCaseClass)
+get_account\xCC128\xCD(self, host)
+get_algorithm_impls\xCC128\xCD(self, algorithm)
+get_all_breaks\xCC128\xCD(self)
+get_alt_binary\xCC128\xCD(f, func, blocksize)
+get_alt_textfile\xCC128\xCD(f, func)
+get_authorization\xCC128\xCD(self, req, chal)
+get_binary\xCC128\xCD(f)
+get_breaks\xCC128\xCD(self, filename, lineno)
+get_break\xCC128\xCD(self, filename, lineno)
+get_buffer\xCC128\xCD(self)
+get_bytes_le\xCC128\xCD(self)
+get_bytes\xCC128\xCD(self)
+get_children\xCC128\xCD(self)
+get_class_members\xCC128\xCD(klass)
+get_clock_seq_hi_variant\xCC128\xCD(self)
+get_clock_seq_low\xCC128\xCD(self)
+get_clock_seq\xCC128\xCD(self)
+get_close_matches\xCC128\xCD(word, possibilities, n=3, cutoff=0.6)
+get_cnonce\xCC128\xCD(self, nonce)
+get_code\xCC128\xCD(self, parent, modname, fqname)
+get_data\xCC128\xCD(self, pathname)
+get_date\xCC128\xCD(self)
+get_default_values\xCC128\xCD(self)
+get_description\xCC128\xCD(self)
+get_directory\xCC128\xCD(f)
+get_entity_digest\xCC128\xCD(self, data, chal)
+get_extension\xCC128\xCD(self, code)
+get_fields\xCC128\xCD(self)
+get_file_breaks\xCC128\xCD(self, filename)
+get_filename\xCC128\xCD(self, fullname=None)
+get_file\xCC128\xCD(self, key)
+get_flags\xCC128\xCD(self)
+get_folder\xCC128\xCD(self, folder)
+get_frees\xCC128\xCD(self)
+get_from\xCC128\xCD(self)
+get_frozen_object\xCC128\xCD(self, name)
+get_full_url\xCC128\xCD(self)
+get_globals\xCC128\xCD(self)
+get_grouped_opcodes\xCC128\xCD(self, n=3)
+get_header\xCC128\xCD(self, header_name, default=None)
+get_hex\xCC128\xCD(self)
+get_hooks\xCC128\xCD(self)
+get_hosts\xCC128\xCD(self)
+get_host\xCC128\xCD(self)
+get_identifiers\xCC128\xCD(self)
+get_id\xCC128\xCD(self)
+get_importer\xCC128\xCD(path_item)
+get_info\xCC128\xCD(self)
+get_labels\xCC128\xCD(self)
+get_lineno\xCC128\xCD(self)
+get_line\xCC128\xCD(self)
+get_loader\xCC128\xCD(self)
+get_locals\xCC128\xCD(self)
+get_long_be\xCC128\xCD(s)
+get_long_le\xCC128\xCD(s)
+get_macros\xCC128\xCD(self)
+get_macro\xCC128\xCD(self, macro)
+get_matching_blocks\xCC128\xCD(self)
+get_message\xCC128\xCD(self, key)
+get_methods\xCC128\xCD(self)
+get_method\xCC128\xCD(self)
+get_msg\xCC128\xCD(self)
+get_namespaces\xCC128\xCD(self)
+get_namespace\xCC128\xCD(self)
+get_names\xCC128\xCD(self)
+get_name\xCC128\xCD(self)
+get_node\xCC128\xCD(self)
+get_nonstandard_attr\xCC128\xCD(self, name, default=None)
+get_nowait\xCC128\xCD(self)
+get_opcodes\xCC128\xCD(self)
+get_opt_string\xCC128\xCD(self)
+get_option_group\xCC128\xCD(self, opt_str)
+get_option\xCC128\xCD(self, opt_str)
+get_origin_req_host\xCC128\xCD(self)
+get_parameters\xCC128\xCD(self)
+get_position\xCC128\xCD(self)
+get_prog_name\xCC128\xCD(self)
+get_request\xCC128\xCD(self)
+get_selector\xCC128\xCD(self)
+get_sequences\xCC128\xCD(self)
+get_short_be\xCC128\xCD(s)
+get_short_le\xCC128\xCD(s)
+get_socket\xCC128\xCD(self)
+get_source\xCC128\xCD(self, fullname=None)
+get_stack\xCC128\xCD(self, f, t)
+get_starttag_text\xCC128\xCD(self)
+get_string\xCC128\xCD(self, key)
+get_subdir\xCC128\xCD(self)
+get_suffixes\xCC128\xCD(self)
+get_symbols\xCC128\xCD(self)
+get_terminator\xCC128\xCD(self)
+get_textfile\xCC128\xCD(f)
+get_time_hi_version\xCC128\xCD(self)
+get_time_low\xCC128\xCD(self)
+get_time_mid\xCC128\xCD(self)
+get_time\xCC128\xCD(self)
+get_token\xCC128\xCD(self)
+get_type\xCC128\xCD(self)
+get_urn\xCC128\xCD(self)
+get_usage\xCC128\xCD(self)
+get_user_passwd\xCC128\xCD(self, host, realm, clear_cache = 0)
+get_variant\xCC128\xCD(self)
+get_verbose\xCC128\xCD(self)
+get_version\xCC128\xCD(self)
+get_visible\xCC128\xCD(self)
+getabsfile\xCC128\xCD(object, _filename=None)
+getacl\xCC128\xCD(self, mailbox)
+getaddress\xCC128\xCD(self)
+getaddrlist\xCC128\xCD(self, name)
+getaddrspec\xCC128\xCD(self)
+getaddr\xCC128\xCD(self, name)
+getallmatchingheaders\xCC128\xCD(self, name)
+getannotation\xCC128\xCD(self, mailbox, entry, attribute)
+getargspec\xCC128\xCD(func)
+getargs\xCC128\xCD(co)
+getargvalues\xCC128\xCD(frame)
+getatime\xCC128\xCD(filename)
+getatom\xCC128\xCD(self, atomends=None)
+getblock\xCC128\xCD(lines)
+getbodyparts\xCC128\xCD(self)
+getbodytext\xCC128\xCD(self, decode = 1)
+getbody\xCC128\xCD(self)
+getboolean\xCC128\xCD(self, section, option)
+getcaps\xCC128\xCD()
+getclasstree\xCC128\xCD(classes, unique=0)
+getcomments\xCC128\xCD(object)
+getcomment\xCC128\xCD(self)
+getcompname\xCC128\xCD(self)
+getcomptype\xCC128\xCD(self)
+getcontext\xCC128\xCD()
+getctime\xCC128\xCD(filename)
+getcurrent\xCC128\xCD(self)
+getdate_tz\xCC128\xCD(self, name)
+getdate\xCC128\xCD(self, name)
+getdecoder\xCC128\xCD(encoding)
+getdefaultlocale\xCC128\xCD(envvars=('LC_ALL', 'LC_CTYPE', 'LANG', 'LANGUAGE'))
+getdelimited\xCC128\xCD(self, beginchar, endchars, allowcomments = 1)
+getdigits\xCC128\xCD(self, p)
+getdocloc\xCC128\xCD(self, object)
+getdoc\xCC128\xCD(object)
+getdomainliteral\xCC128\xCD(self)
+getdomain\xCC128\xCD(self)
+getencoder\xCC128\xCD(encoding)
+getencoding\xCC128\xCD(self)
+getenv\xCC128\xCD(key, default=None)
+getfileinfo\xCC128\xCD(name)
+getfile\xCC128\xCD(self)
+getfillable\xCC128\xCD(self)
+getfilled\xCC128\xCD(self)
+getfirstmatchingheader\xCC128\xCD(self, name)
+getfirstweekday\xCC128\xCD(self)
+getfirst\xCC128\xCD(self, key, default=None)
+getfloat\xCC128\xCD(self, section, option)
+getfp\xCC128\xCD(self)
+getfqdn\xCC128\xCD(name='')
+getframeinfo\xCC128\xCD(frame, context=1)
+getframerate\xCC128\xCD(self)
+getfullname\xCC128\xCD(self)
+gethdr\xCC128\xCD(fp)
+getheaders\xCC128\xCD(self)
+getheadertext\xCC128\xCD(self, pred = None)
+getheader\xCC128\xCD(self, name, default=None)
+getincrementaldecoder\xCC128\xCD(encoding)
+getincrementalencoder\xCC128\xCD(encoding)
+getinfo\xCC128\xCD(self, name)
+getinnerframes\xCC128\xCD(tb, context=1)
+getint\xCC128\xCD(self, section, option)
+getlast\xCC128\xCD(self)
+getlineno\xCC128\xCD(frame)
+getlines\xCC128\xCD(filename, module_globals=None)
+getline\xCC128\xCD(self)
+getlist\xCC128\xCD(self, key)
+getlocale\xCC128\xCD(category=LC_CTYPE)
+getlongresp\xCC128\xCD(self, file=None)
+getmaintype\xCC128\xCD(self)
+getmarkers\xCC128\xCD(self)
+getmark\xCC128\xCD(self, id)
+getmembers\xCC128\xCD(object, predicate=None)
+getmember\xCC128\xCD(self, name)
+getmessagefilename\xCC128\xCD(self, n)
+getmoduleinfo\xCC128\xCD(path)
+getmodulename\xCC128\xCD(path)
+getmodule\xCC128\xCD(object, _filename=None)
+getmro\xCC128\xCD(cls)
+getmtime\xCC128\xCD(filename)
+getmultiline\xCC128\xCD(self)
+getnames\xCC128\xCD(self)
+getname\xCC128\xCD(self)
+getnchannels\xCC128\xCD(self)
+getnframes\xCC128\xCD(self)
+getnode\xCC128\xCD()
+getopt\xCC128\xCD(args, shortopts, longopts = [])
+getouterframes\xCC128\xCD(frame, context=1)
+getoutput\xCC128\xCD(cmd)
+getpager\xCC128\xCD()
+getparamnames\xCC128\xCD(self)
+getparams\xCC128\xCD(self)
+getparam\xCC128\xCD(self, name)
+getpath\xCC128\xCD(self)
+getphraselist\xCC128\xCD(self)
+getplist\xCC128\xCD(self)
+getpos\xCC128\xCD(self)
+getpreferredencoding\xCC128\xCD(do_setlocale = True)
+getprofile\xCC128\xCD(self, key)
+getproxies_environment\xCC128\xCD()
+getproxies_internetconfig\xCC128\xCD()
+getproxies_registry\xCC128\xCD()
+getproxies\xCC128\xCD()
+getquotaroot\xCC128\xCD(self, mailbox)
+getquota\xCC128\xCD(self, root)
+getquote\xCC128\xCD(self)
+getrandbits\xCC128\xCD(self, k)
+getrawheader\xCC128\xCD(self, name)
+getreader\xCC128\xCD(encoding)
+getreply\xCC128\xCD(self)
+getresponse\xCC128\xCD(self)
+getresp\xCC128\xCD(self)
+getrouteaddr\xCC128\xCD(self)
+getsampwidth\xCC128\xCD(self)
+getsequencesfilename\xCC128\xCD(self)
+getsequences\xCC128\xCD(self)
+getsize\xCC128\xCD(self)
+getsourcefile\xCC128\xCD(object)
+getsourcelines\xCC128\xCD(object)
+getsource\xCC128\xCD(object)
+getstate\xCC128\xCD(self)
+getstatusoutput\xCC128\xCD(cmd)
+getstatus\xCC128\xCD(file)
+getsubtype\xCC128\xCD(self)
+gettarinfo\xCC128\xCD(self, name=None, arcname=None, fileobj=None)
+gettempdir\xCC128\xCD()
+gettempprefix\xCC128\xCD()
+gettext\xCC128\xCD(self, message)
+gettype\xCC128\xCD(self)
+geturl\xCC128\xCD(self)
+getuser\xCC128\xCD()
+getvalue\xCC128\xCD(self, key, default=None)
+getwelcome\xCC128\xCD(self)
+getwriter\xCC128\xCD(encoding)
+glob0\xCC128\xCD(dirname, basename)
+glob1\xCC128\xCD(dirname, pattern)
+global_matches\xCC128\xCD(self, text)
+globaltrace_countfuncs\xCC128\xCD(self, frame, why, arg)
+globaltrace_lt\xCC128\xCD(self, frame, why, arg)
+globaltrace_trackcallers\xCC128\xCD(self, frame, why, arg)
+glob\xCC128\xCD(pathname)
+gnu_getopt\xCC128\xCD(args, shortopts, longopts = [])
+goahead\xCC128\xCD(self, end)
+gopher_open\xCC128\xCD(self, req)
+gotonext\xCC128\xCD(self)
+goto\xCC128\xCD(self, event=None)
+grey\xCC128\xCD(text)
+group\xCC128\xCD(self, name)
+guess_all_extensions\xCC128\xCD(self, type, strict=True)
+guess_extension\xCC128\xCD(self, type, strict=True)
+guess_type\xCC128\xCD(self, url, strict=True)
+gzopen\xCC128\xCD(cls, name, mode="r", fileobj=None, compresslevel=9)
+handleBeginElement\xCC128\xCD(self, element, attrs)
+handleData\xCC128\xCD(self, data)
+handleEndElement\xCC128\xCD(self, element)
+handle_accept\xCC128\xCD(self)
+handle_charref\xCC128\xCD(self, name)
+handle_close\xCC128\xCD(self)
+handle_command_def\xCC128\xCD(self,line)
+handle_comment\xCC128\xCD(self, data)
+handle_connect\xCC128\xCD(self)
+handle_data\xCC128\xCD(self, data)
+handle_decl\xCC128\xCD(self, decl)
+handle_endtag\xCC128\xCD(self, tag)
+handle_entityref\xCC128\xCD(self, name)
+handle_error\xCC128\xCD(self)
+handle_expt_event\xCC128\xCD(self)
+handle_expt\xCC128\xCD(self)
+handle_get\xCC128\xCD(self)
+handle_image\xCC128\xCD(self, src, alt, *args)
+handle_one_request\xCC128\xCD(self)
+handle_pi\xCC128\xCD(self, data)
+handle_read_event\xCC128\xCD(self)
+handle_read\xCC128\xCD(self)
+handle_request\xCC128\xCD(self, request_text = None)
+handle_startendtag\xCC128\xCD(self, tag, attrs)
+handle_starttag\xCC128\xCD(self, tag, attrs)
+handle_write_event\xCC128\xCD(self)
+handle_write\xCC128\xCD(self)
+handle_xmlrpc\xCC128\xCD(self, request_text)
+handle\xCC128\xCD(self)
+has_children\xCC128\xCD(self)
+has_data\xCC128\xCD(self)
+has_exec\xCC128\xCD(self)
+has_extn\xCC128\xCD(self, opt)
+has_header\xCC128\xCD(self, sample)
+has_import_star\xCC128\xCD(self)
+has_key\xCC128\xCD(self, key)
+has_magic\xCC128\xCD(s)
+has_nonstandard_attr\xCC128\xCD(self, name)
+has_option\xCC128\xCD(self, section, option)
+has_section\xCC128\xCD(self, section)
+header_items\xCC128\xCD(self)
+heading\xCC128\xCD(self, title, fgcol, bgcol, extras='')
+head\xCC128\xCD(self, id)
+heapify\xCC128\xCD(x)
+heappop\xCC128\xCD(heap)
+heappush\xCC128\xCD(heap, item)
+heapreplace\xCC128\xCD(heap, item)
+helo\xCC128\xCD(self, name='')
+help_EOF\xCC128\xCD(self)
+help_alias\xCC128\xCD(self)
+help_args\xCC128\xCD(self)
+help_a\xCC128\xCD(self)
+help_break\xCC128\xCD(self)
+help_b\xCC128\xCD(self)
+help_clear\xCC128\xCD(self)
+help_cl\xCC128\xCD(self)
+help_commands\xCC128\xCD(self)
+help_condition\xCC128\xCD(self)
+help_continue\xCC128\xCD(self)
+help_cont\xCC128\xCD(self)
+help_c\xCC128\xCD(self)
+help_debug\xCC128\xCD(self)
+help_disable\xCC128\xCD(self)
+help_down\xCC128\xCD(self)
+help_d\xCC128\xCD(self)
+help_enable\xCC128\xCD(self)
+help_exec\xCC128\xCD(self)
+help_help\xCC128\xCD(self)
+help_h\xCC128\xCD(self)
+help_ignore\xCC128\xCD(self)
+help_jump\xCC128\xCD(self)
+help_j\xCC128\xCD(self)
+help_list\xCC128\xCD(self)
+help_l\xCC128\xCD(self)
+help_next\xCC128\xCD(self)
+help_n\xCC128\xCD(self)
+help_pdb\xCC128\xCD(self)
+help_pp\xCC128\xCD(self)
+help_p\xCC128\xCD(self)
+help_quit\xCC128\xCD(self)
+help_q\xCC128\xCD(self)
+help_return\xCC128\xCD(self)
+help_r\xCC128\xCD(self)
+help_step\xCC128\xCD(self)
+help_s\xCC128\xCD(self)
+help_tbreak\xCC128\xCD(self)
+help_unalias\xCC128\xCD(self)
+help_up\xCC128\xCD(self)
+help_u\xCC128\xCD(self)
+help_whatis\xCC128\xCD(self)
+help_where\xCC128\xCD(self)
+help_w\xCC128\xCD(self)
+helper\xCC128\xCD(*args, **kwds)
+help\xCC128\xCD()
+hexbin\xCC128\xCD(inp, out)
+hexdigest\xCC128\xCD(self)
+hide\xCC128\xCD(self, event=None)
+hls_to_rgb\xCC128\xCD(h, l, s)
+hook_compressed\xCC128\xCD(filename, mode)
+hook_encoded\xCC128\xCD(encoding)
+hostname\xCC128\xCD(self)
+hsv_to_rgb\xCC128\xCD(h, s, v)
+html\xCC128\xCD((etype, evalue, etb), context=5)
+http2time\xCC128\xCD(text)
+http_error_301\xCC128\xCD(self, url, fp, errcode, errmsg, headers, data=None)
+http_error_302\xCC128\xCD(self, req, fp, code, msg, headers)
+http_error_303\xCC128\xCD(self, url, fp, errcode, errmsg, headers, data=None)
+http_error_307\xCC128\xCD(self, url, fp, errcode, errmsg, headers, data=None)
+http_error_401\xCC128\xCD(self, req, fp, code, msg, headers)
+http_error_407\xCC128\xCD(self, req, fp, code, msg, headers)
+http_error_auth_reqed\xCC128\xCD(self, authreq, host, req, headers)
+http_error_default\xCC128\xCD(self, url, fp, errcode, errmsg, headers)
+http_error\xCC128\xCD(self, url, fp, errcode, errmsg, headers, data=None)
+http_open\xCC128\xCD(self, req)
+http_request\xCC128\xCD(self, request)
+http_response\xCC128\xCD(self, request, response)
+https_open\xCC128\xCD(self, req)
+ifilterfalse\xCC128\xCD(predicate, iterable)
+ifilter\xCC128\xCD(predicate, iterable)
+iglob\xCC128\xCD(pathname)
+ihave\xCC128\xCD(self, id, f)
+immutable\xCC128\xCD(self)
+import_file\xCC128\xCD(self, filename, finfo, fqname)
+import_from_dir\xCC128\xCD(self, dir, fqname)
+import_hook\xCC128\xCD(self, name, caller=None, fromlist=None)
+import_it\xCC128\xCD(self, partname, fqname, parent, force_load=0)
+import_module\xCC128\xCD(self, name, globals={}, locals={}, fromlist=[])
+import_top\xCC128\xCD(self, name)
+importfile\xCC128\xCD(path)
+in_table_a1\xCC128\xCD(code)
+in_table_b1\xCC128\xCD(code)
+in_table_c11_c12\xCC128\xCD(code)
+in_table_c11\xCC128\xCD(code)
+in_table_c12\xCC128\xCD(code)
+in_table_c21_c22\xCC128\xCD(code)
+in_table_c21\xCC128\xCD(code)
+in_table_c22\xCC128\xCD(code)
+in_table_c3\xCC128\xCD(code)
+in_table_c4\xCC128\xCD(code)
+in_table_c5\xCC128\xCD(code)
+in_table_c6\xCC128\xCD(code)
+in_table_c7\xCC128\xCD(code)
+in_table_c8\xCC128\xCD(code)
+in_table_c9\xCC128\xCD(code)
+in_table_d1\xCC128\xCD(code)
+in_table_d2\xCC128\xCD(code)
+incref\xCC128\xCD(self)
+indent_level\xCC128\xCD(self, tabsize)
+indentsize\xCC128\xCD(line)
+indent\xCC128\xCD(self)
+indexed_value\xCC128\xCD(self, key, location)
+index\xCC128\xCD(self, dir, shadowed=None)
+infolist\xCC128\xCD(self)
+info\xCC128\xCD(self)
+init_builtin\xCC128\xCD(self, name)
+init_frozen\xCC128\xCD(self, name)
+initclass\xCC128\xCD(self)
+initfp\xCC128\xCD(self, file)
+initiate_send\xCC128\xCD(self)
+initlog\xCC128\xCD(*allargs)
+init\xCC128\xCD(files=None)
+inner\xCC128\xCD(_it, _timer)
+insert\xCC128\xCD(self, i, item)
+insort_left\xCC128\xCD(a, x, lo=0, hi=None)
+insort_right\xCC128\xCD(a, x, lo=0, hi=None)
+install_opener\xCC128\xCD(opener)
+install\xCC128\xCD(self, unicode=False, names=None)
+interaction\xCC128\xCD(self, frame, traceback)
+interact\xCC128\xCD(self, banner=None)
+intersection_update\xCC128\xCD(self, other)
+intersection\xCC128\xCD(self, other)
+intro\xCC128\xCD(self)
+isAlive\xCC128\xCD(self)
+isDaemon\xCC128\xCD(self)
+isReservedKey\xCC128\xCD(self, K)
+isSet\xCC128\xCD(self)
+isTestMethod\xCC128\xCD(attrname, testCaseClass=testCaseClass, prefix=self.testMethodPrefix)
+is_HDN\xCC128\xCD(text)
+is_assigned\xCC128\xCD(self)
+is_blocked\xCC128\xCD(self, domain)
+is_builtin\xCC128\xCD(self, name)
+is_canonical\xCC128\xCD(self)
+is_cgi\xCC128\xCD(self)
+is_data\xCC128\xCD(self, line)
+is_empty\xCC128\xCD(self)
+is_executable\xCC128\xCD(self, path)
+is_expired\xCC128\xCD(self, now=None)
+is_finite\xCC128\xCD(self)
+is_free\xCC128\xCD(flags)
+is_frozen\xCC128\xCD(self, name)
+is_global\xCC128\xCD(self)
+is_imported\xCC128\xCD(self)
+is_in_tuple\xCC128\xCD(self)
+is_infinite\xCC128\xCD(self)
+is_keywordarg\xCC128\xCD(self)
+is_local\xCC128\xCD(self)
+is_namespace\xCC128\xCD(self)
+is_nan\xCC128\xCD(self)
+is_nested\xCC128\xCD(self)
+is_normal\xCC128\xCD(self, context=None)
+is_not_allowed\xCC128\xCD(self, domain)
+is_optimized\xCC128\xCD(self)
+is_package\xCC128\xCD(self, fullname)
+is_parameter\xCC128\xCD(self)
+is_python\xCC128\xCD(self, path)
+is_qnan\xCC128\xCD(self)
+is_referenced\xCC128\xCD(self)
+is_rpc_path_valid\xCC128\xCD(self)
+is_signed\xCC128\xCD(self)
+is_snan\xCC128\xCD(self)
+is_subnormal\xCC128\xCD(self, context=None)
+is_suburi\xCC128\xCD(self, base, test)
+is_tarfile\xCC128\xCD(name)
+is_third_party\xCC128\xCD(request)
+is_unverifiable\xCC128\xCD(self)
+is_vararg\xCC128\xCD(self)
+is_zero\xCC128\xCD(self)
+is_zipfile\xCC128\xCD(filename)
+isabs\xCC128\xCD(s)
+isalnum\xCC128\xCD(self)
+isalpha\xCC128\xCD(self)
+isatty\xCC128\xCD(self)
+isbasestring\xCC128\xCD(x)
+isblk\xCC128\xCD(self)
+isbuiltin\xCC128\xCD(object)
+ischr\xCC128\xCD(self)
+isclass\xCC128\xCD(object)
+isclosed\xCC128\xCD(self)
+iscode\xCC128\xCD(object)
+iscomment\xCC128\xCD(self, line)
+isdatadescriptor\xCC128\xCD(object)
+isdata\xCC128\xCD(object)
+isdecimal\xCC128\xCD(self)
+isdev\xCC128\xCD(self)
+isdigit\xCC128\xCD(self)
+isdir\xCC128\xCD(path)
+isfifo\xCC128\xCD(self)
+isfile\xCC128\xCD(path)
+isfirstline\xCC128\xCD()
+isframe\xCC128\xCD(object)
+isfunction\xCC128\xCD(object)
+isgetsetdescriptor\xCC128\xCD(object)
+isheader\xCC128\xCD(self, line)
+ishex\xCC128\xCD(c)
+isinstance\xCC128\xCD(obj, clsinfo)
+islast\xCC128\xCD(self, line)
+isleap\xCC128\xCD(year)
+islink\xCC128\xCD(path)
+islnk\xCC128\xCD(self)
+islower\xCC128\xCD(self)
+ismemberdescriptor\xCC128\xCD(object)
+ismethoddescriptor\xCC128\xCD(object)
+ismethod\xCC128\xCD(object)
+ismodule\xCC128\xCD(object)
+ismount\xCC128\xCD(path)
+isnumeric\xCC128\xCD(str)
+iso2time\xCC128\xCD(text)
+ispackage\xCC128\xCD(path)
+ispath\xCC128\xCD(x)
+isreadable\xCC128\xCD(object)
+isrecursive\xCC128\xCD(object)
+isreg\xCC128\xCD(self)
+isroutine\xCC128\xCD(object)
+isspace\xCC128\xCD(self)
+issparse\xCC128\xCD(self)
+isstdin\xCC128\xCD()
+issubset\xCC128\xCD(self, other)
+issuperset\xCC128\xCD(self, other)
+issym\xCC128\xCD(self)
+istitle\xCC128\xCD(self)
+istraceback\xCC128\xCD(object)
+isupper\xCC128\xCD(self)
+items\xCC128\xCD(self)
+iter_importer_modules\xCC128\xCD(importer, prefix='')
+iter_importers\xCC128\xCD(fullname="")
+iter_modules\xCC128\xCD(path=None, prefix='')
+iter_zipimport_modules\xCC128\xCD(importer, prefix='')
+iterdecode\xCC128\xCD(iterator, encoding, errors='strict', **kwargs)
+iterencode\xCC128\xCD(iterator, encoding, errors='strict', **kwargs)
+iteritems\xCC128\xCD(self)
+iterkeyrefs\xCC128\xCD(self)
+iterkeys\xCC128\xCD(self)
+itermonthdates\xCC128\xCD(self, year, month)
+itermonthdays2\xCC128\xCD(self, year, month)
+itermonthdays\xCC128\xCD(self, year, month)
+itervaluerefs\xCC128\xCD(self)
+itervalues\xCC128\xCD(self)
+iterweekdays\xCC128\xCD(self)
+jabs_op\xCC128\xCD(name, op)
+java_ver\xCC128\xCD(release='',vendor='',vminfo=('','',''),osinfo=('','',''))
+join_header_words\xCC128\xCD(lists)
+joinseq\xCC128\xCD(seq)
+join\xCC128\xCD(a, b)
+jrel_op\xCC128\xCD(name, op)
+js_output\xCC128\xCD(self, attrs=None)
+jumpahead\xCC128\xCD(self, n)
+keyrefs\xCC128\xCD(self)
+keys\xCC128\xCD(self)
+label\xCC128\xCD(code)
+lastpart\xCC128\xCD(self)
+last\xCC128\xCD(self)
+ldgettext\xCC128\xCD(domain, message)
+ldngettext\xCC128\xCD(domain, msgid1, msgid2, n)
+leapdays\xCC128\xCD(y1, y2)
+length\xCC128\xCD(self, key)
+less\xCC128\xCD(self, other)
+lexists\xCC128\xCD(path)
+lgettext\xCC128\xCD(self, message)
+liberal_is_HDN\xCC128\xCD(text)
+lineinfo\xCC128\xCD(self, identifier)
+lineno\xCC128\xCD()
+list2cmdline\xCC128\xCD(seq)
+list_directory\xCC128\xCD(self, path)
+list_folders\xCC128\xCD(self)
+list_public_methods\xCC128\xCD(obj)
+listallfolders\xCC128\xCD(self)
+listallsubfolders\xCC128\xCD(self, name)
+listdir\xCC128\xCD(path)
+listener\xCC128\xCD(self)
+listen\xCC128\xCD(self, num)
+listfolders\xCC128\xCD(self)
+listkeywords\xCC128\xCD(self)
+listmailcapfiles\xCC128\xCD()
+listmessages\xCC128\xCD(self)
+listmodules\xCC128\xCD(self, key='')
+listsubfolders\xCC128\xCD(self, name)
+listtopics\xCC128\xCD(self)
+list\xCC128\xCD(self, directory='""', pattern='*')
+ljust\xCC128\xCD(s, width)
+lngettext\xCC128\xCD(self, msgid1, msgid2, n)
+loadTestsFromModule\xCC128\xCD(self, module)
+loadTestsFromNames\xCC128\xCD(self, names, module=None)
+loadTestsFromName\xCC128\xCD(self, name, module=None)
+loadTestsFromTestCase\xCC128\xCD(self, testCaseClass)
+load_appends\xCC128\xCD(self)
+load_append\xCC128\xCD(self)
+load_binfloat\xCC128\xCD(self, unpack=struct.unpack)
+load_binget\xCC128\xCD(self)
+load_binint1\xCC128\xCD(self)
+load_binint2\xCC128\xCD(self)
+load_binint\xCC128\xCD(self)
+load_binpersid\xCC128\xCD(self)
+load_binput\xCC128\xCD(self)
+load_binstring\xCC128\xCD(self)
+load_binunicode\xCC128\xCD(self)
+load_build\xCC128\xCD(self)
+load_compiled\xCC128\xCD(self, name, filename, file=None)
+load_dict\xCC128\xCD(self)
+load_dup\xCC128\xCD(self)
+load_dynamic\xCC128\xCD(self, name, filename, file=None)
+load_empty_dictionary\xCC128\xCD(self)
+load_empty_list\xCC128\xCD(self)
+load_empty_tuple\xCC128\xCD(self)
+load_eof\xCC128\xCD(self)
+load_ext1\xCC128\xCD(self)
+load_ext2\xCC128\xCD(self)
+load_ext4\xCC128\xCD(self)
+load_false\xCC128\xCD(self)
+load_file\xCC128\xCD(self, pathname)
+load_float\xCC128\xCD(self)
+load_get\xCC128\xCD(self)
+load_global\xCC128\xCD(self)
+load_inst\xCC128\xCD(self)
+load_int\xCC128\xCD(self)
+load_list\xCC128\xCD(self)
+load_long1\xCC128\xCD(self)
+load_long4\xCC128\xCD(self)
+load_long_binget\xCC128\xCD(self)
+load_long_binput\xCC128\xCD(self)
+load_long\xCC128\xCD(self)
+load_mark\xCC128\xCD(self)
+load_module\xCC128\xCD(self, name, stuff)
+load_newobj\xCC128\xCD(self)
+load_none\xCC128\xCD(self)
+load_obj\xCC128\xCD(self)
+load_package\xCC128\xCD(self, name, filename, file=None)
+load_persid\xCC128\xCD(self)
+load_pop_mark\xCC128\xCD(self)
+load_pop\xCC128\xCD(self)
+load_proto\xCC128\xCD(self)
+load_put\xCC128\xCD(self)
+load_reduce\xCC128\xCD(self)
+load_setitems\xCC128\xCD(self)
+load_setitem\xCC128\xCD(self)
+load_short_binstring\xCC128\xCD(self)
+load_source\xCC128\xCD(self, name, filename, file=None)
+load_stop\xCC128\xCD(self)
+load_string\xCC128\xCD(self)
+load_tail\xCC128\xCD(self, q, tail)
+load_true\xCC128\xCD(self)
+load_tuple1\xCC128\xCD(self)
+load_tuple2\xCC128\xCD(self)
+load_tuple3\xCC128\xCD(self)
+load_tuple\xCC128\xCD(self)
+load_unicode\xCC128\xCD(self)
+loads\xCC128\xCD(str)
+load\xCC128\xCD(self, filename=None, ignore_discard=False, ignore_expires=False)
+localcontext\xCC128\xCD(ctx=None)
+localeconv\xCC128\xCD()
+localhost\xCC128\xCD()
+localtrace_count\xCC128\xCD(self, frame, why, arg)
+localtrace_trace_and_count\xCC128\xCD(self, frame, why, arg)
+localtrace_trace\xCC128\xCD(self, frame, why, arg)
+local\xCC128\xCD(self, sys=sys)
+locate\xCC128\xCD(path, forceload=0)
+lock\xCC128\xCD(self)
+log10\xCC128\xCD(self, context=None)
+log_date_time_string\xCC128\xCD(self)
+log_error\xCC128\xCD(self, *args)
+log_info\xCC128\xCD(self, message, type='info')
+log_message\xCC128\xCD(self, format, *args)
+log_request\xCC128\xCD(self, code='-', size='-')
+logb\xCC128\xCD(self, context=None)
+logical_and\xCC128\xCD(self, other, context=None)
+logical_invert\xCC128\xCD(self, context=None)
+logical_or\xCC128\xCD(self, other, context=None)
+logical_xor\xCC128\xCD(self, other, context=None)
+login_cram_md5\xCC128\xCD(self, user, password)
+login\xCC128\xCD(self, user = '', passwd = '', acct = '')
+lognormvariate\xCC128\xCD(self, mu, sigma)
+logout\xCC128\xCD(self)
+long_has_args\xCC128\xCD(opt, longopts)
+longcmd\xCC128\xCD(self, line, file=None)
+longest_run_of_spaces\xCC128\xCD(self)
+lookupmodule\xCC128\xCD(self, filename)
+lookup\xCC128\xCD(name, frame, locals)
+loop\xCC128\xCD(timeout=30.0, use_poll=False, map=None, count=None)
+lower\xCC128\xCD(s)
+lstrip\xCC128\xCD(s)
+lsub\xCC128\xCD(self, directory='""', pattern='*')
+mac_ver\xCC128\xCD(release='',versioninfo=('','',''),machine='')
+machine\xCC128\xCD()
+mail\xCC128\xCD(self,sender,options=[])
+main\xCC128\xCD(args)
+makeSuite\xCC128\xCD(testCaseClass, prefix='test', sortUsing=cmp, suiteClass=TestSuite)
+make_builtin\xCC128\xCD(self)
+make_cookies\xCC128\xCD(self, response, request)
+make_delegate_files\xCC128\xCD(self)
+make_encoding_map\xCC128\xCD(decoding_map)
+make_file\xCC128\xCD(self, binary=None)
+make_identity_dict\xCC128\xCD(rng)
+make_initial_modules\xCC128\xCD(self)
+make_main\xCC128\xCD(self)
+make_osname\xCC128\xCD(self)
+make_sys\xCC128\xCD(self)
+makedev\xCC128\xCD(self, tarinfo, targetpath)
+makedirs\xCC128\xCD(name, mode=0777)
+makedir\xCC128\xCD(self, tarinfo, targetpath)
+makefifo\xCC128\xCD(self, tarinfo, targetpath)
+makefile\xCC128\xCD(self, mode, bufsize=None)
+makefolder\xCC128\xCD(self, name)
+makelink\xCC128\xCD(self, tarinfo, targetpath)
+makename\xCC128\xCD(c, m=object.__module__)
+makepasv\xCC128\xCD(self)
+makepath\xCC128\xCD(*paths)
+makepipeline\xCC128\xCD(self, infile, outfile)
+makeport\xCC128\xCD(self)
+maketrans\xCC128\xCD(fromstr, tostr)
+makeunknown\xCC128\xCD(self, tarinfo, targetpath)
+map_table_b2\xCC128\xCD(a)
+map_table_b3\xCC128\xCD(code)
+marker\xCC128\xCD(self)
+markup\xCC128\xCD(self, text, escape=None, funcs={}, classes={}, methods={})
+master_open\xCC128\xCD()
+match\xCC128\xCD(pattern, string, flags=0)
+max_mag\xCC128\xCD(self, other, context=None)
+maybe\xCC128\xCD(self)
+mboxMessage\xCC1\xCD(_mboxMMDFMessage)
+mbox\xCC1\xCD(_mboxMMDF)
+memoize\xCC128\xCD(self, obj)
+message\xCC128\xCD(self, format, *args)
+mime_decode_header\xCC128\xCD(line)
+mime_decode\xCC128\xCD(line)
+mime_encode_header\xCC128\xCD(line)
+mime_encode\xCC128\xCD(line, header)
+mimify_part\xCC128\xCD(ifile, ofile, is_mime)
+mimify\xCC128\xCD(infile, outfile)
+min_mag\xCC128\xCD(self, other, context=None)
+minus\xCC128\xCD(self, a)
+mk2arg\xCC128\xCD(head, x)
+mkarg\xCC128\xCD(x)
+mkdtemp\xCC128\xCD(suffix="", prefix=template, dir=None)
+mkstemp\xCC128\xCD(suffix="", prefix=template, dir=None, text=False)
+mktemp\xCC128\xCD(suffix="", prefix=template, dir=None)
+mktime_tz\xCC128\xCD(data)
+modified\xCC128\xCD(self)
+modname\xCC128\xCD(path)
+modpkglink\xCC128\xCD(self, (name, path, ispackage, shadowed))
+modulelink\xCC128\xCD(self, object)
+modules_dict\xCC128\xCD(self)
+monthdatescalendar\xCC128\xCD(self, year, month)
+monthdays2calendar\xCC128\xCD(self, year, month)
+monthdayscalendar\xCC128\xCD(self, year, month)
+monthrange\xCC128\xCD(year, month)
+more\xCC128\xCD(self)
+movemessage\xCC128\xCD(self, n, tofolder, ton)
+move\xCC128\xCD(src, dst)
+msgin\xCC128\xCD(self, *args)
+msgout\xCC128\xCD(self, *args)
+mt_interact\xCC128\xCD(self)
+mtime\xCC128\xCD(self)
+multicolumn\xCC128\xCD(self, list, format, cols=4)
+multiply\xCC128\xCD(self, a, b)
+myrights\xCC128\xCD(self, mailbox)
+name_op\xCC128\xCD(name, op)
+namelink\xCC128\xCD(self, name, *dicts)
+namelist\xCC128\xCD(self)
+namespace\xCC128\xCD(self)
+names\xCC128\xCD(self, filename, modulename)
+ndiff\xCC128\xCD(a, b, linejunk=None, charjunk=IS_CHARACTER_JUNK)
+needsquoting\xCC128\xCD(c, quotetabs, header)
+nested\xCC128\xCD(*managers)
+netloc\xCC128\xCD(self)
+new_alignment\xCC128\xCD(self, align)
+new_font\xCC128\xCD(self, font)
+new_margin\xCC128\xCD(self, margin, level)
+new_module\xCC128\xCD(self, name)
+new_spacing\xCC128\xCD(self, spacing)
+new_styles\xCC128\xCD(self, styles)
+newgroups\xCC128\xCD(self, date, time, file=None)
+newnews\xCC128\xCD(self, group, date, time, file=None)
+next_minus\xCC128\xCD(self, context=None)
+next_plus\xCC128\xCD(self, context=None)
+next_toward\xCC128\xCD(self, other, context=None)
+nextfile\xCC128\xCD()
+nextpart\xCC128\xCD(self)
+next\xCC128\xCD(self)
+ngettext\xCC128\xCD(self, msgid1, msgid2, n)
+nlargest\xCC128\xCD(n, iterable)
+nlst\xCC128\xCD(self, *args)
+no_matching_rfc2965\xCC128\xCD(ns_cookie, lookup=lookup)
+nobody_uid\xCC128\xCD()
+node\xCC128\xCD()
+noheaders\xCC128\xCD()
+nolog\xCC128\xCD(*allargs)
+noop\xCC128\xCD(self)
+normalize\xCC128\xCD(self, context=None)
+normalvariate\xCC128\xCD(self, mu, sigma)
+normcase\xCC128\xCD(s)
+normpath\xCC128\xCD(path)
+not_equal_witness\xCC128\xCD(self, other)
+not_less_witness\xCC128\xCD(self, other)
+note\xCC128\xCD(self, *args)
+notifyAll\xCC128\xCD(self)
+notify\xCC128\xCD(self, n=1)
+nsmallest\xCC128\xCD(n, iterable)
+ntransfercmd\xCC128\xCD(self, cmd, rest=None)
+number_class\xCC128\xCD(self, context=None)
+offset_from_tz_string\xCC128\xCD(tz)
+onecmd\xCC128\xCD(self, line)
+onerror\xCC128\xCD(*args)
+open_data\xCC128\xCD(self, url, data=None)
+open_file\xCC128\xCD(self, url)
+open_ftp\xCC128\xCD(self, url)
+open_gopher\xCC128\xCD(self, url)
+open_https\xCC128\xCD(self, url, data=None)
+open_http\xCC128\xCD(self, url, data=None)
+open_local_file\xCC128\xCD(self, req)
+open_new_tab\xCC128\xCD(url)
+open_new\xCC128\xCD(url)
+open_r\xCC128\xCD(self, file)
+open_unknown_proxy\xCC128\xCD(self, proxy, fullurl, data=None)
+open_unknown\xCC128\xCD(self, fullurl, data=None)
+open_w\xCC128\xCD(self, file)
+openfile\xCC128\xCD(self, *x)
+openfolder\xCC128\xCD(self, name)
+openhook\xCC128\xCD(filename, mode)
+openmessage\xCC128\xCD(self, n)
+openpty\xCC128\xCD()
+openrsrc\xCC128\xCD(name, *mode)
+open\xCC128\xCD(file, flag = 'r', mode = 0666)
+options\xCC128\xCD(self, section)
+optionxform\xCC128\xCD(self, optionstr)
+output_charset\xCC128\xCD(self)
+output\xCC128\xCD(self, attrs=None, header = "Set-Cookie:")
+pack_array\xCC128\xCD(self, list, pack_item)
+pack_bool\xCC128\xCD(self, x)
+pack_double\xCC128\xCD(self, x)
+pack_farray\xCC128\xCD(self, n, list, pack_item)
+pack_float\xCC128\xCD(self, x)
+pack_fstring\xCC128\xCD(self, n, s)
+pack_into\xCC128\xCD(fmt, buf, offset, *args)
+pack_list\xCC128\xCD(self, list, pack_item)
+pack_string\xCC128\xCD(self, s)
+pack_uhyper\xCC128\xCD(self, x)
+pack_uint\xCC128\xCD(self, x)
+pack\xCC128\xCD(self)
+pager\xCC128\xCD(text)
+page\xCC128\xCD(self, title, contents)
+params\xCC128\xCD(self)
+paretovariate\xCC128\xCD(self, alpha)
+parse150\xCC128\xCD(resp)
+parse227\xCC128\xCD(resp)
+parse229\xCC128\xCD(resp, peer)
+parse257\xCC128\xCD(resp)
+parseArgs\xCC128\xCD(self, argv)
+parse_args\xCC128\xCD(self, args=None, values=None)
+parse_comment\xCC128\xCD(self, i, report=1)
+parse_declaration\xCC128\xCD(self, i)
+parse_endtag\xCC128\xCD(self, i)
+parse_header\xCC128\xCD(line)
+parse_http_list\xCC128\xCD(s)
+parse_keqv_list\xCC128\xCD(l)
+parse_marked_section\xCC128\xCD(self, i, report=1)
+parse_multipart\xCC128\xCD(fp, pdict)
+parse_ns_headers\xCC128\xCD(ns_headers)
+parse_pi\xCC128\xCD(self, i)
+parse_qsl\xCC128\xCD(qs, keep_blank_values=0, strict_parsing=0)
+parse_qs\xCC128\xCD(qs, keep_blank_values=0, strict_parsing=0)
+parse_request\xCC128\xCD(self)
+parse_starttag\xCC128\xCD(self, i)
+parseaddr\xCC128\xCD(address)
+parseargs\xCC128\xCD()
+parsedate_tz\xCC128\xCD(data)
+parsedate\xCC128\xCD(data)
+parsefield\xCC128\xCD(line, i, n)
+parseline\xCC128\xCD(self, line)
+parseplist\xCC128\xCD(self)
+parsesequence\xCC128\xCD(self, seq)
+parsetype\xCC128\xCD(self)
+parse\xCC128\xCD(fp=None, environ=os.environ, keep_blank_values=0, strict_parsing=0)
+pars\xCC128\xCD(self)
+partial\xCC128\xCD(self, message_num, message_part, start, length)
+partition\xCC128\xCD(self, sep)
+pass_\xCC128\xCD(self, pswd)
+password\xCC128\xCD(self)
+path_exists\xCC128\xCD(self, x)
+path_isabs\xCC128\xCD(self, x)
+path_isdir\xCC128\xCD(self, x)
+path_isfile\xCC128\xCD(self, x)
+path_islink\xCC128\xCD(self, x)
+path_join\xCC128\xCD(self, x, y)
+path_return_ok\xCC128\xCD(self, path, request)
+path_split\xCC128\xCD(self, x)
+path_to_datatype_name\xCC128\xCD(path)
+path_to_selector\xCC128\xCD(path)
+pathdirs\xCC128\xCD()
+pathname2url\xCC128\xCD(p)
+path\xCC128\xCD(self)
+pattern\xCC128\xCD(self, format)
+persistent_id\xCC128\xCD(self, obj)
+pformat\xCC128\xCD(object, indent=1, width=80, depth=None)
+phase0\xCC128\xCD(self)
+phase1\xCC128\xCD(self)
+phase2\xCC128\xCD(self)
+phase3\xCC128\xCD(self)
+phase4_closure\xCC128\xCD(self)
+phase4\xCC128\xCD(self)
+pickle_complex\xCC128\xCD(c)
+pickle\xCC128\xCD(ob_type, pickle_function, constructor_ob=None)
+pickline\xCC128\xCD(file, key, casefold = 1)
+pipepager\xCC128\xCD(text, cmd)
+pipethrough\xCC128\xCD(input, command, output)
+pipeto\xCC128\xCD(input, command)
+plainpager\xCC128\xCD(text)
+plain\xCC128\xCD(text)
+platform\xCC128\xCD(aliased=0, terse=0)
+plus\xCC128\xCD(self, a)
+poll2\xCC128\xCD(timeout=0.0, map=None)
+poll\xCC128\xCD(timeout=0.0, map=None)
+pop_alignment\xCC128\xCD(self)
+pop_font\xCC128\xCD(self)
+pop_margin\xCC128\xCD(self)
+pop_source\xCC128\xCD(self)
+pop_style\xCC128\xCD(self, n=1)
+popen2\xCC128\xCD(cmd, mode="t", bufsize=-1)
+popen3\xCC128\xCD(cmd, mode="t", bufsize=-1)
+popen4\xCC128\xCD(cmd, mode="t", bufsize=-1)
+popen\xCC128\xCD(cmd, mode='r', bufsize=None)
+popitem\xCC128\xCD(self)
+popleft\xCC128\xCD(self)
+port\xCC128\xCD(self)
+post_mortem\xCC128\xCD(t)
+postcmd\xCC128\xCD(self, stop, line)
+postloop\xCC128\xCD(self)
+post\xCC128\xCD(self, f)
+power\xCC128\xCD(self, a, b, modulo=None)
+pprint\xCC128\xCD(object, stream=None, indent=1, width=80, depth=None)
+precmd\xCC128\xCD(self, line)
+predicate\xCC128\xCD(x)
+preformat\xCC128\xCD(self, text)
+preloop\xCC128\xCD(self)
+prepend\xCC128\xCD(self, cmd, kind)
+previous\xCC128\xCD(self)
+printErrorList\xCC128\xCD(self, flavour, errors)
+printErrors\xCC128\xCD(self)
+print_arguments\xCC128\xCD()
+print_directory\xCC128\xCD()
+print_environ_usage\xCC128\xCD()
+print_environ\xCC128\xCD(environ=os.environ)
+print_exception\xCC128\xCD(type=None, value=None, tb=None, limit=None)
+print_exc\xCC128\xCD(self, file=None)
+print_form\xCC128\xCD(form)
+print_help\xCC128\xCD(self, file=None)
+print_last\xCC128\xCD(limit=None, file=None)
+print_line\xCC128\xCD(line)
+print_list\xCC128\xCD(extracted_list, file=None)
+print_log\xCC128\xCD(self)
+print_stack_entry\xCC128\xCD(self, frame_lineno, prompt_prefix=line_prefix)
+print_stack_trace\xCC128\xCD(self)
+print_stack\xCC128\xCD(f=None, limit=None, file=None)
+print_stats\xCC128\xCD(self, sort=-1)
+print_tb\xCC128\xCD(tb, limit=None, file=None)
+print_topics\xCC128\xCD(self, header, cmds, cmdlen, maxcol)
+print_usage\xCC128\xCD(self, file=None)
+print_version\xCC128\xCD(self, file=None)
+printdir\xCC128\xCD(self)
+printhdr\xCC128\xCD(file)
+printtoken\xCC128\xCD(type, token, (srow, scol), (erow, ecol), line)
+prmonth\xCC128\xCD(self, theyear, themonth, w=0, l=0)
+proc_builtin\xCC128\xCD(self, tarinfo)
+proc_gnulong\xCC128\xCD(self, tarinfo)
+proc_member\xCC128\xCD(self, tarinfo)
+proc_sparse\xCC128\xCD(self, tarinfo)
+process_message\xCC128\xCD(self, peer, mailfrom, rcpttos, data)
+process_rawq\xCC128\xCD(self)
+process_request_thread\xCC128\xCD(self, request, client_address)
+process_request\xCC128\xCD(self, request, client_address)
+process_tokens\xCC128\xCD(tokens)
+processor\xCC128\xCD()
+process\xCC128\xCD(self, data)
+prompt_user_passwd\xCC128\xCD(self, host, realm)
+prompt\xCC128\xCD(prompt)
+proxy_bypass\xCC128\xCD(x)
+proxy_open\xCC128\xCD(self, req, proxy, type)
+proxyauth\xCC128\xCD(self, user)
+prweek\xCC128\xCD(self, theweek, width)
+pryear\xCC128\xCD(self, theyear, w=0, l=0, c=6, m=3)
+purge\xCC128\xCD()
+push_alignment\xCC128\xCD(self, align)
+push_font\xCC128\xCD(self, x)
+push_margin\xCC128\xCD(self, margin)
+push_source\xCC128\xCD(self, newstream, newfile=None)
+push_style\xCC128\xCD(self, *styles)
+push_token\xCC128\xCD(self, tok)
+push_with_producer\xCC128\xCD(self, producer)
+push\xCC128\xCD(self, data)
+put_nowait\xCC128\xCD(self, item)
+putcmd\xCC128\xCD(self, line)
+putheader\xCC128\xCD(self, header, value)
+putline\xCC128\xCD(self, line)
+putrequest\xCC128\xCD(self, method, url, skip_host=0, skip_accept_encoding=0)
+putsequences\xCC128\xCD(self, sequences)
+py_suffix_importer\xCC128\xCD(filename, finfo, fqname)
+python_build\xCC128\xCD()
+python_compiler\xCC128\xCD()
+python_version_tuple\xCC128\xCD()
+python_version\xCC128\xCD()
+qsize\xCC128\xCD(self)
+quantize\xCC128\xCD(self, exp, rounding=None, context=None, watchexp=True)
+query\xCC128\xCD(self)
+quick_ratio\xCC128\xCD(self)
+quit\xCC128\xCD(self)
+quote_plus\xCC128\xCD(s, safe = '')
+quoteaddr\xCC128\xCD(addr)
+quotedata\xCC128\xCD(data)
+quote\xCC128\xCD(file)
+r_eval\xCC128\xCD(self, code)
+r_exc_info\xCC128\xCD(self)
+r_execfile\xCC128\xCD(self, file)
+r_exec\xCC128\xCD(self, code)
+r_import\xCC128\xCD(self, mname, globals={}, locals={}, fromlist=[])
+r_open\xCC128\xCD(self, file, mode='r', buf=-1)
+r_reload\xCC128\xCD(self, m)
+r_unload\xCC128\xCD(self, m)
+radix\xCC128\xCD(self)
+randint\xCC128\xCD(self, a, b)
+randombytes\xCC128\xCD(n)
+random\xCC128\xCD(self)
+ratio\xCC128\xCD(self)
+raw_input\xCC128\xCD(self, prompt="")
+rawq_getchar\xCC128\xCD(self)
+rcpt\xCC128\xCD(self,recip,options=[])
+reach\xCC128\xCD(h)
+read32\xCC128\xCD(input)
+readPlistFromResource\xCC128\xCD(path, restype='plst', resid=0)
+readPlistFromString\xCC128\xCD(data)
+readPlist\xCC128\xCD(pathOrFile)
+read_all\xCC128\xCD(self)
+read_binary\xCC128\xCD(self)
+read_code\xCC128\xCD(stream)
+read_decimalnl_long\xCC128\xCD(f)
+read_decimalnl_short\xCC128\xCD(f)
+read_eager\xCC128\xCD(self)
+read_file\xCC128\xCD(self, filename, mode="careful")
+read_float8\xCC128\xCD(f)
+read_floatnl\xCC128\xCD(f)
+read_int4\xCC128\xCD(f)
+read_lazy\xCC128\xCD(self)
+read_lines_to_eof\xCC128\xCD(self)
+read_lines_to_outerboundary\xCC128\xCD(self)
+read_lines\xCC128\xCD(self)
+read_long1\xCC128\xCD(f)
+read_long4\xCC128\xCD(f)
+read_mime_types\xCC128\xCD(file)
+read_module\xCC128\xCD(self, modname, mode="careful")
+read_multi\xCC128\xCD(self, environ, keep_blank_values, strict_parsing)
+read_rsrc\xCC128\xCD(self, *n)
+read_sb_data\xCC128\xCD(self)
+read_single\xCC128\xCD(self)
+read_some\xCC128\xCD(self)
+read_string1\xCC128\xCD(f)
+read_string4\xCC128\xCD(f)
+read_stringnl_noescape_pair\xCC128\xCD(f)
+read_stringnl_noescape\xCC128\xCD(f)
+read_stringnl\xCC128\xCD(f, decode=True, stripquotes=True)
+read_token\xCC128\xCD(self)
+read_uint1\xCC128\xCD(f)
+read_uint2\xCC128\xCD(f)
+read_unicodestring4\xCC128\xCD(f)
+read_unicodestringnl\xCC128\xCD(f)
+read_until\xCC128\xCD(self, match, timeout=None)
+read_urlencoded\xCC128\xCD(self)
+read_very_eager\xCC128\xCD(self)
+read_very_lazy\xCC128\xCD(self)
+readable\xCC128\xCD(self)
+reader\xCC128\xCD(lnum=[lnum])
+readfp\xCC128\xCD(self, fp, filename=None)
+readframes\xCC128\xCD(self, nframes)
+readheaders\xCC128\xCD(self)
+readlines\xCC128\xCD(self, sizehint=None, keepends=True)
+readline\xCC128\xCD(self, size=None, keepends=True)
+readmailcapfile\xCC128\xCD(fp)
+readnormal\xCC128\xCD(self, size)
+readonly\xCC1\xCD(abort)
+readsparsesection\xCC128\xCD(self, size)
+readsparse\xCC128\xCD(self, size)
+readwrite\xCC128\xCD(obj, flags)
+ready\xCC128\xCD(self, server)
+read\xCC128\xCD(obj)
+real_quick_ratio\xCC128\xCD(self)
+realpath\xCC128\xCD(filename)
+recent\xCC128\xCD(self)
+record_sub_info\xCC128\xCD(match_object,sub_info=sub_info)
+recv\xCC128\xCD(self, buffer_size)
+redirect_internal\xCC128\xCD(self, url, fp, errcode, errmsg, headers, data)
+redirect_request\xCC128\xCD(self, req, fp, code, msg, headers, newurl)
+reduce_uri\xCC128\xCD(self, uri, default_port=True)
+refilemessages\xCC128\xCD(self, list, tofolder, keepsequences=0)
+refill_buffer\xCC128\xCD(self)
+register_X_browsers\xCC128\xCD()
+register_function\xCC128\xCD(self, function, name = None)
+register_instance\xCC128\xCD(self, instance, allow_dotted_names=False)
+register_introspection_functions\xCC128\xCD(self)
+register_multicall_functions\xCC128\xCD(self)
+register\xCC128\xCD(typ, func=None)
+reindent\xCC128\xCD(src, indent)
+release\xCC128\xCD()
+reload\xCC128\xCD(self, module, path = None)
+remainder_near\xCC128\xCD(self, other, context=None)
+remainder\xCC128\xCD(self, a, b)
+remove_duplicates\xCC128\xCD(lst)
+remove_extension\xCC128\xCD(module, name, code)
+remove_flag\xCC128\xCD(self, flag)
+remove_folder\xCC128\xCD(self, folder)
+remove_label\xCC128\xCD(self, label)
+remove_option\xCC128\xCD(self, section, option)
+remove_section\xCC128\xCD(self, section)
+remove_sequence\xCC128\xCD(self, sequence)
+removedirs\xCC128\xCD(name)
+removeduppaths\xCC128\xCD()
+removefromallsequences\xCC128\xCD(self, list)
+removemessages\xCC128\xCD(self, list)
+remove\xCC128\xCD(self, key)
+renames\xCC128\xCD(old, new)
+rename\xCC128\xCD(self, fromname, toname)
+repeat\xCC128\xCD(self, repeat=default_repeat, number=default_number)
+replace_paths_in_code\xCC128\xCD(self, co)
+replace\xCC128\xCD(text, *pairs)
+repl\xCC128\xCD(x)
+report_404\xCC128\xCD(self)
+report_full_closure\xCC128\xCD(self)
+report_partial_closure\xCC128\xCD(self)
+reporthook\xCC128\xCD(blocknum, blocksize, totalsize)
+report\xCC128\xCD(self)
+repr1\xCC128\xCD(self, x, level)
+repr_array\xCC128\xCD(self, x, level)
+repr_deque\xCC128\xCD(self, x, level)
+repr_dict\xCC128\xCD(self, x, level)
+repr_frozenset\xCC128\xCD(self, x, level)
+repr_instance\xCC128\xCD(self, x, level)
+repr_list\xCC128\xCD(self, x, level)
+repr_long\xCC128\xCD(self, x, level)
+repr_set\xCC128\xCD(self, x, level)
+repr_string\xCC128\xCD(self, x, level)
+repr_str\xCC128\xCD(self, x, level)
+repr_tuple\xCC128\xCD(self, x, level)
+repr\xCC128\xCD(self, object)
+request_host\xCC128\xCD(request)
+request_path\xCC128\xCD(request)
+request_port\xCC128\xCD(request)
+request\xCC128\xCD(self, method, url, body=None, headers={})
+reset_files\xCC128\xCD(self)
+reset_retry_count\xCC128\xCD(self)
+resetbuffer\xCC128\xCD(self)
+resetlocale\xCC128\xCD(category=LC_ALL)
+resetwarnings\xCC128\xCD()
+reset\xCC128\xCD(self)
+resolve_dotted_attribute\xCC128\xCD(obj, attr, allow_dotted_names=True)
+resolve\xCC128\xCD(thing, forceload=0)
+response\xCC128\xCD(self, code)
+restore_files\xCC128\xCD(self)
+restore\xCC128\xCD(delta, which)
+results\xCC128\xCD(self)
+retrbinary\xCC128\xCD(self, cmd, callback, blocksize=8192, rest=None)
+retrfile\xCC128\xCD(self, file, type)
+retrieve\xCC128\xCD(self, url, filename=None, reporthook=None, data=None)
+retrlines\xCC128\xCD(self, cmd, callback = None)
+retry_http_basic_auth\xCC128\xCD(self, host, req, realm)
+retry_http_digest_auth\xCC128\xCD(self, req, auth)
+retry_https_basic_auth\xCC128\xCD(self, url, realm, data=None)
+retry_proxy_http_basic_auth\xCC128\xCD(self, url, realm, data=None)
+retry_proxy_https_basic_auth\xCC128\xCD(self, url, realm, data=None)
+retr\xCC128\xCD(self, which)
+return_ok_domain\xCC128\xCD(self, cookie, request)
+return_ok_expires\xCC128\xCD(self, cookie, request)
+return_ok_port\xCC128\xCD(self, cookie, request)
+return_ok_secure\xCC128\xCD(self, cookie, request)
+return_ok_verifiability\xCC128\xCD(self, cookie, request)
+return_ok_version\xCC128\xCD(self, cookie, request)
+return_ok\xCC128\xCD(self, cookie, request)
+reverse\xCC128\xCD(self)
+rewindbody\xCC128\xCD(self)
+rewind\xCC128\xCD(self)
+rfind\xCC128\xCD(s, *args)
+rgb_to_hls\xCC128\xCD(r, g, b)
+rgb_to_hsv\xCC128\xCD(r, g, b)
+rgb_to_yiq\xCC128\xCD(r, g, b)
+rindex\xCC128\xCD(s, *args)
+rjust\xCC128\xCD(s, width)
+rmtree\xCC128\xCD(path, ignore_errors=False, onerror=None)
+rotate\xCC128\xCD(self, other, context=None)
+roundfrac\xCC128\xCD(intpart, fraction, digs)
+rpartition\xCC128\xCD(self, sep)
+rpop\xCC128\xCD(self, user)
+rset\xCC128\xCD(self)
+rsplit\xCC128\xCD(s, sep=None, maxsplit=-1)
+rstrip\xCC128\xCD(s)
+runTests\xCC128\xCD(self)
+runTest\xCC128\xCD(self)
+run_cgi\xCC128\xCD(self)
+run_script\xCC128\xCD(self, pathname)
+runcall\xCC128\xCD(self, func, *args, **kwds)
+runcode\xCC128\xCD(self, code)
+runctx\xCC128\xCD(self, cmd, globals, locals)
+runeval\xCC128\xCD(self, expr, globals=None, locals=None)
+runfunc\xCC128\xCD(self, func, *args, **kw)
+runsource\xCC128\xCD(self, source, filename="<input>", symbol="single")
+s_apply\xCC128\xCD(self, func, args=(), kw={})
+s_eval\xCC128\xCD(self, *args)
+s_execfile\xCC128\xCD(self, *args)
+s_exec\xCC128\xCD(self, *args)
+s_import\xCC128\xCD(self, *args)
+s_reload\xCC128\xCD(self, *args)
+s_unload\xCC128\xCD(self, *args)
+safe_substitute\xCC128\xCD(self, *args, **kws)
+safeimport\xCC128\xCD(path, forceload=0, cache={})
+saferepr\xCC128\xCD(object)
+same_quantum\xCC128\xCD(self, other)
+samefile\xCC128\xCD(f1, f2)
+sameopenfile\xCC128\xCD(fp1, fp2)
+samestat\xCC128\xCD(s1, s2)
+sample\xCC128\xCD(self, population, k)
+sanitize\xCC128\xCD(self, s)
+save_bgn\xCC128\xCD(self)
+save_bool\xCC128\xCD(self, obj)
+save_dict\xCC128\xCD(self, obj)
+save_empty_tuple\xCC128\xCD(self, obj)
+save_end\xCC128\xCD(self)
+save_files\xCC128\xCD(self)
+save_float\xCC128\xCD(self, obj, pack=struct.pack)
+save_global\xCC128\xCD(self, obj, name=None, pack=struct.pack)
+save_inst\xCC128\xCD(self, obj)
+save_int\xCC128\xCD(self, obj, pack=struct.pack)
+save_list\xCC128\xCD(self, obj)
+save_long\xCC128\xCD(self, obj, pack=struct.pack)
+save_none\xCC128\xCD(self, obj)
+save_pers\xCC128\xCD(self, pid)
+save_string\xCC128\xCD(self, obj, pack=struct.pack)
+save_tuple\xCC128\xCD(self, obj)
+save_unicode\xCC128\xCD(self, obj, pack=struct.pack)
+save\xCC128\xCD(self, filename=None, ignore_discard=False, ignore_expires=False)
+scaleb\xCC128\xCD(self, other, context=None)
+scan_code\xCC128\xCD(self, co, m)
+scanvars\xCC128\xCD(reader, frame, locals)
+scan\xCC128\xCD(self, string)
+scheme\xCC128\xCD(self)
+search\xCC128\xCD(self, charset, *criteria)
+section_divider\xCC128\xCD(self, str)
+sections\xCC128\xCD(self)
+section\xCC128\xCD(self, title, contents)
+seed\xCC128\xCD(self, a=None)
+seek\xCC128\xCD(self, pos, whence=0)
+seen\xCC128\xCD(p, m={})
+select\xCC128\xCD(self, mailbox='INBOX', readonly=False)
+send_document\xCC128\xCD(self, title, contents)
+send_error\xCC128\xCD(self, code, message=None)
+send_flowing_data\xCC128\xCD(self, data)
+send_header\xCC128\xCD(self, keyword, value)
+send_head\xCC128\xCD(self)
+send_hor_rule\xCC128\xCD(self, *args, **kw)
+send_label_data\xCC128\xCD(self, data)
+send_line_break\xCC128\xCD(self)
+send_literal_data\xCC128\xCD(self, data)
+send_paragraph\xCC128\xCD(self, blankline)
+send_query\xCC128\xCD(selector, query, host, port = 0)
+send_response\xCC128\xCD(self, code, message=None)
+send_selector\xCC128\xCD(selector, host, port = 0)
+sendcmd\xCC128\xCD(self, cmd)
+sendeprt\xCC128\xCD(self, host, port)
+sendport\xCC128\xCD(self, host, port)
+send\xCC128\xCD(self, data)
+serve_forever\xCC128\xCD(self)
+serve_until_quit\xCC128\xCD(self)
+server_activate\xCC128\xCD(self)
+server_bind\xCC128\xCD(self)
+server_close\xCC128\xCD(self)
+serve\xCC128\xCD(port, callback=None, completer=None)
+setBEGINLIBPATH\xCC128\xCD()
+setDaemon\xCC128\xCD(self, daemonic)
+setMaxConns\xCC128\xCD(self, m)
+setName\xCC128\xCD(self, name)
+setTimeout\xCC128\xCD(self, t)
+setUp\xCC128\xCD(self)
+set_allowed_domains\xCC128\xCD(self, allowed_domains)
+set_blocked_domains\xCC128\xCD(self, blocked_domains)
+set_cdata_mode\xCC128\xCD(self)
+set_conflict_handler\xCC128\xCD(self, handler)
+set_continue\xCC128\xCD(self)
+set_cookie_if_ok\xCC128\xCD(self, cookie, request)
+set_cookie\xCC128\xCD(self, cookie)
+set_creator_type\xCC128\xCD(file)
+set_date\xCC128\xCD(self, date)
+set_debuglevel\xCC128\xCD(self, level)
+set_defaults\xCC128\xCD(self, **kwargs)
+set_default\xCC128\xCD(self, dest, value)
+set_description\xCC128\xCD(self, description)
+set_files\xCC128\xCD(self)
+set_file\xCC128\xCD(self, fd)
+set_flags\xCC128\xCD(self, flags)
+set_from\xCC128\xCD(self, from_, time_=None)
+set_hooks\xCC128\xCD(self, hooks)
+set_http_debuglevel\xCC128\xCD(self, level)
+set_info\xCC128\xCD(self, info)
+set_labels\xCC128\xCD(self, labels)
+set_loader\xCC128\xCD(self, loader)
+set_location\xCC128\xCD(self, key)
+set_long_opt_delimiter\xCC128\xCD(self, delim)
+set_next\xCC128\xCD(self, frame)
+set_nonstandard_attr\xCC128\xCD(self, name, value)
+set_ok_domain\xCC128\xCD(self, cookie, request)
+set_ok_name\xCC128\xCD(self, cookie, request)
+set_ok_path\xCC128\xCD(self, cookie, request)
+set_ok_port\xCC128\xCD(self, cookie, request)
+set_ok_verifiability\xCC128\xCD(self, cookie, request)
+set_ok_version\xCC128\xCD(self, cookie, request)
+set_ok\xCC128\xCD(self, cookie, request)
+set_option_negotiation_callback\xCC128\xCD(self, callback)
+set_output_charset\xCC128\xCD(self, charset)
+set_parser\xCC128\xCD(self, parser)
+set_pasv\xCC128\xCD(self, val)
+set_policy\xCC128\xCD(self, policy)
+set_position\xCC128\xCD(self, position)
+set_process_default_values\xCC128\xCD(self, process)
+set_proxy\xCC128\xCD(self, host, type)
+set_quit\xCC128\xCD(self)
+set_return\xCC128\xCD(self, frame)
+set_reuse_addr\xCC128\xCD(self)
+set_rexec\xCC128\xCD(self, rexec)
+set_seq1\xCC128\xCD(self, a)
+set_seq2\xCC128\xCD(self, b)
+set_seqs\xCC128\xCD(self, a, b)
+set_sequences\xCC128\xCD(self, sequences)
+set_server_documentation\xCC128\xCD(self, server_documentation)
+set_server_name\xCC128\xCD(self, server_name)
+set_server_title\xCC128\xCD(self, server_title)
+set_short_opt_delimiter\xCC128\xCD(self, delim)
+set_socket\xCC128\xCD(self, sock, map=None)
+set_spacing\xCC128\xCD(self, spacing)
+set_step\xCC128\xCD(self)
+set_subdir\xCC128\xCD(self, subdir)
+set_terminator\xCC128\xCD(self, term)
+set_title\xCC128\xCD(self, title)
+set_trace\xCC128\xCD(self, frame=None)
+set_trusted_path\xCC128\xCD(self)
+set_url\xCC128\xCD(self, url)
+set_usage\xCC128\xCD(self, usage)
+set_verbose\xCC128\xCD(self, verbose)
+set_visible\xCC128\xCD(self, visible)
+setacl\xCC128\xCD(self, mailbox, who, what)
+setannotation\xCC128\xCD(self, *args)
+setcbreak\xCC128\xCD(fd, when=TCSAFLUSH)
+setcomptype\xCC128\xCD(self, type, name)
+setcontext\xCC128\xCD(context)
+setcopyright\xCC128\xCD()
+setcurrent\xCC128\xCD(self, n)
+setdefault\xCC128\xCD(self, name, default="")
+setencoding\xCC128\xCD()
+setfirstweekday\xCC128\xCD(self, firstweekday)
+setframerate\xCC128\xCD(self, framerate)
+sethelper\xCC128\xCD()
+setlast\xCC128\xCD(self, last)
+setlocale\xCC128\xCD(category, value=None)
+setmark\xCC128\xCD(self, id, pos, name)
+setnchannels\xCC128\xCD(self, nchannels)
+setnframes\xCC128\xCD(self, nframes)
+setoutrate\xCC128\xCD(self, rate)
+setparams\xCC128\xCD(self, (nchannels, sampwidth, framerate, nframes, comptype, compname))
+setpos\xCC128\xCD(self, pos)
+setprofile\xCC128\xCD(func)
+setquit\xCC128\xCD()
+setquota\xCC128\xCD(self, root, limits)
+setraw\xCC128\xCD(fd, when=TCSAFLUSH)
+setsampwidth\xCC128\xCD(self, width)
+setstate\xCC128\xCD(self, state)
+settrace\xCC128\xCD(func)
+setup\xCC128\xCD(self, f, t)
+shift\xCC128\xCD(self, other, context=None)
+shortDescription\xCC128\xCD(self)
+short_has_arg\xCC128\xCD(opt, shortopts)
+shortcmd\xCC128\xCD(self, line)
+showsyntaxerror\xCC128\xCD(self, filename=None)
+showtopic\xCC128\xCD(self, topic)
+showtraceback\xCC128\xCD(self)
+showwarning\xCC128\xCD(message, category, filename, lineno, file=None)
+show\xCC128\xCD(caps)
+shuffle\xCC128\xCD(self, x, random=None, int=int)
+shutdown\xCC128\xCD(self)
+simpleElement\xCC128\xCD(self, element, value=None)
+simplefilter\xCC128\xCD(action, category=Warning, lineno=0, append=0)
+simplegeneric\xCC128\xCD(func)
+size\xCC128\xCD(self, filename)
+skip_lines\xCC128\xCD(self)
+skip\xCC128\xCD(self)
+slave_open\xCC128\xCD(tty_name)
+slave\xCC128\xCD(self)
+small\xCC128\xCD(text)
+smtp_DATA\xCC128\xCD(self, arg)
+smtp_HELO\xCC128\xCD(self, arg)
+smtp_MAIL\xCC128\xCD(self, arg)
+smtp_NOOP\xCC128\xCD(self, arg)
+smtp_QUIT\xCC128\xCD(self, arg)
+smtp_RCPT\xCC128\xCD(self, arg)
+smtp_RSET\xCC128\xCD(self, arg)
+snapshot_stats\xCC128\xCD(self)
+sniff\xCC128\xCD(self, sample, delimiters=None)
+sock_avail\xCC128\xCD(self)
+socket\xCC128\xCD(self)
+softspace\xCC128\xCD(file, newvalue)
+some_generator\xCC128\xCD(<arguments>)
+sort\xCC128\xCD(self, sort_criteria, charset, *search_criteria)
+source_synopsis\xCC128\xCD(file)
+sourcehook\xCC128\xCD(self, newfile)
+spawnle\xCC128\xCD(mode, file, *args)
+spawnlpe\xCC128\xCD(mode, file, *args)
+spawnlp\xCC128\xCD(mode, file, *args)
+spawnl\xCC128\xCD(mode, file, *args)
+spawnve\xCC128\xCD(mode, file, args, env)
+spawnvpe\xCC128\xCD(mode, file, args, env)
+spawnvp\xCC128\xCD(mode, file, args)
+spawnv\xCC128\xCD(mode, file, args)
+spawn\xCC128\xCD(argv, master_read=_read, stdin_read=_read)
+spilldata\xCC128\xCD(msg, attrs, predicate)
+spilldescriptors\xCC128\xCD(msg, attrs, predicate)
+spill\xCC128\xCD(msg, attrs, predicate)
+split_header_words\xCC128\xCD(header_values)
+splitattr\xCC128\xCD(url)
+splitdoc\xCC128\xCD(doc)
+splitdrive\xCC128\xCD(p)
+splitext\xCC128\xCD(p)
+splitgophertype\xCC128\xCD(selector)
+splithost\xCC128\xCD(url)
+splitlines\xCC128\xCD(self, keepends=0)
+splitnport\xCC128\xCD(host, defport=-1)
+splitpasswd\xCC128\xCD(user)
+splitport\xCC128\xCD(host)
+splitquery\xCC128\xCD(url)
+splittag\xCC128\xCD(url)
+splittype\xCC128\xCD(url)
+splitunc\xCC128\xCD(p)
+splituser\xCC128\xCD(host)
+splitvalue\xCC128\xCD(attr)
+split\xCC128\xCD(p)
+sqrt\xCC128\xCD(self, context=None)
+stack\xCC128\xCD(context=1)
+standard_b64decode\xCC128\xCD(s)
+standard_b64encode\xCC128\xCD(s)
+startTest\xCC128\xCD(self, test)
+start_address\xCC128\xCD(self, attrs)
+start_a\xCC128\xCD(self, attrs)
+start_blockquote\xCC128\xCD(self, attrs)
+start_body\xCC128\xCD(self, attrs)
+start_b\xCC128\xCD(self, attrs)
+start_cite\xCC128\xCD(self, attrs)
+start_code\xCC128\xCD(self, attrs)
+start_dir\xCC128\xCD(self, attrs)
+start_dl\xCC128\xCD(self, attrs)
+start_em\xCC128\xCD(self, attrs)
+start_h1\xCC128\xCD(self, attrs)
+start_h2\xCC128\xCD(self, attrs)
+start_h3\xCC128\xCD(self, attrs)
+start_h4\xCC128\xCD(self, attrs)
+start_h5\xCC128\xCD(self, attrs)
+start_h6\xCC128\xCD(self, attrs)
+start_head\xCC128\xCD(self, attrs)
+start_html\xCC128\xCD(self, attrs)
+start_i\xCC128\xCD(self, attrs)
+start_kbd\xCC128\xCD(self, attrs)
+start_listing\xCC128\xCD(self, attrs)
+start_menu\xCC128\xCD(self, attrs)
+start_ol\xCC128\xCD(self, attrs)
+start_pre\xCC128\xCD(self, attrs)
+start_samp\xCC128\xCD(self, attrs)
+start_strong\xCC128\xCD(self, attrs)
+start_title\xCC128\xCD(self, attrs)
+start_tt\xCC128\xCD(self, attrs)
+start_ul\xCC128\xCD(self, attrs)
+start_var\xCC128\xCD(self, attrs)
+start_xmp\xCC128\xCD(self, attrs)
+startbody\xCC128\xCD(self, ctype, plist=[], prefix=1)
+startmultipartbody\xCC128\xCD(self, subtype, boundary=None, plist=[], prefix=1)
+startswith\xCC128\xCD(self, prefix, start=0, end=sys.maxint)
+starttls\xCC128\xCD(self, keyfile = None, certfile = None)
+start\xCC128\xCD(self)
+statcmd\xCC128\xCD(self, line)
+statparse\xCC128\xCD(self, resp)
+status\xCC128\xCD(self, mailbox, names)
+stat\xCC128\xCD(self, id)
+stopTest\xCC128\xCD(self, test)
+stop_here\xCC128\xCD(self, frame)
+stopped\xCC128\xCD()
+stop\xCC128\xCD(self)
+storbinary\xCC128\xCD(self, cmd, fp, blocksize=8192)
+store_option_strings\xCC128\xCD(self, parser)
+store\xCC128\xCD(self, message_set, command, flags)
+storlines\xCC128\xCD(self, cmd, fp)
+strcoll\xCC128\xCD(a,b)
+stripid\xCC128\xCD(text)
+stripped\xCC128\xCD(self, key)
+strip\xCC128\xCD(s)
+strong\xCC128\xCD(text)
+strptime\xCC128\xCD(data_string, format="%a %b %d %H:%M:%S %Y")
+strseq\xCC128\xCD(object, convert, join=joinseq)
+strxfrm\xCC128\xCD(s)
+subn\xCC128\xCD(pattern, repl, string, count=0)
+subscribe\xCC128\xCD(self, mailbox)
+substitute\xCC128\xCD(self, *args, **kws)
+subst\xCC128\xCD(field, MIMEtype, filename, plist=[])
+subtract\xCC128\xCD(self, a, b)
+swapcase\xCC128\xCD(s)
+symmetric_difference_update\xCC128\xCD(self, other)
+symmetric_difference\xCC128\xCD(self, other)
+symtable\xCC128\xCD(code, filename, compile_type)
+sync\xCC128\xCD(self)
+synopsis\xCC128\xCD(filename, cache={})
+system_alias\xCC128\xCD(system,release,version)
+system_listMethods\xCC128\xCD(self)
+system_methodHelp\xCC128\xCD(self, method_name)
+system_methodSignature\xCC128\xCD(self, method_name)
+system_multicall\xCC128\xCD(self, call_list)
+system\xCC128\xCD()
+take_action\xCC128\xCD(self, action, dest, opt, value, values, parser)
+takes_value\xCC128\xCD(self)
+taropen\xCC128\xCD(cls, name, mode="r", fileobj=None)
+task_done\xCC128\xCD(self)
+tb_lineno\xCC128\xCD(tb)
+tearDown\xCC128\xCD(self)
+tell\xCC128\xCD(self)
+tempfilepager\xCC128\xCD(text, cmd)
+template\xCC128\xCD(pattern, flags=0)
+test1\xCC128\xCD()
+testAdd\xCC128\xCD(self)
+testMultiply\xCC128\xCD(self)
+test_8svx\xCC128\xCD(h, f)
+test_aifc\xCC128\xCD(h, f)
+test_au\xCC128\xCD(h, f)
+test_bmp\xCC128\xCD(h, f)
+test_exif\xCC128\xCD(h, f)
+test_gif\xCC128\xCD(h, f)
+test_hcom\xCC128\xCD(h, f)
+test_jpeg\xCC128\xCD(h, f)
+test_pbm\xCC128\xCD(h, f)
+test_pgm\xCC128\xCD(h, f)
+test_png\xCC128\xCD(h, f)
+test_ppm\xCC128\xCD(h, f)
+test_rast\xCC128\xCD(h, f)
+test_rgb\xCC128\xCD(h, f)
+test_sndr\xCC128\xCD(h, f)
+test_sndt\xCC128\xCD(h, f)
+test_tiff\xCC128\xCD(h, f)
+test_voc\xCC128\xCD(h, f)
+test_wav\xCC128\xCD(h, f)
+test_xbm\xCC128\xCD(h, f)
+testall\xCC128\xCD(list, recursive, toplevel)
+testandset\xCC128\xCD(self)
+testzip\xCC128\xCD(self)
+test\xCC128\xCD(fn = None)
+textdomain\xCC128\xCD(domain=None)
+text\xCC128\xCD((etype, evalue, etb), context=5)
+thishost\xCC128\xCD()
+thread\xCC128\xCD(self, threading_algorithm, charset, *search_criteria)
+time2isoz\xCC128\xCD(t=None)
+time2netscape\xCC128\xCD(t=None)
+timegm\xCC128\xCD(tuple)
+timeit\xCC128\xCD(self, number=default_number)
+title\xCC128\xCD(self)
+toBytes\xCC128\xCD(url)
+to_eng_string\xCC128\xCD(self, context=None)
+to_integral_exact\xCC128\xCD(self, rounding=None, context=None)
+to_integral_value\xCC128\xCD(self, rounding=None, context=None)
+to_sci_string\xCC128\xCD(self, a)
+toaiff\xCC128\xCD(filename)
+tobuf\xCC128\xCD(self, posix=False)
+tokeneater\xCC128\xCD(self, type, token, (srow, scol), (erow, ecol), line)
+tokenize_loop\xCC128\xCD(readline, tokeneater)
+tokenize\xCC128\xCD(readline, tokeneater=printtoken)
+tolist\xCC128\xCD(self)
+tostring\xCC128\xCD(self)
+total\xCC128\xCD(self)
+trace_dispatch\xCC128\xCD(self, frame, event, arg)
+trace\xCC128\xCD(context=1)
+transfercmd\xCC128\xCD(self, cmd, rest=None)
+translate_path\xCC128\xCD(self, path)
+translate\xCC128\xCD(pat)
+truncate\xCC128\xCD(self, size=None)
+ttypager\xCC128\xCD(text)
+type_to_name\xCC128\xCD(gtype)
+ugettext\xCC128\xCD(self, message)
+uidl\xCC128\xCD(self, which=None)
+ulaw2lin\xCC128\xCD(self, data)
+uname\xCC128\xCD()
+unescape\xCC128\xCD(self, s)
+unexpo\xCC128\xCD(intpart, fraction, expo)
+ungettext\xCC128\xCD(self, msgid1, msgid2, n)
+unhex\xCC128\xCD(s)
+uniform\xCC128\xCD(self, a, b)
+uninstall\xCC128\xCD(self)
+union_update\xCC128\xCD(self, other)
+union\xCC128\xCD(self, other)
+unix_getpass\xCC128\xCD(prompt='Password: ', stream=None)
+unknown_decl\xCC128\xCD(self, data)
+unknown_endtag\xCC128\xCD(self, tag)
+unknown_open\xCC128\xCD(self, req)
+unknown_starttag\xCC128\xCD(self, tag, attrs)
+unload\xCC128\xCD(self, module)
+unlock\xCC128\xCD(self)
+unmatched\xCC128\xCD(match)
+unmimify_part\xCC128\xCD(ifile, ofile, decode_base64 = 0)
+unmimify\xCC128\xCD(infile, outfile, decode_base64 = 0)
+unpack_array\xCC128\xCD(self, unpack_item)
+unpack_bool\xCC128\xCD(self)
+unpack_double\xCC128\xCD(self)
+unpack_farray\xCC128\xCD(self, n, unpack_item)
+unpack_float\xCC128\xCD(self)
+unpack_from\xCC128\xCD(fmt, buf, offset=0)
+unpack_fstring\xCC128\xCD(self, n)
+unpack_hyper\xCC128\xCD(self)
+unpack_int\xCC128\xCD(self)
+unpack_list\xCC128\xCD(self, unpack_item)
+unpack_string\xCC128\xCD(self)
+unpack_uhyper\xCC128\xCD(self)
+unpack_uint\xCC128\xCD(self)
+unpack\xCC128\xCD(fmt, s)
+unquote_plus\xCC128\xCD(s)
+unquote\xCC128\xCD(s)
+unsetenv\xCC128\xCD(key)
+unsubscribe\xCC128\xCD(self, mailbox)
+untokenize\xCC128\xCD(iterable)
+unwrap\xCC128\xCD(url)
+update_visible\xCC128\xCD(self)
+updatecache\xCC128\xCD(filename, module_globals=None)
+updateline\xCC128\xCD(file, key, value, casefold = 1)
+updatepos\xCC128\xCD(self, i, j)
+update\xCC128\xCD(self, msg)
+uppercase_escaped_char\xCC128\xCD(match)
+upper\xCC128\xCD(s)
+urandom\xCC128\xCD(n)
+url2pathname\xCC128\xCD(url)
+urlcleanup\xCC128\xCD()
+urldefrag\xCC128\xCD(url)
+urlencode\xCC128\xCD(query,doseq=0)
+urljoin\xCC128\xCD(base, url, allow_fragments=True)
+urlopen\xCC128\xCD(url, data=None)
+urlparse\xCC128\xCD(url, scheme='', allow_fragments=True)
+urlretrieve\xCC128\xCD(url, filename=None, reporthook=None, data=None)
+urlsafe_b64decode\xCC128\xCD(s)
+urlsafe_b64encode\xCC128\xCD(s)
+urlsplit\xCC128\xCD(url, scheme='', allow_fragments=True)
+urlunparse\xCC128\xCD((scheme, netloc, url, params, query, fragment))
+urlunsplit\xCC128\xCD((scheme, netloc, url, query, fragment))
+usageExit\xCC128\xCD(self, msg=None)
+usage\xCC128\xCD(code, msg='')
+user_call\xCC128\xCD(self, frame, argument_list)
+user_domain_match\xCC128\xCD(A, B)
+user_exception\xCC128\xCD(self, frame, (exc_type, exc_value, exc_traceback))
+user_line\xCC128\xCD(self, frame)
+user_return\xCC128\xCD(self, frame, return_value)
+username\xCC128\xCD(self)
+user\xCC128\xCD(self, user)
+utime\xCC128\xCD(self, tarinfo, targetpath)
+uuid1\xCC128\xCD(node=None, clock_seq=None)
+uuid3\xCC128\xCD(namespace, name)
+uuid4\xCC128\xCD()
+uuid5\xCC128\xCD(namespace, name)
+valid_boundary\xCC128\xCD(s, _vb_pattern="^[ -~]{0,200}[!-~]$")
+vals_sorted_by_key\xCC128\xCD(adict)
+value_decode\xCC128\xCD(self, val)
+value_encode\xCC128\xCD(self, val)
+valuerefs\xCC128\xCD(self)
+values\xCC128\xCD(self)
+value\xCC128\xCD(self, key)
+verify_request\xCC128\xCD(self, request, client_address)
+verify\xCC128\xCD(self, address)
+version_string\xCC128\xCD(self)
+version\xCC128\xCD()
+visiblename\xCC128\xCD(name, all=None)
+voidcmd\xCC128\xCD(self, cmd)
+voidresp\xCC128\xCD(self)
+vonmisesvariate\xCC128\xCD(self, mu, kappa)
+wait\xCC128\xCD(self)
+walk_packages\xCC128\xCD(path=None, prefix='', onerror=None)
+walktree\xCC128\xCD(classes, children, parent)
+walk\xCC128\xCD(top, func, arg)
+warn\xCC128\xCD(message, category=None, stacklevel=1)
+wasSuccessful\xCC128\xCD(self)
+weekday\xCC128\xCD(year, month, day)
+weibullvariate\xCC128\xCD(self, alpha, beta)
+whathdr\xCC128\xCD(filename)
+what\xCC128\xCD(file, h=None)
+whichdb\xCC128\xCD(filename)
+whichmodule\xCC128\xCD(func, funcname)
+whseed\xCC128\xCD(self, a=None)
+win32_ver\xCC128\xCD(release='',version='',csd='',ptype='')
+win_getpass\xCC128\xCD(prompt='Password: ', stream=None)
+wr_long\xCC128\xCD(f, x)
+wrapper\xCC128\xCD(*args, **kw)
+wrap\xCC128\xCD(self, text)
+writable\xCC128\xCD(self)
+write32u\xCC128\xCD(output, value)
+write32\xCC128\xCD(output, value)
+writeArray\xCC128\xCD(self, array)
+writeData\xCC128\xCD(self, data)
+writeDict\xCC128\xCD(self, d)
+writePlistToResource\xCC128\xCD(rootObject, path, restype='plst', resid=0)
+writePlistToString\xCC128\xCD(rootObject)
+writePlist\xCC128\xCD(rootObject, pathOrFile)
+writeValue\xCC128\xCD(self, value)
+write_results_file\xCC128\xCD(self, path, lines, lnotab, lines_hit)
+write_results\xCC128\xCD(self, show_missing=True, summary=False, coverdir=None)
+write_rsrc\xCC128\xCD(self, data)
+writedocs\xCC128\xCD(dir, pkgpath='', done=None)
+writedoc\xCC128\xCD(thing, forceload=0)
+writeframesraw\xCC128\xCD(self, data)
+writeframes\xCC128\xCD(self, data)
+writelines\xCC128\xCD(self, list)
+writeln\xCC128\xCD(self, line)
+writepy\xCC128\xCD(self, pathname, basename = "")
+writerows\xCC128\xCD(self, rowdicts)
+writerow\xCC128\xCD(self, rowdict)
+writestr\xCC128\xCD(self, zinfo, bytes)
+write\xCC128\xCD(obj)
+xatom\xCC128\xCD(self, name, *args)
+xgtitle\xCC128\xCD(self, group, file=None)
+xhdr\xCC128\xCD(self, hdr, str, file=None)
+xover\xCC128\xCD(self, start, end, file=None)
+xpath\xCC128\xCD(self,id)
+yeardatescalendar\xCC128\xCD(self, year, width=3)
+yeardays2calendar\xCC128\xCD(self, year, width=3)
+yeardayscalendar\xCC128\xCD(self, year, width=3)
+yiq_to_rgb\xCC128\xCD(y, i, q)
+zfill\xCC128\xCD(x, width)

Added: trunk/scripts/create_py_tags.py
===================================================================
--- trunk/scripts/create_py_tags.py	                        (rev 0)
+++ trunk/scripts/create_py_tags.py	2008-06-10 16:39:17 UTC (rev 2677)
@@ -0,0 +1,278 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+#
+# Author:  Enrico Tröger
+# License: GPL v2 or later
+#
+# (based on the script at http://svn.python.org/view/*checkout*/python/trunk/Tools/scripts/ptags.py)
+#
+# This script should be run in the top source directory.
+#
+# Parses all files given on command line for Python classes or functions and write
+# them into data/python.tags (internal tagmanager format).
+# If called without command line arguments, a preset of common Python libs is used.
+
+import sys, re, os, datetime
+
+
+# (from tagmanager/tm_tag.c:32)
+TA_NAME = '%c' % 200,
+TA_TYPE = '%c' % 204
+TA_ARGLIST = '%c' % 205
+
+# TMTagType (tagmanager/tm_tag.h:47)
+TYPE_CLASS = '%d' % 1
+TYPE_FUNCTION = '%d' % 128
+
+tag_filename = 'data/python.tags'
+matcher = re.compile('^[ \t]*(def|class)[ \t]+([a-zA-Z0-9_]+)[ \t]*(\(.*\))[:]')
+
+
+def add_tag(tags, tag):
+	end_pos = tag.find(TA_TYPE)
+	tagname = tag[0:(end_pos+1)]
+	# check for duplicates
+	if len(tagname) < 5:
+		# skip short tags
+		return
+	for test in tags:
+		if test.startswith(tagname):
+			# check wether we find a tag line which starts with the same name,
+			# include the separating TA_TYPE character to ensure we don't match
+			# writelines() and write()
+			return
+	tags.append(tag)
+
+
+def treat_file(tags, filename):
+	try:
+		fp = open(filename, 'r')
+	except:
+		sys.stderr.write('Cannot open %s\n' % filename)
+		return
+	while 1:
+		line = fp.readline()
+		if not line:
+			break
+		m = matcher.match(line)
+		if m:
+			name = m.group(2)
+			if name[0] == '_':
+				# skip non-public tags
+				continue;
+			if m.group(1) == 'class':
+				type = TYPE_CLASS
+			else:
+				type = TYPE_FUNCTION
+			args = m.group(3).strip()
+			# tagnameTA_TYPEtypeTA_ARGLISTarglist\n
+			s = name + TA_TYPE + type + TA_ARGLIST + args + '\n'
+			add_tag(tags, s)
+			#~ # maybe for later use, with a more sophisticated algo to retrieve the API
+			#~ scope = ''
+			#~ return_value = ''
+			#~ # tagnameTA_TYPEtypeTA_ARGLISTarglistTA_SCOPEscopeTA_VARTYPEreturn_value\n
+			#~ s = name + TA_TYPE + type + TA_ARGLIST + args + TA_SCOPE + scope + TA_VARTYPE + return_value + '\n'
+
+
+
+# files to include if none were specified on command line
+# (this list was created manually and probably needs review for sensible input files)
+default_files = [
+'/usr/lib/python2.5/anydbm.py',
+'/usr/lib/python2.5/asynchat.py',
+'/usr/lib/python2.5/asyncore.py',
+'/usr/lib/python2.5/audiodev.py',
+'/usr/lib/python2.5/base64.py',
+'/usr/lib/python2.5/BaseHTTPServer.py',
+'/usr/lib/python2.5/Bastion.py',
+'/usr/lib/python2.5/bdb.py',
+'/usr/lib/python2.5/binhex.py',
+'/usr/lib/python2.5/bisect.py',
+'/usr/lib/python2.5/calendar.py',
+'/usr/lib/python2.5/CGIHTTPServer.py',
+'/usr/lib/python2.5/cgi.py',
+'/usr/lib/python2.5/cgitb.py',
+'/usr/lib/python2.5/chunk.py',
+'/usr/lib/python2.5/cmd.py',
+'/usr/lib/python2.5/codecs.py',
+'/usr/lib/python2.5/codeop.py',
+'/usr/lib/python2.5/code.py',
+'/usr/lib/python2.5/colorsys.py',
+'/usr/lib/python2.5/commands.py',
+'/usr/lib/python2.5/compileall.py',
+'/usr/lib/python2.5/ConfigParser.py',
+'/usr/lib/python2.5/contextlib.py',
+'/usr/lib/python2.5/cookielib.py',
+'/usr/lib/python2.5/Cookie.py',
+'/usr/lib/python2.5/copy.py',
+'/usr/lib/python2.5/copy_reg.py',
+'/usr/lib/python2.5/cProfile.py',
+'/usr/lib/python2.5/csv.py',
+'/usr/lib/python2.5/dbhash.py',
+'/usr/lib/python2.5/decimal.py',
+'/usr/lib/python2.5/difflib.py',
+'/usr/lib/python2.5/dircache.py',
+'/usr/lib/python2.5/dis.py',
+'/usr/lib/python2.5/DocXMLRPCServer.py',
+'/usr/lib/python2.5/filecmp.py',
+'/usr/lib/python2.5/fileinput.py',
+'/usr/lib/python2.5/fnmatch.py',
+'/usr/lib/python2.5/formatter.py',
+'/usr/lib/python2.5/fpformat.py',
+'/usr/lib/python2.5/ftplib.py',
+'/usr/lib/python2.5/functools.py',
+'/usr/lib/python2.5/getopt.py',
+'/usr/lib/python2.5/getpass.py',
+'/usr/lib/python2.5/gettext.py',
+'/usr/lib/python2.5/glob.py',
+'/usr/lib/python2.5/gopherlib.py',
+'/usr/lib/python2.5/gzip.py',
+'/usr/lib/python2.5/hashlib.py',
+'/usr/lib/python2.5/heapq.py',
+'/usr/lib/python2.5/hmac.py',
+'/usr/lib/python2.5/htmlentitydefs.py',
+'/usr/lib/python2.5/htmllib.py',

@@ Diff output truncated at 100000 characters. @@

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

