desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Get next char from raw queue.
Block if no data is immediately available. Raise EOFError
when connection is closed.'
| def rawq_getchar(self):
| if (not self.rawq):
self.fill_rawq()
if self.eof:
raise EOFError
c = self.rawq[self.irawq]
self.irawq = (self.irawq + 1)
if (self.irawq >= len(self.rawq)):
self.rawq = ''
self.irawq = 0
return c
|
'Fill raw queue from exactly one recv() system call.
Block if no data is immediately available. Set self.eof when
connection is closed.'
| def fill_rawq(self):
| if (self.irawq >= len(self.rawq)):
self.rawq = ''
self.irawq = 0
buf = self.sock.recv(50)
self.msg('recv %r', buf)
self.eof = (not buf)
self.rawq = (self.rawq + buf)
|
'Test whether data is available on the socket.'
| def sock_avail(self):
| return (select.select([self], [], [], 0) == ([self], [], []))
|
'Interaction function, emulates a very dumb telnet client.'
| def interact(self):
| if (sys.platform == 'win32'):
self.mt_interact()
return
while 1:
(rfd, wfd, xfd) = select.select([self, sys.stdin], [], [])
if (self in rfd):
try:
text = self.read_eager()
except EOFError:
print '*** Connection closed ... |
'Multithreaded version of interact().'
| def mt_interact(self):
| import thread
thread.start_new_thread(self.listener, ())
while 1:
line = sys.stdin.readline()
if (not line):
break
self.write(line)
|
'Helper for mt_interact() -- this executes in the other thread.'
| def listener(self):
| while 1:
try:
data = self.read_eager()
except EOFError:
print '*** Connection closed by remote host ***'
return
if data:
sys.stdout.write(data)
else:
sys.stdout.flush()
|
'Read until one from a list of a regular expressions matches.
The first argument is a list of regular expressions, either
compiled (re.RegexObject instances) or uncompiled (strings).
The optional second argument is a timeout, in seconds; default
is no timeout.
Return a tuple of three items: the index in the list of the... | def expect(self, list, timeout=None):
| re = None
list = list[:]
indices = range(len(list))
for i in indices:
if (not hasattr(list[i], 'search')):
if (not re):
import re
list[i] = re.compile(list[i])
if (timeout is not None):
from time import time
time_start = time()
whil... |
'Builds a qualified name from a (ns_url, localname) pair'
| def _qname(self, name):
| if name[0]:
if ('http://www.w3.org/XML/1998/namespace' == name[0]):
return ('xml:' + name[1])
prefix = self._current_context[name[0]]
if prefix:
return ((prefix + ':') + name[1])
return name[1]
|
'Parse an XML document from a URL or an InputSource.'
| def parse(self, source):
| source = saxutils.prepare_input_source(source)
self._source = source
self.reset()
self._cont_handler.setDocumentLocator(ExpatLocator(self))
xmlreader.IncrementalParser.parse(self, source)
|
'Creates an exception. The message is required, but the exception
is optional.'
| def __init__(self, msg, exception=None):
| self._msg = msg
self._exception = exception
Exception.__init__(self, msg)
|
'Return a message for this exception.'
| def getMessage(self):
| return self._msg
|
'Return the embedded exception, or None if there was none.'
| def getException(self):
| return self._exception
|
'Create a string representation of the exception.'
| def __str__(self):
| return self._msg
|
'Avoids weird error messages if someone does exception[ix] by
mistake, since Exception has __getitem__ defined.'
| def __getitem__(self, ix):
| raise AttributeError('__getitem__')
|
'Creates the exception. The exception parameter is allowed to be None.'
| def __init__(self, msg, exception, locator):
| SAXException.__init__(self, msg, exception)
self._locator = locator
self._systemId = self._locator.getSystemId()
self._colnum = self._locator.getColumnNumber()
self._linenum = self._locator.getLineNumber()
|
'The column number of the end of the text where the exception
occurred.'
| def getColumnNumber(self):
| return self._colnum
|
'The line number of the end of the text where the exception occurred.'
| def getLineNumber(self):
| return self._linenum
|
'Get the public identifier of the entity where the exception occurred.'
| def getPublicId(self):
| return self._locator.getPublicId()
|
'Get the system identifier of the entity where the exception occurred.'
| def getSystemId(self):
| return self._systemId
|
'Create a string representation of the exception.'
| def __str__(self):
| sysid = self.getSystemId()
if (sysid is None):
sysid = '<unknown>'
linenum = self.getLineNumber()
if (linenum is None):
linenum = '?'
colnum = self.getColumnNumber()
if (colnum is None):
colnum = '?'
return ('%s:%s:%s: %s' % (sysid, linenum, colnum, self._msg))
|
'Parse an XML document from a system identifier or an InputSource.'
| def parse(self, source):
| raise NotImplementedError('This method must be implemented!')
|
'Returns the current ContentHandler.'
| def getContentHandler(self):
| return self._cont_handler
|
'Registers a new object to receive document content events.'
| def setContentHandler(self, handler):
| self._cont_handler = handler
|
'Returns the current DTD handler.'
| def getDTDHandler(self):
| return self._dtd_handler
|
'Register an object to receive basic DTD-related events.'
| def setDTDHandler(self, handler):
| self._dtd_handler = handler
|
'Returns the current EntityResolver.'
| def getEntityResolver(self):
| return self._ent_handler
|
'Register an object to resolve external entities.'
| def setEntityResolver(self, resolver):
| self._ent_handler = resolver
|
'Returns the current ErrorHandler.'
| def getErrorHandler(self):
| return self._err_handler
|
'Register an object to receive error-message events.'
| def setErrorHandler(self, handler):
| self._err_handler = handler
|
'Allow an application to set the locale for errors and warnings.
SAX parsers are not required to provide localization for errors
and warnings; if they cannot support the requested locale,
however, they must throw a SAX exception. Applications may
request a locale change in the middle of a parse.'
| def setLocale(self, locale):
| raise SAXNotSupportedException('Locale support not implemented')
|
'Looks up and returns the state of a SAX2 feature.'
| def getFeature(self, name):
| raise SAXNotRecognizedException(("Feature '%s' not recognized" % name))
|
'Sets the state of a SAX2 feature.'
| def setFeature(self, name, state):
| raise SAXNotRecognizedException(("Feature '%s' not recognized" % name))
|
'Looks up and returns the value of a SAX2 property.'
| def getProperty(self, name):
| raise SAXNotRecognizedException(("Property '%s' not recognized" % name))
|
'Sets the value of a SAX2 property.'
| def setProperty(self, name, value):
| raise SAXNotRecognizedException(("Property '%s' not recognized" % name))
|
'This method gives the raw XML data in the data parameter to
the parser and makes it parse the data, emitting the
corresponding events. It is allowed for XML constructs to be
split across several calls to feed.
feed may raise SAXException.'
| def feed(self, data):
| raise NotImplementedError('This method must be implemented!')
|
'This method is called by the parse implementation to allow
the SAX 2.0 driver to prepare itself for parsing.'
| def prepareParser(self, source):
| raise NotImplementedError('prepareParser must be overridden!')
|
'This method is called when the entire XML document has been
passed to the parser through the feed method, to notify the
parser that there are no more data. This allows the parser to
do the final checks on the document and empty the internal
data buffer.
The parser will not be ready to parse another document until
the ... | def close(self):
| raise NotImplementedError('This method must be implemented!')
|
'This method is called after close has been called to reset
the parser so that it is ready to parse new documents. The
results of calling parse or feed after close without calling
reset are undefined.'
| def reset(self):
| raise NotImplementedError('This method must be implemented!')
|
'Return the column number where the current event ends.'
| def getColumnNumber(self):
| return (-1)
|
'Return the line number where the current event ends.'
| def getLineNumber(self):
| return (-1)
|
'Return the public identifier for the current event.'
| def getPublicId(self):
| return None
|
'Return the system identifier for the current event.'
| def getSystemId(self):
| return None
|
'Sets the public identifier of this InputSource.'
| def setPublicId(self, public_id):
| self.__public_id = public_id
|
'Returns the public identifier of this InputSource.'
| def getPublicId(self):
| return self.__public_id
|
'Sets the system identifier of this InputSource.'
| def setSystemId(self, system_id):
| self.__system_id = system_id
|
'Returns the system identifier of this InputSource.'
| def getSystemId(self):
| return self.__system_id
|
'Sets the character encoding of this InputSource.
The encoding must be a string acceptable for an XML encoding
declaration (see section 4.3.3 of the XML recommendation).
The encoding attribute of the InputSource is ignored if the
InputSource also contains a character stream.'
| def setEncoding(self, encoding):
| self.__encoding = encoding
|
'Get the character encoding of this InputSource.'
| def getEncoding(self):
| return self.__encoding
|
'Set the byte stream (a Python file-like object which does
not perform byte-to-character conversion) for this input
source.
The SAX parser will ignore this if there is also a character
stream specified, but it will use a byte stream in preference
to opening a URI connection itself.
If the application knows the characte... | def setByteStream(self, bytefile):
| self.__bytefile = bytefile
|
'Get the byte stream for this input source.
The getEncoding method will return the character encoding for
this byte stream, or None if unknown.'
| def getByteStream(self):
| return self.__bytefile
|
'Set the character stream for this input source. (The stream
must be a Python 2.0 Unicode-wrapped file-like that performs
conversion to Unicode strings.)
If there is a character stream specified, the SAX parser will
ignore any byte stream and will not attempt to open a URI
connection to the system identifier.'
| def setCharacterStream(self, charfile):
| self.__charfile = charfile
|
'Get the character stream for this input source.'
| def getCharacterStream(self):
| return self.__charfile
|
'Non-NS-aware implementation.
attrs should be of the form {name : value}.'
| def __init__(self, attrs):
| self._attrs = attrs
|
'NS-aware implementation.
attrs should be of the form {(ns_uri, lname): value, ...}.
qnames of the form {(ns_uri, lname): qname, ...}.'
| def __init__(self, attrs, qnames):
| self._attrs = attrs
self._qnames = qnames
|
'Handle a recoverable error.'
| def error(self, exception):
| raise exception
|
'Handle a non-recoverable error.'
| def fatalError(self, exception):
| raise exception
|
'Handle a warning.'
| def warning(self, exception):
| print exception
|
'Called by the parser to give the application a locator for
locating the origin of document events.
SAX parsers are strongly encouraged (though not absolutely
required) to supply a locator: if it does so, it must supply
the locator to the application by invoking this method before
invoking any of the other methods in t... | def setDocumentLocator(self, locator):
| self._locator = locator
|
'Resolve the system identifier of an entity and return either
the system identifier to read from as a string, or an InputSource
to read from.'
| def resolveEntity(self, publicId, systemId):
| return systemId
|
'Create a new parser object.'
| def createParser(self):
| return expat.ParserCreate()
|
'Return the parser object, creating a new one if needed.'
| def getParser(self):
| if (not self._parser):
self._parser = self.createParser()
self._intern_setdefault = self._parser.intern.setdefault
self._parser.buffer_text = True
self._parser.ordered_attributes = True
self._parser.specified_attributes = True
self.install(self._parser)
return sel... |
'Free all data structures used during DOM construction.'
| def reset(self):
| self.document = theDOMImplementation.createDocument(EMPTY_NAMESPACE, None, None)
self.curNode = self.document
self._elem_info = self.document._elem_info
self._cdata = False
|
'Install the callbacks needed to build the DOM into the parser.'
| def install(self, parser):
| parser.StartDoctypeDeclHandler = self.start_doctype_decl_handler
parser.StartElementHandler = self.first_element_handler
parser.EndElementHandler = self.end_element_handler
parser.ProcessingInstructionHandler = self.pi_handler
if self._options.entities:
parser.EntityDeclHandler = self.entity... |
'Parse a document from a file object, returning the document
node.'
| def parseFile(self, file):
| parser = self.getParser()
first_buffer = True
try:
while 1:
buffer = file.read((16 * 1024))
if (not buffer):
break
parser.Parse(buffer, 0)
if (first_buffer and self.document.documentElement):
self._setup_subset(buffer)
... |
'Parse a document from a string, returning the document node.'
| def parseString(self, string):
| parser = self.getParser()
try:
parser.Parse(string, True)
self._setup_subset(string)
except ParseEscape:
pass
doc = self.document
self.reset()
self._parser = None
return doc
|
'Load the internal subset if there might be one.'
| def _setup_subset(self, buffer):
| if self.document.doctype:
extractor = InternalSubsetExtractor()
extractor.parseString(buffer)
subset = extractor.getSubset()
self.document.doctype.internalSubset = subset
|
'Parse a document fragment from a file object, returning the
fragment node.'
| def parseFile(self, file):
| return self.parseString(file.read())
|
'Parse a document fragment from a string, returning the
fragment node.'
| def parseString(self, string):
| self._source = string
parser = self.getParser()
doctype = self.originalDocument.doctype
ident = ''
if doctype:
subset = (doctype.internalSubset or self._getDeclarations())
if doctype.publicId:
ident = ('PUBLIC "%s" "%s"' % (doctype.publicId, doctype.systemId))
... |
'Re-create the internal subset from the DocumentType node.
This is only needed if we don\'t already have the
internalSubset as a string.'
| def _getDeclarations(self):
| doctype = self.context.ownerDocument.doctype
s = ''
if doctype:
for i in range(doctype.notations.length):
notation = doctype.notations.item(i)
if s:
s = (s + '\n ')
s = ('%s<!NOTATION %s' % (s, notation.nodeName))
if notation.... |
'Create a new namespace-handling parser.'
| def createParser(self):
| parser = expat.ParserCreate(namespace_separator=' ')
parser.namespace_prefixes = True
return parser
|
'Insert the namespace-handlers onto the parser.'
| def install(self, parser):
| ExpatBuilder.install(self, parser)
if self._options.namespace_declarations:
parser.StartNamespaceDeclHandler = self.start_namespace_decl_handler
|
'Push this namespace declaration on our storage.'
| def start_namespace_decl_handler(self, prefix, uri):
| self._ns_ordered_prefixes.append((prefix, uri))
|
'Return string of namespace attributes from this element and
ancestors.'
| def _getNSattrs(self):
| attrs = ''
context = self.context
L = []
while context:
if hasattr(context, '_ns_prefix_uri'):
for (prefix, uri) in context._ns_prefix_uri.items():
if (prefix in L):
continue
L.append(prefix)
if prefix:
... |
'Return the internal subset as a string.'
| def getSubset(self):
| return self.subset
|
'clear(): Explicitly release parsing structures'
| def clear(self):
| self.document = None
|
'Fallback replacement for getEvent() using the
standard SAX2 interface, which means we slurp the
SAX events into memory (no performance gain, but
we are compatible to all SAX parsers).'
| def _slurp(self):
| self.parser.parse(self.stream)
self.getEvent = self._emit
return self._emit()
|
'Fallback replacement for getEvent() that emits
the events that _slurp() read previously.'
| def _emit(self):
| rc = self.pulldom.firstEvent[1][0]
self.pulldom.firstEvent[1] = self.pulldom.firstEvent[1][1]
return rc
|
'clear(): Explicitly release parsing objects'
| def clear(self):
| self.pulldom.clear()
del self.pulldom
self.parser = None
self.stream = None
|
'Returns true iff this element is declared to have an EMPTY
content model.'
| def isEmpty(self):
| return False
|
'Returns true iff the named attribute is a DTD-style ID.'
| def isId(self, aname):
| return False
|
'Returns true iff the identified attribute is a DTD-style ID.'
| def isIdNS(self, namespaceURI, localName):
| return False
|
'This method of XMLParser is deprecated.'
| def doctype(self, name, pubid, system):
| warnings.warn('This method of XMLParser is deprecated. Define doctype() method on the TreeBuilder target.', DeprecationWarning)
|
'Constructor for the GzipFile class.
At least one of fileobj and filename must be given a
non-trivial value.
The new class instance is based on fileobj, which can be a regular
file, a StringIO object, or any other object which simulates a file.
It defaults to None, in which case filename is opened to provide
a file obj... | def __init__(self, filename=None, mode=None, compresslevel=9, fileobj=None, mtime=None):
| if (mode and ('b' not in mode)):
mode += 'b'
if (fileobj is None):
fileobj = self.myfileobj = __builtin__.open(filename, (mode or 'rb'))
if (filename is None):
if hasattr(fileobj, 'name'):
filename = fileobj.name
else:
filename = ''
if (mode is Non... |
'Raises a ValueError if the underlying file object has been closed.'
| def _check_closed(self):
| if self.closed:
raise ValueError('I/O operation on closed file.')
|
'Invoke the underlying file object\'s fileno() method.
This will raise AttributeError if the underlying file object
doesn\'t support fileno().'
| def fileno(self):
| return self.fileobj.fileno()
|
'Return the uncompressed stream file position indicator to the
beginning of the file'
| def rewind(self):
| if (self.mode != READ):
raise IOError("Can't rewind in write mode")
self.fileobj.seek(0)
self._new_member = True
self.extrabuf = ''
self.extrasize = 0
self.extrastart = 0
self.offset = 0
|
'Push a token onto the stack popped by the get_token method'
| def push_token(self, tok):
| if (self.debug >= 1):
print ('shlex: pushing token ' + repr(tok))
self.pushback.appendleft(tok)
|
'Push an input source onto the lexer\'s input source stack.'
| def push_source(self, newstream, newfile=None):
| if isinstance(newstream, basestring):
newstream = StringIO(newstream)
self.filestack.appendleft((self.infile, self.instream, self.lineno))
self.infile = newfile
self.instream = newstream
self.lineno = 1
if self.debug:
if (newfile is not None):
print ('shlex: pushin... |
'Pop the input source stack.'
| def pop_source(self):
| self.instream.close()
(self.infile, self.instream, self.lineno) = self.filestack.popleft()
if self.debug:
print ('shlex: popping to %s, line %d' % (self.instream, self.lineno))
self.state = ' '
|
'Get a token from the input stream (or from stack if it\'s nonempty)'
| def get_token(self):
| if self.pushback:
tok = self.pushback.popleft()
if (self.debug >= 1):
print ('shlex: popping token ' + repr(tok))
return tok
raw = self.read_token()
if (self.source is not None):
while (raw == self.source):
spec = self.sourcehook(self.read_tok... |
'Hook called on a filename to be sourced.'
| def sourcehook(self, newfile):
| if (newfile[0] == '"'):
newfile = newfile[1:(-1)]
if (isinstance(self.infile, basestring) and (not os.path.isabs(newfile))):
newfile = os.path.join(os.path.dirname(self.infile), newfile)
return (newfile, open(newfile, 'r'))
|
'Emit a C-compiler-like, Emacs-friendly error-message leader.'
| def error_leader(self, infile=None, lineno=None):
| if (infile is None):
infile = self.infile
if (lineno is None):
lineno = self.lineno
return ('"%s", line %d: ' % (infile, lineno))
|
'Register a virtual subclass of an ABC.'
| def register(cls, subclass):
| if (not isinstance(subclass, (type, types.ClassType))):
raise TypeError('Can only register classes')
if issubclass(subclass, cls):
return
if issubclass(cls, subclass):
raise RuntimeError('Refusing to create an inheritance cycle')
cls._abc_registry.add(subc... |
'Debug helper to print the ABC registry.'
| def _dump_registry(cls, file=None):
| print >>file, ('Class: %s.%s' % (cls.__module__, cls.__name__))
print >>file, ('Inv.counter: %s' % ABCMeta._abc_invalidation_counter)
for name in sorted(cls.__dict__.keys()):
if name.startswith('_abc_'):
value = getattr(cls, name)
print >>file, ('%s: %r' % (name, val... |
'Override for isinstance(instance, cls).'
| def __instancecheck__(cls, instance):
| subclass = getattr(instance, '__class__', None)
if ((subclass is not None) and (subclass in cls._abc_cache)):
return True
subtype = type(instance)
if (subtype is _InstanceType):
subtype = subclass
if ((subtype is subclass) or (subclass is None)):
if ((cls._abc_negative_cache_... |
'Override for issubclass(subclass, cls).'
| def __subclasscheck__(cls, subclass):
| if (subclass in cls._abc_cache):
return True
if (cls._abc_negative_cache_version < ABCMeta._abc_invalidation_counter):
cls._abc_negative_cache = WeakSet()
cls._abc_negative_cache_version = ABCMeta._abc_invalidation_counter
elif (subclass in cls._abc_negative_cache):
return Fa... |
'Return true if the scope uses exec'
| def has_exec(self):
| return bool((self._table.optimized & (OPT_EXEC | OPT_BARE_EXEC)))
|
'Return true if the scope uses import *'
| def has_import_star(self):
| return bool((self._table.optimized & OPT_IMPORT_STAR))
|
'Returns true if name binding introduces new namespace.
If the name is used as the target of a function or class
statement, this will be true.
Note that a single name can be bound to multiple objects. If
is_namespace() is true, the name may also be bound to other
objects, like an int or list, that does not introduce a... | def is_namespace(self):
| return bool(self.__namespaces)
|
'Return a list of namespaces bound to this name'
| def get_namespaces(self):
| return self.__namespaces
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.