internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: numba/numba

Issue:
pycc xxx.py --header not good under python3
In python3, pycc xx.py --header won't work.

```
shiquanwang@vm8760:~/code/test$ pycc thefile.py --header
Traceback (most recent call last):
  File "/usr/local/bin/pycc", line 9, in <module>
    load_entry_point('numba==0.8.0-5-gcbf1549', 'console_scripts', 'pycc')()
  File "/usr/local/lib/python3.3/dist-packages/numba-0.8.0_5_gcbf1549-py3.3-linux-x86_64.egg/numba/pycc/__init__.py", line 82, in main
    compiler.emit_header(args.output)
  File "/usr/local/lib/python3.3/dist-packages/numba-0.8.0_5_gcbf1549-py3.3-linux-x86_64.egg/numba/pycc/compiler.py", line 144, in emit_header
    fout.write(minitypes.get_utility())
TypeError: 'str' does not support the buffer interface
Error in sys.excepthook:
Traceback (most recent call last):
  File "/usr/lib/python3/dist-packages/apport_python_hook.py", line 64, in apport_excepthook
    from apport.fileutils import likely_packaged, get_recent_crashes
  File "/usr/lib/python3/dist-packages/apport/__init__.py", line 4, in <module>
    from apport.report import Report
  File "/usr/lib/python3/dist-packages/apport/report.py", line 30, in <module>
    import apport.fileutils
  File "/usr/lib/python3/dist-packages/apport/fileutils.py", line 23, in <module>
    from apport.packaging_impl import impl as packaging
  File "/usr/lib/python3/dist-packages/apport/packaging_impl.py", line 20, in <module>
    import apt
  File "/usr/lib/python3/dist-packages/apt/__init__.py", line 21, in <module>
    import apt_pkg
ImportError: No module named 'apt_pkg'

Original exception was:
Traceback (most recent call last):
  File "/usr/local/bin/pycc", line 9, in <module>
    load_entry_point('numba==0.8.0-5-gcbf1549', 'console_scripts', 'pycc')()
  File "/usr/local/lib/python3.3/dist-packages/numba-0.8.0_5_gcbf1549-py3.3-linux-x86_64.egg/numba/pycc/__init__.py", line 82, in main
    compiler.emit_header(args.output)
  File "/usr/local/lib/python3.3/dist-packages/numba-0.8.0_5_gcbf1549-py3.3-linux-x86_64.egg/numba/pycc/compiler.py", line 144, in emit_header
    fout.write(minitypes.get_utility())
TypeError: 'str' does not support the buffer interface
```

The problem is in `numba/pycc/compiler.py` that fout.write supports `bytes` only in python3.



Discussion:

Resolving patch:
diff --git a/numba/pycc/compiler.py b/numba/pycc/compiler.py
--- a/numba/pycc/compiler.py
+++ b/numba/pycc/compiler.py
@@ -140,7 +140,7 @@ def emit_header(self, output):
         from numba.minivect import minitypes
 
         fname, ext = os.path.splitext(output)
-        with open(fname + '.h', 'wb') as fout:
+        with open(fname + '.h', 'w') as fout:
             fout.write(minitypes.get_utility())
             fout.write("\n/* Prototypes */\n")
             for signature in self.exported_signatures.values():


Test patch:
Repository: numba/numba

Issue:
cuda.autojit recognized DeviceNDArray as pyobject
<!---
@huboard:{"order":417.0,"custom_state":""}
-->



Discussion:

Resolving patch:
diff --git a/numba/cuda/cudadrv/devicearray.py b/numba/cuda/cudadrv/devicearray.py
--- a/numba/cuda/cudadrv/devicearray.py
+++ b/numba/cuda/cudadrv/devicearray.py
@@ -10,7 +10,7 @@
 from .ndarray import (ndarray_populate_head, ArrayHeaderManager)
 from . import driver as _driver
 from . import devices
-from numba import dummyarray
+from numba import dummyarray, types, numpy_support
 
 try:
     long
@@ -111,6 +111,15 @@ def __del__(self):
         except:
             pass
 
+    @property
+    def _numba_type_(self):
+        """
+        Magic attribute expected by Numba to get the numba type that
+        represents this object.
+        """
+        dtype = numpy_support.from_dtype(self.dtype)
+        return types.Array(dtype, self.ndim, 'A')
+
     @property
     def device_ctypes_pointer(self):
         """Returns the ctypes pointer to the GPU data buffer
diff --git a/numba/dispatcher.py b/numba/dispatcher.py
--- a/numba/dispatcher.py
+++ b/numba/dispatcher.py
@@ -175,7 +175,7 @@ def typeof_pyval(cls, val):
 
         # Other object
         else:
-            return types.pyobject
+            return getattr(val, "_numba_type_", types.pyobject)
 
 
 INT_TYPES = (int,)


Test patch:
diff --git a/numba/cuda/tests/cudapy/test_cuda_autojit.py b/numba/cuda/tests/cudapy/test_cuda_autojit.py
new file mode 100644
--- /dev/null
+++ b/numba/cuda/tests/cudapy/test_cuda_autojit.py
@@ -0,0 +1,28 @@
+from __future__ import print_function
+from numba import unittest_support as unittest
+from numba import cuda
+import numpy as np
+
+
+class TestCudaAutojit(unittest.TestCase):
+    def test_device_array(self):
+        @cuda.autojit
+        def foo(x, y):
+            i = cuda.grid(1)
+            y[i] = x[i]
+
+        x = np.arange(10)
+        y = np.empty_like(x)
+
+        dx = cuda.to_device(x)
+        dy = cuda.to_device(y)
+
+        foo[10, 1](dx, dy)
+
+        dy.copy_to_host(y)
+
+        self.assertTrue(np.all(x == y))
+
+
+if __name__ == '__main__':
+    unittest.main()
Repository: numba/numba

Issue:
Support calling closure functions in object mode
A followup to #518.  Functions defined in a closure cannot be called from object mode, but can in nopython mode.



Discussion:

Resolving patch:
diff --git a/numba/lowering.py b/numba/lowering.py
--- a/numba/lowering.py
+++ b/numba/lowering.py
@@ -916,16 +916,15 @@ def lower_const(self, const):
             return self.get_builtin_obj("Ellipsis")
         elif const is None:
             return self.pyapi.make_none()
-        elif isinstance(const, dispatcher.LiftedLoop):
-            index = len(self.env.lifted_loops)
-            self.env.lifted_loops.append(const)
-            ret = self.get_lifted_loop(index)
+        else:
+            # Constants which can't be reconstructed are frozen inside
+            # the environment (e.g. callables, lifted loops).
+            index = len(self.env.consts)
+            self.env.consts.append(const)
+            ret = self.get_env_const(index)
             self.check_error(ret)
             return ret
 
-        else:
-            raise NotImplementedError(type(const))
-
     def lower_global(self, name, value):
         """
         1) Check global scope dictionary.
@@ -974,11 +973,11 @@ def get_builtin_obj(self, name):
         mod = self.pyapi.dict_getitem_string(moddict, "__builtins__")
         return self.builtin_lookup(mod, name)
 
-    def get_lifted_loop(self, index):
+    def get_env_const(self, index):
         """
-        Lookup lifted loop number *index* inside the environment body.
+        Look up constant number *index* inside the environment body.
         """
-        return self.pyapi.list_getitem(self.env_body.lifted_loops, index)
+        return self.pyapi.list_getitem(self.env_body.consts, index)
 
     def builtin_lookup(self, mod, name):
         """
diff --git a/numba/targets/cpu.py b/numba/targets/cpu.py
--- a/numba/targets/cpu.py
+++ b/numba/targets/cpu.py
@@ -33,7 +33,7 @@ class ClosureBody(cgutils.Structure):
 class EnvBody(cgutils.Structure):
     _fields = [
         ('globals', types.pyobject),
-        ('lifted_loops', types.pyobject),
+        ('consts', types.pyobject),
     ]
 
 


Test patch:
diff --git a/numba/tests/test_closure.py b/numba/tests/test_closure.py
--- a/numba/tests/test_closure.py
+++ b/numba/tests/test_closure.py
@@ -77,11 +77,7 @@ def do_math(x):
 
         self.assertEqual(c_do_math(1), 50)
 
-    @unittest.expectedFailure
     def test_jit_inner_function(self):
-        # See comment in PyLower.lower_assign for why this doesn't work
-        # (the frozen cell variable is a Dispatcher instance and that
-        #  is not supported as a constant).
         self.run_jit_inner_function(forceobj=True)
 
     def test_jit_inner_function_npm(self):
Repository: numba/numba

Issue:
Weird behaviour of globals()
```
>>> myglob = 5
>>> @jit
... def f():
...     return globals()
... 
>>> f()['myglob']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'myglob'
>>> f()
{'f': CPUOverloaded(<function f at 0x7fed955d21b8>), '__builtins__': <module '__builtin__' (built-in)>, '__package__': None, 'jit': <function jit at 0x7fed967329b0>, '__name__': '__main__', '__doc__': None, 'myglob': 5}
>>> 
>>> f()['myglob']
5
```



Discussion:

Resolving patch:
diff --git a/numba/dispatcher.py b/numba/dispatcher.py
--- a/numba/dispatcher.py
+++ b/numba/dispatcher.py
@@ -138,11 +138,14 @@ def jit(self, sig, **kws):
         """
         return self.compile(sig, **kws)
 
-    def _compile_and_call(self, *args, **kws):
+    def _compile_for_args(self, *args, **kws):
+        """
+        For internal use.  Compile a specialized version of the function
+        for the given *args* and *kws*, and return the resulting callable.
+        """
         assert not kws
         sig = tuple([self.typeof_pyval(a) for a in args])
-        self.jit(sig)
-        return self(*args, **kws)
+        return self.jit(sig)
 
     def inspect_types(self):
         for ver, res in utils.dict_iteritems(self.overloads):


Test patch:
diff --git a/numba/tests/test_builtins.py b/numba/tests/test_builtins.py
--- a/numba/tests/test_builtins.py
+++ b/numba/tests/test_builtins.py
@@ -1,10 +1,12 @@
 from __future__ import print_function
+
+import itertools
+import functools
+
 import numba.unittest_support as unittest
 from numba.compiler import compile_isolated, Flags
-from numba import typeinfer, lowering, types, utils
+from numba import jit, typeinfer, lowering, types, utils
 from .support import TestCase
-import itertools
-import functools
 
 enable_pyobj_flags = Flags()
 enable_pyobj_flags.set("enable_pyobject")
@@ -71,6 +73,9 @@ def float_usecase(x):
 def format_usecase(x, y):
     return x.format(y)
 
+def globals_usecase():
+    return globals()
+
 def hex_usecase(x):
     return hex(x)
 
@@ -352,6 +357,29 @@ def test_format_npm(self):
         with self.assertTypingError():
             self.test_format(flags=no_pyobj_flags)
 
+    def test_globals(self, flags=enable_pyobj_flags):
+        pyfunc = globals_usecase
+        cr = compile_isolated(pyfunc, (), flags=flags)
+        cfunc = cr.entry_point
+        g = cfunc()
+        self.assertIs(g, globals())
+
+    def test_globals_npm(self):
+        with self.assertTypingError():
+            self.test_globals(flags=no_pyobj_flags)
+
+    def test_globals_jit(self, **jit_flags):
+        # Issue #416: weird behaviour of globals() in combination with
+        # the @jit decorator.
+        pyfunc = globals_usecase
+        jitted = jit(**jit_flags)(pyfunc)
+        self.assertIs(jitted(), globals())
+        self.assertIs(jitted(), globals())
+
+    def test_globals_jit_npm(self):
+        with self.assertTypingError():
+            self.test_globals_jit(nopython=True)
+
     def test_hex(self, flags=enable_pyobj_flags):
         pyfunc = hex_usecase
Repository: numba/numba

Issue:
Dispatcher finalizer can crash at shutdown
The Dispatcher finalizer can crash when called at shutdown. See https://travis-ci.org/numba/numba/jobs/31636114
(this is in a pull request, but this could perhaps also happen with the master branch)



Discussion:

Resolving patch:
diff --git a/numba/dispatcher.py b/numba/dispatcher.py
--- a/numba/dispatcher.py
+++ b/numba/dispatcher.py
@@ -51,7 +51,13 @@ def _make_finalizer(self):
         """
         overloads = self.overloads
         targetctx = self.targetctx
+        # Early-bind utils.shutting_down() into the closure variables.
+        from numba.utils import shutting_down
         def finalizer():
+            # The finalizer may crash at shutdown, skip it (resources
+            # will be cleared by the process exiting, anyway).
+            if shutting_down():
+                return
             # This function must *not* hold any reference to self:
             # we take care to bind the necessary objects in the closure.
             for func in overloads.values():
diff --git a/numba/utils.py b/numba/utils.py
--- a/numba/utils.py
+++ b/numba/utils.py
@@ -1,5 +1,6 @@
 from __future__ import print_function, division, absolute_import
 
+import atexit
 import collections
 import functools
 import io
@@ -21,6 +22,26 @@
     INT_TYPES += (long,)
 
 
+_shutting_down = False
+
+def _at_shutdown():
+    global _shutting_down
+    _shutting_down = True
+
+atexit.register(_at_shutdown)
+
+def shutting_down():
+    """
+    Whether the interpreter is currently shutting down.
+    For use in finalizers, __del__ methods, and similar; it is advised
+    to early bind this function rather than look it up when calling it,
+    since at shutdown module globals may be cleared.
+    """
+    # At shutdown, the attribute may have been cleared or set to None.
+    v = globals().get('_shutting_down')
+    return v is True or v is None
+
+
 class ConfigOptions(object):
     OPTIONS = ()
 


Test patch:
Repository: numba/numba

Issue:
Occasional error at shutdown
The following (harmless) error can sometimes get printed at shutdown:

```
Exception ignored in: <function _OverloadedBase._make_finalizer.<locals>.finalizer at 0x7f72a9fef9d8>
Traceback (most recent call last):
  File "/home/antoine/numba/numba/dispatcher.py", line 59, in finalizer
  File "/home/antoine/numba/numba/utils.py", line 41, in shutting_down
NameError: name 'globals' is not defined
```



Discussion:
(my fault)

Ah, I did see this at one point while killing the unittest runner.


Resolving patch:
diff --git a/numba/utils.py b/numba/utils.py
--- a/numba/utils.py
+++ b/numba/utils.py
@@ -30,7 +30,7 @@ def _at_shutdown():
 
 atexit.register(_at_shutdown)
 
-def shutting_down():
+def shutting_down(globals=globals):
     """
     Whether the interpreter is currently shutting down.
     For use in finalizers, __del__ methods, and similar; it is advised


Test patch:
Repository: numba/numba

Issue:
TypeError with unhashable globals in object mode
When a function is compiled in object mode and accesses an unhashable global value, the following exception gets raised:

```
  File "/home/antoine/numba/numba/objmode.py", line 349, in lower_global
    if value in _unsupported_builtins:
TypeError: unhashable type: 'numpy.ndarray'
```



Discussion:

Resolving patch:
diff --git a/numba/objmode.py b/numba/objmode.py
--- a/numba/objmode.py
+++ b/numba/objmode.py
@@ -345,9 +345,13 @@ def lower_global(self, name, value):
         obj = self.pyapi.dict_getitem_string(moddict, name)
         self.incref(obj)  # obj is borrowed
 
-        if value in _unsupported_builtins:
-            raise ForbiddenConstruct("builtins %s() is not supported"
-                                     % name, loc=self.loc)
+        try:
+            if value in _unsupported_builtins:
+                raise ForbiddenConstruct("builtins %s() is not supported"
+                                         % name, loc=self.loc)
+        except TypeError:
+            # `value` is unhashable, ignore
+            pass
 
         if hasattr(builtins, name):
             obj_is_null = self.is_null(obj)


Test patch:
diff --git a/numba/tests/test_globals.py b/numba/tests/test_globals.py
--- a/numba/tests/test_globals.py
+++ b/numba/tests/test_globals.py
@@ -13,11 +13,20 @@ def global_ndarray_func(x):
 
 
 class TestGlobals(unittest.TestCase):
-    def test_global_ndarray(self):
+
+    def check_global_ndarray(self, **jitargs):
         # (see github issue #448)
-        ctestfunc = jit('i4(i4)')(global_ndarray_func)
+        ctestfunc = jit(**jitargs)(global_ndarray_func)
         self.assertEqual(ctestfunc(1), 11)
 
+    def test_global_ndarray(self):
+        # This also checks we can access an unhashable global value
+        # (see issue #697)
+        self.check_global_ndarray(forceobj=True)
+
+    def test_global_ndarray_npm(self):
+        self.check_global_ndarray(nopython=True)
+
 
 if __name__ == '__main__':
     unittest.main()
Repository: numba/numba

Issue:
np.array of objects unsupported
```
>>> arr = np.array([object() for i in range(10)])
>>> @jit
... def f(arr):
...     return arr[0]
...
>>> f(arr)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "numba\dispatcher.py", line 152, in typeof_pyval
    dtype = numpy_support.from_dtype(val.dtype)
  File "numba\numpy_support.py", line 61, in from_dtype
    raise NotImplementedError(dtype)
NotImplementedError: object
```



Discussion:
I can reproduce the same error on Win64.


Resolving patch:
diff --git a/numba/typing/context.py b/numba/typing/context.py
--- a/numba/typing/context.py
+++ b/numba/typing/context.py
@@ -131,6 +131,8 @@ def resolve_data_type(self, val):
         Return the numba type of a Python value representing data
         (e.g. a number or an array, but not more sophisticated types
          such as functions, etc.)
+
+        This function can return None to if it cannot decide.
         """
         if val is True or val is False:
             return types.boolean
@@ -167,7 +169,11 @@ def resolve_data_type(self, val):
 
         if numpy_support.is_array(val):
             ary = val
-            dtype = numpy_support.from_dtype(ary.dtype)
+            try:
+                dtype = numpy_support.from_dtype(ary.dtype)
+            except NotImplementedError:
+                return
+
             if ary.flags.c_contiguous:
                 layout = 'C'
             elif ary.flags.f_contiguous:
@@ -176,7 +182,7 @@ def resolve_data_type(self, val):
                 layout = 'A'
             return types.Array(dtype, ary.ndim, layout)
 
-        return None
+        return
 
     def resolve_value_type(self, val):
         """


Test patch:
diff --git a/numba/tests/test_object_mode.py b/numba/tests/test_object_mode.py
--- a/numba/tests/test_object_mode.py
+++ b/numba/tests/test_object_mode.py
@@ -3,9 +3,10 @@
 
 """
 from __future__ import print_function
+import numpy
 import numba.unittest_support as unittest
 from numba.compiler import compile_isolated, Flags
-from numba import utils
+from numba import utils, jit
 
 def complex_constant(n):
     tmp = n + 4
@@ -26,6 +27,10 @@ def loop_nest_3(x, y):
     return n
 
 
+def array_of_object(x):
+    return x
+
+
 class TestObjectMode(unittest.TestCase):
     def test_complex_constant(self):
         pyfunc = complex_constant
@@ -52,5 +57,10 @@ def bm_cfunc():
         print(utils.benchmark(bm_pyfunc))
         print(utils.benchmark(bm_cfunc))
 
+    def test_array_of_object(self):
+        cfunc = jit(array_of_object)
+        objarr = numpy.array([object()] * 10)
+        self.assertIs(cfunc(objarr), objarr)
+
 if __name__ == '__main__':
     unittest.main()
Repository: numba/numba

Issue:
BUG JIT optimizer removes index-variables after the loop
It seemes that the optimizer removes all variables that look like index variables after the loop is completed (or before the next loop is started).

For example, the following code:

```
from numba import jit
import numpy as np

@jit('f8[:](f8[:])')
def test(x):
    res = np.zeros(len(x))
    ind = 0
    for ii in range(len(x)):
        ind += 1
        res[ind] = x[ind]
        if x[ind] >= 10:
            break

    # ind    #### Uncomment this line to get correct result
    for ii in range(ind+1, len(x)):
        res[ii] = 0
    return res

x = np.array([1.,4,2,-3,5,2,10,5,2,6])
print test(x)
```

returns `[ 0.  0.  0.  0.  0.  0.  0.  0.  0.  0.]` as if before the second loop the variable had value: `ind=0`

But when the line `# ind` is not commented (i.e. when variable `ind` is read before the second loop) the result is correct: `[  0.   4.   2.  -3.   5.   2.  10.   0.   0.   0.]`

In first case the loop is jitted and in second is rejected. So it seemed that the access to the variable in `range(ind+1, len(x))` is not considered by the compiler as a reason to reject jitting.

Just in case:
Python 2.7.6
LLVM: 3.3
llvmpy (0.12.7)
numba (0.14.0)



Discussion:

Resolving patch:
diff --git a/numba/looplifting.py b/numba/looplifting.py
--- a/numba/looplifting.py
+++ b/numba/looplifting.py
@@ -20,6 +20,13 @@ def lift_loop(bytecode, dispatcher_factory):
     outer_rds, outer_wrs = find_varnames_uses(bytecode, outer)
     outer_wrs |= set(bytecode.argspec.args)
 
+    # Find in-loop references to variables
+    for loop in loops:
+        args, rets = discover_args_and_returns(bytecode, loop, outer_rds,
+                                               outer_wrs)
+        outer_rds |= args
+        outer_wrs |= rets
+
     dispatchers = []
     outerlabels = set(bytecode.labels)
     outernames = list(bytecode.co_names)


Test patch:
diff --git a/numba/tests/test_looplifting.py b/numba/tests/test_looplifting.py
--- a/numba/tests/test_looplifting.py
+++ b/numba/tests/test_looplifting.py
@@ -142,6 +142,28 @@ def forloop_with_if(u, a):
             forloop_with_if.py_func(u, np_a)
             self.assertTrue(np.all(nb_a == np_a))
 
+    def test_issue_812(self):
+        from numba import jit
+
+        @jit('f8[:](f8[:])', forceobj=True)
+        def test(x):
+            res = np.zeros(len(x))
+            ind = 0
+            for ii in range(len(x)):
+                ind += 1
+                res[ind] = x[ind]
+                if x[ind] >= 10:
+                    break
+
+            # Invalid loopjitting will miss the usage of `ind` in the
+            # following loop.
+            for ii in range(ind + 1, len(x)):
+                res[ii] = 0
+            return res
+
+        x = np.array([1., 4, 2, -3, 5, 2, 10, 5, 2, 6])
+        np.testing.assert_equal(test.py_func(x), test(x))
+
 
 if __name__ == '__main__':
     unittest.main()
Repository: numba/numba

Issue:
PR #856 introduced regression in macro expansion of more than one block
PR #856 caused macro expansion to effectively cease after performing macro expansion in one block, due to the logic in `numba/macro.py`:

``` python
for blk in blocks.values():
    module_getattr_folding(constants, blk)
    expanded = expanded or expand_macros_in_block(constants, blk)
```



Discussion:

Resolving patch:
diff --git a/numba/macro.py b/numba/macro.py
--- a/numba/macro.py
+++ b/numba/macro.py
@@ -29,7 +29,8 @@ def expand_macros(blocks):
     expanded = False
     for blk in blocks.values():
         module_getattr_folding(constants, blk)
-        expanded = expanded or expand_macros_in_block(constants, blk)
+        block_expanded = expand_macros_in_block(constants, blk)
+        expanded = expanded or block_expanded
     return expanded
 
 def module_getattr_folding(constants, block):


Test patch:
diff --git a/numba/cuda/tests/cudapy/test_lang.py b/numba/cuda/tests/cudapy/test_lang.py
--- a/numba/cuda/tests/cudapy/test_lang.py
+++ b/numba/cuda/tests/cudapy/test_lang.py
@@ -5,7 +5,7 @@
 from __future__ import print_function, absolute_import, division
 
 import numpy as np
-from numba import cuda
+from numba import cuda, float64
 from numba.cuda.testing import unittest
 
 
@@ -39,6 +39,24 @@ def foo(a):
         c = np.array(t2)
         self.assertTrue(np.all(a == (b + c).sum()))
 
+    def test_issue_872(self):
+        '''
+        Ensure that macro expansion works for more than one block (issue #872)
+        '''
+
+        @cuda.jit("void(float64[:,:])")
+        def macros_in_multiple_blocks(ary):
+            for i in range(2):
+                tx = cuda.threadIdx.x
+            for j in range(3):
+                ty = cuda.threadIdx.y
+            sm = cuda.shared.array((2, 3), float64)
+            sm[tx, ty] = 1.0
+            ary[tx, ty] = sm[tx, ty]
+
+        a = np.zeros((2, 3))
+        macros_in_multiple_blocks[1, (2, 3)](a)
+
 
 if __name__ == '__main__':
     unittest.main()
Repository: numba/numba

Issue:
Update README
Two issues with our README file:
- it is not up-to-date (e.g. it mentions Cython, which we don't use anymore)
- it uses Markdown rather than reST, and therefore is badly formatted when used for the PyPI long description: https://pypi.python.org/pypi/numba



Discussion:

Resolving patch:
diff --git a/setup.py b/setup.py
--- a/setup.py
+++ b/setup.py
@@ -21,7 +21,7 @@
 cmdclass = versioneer.get_cmdclass()
 
 setup_args = {
-    'long_description': open('README.md').read(),
+    'long_description': open('README.rst').read(),
 }
 
 GCCFLAGS = ["-std=c89", "-Wdeclaration-after-statement", "-Werror"]


Test patch: