The syntax is inspired by Emacs's notation for specifying variables local to a
file. Emacs supports many different variables, but Python only supports
-'coding'. The ``-*-`` symbols indicate that the comment is special; within
-them, you must supply the name ``coding`` and the name of your chosen encoding,
-separated by ``':'``.
+'coding'. The ``-*-`` symbols indicate to Emacs that the comment is special;
+they have no significance to Python but are a convention. Python looks for
+``coding: name`` or ``coding=name`` in the comment.
If you don't include such a comment, the default encoding used will be ASCII.
Versions of Python before 2.4 were Euro-centric and assumed Latin-1 as a default
The *arg* parameter depends on the previous event.
- For more information on trace functions, see :ref:`debugger-hooks`. For
- more information on code and frame objects, refer to :ref:`types`.
+ See the documentation for :func:`sys.settrace` for more information on the
+ trace function. For more information on code and frame objects, refer to
+ :ref:`types`.
.. method:: dispatch_line(frame)
:class:`Iterable`, and ``__len__`` ``index``, and ``count``
:class:`Container`
-:class:`MutableSequnce` :class:`Sequence` ``__getitem__`` Inherited Sequence methods and
+:class:`MutableSequence` :class:`Sequence` ``__getitem__`` Inherited Sequence methods and
``__delitem__``, ``append``, ``reverse``, ``extend``, ``pop``,
``insert``, ``remove``, and ``__iadd__``
and ``__len__``
self-documenting code. They can be used wherever regular tuples are used, and
they add the ability to access fields by name instead of position index.
-.. function:: namedtuple(typename, fieldnames, [verbose])
+.. function:: namedtuple(typename, field_names, [verbose])
Returns a new tuple subclass named *typename*. The new subclass is used to
create tuple-like objects that have fields accessible by attribute lookup as
well as being indexable and iterable. Instances of the subclass also have a
- helpful docstring (with typename and fieldnames) and a helpful :meth:`__repr__`
+ helpful docstring (with typename and field_names) and a helpful :meth:`__repr__`
method which lists the tuple contents in a ``name=value`` format.
- The *fieldnames* are a single string with each fieldname separated by whitespace
- and/or commas, for example ``'x y'`` or ``'x, y'``. Alternatively, *fieldnames*
+ The *field_names* are a single string with each fieldname separated by whitespace
+ and/or commas, for example ``'x y'`` or ``'x, y'``. Alternatively, *field_names*
can be a sequence of strings such as ``['x', 'y']``.
Any valid Python identifier may be used for a fieldname except for names
All these classes can be instantiated by calling them with at least one
argument, the pathname of the shared library. If you have an existing handle to
-an already loaded shard library, it can be passed as the ``handle`` named
+an already loaded shared library, it can be passed as the ``handle`` named
parameter, otherwise the underlying platforms ``dlopen`` or :meth:`LoadLibrary`
function is used to load the library into the process, and to get a handle to
it.
.. method:: close()
- Flush and close this stream. This method has no effect if the file is
- already closed.
+ Flush and close this stream. This method has no effect if the file is
+ already closed. Once the file is closed, any operation on the file
+ (e.g. reading or writing) will raise an :exc:`IOError`. The internal
+ file descriptor isn't closed if *closefd* was False.
.. attribute:: closed
Note that *lock* is a keyword only argument.
- Note that an array of :data:`ctypes.c_char` has *value* and *rawvalue*
+ Note that an array of :data:`ctypes.c_char` has *value* and *raw*
attributes which allow one to use it to store and retrieve strings.
:func:`Value` instead to make sure that access is automatically synchronized
using a lock.
- Note that an array of :data:`ctypes.c_char` has ``value`` and ``rawvalue``
+ Note that an array of :data:`ctypes.c_char` has ``value`` and ``raw``
attributes which allow one to use it to store and retrieve strings -- see
documentation for :mod:`ctypes`.
.. function:: listdir(path)
- Return a list containing the names of the entries in the directory. The list is
- in arbitrary order. It does not include the special entries ``'.'`` and
- ``'..'`` even if they are present in the directory. Availability:
- Unix, Windows.
+ Return a list containing the names of the entries in the directory given by
+ *path*. The list is in arbitrary order. It does not include the special
+ entries ``'.'`` and ``'..'`` even if they are present in the
+ directory. Availability: Unix, Windows.
.. versionchanged:: 2.3
On Windows NT/2k/XP and Unix, if *path* is a Unicode object, the result will be
q(uit)
Quit from the debugger. The program being executed is aborted.
-
-
-.. _debugger-hooks:
-
-How It Works
-============
-
-Some changes were made to the interpreter:
-
-* ``sys.settrace(func)`` sets the global trace function
-
-* there can also a local trace function (see later)
-
-Trace functions have three arguments: *frame*, *event*, and *arg*. *frame* is
-the current stack frame. *event* is a string: ``'call'``, ``'line'``,
-``'return'``, ``'exception'``, ``'c_call'``, ``'c_return'``, or
-``'c_exception'``. *arg* depends on the event type.
-
-The global trace function is invoked (with *event* set to ``'call'``) whenever a
-new local scope is entered; it should return a reference to the local trace
-function to be used that scope, or ``None`` if the scope shouldn't be traced.
-
-The local trace function should return a reference to itself (or to another
-function for further tracing in that scope), or ``None`` to turn off tracing in
-that scope.
-
-Instance methods are accepted (and very useful!) as trace functions.
-
-The events have the following meaning:
-
-``'call'``
- A function is called (or some other code block entered). The global trace
- function is called; *arg* is ``None``; the return value specifies the local
- trace function.
-
-``'line'``
- The interpreter is about to execute a new line of code (sometimes multiple line
- events on one line exist). The local trace function is called; *arg* is
- ``None``; the return value specifies the new local trace function.
-
-``'return'``
- A function (or other code block) is about to return. The local trace function
- is called; *arg* is the value that will be returned. The trace function's
- return value is ignored.
-
-``'exception'``
- An exception has occurred. The local trace function is called; *arg* is a
- triple ``(exception, value, traceback)``; the return value specifies the new
- local trace function.
-
-``'c_call'``
- A C function is about to be called. This may be an extension function or a
- builtin. *arg* is the C function object.
-
-``'c_return'``
- A C function has returned. *arg* is ``None``.
-
-``'c_exception'``
- A C function has thrown an exception. *arg* is ``None``.
-
-Note that as an exception is propagated down the chain of callers, an
-``'exception'`` event is generated at each level.
-
-For more information on code and frame objects, refer to :ref:`types`.
-
single: debugger
Set the system's trace function, which allows you to implement a Python
- source code debugger in Python. See section :ref:`debugger-hooks` in the
- chapter on the Python debugger. The function is thread-specific; for a
+ source code debugger in Python. The function is thread-specific; for a
debugger to support multiple threads, it must be registered using
:func:`settrace` for each thread being debugged.
+ Trace functions should have three arguments: *frame*, *event*, and
+ *arg*. *frame* is the current stack frame. *event* is a string: ``'call'``,
+ ``'line'``, ``'return'``, ``'exception'``, ``'c_call'``, ``'c_return'``, or
+ ``'c_exception'``. *arg* depends on the event type.
+
+ The trace function is invoked (with *event* set to ``'call'``) whenever a new
+ local scope is entered; it should return a reference to a local trace
+ function to be used that scope, or ``None`` if the scope shouldn't be traced.
+
+ The local trace function should return a reference to itself (or to another
+ function for further tracing in that scope), or ``None`` to turn off tracing
+ in that scope.
+
+ The events have the following meaning:
+
+ ``'call'``
+ A function is called (or some other code block entered). The
+ global trace function is called; *arg* is ``None``; the return value
+ specifies the local trace function.
+
+ ``'line'``
+ The interpreter is about to execute a new line of code (sometimes multiple
+ line events on one line exist). The local trace function is called; *arg*
+ is ``None``; the return value specifies the new local trace function.
+
+ ``'return'``
+ A function (or other code block) is about to return. The local trace
+ function is called; *arg* is the value that will be returned. The trace
+ function's return value is ignored.
+
+ ``'exception'``
+ An exception has occurred. The local trace function is called; *arg* is a
+ tuple ``(exception, value, traceback)``; the return value specifies the
+ new local trace function.
+
+ ``'c_call'``
+ A C function is about to be called. This may be an extension function or
+ a builtin. *arg* is the C function object.
+
+ ``'c_return'``
+ A C function has returned. *arg* is ``None``.
+
+ ``'c_exception'``
+ A C function has thrown an exception. *arg* is ``None``.
+
+ Note that as an exception is propagated down the chain of callers, an
+ ``'exception'`` event is generated at each level.
+
+ For more information on code and frame objects, refer to :ref:`types`.
+
.. note::
The :func:`settrace` function is intended only for implementing debuggers,
object: dictionary
builtin: hash
- Called for the key object for dictionary operations, and by the built-in
- function :func:`hash`. Should return an integer usable as a hash value
- for dictionary operations. The only required property is that objects which
- compare equal have the same hash value; it is advised to somehow mix together
- (e.g., using exclusive or) the hash values for the components of the object that
- also play a part in comparison of objects.
+ Called by built-in function :func:`hash` and for operations on members of
+ hashed collections including :class:`set`, :class:`frozenset`, and
+ :class:`dict`. :meth:`__hash__` should return an integer. The only required
+ property is that objects which compare equal have the same hash value; it is
+ advised to somehow mix together (e.g. using exclusive or) the hash values for
+ the components of the object that also play a part in comparison of objects.
If a class does not define a :meth:`__cmp__` or :meth:`__eq__` method it
should not define a :meth:`__hash__` operation either; if it defines
:meth:`__cmp__` or :meth:`__eq__` but not :meth:`__hash__`, its instances
- will not be usable as dictionary keys. If a class defines mutable objects
+ will not be usable in hashed collections. If a class defines mutable objects
and implements a :meth:`__cmp__` or :meth:`__eq__` method, it should not
- implement :meth:`__hash__`, since the dictionary implementation requires that
- a key's hash value is immutable (if the object's hash value changes, it will
- be in the wrong hash bucket).
+ implement :meth:`__hash__`, since hashable collection implementations require
+ that a object's hash value is immutable (if the object's hash value changes,
+ it will be in the wrong hash bucket).
User-defined classes have :meth:`__cmp__` and :meth:`__hash__` methods
by default; with them, all objects compare unequal (except with themselves)
change the meaning of :meth:`__cmp__` or :meth:`__eq__` such that the hash
value returned is no longer appropriate (e.g. by switching to a value-based
concept of equality instead of the default identity based equality) can
- explicitly flag themselves as being unhashable by setting
- ``__hash__ = None`` in the class definition. Doing so means that not only
- will instances of the class raise an appropriate :exc:`TypeError` when
- a program attempts to retrieve their hash value, but they will also be
- correctly identified as unhashable when checking
- ``isinstance(obj, collections.Hashable)`` (unlike classes which define
- their own :meth:`__hash__` to explicitly raise :exc:`TypeError`).
+ explicitly flag themselves as being unhashable by setting ``__hash__ = None``
+ in the class definition. Doing so means that not only will instances of the
+ class raise an appropriate :exc:`TypeError` when a program attempts to
+ retrieve their hash value, but they will also be correctly identified as
+ unhashable when checking ``isinstance(obj, collections.Hashable)`` (unlike
+ classes which define their own :meth:`__hash__` to explicitly raise
+ :exc:`TypeError`).
.. versionchanged:: 2.5
:meth:`__hash__` may now also return a long integer object; the 32-bit
"""
if module is None:
return True
+ elif inspect.getmodule(object) is not None:
+ return module is inspect.getmodule(object)
elif inspect.isfunction(object):
return module.__dict__ is object.func_globals
elif inspect.isclass(object):
return module.__name__ == object.__module__
- elif inspect.getmodule(object) is not None:
- return module is inspect.getmodule(object)
elif hasattr(object, '__module__'):
return module.__name__ == object.__module__
elif isinstance(object, property):
raise ValueError("invalid buffering size")
if buffering == 0:
if binary:
- raw._name = file
- raw._mode = mode
return raw
raise ValueError("can't have unbuffered text I/O")
if updating:
else:
raise ValueError("unknown mode: %r" % mode)
if binary:
- buffer.name = file
- buffer.mode = mode
return buffer
text = TextIOWrapper(buffer, encoding, errors, newline, line_buffering)
- text.name = file
text.mode = mode
return text
# that _fileio._FileIO inherits from io.RawIOBase (which would be hard
# to do since _fileio.c is written in C).
+ def __init__(self, name, mode="r", closefd=True):
+ _fileio._FileIO.__init__(self, name, mode, closefd)
+ self._name = name
+
def close(self):
_fileio._FileIO.close(self)
RawIOBase.close(self)
def name(self):
return self._name
- @property
- def mode(self):
- return self._mode
-
class BufferedIOBase(IOBase):
def closed(self):
return self.raw.closed
+ @property
+ def name(self):
+ return self.raw.name
+
+ @property
+ def mode(self):
+ return self.raw.mode
+
### Lower-level APIs ###
def fileno(self):
def closed(self):
return self.buffer.closed
+ @property
+ def name(self):
+ return self.buffer.name
+
def fileno(self):
return self.buffer.fileno()
def imap(self, func, iterable, chunksize=1):
'''
- Equivalent of `itertool.imap()` -- can be MUCH slower than `Pool.map()`
+ Equivalent of `itertools.imap()` -- can be MUCH slower than `Pool.map()`
'''
assert self._state == RUN
if chunksize == 1:
# Issue 4348. Make sure that operations that don't mutate the array
# copy the bytes.
b = bytearray(b'abc')
- #self.assertFalse(b is b.replace(b'abc', b'cde', 0))
+ self.assertFalse(b is b.replace(b'abc', b'cde', 0))
t = bytearray([i for i in range(256)])
x = bytearray(b'')
self.assertRaises(ValueError, io.open, test_support.TESTFN, 'w',
closefd=False)
+ def testReadClosed(self):
+ with io.open(test_support.TESTFN, "w") as f:
+ f.write("egg\n")
+ with io.open(test_support.TESTFN, "r") as f:
+ file = io.open(f.fileno(), "r", closefd=False)
+ self.assertEqual(file.read(), "egg\n")
+ file.seek(0)
+ file.close()
+ self.assertRaises(ValueError, file.read)
+
+ def test_no_closefd_with_filename(self):
+ # can't use closefd in combination with a file name
+ self.assertRaises(ValueError,
+ io.open, test_support.TESTFN, "r", closefd=False)
+
+ def test_closefd_attr(self):
+ with io.open(test_support.TESTFN, "wb") as f:
+ f.write(b"egg\n")
+ with io.open(test_support.TESTFN, "r") as f:
+ self.assertEqual(f.buffer.raw.closefd, True)
+ file = io.open(f.fileno(), "r", closefd=False)
+ self.assertEqual(file.buffer.raw.closefd, False)
+
+
class MemorySeekTestMixin:
def testInit(self):
class MiscIOTest(unittest.TestCase):
+ def tearDown(self):
+ test_support.unlink(test_support.TESTFN)
+
def testImport__all__(self):
for name in io.__all__:
obj = getattr(io, name, None)
self.assert_(issubclass(obj, io.IOBase))
+ def test_attributes(self):
+ f = io.open(test_support.TESTFN, "wb", buffering=0)
+ self.assertEquals(f.mode, "w")
+ f.close()
+
+ f = io.open(test_support.TESTFN, "U")
+ self.assertEquals(f.name, test_support.TESTFN)
+ self.assertEquals(f.buffer.name, test_support.TESTFN)
+ self.assertEquals(f.buffer.raw.name, test_support.TESTFN)
+ self.assertEquals(f.mode, "U")
+ self.assertEquals(f.buffer.mode, "r")
+ self.assertEquals(f.buffer.raw.mode, "r")
+ f.close()
+
+ f = io.open(test_support.TESTFN, "w+")
+ self.assertEquals(f.mode, "w+")
+ self.assertEquals(f.buffer.mode, "r+") # Does it really matter?
+ self.assertEquals(f.buffer.raw.mode, "r+")
+
+ g = io.open(f.fileno(), "wb", closefd=False)
+ self.assertEquals(g.mode, "w")
+ self.assertEquals(g.raw.mode, "w")
+ self.assertEquals(g.name, f.fileno())
+ self.assertEquals(g.raw.name, f.fileno())
+ f.close()
+ g.close()
+
+
def test_main():
test_support.run_unittest(IOTest, BytesIOTest, StringIOTest,
BufferedReaderTest, BufferedWriterTest,
import mimetools
import httplib
import socket
+import StringIO
import os
from test import test_support
os.remove("xmldata.txt")
os.remove(test_support.TESTFN)
+class FakeSocket:
+
+ def __init__(self):
+ self.data = StringIO.StringIO()
+
+ def send(self, buf):
+ self.data.write(buf)
+ return len(buf)
+
+ def sendall(self, buf):
+ self.data.write(buf)
+
+ def getvalue(self):
+ return self.data.getvalue()
+
+ def makefile(self, x, y):
+ raise RuntimeError
+
+class FakeTransport(xmlrpclib.Transport):
+ """A Transport instance that records instead of sending a request.
+
+ This class replaces the actual socket used by httplib with a
+ FakeSocket object that records the request. It doesn't provide a
+ response.
+ """
+
+ def make_connection(self, host):
+ conn = xmlrpclib.Transport.make_connection(self, host)
+ conn._conn.sock = self.fake_socket = FakeSocket()
+ return conn
+
+class TransportSubclassTestCase(unittest.TestCase):
+
+ def issue_request(self, transport_class):
+ """Return an HTTP request made via transport_class."""
+ transport = transport_class()
+ proxy = xmlrpclib.ServerProxy("http://example.com/",
+ transport=transport)
+ try:
+ proxy.pow(6, 8)
+ except RuntimeError:
+ return transport.fake_socket.getvalue()
+ return None
+
+ def test_custom_user_agent(self):
+ class TestTransport(FakeTransport):
+
+ def send_user_agent(self, conn):
+ xmlrpclib.Transport.send_user_agent(self, conn)
+ conn.putheader("X-Test", "test_custom_user_agent")
+
+ req = self.issue_request(TestTransport)
+ self.assert_("X-Test: test_custom_user_agent\r\n" in req)
+
+ def test_send_host(self):
+ class TestTransport(FakeTransport):
+
+ def send_host(self, conn, host):
+ xmlrpclib.Transport.send_host(self, conn, host)
+ conn.putheader("X-Test", "test_send_host")
+
+ req = self.issue_request(TestTransport)
+ self.assert_("X-Test: test_send_host\r\n" in req)
+
+ def test_send_request(self):
+ class TestTransport(FakeTransport):
+
+ def send_request(self, conn, url, body):
+ xmlrpclib.Transport.send_request(self, conn, url, body)
+ conn.putheader("X-Test", "test_send_request")
+
+ req = self.issue_request(TestTransport)
+ self.assert_("X-Test: test_send_request\r\n" in req)
+
+ def test_send_content(self):
+ class TestTransport(FakeTransport):
+
+ def send_content(self, conn, body):
+ conn.putheader("X-Test", "test_send_content")
+ xmlrpclib.Transport.send_content(self, conn, body)
+
+ req = self.issue_request(TestTransport)
+ self.assert_("X-Test: test_send_content\r\n" in req)
+
def test_main():
xmlrpc_tests = [XMLRPCTestCase, HelperTestCase, DateTimeTestCase,
- BinaryTestCase, FaultTestCase]
+ BinaryTestCase, FaultTestCase, TransportSubclassTestCase]
# The test cases against a SimpleXMLRPCServer raise a socket error
# 10035 (WSAEWOULDBLOCK) in the server thread handle_request call when
Core and Builtins
-----------------
+- Issue #4233: Changed semantic of ``_fileio.FileIO``'s ``close()``
+ method on file objects with closefd=False. The file descriptor is still
+ kept open but the file object behaves like a closed file. The ``FileIO``
+ object also got a new readonly attribute ``closefd``.
+
Library
-------
fileio_close(PyFileIOObject *self)
{
if (!self->closefd) {
- if (PyErr_WarnEx(PyExc_RuntimeWarning,
- "Trying to close unclosable fd!", 3) < 0) {
- return NULL;
- }
+ self->fd = -1;
Py_RETURN_NONE;
}
errno = internal_close(self);
return PyBool_FromLong((long)(self->fd < 0));
}
+static PyObject *
+get_closefd(PyFileIOObject *self, void *closure)
+{
+ return PyBool_FromLong((long)(self->closefd));
+}
+
static PyObject *
get_mode(PyFileIOObject *self, void *closure)
{
static PyGetSetDef fileio_getsetlist[] = {
{"closed", (getter)get_closed, NULL, "True if the file is closed"},
+ {"closefd", (getter)get_closefd, NULL,
+ "True if the file descriptor will be closed"},
{"mode", (getter)get_mode, NULL, "String giving the file mode"},
{0},
};
projects / python / commitdiff