.. cvar:: int PyTrace_C_EXCEPTION
The value for the *what* parameter to :ctype:`Py_tracefunc` functions when a C
- function has thrown an exception.
+ function has raised an exception.
.. cvar:: int PyTrace_C_RETURN
*s*. Return *NULL* if an exception was raised by the codec.
-.. cfunction:: PyObject* PyUnicode_DecodeUTF8Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)
+.. cfunction:: PyObject* PyUnicode_DecodeUTF7Stateful(const char *s, Py_ssize_t size, const char *errors, Py_ssize_t *consumed)
If *consumed* is *NULL*, behave like :cfunc:`PyUnicode_DecodeUTF7`. If
*consumed* is not *NULL*, trailing incomplete UTF-7 base-64 sections will not
become a dangling pointer. Should it become a dangling pointer, C code which
raises the exception could cause a core dump or other unintended side effects.
-We discuss the use of PyMODINIT_FUNC as a function return type later in this
+We discuss the use of ``PyMODINIT_FUNC`` as a function return type later in this
sample.
+The :exc:`spam.error` exception can be raised in your extension module using a
+call to :cfunc:`PyErr_SetString` as shown below::
+
+ static PyObject *
+ spam_system(PyObject *self, PyObject *args)
+ {
+ const char *command;
+ int sts;
+
+ if (!PyArg_ParseTuple(args, "s", &command))
+ return NULL;
+ sts = system(command);
+ if (sts < 0) {
+ PyErr_SetString(SpamError, "System command failed");
+ return NULL;
+ }
+ return PyLong_FromLong(sts);
+ }
+
.. _backtoexample:
'/cgi-bin/some-cgi-script', data=qs)
msg, hdrs = req.read(), req.info()
-Note that in general for a percent-encoded POST operations, query strings must be
-quoted by using :func:`urllib.parse.urlencode`. For example to send name="Guy Steele,
+Note that in general for percent-encoded POST operations, query strings must be
+quoted using :func:`urllib.parse.urlencode`. For example to send name="Guy Steele,
Jr."::
>>> import urllib.parse
.. function:: b64encode(s, altchars=None)
- Encode a string use Base64.
+ Encode a byte string use Base64.
*s* is the string to encode. Optional *altchars* must be a string of at least
length 2 (additional characters are ignored) which specifies an alternative
generate URL or filesystem safe Base64 strings. The default is ``None``, for
which the standard Base64 alphabet is used.
- The encoded string is returned.
+ The encoded byte string is returned.
.. function:: b64decode(s, altchars=None)
- Decode a Base64 encoded string.
+ Decode a Base64 encoded byte string.
*s* is the string to decode. Optional *altchars* must be a string of at least
length 2 (additional characters are ignored) which specifies the alternative
alphabet used instead of the ``+`` and ``/`` characters.
- The decoded string is returned. A :exc:`TypeError` is raised if *s* were
+ The decoded byte string is returned. A :exc:`TypeError` is raised if *s* were
incorrectly padded or if there are non-alphabet characters present in the
string.
.. function:: standard_b64encode(s)
- Encode string *s* using the standard Base64 alphabet.
+ Encode byte string *s* using the standard Base64 alphabet.
.. function:: standard_b64decode(s)
- Decode string *s* using the standard Base64 alphabet.
+ Decode byte string *s* using the standard Base64 alphabet.
.. function:: urlsafe_b64encode(s)
- Encode string *s* using a URL-safe alphabet, which substitutes ``-`` instead of
+ Encode byte string *s* using a URL-safe alphabet, which substitutes ``-`` instead of
``+`` and ``_`` instead of ``/`` in the standard Base64 alphabet. The result
can still contain ``=``.
.. function:: urlsafe_b64decode(s)
- Decode string *s* using a URL-safe alphabet, which substitutes ``-`` instead of
+ Decode byte string *s* using a URL-safe alphabet, which substitutes ``-`` instead of
``+`` and ``_`` instead of ``/`` in the standard Base64 alphabet.
.. function:: b32encode(s)
- Encode a string using Base32. *s* is the string to encode. The encoded string
+ Encode a byte string using Base32. *s* is the string to encode. The encoded string
is returned.
.. function:: b32decode(s, casefold=False, map01=None)
- Decode a Base32 encoded string.
+ Decode a Base32 encoded byte string.
*s* is the string to decode. Optional *casefold* is a flag specifying whether a
lowercase alphabet is acceptable as input. For security purposes, the default
digit 0 is always mapped to the letter O). For security purposes the default is
``None``, so that 0 and 1 are not allowed in the input.
- The decoded string is returned. A :exc:`TypeError` is raised if *s* were
+ The decoded byte string is returned. A :exc:`TypeError` is raised if *s* were
incorrectly padded or if there are non-alphabet characters present in the
string.
.. function:: b16encode(s)
- Encode a string using Base16.
+ Encode a byte string using Base16.
- *s* is the string to encode. The encoded string is returned.
+ *s* is the string to encode. The encoded byte string is returned.
.. function:: b16decode(s, casefold=False)
- Decode a Base16 encoded string.
+ Decode a Base16 encoded byte string.
*s* is the string to decode. Optional *casefold* is a flag specifying whether a
lowercase alphabet is acceptable as input. For security purposes, the default
is ``False``.
- The decoded string is returned. A :exc:`TypeError` is raised if *s* were
+ The decoded byte string is returned. A :exc:`TypeError` is raised if *s* were
incorrectly padded or if there are non-alphabet characters present in the
string.
* ``"exception"``: An exception has occurred.
* ``"c_call"``: A C function is about to be called.
* ``"c_return"``: A C function has returned.
- * ``"c_exception"``: A C function has thrown an exception.
+ * ``"c_exception"``: A C function has raised an exception.
For the Python events, specialized functions (see below) are called. For
the C events, no action is taken.
:func:`~xml.sax.saxutils.quoteattr` function in the :mod:`xml.sax.saxutils`
module instead.
+ If the value to be quoted might include single- or double-quote characters,
+ or both, consider using the :func:`quoteattr` function in the
+ :mod:`xml.sax.saxutils` module instead.
+
.. _cgi-security:
are the beginning and ending indexes of the prefix text, which could be used to
provide different completion depending upon which position the argument is in.
- All subclasses of :class:`Cmd` inherit a predefined :meth:`do_help`. This
+ All subclasses of :class:`Cmd` inherit a predefined :meth:`do_help`. This
method, called with an argument ``'bar'``, invokes the corresponding method
- :meth:`help_bar`. With no argument, :meth:`do_help` lists all available help
- topics (that is, all commands with corresponding :meth:`help_\*` methods), and
- also lists any undocumented commands.
+ :meth:`help_bar`, and if that is not present, prints the docstring of
+ :meth:`do_bar`, if available. With no argument, :meth:`do_help` lists all
+ available help topics (that is, all commands with corresponding
+ :meth:`help_\*` methods or commands that have docstrings), and also lists any
+ undocumented commands.
.. method:: Cmd.onecmd(str)
.. exception:: DocTestFailure(test, example, got)
- An exception thrown by :class:`DocTestRunner` to signal that a doctest example's
+ An exception raised by :class:`DocTestRunner` to signal that a doctest example's
actual output did not match its expected output. The constructor arguments are
used to initialize the member variables of the same names.
.. exception:: UnexpectedException(test, example, exc_info)
- An exception thrown by :class:`DocTestRunner` to signal that a doctest example
- raised an unexpected exception. The constructor arguments are used to
- initialize the member variables of the same names.
+ An exception raised by :class:`DocTestRunner` to signal that a doctest
+ example raised an unexpected exception. The constructor arguments are used
+ to initialize the member variables of the same names.
:exc:`UnexpectedException` defines the following member variables:
.. exception:: MessageParseError()
- This is the base class for exceptions thrown by the :class:`~email.parser.Parser`
+ This is the base class for exceptions raised by the :class:`~email.parser.Parser`
class. It is derived from :exc:`MessageError`.
Method called when an unrecognized SGML declaration is read by the parser.
The *data* parameter will be the entire contents of the declaration inside
the ``<!...>`` markup. It is sometimes useful to be be overridden by a
- derived class; the base class implementation throws an :exc:`HTMLParseError`.
+ derived class; the base class implementation raises an :exc:`HTMLParseError`.
.. method:: HTMLParser.handle_pi(data)
.. function:: getline(filename, lineno, module_globals=None)
- Get line *lineno* from file named *filename*. This function will never throw an
+ Get line *lineno* from file named *filename*. This function will never raise an
exception --- it will return ``''`` on errors (the terminating newline character
will be included for lines that are found).
Copy the *count* bytes starting at offset *src* to the destination index
*dest*. If the mmap was created with :const:`ACCESS_READ`, then calls to
- move will throw a :exc:`TypeError` exception.
+ move will raise a :exc:`TypeError` exception.
.. method:: read(num)
Resizes the map and the underlying file, if any. If the mmap was created
with :const:`ACCESS_READ` or :const:`ACCESS_COPY`, resizing the map will
- throw a :exc:`TypeError` exception.
+ raise a :exc:`TypeError` exception.
.. method:: rfind(sub[, start[, end]])
Write the bytes in *bytes* into memory at the current position of the
file pointer; the file position is updated to point after the bytes that
were written. If the mmap was created with :const:`ACCESS_READ`, then
- writing to it will throw a :exc:`TypeError` exception.
+ writing to it will raise a :exc:`TypeError` exception.
.. method:: write_byte(byte)
Write the the integer *byte* into memory at the current
position of the file pointer; the file position is advanced by ``1``. If
the mmap was created with :const:`ACCESS_READ`, then writing to it will
- throw a :exc:`TypeError` exception.
-
-
+ raise a :exc:`TypeError` exception.
The :func:`expr` function parses the parameter *source* as if it were an input
to ``compile(source, 'file.py', 'eval')``. If the parse succeeds, an ST object
is created to hold the internal parse tree representation, otherwise an
- appropriate exception is thrown.
+ appropriate exception is raised.
.. function:: suite(source)
The :func:`suite` function parses the parameter *source* as if it were an input
to ``compile(source, 'file.py', 'exec')``. If the parse succeeds, an ST object
is created to hold the internal parse tree representation, otherwise an
- appropriate exception is thrown.
+ appropriate exception is raised.
.. function:: sequence2st(sequence)
to the Python grammar and all nodes are valid node types in the host version of
Python, an ST object is created from the internal representation and returned
to the called. If there is a problem creating the internal representation, or
- if the tree cannot be validated, a :exc:`ParserError` exception is thrown. An
+ if the tree cannot be validated, a :exc:`ParserError` exception is raised. An
ST object created this way should not be assumed to compile correctly; normal
- exceptions thrown by compilation may still be initiated when the ST object is
+ exceptions raised by compilation may still be initiated when the ST object is
passed to :func:`compilest`. This may indicate problems not related to syntax
(such as a :exc:`MemoryError` exception), but may also be due to constructs such
as the result of parsing ``del f(0)``, which escapes the Python parser but is
.. exception:: ParserError
Exception raised when a failure occurs within the parser module. This is
- generally produced for validation failures rather than the built in
- :exc:`SyntaxError` thrown during normal parsing. The exception argument is
+ generally produced for validation failures rather than the built-in
+ :exc:`SyntaxError` raised during normal parsing. The exception argument is
either a string describing the reason of the failure or a tuple containing a
sequence causing the failure from a parse tree passed to :func:`sequence2st`
and an explanatory string. Calls to :func:`sequence2st` need to be able to
will only need to be aware of the simple string values.
Note that the functions :func:`compilest`, :func:`expr`, and :func:`suite` may
-throw exceptions which are normally thrown by the parsing and compilation
+raise exceptions which are normally thrown by the parsing and compilation
process. These include the built in exceptions :exc:`MemoryError`,
:exc:`OverflowError`, :exc:`SyntaxError`, and :exc:`SystemError`. In these
cases, these exceptions carry all the meaning normally associated with them.
Called if the XML document hasn't been declared as being a standalone document.
This happens when there is an external subset or a reference to a parameter
entity, but the XML declaration does not set standalone to ``yes`` in an XML
- declaration. If this handler returns ``0``, then the parser will throw an
+ declaration. If this handler returns ``0``, then the parser will raise an
:const:`XML_ERROR_NOT_STANDALONE` error. If this handler is not set, no
exception is raised by the parser for this condition.
responsible for creating the sub-parser using
``ExternalEntityParserCreate(context)``, initializing it with the appropriate
callbacks, and parsing the entity. This handler should return an integer; if it
- returns ``0``, the parser will throw an
+ returns ``0``, the parser will raise an
:const:`XML_ERROR_EXTERNAL_ENTITY_HANDLING` error, otherwise parsing will
continue.
and ESMTP options suppressed.
This method will return normally if the mail is accepted for at least one
- recipient. Otherwise it will throw an exception. That is, if this method does
- not throw an exception, then someone should get your mail. If this method does
- not throw an exception, it returns a dictionary, with one entry for each
+ recipient. Otherwise it will raise an exception. That is, if this method does
+ not raise an exception, then someone should get your mail. If this method does
+ not raise an exception, it returns a dictionary, with one entry for each
recipient that was refused. Each entry contains a tuple of the SMTP error code
and the accompanying error message sent by the server.
the format string (integers for positional arguments, and strings for
named arguments), and a reference to the *args* and *kwargs* that was
passed to vformat. The set of unused args can be calculated from these
- parameters. :meth:`check_unused_args` is assumed to throw an exception if
+ parameters. :meth:`check_unused_args` is assumed to raise an exception if
the check fails.
.. method:: format_field(value, format_spec)
A C function has returned. *arg* is ``None``.
``'c_exception'``
- A C function has thrown an exception. *arg* is ``None``.
+ A C function has raised 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.
>>> o.geturl()
'http://www.cwi.nl:80/%7Eguido/Python.html'
- If the scheme value is not specified, urlparse following the syntax
- specifications from RFC 1808, expects the netloc value to start with '//',
- Otherwise, it is not possible to distinguish between net_loc and path
- component and would classify the indistinguishable component as path as in
- a relative url.
+ If the scheme value is not specified, urlparse expects the netloc value to
+ start with '//', following the syntax specifications from :rfc:`1808`.
+ Otherwise, it is not possible to distinguish between netloc and path
+ components, and would the indistinguishable component would be classified
+ as the path as in a relative URL.
>>> from urlparse import urlparse
>>> urlparse('//www.cwi.nl:80/%7Eguido/Python.html')
.. class:: Headers(headers)
Create a mapping-like object wrapping *headers*, which must be a list of header
- name/value tuples as described in :pep:`333`. Any changes made to the new
- :class:`Headers` object will directly update the *headers* list it was created
- with.
+ name/value tuples as described in :pep:`333`.
:class:`Headers` objects support typical mapping operations including
:meth:`__getitem__`, :meth:`get`, :meth:`__setitem__`, :meth:`setdefault`,
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
+ they cannot support the requested locale, however, they must raise a SAX
exception. Applications may request a locale change in the middle of a parse.
defined in `PKZIP Application Note
<http://www.pkware.com/documents/casestudies/APPNOTE.TXT>`_.
-This module does not currently handle multi-disk ZIP files, or ZIP files
-which have appended comments (although it correctly handles comments
-added to individual archive members---for which see the :ref:`zipinfo-objects`
-documentation). It can handle ZIP files that use the ZIP64 extensions
+This module does not currently handle multi-disk ZIP files.
+It can handle ZIP files that use the ZIP64 extensions
(that is ZIP files that are more than 4 GByte in size). It supports
decryption of encrypted files in ZIP archives, but it currently cannot
create an encrypted file. Decryption is extremely slow as it is
Returns ``True`` if *filename* is a valid ZIP file based on its magic number,
otherwise returns ``False``. *filename* may be a file or file-like object too.
- This module does not currently handle ZIP files which have appended comments.
.. versionchanged:: 3.1
Support for file and file-like objects.
A *namespace* is a mapping from names to objects. Most namespaces are currently
implemented as Python dictionaries, but that's normally not noticeable in any
way (except for performance), and it may change in the future. Examples of
-namespaces are: the set of built-in names (functions such as :func:`abs`, and
+namespaces are: the set of built-in names (containing functions such as :func:`abs`, and
built-in exception names); the global names in a module; and the local names in
a function invocation. In a sense the set of attributes of an object also form
a namespace. The important thing to know about namespaces is that there is
deprecated APIs and removes support for Python versions earlier than 2.3. The
3.0 version of the package uses a new incremental parser for MIME messages,
available in the :mod:`email.FeedParser` module. The new parser doesn't require
- reading the entire message into memory, and doesn't throw exceptions if a
+ reading the entire message into memory, and doesn't raise exceptions if a
message is malformed; instead it records any problems in the :attr:`defect`
attribute of the message. (Developed by Anthony Baxter, Barry Warsaw, Thomas
Wouters, and others.)
}
PyDoc_STRVAR(pyepoll_register_doc,
-"register(fd[, eventmask]) -> bool\n\
+"register(fd[, eventmask]) -> None\n\
\n\
-Registers a new fd or modifies an already registered fd. register() returns\n\
-True if a new fd was registered or False if the event mask for fd was modified.\n\
+Registers a new fd or modifies an already registered fd.\n\
fd is the target file descriptor of the operation.\n\
events is a bit set composed of the various EPOLL constants; the default\n\
is EPOLL_IN | EPOLL_OUT | EPOLL_PRI.\n\
We try to have a comprehensive overview of the changes in the "What's New in
Python 3.1" document, found at
- http://docs.python.org/dev/3.1/whatsnew/3.1.html
+ http://docs.python.org/3.1/whatsnew/3.1.html
For a more detailed change log, read Misc/NEWS (though this file, too,
is incomplete, and also doesn't list anything merged in from the 2.7
Documentation for Python 3.1 is online, updated twice a day:
- http://docs.python.org/dev/3.1/
+ http://docs.python.org/3.1/
All documentation is also available online at the Python web site
(http://docs.python.org/, see below). It is available online for
A source-to-source translation tool, "2to3", can take care of the mundane task
of converting large amounts of source code. It is not a complete solution but
is complemented by the deprecation warnings in 2.6. See
-http://docs.python.org/dev/py3k/library/2to3.html for more information.
+http://docs.python.org/py3k/library/2to3.html for more information.
Testing
HKCU = winreg.HKEY_CURRENT_USER
ENV = "Environment"
PATH = "PATH"
-DEFAULT = u"%PATH%"
+DEFAULT = "%PATH%"
def modify():
pythonpath = os.path.dirname(os.path.normpath(sys.executable))
+++ /dev/null
-This is versioncheck 1.0, a first stab at automatic checking of versions of
-Python extension packages installed on your system.
-
-The basic idea is that each package contains a _checkversion.py
-somewhere, probably at the root level of the package. In addition, each
-package maintainer makes a file available on the net, through ftp or
-http, which contains the version number of the most recent distribution
-and some readable text explaining the differences with previous
-versions, where to download the package, etc.
-
-The checkversions.py script walks through the installed Python tree (or
-through a tree of choice), and runs each _checkversion.py script. These
-scripts retrieve the current-version file over the net, compares version
-numbers and tells the user about new versions of packages available.
-
-A boilerplate for the _checkversion.py file can be found here. Replace
-package name, version and the URL of the version-check file and put it in
-your distribution. In stead of a single URL you can also specify a list
-of URLs. Each of these will be checked in order until one is available,
-this is handy for distributions that live in multiple places. Put the
-primary distribution site (the most up-to-date site) before others.
-The script is read and executed with exec(), not imported, and the current
-directory is the checkversion directory, so be careful with globals,
-importing, etc.
-
-The version-check file consists of an rfc822-style header followed by
-plaintext. The only header field checked currently is
-'Current-Version:', which should contain te current version and is
-matched against the string contained in the _checkversion.py script.
-The rest of the file is human-readable text and presented to the user if
-there is a version mismatch. It should contain at the very least a URL
-of either the current distribution or a webpage describing it.
-
-Pycheckversion.py is the module that does the actual checking of versions.
-It should be fine where it is, it is imported by checkversion before anything
-else is done, but if imports fail you may want to move it to somewhere
-along sys.path.
-
- Jack Jansen, CWI, 23-Dec-97.
- <jack@cwi.nl>
-
+++ /dev/null
-"""This file (which is sourced, not imported) checks the version of the
-"versioncheck" package. It is also an example of how to format your own
-_checkversion.py file"""
-
-import pyversioncheck
-
-_PACKAGE="versioncheck"
-_VERSION="1.0"
-_URL="http://www.cwi.nl/~jack/versioncheck/curversion.txt"
-
-try:
- _myverbose=VERBOSE
-except NameError:
- _myverbose=1
-
-pyversioncheck.versioncheck(_PACKAGE, _URL, _VERSION, verbose=_myverbose)
+++ /dev/null
-"""Checkversions - recursively search a directory (default: sys.prefix)
-for _checkversion.py files, and run each of them. This will tell you of
-new versions available for any packages you have installed."""
-
-import os
-import getopt
-import sys
-import pyversioncheck
-
-CHECKNAME="_checkversion.py"
-
-VERBOSE=1
-
-USAGE="""Usage: checkversions [-v verboselevel] [dir ...]
-Recursively examine a tree (default: sys.prefix) and for each package
-with a _checkversion.py file compare the installed version against the current
-version.
-
-Values for verboselevel:
-0 - Minimal output, one line per package
-1 - Also print descriptions for outdated packages (default)
-2 - Print information on each URL checked
-3 - Check every URL for packages with multiple locations"""
-
-def check1dir(dummy, dir, files):
- if CHECKNAME in files:
- fullname = os.path.join(dir, CHECKNAME)
- try:
- exec(open(fullname).read())
- except:
- print('** Exception in', fullname)
-
-def walk1tree(tree):
- os.walk(tree, check1dir, None)
-
-def main():
- global VERBOSE
- try:
- options, arguments = getopt.getopt(sys.argv[1:], 'v:')
- except getopt.error:
- print(USAGE)
- sys.exit(1)
- for o, a in options:
- if o == '-v':
- VERBOSE = int(a)
- if not arguments:
- arguments = [sys.prefix]
- for dir in arguments:
- walk1tree(dir)
-
-if __name__ == '__main__':
- main()
+++ /dev/null
-"""pyversioncheck - Module to help with checking versions"""
-import urllib.request
-import email
-import sys
-
-# Verbose options
-VERBOSE_SILENT=0 # Single-line reports per package
-VERBOSE_NORMAL=1 # Single-line reports per package, more info if outdated
-VERBOSE_EACHFILE=2 # Report on each URL checked
-VERBOSE_CHECKALL=3 # Check each URL for each package
-
-# Test directory
-## urllib bug: _TESTDIR="ftp://ftp.cwi.nl/pub/jack/python/versiontestdir/"
-_TESTDIR="http://www.cwi.nl/~jack/versiontestdir/"
-
-def versioncheck(package, url, version, verbose=0):
- ok, newversion, fp = checkonly(package, url, version, verbose)
- if verbose > VERBOSE_NORMAL:
- return ok
- if ok < 0:
- print('%s: No correctly formatted current version file found'%(package))
- elif ok == 1:
- print('%s: up-to-date (version %s)'%(package, version))
- else:
- print('%s: version %s installed, version %s found:' % \
- (package, version, newversion))
- if verbose > VERBOSE_SILENT:
- while 1:
- line = fp.readline()
- if not line: break
- sys.stdout.write('\t'+line)
- return ok
-
-def checkonly(package, url, version, verbose=0):
- if verbose >= VERBOSE_EACHFILE:
- print('%s:'%package)
- if isinstance(url, str):
- ok, newversion, fp = _check1version(package, url, version, verbose)
- else:
- for u in url:
- ok, newversion, fp = _check1version(package, u, version, verbose)
- if ok >= 0 and verbose < VERBOSE_CHECKALL:
- break
- return ok, newversion, fp
-
-def _check1version(package, url, version, verbose=0):
- if verbose >= VERBOSE_EACHFILE:
- print(' Checking %s'%url)
- try:
- fp = urllib.request.urlopen(url)
- except IOError as arg:
- if verbose >= VERBOSE_EACHFILE:
- print(' Cannot open:', arg)
- return -1, None, None
- msg = email.message_from_file(fp)
- newversion = msg.get('current-version')
- if not newversion:
- if verbose >= VERBOSE_EACHFILE:
- print(' No "Current-Version:" header in URL or URL not found')
- return -1, None, None
- version = version.lower().strip()
- newversion = newversion.lower().strip()
- if version == newversion:
- if verbose >= VERBOSE_EACHFILE:
- print(' Version identical (%s)'%newversion)
- return 1, version, fp
- else:
- if verbose >= VERBOSE_EACHFILE:
- print(' Versions different (installed: %s, new: %s)'% \
- (version, newversion))
- return 0, newversion, fp
-
-
-def _test():
- print('--- TEST VERBOSE=1')
- print('--- Testing existing and identical version file')
- versioncheck('VersionTestPackage', _TESTDIR+'Version10.txt', '1.0', verbose=1)
- print('--- Testing existing package with new version')
- versioncheck('VersionTestPackage', _TESTDIR+'Version11.txt', '1.0', verbose=1)
- print('--- Testing package with non-existing version file')
- versioncheck('VersionTestPackage', _TESTDIR+'nonexistent.txt', '1.0', verbose=1)
- print('--- Test package with 2 locations, first non-existing second ok')
- versfiles = [_TESTDIR+'nonexistent.txt', _TESTDIR+'Version10.txt']
- versioncheck('VersionTestPackage', versfiles, '1.0', verbose=1)
- print('--- TEST VERBOSE=2')
- print('--- Testing existing and identical version file')
- versioncheck('VersionTestPackage', _TESTDIR+'Version10.txt', '1.0', verbose=2)
- print('--- Testing existing package with new version')
- versioncheck('VersionTestPackage', _TESTDIR+'Version11.txt', '1.0', verbose=2)
- print('--- Testing package with non-existing version file')
- versioncheck('VersionTestPackage', _TESTDIR+'nonexistent.txt', '1.0', verbose=2)
- print('--- Test package with 2 locations, first non-existing second ok')
- versfiles = [_TESTDIR+'nonexistent.txt', _TESTDIR+'Version10.txt']
- versioncheck('VersionTestPackage', versfiles, '1.0', verbose=2)
-
-if __name__ == '__main__':
- _test()
fi
AC_MSG_RESULT($with_doc_strings)
-# Check for Python-specific malloc support
+# Check if eval loop should use timestamp counter profiling
AC_MSG_CHECKING(for --with-tsc)
AC_ARG_WITH(tsc,
[ --with(out)-tsc enable/disable timestamp counter profile], [
projects / python / commitdiff