Merge remote-tracking branch 'upstream/master'

.gitignore

@@ -4,17 +4,22 @@ __pycache__
 *.so
 *.o
 
+*.egg
+*.egg-info
+
 Cython/Compiler/*.c
 Cython/Plex/*.c
 Cython/Runtime/refnanny.c
 Cython/Tempita/*.c
+Cython/*.c
 
 Tools/*.elc
 
-BUILD/
-build/
+/TEST_TMP/
+/build/
+/wheelhouse*/
 !tests/build/
-dist/
+/dist/
 .gitrev
 .coverage
 *.orig
@@ -25,5 +30,6 @@ dist/
 
 tags
 TAGS
+MANIFEST
 
 .tox

.hgignore

@@ -3,12 +3,14 @@ syntax: glob
 *.pyc
 *.pyo
 __pycache__
+*.egg
+*.egg-info
 
 Cython/Compiler/*.c
 Cython/Plex/*.c
 Cython/Runtime/refnanny.c
 
-BUILD/
+TEST_TMP/
 build/
 dist/
 .git/

.hgtags

@@ -49,3 +49,7 @@ c1a18ab6b0808e87f68d2f9d914c01934510aef5 0.18b1
 52beb5b16df5b8a92bb6c8c47faf42370d73cb0f 0.19b2
 4818f5b68eb4b4ea6ad7e415f6672b491e2461bc 0.19rc1
 48407fa3f3c9da84ab3dc103a6a2b1ca4c1beb2a 0.19
+58fc9a3feb83f571623a492256885d21945decb4 0.21.1
+58fc9a3feb83f571623a492256885d21945decb4 0.21.1
+d05a4acd45fca9bdc12cef82890ca569fbaae1a5 0.21.1
+ab1a3afb8775a09d37c0d478476987eee8e734a6 0.21.2

.mailmap

+Stefan Behnel <stefan_ml@behnel.de> Stefan Behnel <scoder@users.berlios.de>
+Stefan Behnel <stefan_ml@behnel.de> scoder <stefan_ml@behnel.de>
+Stefan Behnel <stefan_ml@behnel.de> Stefan Behnel <stb@skoobe.de>
+Robert Bradshaw <robertwb@gmail.com> Robert Bradshaw <robertwb@math.washington.edu>
+Robert Bradshaw <robertwb@gmail.com> Robert Bradshaw <robertwb@google.com>
+Robert Bradshaw <robertwb@gmail.com> robertwb <robertwb@gmail.com>
+Robert Bradshaw <robertwb@gmail.com> Robert Bradshaw <robertwb@robertwb-macbookpro.local>
+Mark Florisson <markflorisson88@gmail.com> Mark <markflorisson88@gmail.com>
+Mark Florisson <markflorisson88@gmail.com> Mark Florisson <eggy.nospam@gmail.com>
+Lars Buitinck <larsmans@gmail.com> Lars Buitinck <L.J.Buitinck@uva.nl>
+Danilo Freitas <dsurviver@gmail.com> DaniloFreitas <dsurviver@gmail.com>
+Danilo Freitas <dsurviver@gmail.com> daniloaf@daniloaf-PC <none@none>
+Danilo Freitas <dsurviver@gmail.com> daniloaf <none@none>
+Lisandro Dalcin <dalcinl@gmail.com> dalcinl <none@none>
+Christoph Gohlke <cgohlke@uci.edu> cgohlke <cgohlke@uci.edu>

.travis.yml

-language: python
+os: linux
+dist: trusty
+sudo: false
+
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - gdb
+      - python-dbg
+      - python3-dbg
+      - gcc-6
+      - g++-6
+      # GCC-7 currently takes 5-7 *minutes* to download on travis
+      #- gcc-7
+      #- g++-7
 
+cache:
+  pip: true
+  directories:
+    - $HOME/.ccache
+
+language: python
 python:
-  - 2.6
   - 2.7
-  - 3.2
+  - 3.6
+  - 2.6
   - 3.3
+  - 3.4
+  - 3.5
+  - 3.6-dev
+  - 3.7-dev
+  - pypy
+  - pypy3
 
-#  - pypy
+env:
+  global:
+    - USE_CCACHE=1
+    - CCACHE_SLOPPINESS=pch_defines,time_macros
+    - CCACHE_COMPRESS=1
+    - CCACHE_MAXSIZE=150M
+    - PATH="/usr/lib/ccache:$HOME/gcc-symlinks:$PATH"
+  matrix:
+    - BACKEND=c
+    - BACKEND=cpp
+
+matrix:
+  include:
+    #- python: 3.7-dev
+    #  env: BACKEND=c PY=3 CC=gcc-7
+    - os: osx
+      osx_image: xcode6.4
+      env: BACKEND=c PY=2
+      python: 2
+      language: c
+      compiler: clang
+      cache: false
+    - os: osx
+      osx_image: xcode6.4
+      env: BACKEND=cpp PY=2
+      python: 2
+      language: cpp
+      compiler: clang
+      cache: false
+    - os: osx
+      osx_image: xcode6.4
+      env: BACKEND=c PY=3
+      python: 3
+      language: c
+      compiler: clang
+      cache: false
+    - os: osx
+      osx_image: xcode6.4
+      env: BACKEND=cpp PY=3
+      python: 3
+      language: cpp
+      compiler: clang
+      cache: false
+  allow_failures:
+    - python: pypy
+    - python: pypy3
+  exclude:
+    - python: pypy
+      env: BACKEND=cpp
+    - python: pypy3
+      env: BACKEND=cpp
 
 branches:
   only:
     - master
+    - release
 
-install: pip install .
+before_install:
+  - |
+    if [[ "$TRAVIS_OS_NAME" == "linux" ]]; then
+      mkdir "$HOME/gcc-symlinks"
+      ln -s /usr/bin/gcc-6 $HOME/gcc-symlinks/gcc 
+      ln -s /usr/bin/g++-6 $HOME/gcc-symlinks/g++ 
+      
+      if [ -n "$CC" ]; then "$CC" --version; else gcc --version; fi
+    fi
 
-script: CFLAGS=-O0 python runtests.py -vv
+  - |
+    if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then # Install Miniconda
+      curl -s -o miniconda.sh https://repo.continuum.io/miniconda/Miniconda$PY-latest-MacOSX-x86_64.sh;
+      bash miniconda.sh -b -p $HOME/miniconda && rm miniconda.sh;
+      export PATH="$HOME/miniconda/bin:$PATH"; hash -r;
+      #conda install --quiet --yes nomkl --file=test-requirements.txt --file=test-requirements-cpython.txt;
+    fi
 
-matrix:
-  allow_failures:
-    - python: pypy
+install:
+  - python -c 'import sys; print("Python %s" % (sys.version,))'
+  - if [ -n "${TRAVIS_PYTHON_VERSION##*-dev}" -a -n "${TRAVIS_PYTHON_VERSION##2.6*}" ]; then pip install -r test-requirements.txt $( [ -z "${TRAVIS_PYTHON_VERSION##pypy*}" ] || echo " -r test-requirements-cpython.txt" ) $( [ -n "${TRAVIS_PYTHON_VERSION##3.3*}" ] || echo " tornado<5.0" ) ; fi
+  - CFLAGS="-O2 -ggdb -Wall -Wextra $(python -c 'import sys; print("-fno-strict-aliasing" if sys.version_info[0] == 2 else "")')" python setup.py build
+
+before_script: ccache -s || true
+
+script:
+  - PYTHON_DBG="python$( python -c 'import sys; print("%d.%d" % sys.version_info[:2])' )-dbg"
+  - if $PYTHON_DBG -V >&2; then CFLAGS="-O0 -ggdb" $PYTHON_DBG runtests.py -vv Debugger --backends=$BACKEND; fi
+  - if [ "$BACKEND" = "cpp" -a -n "${TRAVIS_PYTHON_VERSION##2.6*}" ]; then pip install pythran; fi
+  - CFLAGS="-O2 -ggdb -Wall -Wextra $(python -c 'import sys; print("-fno-strict-aliasing" if sys.version_info[0] == 2 else "")')" python setup.py build_ext -i
+  - CFLAGS="-O0 -ggdb -Wall -Wextra" python runtests.py -vv -x Debugger --backends=$BACKEND -j7

BUILD.bazel

+# Bazel build file for inclusion as external dependency.
+#
+# Most useful is the pyx_library rule from //Tools:rules.bzl
+# which mirrors py_library but compiles .pyx files.
+
+py_library(
+    name = "cython_lib",
+    srcs = glob(
+        ["Cython/**/*.py"],
+        exclude = [
+            "**/Tests/*.py",
+        ],
+    ) + ["cython.py"],
+    data = glob([
+        "Cython/**/*.pyx",
+        "Cython/Utility/*.*",
+        "Cython/Includes/**/*.pxd",
+    ]),
+    visibility = ["//visibility:public"],
+)
+
+py_binary(
+    name = "cythonize",
+    srcs = ["cythonize.py"],
+    visibility = ["//visibility:public"],
+    deps = ["cython_lib"],
+)
+
+py_binary(
+    name = "cython",
+    srcs = ["cython.py"],
+    visibility = ["//visibility:public"],
+    deps = ["cython_lib"],
+)

COPYING.txt

@@ -10,3 +10,10 @@ made to go from Pyrex to Cython are so licensed.
 
 See LICENSE.txt for more details.
 
+------------------
+
+The output of a Cython compilation is NOT considered a derivative
+work of Cython.  Specifically, though the compilation process may
+embed snippets of varying lengths into the final output, these
+snippets, as embedded in the output, do not encumber the resulting
+output with any license restrictions.

Cython/Build/BuildExecutable.py

@@ -7,12 +7,15 @@ Basic usage:
     python cythonrun somefile.py [ARGS]
 """
 
+from __future__ import absolute_import
+
 DEBUG = True
 
 import sys
 import os
 from distutils import sysconfig
 
+
 def get_config_var(name, default=''):
     return sysconfig.get_config_var(name) or default
 
@@ -68,7 +71,7 @@ def runcmd(cmd, shell=True):
         returncode = os.system(cmd)
     else:
         returncode = subprocess.call(cmd, shell=shell)
-    
+
     if returncode:
         sys.exit(returncode)
 
@@ -81,7 +84,7 @@ def ccompile(basename):
     runcmd([CC, '-c', '-o', basename+'.o', basename+'.c', '-I' + INCDIR] + CFLAGS.split())
 
 def cycompile(input_file, options=()):
-    from Cython.Compiler import Version, CmdLine, Main
+    from ..Compiler import Version, CmdLine, Main
     options, sources = CmdLine.parse_command_line(list(options or ()) + ['--embed', input_file])
     _debug('Using Cython %s to compile %s', Version.version, input_file)
     result = Main.compile(sources, options)

Cython/Build/Cythonize.py

 #!/usr/bin/env python
 
+from __future__ import absolute_import
+
 import os
 import shutil
 import tempfile
-
 from distutils.core import setup
-from Cython.Build.Dependencies import cythonize, extended_iglob
-from Cython.Utils import is_package_dir
-from Cython.Compiler import Options
+
+from .Dependencies import cythonize, extended_iglob
+from ..Utils import is_package_dir
+from ..Compiler import Options
 
 try:
     import multiprocessing
@@ -31,7 +33,7 @@ class _FakePool(object):
 def parse_directives(option, name, value, parser):
     dest = option.dest
     old_directives = dict(getattr(parser.values, dest,
-                                  Options.directive_defaults))
+                                  Options.get_directive_defaults()))
     directives = Options.parse_directive_list(
         value, relaxed_bool=True, current_settings=old_directives)
     setattr(parser.values, dest, directives)
@@ -60,9 +62,9 @@ def find_package_base(path):
 
 def cython_compile(path_pattern, options):
     pool = None
-    paths = map(os.path.abspath, extended_iglob(path_pattern))
+    all_paths = map(os.path.abspath, extended_iglob(path_pattern))
     try:
-        for path in paths:
+        for path in all_paths:
             if options.build_inplace:
                 base_dir = path
                 while not os.path.isdir(base_dir) or is_package_dir(base_dir):
@@ -72,8 +74,7 @@ def cython_compile(path_pattern, options):
 
             if os.path.isdir(path):
                 # recursively compiling a package
-                paths = [os.path.join(path, '**', '*.%s' % ext)
-                         for ext in ('py', 'pyx')]
+                paths = [os.path.join(path, '**', '*.{py,pyx}')]
             else:
                 # assume it's a file(-like thing)
                 paths = [path]
@@ -143,6 +144,8 @@ def parse_args(args):
                       help='set a cythonize option')
     parser.add_option('-3', dest='python3_mode', action='store_true',
                       help='use Python 3 syntax mode by default')
+    parser.add_option('-a', '--annotate', dest='annotate', action='store_true',
+                      help='generate annotated HTML page for source files')
 
     parser.add_option('-x', '--exclude', metavar='PATTERN', dest='excludes',
                       action='append', default=[],
@@ -186,6 +189,9 @@ def main(args=None):
         Options.error_on_unknown_names = False
         Options.error_on_uninitialized = False
 
+    if options.annotate:
+        Options.annotate = True
+
     for path in paths:
         cython_compile(path, options)
 

Cython/Build/Distutils.py

+from Cython.Distutils.build_ext import build_ext

Cython/Build/Tests/TestCyCache.py

+import difflib
+import glob
+import gzip
+import os
+import tempfile
+
+import Cython.Build.Dependencies
+import Cython.Utils
+from Cython.TestUtils import CythonTest
+
+
+class TestCyCache(CythonTest):
+
+    def setUp(self):
+        CythonTest.setUp(self)
+        self.temp_dir = tempfile.mkdtemp(
+            prefix='cycache-test',
+            dir='TEST_TMP' if os.path.isdir('TEST_TMP') else None)
+        self.src_dir = tempfile.mkdtemp(prefix='src', dir=self.temp_dir)
+        self.cache_dir = tempfile.mkdtemp(prefix='cache', dir=self.temp_dir)
+
+    def cache_files(self, file_glob):
+        return glob.glob(os.path.join(self.cache_dir, file_glob))
+
+    def fresh_cythonize(self, *args, **kwargs):
+        Cython.Utils.clear_function_caches()
+        Cython.Build.Dependencies._dep_tree = None  # discard method caches
+        Cython.Build.Dependencies.cythonize(*args, **kwargs)
+
+    def test_cycache_switch(self):
+        content1 = 'value = 1\n'
+        content2 = 'value = 2\n'
+        a_pyx = os.path.join(self.src_dir, 'a.pyx')
+        a_c = a_pyx[:-4] + '.c'
+
+        open(a_pyx, 'w').write(content1)
+        self.fresh_cythonize(a_pyx, cache=self.cache_dir)
+        self.fresh_cythonize(a_pyx, cache=self.cache_dir)
+        self.assertEqual(1, len(self.cache_files('a.c*')))
+        a_contents1 = open(a_c).read()
+        os.unlink(a_c)
+
+        open(a_pyx, 'w').write(content2)
+        self.fresh_cythonize(a_pyx, cache=self.cache_dir)
+        a_contents2 = open(a_c).read()
+        os.unlink(a_c)
+
+        self.assertNotEqual(a_contents1, a_contents2, 'C file not changed!')
+        self.assertEqual(2, len(self.cache_files('a.c*')))
+
+        open(a_pyx, 'w').write(content1)
+        self.fresh_cythonize(a_pyx, cache=self.cache_dir)
+        self.assertEqual(2, len(self.cache_files('a.c*')))
+        a_contents = open(a_c).read()
+        self.assertEqual(
+            a_contents, a_contents1,
+            msg='\n'.join(list(difflib.unified_diff(
+                a_contents.split('\n'), a_contents1.split('\n')))[:10]))
+
+    def test_cycache_uses_cache(self):
+        a_pyx = os.path.join(self.src_dir, 'a.pyx')
+        a_c = a_pyx[:-4] + '.c'
+        open(a_pyx, 'w').write('pass')
+        self.fresh_cythonize(a_pyx, cache=self.cache_dir)
+        a_cache = os.path.join(self.cache_dir, os.listdir(self.cache_dir)[0])
+        gzip.GzipFile(a_cache, 'wb').write('fake stuff'.encode('ascii'))
+        os.unlink(a_c)
+        self.fresh_cythonize(a_pyx, cache=self.cache_dir)
+        a_contents = open(a_c).read()
+        self.assertEqual(a_contents, 'fake stuff',
+                         'Unexpected contents: %s...' % a_contents[:100])
+
+    def test_multi_file_output(self):
+        a_pyx = os.path.join(self.src_dir, 'a.pyx')
+        a_c = a_pyx[:-4] + '.c'
+        a_h = a_pyx[:-4] + '.h'
+        a_api_h = a_pyx[:-4] + '_api.h'
+        open(a_pyx, 'w').write('cdef public api int foo(int x): return x\n')
+        self.fresh_cythonize(a_pyx, cache=self.cache_dir)
+        expected = [a_c, a_h, a_api_h]
+        for output in expected:
+            self.assertTrue(os.path.exists(output), output)
+            os.unlink(output)
+        self.fresh_cythonize(a_pyx, cache=self.cache_dir)
+        for output in expected:
+            self.assertTrue(os.path.exists(output), output)
+
+    def test_options_invalidation(self):
+        hash_pyx = os.path.join(self.src_dir, 'options.pyx')
+        hash_c = hash_pyx[:-len('.pyx')] + '.c'
+
+        open(hash_pyx, 'w').write('pass')
+        self.fresh_cythonize(hash_pyx, cache=self.cache_dir, cplus=False)
+        self.assertEqual(1, len(self.cache_files('options.c*')))
+
+        os.unlink(hash_c)
+        self.fresh_cythonize(hash_pyx, cache=self.cache_dir, cplus=True)
+        self.assertEqual(2, len(self.cache_files('options.c*')))
+
+        os.unlink(hash_c)
+        self.fresh_cythonize(hash_pyx, cache=self.cache_dir, cplus=False, show_version=False)
+        self.assertEqual(2, len(self.cache_files('options.c*')))
+
+        os.unlink(hash_c)
+        self.fresh_cythonize(hash_pyx, cache=self.cache_dir, cplus=False, show_version=True)
+        self.assertEqual(2, len(self.cache_files('options.c*')))

Cython/Build/Tests/TestInline.py

@@ -17,8 +17,8 @@ class TestInline(CythonTest):
     def setUp(self):
         CythonTest.setUp(self)
         self.test_kwds = dict(test_kwds)
-        if os.path.isdir('BUILD'):
-            lib_dir = os.path.join('BUILD','inline')
+        if os.path.isdir('TEST_TMP'):
+            lib_dir = os.path.join('TEST_TMP','inline')
         else:
             lib_dir = tempfile.mkdtemp(prefix='cython_inline_')
         self.test_kwds['lib_dir'] = lib_dir
@@ -40,13 +40,24 @@ class TestInline(CythonTest):
     def test_globals(self):
         self.assertEquals(inline("return global_value + 1", **self.test_kwds), global_value + 1)
 
-    def test_pure(self):    
+    def test_no_return(self):
+        self.assertEquals(inline("""
+            a = 1
+            cdef double b = 2
+            cdef c = []
+        """, **self.test_kwds), dict(a=1, b=2.0, c=[]))
+
+    def test_def_node(self):
+        foo = inline("def foo(x): return x * x", **self.test_kwds)['foo']
+        self.assertEquals(foo(7), 49)
+
+    def test_pure(self):
         import cython as cy
         b = inline("""
         b = cy.declare(float, a)
         c = cy.declare(cy.pointer(cy.float), &b)
         return b
-        """, a=3)
+        """, a=3, **self.test_kwds)
         self.assertEquals(type(b), float)
 
     if has_numpy:

Cython/Build/Tests/TestIpythonMagic.py

+# -*- coding: utf-8 -*-
+# tag: ipython
+
+"""Tests for the Cython magics extension."""
+
+from __future__ import absolute_import
+
+import os
+import sys
+from contextlib import contextmanager
+from Cython.Build import IpythonMagic
+from Cython.TestUtils import CythonTest
+
+try:
+    import IPython.testing.globalipapp
+    from IPython.utils import py3compat
+except ImportError:
+    # Disable tests and fake helpers for initialisation below.
+    class _py3compat(object):
+        def str_to_unicode(self, s):
+            return s
+
+    py3compat = _py3compat()
+
+    def skip_if_not_installed(_):
+        return None
+else:
+    def skip_if_not_installed(c):
+        return c
+
+try:
+    # disable IPython history thread before it gets started to avoid having to clean it up
+    from IPython.core.history import HistoryManager
+    HistoryManager.enabled = False
+except ImportError:
+    pass
+
+code = py3compat.str_to_unicode("""\
+def f(x):
+    return 2*x
+""")
+
+cython3_code = py3compat.str_to_unicode("""\
+def f(int x):
+    return 2 / x
+
+def call(x):
+    return f(*(x,))
+""")
+
+pgo_cython3_code = cython3_code + py3compat.str_to_unicode("""\
+def main():
+    for _ in range(100): call(5)
+main()
+""")
+
+
+if sys.platform == 'win32':
+    # not using IPython's decorators here because they depend on "nose"
+    try:
+        from unittest import skip as skip_win32
+    except ImportError:
+        # poor dev's silent @unittest.skip()
+        def skip_win32(dummy):
+            def _skip_win32(func):
+                return None
+            return _skip_win32
+else:
+    def skip_win32(dummy):
+        def _skip_win32(func):
+            def wrapper(*args, **kwargs):
+                func(*args, **kwargs)
+            return wrapper
+        return _skip_win32
+
+
+@skip_if_not_installed
+class TestIPythonMagic(CythonTest):
+
+    @classmethod
+    def setUpClass(cls):
+        CythonTest.setUpClass()
+        cls._ip = IPython.testing.globalipapp.get_ipython()
+
+    def setUp(self):
+        CythonTest.setUp(self)
+        self._ip.extension_manager.load_extension('cython')
+
+    def test_cython_inline(self):
+        ip = self._ip
+        ip.ex('a=10; b=20')
+        result = ip.run_cell_magic('cython_inline', '', 'return a+b')
+        self.assertEqual(result, 30)
+
+    @skip_win32('Skip on Windows')
+    def test_cython_pyximport(self):
+        ip = self._ip
+        module_name = '_test_cython_pyximport'
+        ip.run_cell_magic('cython_pyximport', module_name, code)
+        ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+        ip.run_cell_magic('cython_pyximport', module_name, code)
+        ip.ex('h = f(-10)')
+        self.assertEqual(ip.user_ns['h'], -20.0)
+        try:
+            os.remove(module_name + '.pyx')
+        except OSError:
+            pass
+
+    def test_cython(self):
+        ip = self._ip
+        ip.run_cell_magic('cython', '', code)
+        ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+
+    def test_cython_name(self):
+        # The Cython module named 'mymodule' defines the function f.
+        ip = self._ip
+        ip.run_cell_magic('cython', '--name=mymodule', code)
+        # This module can now be imported in the interactive namespace.
+        ip.ex('import mymodule; g = mymodule.f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+
+    def test_cython_language_level(self):
+        # The Cython cell defines the functions f() and call().
+        ip = self._ip
+        ip.run_cell_magic('cython', '', cython3_code)
+        ip.ex('g = f(10); h = call(10)')
+        if sys.version_info[0] < 3:
+            self.assertEqual(ip.user_ns['g'], 2 // 10)
+            self.assertEqual(ip.user_ns['h'], 2 // 10)
+        else:
+            self.assertEqual(ip.user_ns['g'], 2.0 / 10.0)
+            self.assertEqual(ip.user_ns['h'], 2.0 / 10.0)
+
+    def test_cython3(self):
+        # The Cython cell defines the functions f() and call().
+        ip = self._ip
+        ip.run_cell_magic('cython', '-3', cython3_code)
+        ip.ex('g = f(10); h = call(10)')
+        self.assertEqual(ip.user_ns['g'], 2.0 / 10.0)
+        self.assertEqual(ip.user_ns['h'], 2.0 / 10.0)
+
+    def test_cython2(self):
+        # The Cython cell defines the functions f() and call().
+        ip = self._ip
+        ip.run_cell_magic('cython', '-2', cython3_code)
+        ip.ex('g = f(10); h = call(10)')
+        self.assertEqual(ip.user_ns['g'], 2 // 10)
+        self.assertEqual(ip.user_ns['h'], 2 // 10)
+
+    @skip_win32('Skip on Windows')
+    def test_cython3_pgo(self):
+        # The Cython cell defines the functions f() and call().
+        ip = self._ip
+        ip.run_cell_magic('cython', '-3 --pgo', pgo_cython3_code)
+        ip.ex('g = f(10); h = call(10); main()')
+        self.assertEqual(ip.user_ns['g'], 2.0 / 10.0)
+        self.assertEqual(ip.user_ns['h'], 2.0 / 10.0)
+
+    @skip_win32('Skip on Windows')
+    def test_extlibs(self):
+        ip = self._ip
+        code = py3compat.str_to_unicode("""
+from libc.math cimport sin
+x = sin(0.0)
+        """)
+        ip.user_ns['x'] = 1
+        ip.run_cell_magic('cython', '-l m', code)
+        self.assertEqual(ip.user_ns['x'], 0)
+
+
+    def test_cython_verbose(self):
+        ip = self._ip
+        ip.run_cell_magic('cython', '--verbose', code)
+        ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+
+    def test_cython_verbose_thresholds(self):
+        @contextmanager
+        def mock_distutils():
+            class MockLog:
+                DEBUG = 1
+                INFO = 2
+                thresholds = [INFO]
+
+                def set_threshold(self, val):
+                    self.thresholds.append(val)
+                    return self.thresholds[-2]
+
+
+            new_log = MockLog()
+            old_log = IpythonMagic.distutils.log
+            try:
+                IpythonMagic.distutils.log = new_log
+                yield new_log
+            finally:
+                IpythonMagic.distutils.log = old_log
+
+        ip = self._ip
+        with mock_distutils() as verbose_log:
+            ip.run_cell_magic('cython', '--verbose', code)
+            ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+        self.assertEquals([verbose_log.INFO, verbose_log.DEBUG, verbose_log.INFO],
+                          verbose_log.thresholds)
+
+        with mock_distutils() as normal_log:
+            ip.run_cell_magic('cython', '', code)
+            ip.ex('g = f(10)')
+        self.assertEqual(ip.user_ns['g'], 20.0)
+        self.assertEquals([normal_log.INFO], normal_log.thresholds)

Cython/Build/__init__.py

-from Dependencies import cythonize
+from .Dependencies import cythonize
+from .Distutils import build_ext

Cython/Build/ipython-COPYING.rst

+=============================
+ The IPython licensing terms
+=============================
+
+IPython is licensed under the terms of the Modified BSD License (also known as
+New or Revised or 3-Clause BSD), as follows:
+
+- Copyright (c) 2008-2014, IPython Development Team
+- Copyright (c) 2001-2007, Fernando Perez <fernando.perez@colorado.edu>
+- Copyright (c) 2001, Janko Hauser <jhauser@zscout.de>
+- Copyright (c) 2001, Nathaniel Gray <n8gray@caltech.edu>
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+Neither the name of the IPython Development Team nor the names of its
+contributors may be used to endorse or promote products derived from this
+software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+About the IPython Development Team
+----------------------------------
+
+Fernando Perez began IPython in 2001 based on code from Janko Hauser
+<jhauser@zscout.de> and Nathaniel Gray <n8gray@caltech.edu>.  Fernando is still
+the project lead.
+
+The IPython Development Team is the set of all contributors to the IPython
+project.  This includes all of the IPython subprojects. A full list with
+details is kept in the documentation directory, in the file
+``about/credits.txt``.
+
+The core team that coordinates development on GitHub can be found here:
+https://github.com/ipython/.
+
+Our Copyright Policy
+--------------------
+
+IPython uses a shared copyright model. Each contributor maintains copyright
+over their contributions to IPython. But, it is important to note that these
+contributions are typically only changes to the repositories. Thus, the IPython
+source code, in its entirety is not the copyright of any single person or
+institution.  Instead, it is the collective copyright of the entire IPython
+Development Team.  If individual contributors want to maintain a record of what
+changes/contributions they have specific copyright on, they should indicate
+their copyright in the commit message of the change, when they commit the
+change to one of the IPython repositories.
+
+With this in mind, the following banner should be used in any source code file
+to indicate the copyright and license terms:
+
+::
+
+    # Copyright (c) IPython Development Team.
+    # Distributed under the terms of the Modified BSD License.

Cython/Compiler/AnalysedTreeTransforms.py

-from Visitor import ScopeTrackingTransform
-from Nodes import StatListNode, SingleAssignmentNode, CFuncDefNode, DefNode
-from ExprNodes import DictNode, DictItemNode, NameNode, UnicodeNode
-from PyrexTypes import py_object_type
-from Builtin import dict_type
-from StringEncoding import EncodedString
-import Symtab
+from __future__ import absolute_import
+
+from .Visitor import ScopeTrackingTransform
+from .Nodes import StatListNode, SingleAssignmentNode, CFuncDefNode, DefNode
+from .ExprNodes import DictNode, DictItemNode, NameNode, UnicodeNode
+from .PyrexTypes import py_object_type
+from .StringEncoding import EncodedString
+from . import Symtab
 
 class AutoTestDictTransform(ScopeTrackingTransform):
     # Handles autotestdict directive

Cython/Compiler/AutoDocTransforms.py

-from Cython.Compiler.Visitor import CythonTransform
-from Cython.Compiler.StringEncoding import EncodedString
-from Cython.Compiler import Options
-from Cython.Compiler import PyrexTypes, ExprNodes
+from __future__ import absolute_import, print_function
+
+from .Visitor import CythonTransform
+from .StringEncoding import EncodedString
+from . import Options
+from . import PyrexTypes, ExprNodes
+from ..CodeWriter import ExpressionWriter
+
+
+class AnnotationWriter(ExpressionWriter):
+
+    def visit_Node(self, node):
+        self.put(u"<???>")
+
+    def visit_LambdaNode(self, node):
+        # XXX Should we do better?
+        self.put("<lambda>")
+
 
 class EmbedSignature(CythonTransform):
 
     def __init__(self, context):
         super(EmbedSignature, self).__init__(context)
-        self.denv = None # XXX
         self.class_name = None
         self.class_node = None
 
-    unop_precedence = 11
-    binop_precedence = {
-        'or': 1,
-        'and': 2,
-        'not': 3,
-        'in': 4, 'not in': 4, 'is': 4, 'is not': 4, '<': 4, '<=': 4, '>': 4, '>=': 4, '!=': 4, '==': 4,
-        '|': 5,
-        '^': 6,
-        '&': 7,
-        '<<': 8, '>>': 8,
-        '+': 9, '-': 9,
-        '*': 10, '/': 10, '//': 10, '%': 10,
-        # unary: '+': 11, '-': 11, '~': 11
-        '**': 12}
-
-    def _fmt_expr_node(self, node, precedence=0):
-        if isinstance(node, ExprNodes.BinopNode) and not node.inplace:
-            new_prec = self.binop_precedence.get(node.operator, 0)
-            result = '%s %s %s' % (self._fmt_expr_node(node.operand1, new_prec),
-                                   node.operator,
-                                   self._fmt_expr_node(node.operand2, new_prec))
-            if precedence > new_prec:
-                result = '(%s)' % result
-        elif isinstance(node, ExprNodes.UnopNode):
-            result = '%s%s' % (node.operator,
-                               self._fmt_expr_node(node.operand, self.unop_precedence))
-            if precedence > self.unop_precedence:
-                result = '(%s)' % result
-        elif isinstance(node, ExprNodes.AttributeNode):
-            result = '%s.%s' % (self._fmt_expr_node(node.obj), node.attribute)
-        else:
-            result = node.name
+    def _fmt_expr(self, node):
+        writer = AnnotationWriter()
+        result = writer.write(node)
+        # print(type(node).__name__, '-->', result)
         return result
 
-    def _fmt_arg_defv(self, arg):
-        default_val = arg.default
-        if not default_val:
-            return None
-        try:
-            denv = self.denv  # XXX
-            ctval = default_val.compile_time_value(self.denv)
-            repr_val = repr(ctval)
-            if isinstance(default_val, ExprNodes.UnicodeNode):
-                if repr_val[:1] != 'u':
-                    return u'u%s' % repr_val
-            elif isinstance(default_val, ExprNodes.BytesNode):
-                if repr_val[:1] != 'b':
-                    return u'b%s' % repr_val
-            elif isinstance(default_val, ExprNodes.StringNode):
-                if repr_val[:1] in 'ub':
-                    return repr_val[1:]
-            return repr_val
-        except Exception:
-            try:
-                return self._fmt_expr_node(default_val)
-            except AttributeError, e:
-                return '<???>'
-
     def _fmt_arg(self, arg):
         if arg.type is PyrexTypes.py_object_type or arg.is_self_arg:
             doc = arg.name
         else:
             doc = arg.type.declaration_code(arg.name, for_display=1)
-        if arg.default:
-            arg_defv = self._fmt_arg_defv(arg)
-            if arg_defv:
-                doc = doc + ('=%s' % arg_defv)
+
+        if arg.annotation:
+            annotation = self._fmt_expr(arg.annotation)
+            doc = doc + (': %s' % annotation)
+            if arg.default:
+                default = self._fmt_expr(arg.default)
+                doc = doc + (' = %s' % default)
+        elif arg.default:
+            default = self._fmt_expr(arg.default)
+            doc = doc + ('=%s' % default)
         return doc
 
+    def _fmt_star_arg(self, arg):
+        arg_doc = arg.name
+        if arg.annotation:
+            annotation = self._fmt_expr(arg.annotation)
+            arg_doc = arg_doc + (': %s' % annotation)
+        return arg_doc
+
     def _fmt_arglist(self, args,
                      npargs=0, pargs=None,
                      nkargs=0, kargs=None,
@@ -90,11 +64,13 @@ class EmbedSignature(CythonTransform):
                 arg_doc = self._fmt_arg(arg)
                 arglist.append(arg_doc)
         if pargs:
-            arglist.insert(npargs, '*%s' % pargs.name)
+            arg_doc = self._fmt_star_arg(pargs)
+            arglist.insert(npargs, '*%s' % arg_doc)
         elif nkargs:
             arglist.insert(npargs, '*')
         if kargs:
-            arglist.append('**%s' % kargs.name)
+            arg_doc = self._fmt_star_arg(kargs)
+            arglist.append('**%s' % arg_doc)
         return arglist
 
     def _fmt_ret_type(self, ret):
@@ -106,6 +82,7 @@ class EmbedSignature(CythonTransform):
     def _fmt_signature(self, cls_name, func_name, args,
                        npargs=0, pargs=None,
                        nkargs=0, kargs=None,
+                       return_expr=None,
                        return_type=None, hide_self=False):
         arglist = self._fmt_arglist(args,
                                     npargs, pargs,
@@ -115,10 +92,13 @@ class EmbedSignature(CythonTransform):
         func_doc = '%s(%s)' % (func_name, arglist_doc)
         if cls_name:
             func_doc = '%s.%s' % (cls_name, func_doc)
-        if return_type:
+        ret_doc = None
+        if return_expr:
+            ret_doc = self._fmt_expr(return_expr)
+        elif return_type:
             ret_doc = self._fmt_ret_type(return_type)
-            if ret_doc:
-                func_doc = '%s -> %s' % (func_doc, ret_doc)
+        if ret_doc:
+            func_doc = '%s -> %s' % (func_doc, ret_doc)
         return func_doc
 
     def _embed_signature(self, signature, node_doc):
@@ -148,6 +128,10 @@ class EmbedSignature(CythonTransform):
         self.class_node = oldclass
         return node
 
+    def visit_LambdaNode(self, node):
+        # lambda expressions so not have signature or inner functions
+        return node
+
     def visit_DefNode(self, node):
         if not self.current_directives['embedsignature']:
             return node
@@ -169,6 +153,7 @@ class EmbedSignature(CythonTransform):
             class_name, func_name, node.args,
             npargs, node.star_arg,
             nkargs, node.starstar_arg,
+            return_expr=node.return_type_annotation,
             return_type=None, hide_self=hide_self)
         if signature:
             if is_constructor:
@@ -182,7 +167,7 @@ class EmbedSignature(CythonTransform):
                 old_doc = node.py_func.entry.doc
             else:
                 old_doc = None
-            new_doc  = self._embed_signature(signature, old_doc)
+            new_doc = self._embed_signature(signature, old_doc)
             doc_holder.doc = EncodedString(new_doc)
             if not is_constructor and getattr(node, 'py_func', None) is not None:
                 node.py_func.entry.doc = EncodedString(new_doc)

Cython/Compiler/CodeGeneration.py

-from Cython.Compiler.Visitor import VisitorTransform
-from Cython.Compiler.Nodes import StatListNode
+from __future__ import absolute_import
+
+from .Visitor import VisitorTransform
+from .Nodes import StatListNode
+
 
 class ExtractPxdCode(VisitorTransform):
     """
@@ -9,7 +12,7 @@ class ExtractPxdCode(VisitorTransform):
     The result is a tuple (StatListNode, ModuleScope), i.e.
     everything that is needed from the pxd after it is processed.
 
-    A purer approach would be to seperately compile the pxd code,
+    A purer approach would be to separately compile the pxd code,
     but the result would have to be slightly more sophisticated
     than pure strings (functions + wanted interned strings +
     wanted utility code + wanted cached objects) so for now this

Cython/Compiler/CythonScope.py

-from Symtab import ModuleScope
-from PyrexTypes import *
-from UtilityCode import CythonUtilityCode
-from Errors import error
-from Scanning import StringSourceDescriptor
-import MemoryView
+from __future__ import absolute_import
+
+from .Symtab import ModuleScope
+from .PyrexTypes import *
+from .UtilityCode import CythonUtilityCode
+from .Errors import error
+from .Scanning import StringSourceDescriptor
+from . import MemoryView
+
 
 class CythonScope(ModuleScope):
     is_cython_builtin = 1
@@ -23,6 +26,10 @@ class CythonScope(ModuleScope):
                                          cname='<error>')
             entry.in_cinclude = True
 
+    def is_cpp(self):
+        # Allow C++ utility code in C++ contexts.
+        return self.context.cpp
+
     def lookup_type(self, name):
         # This function should go away when types are all first-level objects.
         type = parse_basic_type(name)
@@ -64,7 +71,9 @@ class CythonScope(ModuleScope):
         name_path = qname.split(u'.')
         scope = self
         while len(name_path) > 1:
-            scope = scope.lookup_here(name_path[0]).as_module
+            scope = scope.lookup_here(name_path[0])
+            if scope:
+                scope = scope.as_module
             del name_path[0]
             if scope is None:
                 return None

Cython/Compiler/Future.py

@@ -10,5 +10,6 @@ print_function = _get_feature("print_function")
 absolute_import = _get_feature("absolute_import")
 nested_scopes = _get_feature("nested_scopes")  # dummy
 generators = _get_feature("generators")  # dummy
+generator_stop = _get_feature("generator_stop")
 
 del _get_feature

Cython/Debugger/Tests/cfuncs.h

+void some_c_function(void);

Cython/Includes/Deprecated/python.pxd

-# Present for backwards compatability
+# Present for backwards compatibility
 from cpython cimport *